diff --git a/docs/compilers/CSharp/Compiler Breaking Changes - post DotNet 5.md b/docs/compilers/CSharp/Compiler Breaking Changes - post DotNet 5.md
index 300e9aeae7ede..f8d3d64760a41 100644
--- a/docs/compilers/CSharp/Compiler Breaking Changes - post DotNet 5.md	
+++ b/docs/compilers/CSharp/Compiler Breaking Changes - post DotNet 5.md	
@@ -48,9 +48,9 @@ record Derived(int I) // The positional member 'Base.I' found corresponding to t
 }
 ```
 
-4. In C# 10, method groups are implicitly convertible to `System.Delegate`, and lambda expressions are implicitly convertible to `System.Delegate` and `System.Linq.Expressions.Expression`.
+4. In C# 10, lambda expressions and method groups are implicitly convertible to `System.MulticastDelegate`, or any base classes or interfaces of `System.MulticastDelegate` including `object`, and lambda expressions are implicitly convertible to `System.Linq.Expressions.Expression`.
 
-    This is a breaking change to overload resolution if there exists an overload with a `System.Delegate` or `System.Linq.Expressions.Expression` parameter that is applicable and the closest applicable overload with a strongly-typed delegate parameter is in an enclosing namespace.
+    This is a breaking change to overload resolution if there exists an applicable overload with a parameter of type `System.MulticastDelegate`, or a parameter of a type in the base types or interfaces of `System.MulticastDelegate`, or a parameter of type `System.Linq.Expressions.Expression`, and the closest applicable extension method overload with a strongly-typed delegate parameter is in an enclosing namespace.
 
     ```C#
     class C
diff --git a/docs/contributing/Compiler Test Plan.md b/docs/contributing/Compiler Test Plan.md
index 2c36d71259123..acb9e77852221 100644
--- a/docs/contributing/Compiler Test Plan.md	
+++ b/docs/contributing/Compiler Test Plan.md	
@@ -319,6 +319,7 @@ __makeref( x )
 - Tuple
 - Default literal
 - Implicit object creation (target-typed new)
+- Function type (in type inference comparing function types of lambdas or method groups)
 
 ## Types 
 
diff --git a/eng/Version.Details.xml b/eng/Version.Details.xml
index ea444bb8a20d4..275bf913b5bdb 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.21426.1">
+    <Dependency Name="Microsoft.SourceBuild.Intermediate.source-build" Version="0.1.0-alpha.1.21428.1">
       <Uri>https://github.com/dotnet/source-build</Uri>
-      <Sha>c96e044a8031b92e840142eab84b85a45fa9c4c0</Sha>
+      <Sha>32d7d9397b3dcf1d0633cbfae18f81812c90d562</Sha>
       <SourceBuild RepoName="source-build" ManagedOnly="true" />
     </Dependency>
   </ProductDependencies>
diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Conversions.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Conversions.cs
index 33246b9d3e6d0..36c8293f199d5 100644
--- a/src/Compilers/CSharp/Portable/Binder/Binder_Conversions.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Binder_Conversions.cs
@@ -97,6 +97,11 @@ protected BoundExpression CreateConversion(
                 return CreateAnonymousFunctionConversion(syntax, source, conversion, isCast: isCast, conversionGroupOpt, destination, diagnostics);
             }
 
+            if (conversion.Kind == ConversionKind.FunctionType)
+            {
+                return CreateFunctionTypeConversion(syntax, source, conversion, isCast: isCast, conversionGroupOpt, destination, diagnostics);
+            }
+
             if (conversion.IsStackAlloc)
             {
                 return CreateStackAllocConversion(syntax, source, conversion, isCast, conversionGroupOpt, destination, diagnostics);
@@ -546,69 +551,68 @@ private BoundExpression CreateUserDefinedConversion(
             return finalConversion;
         }
 
-        private BoundExpression CreateAnonymousFunctionConversion(SyntaxNode syntax, BoundExpression source, Conversion conversion, bool isCast, ConversionGroup? conversionGroup, TypeSymbol destination, BindingDiagnosticBag diagnostics)
+        private BoundExpression CreateFunctionTypeConversion(SyntaxNode syntax, BoundExpression source, Conversion conversion, bool isCast, ConversionGroup? conversionGroup, TypeSymbol destination, BindingDiagnosticBag diagnostics)
         {
-            // We have a successful anonymous function conversion; rather than producing a node
-            // which is a conversion on top of an unbound lambda, replace it with the bound
-            // lambda.
+            Debug.Assert(conversion.Kind == ConversionKind.FunctionType);
+            Debug.Assert(source.Kind is BoundKind.MethodGroup or BoundKind.UnboundLambda);
+            Debug.Assert(syntax.IsFeatureEnabled(MessageID.IDS_FeatureInferredDelegateType));
 
-            // UNDONE: Figure out what to do about the error case, where a lambda
-            // UNDONE: is converted to a delegate that does not match. What to surface then?
+            CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = GetNewCompoundUseSiteInfo(diagnostics);
+            var delegateType = source.GetInferredDelegateType(ref useSiteInfo);
+            Debug.Assert(delegateType is { });
 
-            var unboundLambda = (UnboundLambda)source;
-            if ((destination.SpecialType == SpecialType.System_Delegate || destination.IsNonGenericExpressionType()) &&
-                syntax.IsFeatureEnabled(MessageID.IDS_FeatureInferredDelegateType))
+            if (source.Kind == BoundKind.UnboundLambda &&
+                destination.IsNonGenericExpressionType())
             {
-                CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = GetNewCompoundUseSiteInfo(diagnostics);
-                var delegateType = unboundLambda.InferDelegateType(ref useSiteInfo);
-                BoundLambda boundLambda;
-                if (delegateType is { })
-                {
-                    bool isExpressionTree = destination.IsNonGenericExpressionType();
-                    if (isExpressionTree)
-                    {
-                        delegateType = Compilation.GetWellKnownType(WellKnownType.System_Linq_Expressions_Expression_T).Construct(delegateType);
-                        delegateType.AddUseSiteInfo(ref useSiteInfo);
-                    }
-                    boundLambda = unboundLambda.Bind(delegateType, isExpressionTree);
-                }
-                else
-                {
-                    diagnostics.Add(ErrorCode.ERR_CannotInferDelegateType, syntax.GetLocation());
-                    delegateType = CreateErrorType();
-                    boundLambda = unboundLambda.BindForErrorRecovery();
-                }
-                diagnostics.AddRange(boundLambda.Diagnostics);
-                var expr = createAnonymousFunctionConversion(syntax, source, boundLambda, conversion, isCast, conversionGroup, delegateType);
-                conversion = Conversions.ClassifyConversionFromExpression(expr, destination, ref useSiteInfo);
-                diagnostics.Add(syntax, useSiteInfo);
-                return CreateConversion(syntax, expr, conversion, isCast, conversionGroup, destination, diagnostics);
+                delegateType = Compilation.GetWellKnownType(WellKnownType.System_Linq_Expressions_Expression_T).Construct(delegateType);
+                delegateType.AddUseSiteInfo(ref useSiteInfo);
+            }
+
+            conversion = Conversions.ClassifyConversionFromExpression(source, delegateType, ref useSiteInfo);
+            BoundExpression expr;
+            if (!conversion.Exists)
+            {
+                GenerateImplicitConversionError(diagnostics, syntax, conversion, source, delegateType);
+                expr = new BoundConversion(syntax, source, conversion, @checked: false, explicitCastInCode: isCast, conversionGroup, constantValueOpt: ConstantValue.NotAvailable, type: delegateType, hasErrors: true) { WasCompilerGenerated = source.WasCompilerGenerated };
             }
             else
             {
-#if DEBUG
-                // Test inferring a delegate type for all callers.
-                var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded;
-                _ = unboundLambda.InferDelegateType(ref discardedUseSiteInfo);
-#endif
-                var boundLambda = unboundLambda.Bind((NamedTypeSymbol)destination, isExpressionTree: destination.IsGenericOrNonGenericExpressionType(out _));
-                diagnostics.AddRange(boundLambda.Diagnostics);
-                return createAnonymousFunctionConversion(syntax, source, boundLambda, conversion, isCast, conversionGroup, destination);
+                expr = CreateConversion(syntax, source, conversion, isCast, conversionGroup, delegateType, diagnostics);
             }
 
-            static BoundConversion createAnonymousFunctionConversion(SyntaxNode syntax, BoundExpression source, BoundLambda boundLambda, Conversion conversion, bool isCast, ConversionGroup? conversionGroup, TypeSymbol destination)
+            conversion = Conversions.ClassifyConversionFromExpression(expr, destination, ref useSiteInfo);
+            if (!conversion.Exists)
             {
-                return new BoundConversion(
-                    syntax,
-                    boundLambda,
-                    conversion,
-                    @checked: false,
-                    explicitCastInCode: isCast,
-                    conversionGroup,
-                    constantValueOpt: ConstantValue.NotAvailable,
-                    type: destination)
-                { WasCompilerGenerated = source.WasCompilerGenerated };
+                GenerateImplicitConversionError(diagnostics, syntax, conversion, source, destination);
             }
+
+            diagnostics.Add(syntax, useSiteInfo);
+            return CreateConversion(syntax, expr, conversion, isCast, conversionGroup, destination, diagnostics);
+        }
+
+        private BoundExpression CreateAnonymousFunctionConversion(SyntaxNode syntax, BoundExpression source, Conversion conversion, bool isCast, ConversionGroup? conversionGroup, TypeSymbol destination, BindingDiagnosticBag diagnostics)
+        {
+            // We have a successful anonymous function conversion; rather than producing a node
+            // which is a conversion on top of an unbound lambda, replace it with the bound
+            // lambda.
+
+            // UNDONE: Figure out what to do about the error case, where a lambda
+            // UNDONE: is converted to a delegate that does not match. What to surface then?
+
+            var unboundLambda = (UnboundLambda)source;
+
+            var boundLambda = unboundLambda.Bind((NamedTypeSymbol)destination, isExpressionTree: destination.IsGenericOrNonGenericExpressionType(out _));
+            diagnostics.AddRange(boundLambda.Diagnostics);
+            return new BoundConversion(
+                syntax,
+                boundLambda,
+                conversion,
+                @checked: false,
+                explicitCastInCode: isCast,
+                conversionGroup,
+                constantValueOpt: ConstantValue.NotAvailable,
+                type: destination)
+            { WasCompilerGenerated = source.WasCompilerGenerated };
         }
 
         private BoundExpression CreateMethodGroupConversion(SyntaxNode syntax, BoundExpression source, Conversion conversion, bool isCast, ConversionGroup? conversionGroup, TypeSymbol destination, BindingDiagnosticBag diagnostics)
@@ -627,29 +631,7 @@ private BoundExpression CreateMethodGroupConversion(SyntaxNode syntax, BoundExpr
                 hasErrors = true;
             }
 
-            if (destination.SpecialType == SpecialType.System_Delegate &&
-                syntax.IsFeatureEnabled(MessageID.IDS_FeatureInferredDelegateType))
-            {
-                // https://github.com/dotnet/roslyn/issues/52869: Avoid calculating the delegate type multiple times during conversion.
-                CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = GetNewCompoundUseSiteInfo(diagnostics);
-                var delegateType = GetMethodGroupDelegateType(group, ref useSiteInfo);
-                var expr = createMethodGroupConversion(syntax, group, conversion, isCast, conversionGroup, delegateType!, hasErrors);
-                conversion = Conversions.ClassifyConversionFromExpression(expr, destination, ref useSiteInfo);
-                diagnostics.Add(syntax, useSiteInfo);
-                return CreateConversion(syntax, expr, conversion, isCast, conversionGroup, destination, diagnostics);
-            }
-
-#if DEBUG
-            // Test inferring a delegate type for all callers.
-            var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded;
-            _ = GetMethodGroupDelegateType(group, ref discardedUseSiteInfo);
-#endif
-            return createMethodGroupConversion(syntax, group, conversion, isCast, conversionGroup, destination, hasErrors);
-
-            static BoundConversion createMethodGroupConversion(SyntaxNode syntax, BoundMethodGroup group, Conversion conversion, bool isCast, ConversionGroup? conversionGroup, TypeSymbol destination, bool hasErrors)
-            {
-                return new BoundConversion(syntax, group, conversion, @checked: false, explicitCastInCode: isCast, conversionGroup, constantValueOpt: ConstantValue.NotAvailable, type: destination, hasErrors: hasErrors) { WasCompilerGenerated = group.WasCompilerGenerated };
-            }
+            return new BoundConversion(syntax, group, conversion, @checked: false, explicitCastInCode: isCast, conversionGroup, constantValueOpt: ConstantValue.NotAvailable, type: destination, hasErrors: hasErrors) { WasCompilerGenerated = group.WasCompilerGenerated };
         }
 
         private BoundExpression CreateStackAllocConversion(SyntaxNode syntax, BoundExpression source, Conversion conversion, bool isCast, ConversionGroup? conversionGroup, TypeSymbol destination, BindingDiagnosticBag diagnostics)
@@ -814,6 +796,7 @@ private BoundMethodGroup FixMethodGroupWithTypeOrValue(BoundMethodGroup group, C
                 group.LookupSymbolOpt,
                 group.LookupError,
                 group.Flags,
+                group.FunctionType,
                 receiverOpt, //only change
                 group.ResultKind);
         }
@@ -1226,13 +1209,13 @@ private bool MethodGroupConversionHasErrors(
             TypeSymbol delegateOrFuncPtrType,
             BindingDiagnosticBag diagnostics)
         {
-            Debug.Assert(delegateOrFuncPtrType.SpecialType == SpecialType.System_Delegate || delegateOrFuncPtrType.TypeKind == TypeKind.Delegate || delegateOrFuncPtrType.TypeKind == TypeKind.FunctionPointer);
-
+            var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded;
+            Debug.Assert(Conversions.IsAssignableFromMulticastDelegate(delegateOrFuncPtrType, ref discardedUseSiteInfo) || delegateOrFuncPtrType.TypeKind == TypeKind.Delegate || delegateOrFuncPtrType.TypeKind == TypeKind.FunctionPointer);
             Debug.Assert(conversion.Method is object);
             MethodSymbol selectedMethod = conversion.Method;
 
             var location = syntax.Location;
-            if (delegateOrFuncPtrType.SpecialType != SpecialType.System_Delegate)
+            if (!Conversions.IsAssignableFromMulticastDelegate(delegateOrFuncPtrType, ref discardedUseSiteInfo))
             {
                 if (!MethodIsCompatibleWithDelegateOrFunctionPointer(receiverOpt, isExtensionMethod, selectedMethod, delegateOrFuncPtrType, location, diagnostics) ||
                     MemberGroupFinalValidation(receiverOpt, selectedMethod, syntax, diagnostics, isExtensionMethod))
diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs
index 6f06eed214a44..8292ab627274d 100644
--- a/src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs
@@ -395,21 +395,22 @@ internal BoundExpression BindToNaturalType(BoundExpression expression, BindingDi
 
         private BoundExpression BindToInferredDelegateType(BoundExpression expr, BindingDiagnosticBag diagnostics)
         {
+            Debug.Assert(expr.Kind is BoundKind.UnboundLambda or BoundKind.MethodGroup);
+
             var syntax = expr.Syntax;
-            CheckFeatureAvailability(syntax, MessageID.IDS_FeatureInferredDelegateType, diagnostics);
             CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = GetNewCompoundUseSiteInfo(diagnostics);
-            var delegateType = expr switch
-            {
-                UnboundLambda unboundLambda => unboundLambda.InferDelegateType(ref useSiteInfo),
-                BoundMethodGroup methodGroup => GetMethodGroupDelegateType(methodGroup, ref useSiteInfo),
-                _ => throw ExceptionUtilities.UnexpectedValue(expr),
-            };
+            var delegateType = expr.GetInferredDelegateType(ref useSiteInfo);
             diagnostics.Add(syntax, useSiteInfo);
+
             if (delegateType is null)
             {
-                diagnostics.Add(ErrorCode.ERR_CannotInferDelegateType, syntax.GetLocation());
+                if (CheckFeatureAvailability(syntax, MessageID.IDS_FeatureInferredDelegateType, diagnostics))
+                {
+                    diagnostics.Add(ErrorCode.ERR_CannotInferDelegateType, syntax.GetLocation());
+                }
                 delegateType = CreateErrorType();
             }
+
             return GenerateConversionForAssignment(delegateType, expr, diagnostics);
         }
 
@@ -2650,29 +2651,13 @@ private static string GetName(ExpressionSyntax syntax)
 
         // Given a list of arguments, create arrays of the bound arguments and the names of those
         // arguments.
-        private void BindArgumentsAndNames(ArgumentListSyntax argumentListOpt, BindingDiagnosticBag diagnostics, AnalyzedArguments result, bool allowArglist = false, bool isDelegateCreation = false)
+        private void BindArgumentsAndNames(BaseArgumentListSyntax argumentListOpt, BindingDiagnosticBag diagnostics, AnalyzedArguments result, bool allowArglist = false, bool isDelegateCreation = false)
         {
-            if (argumentListOpt != null)
+            if (argumentListOpt is null)
             {
-                BindArgumentsAndNames(argumentListOpt.Arguments, diagnostics, result, allowArglist, isDelegateCreation: isDelegateCreation);
-            }
-        }
-
-        private void BindArgumentsAndNames(BracketedArgumentListSyntax argumentListOpt, BindingDiagnosticBag diagnostics, AnalyzedArguments result)
-        {
-            if (argumentListOpt != null)
-            {
-                BindArgumentsAndNames(argumentListOpt.Arguments, diagnostics, result, allowArglist: false);
+                return;
             }
-        }
 
-        private void BindArgumentsAndNames(
-            SeparatedSyntaxList<ArgumentSyntax> arguments,
-            BindingDiagnosticBag diagnostics,
-            AnalyzedArguments result,
-            bool allowArglist,
-            bool isDelegateCreation = false)
-        {
             // Only report the first "duplicate name" or "named before positional" error,
             // so as to avoid "cascading" errors.
             bool hadError = false;
@@ -2681,7 +2666,7 @@ private void BindArgumentsAndNames(
             // so as to avoid "cascading" errors.
             bool hadLangVersionError = false;
 
-            foreach (var argumentSyntax in arguments)
+            foreach (var argumentSyntax in argumentListOpt.Arguments)
             {
                 BindArgumentAndName(result, diagnostics, ref hadError, ref hadLangVersionError,
                     argumentSyntax, allowArglist, isDelegateCreation: isDelegateCreation);
@@ -2723,7 +2708,7 @@ private void BindArgumentAndName(
             ref bool hadLangVersionError,
             ArgumentSyntax argumentSyntax,
             bool allowArglist,
-            bool isDelegateCreation = false)
+            bool isDelegateCreation)
         {
             RefKind origRefKind = argumentSyntax.RefOrOutKeyword.Kind().GetRefKind();
             // The old native compiler ignores ref/out in a delegate creation expression.
@@ -4399,7 +4384,7 @@ private BoundExpression BindDelegateCreationExpression(SyntaxNode node, NamedTyp
                     {
                         var boundMethodGroup = new BoundMethodGroup(
                             argument.Syntax, default, WellKnownMemberNames.DelegateInvokeName, ImmutableArray.Create(sourceDelegate.DelegateInvokeMethod),
-                            sourceDelegate.DelegateInvokeMethod, null, BoundMethodGroupFlags.None, argument, LookupResultKind.Viable);
+                            sourceDelegate.DelegateInvokeMethod, null, BoundMethodGroupFlags.None, functionType: null, argument, LookupResultKind.Viable);
                         if (!Conversions.ReportDelegateOrFunctionPointerMethodGroupDiagnostics(this, boundMethodGroup, type, diagnostics))
                         {
                             // If we could not produce a more specialized diagnostic, we report
@@ -6480,7 +6465,8 @@ private BoundExpression BindInstanceMemberAccess(
                         rightName,
                         lookupResult.Symbols.All(s => s.Kind == SymbolKind.Method) ? lookupResult.Symbols.SelectAsArray(s_toMethodSymbolFunc) : ImmutableArray<MethodSymbol>.Empty,
                         lookupResult,
-                        flags);
+                        flags,
+                        this);
 
                     if (!boundMethodGroup.HasErrors && typeArgumentsSyntax.Any(SyntaxKind.OmittedTypeArgument))
                     {
@@ -6630,6 +6616,7 @@ private BoundExpression BindMemberAccessBadResult(
                     methods.Length == 1 ? methods[0] : null,
                     lookupError,
                     flags: BoundMethodGroupFlags.None,
+                    functionType: null,
                     receiverOpt: boundLeft,
                     resultKind: lookupKind,
                     hasErrors: true);
@@ -8506,10 +8493,11 @@ private MethodGroupResolution ResolveDefaultMethodGroup(
         }
 
 #nullable enable
-        internal NamedTypeSymbol? GetMethodGroupDelegateType(BoundMethodGroup node, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)
+        internal NamedTypeSymbol? GetMethodGroupDelegateType(BoundMethodGroup node)
         {
-            if (GetUniqueSignatureFromMethodGroup(node) is { } method &&
-                GetMethodGroupOrLambdaDelegateType(method.RefKind, method.ReturnsVoid ? default : method.ReturnTypeWithAnnotations, method.ParameterRefKinds, method.ParameterTypesWithAnnotations, ref useSiteInfo) is { } delegateType)
+            var method = GetUniqueSignatureFromMethodGroup(node);
+            if (method is { } &&
+                GetMethodGroupOrLambdaDelegateType(method.RefKind, method.ReturnsVoid ? default : method.ReturnTypeWithAnnotations, method.ParameterRefKinds, method.ParameterTypesWithAnnotations) is { } delegateType)
             {
                 return delegateType;
             }
@@ -8597,8 +8585,7 @@ static bool isCandidateUnique(ref MethodSymbol? method, MethodSymbol candidate)
             RefKind returnRefKind,
             TypeWithAnnotations returnTypeOpt,
             ImmutableArray<RefKind> parameterRefKinds,
-            ImmutableArray<TypeWithAnnotations> parameterTypes,
-            ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)
+            ImmutableArray<TypeWithAnnotations> parameterTypes)
         {
             Debug.Assert(parameterRefKinds.IsDefault || parameterRefKinds.Length == parameterTypes.Length);
             Debug.Assert(returnTypeOpt.Type?.IsVoidType() != true); // expecting !returnTypeOpt.HasType rather than System.Void
@@ -8629,8 +8616,9 @@ static bool isCandidateUnique(ref MethodSymbol? method, MethodSymbol candidate)
 
                 if (wkDelegateType != WellKnownType.Unknown)
                 {
+                    // The caller of GetMethodGroupOrLambdaDelegateType() is responsible for
+                    // checking and reporting use-site diagnostics for the returned delegate type.
                     var delegateType = Compilation.GetWellKnownType(wkDelegateType);
-                    delegateType.AddUseSiteInfo(ref useSiteInfo);
                     if (typeArguments.Length == 0)
                     {
                         return delegateType;
diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Invocation.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Invocation.cs
index 16e3e1f1d80b1..c031c1be6aa5a 100644
--- a/src/Compilers/CSharp/Portable/Binder/Binder_Invocation.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Binder_Invocation.cs
@@ -342,6 +342,7 @@ private BoundExpression BindDynamicInvocation(
                                     methodGroup.LookupSymbolOpt,
                                     methodGroup.LookupError,
                                     methodGroup.Flags & ~BoundMethodGroupFlags.HasImplicitReceiver,
+                                    methodGroup.FunctionType,
                                     receiverOpt: new BoundTypeExpression(node, null, this.ContainingType).MakeCompilerGenerated(),
                                     resultKind: methodGroup.ResultKind);
                             }
@@ -366,6 +367,7 @@ private BoundExpression BindDynamicInvocation(
                                     methodGroup.LookupSymbolOpt,
                                     methodGroup.LookupError,
                                     methodGroup.Flags,
+                                    methodGroup.FunctionType,
                                     finalReceiver,
                                     methodGroup.ResultKind);
                             break;
diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Lambda.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Lambda.cs
index ee4dad5e40adf..7cce9af369dc7 100644
--- a/src/Compilers/CSharp/Portable/Binder/Binder_Lambda.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Binder_Lambda.cs
@@ -208,7 +208,7 @@ private UnboundLambda AnalyzeAnonymousFunction(
 
             namesBuilder.Free();
 
-            return new UnboundLambda(syntax, this, diagnostics.AccumulatesDependencies, returnRefKind, returnType, parameterAttributes, refKinds, types, names, discardsOpt, isAsync, isStatic);
+            return UnboundLambda.Create(syntax, this, diagnostics.AccumulatesDependencies, returnRefKind, returnType, parameterAttributes, refKinds, types, names, discardsOpt, isAsync, isStatic);
 
             static ImmutableArray<bool> computeDiscards(SeparatedSyntaxList<ParameterSyntax> parameters, int underscoresCount)
             {
diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Query.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Query.cs
index 38c543310628c..06f90b4a34dbc 100644
--- a/src/Compilers/CSharp/Portable/Binder/Binder_Query.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Binder_Query.cs
@@ -699,7 +699,8 @@ private UnboundLambda MakeQueryUnboundLambda(RangeVariableMap qvm, ImmutableArra
         private static UnboundLambda MakeQueryUnboundLambda(CSharpSyntaxNode node, QueryUnboundLambdaState state, bool withDependencies)
         {
             Debug.Assert(node is ExpressionSyntax || LambdaUtilities.IsQueryPairLambda(node));
-            var lambda = new UnboundLambda(node, state, withDependencies, hasErrors: false) { WasCompilerGenerated = true };
+            // Function type is null because query expression syntax does not allow an explicit signature.
+            var lambda = new UnboundLambda(node, state, functionType: null, withDependencies, hasErrors: false) { WasCompilerGenerated = true };
             state.SetUnboundLambda(lambda);
             return lambda;
         }
diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Statements.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Statements.cs
index 9d66957b6315d..bf9d9b659e10d 100644
--- a/src/Compilers/CSharp/Portable/Binder/Binder_Statements.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Binder_Statements.cs
@@ -1853,6 +1853,19 @@ internal void GenerateAnonymousFunctionConversionError(BindingDiagnosticBag diag
                     return;
                 }
 
+                if (anonymousFunction.FunctionType is { } functionType &&
+                    functionType.GetValue() is null)
+                {
+                    var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded;
+                    if (Conversions.IsValidFunctionTypeConversionTarget(targetType, ref discardedUseSiteInfo))
+                    {
+                        Error(diagnostics, ErrorCode.ERR_CannotInferDelegateType, syntax);
+                        var lambda = anonymousFunction.BindForErrorRecovery();
+                        diagnostics.AddRange(lambda.Diagnostics);
+                        return;
+                    }
+                }
+
                 // Cannot convert {0} to type '{1}' because it is not a delegate type
                 Error(diagnostics, ErrorCode.ERR_AnonMethToNonDel, syntax, id, targetType);
                 return;
@@ -1878,15 +1891,6 @@ internal void GenerateAnonymousFunctionConversionError(BindingDiagnosticBag diag
                 return;
             }
 
-            if (reason == LambdaConversionResult.CannotInferDelegateType)
-            {
-                Debug.Assert(targetType.SpecialType == SpecialType.System_Delegate || targetType.IsNonGenericExpressionType());
-                Error(diagnostics, ErrorCode.ERR_CannotInferDelegateType, syntax);
-                var lambda = anonymousFunction.BindForErrorRecovery();
-                diagnostics.AddRange(lambda.Diagnostics);
-                return;
-            }
-
             // At this point we know that we have either a delegate type or an expression type for the target.
 
             // The target type is a valid delegate or expression tree type. Is there something wrong with the
@@ -2281,11 +2285,13 @@ void reportMethodGroupErrors(BoundMethodGroup methodGroup, bool fromAddressOf)
                             errorCode = ErrorCode.ERR_MethDelegateMismatch;
                             break;
                         default:
+                            var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded;
                             if (fromAddressOf)
                             {
                                 errorCode = ErrorCode.ERR_AddressOfToNonFunctionPointer;
                             }
-                            else if (targetType.SpecialType == SpecialType.System_Delegate &&
+                            else if (Conversions.IsValidFunctionTypeConversionTarget(targetType, ref discardedUseSiteInfo) &&
+                                !targetType.IsNonGenericExpressionType() &&
                                 syntax.IsFeatureEnabled(MessageID.IDS_FeatureInferredDelegateType))
                             {
                                 Error(diagnostics, ErrorCode.ERR_CannotInferDelegateType, location);
diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Symbols.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Symbols.cs
index 3d768e32ded72..8bfa775b936f4 100644
--- a/src/Compilers/CSharp/Portable/Binder/Binder_Symbols.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Binder_Symbols.cs
@@ -1336,7 +1336,7 @@ private NamedTypeSymbol ConstructNamedTypeUnlessTypeArgumentOmitted(SyntaxNode t
         /// <remarks>
         /// Keep check and error in sync with ConstructNamedTypeUnlessTypeArgumentOmitted.
         /// </remarks>
-        private static BoundMethodOrPropertyGroup ConstructBoundMemberGroupAndReportOmittedTypeArguments(
+        private BoundMethodOrPropertyGroup ConstructBoundMemberGroupAndReportOmittedTypeArguments(
             SyntaxNode syntax,
             SeparatedSyntaxList<TypeSyntax> typeArgumentsSyntax,
             ImmutableArray<TypeWithAnnotations> typeArguments,
@@ -1369,6 +1369,7 @@ private static BoundMethodOrPropertyGroup ConstructBoundMemberGroupAndReportOmit
                         members.SelectAsArray(s_toMethodSymbolFunc),
                         lookupResult,
                         methodGroupFlags,
+                        this,
                         hasErrors);
 
                 case SymbolKind.Property:
diff --git a/src/Compilers/CSharp/Portable/Binder/DecisionDagBuilder.cs b/src/Compilers/CSharp/Portable/Binder/DecisionDagBuilder.cs
index 93c3e2c8c9d21..578c8a69a6d5a 100644
--- a/src/Compilers/CSharp/Portable/Binder/DecisionDagBuilder.cs
+++ b/src/Compilers/CSharp/Portable/Binder/DecisionDagBuilder.cs
@@ -915,6 +915,7 @@ private void ComputeBoundDecisionDagNodes(DecisionDag decisionDag, BoundLeafDeci
                         BoundDecisionDagNode whenTrue = finalState(first.Syntax, first.CaseLabel, default);
                         BoundDecisionDagNode? whenFalse = state.FalseBranch.Dag;
                         RoslynDebug.Assert(whenFalse is { });
+                        // Note: we may share `when` clauses between multiple DAG nodes, but we deal with that safely during lowering
                         state.Dag = uniqifyDagNode(new BoundWhenDecisionDagNode(first.Syntax, first.Bindings, first.WhenClause, whenTrue, whenFalse));
                     }
 
diff --git a/src/Compilers/CSharp/Portable/Binder/Semantics/BestTypeInferrer.cs b/src/Compilers/CSharp/Portable/Binder/Semantics/BestTypeInferrer.cs
index 8e5f56f832a57..d3059e2cd3647 100644
--- a/src/Compilers/CSharp/Portable/Binder/Semantics/BestTypeInferrer.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Semantics/BestTypeInferrer.cs
@@ -68,7 +68,7 @@ public static NullableFlowState GetNullableState(ArrayBuilder<TypeWithState> typ
             HashSet<TypeSymbol> candidateTypes = new HashSet<TypeSymbol>(comparer);
             foreach (BoundExpression expr in exprs)
             {
-                TypeSymbol? type = expr.Type;
+                TypeSymbol? type = expr.GetTypeOrFunctionType();
 
                 if (type is { })
                 {
@@ -86,7 +86,8 @@ public static NullableFlowState GetNullableState(ArrayBuilder<TypeWithState> typ
             builder.AddRange(candidateTypes);
             var result = GetBestType(builder, conversions, ref useSiteInfo);
             builder.Free();
-            return result;
+
+            return (result as FunctionTypeSymbol)?.GetInternalDelegateType() ?? result;
         }
 
         /// <remarks>
@@ -241,6 +242,19 @@ public static NullableFlowState GetNullableState(ArrayBuilder<TypeWithState> typ
                 return type1;
             }
 
+            // Prefer types other than FunctionTypeSymbol.
+            if (type1 is FunctionTypeSymbol)
+            {
+                if (!(type2 is FunctionTypeSymbol))
+                {
+                    return type2;
+                }
+            }
+            else if (type2 is FunctionTypeSymbol)
+            {
+                return type1;
+            }
+
             var conversionsWithoutNullability = conversions.WithNullability(false);
             var t1tot2 = conversionsWithoutNullability.ClassifyImplicitConversionFromType(type1, type2, ref useSiteInfo).Exists;
             var t2tot1 = conversionsWithoutNullability.ClassifyImplicitConversionFromType(type2, type1, ref useSiteInfo).Exists;
diff --git a/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/Conversion.cs b/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/Conversion.cs
index 082400b2b10c1..d59683a0ebf79 100644
--- a/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/Conversion.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/Conversion.cs
@@ -9,7 +9,6 @@
 using System.Collections.Immutable;
 using System.Diagnostics;
 using Microsoft.CodeAnalysis.Operations;
-using System.Diagnostics.CodeAnalysis;
 
 namespace Microsoft.CodeAnalysis.CSharp
 {
@@ -247,6 +246,7 @@ internal static Conversion GetTrivialConversion(ConversionKind kind)
         internal static Conversion Deconstruction => new Conversion(ConversionKind.Deconstruction);
         internal static Conversion PinnedObjectToPointer => new Conversion(ConversionKind.PinnedObjectToPointer);
         internal static Conversion ImplicitPointer => new Conversion(ConversionKind.ImplicitPointer);
+        internal static Conversion FunctionType => new Conversion(ConversionKind.FunctionType);
 
         // trivial conversions that could be underlying in nullable conversion
         // NOTE: tuple conversions can be underlying as well, but they are not trivial 
diff --git a/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/ConversionKind.cs b/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/ConversionKind.cs
index 8d82824d3d9a5..7656918721763 100644
--- a/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/ConversionKind.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/ConversionKind.cs
@@ -31,6 +31,12 @@ internal enum ConversionKind : byte
         ImplicitUserDefined,
         AnonymousFunction,
         MethodGroup,
+        // Function type conversions are conversions from an inferred "function type" of
+        // a method group or lambda expression:
+        // - to another inferred "function type", or
+        // - to MulticastDelegate or base type or interface, or
+        // - to Expression or LambdaExpression.
+        FunctionType,
         ExplicitNumeric,
         ExplicitEnumeration,
         ExplicitNullable,
diff --git a/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/ConversionKindExtensions.cs b/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/ConversionKindExtensions.cs
index 09555f2ce90c0..08ebed29d4a48 100644
--- a/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/ConversionKindExtensions.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/ConversionKindExtensions.cs
@@ -2,12 +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.Diagnostics;
-using Microsoft.CodeAnalysis.CSharp.Symbols;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.Text;
 using Roslyn.Utilities;
 using static Microsoft.CodeAnalysis.CSharp.ConversionKind;
 
@@ -45,6 +39,7 @@ public static bool IsImplicitConversion(this ConversionKind conversionKind)
                 case ImplicitUserDefined:
                 case AnonymousFunction:
                 case ConversionKind.MethodGroup:
+                case ConversionKind.FunctionType:
                 case ImplicitPointerToVoid:
                 case ImplicitNullToPointer:
                 case InterpolatedString:
diff --git a/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/Conversions.cs b/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/Conversions.cs
index d62378d12b4fc..2e9931dc26444 100644
--- a/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/Conversions.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/Conversions.cs
@@ -7,10 +7,7 @@
 using System;
 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
 {
@@ -45,18 +42,18 @@ protected override ConversionsBase WithNullabilityCore(bool includeNullability)
         public override Conversion GetMethodGroupDelegateConversion(BoundMethodGroup source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)
         {
             // Must be a bona fide delegate type, not an expression tree type.
-            if (!(destination.IsDelegateType() || (destination.SpecialType == SpecialType.System_Delegate && IsFeatureInferredDelegateTypeEnabled(source))))
+            if (!destination.IsDelegateType())
             {
                 return Conversion.NoConversion;
             }
 
-            var (methodSymbol, isFunctionPointer, callingConventionInfo) = GetDelegateInvokeOrFunctionPointerMethodIfAvailable(source, destination, ref useSiteInfo);
+            var (methodSymbol, isFunctionPointer, callingConventionInfo) = GetDelegateInvokeOrFunctionPointerMethodIfAvailable(destination);
             if ((object)methodSymbol == null)
             {
                 return Conversion.NoConversion;
             }
 
-            Debug.Assert(destination.SpecialType == SpecialType.System_Delegate || methodSymbol == ((NamedTypeSymbol)destination).DelegateInvokeMethod);
+            Debug.Assert(methodSymbol == ((NamedTypeSymbol)destination).DelegateInvokeMethod);
 
             var resolution = ResolveDelegateOrFunctionPointerMethodGroup(_binder, source, methodSymbol, isFunctionPointer, callingConventionInfo, ref useSiteInfo);
             var conversion = (resolution.IsEmpty || resolution.HasAnyErrors) ?
@@ -128,21 +125,14 @@ private static MethodGroupResolution ResolveDelegateOrFunctionPointerMethodGroup
         /// Return the Invoke method symbol if the type is a delegate
         /// type and the Invoke method is available, otherwise null.
         /// </summary>
-        private (MethodSymbol, bool isFunctionPointer, CallingConventionInfo callingConventionInfo) GetDelegateInvokeOrFunctionPointerMethodIfAvailable(
-            BoundMethodGroup methodGroup,
-            TypeSymbol type,
-            ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)
+        private static (MethodSymbol, bool isFunctionPointer, CallingConventionInfo callingConventionInfo) GetDelegateInvokeOrFunctionPointerMethodIfAvailable(TypeSymbol type)
         {
             if (type is FunctionPointerTypeSymbol { Signature: { } signature })
             {
                 return (signature, true, new CallingConventionInfo(signature.CallingConvention, signature.GetCallingConventionModifiers()));
             }
 
-            var delegateType = (type.SpecialType == SpecialType.System_Delegate) && methodGroup.Syntax.IsFeatureEnabled(MessageID.IDS_FeatureNullableReferenceTypes) ?
-                // https://github.com/dotnet/roslyn/issues/52869: Avoid calculating the delegate type multiple times during conversion.
-                _binder.GetMethodGroupDelegateType(methodGroup, ref useSiteInfo) :
-                type.GetDelegateType();
-
+            var delegateType = type.GetDelegateType();
             if ((object)delegateType == null)
             {
                 return (null, false, default);
@@ -157,10 +147,10 @@ private static MethodGroupResolution ResolveDelegateOrFunctionPointerMethodGroup
             return (methodSymbol, false, default);
         }
 
-        public bool ReportDelegateOrFunctionPointerMethodGroupDiagnostics(Binder binder, BoundMethodGroup expr, TypeSymbol targetType, BindingDiagnosticBag diagnostics)
+        public static bool ReportDelegateOrFunctionPointerMethodGroupDiagnostics(Binder binder, BoundMethodGroup expr, TypeSymbol targetType, BindingDiagnosticBag diagnostics)
         {
             CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = binder.GetNewCompoundUseSiteInfo(diagnostics);
-            var (invokeMethodOpt, isFunctionPointer, callingConventionInfo) = GetDelegateInvokeOrFunctionPointerMethodIfAvailable(expr, targetType, ref useSiteInfo);
+            var (invokeMethodOpt, isFunctionPointer, callingConventionInfo) = GetDelegateInvokeOrFunctionPointerMethodIfAvailable(targetType);
             var resolution = ResolveDelegateOrFunctionPointerMethodGroup(binder, expr, invokeMethodOpt, isFunctionPointer, callingConventionInfo, ref useSiteInfo);
             diagnostics.Add(expr.Syntax, useSiteInfo);
 
diff --git a/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/ConversionsBase.cs b/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/ConversionsBase.cs
index d8f2705d5f980..2fcb3c077b57d 100644
--- a/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/ConversionsBase.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/ConversionsBase.cs
@@ -6,6 +6,7 @@
 
 using System.Collections.Immutable;
 using System.Diagnostics;
+using System.Linq;
 using System.Threading;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
@@ -83,7 +84,7 @@ public Conversion ClassifyImplicitConversionFromExpression(BoundExpression sourc
             Debug.Assert(sourceExpression != null);
             Debug.Assert((object)destination != null);
 
-            var sourceType = sourceExpression.Type;
+            var sourceType = sourceExpression.GetTypeOrFunctionType();
 
             //PERF: identity conversion is by far the most common implicit conversion, check for that first
             if ((object)sourceType != null && HasIdentityConversionInternal(sourceType, destination))
@@ -515,7 +516,7 @@ public Conversion ClassifyStandardConversion(BoundExpression sourceExpression, T
         private Conversion ClassifyStandardImplicitConversion(BoundExpression sourceExpression, TypeSymbol source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)
         {
             Debug.Assert(sourceExpression != null || (object)source != null);
-            Debug.Assert(sourceExpression == null || (object)sourceExpression.Type == (object)source);
+            Debug.Assert(sourceExpression == null || (object)sourceExpression.GetTypeOrFunctionType() == (object)source);
             Debug.Assert((object)destination != null);
 
             // SPEC: The following implicit conversions are classified as standard implicit conversions:
@@ -581,6 +582,13 @@ private Conversion ClassifyStandardImplicitConversion(TypeSymbol source, TypeSym
                 return nullableConversion;
             }
 
+            if (source is FunctionTypeSymbol functionType)
+            {
+                return HasImplicitFunctionTypeConversion(functionType, destination, ref useSiteInfo) ?
+                    Conversion.FunctionType :
+                    Conversion.NoConversion;
+            }
+
             if (HasImplicitReferenceConversion(source, destination, ref useSiteInfo))
             {
                 return Conversion.ImplicitReference;
@@ -767,6 +775,7 @@ private Conversion DeriveStandardExplicitFromOppositeStandardImplicitConversion(
             return impliedExplicitConversion;
         }
 
+#nullable enable
         /// <summary>
         /// IsBaseInterface returns true if baseType is on the base interface list of derivedType or
         /// any base class of derivedType. It may be on the base interface list either directly or
@@ -788,7 +797,7 @@ public bool IsBaseInterface(TypeSymbol baseType, TypeSymbol derivedType, ref Com
             }
 
             var d = derivedType as NamedTypeSymbol;
-            if ((object)d == null)
+            if (d is null)
             {
                 return false;
             }
@@ -853,11 +862,12 @@ private static bool ExplicitConversionMayDifferFromImplicit(Conversion implicitC
                     return false;
             }
         }
+#nullable disable
 
         private Conversion ClassifyImplicitBuiltInConversionFromExpression(BoundExpression sourceExpression, TypeSymbol source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)
         {
             Debug.Assert(sourceExpression != null || (object)source != null);
-            Debug.Assert(sourceExpression == null || (object)sourceExpression.Type == (object)source);
+            Debug.Assert(sourceExpression == null || (object)sourceExpression.GetTypeOrFunctionType() == (object)source);
             Debug.Assert((object)destination != null);
 
             if (HasImplicitDynamicConversionFromExpression(source, destination))
@@ -1183,8 +1193,6 @@ private Conversion ClassifyExplicitOnlyConversionFromExpression(BoundExpression
             Debug.Assert(sourceExpression != null);
             Debug.Assert((object)destination != null);
 
-            var sourceType = sourceExpression.Type;
-
             // NB: need to check for explicit tuple literal conversion before checking for explicit conversion from type
             //     The same literal may have both explicit tuple conversion and explicit tuple literal conversion to the target type.
             //     They are, however, observably different conversions via the order of argument evaluations and element-wise conversions
@@ -1197,6 +1205,7 @@ private Conversion ClassifyExplicitOnlyConversionFromExpression(BoundExpression
                 }
             }
 
+            var sourceType = sourceExpression.GetTypeOrFunctionType();
             if ((object)sourceType != null)
             {
                 // Try using the short-circuit "fast-conversion" path.
@@ -1367,7 +1376,7 @@ private static LambdaConversionResult IsAnonymousFunctionCompatibleWithExpressio
         {
             Debug.Assert((object)anonymousFunction != null);
             Debug.Assert((object)type != null);
-            Debug.Assert(type.IsGenericOrNonGenericExpressionType(out _));
+            Debug.Assert(type.IsExpressionTree());
 
             // SPEC OMISSION:
             // 
@@ -1380,8 +1389,8 @@ private static LambdaConversionResult IsAnonymousFunctionCompatibleWithExpressio
             // This appears to be a spec omission; the intention is to make old-style anonymous methods not 
             // convertible to expression trees.
 
-            var delegateType = type.Arity == 0 ? null : type.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type;
-            if (delegateType is { } && !delegateType.IsDelegateType())
+            var delegateType = type.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type;
+            if (!delegateType.IsDelegateType())
             {
                 return LambdaConversionResult.ExpressionTreeMustHaveDelegateTypeArgument;
             }
@@ -1391,55 +1400,33 @@ private static LambdaConversionResult IsAnonymousFunctionCompatibleWithExpressio
                 return LambdaConversionResult.ExpressionTreeFromAnonymousMethod;
             }
 
-            if (delegateType is null)
-            {
-                Debug.Assert(IsFeatureInferredDelegateTypeEnabled(anonymousFunction));
-                return GetInferredDelegateTypeResult(anonymousFunction);
-            }
-
             return IsAnonymousFunctionCompatibleWithDelegate(anonymousFunction, delegateType, isTargetExpressionTree: true);
         }
 
+        internal bool IsAssignableFromMulticastDelegate(TypeSymbol type, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)
+        {
+            var multicastDelegateType = corLibrary.GetSpecialType(SpecialType.System_MulticastDelegate);
+            multicastDelegateType.AddUseSiteInfo(ref useSiteInfo);
+            return ClassifyImplicitConversionFromType(multicastDelegateType, type, ref useSiteInfo).Exists;
+        }
+
         public static LambdaConversionResult IsAnonymousFunctionCompatibleWithType(UnboundLambda anonymousFunction, TypeSymbol type)
         {
             Debug.Assert((object)anonymousFunction != null);
             Debug.Assert((object)type != null);
 
-            if (type.SpecialType == SpecialType.System_Delegate)
-            {
-                if (IsFeatureInferredDelegateTypeEnabled(anonymousFunction))
-                {
-                    return GetInferredDelegateTypeResult(anonymousFunction);
-                }
-            }
-            else if (type.IsDelegateType())
+            if (type.IsDelegateType())
             {
                 return IsAnonymousFunctionCompatibleWithDelegate(anonymousFunction, type, isTargetExpressionTree: false);
             }
-            else if (type.IsGenericOrNonGenericExpressionType(out bool isGenericType))
+            else if (type.IsExpressionTree())
             {
-                if (isGenericType || IsFeatureInferredDelegateTypeEnabled(anonymousFunction))
-                {
-                    return IsAnonymousFunctionCompatibleWithExpressionTree(anonymousFunction, (NamedTypeSymbol)type);
-                }
+                return IsAnonymousFunctionCompatibleWithExpressionTree(anonymousFunction, (NamedTypeSymbol)type);
             }
 
             return LambdaConversionResult.BadTargetType;
         }
 
-        internal static bool IsFeatureInferredDelegateTypeEnabled(BoundExpression expr)
-        {
-            return expr.Syntax.IsFeatureEnabled(MessageID.IDS_FeatureInferredDelegateType);
-        }
-
-        private static LambdaConversionResult GetInferredDelegateTypeResult(UnboundLambda anonymousFunction)
-        {
-            var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded;
-            return anonymousFunction.InferDelegateType(ref discardedUseSiteInfo) is null ?
-                LambdaConversionResult.CannotInferDelegateType :
-                LambdaConversionResult.Success;
-        }
-
         private static bool HasAnonymousFunctionConversion(BoundExpression source, TypeSymbol destination)
         {
             Debug.Assert(source != null);
@@ -2410,6 +2397,7 @@ private bool HasImplicitReferenceConversion(TypeWithAnnotations source, TypeWith
             return HasImplicitReferenceConversion(source.Type, destination.Type, ref useSiteInfo);
         }
 
+#nullable enable
         internal bool HasImplicitReferenceConversion(TypeSymbol source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)
         {
             Debug.Assert((object)source != null);
@@ -2509,8 +2497,8 @@ private bool HasImplicitConversionToInterface(TypeSymbol source, TypeSymbol dest
 
         private bool HasImplicitConversionFromArray(TypeSymbol source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)
         {
-            ArrayTypeSymbol s = source as ArrayTypeSymbol;
-            if ((object)s == null)
+            var s = source as ArrayTypeSymbol;
+            if (s is null)
             {
                 return false;
             }
@@ -2584,6 +2572,50 @@ private bool HasImplicitConversionFromDelegate(TypeSymbol source, TypeSymbol des
             return false;
         }
 
+        private bool HasImplicitFunctionTypeConversion(FunctionTypeSymbol source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)
+        {
+            if (destination is FunctionTypeSymbol destinationFunctionType)
+            {
+                return HasImplicitSignatureConversion(source, destinationFunctionType, ref useSiteInfo);
+            }
+
+            return IsValidFunctionTypeConversionTarget(destination, ref useSiteInfo);
+        }
+
+        internal bool IsValidFunctionTypeConversionTarget(TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)
+        {
+            if (destination.SpecialType == SpecialType.System_MulticastDelegate)
+            {
+                return true;
+            }
+
+            if (destination.IsNonGenericExpressionType())
+            {
+                return true;
+            }
+
+            var derivedType = this.corLibrary.GetDeclaredSpecialType(SpecialType.System_MulticastDelegate);
+            if (IsBaseClass(derivedType, destination, ref useSiteInfo) ||
+                IsBaseInterface(destination, derivedType, ref useSiteInfo))
+            {
+                return true;
+            }
+
+            return false;
+        }
+
+        private bool HasImplicitSignatureConversion(FunctionTypeSymbol sourceType, FunctionTypeSymbol destinationType, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)
+        {
+            var sourceDelegate = sourceType.GetInternalDelegateType();
+            var destinationDelegate = destinationType.GetInternalDelegateType();
+
+            // https://github.com/dotnet/roslyn/issues/55909: We're relying on the variance of
+            // FunctionTypeSymbol.GetInternalDelegateType() which fails for synthesized
+            // delegate types where the type parameters are invariant.
+            return HasDelegateVarianceConversion(sourceDelegate, destinationDelegate, ref useSiteInfo);
+        }
+#nullable disable
+
         public bool HasImplicitTypeParameterConversion(TypeParameterSymbol source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)
         {
             if (HasImplicitReferenceTypeParameterConversion(source, destination, ref useSiteInfo))
diff --git a/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/LambdaConversionResult.cs b/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/LambdaConversionResult.cs
index 227ec23eb7b40..5a10903cb935a 100644
--- a/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/LambdaConversionResult.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/LambdaConversionResult.cs
@@ -16,7 +16,6 @@ internal enum LambdaConversionResult
         StaticTypeInImplicitlyTypedLambda,
         ExpressionTreeMustHaveDelegateTypeArgument,
         ExpressionTreeFromAnonymousMethod,
-        CannotInferDelegateType,
         BindingFailed
     }
 }
diff --git a/src/Compilers/CSharp/Portable/Binder/Semantics/OverloadResolution/MethodTypeInference.cs b/src/Compilers/CSharp/Portable/Binder/Semantics/OverloadResolution/MethodTypeInference.cs
index bd0c69844ab84..650d6aaf94bd0 100644
--- a/src/Compilers/CSharp/Portable/Binder/Semantics/OverloadResolution/MethodTypeInference.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Semantics/OverloadResolution/MethodTypeInference.cs
@@ -8,11 +8,9 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
-using Microsoft.CodeAnalysis.Collections;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
-using Microsoft.CodeAnalysis.CSharp.Symbols.Metadata.PE;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Roslyn.Utilities;
 
@@ -97,7 +95,7 @@ private sealed class DefaultExtensions : Extensions
             {
                 internal override TypeWithAnnotations GetTypeWithAnnotations(BoundExpression expr)
                 {
-                    return TypeWithAnnotations.Create(expr.Type);
+                    return TypeWithAnnotations.Create(expr.GetTypeOrFunctionType());
                 }
 
                 internal override TypeWithAnnotations GetMethodGroupResultType(BoundMethodGroup group, MethodSymbol method)
@@ -124,6 +122,7 @@ private enum Dependency
             Indirect = 0x12
         }
 
+        private readonly CSharpCompilation _compilation;
         private readonly ConversionsBase _conversions;
         private readonly ImmutableArray<TypeParameterSymbol> _methodTypeParameters;
         private readonly NamedTypeSymbol _constructedContainingTypeOfMethod;
@@ -273,6 +272,7 @@ public static MethodTypeInferenceResult Infer(
             }
 
             var inferrer = new MethodTypeInferrer(
+                binder.Compilation,
                 conversions,
                 methodTypeParameters,
                 constructedContainingTypeOfMethod,
@@ -293,6 +293,7 @@ public static MethodTypeInferenceResult Infer(
         // SPEC: with an empty set of bounds.
 
         private MethodTypeInferrer(
+            CSharpCompilation compilation,
             ConversionsBase conversions,
             ImmutableArray<TypeParameterSymbol> methodTypeParameters,
             NamedTypeSymbol constructedContainingTypeOfMethod,
@@ -301,6 +302,7 @@ private MethodTypeInferrer(
             ImmutableArray<BoundExpression> arguments,
             Extensions extensions)
         {
+            _compilation = compilation;
             _conversions = conversions;
             _methodTypeParameters = methodTypeParameters;
             _constructedContainingTypeOfMethod = constructedContainingTypeOfMethod;
@@ -578,7 +580,7 @@ private void MakeExplicitParameterTypeInferences(BoundExpression argument, TypeW
 
             // SPEC: * Otherwise, no inference is made for this argument
 
-            if (argument.Kind == BoundKind.UnboundLambda)
+            if (argument.Kind == BoundKind.UnboundLambda && target.Type.GetDelegateType() is { })
             {
                 ExplicitParameterTypeInference(argument, target, ref useSiteInfo);
             }
@@ -586,7 +588,7 @@ private void MakeExplicitParameterTypeInferences(BoundExpression argument, TypeW
                 !MakeExplicitParameterTypeInferences((BoundTupleLiteral)argument, target, kind, ref useSiteInfo))
             {
                 // Either the argument is not a tuple literal, or we were unable to do the inference from its elements, let's try to infer from argument type
-                if (IsReallyAType(argument.Type))
+                if (IsReallyAType(argument.GetTypeOrFunctionType()))
                 {
                     ExactOrBoundsInference(kind, _extensions.GetTypeWithAnnotations(argument), target, ref useSiteInfo);
                 }
@@ -2528,7 +2530,6 @@ private bool UpperBoundFunctionPointerTypeInference(TypeSymbol source, TypeSymbo
 
             return true;
         }
-#nullable disable
 
         ////////////////////////////////////////////////////////////////////////////////
         //
@@ -2538,11 +2539,12 @@ private bool Fix(int iParam, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo
         {
             Debug.Assert(IsUnfixed(iParam));
 
+            var typeParameter = _methodTypeParameters[iParam];
             var exact = _exactBounds[iParam];
             var lower = _lowerBounds[iParam];
             var upper = _upperBounds[iParam];
 
-            var best = Fix(exact, lower, upper, ref useSiteInfo, _conversions);
+            var best = Fix(_compilation, _conversions, typeParameter, exact, lower, upper, ref useSiteInfo);
             if (!best.HasType)
             {
                 return false;
@@ -2554,7 +2556,7 @@ private bool Fix(int iParam, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo
                 // If the first attempt succeeded, the result should be the same as
                 // the second attempt, although perhaps with different nullability.
                 var discardedUseSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded;
-                var withoutNullability = Fix(exact, lower, upper, ref discardedUseSiteInfo, _conversions.WithNullability(false));
+                var withoutNullability = Fix(_compilation, _conversions.WithNullability(false), typeParameter, exact, lower, upper, ref discardedUseSiteInfo);
                 // https://github.com/dotnet/roslyn/issues/27961 Results may differ by tuple names or dynamic.
                 // See NullableReferenceTypesTests.TypeInference_TupleNameDifferences_01 for example.
                 Debug.Assert(best.Type.Equals(withoutNullability.Type, TypeCompareKind.IgnoreDynamicAndTupleNames | TypeCompareKind.IgnoreNullableModifiersForReferenceTypes));
@@ -2567,11 +2569,13 @@ private bool Fix(int iParam, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo
         }
 
         private static TypeWithAnnotations Fix(
-            HashSet<TypeWithAnnotations> exact,
-            HashSet<TypeWithAnnotations> lower,
-            HashSet<TypeWithAnnotations> upper,
-            ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo,
-            ConversionsBase conversions)
+            CSharpCompilation compilation,
+            ConversionsBase conversions,
+            TypeParameterSymbol typeParameter,
+            HashSet<TypeWithAnnotations>? exact,
+            HashSet<TypeWithAnnotations>? lower,
+            HashSet<TypeWithAnnotations>? upper,
+            ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)
         {
             // UNDONE: This method makes a lot of garbage.
 
@@ -2587,6 +2591,16 @@ private static TypeWithAnnotations Fix(
 
             var candidates = new Dictionary<TypeWithAnnotations, TypeWithAnnotations>(EqualsIgnoringDynamicTupleNamesAndNullabilityComparer.Instance);
 
+            Debug.Assert(!containsFunctionTypes(exact));
+            Debug.Assert(!containsFunctionTypes(upper));
+
+            // Function types are dropped if there are any non-function types.
+            if (containsFunctionTypes(lower) &&
+                (containsNonFunctionTypes(lower) || containsNonFunctionTypes(exact) || containsNonFunctionTypes(upper)))
+            {
+                lower = removeFunctionTypes(lower);
+            }
+
             // Optimization: if we have one exact bound then we need not add any
             // inexact bounds; we're just going to remove them anyway.
 
@@ -2674,7 +2688,69 @@ private static TypeWithAnnotations Fix(
 
             initialCandidates.Free();
 
+            if (isFunctionType(best, out var functionType))
+            {
+                // Realize the type as TDelegate, or Expression<TDelegate> if the type parameter
+                // is constrained to System.Linq.Expressions.Expression.
+                var resultType = functionType.GetInternalDelegateType();
+                if (hasExpressionTypeConstraint(typeParameter))
+                {
+                    var expressionOfTType = compilation.GetWellKnownType(WellKnownType.System_Linq_Expressions_Expression_T);
+                    resultType = expressionOfTType.Construct(resultType);
+                }
+                best = TypeWithAnnotations.Create(resultType, best.NullableAnnotation);
+            }
+
             return best;
+
+            static bool containsFunctionTypes([NotNullWhen(true)] HashSet<TypeWithAnnotations>? types)
+            {
+                return types?.Any(t => isFunctionType(t, out _)) == true;
+            }
+
+            static bool containsNonFunctionTypes([NotNullWhen(true)] HashSet<TypeWithAnnotations>? types)
+            {
+                return types?.Any(t => !isFunctionType(t, out _)) == true;
+            }
+
+            static bool isFunctionType(TypeWithAnnotations type, [NotNullWhen(true)] out FunctionTypeSymbol? functionType)
+            {
+                functionType = type.Type as FunctionTypeSymbol;
+                return functionType is not null;
+            }
+
+            static bool hasExpressionTypeConstraint(TypeParameterSymbol typeParameter)
+            {
+                var constraintTypes = typeParameter.ConstraintTypesNoUseSiteDiagnostics;
+                return constraintTypes.Any(t => isExpressionType(t.Type));
+            }
+
+            static bool isExpressionType(TypeSymbol? type)
+            {
+                while (type is { })
+                {
+                    if (type.IsGenericOrNonGenericExpressionType(out _))
+                    {
+                        return true;
+                    }
+                    type = type.BaseTypeNoUseSiteDiagnostics;
+                }
+                return false;
+            }
+
+            static HashSet<TypeWithAnnotations>? removeFunctionTypes(HashSet<TypeWithAnnotations> types)
+            {
+                HashSet<TypeWithAnnotations>? updated = null;
+                foreach (var type in types)
+                {
+                    if (!isFunctionType(type, out _))
+                    {
+                        updated ??= new HashSet<TypeWithAnnotations>(TypeWithAnnotations.EqualsComparer.ConsiderEverythingComparer);
+                        updated.Add(type);
+                    }
+                }
+                return updated;
+            }
         }
 
         private static bool ImplicitConversionExists(TypeWithAnnotations sourceWithAnnotations, TypeWithAnnotations destinationWithAnnotations, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo, ConversionsBase conversions)
@@ -2695,6 +2771,7 @@ private static bool ImplicitConversionExists(TypeWithAnnotations sourceWithAnnot
 
             return conversions.ClassifyImplicitConversionFromType(source, destination, ref useSiteInfo).Exists;
         }
+#nullable disable
 
         ////////////////////////////////////////////////////////////////////////////////
         //
@@ -2837,6 +2914,7 @@ private static NamedTypeSymbol GetInterfaceInferenceBound(ImmutableArray<NamedTy
         //
         // Clearly it is pointless to run multiple phases
         public static ImmutableArray<TypeWithAnnotations> InferTypeArgumentsFromFirstArgument(
+            CSharpCompilation compilation,
             ConversionsBase conversions,
             MethodSymbol method,
             ImmutableArray<BoundExpression> arguments,
@@ -2857,6 +2935,7 @@ public static ImmutableArray<TypeWithAnnotations> InferTypeArgumentsFromFirstArg
             var constructedFromMethod = method.ConstructedFrom;
 
             var inferrer = new MethodTypeInferrer(
+                compilation,
                 conversions,
                 constructedFromMethod.TypeParameters,
                 constructedFromMethod.ContainingType,
@@ -2908,6 +2987,7 @@ private bool InferTypeArgumentsFromFirstArgument(ref CompoundUseSiteInfo<Assembl
             return true;
         }
 
+#nullable enable
         /// <summary>
         /// Return the inferred type arguments using null
         /// for any type arguments that were not inferred.
@@ -2917,9 +2997,9 @@ private ImmutableArray<TypeWithAnnotations> GetInferredTypeArguments()
             return _fixedResults.AsImmutable();
         }
 
-        private static bool IsReallyAType(TypeSymbol type)
+        private static bool IsReallyAType(TypeSymbol? type)
         {
-            return (object)type != null &&
+            return type is { } &&
                 !type.IsErrorType() &&
                 !type.IsVoidType();
         }
diff --git a/src/Compilers/CSharp/Portable/Binder/Semantics/OverloadResolution/OverloadResolution.cs b/src/Compilers/CSharp/Portable/Binder/Semantics/OverloadResolution/OverloadResolution.cs
index 2d044d80c11c9..7373b362ad47c 100644
--- a/src/Compilers/CSharp/Portable/Binder/Semantics/OverloadResolution/OverloadResolution.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Semantics/OverloadResolution/OverloadResolution.cs
@@ -2078,7 +2078,7 @@ private BetterResult BetterFunctionMember<TMember>(
                 return result;
             }
 
-            // UNDONE: Otherwise if one member is a non-lifted operator and  the other is a lifted
+            // UNDONE: Otherwise if one member is a non-lifted operator and the other is a lifted
             // operator, the non-lifted one is better.
 
             // Otherwise: Position in interactive submission chain. The last definition wins.
@@ -2333,7 +2333,6 @@ private static BetterResult MoreSpecificType(TypeSymbol t1, TypeSymbol t2, ref C
         // Determine whether t1 or t2 is a better conversion target from node.
         private BetterResult BetterConversionFromExpression(BoundExpression node, TypeSymbol t1, TypeSymbol t2, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)
         {
-            Debug.Assert(node.Kind != BoundKind.UnboundLambda);
             bool ignore;
             return BetterConversionFromExpression(
                 node,
@@ -3548,6 +3547,7 @@ private ImmutableArray<TypeWithAnnotations> InferMethodTypeArguments(
             if (arguments.IsExtensionMethodInvocation)
             {
                 var inferredFromFirstArgument = MethodTypeInferrer.InferTypeArgumentsFromFirstArgument(
+                    _binder.Compilation,
                     _binder.Conversions,
                     method,
                     args,
diff --git a/src/Compilers/CSharp/Portable/Binder/Semantics/OverloadResolution/OverloadResolutionResult.cs b/src/Compilers/CSharp/Portable/Binder/Semantics/OverloadResolution/OverloadResolutionResult.cs
index 72b0af49a0c0b..36d0e25f065f0 100644
--- a/src/Compilers/CSharp/Portable/Binder/Semantics/OverloadResolution/OverloadResolutionResult.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Semantics/OverloadResolution/OverloadResolutionResult.cs
@@ -1183,7 +1183,7 @@ private static void ReportBadArgumentError(
                     ((UnboundLambda)argument).GenerateAnonymousFunctionConversionError(diagnostics, parameterType);
                 }
                 else if (argument.Kind == BoundKind.MethodGroup && parameterType.TypeKind == TypeKind.Delegate &&
-                        binder.Conversions.ReportDelegateOrFunctionPointerMethodGroupDiagnostics(binder, (BoundMethodGroup)argument, parameterType, diagnostics))
+                        Conversions.ReportDelegateOrFunctionPointerMethodGroupDiagnostics(binder, (BoundMethodGroup)argument, parameterType, diagnostics))
                 {
                     // a diagnostic has been reported by ReportDelegateOrFunctionPointerMethodGroupDiagnostics
                 }
@@ -1192,7 +1192,7 @@ private static void ReportBadArgumentError(
                     diagnostics.Add(ErrorCode.ERR_MissingAddressOf, sourceLocation);
                 }
                 else if (argument.Kind == BoundKind.UnconvertedAddressOfOperator &&
-                        binder.Conversions.ReportDelegateOrFunctionPointerMethodGroupDiagnostics(binder, ((BoundUnconvertedAddressOfOperator)argument).Operand, parameterType, diagnostics))
+                        Conversions.ReportDelegateOrFunctionPointerMethodGroupDiagnostics(binder, ((BoundUnconvertedAddressOfOperator)argument).Operand, parameterType, diagnostics))
                 {
                     // a diagnostic has been reported by ReportDelegateOrFunctionPointerMethodGroupDiagnostics
                 }
diff --git a/src/Compilers/CSharp/Portable/BoundTree/BoundExpressionExtensions.cs b/src/Compilers/CSharp/Portable/BoundTree/BoundExpressionExtensions.cs
index 889fb315e0e86..cf855070b5234 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/BoundExpressionExtensions.cs
+++ b/src/Compilers/CSharp/Portable/BoundTree/BoundExpressionExtensions.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.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
@@ -90,6 +91,35 @@ public static bool HasDynamicType(this BoundExpression node)
             return type is { } && type.IsDynamic();
         }
 
+        public static NamedTypeSymbol? GetInferredDelegateType(this BoundExpression expr, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)
+        {
+            Debug.Assert(expr.Kind is BoundKind.MethodGroup or BoundKind.UnboundLambda);
+
+            var delegateType = expr.GetFunctionType()?.GetInternalDelegateType();
+            delegateType?.AddUseSiteInfo(ref useSiteInfo);
+            return delegateType;
+        }
+
+        public static TypeSymbol? GetTypeOrFunctionType(this BoundExpression expr)
+        {
+            if (expr.Type is { } type)
+            {
+                return type;
+            }
+            return expr.GetFunctionType();
+        }
+
+        public static FunctionTypeSymbol? GetFunctionType(this BoundExpression expr)
+        {
+            var lazyType = expr switch
+            {
+                BoundMethodGroup methodGroup => methodGroup.FunctionType,
+                UnboundLambda unboundLambda => unboundLambda.FunctionType,
+                _ => null
+            };
+            return lazyType?.GetValue();
+        }
+
         public static bool MethodGroupReceiverIsDynamic(this BoundMethodGroup node)
         {
             return node.InstanceOpt != null && node.InstanceOpt.HasDynamicType();
diff --git a/src/Compilers/CSharp/Portable/BoundTree/BoundMethodGroup.cs b/src/Compilers/CSharp/Portable/BoundTree/BoundMethodGroup.cs
index f8f6226aa847b..e9cd966be0d25 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/BoundMethodGroup.cs
+++ b/src/Compilers/CSharp/Portable/BoundTree/BoundMethodGroup.cs
@@ -5,7 +5,6 @@
 using System.Collections.Immutable;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.Text;
 
 namespace Microsoft.CodeAnalysis.CSharp
 {
@@ -19,9 +18,16 @@ public BoundMethodGroup(
             ImmutableArray<MethodSymbol> methods,
             LookupResult lookupResult,
             BoundMethodGroupFlags flags,
+            Binder binder,
             bool hasErrors = false)
-            : this(syntax, typeArgumentsOpt, name, methods, lookupResult.SingleSymbolOrDefault, lookupResult.Error, flags, receiverOpt, lookupResult.Kind, hasErrors)
+            : this(syntax, typeArgumentsOpt, name, methods, lookupResult.SingleSymbolOrDefault, lookupResult.Error, flags, functionType: GetLazyFunctionType(binder, syntax), receiverOpt, lookupResult.Kind, hasErrors)
         {
+            FunctionType?.SetExpression(this);
+        }
+
+        private static FunctionTypeSymbol.Lazy? GetLazyFunctionType(Binder binder, SyntaxNode syntax)
+        {
+            return FunctionTypeSymbol.Lazy.CreateIfFeatureEnabled(syntax, binder, static (binder, expr) => binder.GetMethodGroupDelegateType((BoundMethodGroup)expr));
         }
 
         public MemberAccessExpressionSyntax? MemberAccessExpressionSyntax
diff --git a/src/Compilers/CSharp/Portable/BoundTree/BoundMethodGroupFlags.cs b/src/Compilers/CSharp/Portable/BoundTree/BoundMethodGroupFlags.cs
index 69355be158e54..46727e00cee3f 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/BoundMethodGroupFlags.cs
+++ b/src/Compilers/CSharp/Portable/BoundTree/BoundMethodGroupFlags.cs
@@ -3,13 +3,6 @@
 // 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.Tasks;
-using Microsoft.CodeAnalysis.CSharp.Symbols;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.Text;
 
 namespace Microsoft.CodeAnalysis.CSharp
 {
@@ -20,7 +13,7 @@ internal enum BoundMethodGroupFlags
         SearchExtensionMethods = 1,
 
         /// <summary>
-        /// Set if the group has a receiver but none was not specified in syntax.
+        /// Set if the group has a receiver but one was not specified in syntax.
         /// </summary>
         HasImplicitReceiver = 2,
     }
diff --git a/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml b/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml
index e85637183faee..33618417c72d5 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml
+++ b/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml
@@ -1441,7 +1441,7 @@
   <AbstractNode Name="BoundMethodOrPropertyGroup" Base="BoundExpression">
     <!-- Type is not significant for this node type; always null -->
     <Field Name="Type" Type="TypeSymbol?" Override="true" Null="always"/>
-
+    
     <!--We wish to keep the left-hand-side of the member access in the method group even if the
     *instance* expression ought to be null. For example, if we have System.Console.WriteLine then
     we want to keep the System.Console type expression as the receiver, even though the spec
@@ -1568,6 +1568,7 @@
     <Field Name="LookupSymbolOpt" Type="Symbol?"/>
     <Field Name="LookupError" Type="DiagnosticInfo?"/>
     <Field Name="Flags" Type="BoundMethodGroupFlags?"/>
+    <Field Name="FunctionType" Type="FunctionTypeSymbol.Lazy?" Null="allow"/>
   </Node>
 
   <Node Name="BoundPropertyGroup" Base="BoundMethodOrPropertyGroup">
@@ -1966,6 +1967,7 @@
     <!-- Type is not significant for this node type; always null -->
     <Field Name="Type" Type="TypeSymbol?" Override="true" Null="always"/>
     <Field Name="Data" Type="UnboundLambdaState" Null="disallow"/>
+    <Field Name="FunctionType" Type="FunctionTypeSymbol.Lazy?" Null="allow"/>
     <!-- Track dependencies while binding body, etc. -->
     <Field Name="WithDependencies" Type="Boolean"/>
   </Node>
diff --git a/src/Compilers/CSharp/Portable/BoundTree/UnboundLambda.cs b/src/Compilers/CSharp/Portable/BoundTree/UnboundLambda.cs
index e0e95ad7bb7bb..e3c1f8e58c278 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/UnboundLambda.cs
+++ b/src/Compilers/CSharp/Portable/BoundTree/UnboundLambda.cs
@@ -217,7 +217,7 @@ private static TypeWithAnnotations CalculateReturnType(
             Binder binder,
             ConversionsBase conversions,
             TypeSymbol? delegateType,
-            ArrayBuilder<(BoundExpression, TypeWithAnnotations resultType)> returns,
+            ArrayBuilder<(BoundExpression expr, TypeWithAnnotations resultType)> returns,
             bool isAsync,
             BoundNode node,
             ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)
@@ -230,7 +230,18 @@ private static TypeWithAnnotations CalculateReturnType(
                     bestResultType = default;
                     break;
                 case 1:
-                    bestResultType = returns[0].resultType;
+                    if (conversions.IncludeNullability)
+                    {
+                        bestResultType = returns[0].resultType;
+                    }
+                    else
+                    {
+                        var exprType = returns[0].expr.GetTypeOrFunctionType();
+                        var bestType = exprType is FunctionTypeSymbol functionType ?
+                            functionType.GetInternalDelegateType() :
+                            exprType;
+                        bestResultType = TypeWithAnnotations.Create(bestType);
+                    }
                     break;
                 default:
                     // Need to handle ref returns. See https://github.com/dotnet/roslyn/issues/30432
@@ -240,14 +251,8 @@ private static TypeWithAnnotations CalculateReturnType(
                     }
                     else
                     {
-                        var typesOnly = ArrayBuilder<TypeSymbol>.GetInstance(n);
-                        foreach (var (_, resultType) in returns)
-                        {
-                            typesOnly.Add(resultType.Type);
-                        }
-                        var bestType = BestTypeInferrer.GetBestType(typesOnly, conversions, ref useSiteInfo);
-                        bestResultType = bestType is null ? default : TypeWithAnnotations.Create(bestType);
-                        typesOnly.Free();
+                        var bestType = BestTypeInferrer.InferBestType(returns.SelectAsArray(pair => pair.expr), conversions, ref useSiteInfo);
+                        bestResultType = TypeWithAnnotations.Create(bestType);
                     }
                     break;
             }
@@ -347,7 +352,7 @@ internal partial class UnboundLambda
     {
         private readonly NullableWalker.VariableState? _nullableState;
 
-        public UnboundLambda(
+        public static UnboundLambda Create(
             CSharpSyntaxNode syntax,
             Binder binder,
             bool withDependencies,
@@ -360,15 +365,21 @@ public UnboundLambda(
             ImmutableArray<bool> discardsOpt,
             bool isAsync,
             bool isStatic)
-            : this(syntax, new PlainUnboundLambdaState(binder, returnRefKind, returnType, parameterAttributes, names, discardsOpt, types, refKinds, isAsync, isStatic, includeCache: true), withDependencies, !types.IsDefault && types.Any(t => t.Type?.Kind == SymbolKind.ErrorType))
         {
             Debug.Assert(binder != null);
             Debug.Assert(syntax.IsAnonymousFunction());
-            this.Data.SetUnboundLambda(this);
+            bool hasErrors = !types.IsDefault && types.Any(t => t.Type?.Kind == SymbolKind.ErrorType);
+
+            var functionType = FunctionTypeSymbol.Lazy.CreateIfFeatureEnabled(syntax, binder, static (binder, expr) => ((UnboundLambda)expr).Data.InferDelegateType());
+            var data = new PlainUnboundLambdaState(binder, returnRefKind, returnType, parameterAttributes, names, discardsOpt, types, refKinds, isAsync, isStatic, includeCache: true);
+            var lambda = new UnboundLambda(syntax, data, functionType, withDependencies, hasErrors: hasErrors);
+            data.SetUnboundLambda(lambda);
+            functionType?.SetExpression(lambda.WithNoCache());
+            return lambda;
         }
 
-        private UnboundLambda(SyntaxNode syntax, UnboundLambdaState state, bool withDependencies, NullableWalker.VariableState? nullableState, bool hasErrors) :
-            this(syntax, state, withDependencies, hasErrors)
+        private UnboundLambda(SyntaxNode syntax, UnboundLambdaState state, FunctionTypeSymbol.Lazy? functionType, bool withDependencies, NullableWalker.VariableState? nullableState, bool hasErrors) :
+            this(syntax, state, functionType, withDependencies, hasErrors)
         {
             this._nullableState = nullableState;
         }
@@ -376,7 +387,7 @@ private UnboundLambda(SyntaxNode syntax, UnboundLambdaState state, bool withDepe
         internal UnboundLambda WithNullableState(NullableWalker.VariableState nullableState)
         {
             var data = Data.WithCaching(true);
-            var lambda = new UnboundLambda(Syntax, data, WithDependencies, nullableState, HasErrors);
+            var lambda = new UnboundLambda(Syntax, data, FunctionType, WithDependencies, nullableState, HasErrors);
             data.SetUnboundLambda(lambda);
             return lambda;
         }
@@ -389,16 +400,13 @@ internal UnboundLambda WithNoCache()
                 return this;
             }
 
-            var lambda = new UnboundLambda(Syntax, data, WithDependencies, _nullableState, HasErrors);
+            var lambda = new UnboundLambda(Syntax, data, FunctionType, WithDependencies, _nullableState, HasErrors);
             data.SetUnboundLambda(lambda);
             return lambda;
         }
 
         public MessageID MessageID { get { return Data.MessageID; } }
 
-        public NamedTypeSymbol? InferDelegateType(ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)
-            => Data.InferDelegateType(ref useSiteInfo);
-
         public BoundLambda Bind(NamedTypeSymbol delegateType, bool isExpressionTree)
             => SuppressIfNeeded(Data.Bind(delegateType, isExpressionTree));
 
@@ -571,7 +579,7 @@ private static TypeWithAnnotations DelegateReturnTypeWithAnnotations(MethodSymbo
             return invokeMethod.ReturnTypeWithAnnotations;
         }
 
-        internal NamedTypeSymbol? InferDelegateType(ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)
+        internal NamedTypeSymbol? InferDelegateType()
         {
             Debug.Assert(Binder.ContainingMemberOrLambda is { });
 
@@ -626,8 +634,7 @@ private static TypeWithAnnotations DelegateReturnTypeWithAnnotations(MethodSymbo
                 returnRefKind,
                 returnType.Type?.IsVoidType() == true ? default : returnType,
                 parameterRefKinds,
-                parameterTypes,
-                ref useSiteInfo);
+                parameterTypes);
         }
 
         private BoundLambda ReallyBind(NamedTypeSymbol delegateType, bool inExpressionTree)
diff --git a/src/Compilers/CSharp/Portable/CommandLine/CSharpCompiler.cs b/src/Compilers/CSharp/Portable/CommandLine/CSharpCompiler.cs
index 11aab0a785c20..64777db3b8094 100644
--- a/src/Compilers/CSharp/Portable/CommandLine/CSharpCompiler.cs
+++ b/src/Compilers/CSharp/Portable/CommandLine/CSharpCompiler.cs
@@ -25,8 +25,8 @@ internal abstract class CSharpCompiler : CommonCompiler
         private readonly CommandLineDiagnosticFormatter _diagnosticFormatter;
         private readonly string? _tempDirectory;
 
-        protected CSharpCompiler(CSharpCommandLineParser parser, string? responseFile, string[] args, BuildPaths buildPaths, string? additionalReferenceDirectories, IAnalyzerAssemblyLoader assemblyLoader)
-            : base(parser, responseFile, args, buildPaths, additionalReferenceDirectories, assemblyLoader)
+        protected CSharpCompiler(CSharpCommandLineParser parser, string? responseFile, string[] args, BuildPaths buildPaths, string? additionalReferenceDirectories, IAnalyzerAssemblyLoader assemblyLoader, GeneratorDriverCache? driverCache = null)
+            : base(parser, responseFile, args, buildPaths, additionalReferenceDirectories, assemblyLoader, driverCache)
         {
             _diagnosticFormatter = new CommandLineDiagnosticFormatter(buildPaths.WorkingDirectory, Arguments.PrintFullPaths, Arguments.ShouldIncludeErrorEndLocation);
             _tempDirectory = buildPaths.TempDirectory;
@@ -372,12 +372,9 @@ protected override void ResolveEmbeddedFilesFromExternalSourceDirectives(
             }
         }
 
-        private protected override Compilation RunGenerators(Compilation input, ParseOptions parseOptions, ImmutableArray<ISourceGenerator> generators, AnalyzerConfigOptionsProvider analyzerConfigProvider, ImmutableArray<AdditionalText> additionalTexts, DiagnosticBag diagnostics)
+        private protected override GeneratorDriver CreateGeneratorDriver(ParseOptions parseOptions, ImmutableArray<ISourceGenerator> generators, AnalyzerConfigOptionsProvider analyzerConfigOptionsProvider, ImmutableArray<AdditionalText> additionalTexts)
         {
-            var driver = CSharpGeneratorDriver.Create(generators, additionalTexts, (CSharpParseOptions)parseOptions, analyzerConfigProvider);
-            driver.RunGeneratorsAndUpdateCompilation(input, out var compilationOut, out var generatorDiagnostics);
-            diagnostics.AddRange(generatorDiagnostics);
-            return compilationOut;
+            return CSharpGeneratorDriver.Create(generators, additionalTexts, (CSharpParseOptions)parseOptions, analyzerConfigOptionsProvider);
         }
     }
 }
diff --git a/src/Compilers/CSharp/Portable/Emitter/EditAndContinue/CSharpSymbolMatcher.cs b/src/Compilers/CSharp/Portable/Emitter/EditAndContinue/CSharpSymbolMatcher.cs
index 37ffd8bf4425d..0fa5603c6d141 100644
--- a/src/Compilers/CSharp/Portable/Emitter/EditAndContinue/CSharpSymbolMatcher.cs
+++ b/src/Compilers/CSharp/Portable/Emitter/EditAndContinue/CSharpSymbolMatcher.cs
@@ -26,6 +26,7 @@ internal sealed class CSharpSymbolMatcher : SymbolMatcher
 
         public CSharpSymbolMatcher(
             IReadOnlyDictionary<AnonymousTypeKey, AnonymousTypeValue> anonymousTypeMap,
+            IReadOnlyDictionary<SynthesizedDelegateKey, SynthesizedDelegateValue> synthesizedDelegates,
             SourceAssemblySymbol sourceAssembly,
             EmitContext sourceContext,
             SourceAssemblySymbol otherAssembly,
@@ -33,11 +34,12 @@ public CSharpSymbolMatcher(
             ImmutableDictionary<ISymbolInternal, ImmutableArray<ISymbolInternal>> otherSynthesizedMembersOpt)
         {
             _defs = new MatchDefsToSource(sourceContext, otherContext);
-            _symbols = new MatchSymbols(anonymousTypeMap, sourceAssembly, otherAssembly, otherSynthesizedMembersOpt, new DeepTranslator(otherAssembly.GetSpecialType(SpecialType.System_Object)));
+            _symbols = new MatchSymbols(anonymousTypeMap, synthesizedDelegates, sourceAssembly, otherAssembly, otherSynthesizedMembersOpt, new DeepTranslator(otherAssembly.GetSpecialType(SpecialType.System_Object)));
         }
 
         public CSharpSymbolMatcher(
             IReadOnlyDictionary<AnonymousTypeKey, AnonymousTypeValue> anonymousTypeMap,
+            IReadOnlyDictionary<SynthesizedDelegateKey, SynthesizedDelegateValue> synthesizedDelegates,
             SourceAssemblySymbol sourceAssembly,
             EmitContext sourceContext,
             PEAssemblySymbol otherAssembly)
@@ -46,6 +48,7 @@ public CSharpSymbolMatcher(
 
             _symbols = new MatchSymbols(
                 anonymousTypeMap,
+                synthesizedDelegates,
                 sourceAssembly,
                 otherAssembly,
                 otherSynthesizedMembers: null,
@@ -273,6 +276,7 @@ public MatchDefsToSource(
         private sealed class MatchSymbols : CSharpSymbolVisitor<Symbol?>
         {
             private readonly IReadOnlyDictionary<AnonymousTypeKey, AnonymousTypeValue> _anonymousTypeMap;
+            private readonly IReadOnlyDictionary<SynthesizedDelegateKey, SynthesizedDelegateValue> _synthesizedDelegates;
             private readonly SourceAssemblySymbol _sourceAssembly;
 
             // metadata or source assembly:
@@ -297,12 +301,14 @@ private sealed class MatchSymbols : CSharpSymbolVisitor<Symbol?>
 
             public MatchSymbols(
                 IReadOnlyDictionary<AnonymousTypeKey, AnonymousTypeValue> anonymousTypeMap,
+                IReadOnlyDictionary<SynthesizedDelegateKey, SynthesizedDelegateValue> synthesizedDelegates,
                 SourceAssemblySymbol sourceAssembly,
                 AssemblySymbol otherAssembly,
                 ImmutableDictionary<ISymbolInternal, ImmutableArray<ISymbolInternal>>? otherSynthesizedMembers,
                 DeepTranslator? deepTranslator)
             {
                 _anonymousTypeMap = anonymousTypeMap;
+                _synthesizedDelegates = synthesizedDelegates;
                 _sourceAssembly = sourceAssembly;
                 _otherAssembly = otherAssembly;
                 _otherSynthesizedMembers = otherSynthesizedMembers;
@@ -528,6 +534,12 @@ public override Symbol VisitDynamicType(DynamicTypeSymbol symbol)
                             TryFindAnonymousType(template, out var value);
                             return (NamedTypeSymbol?)value.Type?.GetInternalSymbol();
                         }
+                        else if (sourceType is SynthesizedDelegateSymbol delegateSymbol)
+                        {
+                            Debug.Assert((object)otherContainer == (object)_otherAssembly.GlobalNamespace);
+                            TryFindSynthesizedDelegate(delegateSymbol, out var value);
+                            return (NamedTypeSymbol?)value.Delegate?.GetInternalSymbol();
+                        }
 
                         if (sourceType.IsAnonymousType)
                         {
@@ -650,6 +662,14 @@ internal bool TryFindAnonymousType(AnonymousTypeManager.AnonymousTypeTemplateSym
                 return _anonymousTypeMap.TryGetValue(type.GetAnonymousTypeKey(), out otherType);
             }
 
+            internal bool TryFindSynthesizedDelegate(SynthesizedDelegateSymbol delegateSymbol, out SynthesizedDelegateValue otherDelegateSymbol)
+            {
+                Debug.Assert((object)delegateSymbol.ContainingSymbol == (object)_sourceAssembly.GlobalNamespace);
+
+                var key = new SynthesizedDelegateKey(delegateSymbol.MetadataName);
+                return _synthesizedDelegates.TryGetValue(key, out otherDelegateSymbol);
+            }
+
             private Symbol? VisitNamedTypeMember<T>(T member, Func<T, T, bool> predicate)
                 where T : Symbol
             {
diff --git a/src/Compilers/CSharp/Portable/Emitter/EditAndContinue/EmitHelpers.cs b/src/Compilers/CSharp/Portable/Emitter/EditAndContinue/EmitHelpers.cs
index f3dd7b2c57a04..d996f499c3086 100644
--- a/src/Compilers/CSharp/Portable/Emitter/EditAndContinue/EmitHelpers.cs
+++ b/src/Compilers/CSharp/Portable/Emitter/EditAndContinue/EmitHelpers.cs
@@ -140,12 +140,14 @@ private static EmitBaseline MapToCompilation(
 
             // Mapping from previous compilation to the current.
             var anonymousTypeMap = moduleBeingBuilt.GetAnonymousTypeMap();
+            var synthesizedDelegates = moduleBeingBuilt.GetSynthesizedDelegates();
             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,
                 sourceAssembly,
                 sourceContext,
                 compilation.SourceAssembly,
@@ -157,6 +159,7 @@ private static EmitBaseline MapToCompilation(
             // TODO: can we reuse some data from the previous matcher?
             var matcherWithAllSynthesizedMembers = new CSharpSymbolMatcher(
                 anonymousTypeMap,
+                synthesizedDelegates,
                 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 99ef0e9ca04b1..f3f674f209c65 100644
--- a/src/Compilers/CSharp/Portable/Emitter/EditAndContinue/PEDeltaAssemblyBuilder.cs
+++ b/src/Compilers/CSharp/Portable/Emitter/EditAndContinue/PEDeltaAssemblyBuilder.cs
@@ -47,7 +47,7 @@ public PEDeltaAssemblyBuilder(
             var metadataDecoder = (MetadataDecoder)metadataSymbols.MetadataDecoder;
             var metadataAssembly = (PEAssemblySymbol)metadataDecoder.ModuleSymbol.ContainingAssembly;
 
-            var matchToMetadata = new CSharpSymbolMatcher(metadataSymbols.AnonymousTypes, sourceAssembly, context, metadataAssembly);
+            var matchToMetadata = new CSharpSymbolMatcher(metadataSymbols.AnonymousTypes, metadataSymbols.SynthesizedDelegates, sourceAssembly, context, metadataAssembly);
 
             CSharpSymbolMatcher? matchToPrevious = null;
             if (previousGeneration.Ordinal > 0)
@@ -60,6 +60,7 @@ public PEDeltaAssemblyBuilder(
 
                 matchToPrevious = new CSharpSymbolMatcher(
                     previousGeneration.AnonymousTypeMap,
+                    previousGeneration.SynthesizedDelegates,
                     sourceAssembly: sourceAssembly,
                     sourceContext: context,
                     otherAssembly: previousAssembly,
@@ -116,7 +117,8 @@ private static EmitBaseline.MetadataSymbols GetOrCreateMetadataSymbols(EmitBasel
             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 metadataSymbols = new EmitBaseline.MetadataSymbols(metadataAnonymousTypes, metadataDecoder, assemblyReferenceIdentityMap);
+            var metadataSynthesizedDelegates = GetSynthesizedDelegateMapFromMetadata(originalMetadata.MetadataReader, metadataDecoder);
+            var metadataSymbols = new EmitBaseline.MetadataSymbols(metadataAnonymousTypes, metadataSynthesizedDelegates, metadataDecoder, assemblyReferenceIdentityMap);
 
             return InterlockedOperations.Initialize(ref initialBaseline.LazyMetadataSymbols, metadataSymbols);
         }
@@ -164,6 +166,37 @@ internal static IReadOnlyDictionary<AnonymousTypeKey, AnonymousTypeValue> GetAno
             return result;
         }
 
+        // internal for testing
+        internal static IReadOnlyDictionary<SynthesizedDelegateKey, SynthesizedDelegateValue> GetSynthesizedDelegateMapFromMetadata(MetadataReader reader, MetadataDecoder metadataDecoder)
+        {
+            var result = new Dictionary<SynthesizedDelegateKey, SynthesizedDelegateValue>();
+            foreach (var handle in reader.TypeDefinitions)
+            {
+                var def = reader.GetTypeDefinition(handle);
+                if (!def.Namespace.IsNil)
+                {
+                    continue;
+                }
+
+                if (!reader.StringComparer.StartsWith(def.Name, GeneratedNames.ActionDelegateNamePrefix) &&
+                    !reader.StringComparer.StartsWith(def.Name, GeneratedNames.FuncDelegateNamePrefix))
+                {
+                    continue;
+                }
+
+                // The name of a synthesized delegate neatly encodes everything we need to identify it, either
+                // in the prefix (return void or not) or the name (ref kinds and arity) so we don't need anything
+                // fancy for a key.
+                var metadataName = reader.GetString(def.Name);
+                var key = new SynthesizedDelegateKey(metadataName);
+
+                var type = (NamedTypeSymbol)metadataDecoder.GetTypeOfToken(handle);
+                var value = new SynthesizedDelegateValue(type.GetCciAdapter());
+                result.Add(key, value);
+            }
+            return result;
+        }
+
         private static bool TryGetAnonymousTypeKey(
             MetadataReader reader,
             TypeDefinition def,
@@ -205,6 +238,14 @@ public IReadOnlyDictionary<AnonymousTypeKey, AnonymousTypeValue> GetAnonymousTyp
             return anonymousTypes;
         }
 
+        public IReadOnlyDictionary<SynthesizedDelegateKey, SynthesizedDelegateValue> GetSynthesizedDelegates()
+        {
+            var synthesizedDelegates = this.Compilation.AnonymousTypeManager.GetSynthesizedDelegates();
+            // Should contain all entries in previous generation.
+            Debug.Assert(_previousGeneration.SynthesizedDelegates.All(p => synthesizedDelegates.ContainsKey(p.Key)));
+            return synthesizedDelegates;
+        }
+
         public override IEnumerable<Cci.INamespaceTypeDefinition> GetTopLevelTypeDefinitions(EmitContext context)
         {
             foreach (var typeDef in GetAnonymousTypeDefinitions(context))
@@ -233,6 +274,11 @@ internal override ImmutableArray<AnonymousTypeKey> GetPreviousAnonymousTypes()
             return ImmutableArray.CreateRange(_previousGeneration.AnonymousTypeMap.Keys);
         }
 
+        internal override ImmutableArray<SynthesizedDelegateKey> GetPreviousSynthesizedDelegates()
+        {
+            return ImmutableArray.CreateRange(_previousGeneration.SynthesizedDelegates.Keys);
+        }
+
         internal override int GetNextAnonymousTypeIndex()
         {
             return _previousGeneration.GetNextAnonymousTypeIndex();
diff --git a/src/Compilers/CSharp/Portable/Emitter/Model/PEModuleBuilder.cs b/src/Compilers/CSharp/Portable/Emitter/Model/PEModuleBuilder.cs
index 9fbe0b1600ccf..622b37a11a41e 100644
--- a/src/Compilers/CSharp/Portable/Emitter/Model/PEModuleBuilder.cs
+++ b/src/Compilers/CSharp/Portable/Emitter/Model/PEModuleBuilder.cs
@@ -382,6 +382,11 @@ internal virtual ImmutableArray<AnonymousTypeKey> GetPreviousAnonymousTypes()
             return ImmutableArray<AnonymousTypeKey>.Empty;
         }
 
+        internal virtual ImmutableArray<SynthesizedDelegateKey> GetPreviousSynthesizedDelegates()
+        {
+            return ImmutableArray<SynthesizedDelegateKey>.Empty;
+        }
+
         internal virtual int GetNextAnonymousTypeIndex()
         {
             return 0;
diff --git a/src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs b/src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs
index 445fd9963f57c..772a97c76decc 100644
--- a/src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs
+++ b/src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs
@@ -6127,7 +6127,7 @@ internal MethodInferenceExtensions(NullableWalker walker)
 
             internal override TypeWithAnnotations GetTypeWithAnnotations(BoundExpression expr)
             {
-                return TypeWithAnnotations.Create(expr.Type, GetNullableAnnotation(expr));
+                return TypeWithAnnotations.Create(expr.GetTypeOrFunctionType(), GetNullableAnnotation(expr));
             }
 
             /// <summary>
@@ -6974,9 +6974,7 @@ private TypeWithState VisitConversion(
                         {
                             NamedTypeSymbol { TypeKind: TypeKind.Delegate, DelegateInvokeMethod: { Parameters: { } parameters } signature } => (signature, parameters),
                             FunctionPointerTypeSymbol { Signature: { Parameters: { } parameters } signature } => (signature, parameters),
-                            { SpecialType: SpecialType.System_Delegate } => (null, ImmutableArray<ParameterSymbol>.Empty),
-                            ErrorTypeSymbol => (null, ImmutableArray<ParameterSymbol>.Empty),
-                            _ => throw ExceptionUtilities.UnexpectedValue(targetType)
+                            _ => (null, ImmutableArray<ParameterSymbol>.Empty),
                         };
 
                 case ConversionKind.AnonymousFunction:
@@ -6995,6 +6993,10 @@ private TypeWithState VisitConversion(
                     }
                     break;
 
+                case ConversionKind.FunctionType:
+                    resultState = NullableFlowState.NotNull;
+                    break;
+
                 case ConversionKind.InterpolatedString:
                     resultState = NullableFlowState.NotNull;
                     break;
diff --git a/src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker_Patterns.cs b/src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker_Patterns.cs
index 010be6c6de555..f316001aaafa7 100644
--- a/src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker_Patterns.cs
+++ b/src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker_Patterns.cs
@@ -228,10 +228,6 @@ protected override LocalState VisitSwitchStatementDispatch(BoundSwitchStatement
                 }
             }
 
-            // visit switch header
-            Visit(node.Expression);
-            var expressionState = ResultType;
-
             DeclareLocals(node.InnerLocals);
             foreach (var section in node.SwitchSections)
             {
@@ -239,6 +235,10 @@ protected override LocalState VisitSwitchStatementDispatch(BoundSwitchStatement
                 DeclareLocals(section.Locals);
             }
 
+            // visit switch header
+            Visit(node.Expression);
+            var expressionState = ResultType;
+
             var labelStateMap = LearnFromDecisionDag(node.Syntax, node.DecisionDag, node.Expression, expressionState, stateWhenNotNullOpt: null);
             foreach (var section in node.SwitchSections)
             {
diff --git a/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs b/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs
index cad641a418aab..e9222f997d347 100644
--- a/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs
+++ b/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs
@@ -5587,7 +5587,7 @@ public BoundComplexConditionalReceiver Update(BoundExpression valueTypeReceiver,
 
     internal sealed partial class BoundMethodGroup : BoundMethodOrPropertyGroup
     {
-        public BoundMethodGroup(SyntaxNode syntax, ImmutableArray<TypeWithAnnotations> typeArgumentsOpt, string name, ImmutableArray<MethodSymbol> methods, Symbol? lookupSymbolOpt, DiagnosticInfo? lookupError, BoundMethodGroupFlags? flags, BoundExpression? receiverOpt, LookupResultKind resultKind, bool hasErrors = false)
+        public BoundMethodGroup(SyntaxNode syntax, ImmutableArray<TypeWithAnnotations> typeArgumentsOpt, string name, ImmutableArray<MethodSymbol> methods, Symbol? lookupSymbolOpt, DiagnosticInfo? lookupError, BoundMethodGroupFlags? flags, FunctionTypeSymbol.Lazy? functionType, BoundExpression? receiverOpt, LookupResultKind resultKind, bool hasErrors = false)
             : base(BoundKind.MethodGroup, syntax, receiverOpt, resultKind, hasErrors || receiverOpt.HasErrors())
         {
 
@@ -5600,6 +5600,7 @@ public BoundMethodGroup(SyntaxNode syntax, ImmutableArray<TypeWithAnnotations> t
             this.LookupSymbolOpt = lookupSymbolOpt;
             this.LookupError = lookupError;
             this.Flags = flags;
+            this.FunctionType = functionType;
         }
 
 
@@ -5614,14 +5615,16 @@ public BoundMethodGroup(SyntaxNode syntax, ImmutableArray<TypeWithAnnotations> t
         public DiagnosticInfo? LookupError { get; }
 
         public BoundMethodGroupFlags? Flags { get; }
+
+        public FunctionTypeSymbol.Lazy? FunctionType { get; }
         [DebuggerStepThrough]
         public override BoundNode? Accept(BoundTreeVisitor visitor) => visitor.VisitMethodGroup(this);
 
-        public BoundMethodGroup Update(ImmutableArray<TypeWithAnnotations> typeArgumentsOpt, string name, ImmutableArray<MethodSymbol> methods, Symbol? lookupSymbolOpt, DiagnosticInfo? lookupError, BoundMethodGroupFlags? flags, BoundExpression? receiverOpt, LookupResultKind resultKind)
+        public BoundMethodGroup Update(ImmutableArray<TypeWithAnnotations> typeArgumentsOpt, string name, ImmutableArray<MethodSymbol> methods, Symbol? lookupSymbolOpt, DiagnosticInfo? lookupError, BoundMethodGroupFlags? flags, FunctionTypeSymbol.Lazy? functionType, BoundExpression? receiverOpt, LookupResultKind resultKind)
         {
-            if (typeArgumentsOpt != this.TypeArgumentsOpt || name != this.Name || methods != this.Methods || !Symbols.SymbolEqualityComparer.ConsiderEverything.Equals(lookupSymbolOpt, this.LookupSymbolOpt) || lookupError != this.LookupError || flags != this.Flags || receiverOpt != this.ReceiverOpt || resultKind != this.ResultKind)
+            if (typeArgumentsOpt != this.TypeArgumentsOpt || name != this.Name || methods != this.Methods || !Symbols.SymbolEqualityComparer.ConsiderEverything.Equals(lookupSymbolOpt, this.LookupSymbolOpt) || lookupError != this.LookupError || flags != this.Flags || functionType != this.FunctionType || receiverOpt != this.ReceiverOpt || resultKind != this.ResultKind)
             {
-                var result = new BoundMethodGroup(this.Syntax, typeArgumentsOpt, name, methods, lookupSymbolOpt, lookupError, flags, receiverOpt, resultKind, this.HasErrors);
+                var result = new BoundMethodGroup(this.Syntax, typeArgumentsOpt, name, methods, lookupSymbolOpt, lookupError, flags, functionType, receiverOpt, resultKind, this.HasErrors);
                 result.CopyAttributes(this);
                 return result;
             }
@@ -7028,23 +7031,25 @@ public BoundLambda Update(UnboundLambda unboundLambda, LambdaSymbol symbol, Boun
 
     internal sealed partial class UnboundLambda : BoundExpression
     {
-        public UnboundLambda(SyntaxNode syntax, UnboundLambdaState data, Boolean withDependencies, bool hasErrors)
+        public UnboundLambda(SyntaxNode syntax, UnboundLambdaState data, FunctionTypeSymbol.Lazy? functionType, Boolean withDependencies, bool hasErrors)
             : base(BoundKind.UnboundLambda, syntax, null, hasErrors)
         {
 
             RoslynDebug.Assert(data is object, "Field 'data' cannot be null (make the type nullable in BoundNodes.xml to remove this check)");
 
             this.Data = data;
+            this.FunctionType = functionType;
             this.WithDependencies = withDependencies;
         }
 
-        public UnboundLambda(SyntaxNode syntax, UnboundLambdaState data, Boolean withDependencies)
+        public UnboundLambda(SyntaxNode syntax, UnboundLambdaState data, FunctionTypeSymbol.Lazy? functionType, Boolean withDependencies)
             : base(BoundKind.UnboundLambda, syntax, null)
         {
 
             RoslynDebug.Assert(data is object, "Field 'data' cannot be null (make the type nullable in BoundNodes.xml to remove this check)");
 
             this.Data = data;
+            this.FunctionType = functionType;
             this.WithDependencies = withDependencies;
         }
 
@@ -7053,15 +7058,17 @@ public UnboundLambda(SyntaxNode syntax, UnboundLambdaState data, Boolean withDep
 
         public UnboundLambdaState Data { get; }
 
+        public FunctionTypeSymbol.Lazy? FunctionType { get; }
+
         public Boolean WithDependencies { get; }
         [DebuggerStepThrough]
         public override BoundNode? Accept(BoundTreeVisitor visitor) => visitor.VisitUnboundLambda(this);
 
-        public UnboundLambda Update(UnboundLambdaState data, Boolean withDependencies)
+        public UnboundLambda Update(UnboundLambdaState data, FunctionTypeSymbol.Lazy? functionType, Boolean withDependencies)
         {
-            if (data != this.Data || withDependencies != this.WithDependencies)
+            if (data != this.Data || functionType != this.FunctionType || withDependencies != this.WithDependencies)
             {
-                var result = new UnboundLambda(this.Syntax, data, withDependencies, this.HasErrors);
+                var result = new UnboundLambda(this.Syntax, data, functionType, withDependencies, this.HasErrors);
                 result.CopyAttributes(this);
                 return result;
             }
@@ -10745,7 +10752,7 @@ internal abstract partial class BoundTreeRewriter : BoundTreeVisitor
         {
             BoundExpression? receiverOpt = (BoundExpression?)this.Visit(node.ReceiverOpt);
             TypeSymbol? type = this.VisitType(node.Type);
-            return node.Update(node.TypeArgumentsOpt, node.Name, node.Methods, node.LookupSymbolOpt, node.LookupError, node.Flags, receiverOpt, node.ResultKind);
+            return node.Update(node.TypeArgumentsOpt, node.Name, node.Methods, node.LookupSymbolOpt, node.LookupError, node.Flags, node.FunctionType, receiverOpt, node.ResultKind);
         }
         public override BoundNode? VisitPropertyGroup(BoundPropertyGroup node)
         {
@@ -10966,7 +10973,7 @@ internal abstract partial class BoundTreeRewriter : BoundTreeVisitor
         public override BoundNode? VisitUnboundLambda(UnboundLambda node)
         {
             TypeSymbol? type = this.VisitType(node.Type);
-            return node.Update(node.Data, node.WithDependencies);
+            return node.Update(node.Data, node.FunctionType, node.WithDependencies);
         }
         public override BoundNode? VisitQueryClause(BoundQueryClause node)
         {
@@ -12611,12 +12618,12 @@ public NullabilityRewriter(ImmutableDictionary<BoundExpression, (NullabilityInfo
 
             if (_updatedNullabilities.TryGetValue(node, out (NullabilityInfo Info, TypeSymbol? Type) infoAndType))
             {
-                updatedNode = node.Update(node.TypeArgumentsOpt, node.Name, methods, lookupSymbolOpt, node.LookupError, node.Flags, receiverOpt, node.ResultKind);
+                updatedNode = node.Update(node.TypeArgumentsOpt, node.Name, methods, lookupSymbolOpt, node.LookupError, node.Flags, node.FunctionType, receiverOpt, node.ResultKind);
                 updatedNode.TopLevelNullability = infoAndType.Info;
             }
             else
             {
-                updatedNode = node.Update(node.TypeArgumentsOpt, node.Name, methods, lookupSymbolOpt, node.LookupError, node.Flags, receiverOpt, node.ResultKind);
+                updatedNode = node.Update(node.TypeArgumentsOpt, node.Name, methods, lookupSymbolOpt, node.LookupError, node.Flags, node.FunctionType, receiverOpt, node.ResultKind);
             }
             return updatedNode;
         }
@@ -13227,7 +13234,7 @@ public NullabilityRewriter(ImmutableDictionary<BoundExpression, (NullabilityInfo
                 return node;
             }
 
-            UnboundLambda updatedNode = node.Update(node.Data, node.WithDependencies);
+            UnboundLambda updatedNode = node.Update(node.Data, node.FunctionType, node.WithDependencies);
             updatedNode.TopLevelNullability = infoAndType.Info;
             return updatedNode;
         }
@@ -14824,6 +14831,7 @@ private BoundTreeDumperNodeProducer()
             new TreeDumperNode("lookupSymbolOpt", node.LookupSymbolOpt, null),
             new TreeDumperNode("lookupError", node.LookupError, null),
             new TreeDumperNode("flags", node.Flags, null),
+            new TreeDumperNode("functionType", node.FunctionType, null),
             new TreeDumperNode("receiverOpt", null, new TreeDumperNode[] { Visit(node.ReceiverOpt, null) }),
             new TreeDumperNode("resultKind", node.ResultKind, null),
             new TreeDumperNode("type", node.Type, null),
@@ -15203,6 +15211,7 @@ private BoundTreeDumperNodeProducer()
         public override TreeDumperNode VisitUnboundLambda(UnboundLambda node, object? arg) => new TreeDumperNode("unboundLambda", null, new TreeDumperNode[]
         {
             new TreeDumperNode("data", node.Data, null),
+            new TreeDumperNode("functionType", node.FunctionType, null),
             new TreeDumperNode("withDependencies", node.WithDependencies, null),
             new TreeDumperNode("type", node.Type, null),
             new TreeDumperNode("isSuppressed", node.IsSuppressed, null),
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.DecisionDagRewriter.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.DecisionDagRewriter.cs
index 14c2af0a96082..f78f57a556add 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.DecisionDagRewriter.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.DecisionDagRewriter.cs
@@ -13,6 +13,7 @@
 using Microsoft.CodeAnalysis.CSharp.Symbols;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Roslyn.Utilities;
+using static Microsoft.CodeAnalysis.CSharp.SyntheticBoundNodeFactory;
 
 namespace Microsoft.CodeAnalysis.CSharp
 {
@@ -40,6 +41,16 @@ private abstract partial class DecisionDagRewriter : PatternLocalRewriter
             /// </summary>
             protected readonly PooledDictionary<BoundDecisionDagNode, LabelSymbol> _dagNodeLabels = PooledDictionary<BoundDecisionDagNode, LabelSymbol>.GetInstance();
 
+#nullable enable
+            // When different branches of the DAG share `when` expressions, the
+            // shared expression will be lowered as a shared section and the `when` nodes that need
+            // to will jump there. After the expression is evaluated, we need to jump to different
+            // labels depending on the `when` node we came from. To achieve that, each `when` node
+            // gets an identifier and sets a local before jumping into the shared `when` expression.
+            private int _nextWhenNodeIdentifier = 0;
+            internal LocalSymbol? _whenNodeIdentifierLocal;
+#nullable disable
+
             protected DecisionDagRewriter(
                 SyntaxNode node,
                 LocalRewriter localRewriter,
@@ -372,13 +383,7 @@ protected ImmutableArray<BoundStatement> LowerDecisionDagCore(BoundDecisionDag d
                 }
 
                 // Code for each when clause goes in the separate code section for its switch section.
-                foreach (BoundDecisionDagNode node in sortedNodes)
-                {
-                    if (node is BoundWhenDecisionDagNode w)
-                    {
-                        LowerWhenClause(w);
-                    }
-                }
+                LowerWhenClauses(sortedNodes);
 
                 ImmutableArray<BoundDecisionDagNode> nodesToLower = sortedNodes.WhereAsArray(n => n.Kind != BoundKind.WhenDecisionDagNode && n.Kind != BoundKind.LeafDecisionDagNode);
                 var loweredNodes = PooledHashSet<BoundDecisionDagNode>.GetInstance();
@@ -865,59 +870,230 @@ private void EnsureStringHashFunction(int labelsCount, SyntaxNode syntaxNode)
                 privateImplClass.TryAddSynthesizedMethod(method.GetCciAdapter());
             }
 
-            private void LowerWhenClause(BoundWhenDecisionDagNode whenClause)
+#nullable enable
+            private void LowerWhenClauses(ImmutableArray<BoundDecisionDagNode> sortedNodes)
             {
-                // This node is used even when there is no when clause, to record bindings. In the case that there
-                // is no when clause, whenClause.WhenExpression and whenClause.WhenFalse are null, and the syntax for this
-                // node is the case clause.
-
-                // We need to assign the pattern variables in the code where they are in scope, so we produce a branch
-                // to the section where they are in scope and evaluate the when clause there.
-                var whenTrue = (BoundLeafDecisionDagNode)whenClause.WhenTrue;
-                LabelSymbol labelToSectionScope = GetDagNodeLabel(whenClause);
-
-                ArrayBuilder<BoundStatement> sectionBuilder = BuilderForSection(whenClause.Syntax);
-                sectionBuilder.Add(_factory.Label(labelToSectionScope));
-                foreach (BoundPatternBinding binding in whenClause.Bindings)
-                {
-                    BoundExpression left = _localRewriter.VisitExpression(binding.VariableAccess);
-                    // Since a switch does not add variables to the enclosing scope, the pattern variables
-                    // are locals even in a script and rewriting them should have no effect.
-                    Debug.Assert(left.Kind == BoundKind.Local && left == binding.VariableAccess);
-                    BoundExpression right = _tempAllocator.GetTemp(binding.TempContainingValue);
-                    if (left != right)
+                if (!sortedNodes.Any(n => n.Kind == BoundKind.WhenDecisionDagNode)) return;
+
+                // The way the DAG is prepared, it is possible for different `BoundWhenDecisionDagNode` nodes to
+                // share the same `WhenExpression` (same `BoundExpression` instance).
+                // So we can't just lower each `BoundWhenDecisionDagNode` separately, as that would result in duplicate blocks
+                // for the same `WhenExpression` and such expressions might contains labels which must be emitted once only.
+
+                // For a simple `BoundWhenDecisionDagNode` (with a unique `WhenExpression`), we lower to something like:
+                //   labelToSectionScope;
+                //   if (... logic from WhenExpression ...)
+                //   {
+                //     jump to whenTrue label
+                //   }
+                //   jump to whenFalse label
+
+                // For a complex `BoundWhenDecisionDagNode` (where the `WhenExpression` is shared), we lower to something like:
+                //   labelToSectionScope;
+                //   whenNodeIdentifierLocal = whenNodeIdentifier;
+                //   goto labelToWhenExpression;
+                //
+                // and we'll also create a section for the shared `WhenExpression` logic:
+                //   labelToWhenExpression;
+                //   if (... logic from WhenExpression ...)
+                //   {
+                //     jump to whenTrue label
+                //   }
+                //   switch on whenNodeIdentifierLocal with dispatches to whenFalse labels
+
+                // Prepared maps for `when` nodes and expressions
+                var whenExpressionMap = PooledDictionary<BoundExpression, (LabelSymbol LabelToWhenExpression, ArrayBuilder<BoundWhenDecisionDagNode> WhenNodes)>.GetInstance();
+                var whenNodeMap = PooledDictionary<BoundWhenDecisionDagNode, (LabelSymbol LabelToWhenExpression, int WhenNodeIdentifier)>.GetInstance();
+                foreach (BoundDecisionDagNode node in sortedNodes)
+                {
+                    if (node is BoundWhenDecisionDagNode whenNode)
+                    {
+                        var whenExpression = whenNode.WhenExpression;
+                        if (whenExpression is not null && whenExpression.ConstantValue != ConstantValue.True)
+                        {
+                            LabelSymbol labelToWhenExpression;
+                            if (whenExpressionMap.TryGetValue(whenExpression, out var whenExpressionInfo))
+                            {
+                                labelToWhenExpression = whenExpressionInfo.LabelToWhenExpression;
+                                whenExpressionInfo.WhenNodes.Add(whenNode);
+                            }
+                            else
+                            {
+                                labelToWhenExpression = _factory.GenerateLabel("sharedWhenExpression");
+                                var list = ArrayBuilder<BoundWhenDecisionDagNode>.GetInstance();
+                                list.Add(whenNode);
+                                whenExpressionMap.Add(whenExpression, (labelToWhenExpression, list));
+                            }
+
+                            whenNodeMap.Add(whenNode, (labelToWhenExpression, _nextWhenNodeIdentifier++));
+                        }
+                    }
+                }
+
+                // Lower nodes
+                foreach (BoundDecisionDagNode node in sortedNodes)
+                {
+                    if (node is BoundWhenDecisionDagNode whenNode)
+                    {
+                        if (!tryLowerAsJumpToSharedWhenExpression(whenNode))
+                        {
+                            lowerWhenClause(whenNode);
+                        }
+                    }
+                }
+
+                // Lower shared `when` expressions
+                foreach (var (whenExpression, (labelToWhenExpression, whenNodes)) in whenExpressionMap)
+                {
+                    lowerWhenExpressionIfShared(whenExpression, labelToWhenExpression, whenNodes);
+                    whenNodes.Free();
+                }
+
+                whenExpressionMap.Free();
+                whenNodeMap.Free();
+
+                return;
+
+                bool tryLowerAsJumpToSharedWhenExpression(BoundWhenDecisionDagNode whenNode)
+                {
+                    var whenExpression = whenNode.WhenExpression;
+                    if (!isSharedWhenExpression(whenExpression))
+                    {
+                        return false;
+                    }
+
+                    LabelSymbol labelToSectionScope = GetDagNodeLabel(whenNode);
+                    ArrayBuilder<BoundStatement> sectionBuilder = BuilderForSection(whenNode.Syntax);
+                    sectionBuilder.Add(_factory.Label(labelToSectionScope));
+
+                    _whenNodeIdentifierLocal ??= _factory.SynthesizedLocal(_factory.SpecialType(SpecialType.System_Int32));
+                    var found = whenNodeMap.TryGetValue(whenNode, out var whenNodeInfo);
+                    Debug.Assert(found);
+
+                    // whenNodeIdentifierLocal = whenNodeIdentifier;
+                    sectionBuilder.Add(_factory.Assignment(_factory.Local(_whenNodeIdentifierLocal), _factory.Literal(whenNodeInfo.WhenNodeIdentifier)));
+
+                    // goto labelToWhenExpression;
+                    sectionBuilder.Add(_factory.Goto(whenNodeInfo.LabelToWhenExpression));
+
+                    return true;
+                }
+
+                void lowerWhenExpressionIfShared(BoundExpression whenExpression, LabelSymbol labelToWhenExpression, ArrayBuilder<BoundWhenDecisionDagNode> whenNodes)
+                {
+                    if (!isSharedWhenExpression(whenExpression))
                     {
-                        sectionBuilder.Add(_factory.Assignment(left, right));
+                        return;
                     }
+
+                    var whenClauseSyntax = whenNodes[0].Syntax;
+                    var whenTrueLabel = GetDagNodeLabel(whenNodes[0].WhenTrue);
+                    Debug.Assert(whenNodes.Count > 1);
+                    Debug.Assert(whenNodes.All(n => n.Syntax == whenClauseSyntax));
+                    Debug.Assert(whenNodes.All(n => n.WhenExpression == whenExpression));
+                    Debug.Assert(whenNodes.All(n => n.Bindings == whenNodes[0].Bindings));
+                    Debug.Assert(whenNodes.All(n => GetDagNodeLabel(n.WhenTrue) == whenTrueLabel));
+
+                    ArrayBuilder<BoundStatement> sectionBuilder = BuilderForSection(whenClauseSyntax);
+                    sectionBuilder.Add(_factory.Label(labelToWhenExpression));
+                    lowerBindings(whenNodes[0].Bindings, sectionBuilder);
+                    addConditionalGoto(whenExpression, whenClauseSyntax, whenTrueLabel, sectionBuilder);
+
+                    var whenFalseSwitchSections = ArrayBuilder<SyntheticSwitchSection>.GetInstance();
+                    foreach (var whenNode in whenNodes)
+                    {
+                        var (_, whenNodeIdentifier) = whenNodeMap[whenNode];
+                        Debug.Assert(whenNode.WhenFalse != null);
+                        whenFalseSwitchSections.Add(_factory.SwitchSection(whenNodeIdentifier, _factory.Goto(GetDagNodeLabel(whenNode.WhenFalse))));
+                    }
+
+                    // switch (whenNodeIdentifierLocal)
+                    // {
+                    //   case whenNodeIdentifier: goto falseLabelForWhenNode;
+                    //   ...
+                    // }
+                    Debug.Assert(_whenNodeIdentifierLocal is not null);
+                    BoundStatement jumps = _factory.Switch(_factory.Local(_whenNodeIdentifierLocal), whenFalseSwitchSections.ToImmutableAndFree());
+
+                    // We hide the jump back into the decision dag, as it is not logically part of the when clause
+                    sectionBuilder.Add(GenerateInstrumentation ? _factory.HiddenSequencePoint(jumps) : jumps);
                 }
 
-                var whenFalse = whenClause.WhenFalse;
-                var trueLabel = GetDagNodeLabel(whenTrue);
-                if (whenClause.WhenExpression != null && whenClause.WhenExpression.ConstantValue != ConstantValue.True)
+                // if (loweredWhenExpression)
+                // {
+                //   jump to whenTrue label
+                // }
+                void addConditionalGoto(BoundExpression whenExpression, SyntaxNode whenClauseSyntax, LabelSymbol whenTrueLabel, ArrayBuilder<BoundStatement> sectionBuilder)
                 {
-                    _factory.Syntax = whenClause.Syntax;
-                    BoundStatement conditionalGoto = _factory.ConditionalGoto(_localRewriter.VisitExpression(whenClause.WhenExpression), trueLabel, jumpIfTrue: true);
+                    _factory.Syntax = whenClauseSyntax;
+                    BoundStatement conditionalGoto = _factory.ConditionalGoto(_localRewriter.VisitExpression(whenExpression), whenTrueLabel, jumpIfTrue: true);
 
                     // Only add instrumentation (such as a sequence point) if the node is not compiler-generated.
-                    if (GenerateInstrumentation && !whenClause.WhenExpression.WasCompilerGenerated)
+                    if (GenerateInstrumentation && !whenExpression.WasCompilerGenerated)
                     {
-                        conditionalGoto = _localRewriter._instrumenter.InstrumentSwitchWhenClauseConditionalGotoBody(whenClause.WhenExpression, conditionalGoto);
+                        conditionalGoto = _localRewriter._instrumenter.InstrumentSwitchWhenClauseConditionalGotoBody(whenExpression, conditionalGoto);
                     }
 
                     sectionBuilder.Add(conditionalGoto);
+                }
 
-                    Debug.Assert(whenFalse != null);
+                bool isSharedWhenExpression(BoundExpression? whenExpression)
+                {
+                    return whenExpression is not null
+                        && whenExpressionMap.TryGetValue(whenExpression, out var whenExpressionInfo)
+                        && whenExpressionInfo.WhenNodes.Count > 1;
+                }
 
-                    // We hide the jump back into the decision dag, as it is not logically part of the when clause
-                    BoundStatement jump = _factory.Goto(GetDagNodeLabel(whenFalse));
-                    sectionBuilder.Add(GenerateInstrumentation ? _factory.HiddenSequencePoint(jump) : jump);
+                void lowerWhenClause(BoundWhenDecisionDagNode whenClause)
+                {
+                    // This node is used even when there is no when clause, to record bindings. In the case that there
+                    // is no when clause, whenClause.WhenExpression and whenClause.WhenFalse are null, and the syntax for this
+                    // node is the case clause.
+
+                    // We need to assign the pattern variables in the code where they are in scope, so we produce a branch
+                    // to the section where they are in scope and evaluate the when clause there.
+                    var whenTrue = (BoundLeafDecisionDagNode)whenClause.WhenTrue;
+                    LabelSymbol labelToSectionScope = GetDagNodeLabel(whenClause);
+
+                    ArrayBuilder<BoundStatement> sectionBuilder = BuilderForSection(whenClause.Syntax);
+                    sectionBuilder.Add(_factory.Label(labelToSectionScope));
+                    lowerBindings(whenClause.Bindings, sectionBuilder);
+
+                    var whenFalse = whenClause.WhenFalse;
+                    var trueLabel = GetDagNodeLabel(whenTrue);
+                    if (whenClause.WhenExpression != null && whenClause.WhenExpression.ConstantValue != ConstantValue.True)
+                    {
+                        addConditionalGoto(whenClause.WhenExpression, whenClause.Syntax, trueLabel, sectionBuilder);
+
+                        // We hide the jump back into the decision dag, as it is not logically part of the when clause
+                        Debug.Assert(whenFalse != null);
+                        BoundStatement jump = _factory.Goto(GetDagNodeLabel(whenFalse));
+                        sectionBuilder.Add(GenerateInstrumentation ? _factory.HiddenSequencePoint(jump) : jump);
+                    }
+                    else
+                    {
+                        Debug.Assert(whenFalse == null);
+                        sectionBuilder.Add(_factory.Goto(trueLabel));
+                    }
                 }
-                else
+
+                void lowerBindings(ImmutableArray<BoundPatternBinding> bindings, ArrayBuilder<BoundStatement> sectionBuilder)
                 {
-                    Debug.Assert(whenFalse == null);
-                    sectionBuilder.Add(_factory.Goto(trueLabel));
+                    foreach (BoundPatternBinding binding in bindings)
+                    {
+                        BoundExpression left = _localRewriter.VisitExpression(binding.VariableAccess);
+                        // Since a switch does not add variables to the enclosing scope, the pattern variables
+                        // are locals even in a script and rewriting them should have no effect.
+                        Debug.Assert(left.Kind == BoundKind.Local && left == binding.VariableAccess);
+                        BoundExpression right = _tempAllocator.GetTemp(binding.TempContainingValue);
+                        if (left != right)
+                        {
+                            sectionBuilder.Add(_factory.Assignment(left, right));
+                        }
+                    }
                 }
             }
+#nullable disable
 
             /// <summary>
             /// Translate the decision dag for node, given that it will be followed by the translation for nextNode.
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_PatternSwitchStatement.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_PatternSwitchStatement.cs
index 701279a6f2ae6..e82caceede5d8 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_PatternSwitchStatement.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_PatternSwitchStatement.cs
@@ -112,6 +112,11 @@ private BoundStatement LowerSwitchStatement(BoundSwitchStatement node)
                 (ImmutableArray<BoundStatement> loweredDag, ImmutableDictionary<SyntaxNode, ImmutableArray<BoundStatement>> switchSections) =
                     LowerDecisionDag(decisionDag);
 
+                if (_whenNodeIdentifierLocal is not null)
+                {
+                    outerVariables.Add(_whenNodeIdentifierLocal);
+                }
+
                 // then add the rest of the lowered dag that references that input
                 result.Add(_factory.Block(loweredDag));
 
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_SwitchExpression.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_SwitchExpression.cs
index 9cc19e208351d..9214a7b639b0b 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_SwitchExpression.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_SwitchExpression.cs
@@ -60,6 +60,11 @@ private BoundExpression LowerSwitchExpression(BoundConvertedSwitchExpression nod
                 (ImmutableArray<BoundStatement> loweredDag, ImmutableDictionary<SyntaxNode, ImmutableArray<BoundStatement>> switchSections) =
                     LowerDecisionDag(decisionDag);
 
+                if (_whenNodeIdentifierLocal is not null)
+                {
+                    outerVariables.Add(_whenNodeIdentifierLocal);
+                }
+
                 if (produceDetailedSequencePoints)
                 {
                     var syntax = (SwitchExpressionSyntax)node.Syntax;
diff --git a/src/Compilers/CSharp/Portable/Symbols/AnonymousTypes/AnonymousTypeManager.Templates.cs b/src/Compilers/CSharp/Portable/Symbols/AnonymousTypes/AnonymousTypeManager.Templates.cs
index 0f0766e078a5f..41b60795c6158 100644
--- a/src/Compilers/CSharp/Portable/Symbols/AnonymousTypes/AnonymousTypeManager.Templates.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/AnonymousTypes/AnonymousTypeManager.Templates.cs
@@ -53,7 +53,7 @@ public SynthesizedDelegateKey(int parameterCount, RefKindVector byRefs, bool ret
 
             public string MakeTypeName()
             {
-                return GeneratedNames.MakeDynamicCallSiteDelegateName(_byRefs, _returnsVoid, _generation);
+                return GeneratedNames.MakeSynthesizedDelegateName(_byRefs, _returnsVoid, _generation);
             }
 
             public override bool Equals(object obj)
@@ -235,6 +235,19 @@ private AnonymousTypeTemplateSymbol CreatePlaceholderTemplate(Microsoft.CodeAnal
             return new AnonymousTypeTemplateSymbol(this, typeDescr);
         }
 
+        private SynthesizedDelegateValue CreatePlaceholderSynthesizedDelegateValue(string name, RefKindVector refKinds, bool returnsVoid, int parameterCount)
+        {
+            var symbol = new SynthesizedDelegateSymbol(
+               this.Compilation.Assembly.GlobalNamespace,
+               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>
         /// Resets numbering in anonymous type names and compiles the
         /// anonymous type methods. Also seals the collection of templates.
@@ -314,6 +327,17 @@ public void AssignTemplatesNamesAndCompile(MethodCompiler compiler, PEModuleBuil
 
             builder.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())
+            {
+                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));
+                }
+            }
+
             var synthesizedDelegates = ArrayBuilder<SynthesizedDelegateSymbol>.GetInstance();
             GetCreatedSynthesizedDelegates(synthesizedDelegates);
             foreach (var synthesizedDelegate in synthesizedDelegates)
@@ -376,6 +400,21 @@ public int Compare(SynthesizedDelegateSymbol x, SynthesizedDelegateSymbol y)
             }
         }
 
+        internal IReadOnlyDictionary<CodeAnalysis.Emit.SynthesizedDelegateKey, CodeAnalysis.Emit.SynthesizedDelegateValue> GetSynthesizedDelegates()
+        {
+            var result = new Dictionary<CodeAnalysis.Emit.SynthesizedDelegateKey, CodeAnalysis.Emit.SynthesizedDelegateValue>();
+            var synthesizedDelegates = ArrayBuilder<SynthesizedDelegateSymbol>.GetInstance();
+            GetCreatedSynthesizedDelegates(synthesizedDelegates);
+            foreach (var delegateSymbol in synthesizedDelegates)
+            {
+                var key = new CodeAnalysis.Emit.SynthesizedDelegateKey(delegateSymbol.MetadataName);
+                var value = new CodeAnalysis.Emit.SynthesizedDelegateValue(delegateSymbol.GetCciAdapter());
+                result.Add(key, value);
+            }
+            synthesizedDelegates.Free();
+            return result;
+        }
+
         internal IReadOnlyDictionary<Microsoft.CodeAnalysis.Emit.AnonymousTypeKey, Microsoft.CodeAnalysis.Emit.AnonymousTypeValue> GetAnonymousTypeMap()
         {
             var result = new Dictionary<Microsoft.CodeAnalysis.Emit.AnonymousTypeKey, Microsoft.CodeAnalysis.Emit.AnonymousTypeValue>();
diff --git a/src/Compilers/CSharp/Portable/Symbols/FunctionTypeSymbol.Lazy.cs b/src/Compilers/CSharp/Portable/Symbols/FunctionTypeSymbol.Lazy.cs
new file mode 100644
index 0000000000000..cfe4d7f8a8b6a
--- /dev/null
+++ b/src/Compilers/CSharp/Portable/Symbols/FunctionTypeSymbol.Lazy.cs
@@ -0,0 +1,68 @@
+// 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;
+using System.Threading;
+
+namespace Microsoft.CodeAnalysis.CSharp.Symbols
+{
+    internal sealed partial class FunctionTypeSymbol
+    {
+        /// <summary>
+        /// A lazily calculated instance of <see cref="FunctionTypeSymbol"/> that represents
+        /// the inferred signature of a lambda expression or method group.
+        /// The actual signature is calculated on demand in <see cref="GetValue()"/>.
+        /// </summary>
+        internal sealed class Lazy
+        {
+            private readonly Binder _binder;
+            private readonly Func<Binder, BoundExpression, NamedTypeSymbol?> _calculateDelegate;
+
+            private FunctionTypeSymbol? _lazyFunctionType;
+            private BoundExpression? _expression;
+
+            internal static Lazy? CreateIfFeatureEnabled(SyntaxNode syntax, Binder binder, Func<Binder, BoundExpression, NamedTypeSymbol?> calculateDelegate)
+            {
+                return syntax.IsFeatureEnabled(MessageID.IDS_FeatureInferredDelegateType) ?
+                    new Lazy(binder, calculateDelegate) :
+                    null;
+            }
+
+            private Lazy(Binder binder, Func<Binder, BoundExpression, NamedTypeSymbol?> calculateDelegate)
+            {
+                _binder = binder;
+                _calculateDelegate = calculateDelegate;
+                _lazyFunctionType = FunctionTypeSymbol.Uninitialized;
+            }
+
+            internal void SetExpression(BoundExpression expression)
+            {
+                Debug.Assert((object?)_lazyFunctionType == FunctionTypeSymbol.Uninitialized);
+                Debug.Assert(_expression is null);
+                Debug.Assert(expression.Kind is BoundKind.MethodGroup or BoundKind.UnboundLambda);
+
+                _expression = expression;
+            }
+
+            /// <summary>
+            /// Returns the inferred signature as a <see cref="FunctionTypeSymbol"/>
+            /// or null if the signature could not be inferred.
+            /// </summary>
+            internal FunctionTypeSymbol? GetValue()
+            {
+                Debug.Assert(_expression is { });
+
+                if ((object?)_lazyFunctionType == FunctionTypeSymbol.Uninitialized)
+                {
+                    var delegateType = _calculateDelegate(_binder, _expression);
+                    var functionType = delegateType is null ? null : new FunctionTypeSymbol(delegateType);
+                    Interlocked.CompareExchange(ref _lazyFunctionType, functionType, FunctionTypeSymbol.Uninitialized);
+                }
+
+                return _lazyFunctionType;
+            }
+        }
+    }
+}
diff --git a/src/Compilers/CSharp/Portable/Symbols/FunctionTypeSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/FunctionTypeSymbol.cs
new file mode 100644
index 0000000000000..f50feaa6f7ea1
--- /dev/null
+++ b/src/Compilers/CSharp/Portable/Symbols/FunctionTypeSymbol.cs
@@ -0,0 +1,144 @@
+// 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 Microsoft.CodeAnalysis.PooledObjects;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis.CSharp.Symbols
+{
+    /// <summary>
+    /// A <see cref="TypeSymbol"/> implementation that represents the inferred signature of a
+    /// lambda expression or method group. This is implemented as a <see cref="TypeSymbol"/>
+    /// to allow types and function signatures to be treated similarly in <see cref="ConversionsBase"/>,
+    /// <see cref="BestTypeInferrer"/>, and <see cref="MethodTypeInferrer"/>. Instances of this type
+    /// should only be used in those code paths and should not be exposed from the symbol model.
+    /// </summary>
+    [DebuggerDisplay("{GetDebuggerDisplay(),nq}")]
+    internal sealed partial class FunctionTypeSymbol : TypeSymbol
+    {
+        internal static readonly FunctionTypeSymbol Uninitialized = new FunctionTypeSymbol(ErrorTypeSymbol.UnknownResultType);
+
+        private readonly NamedTypeSymbol _delegateType;
+
+        internal FunctionTypeSymbol(NamedTypeSymbol delegateType)
+        {
+            _delegateType = delegateType;
+        }
+
+        internal NamedTypeSymbol GetInternalDelegateType() => _delegateType;
+
+        public override bool IsReferenceType => true;
+
+        public override bool IsValueType => false;
+
+        public override TypeKind TypeKind => TypeKindInternal.FunctionType;
+
+        public override bool IsRefLikeType => false;
+
+        public override bool IsReadOnly => true;
+
+        public override SymbolKind Kind => SymbolKindInternal.FunctionType;
+
+        public override Symbol? ContainingSymbol => null;
+
+        public override ImmutableArray<Location> Locations => throw ExceptionUtilities.Unreachable;
+
+        public override ImmutableArray<SyntaxReference> DeclaringSyntaxReferences => throw ExceptionUtilities.Unreachable;
+
+        public override Accessibility DeclaredAccessibility => throw ExceptionUtilities.Unreachable;
+
+        public override bool IsStatic => false;
+
+        public override bool IsAbstract => throw ExceptionUtilities.Unreachable;
+
+        public override bool IsSealed => throw ExceptionUtilities.Unreachable;
+
+        internal override NamedTypeSymbol? BaseTypeNoUseSiteDiagnostics => null;
+
+        internal override bool IsRecord => throw ExceptionUtilities.Unreachable;
+
+        internal override bool IsRecordStruct => throw ExceptionUtilities.Unreachable;
+
+        internal override ObsoleteAttributeData ObsoleteAttributeData => throw ExceptionUtilities.Unreachable;
+
+        public override void Accept(CSharpSymbolVisitor visitor) => throw ExceptionUtilities.Unreachable;
+
+        public override TResult Accept<TResult>(CSharpSymbolVisitor<TResult> visitor) => throw ExceptionUtilities.Unreachable;
+
+        public override ImmutableArray<Symbol> GetMembers() => throw ExceptionUtilities.Unreachable;
+
+        public override ImmutableArray<Symbol> GetMembers(string name) => throw ExceptionUtilities.Unreachable;
+
+        public override ImmutableArray<NamedTypeSymbol> GetTypeMembers() => throw ExceptionUtilities.Unreachable;
+
+        public override ImmutableArray<NamedTypeSymbol> GetTypeMembers(string name) => throw ExceptionUtilities.Unreachable;
+
+        protected override ISymbol CreateISymbol() => throw ExceptionUtilities.Unreachable;
+
+        protected override ITypeSymbol CreateITypeSymbol(CodeAnalysis.NullableAnnotation nullableAnnotation) => throw ExceptionUtilities.Unreachable;
+
+        internal override TResult Accept<TArgument, TResult>(CSharpSymbolVisitor<TArgument, TResult> visitor, TArgument a) => throw ExceptionUtilities.Unreachable;
+
+        internal override void AddNullableTransforms(ArrayBuilder<byte> transforms) => throw ExceptionUtilities.Unreachable;
+
+        internal override bool ApplyNullableTransforms(byte defaultTransformFlag, ImmutableArray<byte> transforms, ref int position, out TypeSymbol result) => throw ExceptionUtilities.Unreachable;
+
+        internal override ManagedKind GetManagedKind(ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) => throw ExceptionUtilities.Unreachable;
+
+        internal override bool GetUnificationUseSiteDiagnosticRecursive(ref DiagnosticInfo result, Symbol owner, ref HashSet<TypeSymbol> checkedTypes) => throw ExceptionUtilities.Unreachable;
+
+        internal override ImmutableArray<NamedTypeSymbol> InterfacesNoUseSiteDiagnostics(ConsList<TypeSymbol>? basesBeingResolved = null) => ImmutableArray<NamedTypeSymbol>.Empty;
+
+        internal override TypeSymbol MergeEquivalentTypes(TypeSymbol other, VarianceKind variance)
+        {
+            Debug.Assert(this.Equals(other, TypeCompareKind.IgnoreDynamicAndTupleNames | TypeCompareKind.IgnoreNullableModifiersForReferenceTypes));
+
+            var otherType = (FunctionTypeSymbol)other;
+            var delegateType = (NamedTypeSymbol)_delegateType.MergeEquivalentTypes(otherType._delegateType, variance);
+
+            return (object)_delegateType == delegateType ?
+                this :
+                otherType.WithDelegateType(delegateType);
+        }
+
+        internal override TypeSymbol SetNullabilityForReferenceTypes(Func<TypeWithAnnotations, TypeWithAnnotations> transform)
+        {
+            return WithDelegateType((NamedTypeSymbol)_delegateType.SetNullabilityForReferenceTypes(transform));
+        }
+
+        private FunctionTypeSymbol WithDelegateType(NamedTypeSymbol delegateType)
+        {
+            return (object)_delegateType == delegateType ?
+                this :
+                new FunctionTypeSymbol(delegateType);
+        }
+
+        internal override IEnumerable<(MethodSymbol Body, MethodSymbol Implemented)> SynthesizedInterfaceMethodImpls() => throw ExceptionUtilities.Unreachable;
+
+        internal override bool Equals(TypeSymbol t2, TypeCompareKind compareKind)
+        {
+            if (ReferenceEquals(this, t2))
+            {
+                return true;
+            }
+
+            var otherType = (t2 as FunctionTypeSymbol)?._delegateType;
+            return _delegateType.Equals(otherType, compareKind);
+        }
+
+        public override int GetHashCode()
+        {
+            return _delegateType.GetHashCode();
+        }
+
+        internal override string GetDebuggerDisplay()
+        {
+            return $"FunctionTypeSymbol: {_delegateType.GetDebuggerDisplay()}";
+        }
+    }
+}
diff --git a/src/Compilers/CSharp/Portable/Symbols/ReducedExtensionMethodSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/ReducedExtensionMethodSymbol.cs
index 39288907433d6..079d740aace9e 100644
--- a/src/Compilers/CSharp/Portable/Symbols/ReducedExtensionMethodSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/ReducedExtensionMethodSymbol.cs
@@ -150,6 +150,7 @@ private static MethodSymbol InferExtensionMethodTypeArguments(MethodSymbol metho
             }
 
             var typeArgs = MethodTypeInferrer.InferTypeArgumentsFromFirstArgument(
+                compilation,
                 conversions,
                 method,
                 arguments.AsImmutable(),
diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/SourceLocalSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Source/SourceLocalSymbol.cs
index 8ffae42c029ef..aea0db3944c67 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Source/SourceLocalSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Source/SourceLocalSymbol.cs
@@ -708,9 +708,7 @@ internal override SyntaxNode ForbiddenZone
                             return _deconstruction;
 
                         case SyntaxKind.ForEachVariableStatement:
-                            // There is no forbidden zone for a foreach statement, because the
-                            // variables are not in scope in the expression.
-                            return null;
+                            return ((ForEachVariableStatementSyntax)_deconstruction).Variable;
 
                         default:
                             return null;
diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/SourceNamedTypeSymbol_Bases.cs b/src/Compilers/CSharp/Portable/Symbols/Source/SourceNamedTypeSymbol_Bases.cs
index e8bc2be3a8445..77a181093c2fc 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Source/SourceNamedTypeSymbol_Bases.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Source/SourceNamedTypeSymbol_Bases.cs
@@ -315,13 +315,36 @@ private Tuple<NamedTypeSymbol, ImmutableArray<NamedTypeSymbol>> MakeDeclaredBase
                         baseType = partBase;
                         baseTypeLocation = decl.NameLocation;
                     }
-                    else if ((object)partBase != null && !TypeSymbol.Equals(partBase, baseType, TypeCompareKind.ConsiderEverything2) && partBase.TypeKind != TypeKind.Error)
+                    else if ((object)partBase != null && !TypeSymbol.Equals(partBase, baseType, TypeCompareKind.ConsiderEverything) && partBase.TypeKind != TypeKind.Error)
                     {
                         // the parts do not agree
+                        if (partBase.Equals(baseType, TypeCompareKind.ObliviousNullableModifierMatchesAny))
+                        {
+                            if (containsOnlyOblivious(baseType))
+                            {
+                                baseType = partBase;
+                                baseTypeLocation = decl.NameLocation;
+                                continue;
+                            }
+                            else if (containsOnlyOblivious(partBase))
+                            {
+                                continue;
+                            }
+                        }
+
                         var info = diagnostics.Add(ErrorCode.ERR_PartialMultipleBases, Locations[0], this);
                         baseType = new ExtendedErrorTypeSymbol(baseType, LookupResultKind.Ambiguous, info);
                         baseTypeLocation = decl.NameLocation;
                         reportedPartialConflict = true;
+
+                        static bool containsOnlyOblivious(TypeSymbol type)
+                        {
+                            return TypeWithAnnotations.Create(type).VisitType(
+                                type: null,
+                                static (type, arg, flag) => !type.Type.IsValueType && !type.NullableAnnotation.IsOblivious(),
+                                typePredicate: null,
+                                arg: (object)null) is null;
+                        }
                     }
                 }
 
diff --git a/src/Compilers/CSharp/Portable/Symbols/Synthesized/GeneratedNames.cs b/src/Compilers/CSharp/Portable/Symbols/Synthesized/GeneratedNames.cs
index 498a1b7a0a63e..51a70440192ed 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Synthesized/GeneratedNames.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Synthesized/GeneratedNames.cs
@@ -350,39 +350,86 @@ internal static string MakeDynamicCallSiteFieldName(int uniqueId)
             return "<>p__" + StringExtensions.GetNumeral(uniqueId);
         }
 
+        internal const string ActionDelegateNamePrefix = "<>A";
+        internal const string FuncDelegateNamePrefix = "<>F";
+        private const int DelegateNamePrefixLength = 3;
+        private const int DelegateNamePrefixLengthWithOpenBrace = 4;
+
         /// <summary>
         /// 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>
-        internal static string MakeDynamicCallSiteDelegateName(RefKindVector byRefs, bool returnsVoid, int generation)
+        internal static string MakeSynthesizedDelegateName(RefKindVector byRefs, bool returnsVoid, int generation)
         {
             var pooledBuilder = PooledStringBuilder.GetInstance();
             var builder = pooledBuilder.Builder;
 
-            builder.Append(returnsVoid ? "<>A" : "<>F");
+            builder.Append(returnsVoid ? ActionDelegateNamePrefix : FuncDelegateNamePrefix);
 
             if (!byRefs.IsNull)
             {
-                builder.Append("{");
+                builder.Append(byRefs.ToRefKindString());
+            }
 
-                int i = 0;
-                foreach (int byRefIndex in byRefs.Words())
-                {
-                    if (i > 0)
-                    {
-                        builder.Append(",");
-                    }
+            AppendOptionalGeneration(builder, generation);
+            return pooledBuilder.ToStringAndFree();
+        }
+
+        internal static bool TryParseSynthesizedDelegateName(string name, out RefKindVector byRefs, out bool returnsVoid, out int generation, out int parameterCount)
+        {
+            byRefs = default;
+            parameterCount = 0;
+            generation = 0;
+
+            name = MetadataHelpers.InferTypeArityAndUnmangleMetadataName(name, out var arity);
+
+            returnsVoid = name.StartsWith(ActionDelegateNamePrefix);
+
+            if (!returnsVoid && !name.StartsWith(FuncDelegateNamePrefix))
+            {
+                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)
+            {
+                return false;
+            }
+
+            // The ref kind string is between the two braces
+            var refKindString = name[DelegateNamePrefixLengthWithOpenBrace..lastBraceIndex];
+
+            if (!RefKindVector.TryParse(refKindString, arity, out byRefs))
+            {
+                return false;
+            }
 
-                    builder.AppendFormat("{0:x8}", byRefIndex);
-                    i++;
+            // 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)
+            {
+                // Format is a '#' followed by the generation number
+                if (name[lastBraceIndex + 1] != '#')
+                {
+                    return false;
                 }
 
-                builder.Append("}");
-                Debug.Assert(i > 0);
+                if (!int.TryParse(name[(lastBraceIndex + 2)..], out generation))
+                {
+                    return false;
+                }
             }
 
-            AppendOptionalGeneration(builder, generation);
-            return pooledBuilder.ToStringAndFree();
+            Debug.Assert(name == MakeSynthesizedDelegateName(byRefs, returnsVoid, generation));
+            return true;
         }
 
         internal static string AsyncBuilderFieldName()
diff --git a/src/Compilers/CSharp/Portable/Symbols/Synthesized/RefKindVector.cs b/src/Compilers/CSharp/Portable/Symbols/Synthesized/RefKindVector.cs
index a911d0b2dccf6..c547c7352c301 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Synthesized/RefKindVector.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Synthesized/RefKindVector.cs
@@ -4,6 +4,8 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
+using Microsoft.CodeAnalysis.PooledObjects;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.Symbols
@@ -22,6 +24,11 @@ private RefKindVector(int capacity)
             _bits = BitVector.Create(capacity * 2);
         }
 
+        private RefKindVector(BitVector bits)
+        {
+            _bits = bits;
+        }
+
         internal bool IsNull => _bits.IsNull;
 
         internal int Capacity => _bits.Capacity / 2;
@@ -69,5 +76,65 @@ public override int GetHashCode()
         {
             return _bits.GetHashCode();
         }
+
+        public string ToRefKindString()
+        {
+            var pooledBuilder = PooledStringBuilder.GetInstance();
+            var builder = pooledBuilder.Builder;
+
+            builder.Append("{");
+
+            int i = 0;
+            foreach (int byRefIndex in this.Words())
+            {
+                if (i > 0)
+                {
+                    builder.Append(",");
+                }
+
+                builder.AppendFormat("{0:x8}", byRefIndex);
+                i++;
+            }
+
+            builder.Append("}");
+            Debug.Assert(i > 0);
+
+            return pooledBuilder.ToStringAndFree();
+        }
+
+        public static bool TryParse(string refKindString, int capacity, out RefKindVector result)
+        {
+            ulong? firstWord = null;
+            ArrayBuilder<ulong>? otherWords = null;
+            foreach (var word in refKindString.Split(','))
+            {
+                ulong value;
+                try
+                {
+                    value = Convert.ToUInt64(word, 16);
+                }
+                catch (Exception)
+                {
+                    result = default;
+                    return false;
+                }
+
+                if (firstWord is null)
+                {
+                    firstWord = value;
+                }
+                else
+                {
+                    otherWords ??= ArrayBuilder<ulong>.GetInstance();
+                    otherWords.Add(value);
+                }
+            }
+
+            Debug.Assert(firstWord is not null);
+
+            var bitVector = BitVector.FromWords(firstWord.Value, otherWords?.ToArrayAndFree() ?? Array.Empty<ulong>(), capacity * 2);
+            result = new RefKindVector(bitVector);
+            return true;
+        }
     }
 }
diff --git a/src/Compilers/CSharp/Test/CommandLine/CommandLineTestBase.cs b/src/Compilers/CSharp/Test/CommandLine/CommandLineTestBase.cs
index 81fdcedb8d1ec..d9788dd37f7aa 100644
--- a/src/Compilers/CSharp/Test/CommandLine/CommandLineTestBase.cs
+++ b/src/Compilers/CSharp/Test/CommandLine/CommandLineTestBase.cs
@@ -54,15 +54,15 @@ internal CSharpCommandLineArguments DefaultParse(IEnumerable<string> args, strin
             return CSharpCommandLineParser.Default.Parse(args, baseDirectory, sdkDirectory, additionalReferenceDirectories);
         }
 
-        internal MockCSharpCompiler CreateCSharpCompiler(string[] args, ImmutableArray<DiagnosticAnalyzer> analyzers = default, ImmutableArray<ISourceGenerator> generators = default, AnalyzerAssemblyLoader loader = null)
+        internal MockCSharpCompiler CreateCSharpCompiler(string[] args, ImmutableArray<DiagnosticAnalyzer> analyzers = default, ImmutableArray<ISourceGenerator> generators = default, AnalyzerAssemblyLoader loader = null, GeneratorDriverCache driverCache = null)
         {
-            return CreateCSharpCompiler(null, WorkingDirectory, args, analyzers, generators, loader);
+            return CreateCSharpCompiler(null, WorkingDirectory, args, analyzers, generators, loader, driverCache);
         }
 
-        internal MockCSharpCompiler CreateCSharpCompiler(string responseFile, string workingDirectory, string[] args, ImmutableArray<DiagnosticAnalyzer> analyzers = default, ImmutableArray<ISourceGenerator> generators = default, AnalyzerAssemblyLoader loader = null)
+        internal MockCSharpCompiler CreateCSharpCompiler(string responseFile, string workingDirectory, string[] args, ImmutableArray<DiagnosticAnalyzer> analyzers = default, ImmutableArray<ISourceGenerator> generators = default, AnalyzerAssemblyLoader loader = null, GeneratorDriverCache driverCache = null)
         {
             var buildPaths = RuntimeUtilities.CreateBuildPaths(workingDirectory, sdkDirectory: SdkDirectory);
-            return new MockCSharpCompiler(responseFile, buildPaths, args, analyzers, generators, loader);
+            return new MockCSharpCompiler(responseFile, buildPaths, args, analyzers, generators, loader, driverCache);
         }
     }
 }
diff --git a/src/Compilers/CSharp/Test/CommandLine/CommandLineTests.cs b/src/Compilers/CSharp/Test/CommandLine/CommandLineTests.cs
index 22c66e1e3ec12..ded4e33b6a2fc 100644
--- a/src/Compilers/CSharp/Test/CommandLine/CommandLineTests.cs
+++ b/src/Compilers/CSharp/Test/CommandLine/CommandLineTests.cs
@@ -9793,6 +9793,235 @@ string[] compileAndRun(string featureOpt)
             };
         }
 
+        [Fact]
+        public void Compiler_Uses_DriverCache()
+        {
+            var dir = Temp.CreateDirectory();
+            var src = dir.CreateFile("temp.cs").WriteAllText(@"
+class C
+{
+}");
+            int sourceCallbackCount = 0;
+            var generator = new PipelineCallbackGenerator((ctx) =>
+            {
+                ctx.RegisterSourceOutput(ctx.ParseOptionsProvider, (spc, po) =>
+                {
+                    sourceCallbackCount++;
+                });
+            });
+
+            // with no cache, we'll see the callback execute multiple times
+            RunWithNoCache();
+            Assert.Equal(1, sourceCallbackCount);
+
+            RunWithNoCache();
+            Assert.Equal(2, sourceCallbackCount);
+
+            RunWithNoCache();
+            Assert.Equal(3, sourceCallbackCount);
+
+            // now re-run with a cache
+            GeneratorDriverCache cache = new GeneratorDriverCache();
+            sourceCallbackCount = 0;
+
+            RunWithCache();
+            Assert.Equal(1, sourceCallbackCount);
+
+            RunWithCache();
+            Assert.Equal(1, sourceCallbackCount);
+
+            RunWithCache();
+            Assert.Equal(1, sourceCallbackCount);
+
+            // Clean up temp files
+            CleanupAllGeneratedFiles(src.Path);
+            Directory.Delete(dir.Path, true);
+
+            void RunWithNoCache() => VerifyOutput(dir, src, includeCurrentAssemblyAsAnalyzerReference: false, additionalFlags: new[] { "/langversion:preview" }, generators: new[] { generator.AsSourceGenerator() }, analyzers: null);
+
+            void RunWithCache() => VerifyOutput(dir, src, includeCurrentAssemblyAsAnalyzerReference: false, additionalFlags: new[] { "/langversion:preview" }, generators: new[] { generator.AsSourceGenerator() }, driverCache: cache, analyzers: null);
+        }
+
+        [Fact]
+        public void Compiler_Doesnt_Use_Cache_From_Other_Compilation()
+        {
+            var dir = Temp.CreateDirectory();
+            var src = dir.CreateFile("temp.cs").WriteAllText(@"
+class C
+{
+}");
+            int sourceCallbackCount = 0;
+            var generator = new PipelineCallbackGenerator((ctx) =>
+            {
+                ctx.RegisterSourceOutput(ctx.ParseOptionsProvider, (spc, po) =>
+                {
+                    sourceCallbackCount++;
+                });
+            });
+
+            // now re-run with a cache
+            GeneratorDriverCache cache = new GeneratorDriverCache();
+            sourceCallbackCount = 0;
+
+            RunWithCache("1.dll");
+            Assert.Equal(1, sourceCallbackCount);
+
+            RunWithCache("1.dll");
+            Assert.Equal(1, sourceCallbackCount);
+
+            // now emulate a new compilation, and check we were invoked, but only once
+            RunWithCache("2.dll");
+            Assert.Equal(2, sourceCallbackCount);
+
+            RunWithCache("2.dll");
+            Assert.Equal(2, sourceCallbackCount);
+
+            // now re-run our first compilation
+            RunWithCache("1.dll");
+            Assert.Equal(2, sourceCallbackCount);
+
+            // a new one
+            RunWithCache("3.dll");
+            Assert.Equal(3, sourceCallbackCount);
+
+            // and another old one
+            RunWithCache("2.dll");
+            Assert.Equal(3, sourceCallbackCount);
+
+            RunWithCache("1.dll");
+            Assert.Equal(3, sourceCallbackCount);
+
+            // Clean up temp files
+            CleanupAllGeneratedFiles(src.Path);
+            Directory.Delete(dir.Path, true);
+
+            void RunWithCache(string outputPath) => VerifyOutput(dir, src, includeCurrentAssemblyAsAnalyzerReference: false, additionalFlags: new[] { "/langversion:preview", "/out:" + outputPath }, generators: new[] { generator.AsSourceGenerator() }, driverCache: cache, analyzers: null);
+        }
+
+        [Fact]
+        public void Compiler_Can_Disable_DriverCache()
+        {
+            var dir = Temp.CreateDirectory();
+            var src = dir.CreateFile("temp.cs").WriteAllText(@"
+class C
+{
+}");
+            int sourceCallbackCount = 0;
+            var generator = new PipelineCallbackGenerator((ctx) =>
+            {
+                ctx.RegisterSourceOutput(ctx.ParseOptionsProvider, (spc, po) =>
+                {
+                    sourceCallbackCount++;
+                });
+            });
+
+            // run with the cache
+            GeneratorDriverCache cache = new GeneratorDriverCache();
+            sourceCallbackCount = 0;
+
+            RunWithCache();
+            Assert.Equal(1, sourceCallbackCount);
+
+            RunWithCache();
+            Assert.Equal(1, sourceCallbackCount);
+
+            RunWithCache();
+            Assert.Equal(1, sourceCallbackCount);
+
+            // now re-run with the cache disabled
+            sourceCallbackCount = 0;
+
+            RunWithCacheDisabled();
+            Assert.Equal(1, sourceCallbackCount);
+
+            RunWithCacheDisabled();
+            Assert.Equal(2, sourceCallbackCount);
+
+            RunWithCacheDisabled();
+            Assert.Equal(3, sourceCallbackCount);
+
+            // now clear the cache as well as disabling, and verify we don't put any entries into it either
+            cache = new GeneratorDriverCache();
+            sourceCallbackCount = 0;
+
+            RunWithCacheDisabled();
+            Assert.Equal(1, sourceCallbackCount);
+            Assert.Equal(0, cache.CacheSize);
+
+            RunWithCacheDisabled();
+            Assert.Equal(2, sourceCallbackCount);
+            Assert.Equal(0, cache.CacheSize);
+
+            RunWithCacheDisabled();
+            Assert.Equal(3, sourceCallbackCount);
+            Assert.Equal(0, cache.CacheSize);
+
+            // Clean up temp files
+            CleanupAllGeneratedFiles(src.Path);
+            Directory.Delete(dir.Path, true);
+
+            void RunWithCache() => VerifyOutput(dir, src, includeCurrentAssemblyAsAnalyzerReference: false, additionalFlags: new[] { "/langversion:preview" }, generators: new[] { generator.AsSourceGenerator() }, driverCache: cache, analyzers: null);
+
+            void RunWithCacheDisabled() => VerifyOutput(dir, src, includeCurrentAssemblyAsAnalyzerReference: false, additionalFlags: new[] { "/langversion:preview", "/features:disable-generator-cache" }, generators: new[] { generator.AsSourceGenerator() }, driverCache: cache, analyzers: null);
+        }
+
+        [Fact]
+        public void Adding_Or_Removing_A_Generator_Invalidates_Cache()
+        {
+            var dir = Temp.CreateDirectory();
+            var src = dir.CreateFile("temp.cs").WriteAllText(@"
+class C
+{
+}");
+            int sourceCallbackCount = 0;
+            int sourceCallbackCount2 = 0;
+            var generator = new PipelineCallbackGenerator((ctx) =>
+            {
+                ctx.RegisterSourceOutput(ctx.ParseOptionsProvider, (spc, po) =>
+                {
+                    sourceCallbackCount++;
+                });
+            });
+
+            var generator2 = new PipelineCallbackGenerator2((ctx) =>
+            {
+                ctx.RegisterSourceOutput(ctx.ParseOptionsProvider, (spc, po) =>
+                {
+                    sourceCallbackCount2++;
+                });
+            });
+
+            // run with the cache
+            GeneratorDriverCache cache = new GeneratorDriverCache();
+
+            RunWithOneGenerator();
+            Assert.Equal(1, sourceCallbackCount);
+            Assert.Equal(0, sourceCallbackCount2);
+
+            RunWithOneGenerator();
+            Assert.Equal(1, sourceCallbackCount);
+            Assert.Equal(0, sourceCallbackCount2);
+
+            RunWithTwoGenerators();
+            Assert.Equal(2, sourceCallbackCount);
+            Assert.Equal(1, sourceCallbackCount2);
+
+            RunWithTwoGenerators();
+            Assert.Equal(2, sourceCallbackCount);
+            Assert.Equal(1, sourceCallbackCount2);
+
+            // this seems counterintuitive, but when the only thing to change is the generator, we end up back at the state of the project when 
+            // we just ran a single generator. Thus we already have an entry in the cache we can use (the one created by the original call to
+            // RunWithOneGenerator above) meaning we can use the previously cached results and not run.
+            RunWithOneGenerator();
+            Assert.Equal(2, sourceCallbackCount);
+            Assert.Equal(1, sourceCallbackCount2);
+
+            void RunWithOneGenerator() => VerifyOutput(dir, src, includeCurrentAssemblyAsAnalyzerReference: false, additionalFlags: new[] { "/langversion:preview" }, generators: new[] { generator.AsSourceGenerator() }, driverCache: cache, analyzers: null);
+
+            void RunWithTwoGenerators() => VerifyOutput(dir, src, includeCurrentAssemblyAsAnalyzerReference: false, additionalFlags: new[] { "/langversion:preview" }, generators: new[] { generator.AsSourceGenerator(), generator2.AsSourceGenerator() }, driverCache: cache, analyzers: null);
+        }
+
         private static int OccurrenceCount(string source, string word)
         {
             var n = 0;
@@ -9814,6 +10043,7 @@ private string VerifyOutput(TempDirectory sourceDir, TempFile sourceFile,
                                            int? expectedExitCode = null,
                                            bool errorlog = false,
                                            IEnumerable<ISourceGenerator> generators = null,
+                                           GeneratorDriverCache driverCache = null,
                                            params DiagnosticAnalyzer[] analyzers)
         {
             var args = new[] {
@@ -9835,7 +10065,7 @@ private string VerifyOutput(TempDirectory sourceDir, TempFile sourceFile,
                 args = args.Append(additionalFlags);
             }
 
-            var csc = CreateCSharpCompiler(null, sourceDir.Path, args, analyzers: analyzers.ToImmutableArrayOrEmpty(), generators: generators.ToImmutableArrayOrEmpty());
+            var csc = CreateCSharpCompiler(null, sourceDir.Path, args, analyzers: analyzers.ToImmutableArrayOrEmpty(), generators: generators.ToImmutableArrayOrEmpty(), driverCache: driverCache);
             var outWriter = new StringWriter(CultureInfo.InvariantCulture);
             var exitCode = csc.Run(outWriter);
             var output = outWriter.ToString();
diff --git a/src/Compilers/CSharp/Test/CommandLine/GeneratorDriverCacheTests.cs b/src/Compilers/CSharp/Test/CommandLine/GeneratorDriverCacheTests.cs
new file mode 100644
index 0000000000000..3c7e7eb8fe0c0
--- /dev/null
+++ b/src/Compilers/CSharp/Test/CommandLine/GeneratorDriverCacheTests.cs
@@ -0,0 +1,101 @@
+// 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.Linq;
+using Xunit;
+
+namespace Microsoft.CodeAnalysis.CSharp.CommandLine.UnitTests
+{
+    public class GeneratorDriverCacheTests : CommandLineTestBase
+    {
+
+        [Fact]
+        public void DriverCache_Returns_Null_For_No_Match()
+        {
+            var driverCache = new GeneratorDriverCache();
+            var driver = driverCache.TryGetDriver("0");
+
+            Assert.Null(driver);
+        }
+
+        [Fact]
+        public void DriverCache_Returns_Cached_Driver()
+        {
+            var drivers = GetDrivers(1);
+            var driverCache = new GeneratorDriverCache();
+            driverCache.CacheGenerator("0", drivers[0]);
+
+            var driver = driverCache.TryGetDriver("0");
+            Assert.Same(driver, drivers[0]);
+        }
+
+        [Fact]
+        public void DriverCache_Can_Cache_Multiple_Drivers()
+        {
+            var drivers = GetDrivers(3);
+
+            var driverCache = new GeneratorDriverCache();
+            driverCache.CacheGenerator("0", drivers[0]);
+            driverCache.CacheGenerator("1", drivers[1]);
+            driverCache.CacheGenerator("2", drivers[2]);
+
+            var driver = driverCache.TryGetDriver("0");
+            Assert.Same(driver, drivers[0]);
+
+            driver = driverCache.TryGetDriver("1");
+            Assert.Same(driver, drivers[1]);
+
+            driver = driverCache.TryGetDriver("2");
+            Assert.Same(driver, drivers[2]);
+        }
+
+        [Fact]
+        public void DriverCache_Evicts_Least_Recently_Used()
+        {
+            var drivers = GetDrivers(GeneratorDriverCache.MaxCacheSize + 2);
+            var driverCache = new GeneratorDriverCache();
+
+            // put n+1 drivers into the cache
+            for (int i = 0; i < GeneratorDriverCache.MaxCacheSize + 1; i++)
+            {
+                driverCache.CacheGenerator(i.ToString(), drivers[i]);
+            }
+            // current cache state is 
+            // (10, 9, 8, 7, 6, 5, 4, 3, 2, 1)
+
+            // now try and retrieve the first driver which should no longer be in the cache
+            var driver = driverCache.TryGetDriver("0");
+            Assert.Null(driver);
+
+            // add it back
+            driverCache.CacheGenerator("0", drivers[0]);
+
+            // current cache state is 
+            // (0, 10, 9, 8, 7, 6, 5, 4, 3, 2)
+
+            // access some drivers in the middle
+            driver = driverCache.TryGetDriver("7");
+            driver = driverCache.TryGetDriver("4");
+            driver = driverCache.TryGetDriver("2");
+
+            // current cache state is 
+            // (2, 4, 7, 0, 10, 9, 8, 6, 5, 3)
+
+            // try and get a new driver that was never in the cache
+            driver = driverCache.TryGetDriver("11");
+            Assert.Null(driver);
+            driverCache.CacheGenerator("11", drivers[11]);
+
+            // current cache state is 
+            // (11, 2, 4, 7, 0, 10, 9, 8, 6, 5)
+
+            // get a driver that has been evicted
+            driver = driverCache.TryGetDriver("3");
+            Assert.Null(driver);
+        }
+
+        private static GeneratorDriver[] GetDrivers(int count) => Enumerable.Range(0, count).Select(i => CSharpGeneratorDriver.Create(Array.Empty<ISourceGenerator>())).ToArray();
+    }
+}
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/SwitchTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/SwitchTests.cs
index 47e3778234193..8791b07a346fe 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/SwitchTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/SwitchTests.cs
@@ -9050,49 +9050,74 @@ public static void M(object o)
             var compVerifier = CompileAndVerify(source,
                 options: TestOptions.ReleaseDll.WithOutputKind(OutputKind.ConsoleApplication),
                 expectedOutput: "");
-            compVerifier.VerifyIL("Program.M",
-@"{
-  // Code size      106 (0x6a)
-  .maxstack  1
-  .locals init (int V_0, //i
-                object V_1)
+            compVerifier.VerifyIL("Program.M", @"
+{
+  // Code size      120 (0x78)
+  .maxstack  2
+  .locals init (int V_0,
+                int V_1, //i
+                object V_2)
   IL_0000:  ldarg.0
-  IL_0001:  stloc.1
-  IL_0002:  ldloc.1
+  IL_0001:  stloc.2
+  IL_0002:  ldloc.2
   IL_0003:  isinst     ""int""
-  IL_0008:  brfalse.s  IL_0021
-  IL_000a:  ldloc.1
+  IL_0008:  brfalse.s  IL_001c
+  IL_000a:  ldloc.2
   IL_000b:  unbox.any  ""int""
-  IL_0010:  stloc.0
+  IL_0010:  stloc.1
   IL_0011:  ldsfld     ""bool Program.b""
-  IL_0016:  brtrue.s   IL_0069
-  IL_0018:  ldsfld     ""bool Program.b""
-  IL_001d:  brtrue.s   IL_0069
-  IL_001f:  br.s       IL_002a
-  IL_0021:  ldsfld     ""bool Program.b""
-  IL_0026:  brtrue.s   IL_0069
-  IL_0028:  br.s       IL_003a
-  IL_002a:  ldsfld     ""bool Program.b""
-  IL_002f:  brtrue.s   IL_0069
-  IL_0031:  ldsfld     ""bool Program.b""
-  IL_0036:  brtrue.s   IL_0069
-  IL_0038:  br.s       IL_0043
-  IL_003a:  ldsfld     ""bool Program.b""
-  IL_003f:  brtrue.s   IL_0069
-  IL_0041:  br.s       IL_0053
-  IL_0043:  ldsfld     ""bool Program.b""
-  IL_0048:  brtrue.s   IL_0069
-  IL_004a:  ldsfld     ""bool Program.b""
-  IL_004f:  brtrue.s   IL_0069
-  IL_0051:  br.s       IL_005c
-  IL_0053:  ldsfld     ""bool Program.b""
-  IL_0058:  brtrue.s   IL_0069
-  IL_005a:  br.s       IL_0063
-  IL_005c:  ldsfld     ""bool Program.b""
-  IL_0061:  brtrue.s   IL_0069
-  IL_0063:  ldsfld     ""bool Program.b""
-  IL_0068:  pop
+  IL_0016:  brtrue.s   IL_0077
+  IL_0018:  ldc.i4.1
+  IL_0019:  stloc.0
+  IL_001a:  br.s       IL_001e
+  IL_001c:  ldc.i4.7
+  IL_001d:  stloc.0
+  IL_001e:  ldsfld     ""bool Program.b""
+  IL_0023:  brtrue.s   IL_0077
+  IL_0025:  ldloc.0
+  IL_0026:  ldc.i4.1
+  IL_0027:  beq.s      IL_002e
+  IL_0029:  ldloc.0
+  IL_002a:  ldc.i4.7
+  IL_002b:  beq.s      IL_0039
+  IL_002d:  ret
+  IL_002e:  ldsfld     ""bool Program.b""
+  IL_0033:  brtrue.s   IL_0077
+  IL_0035:  ldc.i4.3
+  IL_0036:  stloc.0
+  IL_0037:  br.s       IL_003b
+  IL_0039:  ldc.i4.8
+  IL_003a:  stloc.0
+  IL_003b:  ldsfld     ""bool Program.b""
+  IL_0040:  brtrue.s   IL_0077
+  IL_0042:  ldloc.0
+  IL_0043:  ldc.i4.3
+  IL_0044:  beq.s      IL_004b
+  IL_0046:  ldloc.0
+  IL_0047:  ldc.i4.8
+  IL_0048:  beq.s      IL_0056
+  IL_004a:  ret
+  IL_004b:  ldsfld     ""bool Program.b""
+  IL_0050:  brtrue.s   IL_0077
+  IL_0052:  ldc.i4.5
+  IL_0053:  stloc.0
+  IL_0054:  br.s       IL_0059
+  IL_0056:  ldc.i4.s   9
+  IL_0058:  stloc.0
+  IL_0059:  ldsfld     ""bool Program.b""
+  IL_005e:  brtrue.s   IL_0077
+  IL_0060:  ldloc.0
+  IL_0061:  ldc.i4.5
+  IL_0062:  beq.s      IL_006a
+  IL_0064:  ldloc.0
+  IL_0065:  ldc.i4.s   9
+  IL_0067:  beq.s      IL_0071
   IL_0069:  ret
+  IL_006a:  ldsfld     ""bool Program.b""
+  IL_006f:  brtrue.s   IL_0077
+  IL_0071:  ldsfld     ""bool Program.b""
+  IL_0076:  pop
+  IL_0077:  ret
 }"
             );
 
@@ -9109,113 +9134,147 @@ void validator(ModuleSymbol module)
 
             compVerifier.VerifyIL(qualifiedMethodName: "Program.M", sequencePoints: "Program.M", source: source,
 expectedIL: @"{
-  // Code size      149 (0x95)
-  .maxstack  1
-  .locals init (int V_0, //i
+  // Code size      194 (0xc2)
+  .maxstack  2
+  .locals init (int V_0,
                 int V_1, //i
                 int V_2, //i
                 int V_3, //i
-                object V_4,
-                object V_5)
+                int V_4, //i
+                object V_5,
+                object V_6)
   // sequence point: {
   IL_0000:  nop
   // sequence point: switch (o)
   IL_0001:  ldarg.0
-  IL_0002:  stloc.s    V_5
+  IL_0002:  stloc.s    V_6
   // sequence point: <hidden>
-  IL_0004:  ldloc.s    V_5
-  IL_0006:  stloc.s    V_4
+  IL_0004:  ldloc.s    V_6
+  IL_0006:  stloc.s    V_5
   // sequence point: <hidden>
-  IL_0008:  ldloc.s    V_4
+  IL_0008:  ldloc.s    V_5
   IL_000a:  isinst     ""int""
-  IL_000f:  brfalse.s  IL_002f
-  IL_0011:  ldloc.s    V_4
+  IL_000f:  brfalse.s  IL_002d
+  IL_0011:  ldloc.s    V_5
   IL_0013:  unbox.any  ""int""
-  IL_0018:  stloc.0
+  IL_0018:  stloc.1
   // sequence point: <hidden>
   IL_0019:  br.s       IL_001b
   // sequence point: when b
   IL_001b:  ldsfld     ""bool Program.b""
   IL_0020:  brtrue.s   IL_0024
   // sequence point: <hidden>
-  IL_0022:  br.s       IL_0026
+  IL_0022:  br.s       IL_0029
   // sequence point: break;
-  IL_0024:  br.s       IL_0094
-  // sequence point: when b
-  IL_0026:  ldsfld     ""bool Program.b""
-  IL_002b:  brtrue.s   IL_0038
+  IL_0024:  br         IL_00c1
   // sequence point: <hidden>
-  IL_002d:  br.s       IL_003a
+  IL_0029:  ldc.i4.1
+  IL_002a:  stloc.0
+  IL_002b:  br.s       IL_0031
+  IL_002d:  ldc.i4.7
+  IL_002e:  stloc.0
+  IL_002f:  br.s       IL_0031
   // sequence point: when b
-  IL_002f:  ldsfld     ""bool Program.b""
-  IL_0034:  brtrue.s   IL_0038
+  IL_0031:  ldsfld     ""bool Program.b""
+  IL_0036:  brtrue.s   IL_0048
   // sequence point: <hidden>
-  IL_0036:  br.s       IL_0050
+  IL_0038:  ldloc.0
+  IL_0039:  ldc.i4.1
+  IL_003a:  beq.s      IL_0044
+  IL_003c:  br.s       IL_003e
+  IL_003e:  ldloc.0
+  IL_003f:  ldc.i4.7
+  IL_0040:  beq.s      IL_0046
+  IL_0042:  br.s       IL_0048
+  IL_0044:  br.s       IL_004a
+  IL_0046:  br.s       IL_005b
   // sequence point: break;
-  IL_0038:  br.s       IL_0094
+  IL_0048:  br.s       IL_00c1
   // sequence point: <hidden>
-  IL_003a:  ldloc.0
-  IL_003b:  stloc.1
+  IL_004a:  ldloc.1
+  IL_004b:  stloc.2
   // sequence point: when b
-  IL_003c:  ldsfld     ""bool Program.b""
-  IL_0041:  brtrue.s   IL_0045
+  IL_004c:  ldsfld     ""bool Program.b""
+  IL_0051:  brtrue.s   IL_0055
   // sequence point: <hidden>
-  IL_0043:  br.s       IL_0047
+  IL_0053:  br.s       IL_0057
   // sequence point: break;
-  IL_0045:  br.s       IL_0094
-  // sequence point: when b
-  IL_0047:  ldsfld     ""bool Program.b""
-  IL_004c:  brtrue.s   IL_0059
+  IL_0055:  br.s       IL_00c1
   // sequence point: <hidden>
-  IL_004e:  br.s       IL_005b
+  IL_0057:  ldc.i4.3
+  IL_0058:  stloc.0
+  IL_0059:  br.s       IL_005f
+  IL_005b:  ldc.i4.8
+  IL_005c:  stloc.0
+  IL_005d:  br.s       IL_005f
   // sequence point: when b
-  IL_0050:  ldsfld     ""bool Program.b""
-  IL_0055:  brtrue.s   IL_0059
+  IL_005f:  ldsfld     ""bool Program.b""
+  IL_0064:  brtrue.s   IL_0076
   // sequence point: <hidden>
-  IL_0057:  br.s       IL_0071
+  IL_0066:  ldloc.0
+  IL_0067:  ldc.i4.3
+  IL_0068:  beq.s      IL_0072
+  IL_006a:  br.s       IL_006c
+  IL_006c:  ldloc.0
+  IL_006d:  ldc.i4.8
+  IL_006e:  beq.s      IL_0074
+  IL_0070:  br.s       IL_0076
+  IL_0072:  br.s       IL_0078
+  IL_0074:  br.s       IL_0089
   // sequence point: break;
-  IL_0059:  br.s       IL_0094
+  IL_0076:  br.s       IL_00c1
   // sequence point: <hidden>
-  IL_005b:  ldloc.0
-  IL_005c:  stloc.2
+  IL_0078:  ldloc.1
+  IL_0079:  stloc.3
   // sequence point: when b
-  IL_005d:  ldsfld     ""bool Program.b""
-  IL_0062:  brtrue.s   IL_0066
+  IL_007a:  ldsfld     ""bool Program.b""
+  IL_007f:  brtrue.s   IL_0083
   // sequence point: <hidden>
-  IL_0064:  br.s       IL_0068
+  IL_0081:  br.s       IL_0085
   // sequence point: break;
-  IL_0066:  br.s       IL_0094
-  // sequence point: when b
-  IL_0068:  ldsfld     ""bool Program.b""
-  IL_006d:  brtrue.s   IL_007a
+  IL_0083:  br.s       IL_00c1
   // sequence point: <hidden>
-  IL_006f:  br.s       IL_007c
+  IL_0085:  ldc.i4.5
+  IL_0086:  stloc.0
+  IL_0087:  br.s       IL_008e
+  IL_0089:  ldc.i4.s   9
+  IL_008b:  stloc.0
+  IL_008c:  br.s       IL_008e
   // sequence point: when b
-  IL_0071:  ldsfld     ""bool Program.b""
-  IL_0076:  brtrue.s   IL_007a
+  IL_008e:  ldsfld     ""bool Program.b""
+  IL_0093:  brtrue.s   IL_00a6
   // sequence point: <hidden>
-  IL_0078:  br.s       IL_0089
+  IL_0095:  ldloc.0
+  IL_0096:  ldc.i4.5
+  IL_0097:  beq.s      IL_00a2
+  IL_0099:  br.s       IL_009b
+  IL_009b:  ldloc.0
+  IL_009c:  ldc.i4.s   9
+  IL_009e:  beq.s      IL_00a4
+  IL_00a0:  br.s       IL_00a6
+  IL_00a2:  br.s       IL_00a8
+  IL_00a4:  br.s       IL_00b6
   // sequence point: break;
-  IL_007a:  br.s       IL_0094
+  IL_00a6:  br.s       IL_00c1
   // sequence point: <hidden>
-  IL_007c:  ldloc.0
-  IL_007d:  stloc.3
+  IL_00a8:  ldloc.1
+  IL_00a9:  stloc.s    V_4
   // sequence point: when b
-  IL_007e:  ldsfld     ""bool Program.b""
-  IL_0083:  brtrue.s   IL_0087
+  IL_00ab:  ldsfld     ""bool Program.b""
+  IL_00b0:  brtrue.s   IL_00b4
   // sequence point: <hidden>
-  IL_0085:  br.s       IL_0089
+  IL_00b2:  br.s       IL_00b6
   // sequence point: break;
-  IL_0087:  br.s       IL_0094
+  IL_00b4:  br.s       IL_00c1
   // sequence point: when b
-  IL_0089:  ldsfld     ""bool Program.b""
-  IL_008e:  brtrue.s   IL_0092
+  IL_00b6:  ldsfld     ""bool Program.b""
+  IL_00bb:  brtrue.s   IL_00bf
   // sequence point: <hidden>
-  IL_0090:  br.s       IL_0094
+  IL_00bd:  br.s       IL_00c1
   // sequence point: break;
-  IL_0092:  br.s       IL_0094
+  IL_00bf:  br.s       IL_00c1
   // sequence point: }
-  IL_0094:  ret
+  IL_00c1:  ret
 }"
             );
             compVerifier.VerifyPdb(
@@ -9243,6 +9302,7 @@ .locals init (int V_0, //i
       <customDebugInfo>
         <forward declaringType=""Program"" methodName=""Main"" />
         <encLocalSlotMap>
+          <slot kind=""temp"" />
           <slot kind=""0"" offset=""55"" />
           <slot kind=""0"" offset=""133"" />
           <slot kind=""0"" offset=""211"" />
@@ -9260,50 +9320,47 @@ .locals init (int V_0, //i
         <entry offset=""0x1b"" startLine=""12"" startColumn=""24"" endLine=""12"" endColumn=""30"" document=""1"" />
         <entry offset=""0x22"" hidden=""true"" document=""1"" />
         <entry offset=""0x24"" startLine=""12"" startColumn=""32"" endLine=""12"" endColumn=""38"" document=""1"" />
-        <entry offset=""0x26"" startLine=""13"" startColumn=""24"" endLine=""13"" endColumn=""30"" document=""1"" />
-        <entry offset=""0x2d"" hidden=""true"" document=""1"" />
-        <entry offset=""0x2f"" startLine=""13"" startColumn=""24"" endLine=""13"" endColumn=""30"" document=""1"" />
-        <entry offset=""0x36"" hidden=""true"" document=""1"" />
-        <entry offset=""0x38"" startLine=""13"" startColumn=""32"" endLine=""13"" endColumn=""38"" document=""1"" />
-        <entry offset=""0x3a"" hidden=""true"" document=""1"" />
-        <entry offset=""0x3c"" startLine=""14"" startColumn=""24"" endLine=""14"" endColumn=""30"" document=""1"" />
-        <entry offset=""0x43"" hidden=""true"" document=""1"" />
-        <entry offset=""0x45"" startLine=""14"" startColumn=""32"" endLine=""14"" endColumn=""38"" document=""1"" />
-        <entry offset=""0x47"" startLine=""15"" startColumn=""24"" endLine=""15"" endColumn=""30"" document=""1"" />
-        <entry offset=""0x4e"" hidden=""true"" document=""1"" />
-        <entry offset=""0x50"" startLine=""15"" startColumn=""24"" endLine=""15"" endColumn=""30"" document=""1"" />
+        <entry offset=""0x29"" hidden=""true"" document=""1"" />
+        <entry offset=""0x31"" startLine=""13"" startColumn=""24"" endLine=""13"" endColumn=""30"" document=""1"" />
+        <entry offset=""0x38"" hidden=""true"" document=""1"" />
+        <entry offset=""0x48"" startLine=""13"" startColumn=""32"" endLine=""13"" endColumn=""38"" document=""1"" />
+        <entry offset=""0x4a"" hidden=""true"" document=""1"" />
+        <entry offset=""0x4c"" startLine=""14"" startColumn=""24"" endLine=""14"" endColumn=""30"" document=""1"" />
+        <entry offset=""0x53"" hidden=""true"" document=""1"" />
+        <entry offset=""0x55"" startLine=""14"" startColumn=""32"" endLine=""14"" endColumn=""38"" document=""1"" />
         <entry offset=""0x57"" hidden=""true"" document=""1"" />
-        <entry offset=""0x59"" startLine=""15"" startColumn=""32"" endLine=""15"" endColumn=""38"" document=""1"" />
-        <entry offset=""0x5b"" hidden=""true"" document=""1"" />
-        <entry offset=""0x5d"" startLine=""16"" startColumn=""24"" endLine=""16"" endColumn=""30"" document=""1"" />
-        <entry offset=""0x64"" hidden=""true"" document=""1"" />
-        <entry offset=""0x66"" startLine=""16"" startColumn=""32"" endLine=""16"" endColumn=""38"" document=""1"" />
-        <entry offset=""0x68"" startLine=""17"" startColumn=""24"" endLine=""17"" endColumn=""30"" document=""1"" />
-        <entry offset=""0x6f"" hidden=""true"" document=""1"" />
-        <entry offset=""0x71"" startLine=""17"" startColumn=""24"" endLine=""17"" endColumn=""30"" document=""1"" />
+        <entry offset=""0x5f"" startLine=""15"" startColumn=""24"" endLine=""15"" endColumn=""30"" document=""1"" />
+        <entry offset=""0x66"" hidden=""true"" document=""1"" />
+        <entry offset=""0x76"" startLine=""15"" startColumn=""32"" endLine=""15"" endColumn=""38"" document=""1"" />
         <entry offset=""0x78"" hidden=""true"" document=""1"" />
-        <entry offset=""0x7a"" startLine=""17"" startColumn=""32"" endLine=""17"" endColumn=""38"" document=""1"" />
-        <entry offset=""0x7c"" hidden=""true"" document=""1"" />
-        <entry offset=""0x7e"" startLine=""18"" startColumn=""24"" endLine=""18"" endColumn=""30"" document=""1"" />
+        <entry offset=""0x7a"" startLine=""16"" startColumn=""24"" endLine=""16"" endColumn=""30"" document=""1"" />
+        <entry offset=""0x81"" hidden=""true"" document=""1"" />
+        <entry offset=""0x83"" startLine=""16"" startColumn=""32"" endLine=""16"" endColumn=""38"" document=""1"" />
         <entry offset=""0x85"" hidden=""true"" document=""1"" />
-        <entry offset=""0x87"" startLine=""18"" startColumn=""32"" endLine=""18"" endColumn=""38"" document=""1"" />
-        <entry offset=""0x89"" startLine=""19"" startColumn=""24"" endLine=""19"" endColumn=""30"" document=""1"" />
-        <entry offset=""0x90"" hidden=""true"" document=""1"" />
-        <entry offset=""0x92"" startLine=""19"" startColumn=""32"" endLine=""19"" endColumn=""38"" document=""1"" />
-        <entry offset=""0x94"" startLine=""21"" startColumn=""5"" endLine=""21"" endColumn=""6"" document=""1"" />
+        <entry offset=""0x8e"" startLine=""17"" startColumn=""24"" endLine=""17"" endColumn=""30"" document=""1"" />
+        <entry offset=""0x95"" hidden=""true"" document=""1"" />
+        <entry offset=""0xa6"" startLine=""17"" startColumn=""32"" endLine=""17"" endColumn=""38"" document=""1"" />
+        <entry offset=""0xa8"" hidden=""true"" document=""1"" />
+        <entry offset=""0xab"" startLine=""18"" startColumn=""24"" endLine=""18"" endColumn=""30"" document=""1"" />
+        <entry offset=""0xb2"" hidden=""true"" document=""1"" />
+        <entry offset=""0xb4"" startLine=""18"" startColumn=""32"" endLine=""18"" endColumn=""38"" document=""1"" />
+        <entry offset=""0xb6"" startLine=""19"" startColumn=""24"" endLine=""19"" endColumn=""30"" document=""1"" />
+        <entry offset=""0xbd"" hidden=""true"" document=""1"" />
+        <entry offset=""0xbf"" startLine=""19"" startColumn=""32"" endLine=""19"" endColumn=""38"" document=""1"" />
+        <entry offset=""0xc1"" startLine=""21"" startColumn=""5"" endLine=""21"" endColumn=""6"" document=""1"" />
       </sequencePoints>
-      <scope startOffset=""0x0"" endOffset=""0x95"">
-        <scope startOffset=""0x1b"" endOffset=""0x26"">
-          <local name=""i"" il_index=""0"" il_start=""0x1b"" il_end=""0x26"" attributes=""0"" />
+      <scope startOffset=""0x0"" endOffset=""0xc2"">
+        <scope startOffset=""0x1b"" endOffset=""0x29"">
+          <local name=""i"" il_index=""1"" il_start=""0x1b"" il_end=""0x29"" attributes=""0"" />
         </scope>
-        <scope startOffset=""0x3a"" endOffset=""0x47"">
-          <local name=""i"" il_index=""1"" il_start=""0x3a"" il_end=""0x47"" attributes=""0"" />
+        <scope startOffset=""0x4a"" endOffset=""0x57"">
+          <local name=""i"" il_index=""2"" il_start=""0x4a"" il_end=""0x57"" attributes=""0"" />
         </scope>
-        <scope startOffset=""0x5b"" endOffset=""0x68"">
-          <local name=""i"" il_index=""2"" il_start=""0x5b"" il_end=""0x68"" attributes=""0"" />
+        <scope startOffset=""0x78"" endOffset=""0x85"">
+          <local name=""i"" il_index=""3"" il_start=""0x78"" il_end=""0x85"" attributes=""0"" />
         </scope>
-        <scope startOffset=""0x7c"" endOffset=""0x89"">
-          <local name=""i"" il_index=""3"" il_start=""0x7c"" il_end=""0x89"" attributes=""0"" />
+        <scope startOffset=""0xa8"" endOffset=""0xb6"">
+          <local name=""i"" il_index=""4"" il_start=""0xa8"" il_end=""0xb6"" attributes=""0"" />
         </scope>
       </scope>
     </method>
@@ -9346,50 +9403,63 @@ public static void M2(object o, bool b1, bool b2, bool b3)
             var compVerifier = CompileAndVerify(compilation, expectedOutput: "abc");
             compVerifier.VerifyIL("Program.M2",
 @"{
-  // Code size       79 (0x4f)
-  .maxstack  1
-  .locals init (Generic<object, System.ValueTuple<int, int>> V_0, //g
-                Generic<dynamic, System.ValueTuple<int, int>> V_1, //g
-                object V_2,
-                object V_3)
+  // Code size       98 (0x62)
+  .maxstack  2
+  .locals init (int V_0,
+                Generic<object, System.ValueTuple<int, int>> V_1, //g
+                Generic<dynamic, System.ValueTuple<int, int>> V_2, //g
+                object V_3,
+                object V_4)
   IL_0000:  nop
   IL_0001:  ldarg.0
-  IL_0002:  stloc.3
-  IL_0003:  ldloc.3
-  IL_0004:  stloc.2
-  IL_0005:  ldloc.2
-  IL_0006:  isinst     ""Generic<object, System.ValueTuple<int, int>>""
-  IL_000b:  stloc.0
-  IL_000c:  ldloc.0
-  IL_000d:  brtrue.s   IL_0011
-  IL_000f:  br.s       IL_0028
-  IL_0011:  ldarg.1
-  IL_0012:  brtrue.s   IL_0016
-  IL_0014:  br.s       IL_0023
-  IL_0016:  ldstr      ""a""
-  IL_001b:  call       ""void System.Console.Write(string)""
-  IL_0020:  nop
-  IL_0021:  br.s       IL_004e
-  IL_0023:  ldarg.2
-  IL_0024:  brtrue.s   IL_002d
-  IL_0026:  br.s       IL_003a
-  IL_0028:  ldarg.2
-  IL_0029:  brtrue.s   IL_002d
-  IL_002b:  br.s       IL_004e
-  IL_002d:  ldstr      ""b""
-  IL_0032:  call       ""void System.Console.Write(string)""
-  IL_0037:  nop
-  IL_0038:  br.s       IL_004e
-  IL_003a:  ldloc.0
-  IL_003b:  stloc.1
-  IL_003c:  ldarg.3
-  IL_003d:  brtrue.s   IL_0041
-  IL_003f:  br.s       IL_004e
-  IL_0041:  ldstr      ""c""
-  IL_0046:  call       ""void System.Console.Write(string)""
-  IL_004b:  nop
-  IL_004c:  br.s       IL_004e
-  IL_004e:  ret
+  IL_0002:  stloc.s    V_4
+  IL_0004:  ldloc.s    V_4
+  IL_0006:  stloc.3
+  IL_0007:  ldloc.3
+  IL_0008:  isinst     ""Generic<object, System.ValueTuple<int, int>>""
+  IL_000d:  stloc.1
+  IL_000e:  ldloc.1
+  IL_000f:  brtrue.s   IL_0013
+  IL_0011:  br.s       IL_0029
+  IL_0013:  ldarg.1
+  IL_0014:  brtrue.s   IL_0018
+  IL_0016:  br.s       IL_0025
+  IL_0018:  ldstr      ""a""
+  IL_001d:  call       ""void System.Console.Write(string)""
+  IL_0022:  nop
+  IL_0023:  br.s       IL_0061
+  IL_0025:  ldc.i4.1
+  IL_0026:  stloc.0
+  IL_0027:  br.s       IL_002d
+  IL_0029:  ldc.i4.3
+  IL_002a:  stloc.0
+  IL_002b:  br.s       IL_002d
+  IL_002d:  ldarg.2
+  IL_002e:  brtrue.s   IL_0040
+  IL_0030:  ldloc.0
+  IL_0031:  ldc.i4.1
+  IL_0032:  beq.s      IL_003c
+  IL_0034:  br.s       IL_0036
+  IL_0036:  ldloc.0
+  IL_0037:  ldc.i4.3
+  IL_0038:  beq.s      IL_003e
+  IL_003a:  br.s       IL_0040
+  IL_003c:  br.s       IL_004d
+  IL_003e:  br.s       IL_0061
+  IL_0040:  ldstr      ""b""
+  IL_0045:  call       ""void System.Console.Write(string)""
+  IL_004a:  nop
+  IL_004b:  br.s       IL_0061
+  IL_004d:  ldloc.1
+  IL_004e:  stloc.2
+  IL_004f:  ldarg.3
+  IL_0050:  brtrue.s   IL_0054
+  IL_0052:  br.s       IL_0061
+  IL_0054:  ldstr      ""c""
+  IL_0059:  call       ""void System.Console.Write(string)""
+  IL_005e:  nop
+  IL_005f:  br.s       IL_0061
+  IL_0061:  ret
 }
 "
             );
diff --git a/src/Compilers/CSharp/Test/Emit/Emit/DynamicAnalysis/DynamicAnalysisResourceTests.cs b/src/Compilers/CSharp/Test/Emit/Emit/DynamicAnalysis/DynamicAnalysisResourceTests.cs
index bad1bfc6802d6..216207b541961 100644
--- a/src/Compilers/CSharp/Test/Emit/Emit/DynamicAnalysis/DynamicAnalysisResourceTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/Emit/DynamicAnalysis/DynamicAnalysisResourceTests.cs
@@ -457,6 +457,55 @@ class Student : Person { public double GPA; }
                 new SpanResult(15, 16, 15, 17, "p"));
         }
 
+        [Fact]
+        public void TestPatternSpans_WithSharedWhenExpression()
+        {
+            string source = @"
+using System;
+
+public class C
+{
+    public static void Main()                            // Method 0
+    {
+        Method1(1, b1: false, b2: false);
+    }
+
+    static string Method1(int i, bool b1, bool b2)       // Method 1
+    {
+        switch (i)
+        {
+            case not 1 when b1:
+                return ""b1"";
+            case var _ when b2:
+                return ""b2"";
+            case 1:
+                return ""1"";
+            default:
+                return ""default"";
+        }
+    }
+}
+";
+
+            var c = CreateCompilation(Parse(source + InstrumentationHelperSource, @"C:\myproject\doc1.cs"));
+            var peImage = c.EmitToArray(EmitOptions.Default.WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.TestCoverage)));
+
+            var peReader = new PEReader(peImage);
+            var reader = DynamicAnalysisDataReader.TryCreateFromPE(peReader, "<DynamicAnalysisData>");
+
+            string[] sourceLines = source.Split('\n');
+
+            VerifySpans(reader, reader.Methods[1], sourceLines,
+                new SpanResult(10, 4, 23, 5, "static string Method1(int i, bool b1, bool b2)"),
+                new SpanResult(14, 23, 14, 30, "when b1:"),
+                new SpanResult(16, 23, 16, 30, "when b2:"),
+                new SpanResult(15, 16, 15, 28, @"return ""b1"";"),
+                new SpanResult(17, 16, 17, 28, @"return ""b2"";"),
+                new SpanResult(19, 16, 19, 27, @"return ""1"";"),
+                new SpanResult(21, 16, 21, 33, @"return ""default"";"),
+                new SpanResult(12, 16, 12, 17, "i"));
+        }
+
         [Fact]
         public void TestDeconstructionSpans()
         {
@@ -1003,7 +1052,9 @@ private static void VerifySpans(DynamicAnalysisDataReader reader, DynamicAnalysi
             ArrayBuilder<string> expectedSpanSpellings = ArrayBuilder<string>.GetInstance(expected.Length);
             foreach (SpanResult expectedSpanResult in expected)
             {
-                Assert.True(sourceLines[expectedSpanResult.StartLine].Substring(expectedSpanResult.StartColumn).StartsWith(expectedSpanResult.TextStart));
+                var text = sourceLines[expectedSpanResult.StartLine].Substring(expectedSpanResult.StartColumn);
+                Assert.True(text.StartsWith(expectedSpanResult.TextStart), $"Text doesn't start with {expectedSpanResult.TextStart}. Text is: {text}");
+
                 expectedSpanSpellings.Add(string.Format("({0},{1})-({2},{3})", expectedSpanResult.StartLine, expectedSpanResult.StartColumn, expectedSpanResult.EndLine, expectedSpanResult.EndColumn));
             }
 
diff --git a/src/Compilers/CSharp/Test/Emit/Emit/DynamicAnalysis/DynamicInstrumentationTests.cs b/src/Compilers/CSharp/Test/Emit/Emit/DynamicAnalysis/DynamicInstrumentationTests.cs
index 2df83857e1d4d..d72fadf646152 100644
--- a/src/Compilers/CSharp/Test/Emit/Emit/DynamicAnalysis/DynamicInstrumentationTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/Emit/DynamicAnalysis/DynamicInstrumentationTests.cs
@@ -11,7 +11,6 @@
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Test.Utilities;
 using Xunit;
-using Roslyn.Test.Utilities;
 using static Microsoft.CodeAnalysis.Test.Utilities.CSharpInstrumentationChecker;
 
 namespace Microsoft.CodeAnalysis.CSharp.DynamicAnalysis.UnitTests
@@ -1517,6 +1516,85 @@ File 1
             verifier.VerifyDiagnostics(Diagnostic(ErrorCode.WRN_UnassignedInternalField, "Subject").WithArguments("Teacher.Subject", "null").WithLocation(37, 40));
         }
 
+        /// <see cref="DynamicAnalysisResourceTests.TestPatternSpans_WithSharedWhenExpression"/>
+        /// for meaning of the spans
+        [Fact]
+        public void PatternsCoverage_WithSharedWhenExpression()
+        {
+            string source = @"
+using System;
+
+public class C
+{
+    public static void Main()
+    {
+        TestMain();
+        Microsoft.CodeAnalysis.Runtime.Instrumentation.FlushPayload();
+    }
+
+    public static void TestMain()
+    {
+        Method3(1, b1: false, b2: false);
+    }
+
+    static string Method3(int i, bool b1, bool b2) // Method 3
+    {
+        switch (i)
+        {
+            case not 1 when b1:
+                return ""b1"";
+            case var _ when b2:
+                return ""b2"";
+            case 1:
+                return ""1"";
+            default:
+                return ""default"";
+        }
+    }
+}
+";
+            string expectedOutput = @"Flushing
+Method 1
+File 1
+True
+True
+True
+Method 2
+File 1
+True
+True
+Method 3
+File 1
+True
+False
+True
+False
+False
+True
+False
+True
+Method 6
+File 1
+True
+True
+False
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+True
+";
+            CompileAndVerify(source + InstrumentationHelperSource, expectedOutput: expectedOutput);
+        }
+
         [Fact]
         public void DeconstructionStatementCoverage()
         {
diff --git a/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueTest.GenerationVerifier.cs b/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueTest.GenerationVerifier.cs
index 54d0a13a58ee5..7a0ea905875d6 100644
--- a/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueTest.GenerationVerifier.cs
+++ b/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueTest.GenerationVerifier.cs
@@ -50,6 +50,18 @@ internal void VerifyMemberRefNames(params string[] expected)
                 AssertEx.Equal(expected, actual, message: GetAssertMessage("MemberRefs don't match"));
             }
 
+            internal void VerifyFieldDefNames(params string[] expected)
+            {
+                var actual = _readers.GetStrings(_metadataReader.GetFieldDefNames());
+                AssertEx.Equal(expected, actual, message: GetAssertMessage("FieldDefs don't match"));
+            }
+
+            internal void VerifyPropertyDefNames(params string[] expected)
+            {
+                var actual = _readers.GetStrings(_metadataReader.GetPropertyDefNames());
+                AssertEx.Equal(expected, actual, message: GetAssertMessage("PropertyDefs don't match"));
+            }
+
             internal void VerifyTableSize(TableIndex table, int expected)
             {
                 AssertEx.AreEqual(expected, _metadataReader.GetTableRowCount(table), message: GetAssertMessage($"{table} table size doesnt't match"));
@@ -74,6 +86,11 @@ internal void VerifyEncMapDefinitions(IEnumerable<EntityHandle> expected)
             {
                 AssertEx.Equal(expected, _metadataReader.GetEditAndContinueMapEntries().Where(e => IsDefinition(e.Kind)), itemInspector: EncMapRowToString, message: GetAssertMessage("EncMap definitions don't match"));
             }
+
+            internal void VerifyCustomAttributes(IEnumerable<CustomAttributeRow> expected)
+            {
+                AssertEx.Equal(expected, _metadataReader.GetCustomAttributeRows(), itemInspector: AttributeRowToString);
+            }
         }
     }
 }
diff --git a/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueTests.cs b/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueTests.cs
index 47facf0e503f7..653e9bb86318a 100644
--- a/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueTests.cs
@@ -1038,6 +1038,171 @@ static void Main() { }
                 Handle(4, TableIndex.AssemblyRef));
         }
 
+        [Fact]
+        public void Lambda_Attributes()
+        {
+            var source0 = MarkedSource(@"
+class C
+{
+    void F()
+    {
+        var x = <N:0>(int a) => a</N:0>;
+    }
+}");
+            var source1 = MarkedSource(@"
+class C
+{
+    void F()
+    {
+        var x = <N:0>[System.Obsolete](int a) => a</N:0>;
+    }
+}");
+
+            var compilation0 = CreateCompilation(source0.Tree, options: ComSafeDebugDll.WithMetadataImportOptions(MetadataImportOptions.All));
+            var compilation1 = compilation0.WithSource(source1.Tree);
+
+            var v0 = CompileAndVerify(compilation0);
+            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>", "C", "<>c");
+            CheckNames(reader0, reader0.GetMethodDefNames(), "F", ".ctor", ".cctor", ".ctor", "<F>b__0_0");
+            CheckAttributes(reader0,
+                new CustomAttributeRow(Handle(1, TableIndex.Assembly), Handle(1, TableIndex.MemberRef)),
+                new CustomAttributeRow(Handle(1, TableIndex.Assembly), Handle(2, TableIndex.MemberRef)),
+                new CustomAttributeRow(Handle(1, TableIndex.Assembly), Handle(3, TableIndex.MemberRef)),
+                new CustomAttributeRow(Handle(3, TableIndex.TypeDef), Handle(4, TableIndex.MemberRef)));
+
+            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}",
+                "C.<>c: {<>9__0_0, <F>b__0_0}");
+
+            CheckAttributes(reader1,
+                new CustomAttributeRow(Handle(5, TableIndex.MethodDef), Handle(8, TableIndex.MemberRef)));
+
+            CheckEncLogDefinitions(reader1,
+                Row(2, TableIndex.StandAloneSig, EditAndContinueOperation.Default),
+                Row(1, TableIndex.MethodDef, EditAndContinueOperation.Default),
+                Row(5, TableIndex.MethodDef, EditAndContinueOperation.Default),
+                Row(1, TableIndex.Param, EditAndContinueOperation.Default),
+                Row(5, TableIndex.CustomAttribute, EditAndContinueOperation.Default)); // row 5 = new custom attribute
+
+            CheckEncMapDefinitions(reader1,
+                Handle(1, TableIndex.MethodDef),
+                Handle(5, TableIndex.MethodDef),
+                Handle(1, TableIndex.Param),
+                Handle(5, TableIndex.CustomAttribute),
+                Handle(2, TableIndex.StandAloneSig));
+        }
+
+        [Fact]
+        public void Lambda_SynthesizedDelegate()
+        {
+            var source0 = MarkedSource(@"
+class C
+{
+    void F()
+    {
+        var x = <N:0>(ref int a, int b) => a</N:0>;
+    }
+}");
+            var source1 = MarkedSource(@"
+class C
+{
+    void F()
+    {
+        var x = <N:0>(ref int a, int b) => b</N:0>;
+
+        var y = <N:1>(int a, ref int b) => a</N:1>;
+
+        var z = <N:2>(int _1, int _2, int _3, int _4, int _5, int _6, ref int _7, int _8, int _9, int _10, int _11, int _12, int _13, int _14, int _15, int _16, int _17, int _18, int _19, int _20, int _21, int _22, int _23, int _24, int _25, int _26, int _27, int _28, int _29, int _30, int _31, int _32, ref int _33) => { }</N:2>;
+    }
+}");
+            var source2 = MarkedSource(@"
+class C
+{
+    void F()
+    {
+        var x = <N:0>(ref int a, int b) => b</N:0>;
+
+        var y = <N:1>(int a, ref int b) => b</N:1>;
+
+        var z = <N:2>(int _1, int _2, int _3, int _4, int _5, int _6, ref int _7, int _8, int _9, int _10, int _11, int _12, int _13, int _14, int _15, int _16, int _17, int _18, int _19, int _20, int _21, int _22, int _23, int _24, int _25, int _26, int _27, int _28, int _29, int _30, int _31, int _32, ref int _33) => { _1.ToString(); }</N:2>;
+    }
+}");
+
+            var compilation0 = CreateCompilation(source0.Tree, options: ComSafeDebugDll.WithMetadataImportOptions(MetadataImportOptions.All));
+            var compilation1 = compilation0.WithSource(source1.Tree);
+            var compilation2 = compilation1.WithSource(source2.Tree);
+
+            var v0 = CompileAndVerify(compilation0);
+            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>", "<>F{00000001}`3", "C", "<>c");       // <>F{00000001}`3 is the synthesized delegate for the lambda
+            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(), "<>A{00001000,00000001}`33", "<>F{00000004}`3");                              // new synthesized delegate for the new lambda
+            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());                                     // No new delegate added, reusing from gen 0 and 1
+            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}");
+        }
+
         [WorkItem(962219, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/962219")]
         [Fact]
         public void PartialMethod()
@@ -1384,6 +1549,201 @@ class A : System.Attribute { }
                 Handle(2, TableIndex.AssemblyRef));
         }
 
+        [Fact]
+        public void TypePropertyField_Attributes()
+        {
+            using var _ = new EditAndContinueTest(options: TestOptions.DebugDll, targetFramework: TargetFramework.NetStandard20)
+                .AddGeneration(
+                    source: @"
+enum E
+{
+    A
+}
+
+class C
+{
+    private int _x;
+    public int X { get; }
+}
+
+delegate int D(int x);
+",
+                    validator: g =>
+                    {
+                        g.VerifyTypeDefNames("<Module>", "E", "C", "D");
+                        g.VerifyMethodDefNames("get_X", ".ctor", ".ctor", "Invoke", "BeginInvoke", "EndInvoke");
+                        g.VerifyPropertyDefNames("X");
+                        g.VerifyFieldDefNames("value__", "A", "_x", "<X>k__BackingField");
+                        g.VerifyTableSize(TableIndex.CustomAttribute, 6);
+                    })
+
+                .AddGeneration(
+                    source: @"
+using System.ComponentModel;
+
+[Description(""E"")]
+enum E
+{
+    [Description(""A"")]
+    A
+}
+
+[Description(""C"")]
+class C
+{
+    [Description(""_x"")]
+    private int _x;
+    [Description(""X"")]
+    public int X { get; }
+}
+
+[Description(""D"")]
+delegate int D(int x);
+",
+                    edits: new[]
+                    {
+                        Edit(SemanticEditKind.Update, c => c.GetMember("E")),
+                        Edit(SemanticEditKind.Update, c => c.GetMember("E.A")),
+                        Edit(SemanticEditKind.Update, c => c.GetMember("C")),
+                        Edit(SemanticEditKind.Update, c => c.GetMember("C._x")),
+                        Edit(SemanticEditKind.Update, c => c.GetMember("C.X")),
+                        Edit(SemanticEditKind.Update, c => c.GetMember("D"))
+                    },
+                    validator: g =>
+                    {
+                        g.VerifyTypeDefNames("E", "C", "D");
+                        g.VerifyMethodDefNames();
+                        g.VerifyTableSize(TableIndex.CustomAttribute, 6);
+                        g.VerifyCustomAttributes(new[]
+                        {
+                            new CustomAttributeRow(Handle(1, TableIndex.Property), Handle(7, TableIndex.MemberRef)), // C.X
+                            new CustomAttributeRow(Handle(2, TableIndex.Field), Handle(7, TableIndex.MemberRef)),    // E.A
+                            new CustomAttributeRow(Handle(2, TableIndex.TypeDef), Handle(7, TableIndex.MemberRef)),  // E
+                            new CustomAttributeRow(Handle(3, TableIndex.Field), Handle(7, TableIndex.MemberRef)),    // C._x
+                            new CustomAttributeRow(Handle(3, TableIndex.TypeDef), Handle(7, TableIndex.MemberRef)),  // C
+                            new CustomAttributeRow(Handle(4, TableIndex.TypeDef), Handle(7, TableIndex.MemberRef))   // D
+                        });
+                        g.VerifyEncLogDefinitions(new[]
+                        {
+                            Row(2, TableIndex.TypeDef, EditAndContinueOperation.Default),
+                            Row(3, TableIndex.TypeDef, EditAndContinueOperation.Default),
+                            Row(4, TableIndex.TypeDef, EditAndContinueOperation.Default),
+                            Row(2, TableIndex.Field, EditAndContinueOperation.Default),
+                            Row(3, TableIndex.Field, EditAndContinueOperation.Default),
+                            Row(1, TableIndex.Property, EditAndContinueOperation.Default),
+                            Row(2, TableIndex.Constant, EditAndContinueOperation.Default),
+                            Row(7, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                            Row(8, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                            Row(9, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                            Row(10, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                            Row(11, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                            Row(12, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                            Row(2, TableIndex.MethodSemantics, EditAndContinueOperation.Default)
+                        });
+                        g.VerifyEncMapDefinitions(new[]
+                        {
+                            Handle(2, TableIndex.TypeDef),
+                            Handle(3, TableIndex.TypeDef),
+                            Handle(4, TableIndex.TypeDef),
+                            Handle(2, TableIndex.Field),
+                            Handle(3, TableIndex.Field),
+                            Handle(2, TableIndex.Constant),
+                            Handle(7, TableIndex.CustomAttribute),
+                            Handle(8, TableIndex.CustomAttribute),
+                            Handle(9, TableIndex.CustomAttribute),
+                            Handle(10, TableIndex.CustomAttribute),
+                            Handle(11, TableIndex.CustomAttribute),
+                            Handle(12, TableIndex.CustomAttribute),
+                            Handle(1, TableIndex.Property),
+                            Handle(2, TableIndex.MethodSemantics)
+                        });
+                    })
+
+                .AddGeneration(
+                    source: @"
+using System.ComponentModel;
+
+[Description(""E_2"")]
+enum E
+{
+    [Description(""A_2"")]
+    A
+}
+
+[Description(""C_2"")]
+class C
+{
+    [Description(""_x_2"")]
+    private int _x;
+    [Description(""X_2"")]
+    public int X { get; }
+}
+
+[Description(""D_2"")]
+delegate int D(int x);
+",
+                    edits: new[]
+                    {
+                        Edit(SemanticEditKind.Update, c => c.GetMember("E")),
+                        Edit(SemanticEditKind.Update, c => c.GetMember("E.A")),
+                        Edit(SemanticEditKind.Update, c => c.GetMember("C")),
+                        Edit(SemanticEditKind.Update, c => c.GetMember("C._x")),
+                        Edit(SemanticEditKind.Update, c => c.GetMember("C.X")),
+                        Edit(SemanticEditKind.Update, c => c.GetMember("D"))
+                    },
+                    validator: g =>
+                    {
+                        g.VerifyTypeDefNames("E", "C", "D");
+                        g.VerifyMethodDefNames();
+                        g.VerifyTableSize(TableIndex.CustomAttribute, 6);
+                        g.VerifyCustomAttributes(new[]
+                        {
+                            new CustomAttributeRow(Handle(1, TableIndex.Property), Handle(8, TableIndex.MemberRef)), // C.X
+                            new CustomAttributeRow(Handle(2, TableIndex.Field), Handle(8, TableIndex.MemberRef)),    // E.A
+                            new CustomAttributeRow(Handle(2, TableIndex.TypeDef), Handle(8, TableIndex.MemberRef)),  // E
+                            new CustomAttributeRow(Handle(3, TableIndex.Field), Handle(8, TableIndex.MemberRef)),    // C._x
+                            new CustomAttributeRow(Handle(3, TableIndex.TypeDef), Handle(8, TableIndex.MemberRef)),  // C
+                            new CustomAttributeRow(Handle(4, TableIndex.TypeDef), Handle(8, TableIndex.MemberRef))   // D
+                        });
+                        g.VerifyEncLogDefinitions(new[]
+                        {
+                            Row(2, TableIndex.TypeDef, EditAndContinueOperation.Default),
+                            Row(3, TableIndex.TypeDef, EditAndContinueOperation.Default),
+                            Row(4, TableIndex.TypeDef, EditAndContinueOperation.Default),
+                            Row(2, TableIndex.Field, EditAndContinueOperation.Default),
+                            Row(3, TableIndex.Field, EditAndContinueOperation.Default),
+                            Row(1, TableIndex.Property, EditAndContinueOperation.Default),
+                            Row(3, TableIndex.Constant, EditAndContinueOperation.Default),
+                            Row(7, TableIndex.CustomAttribute, EditAndContinueOperation.Default),   // Same row numbers as previous gen
+                            Row(8, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                            Row(9, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                            Row(10, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                            Row(11, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                            Row(12, TableIndex.CustomAttribute, EditAndContinueOperation.Default),
+                            Row(3, TableIndex.MethodSemantics, EditAndContinueOperation.Default)
+                        });
+                        g.VerifyEncMapDefinitions(new[]
+                        {
+                            Handle(2, TableIndex.TypeDef),
+                            Handle(3, TableIndex.TypeDef),
+                            Handle(4, TableIndex.TypeDef),
+                            Handle(2, TableIndex.Field),
+                            Handle(3, TableIndex.Field),
+                            Handle(3, TableIndex.Constant),
+                            Handle(7, TableIndex.CustomAttribute),
+                            Handle(8, TableIndex.CustomAttribute),
+                            Handle(9, TableIndex.CustomAttribute),
+                            Handle(10, TableIndex.CustomAttribute),
+                            Handle(11, TableIndex.CustomAttribute),
+                            Handle(12, TableIndex.CustomAttribute),
+                            Handle(1, TableIndex.Property),
+                            Handle(3, TableIndex.MethodSemantics)
+                        });
+                    })
+
+                .Verify();
+        }
+
         /// <summary>
         /// Add a method that requires entries in the ParameterDefs table.
         /// Specifically, normal parameters or return types with attributes.
diff --git a/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/SymbolMatcherTests.cs b/src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/SymbolMatcherTests.cs
index b2bb176e580eb..88b332ce65632 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,
                     compilation1.SourceAssembly,
                     default,
@@ -127,6 +128,7 @@ struct S
             var compilation1 = compilation0.WithSource(source);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 compilation1.SourceAssembly,
                 default,
@@ -159,6 +161,7 @@ static void M<T>(I<T> o) where T : I<T>
             var compilation1 = compilation0.WithSource(source);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 compilation1.SourceAssembly,
                 default,
@@ -193,6 +196,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,
                 compilation1.SourceAssembly,
                 default,
@@ -236,6 +240,7 @@ abstract class C
             var compilation1 = compilation0.WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 compilation1.SourceAssembly,
                 default,
@@ -286,6 +291,7 @@ abstract class C
             var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll).WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 compilation1.SourceAssembly,
                 default,
@@ -322,6 +328,7 @@ public void F(D a) {}
             var compilation1 = compilation0.WithSource(source).WithReferences(MscorlibRef, lib1.ToMetadataReference());
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 compilation1.SourceAssembly,
                 default,
@@ -362,6 +369,7 @@ class D {}
             var compilation1 = compilation0.WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 compilation1.SourceAssembly,
                 default,
@@ -399,6 +407,7 @@ class D {}
             var compilation1 = compilation0.WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 compilation1.SourceAssembly,
                 default,
@@ -437,6 +446,7 @@ struct D {}
             var compilation1 = compilation0.WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 compilation1.SourceAssembly,
                 default,
@@ -478,6 +488,7 @@ class D {}
             var compilation1 = compilation0.WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 compilation1.SourceAssembly,
                 default,
@@ -548,7 +559,7 @@ static void F()
             Assert.Equal("x1", x1.Name);
             Assert.Equal("x2", x2.Name);
 
-            var matcher = new CSharpSymbolMatcher(anonymousTypeMap0, compilation1.SourceAssembly, emitContext, peAssemblySymbol0);
+            var matcher = new CSharpSymbolMatcher(anonymousTypeMap0, null, compilation1.SourceAssembly, emitContext, peAssemblySymbol0);
 
             var mappedX1 = (Cci.IFieldDefinition)matcher.MapDefinition(x1);
             var mappedX2 = (Cci.IFieldDefinition)matcher.MapDefinition(x2);
@@ -617,7 +628,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, compilation1.SourceAssembly, emitContext, peAssemblySymbol0);
+            var matcher = new CSharpSymbolMatcher(anonymousTypeMap0, null, compilation1.SourceAssembly, emitContext, peAssemblySymbol0);
 
             var mappedX1 = (Cci.IFieldDefinition)matcher.MapDefinition(x1);
             var mappedX2 = (Cci.IFieldDefinition)matcher.MapDefinition(x2);
@@ -643,6 +654,7 @@ class C
             var compilation1 = compilation0.WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 compilation1.SourceAssembly,
                 default,
@@ -673,6 +685,7 @@ class C
             var compilation1 = compilation0.WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 compilation1.SourceAssembly,
                 default,
@@ -703,6 +716,7 @@ class C
             var compilation1 = compilation0.WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 compilation1.SourceAssembly,
                 default,
@@ -733,6 +747,7 @@ class C
             var compilation1 = compilation0.WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 compilation1.SourceAssembly,
                 default,
@@ -763,6 +778,7 @@ class C
             var compilation1 = compilation0.WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 compilation1.SourceAssembly,
                 default,
@@ -793,6 +809,7 @@ class C
             var compilation1 = compilation0.WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 compilation1.SourceAssembly,
                 default,
@@ -823,6 +840,7 @@ public struct Vector
             var compilation1 = compilation0.WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 compilation1.SourceAssembly,
                 default,
@@ -853,6 +871,7 @@ public struct Vector
             var compilation1 = compilation0.WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 compilation1.SourceAssembly,
                 default,
@@ -883,6 +902,7 @@ public class C
             var compilation1 = compilation0.WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 compilation1.SourceAssembly,
                 default,
@@ -913,6 +933,7 @@ public class C
             var compilation1 = compilation0.WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 compilation1.SourceAssembly,
                 default,
@@ -957,6 +978,7 @@ struct C
             var compilation1 = compilation0.WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 compilation1.SourceAssembly,
                 default,
@@ -1011,6 +1033,7 @@ struct C
             var compilation1 = compilation0.WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 compilation1.SourceAssembly,
                 default,
@@ -1072,7 +1095,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, compilation1.SourceAssembly, emitContext, peAssemblySymbol0);
+            var matcher = new CSharpSymbolMatcher(null, null, compilation1.SourceAssembly, emitContext, peAssemblySymbol0);
 
             var mappedProperty = (Cci.IPropertyDefinition)matcher.MapDefinition(property.GetCciAdapter());
 
@@ -1100,6 +1123,7 @@ class C
             var compilation1 = compilation0.WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 compilation1.SourceAssembly,
                 default,
@@ -1131,6 +1155,7 @@ class C
             var compilation1 = compilation0.WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 compilation1.SourceAssembly,
                 default,
@@ -1162,6 +1187,7 @@ class C
             var compilation1 = compilation0.WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 compilation1.SourceAssembly,
                 default,
@@ -1191,6 +1217,7 @@ class C
             var compilation1 = compilation0.WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 compilation1.SourceAssembly,
                 default,
@@ -1268,7 +1295,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, compilation1.SourceAssembly, emitContext, peAssemblySymbol0);
+            var matcher = new CSharpSymbolMatcher(anonymousTypeMap0, null, compilation1.SourceAssembly, emitContext, peAssemblySymbol0);
 
             var mappedY1 = (Cci.IFieldDefinition)matcher.MapDefinition(y1);
             var mappedY2 = (Cci.IFieldDefinition)matcher.MapDefinition(y2);
@@ -1302,6 +1329,7 @@ event Action F { add { } remove { } }
             var compilation1 = compilation0.WithSource(source);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 compilation1.SourceAssembly,
                 default,
@@ -1357,6 +1385,7 @@ unsafe class C
             var compilation1 = compilation0.WithSource(source);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 compilation1.SourceAssembly,
                 default,
@@ -1397,6 +1426,7 @@ unsafe class C
             var compilation1 = compilation0.WithSource(source2);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 compilation1.SourceAssembly,
                 default,
@@ -1454,6 +1484,7 @@ static void verify(string source1, string source2)
                 var compilation1 = compilation0.WithSource(source2);
 
                 var matcher = new CSharpSymbolMatcher(
+                    null,
                     null,
                     compilation1.SourceAssembly,
                     default,
@@ -1483,6 +1514,7 @@ public record R
             var compilation1 = compilation0.WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 compilation1.SourceAssembly,
                 default,
@@ -1511,6 +1543,7 @@ public record R
             var compilation1 = compilation0.WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 compilation1.SourceAssembly,
                 default,
@@ -1540,6 +1573,7 @@ public record R
             var compilation1 = compilation0.WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 compilation1.SourceAssembly,
                 default,
@@ -1567,6 +1601,7 @@ public record R(int X)
             var compilation1 = compilation0.WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 compilation1.SourceAssembly,
                 default,
@@ -1599,6 +1634,7 @@ public R(int X)
             var compilation1 = compilation0.WithSource(source1);
 
             var matcher = new CSharpSymbolMatcher(
+                null,
                 null,
                 compilation1.SourceAssembly,
                 default,
@@ -1614,5 +1650,79 @@ public R(int X)
             var other = matcher.MapDefinition(member.GetCciAdapter());
             Assert.NotNull(other);
         }
+
+        [Fact]
+        public void SynthesizedDelegates()
+        {
+            var source0 = @"
+using System;
+
+class C
+{
+    static void F()
+    {
+        var _1 = (int a, ref int b) => a;
+        var _2 = (in int a, int b) => { };
+
+        var _3 = (int _1, int _2, int _3, int _4, int _5, int _6, int _7, int _8, int _9, int _10, int _11, int _12, int _13, int _14, int _15, int _16, int _17, int _18, int _19, int _20, int _21, int _22, int _23, int _24, int _25, int _26, int _27, int _28, int _29, int _30, int _31, int _32, ref int _33) => { };
+    }
+}
+";
+            var source1 = @"
+using System;
+
+class C
+{
+    static void F()
+    {
+        var _1 = (int c, ref int d) => c;
+        var _2 = (in int c, int d) => { d.ToString(); };
+
+        var _3 = (int _1, int _2, int _3, int _4, int _5, int _6, int _7, int _8, int _9, int _10, int _11, int _12, int _13, int _14, int _15, int _16, int _17, int _18, int _19, int _20, int _21, int _22, int _23, int _24, int _25, int _26, int _27, int _28, int _29, int _30, int _31, int _32, ref int _33) => { _1.ToString(); };
+    }
+}";
+
+            var peAssemblySymbol0 = CreatePEAssemblySymbol(source0);
+            var peModule0 = (PEModuleSymbol)peAssemblySymbol0.Modules[0];
+
+            var reader0 = peModule0.Module.MetadataReader;
+            var decoder0 = new MetadataDecoder(peModule0);
+
+            var synthesizedDelegates0 = PEDeltaAssemblyBuilder.GetSynthesizedDelegateMapFromMetadata(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);
+            Assert.Equal(3, synthesizedDelegates0.Count);
+
+            var compilation1 = CreateCompilation(source1, options: TestOptions.DebugDll);
+
+            var testData = new CompilationTestData();
+            compilation1.EmitToArray(testData: testData);
+            var peAssemblyBuilder = (PEAssemblyBuilder)testData.Module;
+
+            var c = compilation1.GetMember<NamedTypeSymbol>("C");
+            var displayClass = peAssemblyBuilder.GetSynthesizedTypes(c).Single();
+            Assert.Equal("<>c", displayClass.Name);
+
+            var emitContext = new EmitContext(peAssemblyBuilder, null, new DiagnosticBag(), metadataOnly: false, includePrivateMembers: true);
+
+            var fields = displayClass.GetFields(emitContext).ToArray();
+            var field1 = fields[1];
+            var field2 = fields[2];
+            var field3 = fields[3];
+            Assert.Equal("<>9__0_0", field1.Name);
+            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 mappedField1 = (Cci.IFieldDefinition)matcher.MapDefinition(field1);
+            var mappedField2 = (Cci.IFieldDefinition)matcher.MapDefinition(field2);
+            var mappedField3 = (Cci.IFieldDefinition)matcher.MapDefinition(field3);
+
+            Assert.Equal("<>9__0_0", mappedField1.Name);
+            Assert.Equal("<>9__0_1", mappedField2.Name);
+            Assert.Equal("<>9__0_2", mappedField3.Name);
+        }
     }
 }
diff --git a/src/Compilers/CSharp/Test/Emit/PDB/PDBTests.cs b/src/Compilers/CSharp/Test/Emit/PDB/PDBTests.cs
index 5f8f7985e1404..fa2de03a47696 100644
--- a/src/Compilers/CSharp/Test/Emit/PDB/PDBTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/PDB/PDBTests.cs
@@ -8463,329 +8463,341 @@ static int Main()
             var verifier = CompileAndVerify(c, verify: Verification.Skipped);
 
             verifier.VerifyIL("Program.Main", sequencePoints: "Program.Main", expectedIL: @"
-    {
-      // Code size      432 (0x1b0)
-      .maxstack  3
-      .locals init (int V_0, //x
-                    object V_1, //y
-                    object V_2, //z
-                    int V_3, //p
-                    int V_4, //q
-                    int V_5, //p
-                    int V_6, //z
-                    object V_7,
-                    System.Runtime.CompilerServices.ITuple V_8,
-                    int V_9,
-                    double V_10,
-                    C V_11,
-                    object V_12,
-                    C V_13,
-                    D V_14,
-                    int V_15,
-                    D V_16,
-                    int V_17,
-                    C V_18,
-                    object V_19,
-                    int V_20)
-      // sequence point: {
-      IL_0000:  nop
-      // sequence point: switch (F())
-      IL_0001:  call       ""object Program.F()""
-      IL_0006:  stloc.s    V_19
-      // sequence point: <hidden>
-      IL_0008:  ldloc.s    V_19
-      IL_000a:  stloc.s    V_7
-      // sequence point: <hidden>
-      IL_000c:  ldloc.s    V_7
-      IL_000e:  isinst     ""int""
-      IL_0013:  brfalse.s  IL_0022
-      IL_0015:  ldloc.s    V_7
-      IL_0017:  unbox.any  ""int""
-      IL_001c:  stloc.0
-      // sequence point: <hidden>
-      IL_001d:  br         IL_014d
-      IL_0022:  ldloc.s    V_7
-      IL_0024:  isinst     ""bool""
-      IL_0029:  brtrue     IL_015e
-      IL_002e:  ldloc.s    V_7
-      IL_0030:  isinst     ""System.Runtime.CompilerServices.ITuple""
-      IL_0035:  stloc.s    V_8
-      IL_0037:  ldloc.s    V_8
-      IL_0039:  brfalse.s  IL_0080
-      IL_003b:  ldloc.s    V_8
-      IL_003d:  callvirt   ""int System.Runtime.CompilerServices.ITuple.Length.get""
-      IL_0042:  stloc.s    V_9
-      // sequence point: <hidden>
-      IL_0044:  ldloc.s    V_9
-      IL_0046:  ldc.i4.2
-      IL_0047:  bne.un.s   IL_0060
-      IL_0049:  ldloc.s    V_8
-      IL_004b:  ldc.i4.0
-      IL_004c:  callvirt   ""object System.Runtime.CompilerServices.ITuple.this[int].get""
-      IL_0051:  stloc.1
-      // sequence point: <hidden>
-      IL_0052:  ldloc.s    V_8
-      IL_0054:  ldc.i4.1
-      IL_0055:  callvirt   ""object System.Runtime.CompilerServices.ITuple.this[int].get""
-      IL_005a:  stloc.2
-      // sequence point: <hidden>
-      IL_005b:  br         IL_0163
-      IL_0060:  ldloc.s    V_7
-      IL_0062:  isinst     ""C""
-      IL_0067:  brtrue     IL_016f
-      IL_006c:  br.s       IL_0077
-      IL_006e:  ldloc.s    V_9
-      IL_0070:  brfalse    IL_018c
-      IL_0075:  br.s       IL_00b5
-      IL_0077:  ldloc.s    V_9
-      IL_0079:  brfalse    IL_018c
-      IL_007e:  br.s       IL_00f5
-      IL_0080:  ldloc.s    V_7
-      IL_0082:  isinst     ""double""
-      IL_0087:  brfalse.s  IL_00a7
-      IL_0089:  ldloc.s    V_7
-      IL_008b:  unbox.any  ""double""
-      IL_0090:  stloc.s    V_10
-      // sequence point: <hidden>
-      IL_0092:  ldloc.s    V_10
-      IL_0094:  ldc.r8     4
-      IL_009d:  beq        IL_016a
-      IL_00a2:  br         IL_01a7
-      IL_00a7:  ldloc.s    V_7
-      IL_00a9:  isinst     ""C""
-      IL_00ae:  brtrue     IL_017b
-      IL_00b3:  br.s       IL_00f5
-      IL_00b5:  ldloc.s    V_7
-      IL_00b7:  castclass  ""C""
-      IL_00bc:  stloc.s    V_11
-      // sequence point: <hidden>
-      IL_00be:  ldloc.s    V_11
-      IL_00c0:  ldloca.s   V_3
-      IL_00c2:  ldloca.s   V_12
-      IL_00c4:  callvirt   ""void C.Deconstruct(out int, out object)""
-      IL_00c9:  nop
-      // sequence point: <hidden>
-      IL_00ca:  ldloc.s    V_12
-      IL_00cc:  isinst     ""C""
-      IL_00d1:  stloc.s    V_13
-      IL_00d3:  ldloc.s    V_13
-      IL_00d5:  brfalse.s  IL_00e6
-      IL_00d7:  ldloc.s    V_13
-      IL_00d9:  ldloca.s   V_4
-      IL_00db:  callvirt   ""void C.Deconstruct(out int)""
-      IL_00e0:  nop
-      // sequence point: <hidden>
-      IL_00e1:  br         IL_0191
-      IL_00e6:  ldloc.s    V_11
-      IL_00e8:  ldloca.s   V_5
-      IL_00ea:  callvirt   ""void C.Deconstruct(out int)""
-      IL_00ef:  nop
-      // sequence point: <hidden>
-      IL_00f0:  br         IL_0198
-      IL_00f5:  ldloc.s    V_7
-      IL_00f7:  isinst     ""D""
-      IL_00fc:  stloc.s    V_14
-      IL_00fe:  ldloc.s    V_14
-      IL_0100:  brfalse    IL_01a7
-      IL_0105:  ldloc.s    V_14
-      IL_0107:  callvirt   ""int D.P.get""
-      IL_010c:  stloc.s    V_15
-      // sequence point: <hidden>
-      IL_010e:  ldloc.s    V_15
-      IL_0110:  ldc.i4.1
-      IL_0111:  bne.un     IL_01a7
-      IL_0116:  ldloc.s    V_14
-      IL_0118:  callvirt   ""D D.Q.get""
-      IL_011d:  stloc.s    V_16
-      // sequence point: <hidden>
-      IL_011f:  ldloc.s    V_16
-      IL_0121:  brfalse    IL_01a7
-      IL_0126:  ldloc.s    V_16
-      IL_0128:  callvirt   ""int D.P.get""
-      IL_012d:  stloc.s    V_17
-      // sequence point: <hidden>
-      IL_012f:  ldloc.s    V_17
-      IL_0131:  ldc.i4.2
-      IL_0132:  bne.un.s   IL_01a7
-      IL_0134:  ldloc.s    V_14
-      IL_0136:  callvirt   ""C D.R.get""
-      IL_013b:  stloc.s    V_18
-      // sequence point: <hidden>
-      IL_013d:  ldloc.s    V_18
-      IL_013f:  brfalse.s  IL_01a7
-      IL_0141:  ldloc.s    V_18
-      IL_0143:  ldloca.s   V_6
-      IL_0145:  callvirt   ""void C.Deconstruct(out int)""
-      IL_014a:  nop
-      // sequence point: <hidden>
-      IL_014b:  br.s       IL_019f
-      // sequence point: when G(x) > 10
-      IL_014d:  ldloc.0
-      IL_014e:  call       ""int Program.G(int)""
-      IL_0153:  ldc.i4.s   10
-      IL_0155:  bgt.s      IL_0159
-      // sequence point: <hidden>
-      IL_0157:  br.s       IL_01a7
-      // sequence point: return 1;
-      IL_0159:  ldc.i4.1
-      IL_015a:  stloc.s    V_20
-      IL_015c:  br.s       IL_01ad
-      // sequence point: return 2;
-      IL_015e:  ldc.i4.2
-      IL_015f:  stloc.s    V_20
-      IL_0161:  br.s       IL_01ad
-      // sequence point: <hidden>
-      IL_0163:  br.s       IL_0165
-      // sequence point: return 3;
-      IL_0165:  ldc.i4.3
-      IL_0166:  stloc.s    V_20
-      IL_0168:  br.s       IL_01ad
-      // sequence point: return 4;
-      IL_016a:  ldc.i4.4
-      IL_016b:  stloc.s    V_20
-      IL_016d:  br.s       IL_01ad
-      // sequence point: when B()
-      IL_016f:  call       ""bool Program.B()""
-      IL_0174:  brtrue.s   IL_0187
-      // sequence point: <hidden>
-      IL_0176:  br         IL_006e
-      // sequence point: when B()
-      IL_017b:  call       ""bool Program.B()""
-      IL_0180:  brtrue.s   IL_0187
-      // sequence point: <hidden>
-      IL_0182:  br         IL_00b5
-      // sequence point: return 5;
-      IL_0187:  ldc.i4.5
-      IL_0188:  stloc.s    V_20
-      IL_018a:  br.s       IL_01ad
-      // sequence point: return 6;
-      IL_018c:  ldc.i4.6
-      IL_018d:  stloc.s    V_20
-      IL_018f:  br.s       IL_01ad
-      // sequence point: <hidden>
-      IL_0191:  br.s       IL_0193
-      // sequence point: return 7;
-      IL_0193:  ldc.i4.7
-      IL_0194:  stloc.s    V_20
-      IL_0196:  br.s       IL_01ad
-      // sequence point: <hidden>
-      IL_0198:  br.s       IL_019a
-      // sequence point: return 8;
-      IL_019a:  ldc.i4.8
-      IL_019b:  stloc.s    V_20
-      IL_019d:  br.s       IL_01ad
-      // sequence point: <hidden>
-      IL_019f:  br.s       IL_01a1
-      // sequence point: return 9;
-      IL_01a1:  ldc.i4.s   9
-      IL_01a3:  stloc.s    V_20
-      IL_01a5:  br.s       IL_01ad
-      // sequence point: return 10;
-      IL_01a7:  ldc.i4.s   10
-      IL_01a9:  stloc.s    V_20
-      IL_01ab:  br.s       IL_01ad
-      // sequence point: }
-      IL_01ad:  ldloc.s    V_20
-      IL_01af:  ret
-    }
+{
+  // Code size      448 (0x1c0)
+  .maxstack  3
+  .locals init (int V_0,
+                int V_1, //x
+                object V_2, //y
+                object V_3, //z
+                int V_4, //p
+                int V_5, //q
+                int V_6, //p
+                int V_7, //z
+                object V_8,
+                System.Runtime.CompilerServices.ITuple V_9,
+                int V_10,
+                double V_11,
+                C V_12,
+                object V_13,
+                C V_14,
+                D V_15,
+                int V_16,
+                D V_17,
+                int V_18,
+                C V_19,
+                object V_20,
+                int V_21)
+  // sequence point: {
+  IL_0000:  nop
+  // sequence point: switch (F())
+  IL_0001:  call       ""object Program.F()""
+  IL_0006:  stloc.s    V_20
+  // sequence point: <hidden>
+  IL_0008:  ldloc.s    V_20
+  IL_000a:  stloc.s    V_8
+  // sequence point: <hidden>
+  IL_000c:  ldloc.s    V_8
+  IL_000e:  isinst     ""int""
+  IL_0013:  brfalse.s  IL_0022
+  IL_0015:  ldloc.s    V_8
+  IL_0017:  unbox.any  ""int""
+  IL_001c:  stloc.1
+  // sequence point: <hidden>
+  IL_001d:  br         IL_0150
+  IL_0022:  ldloc.s    V_8
+  IL_0024:  isinst     ""bool""
+  IL_0029:  brtrue     IL_0161
+  IL_002e:  ldloc.s    V_8
+  IL_0030:  isinst     ""System.Runtime.CompilerServices.ITuple""
+  IL_0035:  stloc.s    V_9
+  IL_0037:  ldloc.s    V_9
+  IL_0039:  brfalse.s  IL_0080
+  IL_003b:  ldloc.s    V_9
+  IL_003d:  callvirt   ""int System.Runtime.CompilerServices.ITuple.Length.get""
+  IL_0042:  stloc.s    V_10
+  // sequence point: <hidden>
+  IL_0044:  ldloc.s    V_10
+  IL_0046:  ldc.i4.2
+  IL_0047:  bne.un.s   IL_0060
+  IL_0049:  ldloc.s    V_9
+  IL_004b:  ldc.i4.0
+  IL_004c:  callvirt   ""object System.Runtime.CompilerServices.ITuple.this[int].get""
+  IL_0051:  stloc.2
+  // sequence point: <hidden>
+  IL_0052:  ldloc.s    V_9
+  IL_0054:  ldc.i4.1
+  IL_0055:  callvirt   ""object System.Runtime.CompilerServices.ITuple.this[int].get""
+  IL_005a:  stloc.3
+  // sequence point: <hidden>
+  IL_005b:  br         IL_0166
+  IL_0060:  ldloc.s    V_8
+  IL_0062:  isinst     ""C""
+  IL_0067:  brtrue     IL_0172
+  IL_006c:  br.s       IL_0077
+  IL_006e:  ldloc.s    V_10
+  IL_0070:  brfalse    IL_019c
+  IL_0075:  br.s       IL_00b5
+  IL_0077:  ldloc.s    V_10
+  IL_0079:  brfalse    IL_019c
+  IL_007e:  br.s       IL_00f5
+  IL_0080:  ldloc.s    V_8
+  IL_0082:  isinst     ""double""
+  IL_0087:  brfalse.s  IL_00a7
+  IL_0089:  ldloc.s    V_8
+  IL_008b:  unbox.any  ""double""
+  IL_0090:  stloc.s    V_11
+  // sequence point: <hidden>
+  IL_0092:  ldloc.s    V_11
+  IL_0094:  ldc.r8     4
+  IL_009d:  beq        IL_016d
+  IL_00a2:  br         IL_01b7
+  IL_00a7:  ldloc.s    V_8
+  IL_00a9:  isinst     ""C""
+  IL_00ae:  brtrue     IL_0176
+  IL_00b3:  br.s       IL_00f5
+  IL_00b5:  ldloc.s    V_8
+  IL_00b7:  castclass  ""C""
+  IL_00bc:  stloc.s    V_12
+  // sequence point: <hidden>
+  IL_00be:  ldloc.s    V_12
+  IL_00c0:  ldloca.s   V_4
+  IL_00c2:  ldloca.s   V_13
+  IL_00c4:  callvirt   ""void C.Deconstruct(out int, out object)""
+  IL_00c9:  nop
+  // sequence point: <hidden>
+  IL_00ca:  ldloc.s    V_13
+  IL_00cc:  isinst     ""C""
+  IL_00d1:  stloc.s    V_14
+  IL_00d3:  ldloc.s    V_14
+  IL_00d5:  brfalse.s  IL_00e6
+  IL_00d7:  ldloc.s    V_14
+  IL_00d9:  ldloca.s   V_5
+  IL_00db:  callvirt   ""void C.Deconstruct(out int)""
+  IL_00e0:  nop
+  // sequence point: <hidden>
+  IL_00e1:  br         IL_01a1
+  IL_00e6:  ldloc.s    V_12
+  IL_00e8:  ldloca.s   V_6
+  IL_00ea:  callvirt   ""void C.Deconstruct(out int)""
+  IL_00ef:  nop
+  // sequence point: <hidden>
+  IL_00f0:  br         IL_01a8
+  IL_00f5:  ldloc.s    V_8
+  IL_00f7:  isinst     ""D""
+  IL_00fc:  stloc.s    V_15
+  IL_00fe:  ldloc.s    V_15
+  IL_0100:  brfalse    IL_01b7
+  IL_0105:  ldloc.s    V_15
+  IL_0107:  callvirt   ""int D.P.get""
+  IL_010c:  stloc.s    V_16
+  // sequence point: <hidden>
+  IL_010e:  ldloc.s    V_16
+  IL_0110:  ldc.i4.1
+  IL_0111:  bne.un     IL_01b7
+  IL_0116:  ldloc.s    V_15
+  IL_0118:  callvirt   ""D D.Q.get""
+  IL_011d:  stloc.s    V_17
+  // sequence point: <hidden>
+  IL_011f:  ldloc.s    V_17
+  IL_0121:  brfalse    IL_01b7
+  IL_0126:  ldloc.s    V_17
+  IL_0128:  callvirt   ""int D.P.get""
+  IL_012d:  stloc.s    V_18
+  // sequence point: <hidden>
+  IL_012f:  ldloc.s    V_18
+  IL_0131:  ldc.i4.2
+  IL_0132:  bne.un     IL_01b7
+  IL_0137:  ldloc.s    V_15
+  IL_0139:  callvirt   ""C D.R.get""
+  IL_013e:  stloc.s    V_19
+  // sequence point: <hidden>
+  IL_0140:  ldloc.s    V_19
+  IL_0142:  brfalse.s  IL_01b7
+  IL_0144:  ldloc.s    V_19
+  IL_0146:  ldloca.s   V_7
+  IL_0148:  callvirt   ""void C.Deconstruct(out int)""
+  IL_014d:  nop
+  // sequence point: <hidden>
+  IL_014e:  br.s       IL_01af
+  // sequence point: when G(x) > 10
+  IL_0150:  ldloc.1
+  IL_0151:  call       ""int Program.G(int)""
+  IL_0156:  ldc.i4.s   10
+  IL_0158:  bgt.s      IL_015c
+  // sequence point: <hidden>
+  IL_015a:  br.s       IL_01b7
+  // sequence point: return 1;
+  IL_015c:  ldc.i4.1
+  IL_015d:  stloc.s    V_21
+  IL_015f:  br.s       IL_01bd
+  // sequence point: return 2;
+  IL_0161:  ldc.i4.2
+  IL_0162:  stloc.s    V_21
+  IL_0164:  br.s       IL_01bd
+  // sequence point: <hidden>
+  IL_0166:  br.s       IL_0168
+  // sequence point: return 3;
+  IL_0168:  ldc.i4.3
+  IL_0169:  stloc.s    V_21
+  IL_016b:  br.s       IL_01bd
+  // sequence point: return 4;
+  IL_016d:  ldc.i4.4
+  IL_016e:  stloc.s    V_21
+  IL_0170:  br.s       IL_01bd
+  // sequence point: <hidden>
+  IL_0172:  ldc.i4.1
+  IL_0173:  stloc.0
+  IL_0174:  br.s       IL_017a
+  IL_0176:  ldc.i4.2
+  IL_0177:  stloc.0
+  IL_0178:  br.s       IL_017a
+  // sequence point: when B()
+  IL_017a:  call       ""bool Program.B()""
+  IL_017f:  brtrue.s   IL_0197
+  // sequence point: <hidden>
+  IL_0181:  ldloc.0
+  IL_0182:  ldc.i4.1
+  IL_0183:  beq.s      IL_018d
+  IL_0185:  br.s       IL_0187
+  IL_0187:  ldloc.0
+  IL_0188:  ldc.i4.2
+  IL_0189:  beq.s      IL_0192
+  IL_018b:  br.s       IL_0197
+  IL_018d:  br         IL_006e
+  IL_0192:  br         IL_00b5
+  // sequence point: return 5;
+  IL_0197:  ldc.i4.5
+  IL_0198:  stloc.s    V_21
+  IL_019a:  br.s       IL_01bd
+  // sequence point: return 6;
+  IL_019c:  ldc.i4.6
+  IL_019d:  stloc.s    V_21
+  IL_019f:  br.s       IL_01bd
+  // sequence point: <hidden>
+  IL_01a1:  br.s       IL_01a3
+  // sequence point: return 7;
+  IL_01a3:  ldc.i4.7
+  IL_01a4:  stloc.s    V_21
+  IL_01a6:  br.s       IL_01bd
+  // sequence point: <hidden>
+  IL_01a8:  br.s       IL_01aa
+  // sequence point: return 8;
+  IL_01aa:  ldc.i4.8
+  IL_01ab:  stloc.s    V_21
+  IL_01ad:  br.s       IL_01bd
+  // sequence point: <hidden>
+  IL_01af:  br.s       IL_01b1
+  // sequence point: return 9;
+  IL_01b1:  ldc.i4.s   9
+  IL_01b3:  stloc.s    V_21
+  IL_01b5:  br.s       IL_01bd
+  // sequence point: return 10;
+  IL_01b7:  ldc.i4.s   10
+  IL_01b9:  stloc.s    V_21
+  IL_01bb:  br.s       IL_01bd
+  // sequence point: }
+  IL_01bd:  ldloc.s    V_21
+  IL_01bf:  ret
+}
 ", source: source);
 
             verifier.VerifyPdb("Program.Main", @"   
-    <symbols>
-      <files>
-        <file id=""1"" name="""" language=""C#"" />
-      </files>
-      <methods>
-        <method containingType=""Program"" name=""Main"">
-          <customDebugInfo>
-            <forward declaringType=""C"" methodName=""Deconstruct"" />
-            <encLocalSlotMap>
-              <slot kind=""0"" offset=""93"" />
-              <slot kind=""0"" offset=""244"" />
-              <slot kind=""0"" offset=""247"" />
-              <slot kind=""0"" offset=""465"" />
-              <slot kind=""0"" offset=""474"" />
-              <slot kind=""0"" offset=""516"" />
-              <slot kind=""0"" offset=""617"" />
-              <slot kind=""35"" offset=""11"" />
-              <slot kind=""35"" offset=""11"" ordinal=""1"" />
-              <slot kind=""35"" offset=""11"" ordinal=""2"" />
-              <slot kind=""35"" offset=""11"" ordinal=""3"" />
-              <slot kind=""35"" offset=""11"" ordinal=""4"" />
-              <slot kind=""35"" offset=""11"" ordinal=""5"" />
-              <slot kind=""35"" offset=""11"" ordinal=""6"" />
-              <slot kind=""35"" offset=""11"" ordinal=""7"" />
-              <slot kind=""35"" offset=""11"" ordinal=""8"" />
-              <slot kind=""35"" offset=""11"" ordinal=""9"" />
-              <slot kind=""35"" offset=""11"" ordinal=""10"" />
-              <slot kind=""35"" offset=""11"" ordinal=""11"" />
-              <slot kind=""1"" offset=""11"" />
-              <slot kind=""21"" offset=""0"" />
-            </encLocalSlotMap>
-          </customDebugInfo>
-          <sequencePoints>
-            <entry offset=""0x0"" startLine=""23"" startColumn=""5"" endLine=""23"" endColumn=""6"" document=""1"" />
-            <entry offset=""0x1"" startLine=""24"" startColumn=""9"" endLine=""24"" endColumn=""21"" document=""1"" />
-            <entry offset=""0x8"" hidden=""true"" document=""1"" />
-            <entry offset=""0xc"" hidden=""true"" document=""1"" />
-            <entry offset=""0x1d"" hidden=""true"" document=""1"" />
-            <entry offset=""0x44"" hidden=""true"" document=""1"" />
-            <entry offset=""0x52"" hidden=""true"" document=""1"" />
-            <entry offset=""0x5b"" hidden=""true"" document=""1"" />
-            <entry offset=""0x92"" hidden=""true"" document=""1"" />
-            <entry offset=""0xbe"" hidden=""true"" document=""1"" />
-            <entry offset=""0xca"" hidden=""true"" document=""1"" />
-            <entry offset=""0xe1"" hidden=""true"" document=""1"" />
-            <entry offset=""0xf0"" hidden=""true"" document=""1"" />
-            <entry offset=""0x10e"" hidden=""true"" document=""1"" />
-            <entry offset=""0x11f"" hidden=""true"" document=""1"" />
-            <entry offset=""0x12f"" hidden=""true"" document=""1"" />
-            <entry offset=""0x13d"" hidden=""true"" document=""1"" />
-            <entry offset=""0x14b"" hidden=""true"" document=""1"" />
-            <entry offset=""0x14d"" startLine=""27"" startColumn=""24"" endLine=""27"" endColumn=""38"" document=""1"" />
-            <entry offset=""0x157"" hidden=""true"" document=""1"" />
-            <entry offset=""0x159"" startLine=""27"" startColumn=""40"" endLine=""27"" endColumn=""49"" document=""1"" />
-            <entry offset=""0x15e"" startLine=""30"" startColumn=""26"" endLine=""30"" endColumn=""35"" document=""1"" />
-            <entry offset=""0x163"" hidden=""true"" document=""1"" />
-            <entry offset=""0x165"" startLine=""33"" startColumn=""30"" endLine=""33"" endColumn=""39"" document=""1"" />
-            <entry offset=""0x16a"" startLine=""36"" startColumn=""23"" endLine=""36"" endColumn=""32"" document=""1"" />
-            <entry offset=""0x16f"" startLine=""39"" startColumn=""22"" endLine=""39"" endColumn=""30"" document=""1"" />
-            <entry offset=""0x176"" hidden=""true"" document=""1"" />
-            <entry offset=""0x17b"" startLine=""39"" startColumn=""22"" endLine=""39"" endColumn=""30"" document=""1"" />
-            <entry offset=""0x182"" hidden=""true"" document=""1"" />
-            <entry offset=""0x187"" startLine=""39"" startColumn=""32"" endLine=""39"" endColumn=""41"" document=""1"" />
-            <entry offset=""0x18c"" startLine=""40"" startColumn=""22"" endLine=""40"" endColumn=""31"" document=""1"" />
-            <entry offset=""0x191"" hidden=""true"" document=""1"" />
-            <entry offset=""0x193"" startLine=""41"" startColumn=""38"" endLine=""41"" endColumn=""47"" document=""1"" />
-            <entry offset=""0x198"" hidden=""true"" document=""1"" />
-            <entry offset=""0x19a"" startLine=""42"" startColumn=""31"" endLine=""42"" endColumn=""40"" document=""1"" />
-            <entry offset=""0x19f"" hidden=""true"" document=""1"" />
-            <entry offset=""0x1a1"" startLine=""45"" startColumn=""58"" endLine=""45"" endColumn=""67"" document=""1"" />
-            <entry offset=""0x1a7"" startLine=""47"" startColumn=""22"" endLine=""47"" endColumn=""32"" document=""1"" />
-            <entry offset=""0x1ad"" startLine=""49"" startColumn=""5"" endLine=""49"" endColumn=""6"" document=""1"" />
-          </sequencePoints>
-          <scope startOffset=""0x0"" endOffset=""0x1b0"">
-            <scope startOffset=""0x14d"" endOffset=""0x15e"">
-              <local name=""x"" il_index=""0"" il_start=""0x14d"" il_end=""0x15e"" attributes=""0"" />
-            </scope>
-            <scope startOffset=""0x163"" endOffset=""0x16a"">
-              <local name=""y"" il_index=""1"" il_start=""0x163"" il_end=""0x16a"" attributes=""0"" />
-              <local name=""z"" il_index=""2"" il_start=""0x163"" il_end=""0x16a"" attributes=""0"" />
-            </scope>
-            <scope startOffset=""0x191"" endOffset=""0x198"">
-              <local name=""p"" il_index=""3"" il_start=""0x191"" il_end=""0x198"" attributes=""0"" />
-              <local name=""q"" il_index=""4"" il_start=""0x191"" il_end=""0x198"" attributes=""0"" />
-            </scope>
-            <scope startOffset=""0x198"" endOffset=""0x19f"">
-              <local name=""p"" il_index=""5"" il_start=""0x198"" il_end=""0x19f"" attributes=""0"" />
-            </scope>
-            <scope startOffset=""0x19f"" endOffset=""0x1a7"">
-              <local name=""z"" il_index=""6"" il_start=""0x19f"" il_end=""0x1a7"" attributes=""0"" />
-            </scope>
-          </scope>
-        </method>
-      </methods>
-    </symbols>
+<symbols>
+  <files>
+    <file id=""1"" name="""" language=""C#"" />
+  </files>
+  <methods>
+    <method containingType=""Program"" name=""Main"">
+      <customDebugInfo>
+        <forward declaringType=""C"" methodName=""Deconstruct"" />
+        <encLocalSlotMap>
+          <slot kind=""temp"" />
+          <slot kind=""0"" offset=""93"" />
+          <slot kind=""0"" offset=""244"" />
+          <slot kind=""0"" offset=""247"" />
+          <slot kind=""0"" offset=""465"" />
+          <slot kind=""0"" offset=""474"" />
+          <slot kind=""0"" offset=""516"" />
+          <slot kind=""0"" offset=""617"" />
+          <slot kind=""35"" offset=""11"" />
+          <slot kind=""35"" offset=""11"" ordinal=""1"" />
+          <slot kind=""35"" offset=""11"" ordinal=""2"" />
+          <slot kind=""35"" offset=""11"" ordinal=""3"" />
+          <slot kind=""35"" offset=""11"" ordinal=""4"" />
+          <slot kind=""35"" offset=""11"" ordinal=""5"" />
+          <slot kind=""35"" offset=""11"" ordinal=""6"" />
+          <slot kind=""35"" offset=""11"" ordinal=""7"" />
+          <slot kind=""35"" offset=""11"" ordinal=""8"" />
+          <slot kind=""35"" offset=""11"" ordinal=""9"" />
+          <slot kind=""35"" offset=""11"" ordinal=""10"" />
+          <slot kind=""35"" offset=""11"" ordinal=""11"" />
+          <slot kind=""1"" offset=""11"" />
+          <slot kind=""21"" offset=""0"" />
+        </encLocalSlotMap>
+      </customDebugInfo>
+      <sequencePoints>
+        <entry offset=""0x0"" startLine=""23"" startColumn=""5"" endLine=""23"" endColumn=""6"" document=""1"" />
+        <entry offset=""0x1"" startLine=""24"" startColumn=""9"" endLine=""24"" endColumn=""21"" document=""1"" />
+        <entry offset=""0x8"" hidden=""true"" document=""1"" />
+        <entry offset=""0xc"" hidden=""true"" document=""1"" />
+        <entry offset=""0x1d"" hidden=""true"" document=""1"" />
+        <entry offset=""0x44"" hidden=""true"" document=""1"" />
+        <entry offset=""0x52"" hidden=""true"" document=""1"" />
+        <entry offset=""0x5b"" hidden=""true"" document=""1"" />
+        <entry offset=""0x92"" hidden=""true"" document=""1"" />
+        <entry offset=""0xbe"" hidden=""true"" document=""1"" />
+        <entry offset=""0xca"" hidden=""true"" document=""1"" />
+        <entry offset=""0xe1"" hidden=""true"" document=""1"" />
+        <entry offset=""0xf0"" hidden=""true"" document=""1"" />
+        <entry offset=""0x10e"" hidden=""true"" document=""1"" />
+        <entry offset=""0x11f"" hidden=""true"" document=""1"" />
+        <entry offset=""0x12f"" hidden=""true"" document=""1"" />
+        <entry offset=""0x140"" hidden=""true"" document=""1"" />
+        <entry offset=""0x14e"" hidden=""true"" document=""1"" />
+        <entry offset=""0x150"" startLine=""27"" startColumn=""24"" endLine=""27"" endColumn=""38"" document=""1"" />
+        <entry offset=""0x15a"" hidden=""true"" document=""1"" />
+        <entry offset=""0x15c"" startLine=""27"" startColumn=""40"" endLine=""27"" endColumn=""49"" document=""1"" />
+        <entry offset=""0x161"" startLine=""30"" startColumn=""26"" endLine=""30"" endColumn=""35"" document=""1"" />
+        <entry offset=""0x166"" hidden=""true"" document=""1"" />
+        <entry offset=""0x168"" startLine=""33"" startColumn=""30"" endLine=""33"" endColumn=""39"" document=""1"" />
+        <entry offset=""0x16d"" startLine=""36"" startColumn=""23"" endLine=""36"" endColumn=""32"" document=""1"" />
+        <entry offset=""0x172"" hidden=""true"" document=""1"" />
+        <entry offset=""0x17a"" startLine=""39"" startColumn=""22"" endLine=""39"" endColumn=""30"" document=""1"" />
+        <entry offset=""0x181"" hidden=""true"" document=""1"" />
+        <entry offset=""0x197"" startLine=""39"" startColumn=""32"" endLine=""39"" endColumn=""41"" document=""1"" />
+        <entry offset=""0x19c"" startLine=""40"" startColumn=""22"" endLine=""40"" endColumn=""31"" document=""1"" />
+        <entry offset=""0x1a1"" hidden=""true"" document=""1"" />
+        <entry offset=""0x1a3"" startLine=""41"" startColumn=""38"" endLine=""41"" endColumn=""47"" document=""1"" />
+        <entry offset=""0x1a8"" hidden=""true"" document=""1"" />
+        <entry offset=""0x1aa"" startLine=""42"" startColumn=""31"" endLine=""42"" endColumn=""40"" document=""1"" />
+        <entry offset=""0x1af"" hidden=""true"" document=""1"" />
+        <entry offset=""0x1b1"" startLine=""45"" startColumn=""58"" endLine=""45"" endColumn=""67"" document=""1"" />
+        <entry offset=""0x1b7"" startLine=""47"" startColumn=""22"" endLine=""47"" endColumn=""32"" document=""1"" />
+        <entry offset=""0x1bd"" startLine=""49"" startColumn=""5"" endLine=""49"" endColumn=""6"" document=""1"" />
+      </sequencePoints>
+      <scope startOffset=""0x0"" endOffset=""0x1c0"">
+        <scope startOffset=""0x150"" endOffset=""0x161"">
+          <local name=""x"" il_index=""1"" il_start=""0x150"" il_end=""0x161"" attributes=""0"" />
+        </scope>
+        <scope startOffset=""0x166"" endOffset=""0x16d"">
+          <local name=""y"" il_index=""2"" il_start=""0x166"" il_end=""0x16d"" attributes=""0"" />
+          <local name=""z"" il_index=""3"" il_start=""0x166"" il_end=""0x16d"" attributes=""0"" />
+        </scope>
+        <scope startOffset=""0x1a1"" endOffset=""0x1a8"">
+          <local name=""p"" il_index=""4"" il_start=""0x1a1"" il_end=""0x1a8"" attributes=""0"" />
+          <local name=""q"" il_index=""5"" il_start=""0x1a1"" il_end=""0x1a8"" attributes=""0"" />
+        </scope>
+        <scope startOffset=""0x1a8"" endOffset=""0x1af"">
+          <local name=""p"" il_index=""6"" il_start=""0x1a8"" il_end=""0x1af"" attributes=""0"" />
+        </scope>
+        <scope startOffset=""0x1af"" endOffset=""0x1b7"">
+          <local name=""z"" il_index=""7"" il_start=""0x1af"" il_end=""0x1b7"" attributes=""0"" />
+        </scope>
+      </scope>
+    </method>
+  </methods>
+</symbols>
 ");
         }
 
@@ -8850,299 +8862,312 @@ int x when G(x) > 10 => 1,
             // note no sequence points emitted within the switch expression
 
             verifier.VerifyIL("Program.Main", sequencePoints: "Program.Main", expectedIL: @"
-    {
-      // Code size      437 (0x1b5)
-      .maxstack  3
-      .locals init (int V_0, //a
-                    int V_1, //x
-                    object V_2, //y
-                    object V_3, //z
-                    int V_4, //p
-                    int V_5, //q
-                    int V_6, //p
-                    int V_7, //z
-                    int V_8,
-                    object V_9,
-                    System.Runtime.CompilerServices.ITuple V_10,
-                    int V_11,
-                    double V_12,
-                    C V_13,
-                    object V_14,
-                    C V_15,
-                    D V_16,
-                    int V_17,
-                    D V_18,
-                    int V_19,
-                    C V_20)
-     -IL_0000:  nop
-     -IL_0001:  call       ""object Program.F()""
-      IL_0006:  stloc.s    V_9
-      IL_0008:  ldc.i4.1
-      IL_0009:  brtrue.s   IL_000c
-     -IL_000b:  nop
-     ~IL_000c:  ldloc.s    V_9
-      IL_000e:  isinst     ""int""
-      IL_0013:  brfalse.s  IL_0022
-      IL_0015:  ldloc.s    V_9
-      IL_0017:  unbox.any  ""int""
-      IL_001c:  stloc.1
-     ~IL_001d:  br         IL_014d
-      IL_0022:  ldloc.s    V_9
-      IL_0024:  isinst     ""bool""
-      IL_0029:  brtrue     IL_015e
-      IL_002e:  ldloc.s    V_9
-      IL_0030:  isinst     ""System.Runtime.CompilerServices.ITuple""
-      IL_0035:  stloc.s    V_10
-      IL_0037:  ldloc.s    V_10
-      IL_0039:  brfalse.s  IL_0080
-      IL_003b:  ldloc.s    V_10
-      IL_003d:  callvirt   ""int System.Runtime.CompilerServices.ITuple.Length.get""
-      IL_0042:  stloc.s    V_11
-     ~IL_0044:  ldloc.s    V_11
-      IL_0046:  ldc.i4.2
-      IL_0047:  bne.un.s   IL_0060
-      IL_0049:  ldloc.s    V_10
-      IL_004b:  ldc.i4.0
-      IL_004c:  callvirt   ""object System.Runtime.CompilerServices.ITuple.this[int].get""
-      IL_0051:  stloc.2
-     ~IL_0052:  ldloc.s    V_10
-      IL_0054:  ldc.i4.1
-      IL_0055:  callvirt   ""object System.Runtime.CompilerServices.ITuple.this[int].get""
-      IL_005a:  stloc.3
-     ~IL_005b:  br         IL_0163
-      IL_0060:  ldloc.s    V_9
-      IL_0062:  isinst     ""C""
-      IL_0067:  brtrue     IL_016f
-      IL_006c:  br.s       IL_0077
-      IL_006e:  ldloc.s    V_11
-      IL_0070:  brfalse    IL_018c
-      IL_0075:  br.s       IL_00b5
-      IL_0077:  ldloc.s    V_11
-      IL_0079:  brfalse    IL_018c
-      IL_007e:  br.s       IL_00f5
-      IL_0080:  ldloc.s    V_9
-      IL_0082:  isinst     ""double""
-      IL_0087:  brfalse.s  IL_00a7
-      IL_0089:  ldloc.s    V_9
-      IL_008b:  unbox.any  ""double""
-      IL_0090:  stloc.s    V_12
-     ~IL_0092:  ldloc.s    V_12
-      IL_0094:  ldc.r8     4
-      IL_009d:  beq        IL_016a
-      IL_00a2:  br         IL_01a7
-      IL_00a7:  ldloc.s    V_9
-      IL_00a9:  isinst     ""C""
-      IL_00ae:  brtrue     IL_017b
-      IL_00b3:  br.s       IL_00f5
-      IL_00b5:  ldloc.s    V_9
-      IL_00b7:  castclass  ""C""
-      IL_00bc:  stloc.s    V_13
-     ~IL_00be:  ldloc.s    V_13
-      IL_00c0:  ldloca.s   V_4
-      IL_00c2:  ldloca.s   V_14
-      IL_00c4:  callvirt   ""void C.Deconstruct(out int, out object)""
-      IL_00c9:  nop
-     ~IL_00ca:  ldloc.s    V_14
-      IL_00cc:  isinst     ""C""
-      IL_00d1:  stloc.s    V_15
-      IL_00d3:  ldloc.s    V_15
-      IL_00d5:  brfalse.s  IL_00e6
-      IL_00d7:  ldloc.s    V_15
-      IL_00d9:  ldloca.s   V_5
-      IL_00db:  callvirt   ""void C.Deconstruct(out int)""
-      IL_00e0:  nop
-     ~IL_00e1:  br         IL_0191
-      IL_00e6:  ldloc.s    V_13
-      IL_00e8:  ldloca.s   V_6
-      IL_00ea:  callvirt   ""void C.Deconstruct(out int)""
-      IL_00ef:  nop
-     ~IL_00f0:  br         IL_0198
-      IL_00f5:  ldloc.s    V_9
-      IL_00f7:  isinst     ""D""
-      IL_00fc:  stloc.s    V_16
-      IL_00fe:  ldloc.s    V_16
-      IL_0100:  brfalse    IL_01a7
-      IL_0105:  ldloc.s    V_16
-      IL_0107:  callvirt   ""int D.P.get""
-      IL_010c:  stloc.s    V_17
-     ~IL_010e:  ldloc.s    V_17
-      IL_0110:  ldc.i4.1
-      IL_0111:  bne.un     IL_01a7
-      IL_0116:  ldloc.s    V_16
-      IL_0118:  callvirt   ""D D.Q.get""
-      IL_011d:  stloc.s    V_18
-     ~IL_011f:  ldloc.s    V_18
-      IL_0121:  brfalse    IL_01a7
-      IL_0126:  ldloc.s    V_18
-      IL_0128:  callvirt   ""int D.P.get""
-      IL_012d:  stloc.s    V_19
-     ~IL_012f:  ldloc.s    V_19
-      IL_0131:  ldc.i4.2
-      IL_0132:  bne.un.s   IL_01a7
-      IL_0134:  ldloc.s    V_16
-      IL_0136:  callvirt   ""C D.R.get""
-      IL_013b:  stloc.s    V_20
-     ~IL_013d:  ldloc.s    V_20
-      IL_013f:  brfalse.s  IL_01a7
-      IL_0141:  ldloc.s    V_20
-      IL_0143:  ldloca.s   V_7
-      IL_0145:  callvirt   ""void C.Deconstruct(out int)""
-      IL_014a:  nop
-     ~IL_014b:  br.s       IL_019f
-     -IL_014d:  ldloc.1
-      IL_014e:  call       ""int Program.G(int)""
-      IL_0153:  ldc.i4.s   10
-      IL_0155:  bgt.s      IL_0159
-     ~IL_0157:  br.s       IL_01a7
-     -IL_0159:  ldc.i4.1
-      IL_015a:  stloc.s    V_8
-      IL_015c:  br.s       IL_01ad
-     -IL_015e:  ldc.i4.2
-      IL_015f:  stloc.s    V_8
-      IL_0161:  br.s       IL_01ad
-     ~IL_0163:  br.s       IL_0165
-     -IL_0165:  ldc.i4.3
-      IL_0166:  stloc.s    V_8
-      IL_0168:  br.s       IL_01ad
-     -IL_016a:  ldc.i4.4
-      IL_016b:  stloc.s    V_8
-      IL_016d:  br.s       IL_01ad
-     -IL_016f:  call       ""bool Program.B()""
-      IL_0174:  brtrue.s   IL_0187
-     ~IL_0176:  br         IL_006e
-     -IL_017b:  call       ""bool Program.B()""
-      IL_0180:  brtrue.s   IL_0187
-     ~IL_0182:  br         IL_00b5
-     -IL_0187:  ldc.i4.5
-      IL_0188:  stloc.s    V_8
-      IL_018a:  br.s       IL_01ad
-     -IL_018c:  ldc.i4.6
-      IL_018d:  stloc.s    V_8
-      IL_018f:  br.s       IL_01ad
-     ~IL_0191:  br.s       IL_0193
-     -IL_0193:  ldc.i4.7
-      IL_0194:  stloc.s    V_8
-      IL_0196:  br.s       IL_01ad
-     ~IL_0198:  br.s       IL_019a
-     -IL_019a:  ldc.i4.8
-      IL_019b:  stloc.s    V_8
-      IL_019d:  br.s       IL_01ad
-     ~IL_019f:  br.s       IL_01a1
-     -IL_01a1:  ldc.i4.s   9
-      IL_01a3:  stloc.s    V_8
-      IL_01a5:  br.s       IL_01ad
-     -IL_01a7:  ldc.i4.s   10
-      IL_01a9:  stloc.s    V_8
-      IL_01ab:  br.s       IL_01ad
-     ~IL_01ad:  ldc.i4.1
-      IL_01ae:  brtrue.s   IL_01b1
-     -IL_01b0:  nop
-     ~IL_01b1:  ldloc.s    V_8
-      IL_01b3:  stloc.0
-     -IL_01b4:  ret
-    }
+{
+  // Code size      454 (0x1c6)
+  .maxstack  3
+  .locals init (int V_0, //a
+                int V_1,
+                int V_2, //x
+                object V_3, //y
+                object V_4, //z
+                int V_5, //p
+                int V_6, //q
+                int V_7, //p
+                int V_8, //z
+                int V_9,
+                object V_10,
+                System.Runtime.CompilerServices.ITuple V_11,
+                int V_12,
+                double V_13,
+                C V_14,
+                object V_15,
+                C V_16,
+                D V_17,
+                int V_18,
+                D V_19,
+                int V_20,
+                C V_21)
+ -IL_0000:  nop
+ -IL_0001:  call       ""object Program.F()""
+  IL_0006:  stloc.s    V_10
+  IL_0008:  ldc.i4.1
+  IL_0009:  brtrue.s   IL_000c
+ -IL_000b:  nop
+ ~IL_000c:  ldloc.s    V_10
+  IL_000e:  isinst     ""int""
+  IL_0013:  brfalse.s  IL_0022
+  IL_0015:  ldloc.s    V_10
+  IL_0017:  unbox.any  ""int""
+  IL_001c:  stloc.2
+ ~IL_001d:  br         IL_0151
+  IL_0022:  ldloc.s    V_10
+  IL_0024:  isinst     ""bool""
+  IL_0029:  brtrue     IL_0162
+  IL_002e:  ldloc.s    V_10
+  IL_0030:  isinst     ""System.Runtime.CompilerServices.ITuple""
+  IL_0035:  stloc.s    V_11
+  IL_0037:  ldloc.s    V_11
+  IL_0039:  brfalse.s  IL_0081
+  IL_003b:  ldloc.s    V_11
+  IL_003d:  callvirt   ""int System.Runtime.CompilerServices.ITuple.Length.get""
+  IL_0042:  stloc.s    V_12
+ ~IL_0044:  ldloc.s    V_12
+  IL_0046:  ldc.i4.2
+  IL_0047:  bne.un.s   IL_0061
+  IL_0049:  ldloc.s    V_11
+  IL_004b:  ldc.i4.0
+  IL_004c:  callvirt   ""object System.Runtime.CompilerServices.ITuple.this[int].get""
+  IL_0051:  stloc.3
+ ~IL_0052:  ldloc.s    V_11
+  IL_0054:  ldc.i4.1
+  IL_0055:  callvirt   ""object System.Runtime.CompilerServices.ITuple.this[int].get""
+  IL_005a:  stloc.s    V_4
+ ~IL_005c:  br         IL_0167
+  IL_0061:  ldloc.s    V_10
+  IL_0063:  isinst     ""C""
+  IL_0068:  brtrue     IL_0173
+  IL_006d:  br.s       IL_0078
+  IL_006f:  ldloc.s    V_12
+  IL_0071:  brfalse    IL_019d
+  IL_0076:  br.s       IL_00b6
+  IL_0078:  ldloc.s    V_12
+  IL_007a:  brfalse    IL_019d
+  IL_007f:  br.s       IL_00f6
+  IL_0081:  ldloc.s    V_10
+  IL_0083:  isinst     ""double""
+  IL_0088:  brfalse.s  IL_00a8
+  IL_008a:  ldloc.s    V_10
+  IL_008c:  unbox.any  ""double""
+  IL_0091:  stloc.s    V_13
+ ~IL_0093:  ldloc.s    V_13
+  IL_0095:  ldc.r8     4
+  IL_009e:  beq        IL_016e
+  IL_00a3:  br         IL_01b8
+  IL_00a8:  ldloc.s    V_10
+  IL_00aa:  isinst     ""C""
+  IL_00af:  brtrue     IL_0177
+  IL_00b4:  br.s       IL_00f6
+  IL_00b6:  ldloc.s    V_10
+  IL_00b8:  castclass  ""C""
+  IL_00bd:  stloc.s    V_14
+ ~IL_00bf:  ldloc.s    V_14
+  IL_00c1:  ldloca.s   V_5
+  IL_00c3:  ldloca.s   V_15
+  IL_00c5:  callvirt   ""void C.Deconstruct(out int, out object)""
+  IL_00ca:  nop
+ ~IL_00cb:  ldloc.s    V_15
+  IL_00cd:  isinst     ""C""
+  IL_00d2:  stloc.s    V_16
+  IL_00d4:  ldloc.s    V_16
+  IL_00d6:  brfalse.s  IL_00e7
+  IL_00d8:  ldloc.s    V_16
+  IL_00da:  ldloca.s   V_6
+  IL_00dc:  callvirt   ""void C.Deconstruct(out int)""
+  IL_00e1:  nop
+ ~IL_00e2:  br         IL_01a2
+  IL_00e7:  ldloc.s    V_14
+  IL_00e9:  ldloca.s   V_7
+  IL_00eb:  callvirt   ""void C.Deconstruct(out int)""
+  IL_00f0:  nop
+ ~IL_00f1:  br         IL_01a9
+  IL_00f6:  ldloc.s    V_10
+  IL_00f8:  isinst     ""D""
+  IL_00fd:  stloc.s    V_17
+  IL_00ff:  ldloc.s    V_17
+  IL_0101:  brfalse    IL_01b8
+  IL_0106:  ldloc.s    V_17
+  IL_0108:  callvirt   ""int D.P.get""
+  IL_010d:  stloc.s    V_18
+ ~IL_010f:  ldloc.s    V_18
+  IL_0111:  ldc.i4.1
+  IL_0112:  bne.un     IL_01b8
+  IL_0117:  ldloc.s    V_17
+  IL_0119:  callvirt   ""D D.Q.get""
+  IL_011e:  stloc.s    V_19
+ ~IL_0120:  ldloc.s    V_19
+  IL_0122:  brfalse    IL_01b8
+  IL_0127:  ldloc.s    V_19
+  IL_0129:  callvirt   ""int D.P.get""
+  IL_012e:  stloc.s    V_20
+ ~IL_0130:  ldloc.s    V_20
+  IL_0132:  ldc.i4.2
+  IL_0133:  bne.un     IL_01b8
+  IL_0138:  ldloc.s    V_17
+  IL_013a:  callvirt   ""C D.R.get""
+  IL_013f:  stloc.s    V_21
+ ~IL_0141:  ldloc.s    V_21
+  IL_0143:  brfalse.s  IL_01b8
+  IL_0145:  ldloc.s    V_21
+  IL_0147:  ldloca.s   V_8
+  IL_0149:  callvirt   ""void C.Deconstruct(out int)""
+  IL_014e:  nop
+ ~IL_014f:  br.s       IL_01b0
+ -IL_0151:  ldloc.2
+  IL_0152:  call       ""int Program.G(int)""
+  IL_0157:  ldc.i4.s   10
+  IL_0159:  bgt.s      IL_015d
+ ~IL_015b:  br.s       IL_01b8
+ -IL_015d:  ldc.i4.1
+  IL_015e:  stloc.s    V_9
+  IL_0160:  br.s       IL_01be
+ -IL_0162:  ldc.i4.2
+  IL_0163:  stloc.s    V_9
+  IL_0165:  br.s       IL_01be
+ ~IL_0167:  br.s       IL_0169
+ -IL_0169:  ldc.i4.3
+  IL_016a:  stloc.s    V_9
+  IL_016c:  br.s       IL_01be
+ -IL_016e:  ldc.i4.4
+  IL_016f:  stloc.s    V_9
+  IL_0171:  br.s       IL_01be
+ ~IL_0173:  ldc.i4.1
+  IL_0174:  stloc.1
+  IL_0175:  br.s       IL_017b
+  IL_0177:  ldc.i4.2
+  IL_0178:  stloc.1
+  IL_0179:  br.s       IL_017b
+ -IL_017b:  call       ""bool Program.B()""
+  IL_0180:  brtrue.s   IL_0198
+ ~IL_0182:  ldloc.1
+  IL_0183:  ldc.i4.1
+  IL_0184:  beq.s      IL_018e
+  IL_0186:  br.s       IL_0188
+  IL_0188:  ldloc.1
+  IL_0189:  ldc.i4.2
+  IL_018a:  beq.s      IL_0193
+  IL_018c:  br.s       IL_0198
+  IL_018e:  br         IL_006f
+  IL_0193:  br         IL_00b6
+ -IL_0198:  ldc.i4.5
+  IL_0199:  stloc.s    V_9
+  IL_019b:  br.s       IL_01be
+ -IL_019d:  ldc.i4.6
+  IL_019e:  stloc.s    V_9
+  IL_01a0:  br.s       IL_01be
+ ~IL_01a2:  br.s       IL_01a4
+ -IL_01a4:  ldc.i4.7
+  IL_01a5:  stloc.s    V_9
+  IL_01a7:  br.s       IL_01be
+ ~IL_01a9:  br.s       IL_01ab
+ -IL_01ab:  ldc.i4.8
+  IL_01ac:  stloc.s    V_9
+  IL_01ae:  br.s       IL_01be
+ ~IL_01b0:  br.s       IL_01b2
+ -IL_01b2:  ldc.i4.s   9
+  IL_01b4:  stloc.s    V_9
+  IL_01b6:  br.s       IL_01be
+ -IL_01b8:  ldc.i4.s   10
+  IL_01ba:  stloc.s    V_9
+  IL_01bc:  br.s       IL_01be
+ ~IL_01be:  ldc.i4.1
+  IL_01bf:  brtrue.s   IL_01c2
+ -IL_01c1:  nop
+ ~IL_01c2:  ldloc.s    V_9
+  IL_01c4:  stloc.0
+ -IL_01c5:  ret
+}
 ");
 
             verifier.VerifyPdb("Program.Main", @"
-    <symbols>
-      <files>
-        <file id=""1"" name="""" language=""C#"" />
-      </files>
-      <methods>
-        <method containingType=""Program"" name=""Main"">
-          <customDebugInfo>
-            <forward declaringType=""C"" methodName=""Deconstruct"" />
-            <encLocalSlotMap>
-              <slot kind=""0"" offset=""15"" />
-              <slot kind=""0"" offset=""94"" />
-              <slot kind=""0"" offset=""225"" />
-              <slot kind=""0"" offset=""228"" />
-              <slot kind=""0"" offset=""406"" />
-              <slot kind=""0"" offset=""415"" />
-              <slot kind=""0"" offset=""447"" />
-              <slot kind=""0"" offset=""539"" />
-              <slot kind=""temp"" />
-              <slot kind=""35"" offset=""23"" />
-              <slot kind=""35"" offset=""23"" ordinal=""1"" />
-              <slot kind=""35"" offset=""23"" ordinal=""2"" />
-              <slot kind=""35"" offset=""23"" ordinal=""3"" />
-              <slot kind=""35"" offset=""23"" ordinal=""4"" />
-              <slot kind=""35"" offset=""23"" ordinal=""5"" />
-              <slot kind=""35"" offset=""23"" ordinal=""6"" />
-              <slot kind=""35"" offset=""23"" ordinal=""7"" />
-              <slot kind=""35"" offset=""23"" ordinal=""8"" />
-              <slot kind=""35"" offset=""23"" ordinal=""9"" />
-              <slot kind=""35"" offset=""23"" ordinal=""10"" />
-              <slot kind=""35"" offset=""23"" ordinal=""11"" />
-            </encLocalSlotMap>
-          </customDebugInfo>
-          <sequencePoints>
-            <entry offset=""0x0"" startLine=""23"" startColumn=""5"" endLine=""23"" endColumn=""6"" document=""1"" />
-            <entry offset=""0x1"" startLine=""24"" startColumn=""9"" endLine=""48"" endColumn=""11"" document=""1"" />
-            <entry offset=""0xb"" startLine=""24"" startColumn=""21"" endLine=""48"" endColumn=""10"" document=""1"" />
-            <entry offset=""0xc"" hidden=""true"" document=""1"" />
-            <entry offset=""0x1d"" hidden=""true"" document=""1"" />
-            <entry offset=""0x44"" hidden=""true"" document=""1"" />
-            <entry offset=""0x52"" hidden=""true"" document=""1"" />
-            <entry offset=""0x5b"" hidden=""true"" document=""1"" />
-            <entry offset=""0x92"" hidden=""true"" document=""1"" />
-            <entry offset=""0xbe"" hidden=""true"" document=""1"" />
-            <entry offset=""0xca"" hidden=""true"" document=""1"" />
-            <entry offset=""0xe1"" hidden=""true"" document=""1"" />
-            <entry offset=""0xf0"" hidden=""true"" document=""1"" />
-            <entry offset=""0x10e"" hidden=""true"" document=""1"" />
-            <entry offset=""0x11f"" hidden=""true"" document=""1"" />
-            <entry offset=""0x12f"" hidden=""true"" document=""1"" />
-            <entry offset=""0x13d"" hidden=""true"" document=""1"" />
-            <entry offset=""0x14b"" hidden=""true"" document=""1"" />
-            <entry offset=""0x14d"" startLine=""27"" startColumn=""19"" endLine=""27"" endColumn=""33"" document=""1"" />
-            <entry offset=""0x157"" hidden=""true"" document=""1"" />
-            <entry offset=""0x159"" startLine=""27"" startColumn=""37"" endLine=""27"" endColumn=""38"" document=""1"" />
-            <entry offset=""0x15e"" startLine=""30"" startColumn=""23"" endLine=""30"" endColumn=""24"" document=""1"" />
-            <entry offset=""0x163"" hidden=""true"" document=""1"" />
-            <entry offset=""0x165"" startLine=""33"" startColumn=""27"" endLine=""33"" endColumn=""28"" document=""1"" />
-            <entry offset=""0x16a"" startLine=""36"" startColumn=""20"" endLine=""36"" endColumn=""21"" document=""1"" />
-            <entry offset=""0x16f"" startLine=""39"" startColumn=""17"" endLine=""39"" endColumn=""25"" document=""1"" />
-            <entry offset=""0x176"" hidden=""true"" document=""1"" />
-            <entry offset=""0x17b"" startLine=""39"" startColumn=""17"" endLine=""39"" endColumn=""25"" document=""1"" />
-            <entry offset=""0x182"" hidden=""true"" document=""1"" />
-            <entry offset=""0x187"" startLine=""39"" startColumn=""29"" endLine=""39"" endColumn=""30"" document=""1"" />
-            <entry offset=""0x18c"" startLine=""40"" startColumn=""19"" endLine=""40"" endColumn=""20"" document=""1"" />
-            <entry offset=""0x191"" hidden=""true"" document=""1"" />
-            <entry offset=""0x193"" startLine=""41"" startColumn=""35"" endLine=""41"" endColumn=""36"" document=""1"" />
-            <entry offset=""0x198"" hidden=""true"" document=""1"" />
-            <entry offset=""0x19a"" startLine=""42"" startColumn=""28"" endLine=""42"" endColumn=""29"" document=""1"" />
-            <entry offset=""0x19f"" hidden=""true"" document=""1"" />
-            <entry offset=""0x1a1"" startLine=""45"" startColumn=""56"" endLine=""45"" endColumn=""57"" document=""1"" />
-            <entry offset=""0x1a7"" startLine=""47"" startColumn=""18"" endLine=""47"" endColumn=""20"" document=""1"" />
-            <entry offset=""0x1ad"" hidden=""true"" document=""1"" />
-            <entry offset=""0x1b0"" startLine=""24"" startColumn=""9"" endLine=""48"" endColumn=""11"" document=""1"" />
-            <entry offset=""0x1b1"" hidden=""true"" document=""1"" />
-            <entry offset=""0x1b4"" startLine=""49"" startColumn=""5"" endLine=""49"" endColumn=""6"" document=""1"" />
-          </sequencePoints>
-          <scope startOffset=""0x0"" endOffset=""0x1b5"">
-            <local name=""a"" il_index=""0"" il_start=""0x0"" il_end=""0x1b5"" attributes=""0"" />
-            <scope startOffset=""0x14d"" endOffset=""0x15e"">
-              <local name=""x"" il_index=""1"" il_start=""0x14d"" il_end=""0x15e"" attributes=""0"" />
-            </scope>
-            <scope startOffset=""0x163"" endOffset=""0x16a"">
-              <local name=""y"" il_index=""2"" il_start=""0x163"" il_end=""0x16a"" attributes=""0"" />
-              <local name=""z"" il_index=""3"" il_start=""0x163"" il_end=""0x16a"" attributes=""0"" />
-            </scope>
-            <scope startOffset=""0x191"" endOffset=""0x198"">
-              <local name=""p"" il_index=""4"" il_start=""0x191"" il_end=""0x198"" attributes=""0"" />
-              <local name=""q"" il_index=""5"" il_start=""0x191"" il_end=""0x198"" attributes=""0"" />
-            </scope>
-            <scope startOffset=""0x198"" endOffset=""0x19f"">
-              <local name=""p"" il_index=""6"" il_start=""0x198"" il_end=""0x19f"" attributes=""0"" />
-            </scope>
-            <scope startOffset=""0x19f"" endOffset=""0x1a7"">
-              <local name=""z"" il_index=""7"" il_start=""0x19f"" il_end=""0x1a7"" attributes=""0"" />
-            </scope>
-          </scope>
-        </method>
-      </methods>
-    </symbols>
+<symbols>
+  <files>
+    <file id=""1"" name="""" language=""C#"" />
+  </files>
+  <methods>
+    <method containingType=""Program"" name=""Main"">
+      <customDebugInfo>
+        <forward declaringType=""C"" methodName=""Deconstruct"" />
+        <encLocalSlotMap>
+          <slot kind=""0"" offset=""15"" />
+          <slot kind=""temp"" />
+          <slot kind=""0"" offset=""94"" />
+          <slot kind=""0"" offset=""225"" />
+          <slot kind=""0"" offset=""228"" />
+          <slot kind=""0"" offset=""406"" />
+          <slot kind=""0"" offset=""415"" />
+          <slot kind=""0"" offset=""447"" />
+          <slot kind=""0"" offset=""539"" />
+          <slot kind=""temp"" />
+          <slot kind=""35"" offset=""23"" />
+          <slot kind=""35"" offset=""23"" ordinal=""1"" />
+          <slot kind=""35"" offset=""23"" ordinal=""2"" />
+          <slot kind=""35"" offset=""23"" ordinal=""3"" />
+          <slot kind=""35"" offset=""23"" ordinal=""4"" />
+          <slot kind=""35"" offset=""23"" ordinal=""5"" />
+          <slot kind=""35"" offset=""23"" ordinal=""6"" />
+          <slot kind=""35"" offset=""23"" ordinal=""7"" />
+          <slot kind=""35"" offset=""23"" ordinal=""8"" />
+          <slot kind=""35"" offset=""23"" ordinal=""9"" />
+          <slot kind=""35"" offset=""23"" ordinal=""10"" />
+          <slot kind=""35"" offset=""23"" ordinal=""11"" />
+        </encLocalSlotMap>
+      </customDebugInfo>
+      <sequencePoints>
+        <entry offset=""0x0"" startLine=""23"" startColumn=""5"" endLine=""23"" endColumn=""6"" document=""1"" />
+        <entry offset=""0x1"" startLine=""24"" startColumn=""9"" endLine=""48"" endColumn=""11"" document=""1"" />
+        <entry offset=""0xb"" startLine=""24"" startColumn=""21"" endLine=""48"" endColumn=""10"" document=""1"" />
+        <entry offset=""0xc"" hidden=""true"" document=""1"" />
+        <entry offset=""0x1d"" hidden=""true"" document=""1"" />
+        <entry offset=""0x44"" hidden=""true"" document=""1"" />
+        <entry offset=""0x52"" hidden=""true"" document=""1"" />
+        <entry offset=""0x5c"" hidden=""true"" document=""1"" />
+        <entry offset=""0x93"" hidden=""true"" document=""1"" />
+        <entry offset=""0xbf"" hidden=""true"" document=""1"" />
+        <entry offset=""0xcb"" hidden=""true"" document=""1"" />
+        <entry offset=""0xe2"" hidden=""true"" document=""1"" />
+        <entry offset=""0xf1"" hidden=""true"" document=""1"" />
+        <entry offset=""0x10f"" hidden=""true"" document=""1"" />
+        <entry offset=""0x120"" hidden=""true"" document=""1"" />
+        <entry offset=""0x130"" hidden=""true"" document=""1"" />
+        <entry offset=""0x141"" hidden=""true"" document=""1"" />
+        <entry offset=""0x14f"" hidden=""true"" document=""1"" />
+        <entry offset=""0x151"" startLine=""27"" startColumn=""19"" endLine=""27"" endColumn=""33"" document=""1"" />
+        <entry offset=""0x15b"" hidden=""true"" document=""1"" />
+        <entry offset=""0x15d"" startLine=""27"" startColumn=""37"" endLine=""27"" endColumn=""38"" document=""1"" />
+        <entry offset=""0x162"" startLine=""30"" startColumn=""23"" endLine=""30"" endColumn=""24"" document=""1"" />
+        <entry offset=""0x167"" hidden=""true"" document=""1"" />
+        <entry offset=""0x169"" startLine=""33"" startColumn=""27"" endLine=""33"" endColumn=""28"" document=""1"" />
+        <entry offset=""0x16e"" startLine=""36"" startColumn=""20"" endLine=""36"" endColumn=""21"" document=""1"" />
+        <entry offset=""0x173"" hidden=""true"" document=""1"" />
+        <entry offset=""0x17b"" startLine=""39"" startColumn=""17"" endLine=""39"" endColumn=""25"" document=""1"" />
+        <entry offset=""0x182"" hidden=""true"" document=""1"" />
+        <entry offset=""0x198"" startLine=""39"" startColumn=""29"" endLine=""39"" endColumn=""30"" document=""1"" />
+        <entry offset=""0x19d"" startLine=""40"" startColumn=""19"" endLine=""40"" endColumn=""20"" document=""1"" />
+        <entry offset=""0x1a2"" hidden=""true"" document=""1"" />
+        <entry offset=""0x1a4"" startLine=""41"" startColumn=""35"" endLine=""41"" endColumn=""36"" document=""1"" />
+        <entry offset=""0x1a9"" hidden=""true"" document=""1"" />
+        <entry offset=""0x1ab"" startLine=""42"" startColumn=""28"" endLine=""42"" endColumn=""29"" document=""1"" />
+        <entry offset=""0x1b0"" hidden=""true"" document=""1"" />
+        <entry offset=""0x1b2"" startLine=""45"" startColumn=""56"" endLine=""45"" endColumn=""57"" document=""1"" />
+        <entry offset=""0x1b8"" startLine=""47"" startColumn=""18"" endLine=""47"" endColumn=""20"" document=""1"" />
+        <entry offset=""0x1be"" hidden=""true"" document=""1"" />
+        <entry offset=""0x1c1"" startLine=""24"" startColumn=""9"" endLine=""48"" endColumn=""11"" document=""1"" />
+        <entry offset=""0x1c2"" hidden=""true"" document=""1"" />
+        <entry offset=""0x1c5"" startLine=""49"" startColumn=""5"" endLine=""49"" endColumn=""6"" document=""1"" />
+      </sequencePoints>
+      <scope startOffset=""0x0"" endOffset=""0x1c6"">
+        <local name=""a"" il_index=""0"" il_start=""0x0"" il_end=""0x1c6"" attributes=""0"" />
+        <scope startOffset=""0x151"" endOffset=""0x162"">
+          <local name=""x"" il_index=""2"" il_start=""0x151"" il_end=""0x162"" attributes=""0"" />
+        </scope>
+        <scope startOffset=""0x167"" endOffset=""0x16e"">
+          <local name=""y"" il_index=""3"" il_start=""0x167"" il_end=""0x16e"" attributes=""0"" />
+          <local name=""z"" il_index=""4"" il_start=""0x167"" il_end=""0x16e"" attributes=""0"" />
+        </scope>
+        <scope startOffset=""0x1a2"" endOffset=""0x1a9"">
+          <local name=""p"" il_index=""5"" il_start=""0x1a2"" il_end=""0x1a9"" attributes=""0"" />
+          <local name=""q"" il_index=""6"" il_start=""0x1a2"" il_end=""0x1a9"" attributes=""0"" />
+        </scope>
+        <scope startOffset=""0x1a9"" endOffset=""0x1b0"">
+          <local name=""p"" il_index=""7"" il_start=""0x1a9"" il_end=""0x1b0"" attributes=""0"" />
+        </scope>
+        <scope startOffset=""0x1b0"" endOffset=""0x1b8"">
+          <local name=""z"" il_index=""8"" il_start=""0x1b0"" il_end=""0x1b8"" attributes=""0"" />
+        </scope>
+      </scope>
+    </method>
+  </methods>
+</symbols>
 ");
         }
 
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/BindingTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/BindingTests.cs
index cf8e4899f0382..5431341ab00a0 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/BindingTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/BindingTests.cs
@@ -3558,6 +3558,9 @@ public void Test()
                 // (18,31): error CS8389: Omitting the type argument is not allowed in the current context
                 //         var omittedArgFunc1 = "string literal".ExtensionMethod1<>;
                 Diagnostic(ErrorCode.ERR_OmittedTypeArgument, @"""string literal"".ExtensionMethod1<>").WithLocation(18, 31),
+                // (18,31): error CS7003: Unexpected use of an unbound generic name
+                //         var omittedArgFunc1 = "string literal".ExtensionMethod1<>;
+                Diagnostic(ErrorCode.ERR_UnexpectedUnboundGenericName, @"""string literal"".ExtensionMethod1<>").WithLocation(18, 31),
                 // (19,31): error CS8389: Omitting the type argument is not allowed in the current context
                 //         var omittedArgFunc2 = "string literal".ExtensionMethod2<>;
                 Diagnostic(ErrorCode.ERR_OmittedTypeArgument, @"""string literal"".ExtensionMethod2<>").WithLocation(19, 31),
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/DeconstructionTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/DeconstructionTests.cs
index 212220a0974be..6794e0f85d9bc 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/DeconstructionTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/DeconstructionTests.cs
@@ -6258,5 +6258,124 @@ void M2(out int x)
 
             VerifyOperationTreeAndDiagnosticsForTest<DeclarationExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
         }
+
+        [Fact]
+        [WorkItem(46165, "https://github.com/dotnet/roslyn/issues/46165")]
+        public void Issue46165_1()
+        {
+            var text = @"
+class C
+{
+    static void Main()
+    {
+        foreach ((var i, i))
+    }
+}";
+
+            CreateCompilation(text).VerifyEmitDiagnostics(
+                // (6,18): error CS8186: A foreach loop must declare its iteration variables.
+                //         foreach ((var i, i))
+                Diagnostic(ErrorCode.ERR_MustDeclareForeachIteration, "(var i, i)").WithLocation(6, 18),
+                // (6,23): error CS8130: Cannot infer the type of implicitly-typed deconstruction variable 'i'.
+                //         foreach ((var i, i))
+                Diagnostic(ErrorCode.ERR_TypeInferenceFailedForImplicitlyTypedDeconstructionVariable, "i").WithArguments("i").WithLocation(6, 23),
+                // (6,26): error CS0841: Cannot use local variable 'i' before it is declared
+                //         foreach ((var i, i))
+                Diagnostic(ErrorCode.ERR_VariableUsedBeforeDeclaration, "i").WithArguments("i").WithLocation(6, 26),
+                // (6,28): error CS1515: 'in' expected
+                //         foreach ((var i, i))
+                Diagnostic(ErrorCode.ERR_InExpected, ")").WithLocation(6, 28),
+                // (6,28): error CS1525: Invalid expression term ')'
+                //         foreach ((var i, i))
+                Diagnostic(ErrorCode.ERR_InvalidExprTerm, ")").WithArguments(")").WithLocation(6, 28),
+                // (6,29): error CS1525: Invalid expression term '}'
+                //         foreach ((var i, i))
+                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "").WithArguments("}").WithLocation(6, 29),
+                // (6,29): error CS1002: ; expected
+                //         foreach ((var i, i))
+                Diagnostic(ErrorCode.ERR_SemicolonExpected, "").WithLocation(6, 29)
+                );
+        }
+
+        [Fact]
+        [WorkItem(46165, "https://github.com/dotnet/roslyn/issues/46165")]
+        public void Issue46165_2()
+        {
+            var text = @"
+class C
+{
+    static void Main()
+    {
+        (var i, i) = ;
+    }
+}";
+
+            CreateCompilation(text).VerifyEmitDiagnostics(
+                // (6,14): error CS8130: Cannot infer the type of implicitly-typed deconstruction variable 'i'.
+                //         (var i, i) = ;
+                Diagnostic(ErrorCode.ERR_TypeInferenceFailedForImplicitlyTypedDeconstructionVariable, "i").WithArguments("i").WithLocation(6, 14),
+                // (6,17): error CS0841: Cannot use local variable 'i' before it is declared
+                //         (var i, i) = ;
+                Diagnostic(ErrorCode.ERR_VariableUsedBeforeDeclaration, "i").WithArguments("i").WithLocation(6, 17),
+                // (6,22): error CS1525: Invalid expression term ';'
+                //         (var i, i) = ;
+                Diagnostic(ErrorCode.ERR_InvalidExprTerm, ";").WithArguments(";").WithLocation(6, 22)
+                );
+        }
+
+        [Fact]
+        [WorkItem(46165, "https://github.com/dotnet/roslyn/issues/46165")]
+        public void Issue46165_3()
+        {
+            var text = @"
+class C
+{
+    static void Main()
+    {
+        foreach ((int i, i))
+    }
+}";
+
+            CreateCompilation(text).VerifyEmitDiagnostics(
+                // (6,18): error CS8186: A foreach loop must declare its iteration variables.
+                //         foreach ((int i, i))
+                Diagnostic(ErrorCode.ERR_MustDeclareForeachIteration, "(int i, i)").WithLocation(6, 18),
+                // (6,26): error CS1656: Cannot assign to 'i' because it is a 'foreach iteration variable'
+                //         foreach ((int i, i))
+                Diagnostic(ErrorCode.ERR_AssgReadonlyLocalCause, "i").WithArguments("i", "foreach iteration variable").WithLocation(6, 26),
+                // (6,28): error CS1515: 'in' expected
+                //         foreach ((int i, i))
+                Diagnostic(ErrorCode.ERR_InExpected, ")").WithLocation(6, 28),
+                // (6,28): error CS1525: Invalid expression term ')'
+                //         foreach ((int i, i))
+                Diagnostic(ErrorCode.ERR_InvalidExprTerm, ")").WithArguments(")").WithLocation(6, 28),
+                // (6,29): error CS1525: Invalid expression term '}'
+                //         foreach ((int i, i))
+                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "").WithArguments("}").WithLocation(6, 29),
+                // (6,29): error CS1002: ; expected
+                //         foreach ((int i, i))
+                Diagnostic(ErrorCode.ERR_SemicolonExpected, "").WithLocation(6, 29)
+                );
+        }
+
+        [Fact]
+        [WorkItem(46165, "https://github.com/dotnet/roslyn/issues/46165")]
+        public void Issue46165_4()
+        {
+            var text = @"
+class C
+{
+    static void Main()
+    {
+        (int i, i) = ;
+    }
+}";
+
+            CreateCompilation(text).VerifyEmitDiagnostics(
+                // (6,22): error CS1525: Invalid expression term ';'
+                //         (int i, i) = ;
+                Diagnostic(ErrorCode.ERR_InvalidExprTerm, ";").WithArguments(";").WithLocation(6, 22)
+                );
+        }
     }
 }
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/DelegateTypeTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/DelegateTypeTests.cs
index 27eb4db64382d..7edef10a37d1e 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/DelegateTypeTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/DelegateTypeTests.cs
@@ -55,6 +55,10 @@ private static string Concat(string container, string name)
     }
 }";
 
+        private static readonly string s_expressionOfTDelegateTypeName = ExecutionConditionUtil.IsDesktop ?
+            "System.Linq.Expressions.Expression`1" :
+            "System.Linq.Expressions.Expression0`1";
+
         [Fact]
         public void LanguageVersion()
         {
@@ -91,61 +95,424 @@ static void Main()
         }
 
         [Fact]
-        public void MethodGroupConversions()
+        public void MethodGroupConversions_01()
         {
             var source =
-@"class Program
+@"using System;
+class Program
 {
     static void Main()
     {
         object o = Main;
-        System.ICloneable c = Main;
-        System.Delegate d = Main;
-        System.MulticastDelegate m = Main;
+        ICloneable c = Main;
+        Delegate d = Main;
+        MulticastDelegate m = Main;
+        Report(o);
+        Report(c);
+        Report(d);
+        Report(m);
     }
+    static void Report(object obj) => Console.WriteLine(obj.GetType());
 }";
-            var comp = CreateCompilation(source, parseOptions: TestOptions.RegularPreview);
+
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
             comp.VerifyDiagnostics(
-                // (5,20): error CS0428: Cannot convert method group 'Main' to non-delegate type 'object'. Did you intend to invoke the method?
+                // (6,20): error CS0428: Cannot convert method group 'Main' to non-delegate type 'object'. Did you intend to invoke the method?
                 //         object o = Main;
-                Diagnostic(ErrorCode.ERR_MethGrpToNonDel, "Main").WithArguments("Main", "object").WithLocation(5, 20),
-                // (6,31): error CS0428: Cannot convert method group 'Main' to non-delegate type 'ICloneable'. Did you intend to invoke the method?
-                //         System.ICloneable c = Main;
-                Diagnostic(ErrorCode.ERR_MethGrpToNonDel, "Main").WithArguments("Main", "System.ICloneable").WithLocation(6, 31),
-                // (8,38): error CS0428: Cannot convert method group 'Main' to non-delegate type 'MulticastDelegate'. Did you intend to invoke the method?
-                //         System.MulticastDelegate m = Main;
-                Diagnostic(ErrorCode.ERR_MethGrpToNonDel, "Main").WithArguments("Main", "System.MulticastDelegate").WithLocation(8, 38));
+                Diagnostic(ErrorCode.ERR_MethGrpToNonDel, "Main").WithArguments("Main", "object").WithLocation(6, 20),
+                // (7,24): error CS0428: Cannot convert method group 'Main' to non-delegate type 'ICloneable'. Did you intend to invoke the method?
+                //         ICloneable c = Main;
+                Diagnostic(ErrorCode.ERR_MethGrpToNonDel, "Main").WithArguments("Main", "System.ICloneable").WithLocation(7, 24),
+                // (8,22): error CS0428: Cannot convert method group 'Main' to non-delegate type 'Delegate'. Did you intend to invoke the method?
+                //         Delegate d = Main;
+                Diagnostic(ErrorCode.ERR_MethGrpToNonDel, "Main").WithArguments("Main", "System.Delegate").WithLocation(8, 22),
+                // (9,31): error CS0428: Cannot convert method group 'Main' to non-delegate type 'MulticastDelegate'. Did you intend to invoke the method?
+                //         MulticastDelegate m = Main;
+                Diagnostic(ErrorCode.ERR_MethGrpToNonDel, "Main").WithArguments("Main", "System.MulticastDelegate").WithLocation(9, 31));
+
+            CompileAndVerify(source, options: TestOptions.ReleaseExe, expectedOutput:
+@"System.Action
+System.Action
+System.Action
+System.Action
+");
+        }
+
+        [Fact]
+        public void MethodGroupConversions_02()
+        {
+            var source =
+@"using System;
+class Program
+{
+    static void Main()
+    {
+        var o = (object)Main;
+        var c = (ICloneable)Main;
+        var d = (Delegate)Main;
+        var m = (MulticastDelegate)Main;
+        Report(o);
+        Report(c);
+        Report(d);
+        Report(m);
+    }
+    static void Report(object obj) => Console.WriteLine(obj.GetType());
+}";
+
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
+            comp.VerifyDiagnostics(
+                // (6,17): error CS0030: Cannot convert type 'method' to 'object'
+                //         var o = (object)Main;
+                Diagnostic(ErrorCode.ERR_NoExplicitConv, "(object)Main").WithArguments("method", "object").WithLocation(6, 17),
+                // (7,17): error CS0030: Cannot convert type 'method' to 'ICloneable'
+                //         var c = (ICloneable)Main;
+                Diagnostic(ErrorCode.ERR_NoExplicitConv, "(ICloneable)Main").WithArguments("method", "System.ICloneable").WithLocation(7, 17),
+                // (8,17): error CS0030: Cannot convert type 'method' to 'Delegate'
+                //         var d = (Delegate)Main;
+                Diagnostic(ErrorCode.ERR_NoExplicitConv, "(Delegate)Main").WithArguments("method", "System.Delegate").WithLocation(8, 17),
+                // (9,17): error CS0030: Cannot convert type 'method' to 'MulticastDelegate'
+                //         var m = (MulticastDelegate)Main;
+                Diagnostic(ErrorCode.ERR_NoExplicitConv, "(MulticastDelegate)Main").WithArguments("method", "System.MulticastDelegate").WithLocation(9, 17));
+
+            CompileAndVerify(source, options: TestOptions.ReleaseExe, expectedOutput:
+@"System.Action
+System.Action
+System.Action
+System.Action
+");
         }
 
         [Fact]
-        public void LambdaConversions()
+        public void MethodGroupConversions_03()
         {
             var source =
 @"class Program
+{
+    static void Main()
+    {
+        System.Linq.Expressions.Expression e = F;
+        e = (System.Linq.Expressions.Expression)F;
+    }
+    static int F() => 1;
+}";
+
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
+            comp.VerifyDiagnostics(
+                // (5,48): error CS0428: Cannot convert method group 'F' to non-delegate type 'Expression'. Did you intend to invoke the method?
+                //         System.Linq.Expressions.Expression e = F;
+                Diagnostic(ErrorCode.ERR_MethGrpToNonDel, "F").WithArguments("F", "System.Linq.Expressions.Expression").WithLocation(5, 48),
+                // (6,13): error CS0030: Cannot convert type 'method' to 'Expression'
+                //         e = (System.Linq.Expressions.Expression)F;
+                Diagnostic(ErrorCode.ERR_NoExplicitConv, "(System.Linq.Expressions.Expression)F").WithArguments("method", "System.Linq.Expressions.Expression").WithLocation(6, 13));
+
+            comp = CreateCompilation(source);
+            comp.VerifyDiagnostics(
+                // (5,48): error CS0428: Cannot convert method group 'F' to non-delegate type 'Expression'. Did you intend to invoke the method?
+                //         System.Linq.Expressions.Expression e = F;
+                Diagnostic(ErrorCode.ERR_MethGrpToNonDel, "F").WithArguments("F", "System.Linq.Expressions.Expression").WithLocation(5, 48),
+                // (6,13): error CS0428: Cannot convert method group 'F' to non-delegate type 'Expression'. Did you intend to invoke the method?
+                //         e = (System.Linq.Expressions.Expression)F;
+                Diagnostic(ErrorCode.ERR_MethGrpToNonDel, "(System.Linq.Expressions.Expression)F").WithArguments("F", "System.Linq.Expressions.Expression").WithLocation(6, 13));
+        }
+
+        [Fact]
+        public void MethodGroupConversions_04()
+        {
+            var source =
+@"using System;
+using System.Linq.Expressions;
+class Program
+{
+    static void F() { }
+    static void F(object o) { }
+    static void Main()
+    {
+        object o = F;
+        ICloneable c = F;
+        Delegate d = F;
+        MulticastDelegate m = F;
+        Expression e = F;
+    }
+}";
+
+            var comp = CreateCompilation(source);
+            comp.VerifyDiagnostics(
+                // (9,20): error CS8917: The delegate type could not be inferred.
+                //         object o = F;
+                Diagnostic(ErrorCode.ERR_CannotInferDelegateType, "F").WithLocation(9, 20),
+                // (10,24): error CS8917: The delegate type could not be inferred.
+                //         ICloneable c = F;
+                Diagnostic(ErrorCode.ERR_CannotInferDelegateType, "F").WithLocation(10, 24),
+                // (11,22): error CS8917: The delegate type could not be inferred.
+                //         Delegate d = F;
+                Diagnostic(ErrorCode.ERR_CannotInferDelegateType, "F").WithLocation(11, 22),
+                // (12,31): error CS8917: The delegate type could not be inferred.
+                //         MulticastDelegate m = F;
+                Diagnostic(ErrorCode.ERR_CannotInferDelegateType, "F").WithLocation(12, 31),
+                // (13,24): error CS0428: Cannot convert method group 'F' to non-delegate type 'Expression'. Did you intend to invoke the method?
+                //         Expression e = F;
+                Diagnostic(ErrorCode.ERR_MethGrpToNonDel, "F").WithArguments("F", "System.Linq.Expressions.Expression").WithLocation(13, 24));
+        }
+
+        [Fact]
+        public void LambdaConversions_01()
+        {
+            var source =
+@"using System;
+class Program
 {
     static void Main()
     {
         object o = () => { };
-        System.ICloneable c = () => { };
-        System.Delegate d = () => { };
-        System.MulticastDelegate m = () => { };
-        d = x => x;
+        ICloneable c = () => { };
+        Delegate d = () => { };
+        MulticastDelegate m = () => { };
+        Report(o);
+        Report(c);
+        Report(d);
+        Report(m);
     }
+    static void Report(object obj) => Console.WriteLine(obj.GetType());
 }";
-            var comp = CreateCompilation(source, parseOptions: TestOptions.RegularPreview);
+
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
             comp.VerifyDiagnostics(
-                // (5,20): error CS1660: Cannot convert lambda expression to type 'object' because it is not a delegate type
+                // (6,20): error CS1660: Cannot convert lambda expression to type 'object' because it is not a delegate type
                 //         object o = () => { };
-                Diagnostic(ErrorCode.ERR_AnonMethToNonDel, "() => { }").WithArguments("lambda expression", "object").WithLocation(5, 20),
-                // (6,31): error CS1660: Cannot convert lambda expression to type 'ICloneable' because it is not a delegate type
-                //         System.ICloneable c = () => { };
-                Diagnostic(ErrorCode.ERR_AnonMethToNonDel, "() => { }").WithArguments("lambda expression", "System.ICloneable").WithLocation(6, 31),
-                // (8,38): error CS1660: Cannot convert lambda expression to type 'MulticastDelegate' because it is not a delegate type
-                //         System.MulticastDelegate m = () => { };
-                Diagnostic(ErrorCode.ERR_AnonMethToNonDel, "() => { }").WithArguments("lambda expression", "System.MulticastDelegate").WithLocation(8, 38),
-                // (9,13): error CS8917: The delegate type could not be inferred.
-                //         d = x => x;
-                Diagnostic(ErrorCode.ERR_CannotInferDelegateType, "x => x").WithLocation(9, 13));
+                Diagnostic(ErrorCode.ERR_AnonMethToNonDel, "() => { }").WithArguments("lambda expression", "object").WithLocation(6, 20),
+                // (7,24): error CS1660: Cannot convert lambda expression to type 'ICloneable' because it is not a delegate type
+                //         ICloneable c = () => { };
+                Diagnostic(ErrorCode.ERR_AnonMethToNonDel, "() => { }").WithArguments("lambda expression", "System.ICloneable").WithLocation(7, 24),
+                // (8,22): error CS1660: Cannot convert lambda expression to type 'Delegate' because it is not a delegate type
+                //         Delegate d = () => { };
+                Diagnostic(ErrorCode.ERR_AnonMethToNonDel, "() => { }").WithArguments("lambda expression", "System.Delegate").WithLocation(8, 22),
+                // (9,31): error CS1660: Cannot convert lambda expression to type 'MulticastDelegate' because it is not a delegate type
+                //         MulticastDelegate m = () => { };
+                Diagnostic(ErrorCode.ERR_AnonMethToNonDel, "() => { }").WithArguments("lambda expression", "System.MulticastDelegate").WithLocation(9, 31));
+
+            CompileAndVerify(source, options: TestOptions.ReleaseExe, expectedOutput:
+@"System.Action
+System.Action
+System.Action
+System.Action
+");
+        }
+
+        [Fact]
+        public void LambdaConversions_02()
+        {
+            var source =
+@"using System;
+class Program
+{
+    static void Main()
+    {
+        var o = (object)(() => { });
+        var c = (ICloneable)(() => { });
+        var d = (Delegate)(() => { });
+        var m = (MulticastDelegate)(() => { });
+        Report(o);
+        Report(c);
+        Report(d);
+        Report(m);
+    }
+    static void Report(object obj) => Console.WriteLine(obj.GetType());
+}";
+
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
+            comp.VerifyDiagnostics(
+                // (6,26): error CS1660: Cannot convert lambda expression to type 'object' because it is not a delegate type
+                //         var o = (object)(() => { });
+                Diagnostic(ErrorCode.ERR_AnonMethToNonDel, "() => { }").WithArguments("lambda expression", "object").WithLocation(6, 26),
+                // (7,30): error CS1660: Cannot convert lambda expression to type 'ICloneable' because it is not a delegate type
+                //         var c = (ICloneable)(() => { });
+                Diagnostic(ErrorCode.ERR_AnonMethToNonDel, "() => { }").WithArguments("lambda expression", "System.ICloneable").WithLocation(7, 30),
+                // (8,28): error CS1660: Cannot convert lambda expression to type 'Delegate' because it is not a delegate type
+                //         var d = (Delegate)(() => { });
+                Diagnostic(ErrorCode.ERR_AnonMethToNonDel, "() => { }").WithArguments("lambda expression", "System.Delegate").WithLocation(8, 28),
+                // (9,37): error CS1660: Cannot convert lambda expression to type 'MulticastDelegate' because it is not a delegate type
+                //         var m = (MulticastDelegate)(() => { });
+                Diagnostic(ErrorCode.ERR_AnonMethToNonDel, "() => { }").WithArguments("lambda expression", "System.MulticastDelegate").WithLocation(9, 37));
+
+            CompileAndVerify(source, options: TestOptions.ReleaseExe, expectedOutput:
+@"System.Action
+System.Action
+System.Action
+System.Action
+");
+        }
+
+        [Fact]
+        public void LambdaConversions_03()
+        {
+            var source =
+@"using System;
+using System.Linq.Expressions;
+class Program
+{
+    static void Main()
+    {
+        Expression e = () => 1;
+        Report(e);
+        e = (Expression)(() => 2);
+        Report(e);
+    }
+    static void Report(object obj) => Console.WriteLine(obj.GetType());
+}";
+
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
+            comp.VerifyDiagnostics(
+                // (7,24): error CS1660: Cannot convert lambda expression to type 'Expression' because it is not a delegate type
+                //         Expression e = () => 1;
+                Diagnostic(ErrorCode.ERR_AnonMethToNonDel, "() => 1").WithArguments("lambda expression", "System.Linq.Expressions.Expression").WithLocation(7, 24),
+                // (9,26): error CS1660: Cannot convert lambda expression to type 'Expression' because it is not a delegate type
+                //         e = (Expression)(() => 2);
+                Diagnostic(ErrorCode.ERR_AnonMethToNonDel, "() => 2").WithArguments("lambda expression", "System.Linq.Expressions.Expression").WithLocation(9, 26));
+
+            CompileAndVerify(source, options: TestOptions.ReleaseExe, expectedOutput:
+$@"{s_expressionOfTDelegateTypeName}[System.Func`1[System.Int32]]
+{s_expressionOfTDelegateTypeName}[System.Func`1[System.Int32]]
+");
+        }
+
+        [Fact]
+        public void LambdaConversions_04()
+        {
+            var source =
+@"using System;
+using System.Linq.Expressions;
+class Program
+{
+    static void Main()
+    {
+        Delegate d = x => x;
+        object o = (object)(x => x);
+        Expression e = x => x;
+        e = (Expression)(x => x);
+    }
+}";
+
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
+            comp.VerifyDiagnostics(
+                // (7,22): error CS1660: Cannot convert lambda expression to type 'Delegate' because it is not a delegate type
+                //         Delegate d = x => x;
+                Diagnostic(ErrorCode.ERR_AnonMethToNonDel, "x => x").WithArguments("lambda expression", "System.Delegate").WithLocation(7, 22),
+                // (8,29): error CS1660: Cannot convert lambda expression to type 'object' because it is not a delegate type
+                //         object o = (object)(x => x);
+                Diagnostic(ErrorCode.ERR_AnonMethToNonDel, "x => x").WithArguments("lambda expression", "object").WithLocation(8, 29),
+                // (9,24): error CS1660: Cannot convert lambda expression to type 'Expression' because it is not a delegate type
+                //         Expression e = x => x;
+                Diagnostic(ErrorCode.ERR_AnonMethToNonDel, "x => x").WithArguments("lambda expression", "System.Linq.Expressions.Expression").WithLocation(9, 24),
+                // (10,26): error CS1660: Cannot convert lambda expression to type 'Expression' because it is not a delegate type
+                //         e = (Expression)(x => x);
+                Diagnostic(ErrorCode.ERR_AnonMethToNonDel, "x => x").WithArguments("lambda expression", "System.Linq.Expressions.Expression").WithLocation(10, 26));
+
+            comp = CreateCompilation(source);
+            comp.VerifyDiagnostics(
+                // (7,22): error CS8917: The delegate type could not be inferred.
+                //         Delegate d = x => x;
+                Diagnostic(ErrorCode.ERR_CannotInferDelegateType, "x => x").WithLocation(7, 22),
+                // (8,29): error CS8917: The delegate type could not be inferred.
+                //         object o = (object)(x => x);
+                Diagnostic(ErrorCode.ERR_CannotInferDelegateType, "x => x").WithLocation(8, 29),
+                // (9,24): error CS8917: The delegate type could not be inferred.
+                //         Expression e = x => x;
+                Diagnostic(ErrorCode.ERR_CannotInferDelegateType, "x => x").WithLocation(9, 24),
+                // (10,26): error CS8917: The delegate type could not be inferred.
+                //         e = (Expression)(x => x);
+                Diagnostic(ErrorCode.ERR_CannotInferDelegateType, "x => x").WithLocation(10, 26));
+        }
+
+        [Fact]
+        public void LambdaConversions_05()
+        {
+            var source =
+@"using System;
+class Program
+{
+    static void Main()
+    {
+        System.Delegate d = () => Main;
+        System.Linq.Expressions.Expression e = () => Main;
+        Report(d);
+        Report(e);
+    }
+    static void Report(object obj) => Console.WriteLine(obj.GetType());
+}";
+            CompileAndVerify(source, options: TestOptions.ReleaseExe, expectedOutput:
+$@"System.Func`1[System.Action]
+{s_expressionOfTDelegateTypeName}[System.Func`1[System.Action]]
+");
+        }
+
+        [Fact]
+        public void AnonymousMethod_01()
+        {
+            var source =
+@"using System;
+class Program
+{
+    static void Main()
+    {
+        object o = delegate () { };
+        ICloneable c = delegate () { };
+        Delegate d = delegate () { };
+        MulticastDelegate m = delegate () { };
+        Report(o);
+        Report(c);
+        Report(d);
+        Report(m);
+    }
+    static void Report(object obj) => Console.WriteLine(obj.GetType());
+}";
+
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
+            comp.VerifyDiagnostics(
+                // (6,20): error CS1660: Cannot convert anonymous method to type 'object' because it is not a delegate type
+                //         object o = delegate () { };
+                Diagnostic(ErrorCode.ERR_AnonMethToNonDel, "delegate () { }").WithArguments("anonymous method", "object").WithLocation(6, 20),
+                // (7,24): error CS1660: Cannot convert anonymous method to type 'ICloneable' because it is not a delegate type
+                //         ICloneable c = delegate () { };
+                Diagnostic(ErrorCode.ERR_AnonMethToNonDel, "delegate () { }").WithArguments("anonymous method", "System.ICloneable").WithLocation(7, 24),
+                // (8,22): error CS1660: Cannot convert anonymous method to type 'Delegate' because it is not a delegate type
+                //         Delegate d = delegate () { };
+                Diagnostic(ErrorCode.ERR_AnonMethToNonDel, "delegate () { }").WithArguments("anonymous method", "System.Delegate").WithLocation(8, 22),
+                // (9,31): error CS1660: Cannot convert anonymous method to type 'MulticastDelegate' because it is not a delegate type
+                //         MulticastDelegate m = delegate () { };
+                Diagnostic(ErrorCode.ERR_AnonMethToNonDel, "delegate () { }").WithArguments("anonymous method", "System.MulticastDelegate").WithLocation(9, 31));
+
+            CompileAndVerify(source, options: TestOptions.ReleaseExe, expectedOutput:
+@"System.Action
+System.Action
+System.Action
+System.Action
+");
+        }
+
+        [Fact]
+        public void DynamicConversion()
+        {
+            var source =
+@"using System;
+class Program
+{
+    static void Main()
+    {
+        dynamic d;
+        d = Main;
+        d = () => 1;
+    }
+    static void Report(dynamic d) => Console.WriteLine(d.GetType());
+}";
+
+            var comp = CreateCompilation(source);
+            comp.VerifyDiagnostics(
+                // (7,13): error CS0428: Cannot convert method group 'Main' to non-delegate type 'dynamic'. Did you intend to invoke the method?
+                //         d = Main;
+                Diagnostic(ErrorCode.ERR_MethGrpToNonDel, "Main").WithArguments("Main", "dynamic").WithLocation(7, 13),
+                // (8,13): error CS1660: Cannot convert lambda expression to type 'dynamic' because it is not a delegate type
+                //         d = () => 1;
+                Diagnostic(ErrorCode.ERR_AnonMethToNonDel, "() => 1").WithArguments("lambda expression", "dynamic").WithLocation(8, 13));
         }
 
         private static IEnumerable<object?[]> GetMethodGroupData(Func<string, string, DiagnosticDescription[]> getExpectedDiagnostics)
@@ -289,7 +656,7 @@ static void Main()
             yield return getData("static () => 1", "System.Func<System.Int32>");
             yield return getData("async () => { await System.Threading.Tasks.Task.Delay(0); }", "System.Func<System.Threading.Tasks.Task>");
             yield return getData("static async () => { await System.Threading.Tasks.Task.Delay(0); return 0; }", "System.Func<System.Threading.Tasks.Task<System.Int32>>");
-            yield return getData("() => Main", null);
+            yield return getData("() => Main", "System.Func<System.Action<System.String[]>>");
             yield return getData("(int x) => x switch { _ => null }", null);
             yield return getData("_ => { }", null);
             yield return getData("_ => _", null);
@@ -306,6 +673,10 @@ static void Main()
             yield return getData("object () => default", "System.Func<System.Object>");
             yield return getData("void () => { }", "System.Action");
 
+            // These two lambdas have different signatures but produce the same delegate names: https://github.com/dotnet/roslyn/issues/55570
+            yield return getData("(int _1, int _2, int _3, int _4, int _5, int _6, int _7, int _8, int _9, int _10, int _11, int _12, int _13, int _14, int _15, int _16, ref int _17) => { }", "<>A{00000000}<System.Int32, System.Int32, System.Int32, System.Int32, System.Int32, System.Int32, System.Int32, System.Int32, System.Int32, System.Int32, System.Int32, System.Int32, System.Int32, System.Int32, System.Int32, System.Int32, System.Int32>");
+            yield return getData("(int _1, int _2, int _3, int _4, int _5, int _6, int _7, int _8, int _9, int _10, int _11, int _12, int _13, int _14, int _15, int _16, in int _17)  => { }", "<>A{00000000}<System.Int32, System.Int32, System.Int32, System.Int32, System.Int32, System.Int32, System.Int32, System.Int32, System.Int32, System.Int32, System.Int32, System.Int32, System.Int32, System.Int32, System.Int32, System.Int32, System.Int32>");
+
             static object?[] getData(string expr, string? expectedType) =>
                 new object?[] { expr, expectedType };
         }
@@ -369,6 +740,14 @@ static void Main(string[] args)
                 Assert.Equal(expectedType, typeInfo.Type.ToTestDisplayString());
             }
             Assert.Equal(SpecialType.System_Delegate, typeInfo.ConvertedType!.SpecialType);
+
+            var symbolInfo = model.GetSymbolInfo(expr);
+            var method = (IMethodSymbol)symbolInfo.Symbol!;
+            Assert.Equal(MethodKind.LambdaMethod, method.MethodKind);
+            if (typeInfo.Type is { })
+            {
+                Assert.True(HaveMatchingSignatures(((INamedTypeSymbol)typeInfo.Type!).DelegateInvokeMethod!, method));
+            }
         }
 
         [Theory]
@@ -404,6 +783,19 @@ static void Main(string[] args)
             var typeInfo = model.GetTypeInfo(expr);
             Assert.Null(typeInfo.Type);
             Assert.Equal(expectedType, typeInfo.ConvertedType?.ToTestDisplayString());
+
+            var symbolInfo = model.GetSymbolInfo(expr);
+            var method = (IMethodSymbol)symbolInfo.Symbol!;
+            Assert.Equal(MethodKind.LambdaMethod, method.MethodKind);
+            if (typeInfo.Type is { })
+            {
+                Assert.True(HaveMatchingSignatures(((INamedTypeSymbol)typeInfo.Type!).DelegateInvokeMethod!, method));
+            }
+        }
+
+        private static bool HaveMatchingSignatures(IMethodSymbol methodA, IMethodSymbol methodB)
+        {
+            return MemberSignatureComparer.MethodGroupSignatureComparer.Equals(methodA.GetSymbol<MethodSymbol>(), methodB.GetSymbol<MethodSymbol>());
         }
 
         public static IEnumerable<object?[]> GetExpressionData()
@@ -701,7 +1093,13 @@ partial class B : A
                     //         System.Delegate d = this.F<object>;
                     Diagnostic(ErrorCode.ERR_AmbigCall, "this.F<object>").WithArguments("A.F<T>(T)", "B.F<T>(T)").WithLocation(5, 29)
                 }); // different type parameter constraints
-            yield return getData("internal static void F<T>(this T t) where T : class { }", "internal static void F<T>(this T t) where T : struct { }", "this.F<int>", "F<int>"); // different type parameter constraints
+            yield return getData("internal static void F<T>(this T t) where T : class { }", "internal static void F<T>(this T t) where T : struct { }", "this.F<int>", "F<int>",
+                new[]
+                {
+                    // (5,34): error CS0123: No overload for 'F' matches delegate 'Action'
+                    //         System.Delegate d = this.F<int>;
+                    Diagnostic(ErrorCode.ERR_MethDelegateMismatch, "F<int>").WithArguments("F", "System.Action").WithLocation(5, 34)
+                 }); // different type parameter constraints
 
             static object?[] getData(string methodA, string methodB, string methodGroupExpression, string methodGroupOnly, DiagnosticDescription[]? expectedDiagnostics = null, string? expectedMethod = null, string? expectedType = null)
             {
@@ -785,7 +1183,13 @@ static class B
             yield return getData("internal static void F<T>(this object x) { }", "internal static void F(this object x) { }", "this.F<int>", "F<int>", null, "A.F", "System.Action"); // different arity
             yield return getData("internal static void F<T>(this T t) where T : class { }", "internal static void F<T>(this T t) { }", "this.F<object>", "F<object>", null, "A.F", "System.Action"); // different type parameter constraints
             yield return getData("internal static void F<T>(this T t) { }", "internal static void F<T>(this T t) where T : class { }", "this.F<object>", "F<object>", null, "A.F", "System.Action"); // different type parameter constraints
-            yield return getData("internal static void F<T>(this T t) where T : class { }", "internal static void F<T>(this T t) where T : struct { }", "this.F<int>", "F<int>"); // different type parameter constraints
+            yield return getData("internal static void F<T>(this T t) where T : class { }", "internal static void F<T>(this T t) where T : struct { }", "this.F<int>", "F<int>",
+                new[]
+                {
+                    // (6,34): error CS0123: No overload for 'F' matches delegate 'Action'
+                    //         System.Delegate d = this.F<int>;
+                    Diagnostic(ErrorCode.ERR_MethDelegateMismatch, "F<int>").WithArguments("F", "System.Action").WithLocation(6, 34)
+                 }); // different type parameter constraints
 
             static object?[] getData(string methodA, string methodB, string methodGroupExpression, string methodGroupOnly, DiagnosticDescription[]? expectedDiagnostics = null, string? expectedMethod = null, string? expectedType = null)
             {
@@ -1287,6 +1691,60 @@ unsafe static Delegate F<T>()
                 Diagnostic(ErrorCode.ERR_CannotInferDelegateType, "(T t, int* p) => { }").WithLocation(11, 16));
         }
 
+        [Fact]
+        public void Member_01()
+        {
+            var source =
+@"using System;
+class Program
+{
+    static void Main()
+    {
+        Console.WriteLine((() => { }).GetType());
+    }
+}";
+
+            var expectedDiagnostics = new[]
+            {
+                // (6,27): error CS0023: Operator '.' cannot be applied to operand of type 'lambda expression'
+                //         Console.WriteLine((() => { }).GetType());
+                Diagnostic(ErrorCode.ERR_BadUnaryOp, "(() => { }).GetType").WithArguments(".", "lambda expression").WithLocation(6, 27)
+            };
+
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9, options: TestOptions.ReleaseExe);
+            comp.VerifyDiagnostics(expectedDiagnostics);
+
+            comp = CreateCompilation(source, options: TestOptions.ReleaseExe);
+            comp.VerifyDiagnostics(expectedDiagnostics);
+        }
+
+        [Fact]
+        public void Member_02()
+        {
+            var source =
+@"using System;
+class Program
+{
+    static void Main()
+    {
+        Console.WriteLine(Main.GetType());
+    }
+}";
+
+            var expectedDiagnostics = new[]
+            {
+                // (6,27): error CS0119: 'Program.Main()' is a method, which is not valid in the given context
+                //         Console.WriteLine(Main.GetType());
+                Diagnostic(ErrorCode.ERR_BadSKunknown, "Main").WithArguments("Program.Main()", "method").WithLocation(6, 27)
+            };
+
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9, options: TestOptions.ReleaseExe);
+            comp.VerifyDiagnostics(expectedDiagnostics);
+
+            comp = CreateCompilation(source, options: TestOptions.ReleaseExe);
+            comp.VerifyDiagnostics(expectedDiagnostics);
+        }
+
         /// <summary>
         /// Custom modifiers should not affect delegate signature.
         /// </summary>
@@ -1351,12 +1809,18 @@ static void Main()
 }";
             var comp = CreateCompilation(new[] { sourceB, s_utils }, new[] { refA }, parseOptions: TestOptions.RegularPreview, options: TestOptions.ReleaseExe);
             comp.VerifyDiagnostics(
-                // (10,16): error CS1503: Argument 1: cannot convert from 'method group' to 'Delegate'
+                // (10,16): error CS0570: 'A.F1(object)' is not supported by the language
                 //         Report(A.F1);
-                Diagnostic(ErrorCode.ERR_BadArgType, "A.F1").WithArguments("1", "method group", "System.Delegate").WithLocation(10, 16),
-                // (11,16): error CS1503: Argument 1: cannot convert from 'method group' to 'Delegate'
+                Diagnostic(ErrorCode.ERR_BindToBogus, "A.F1").WithArguments("A.F1(object)").WithLocation(10, 16),
+                // (10,16): error CS0648: '' is a type not supported by the language
+                //         Report(A.F1);
+                Diagnostic(ErrorCode.ERR_BogusType, "A.F1").WithArguments("").WithLocation(10, 16),
+                // (11,16): error CS0570: 'A.F2()' is not supported by the language
+                //         Report(A.F2);
+                Diagnostic(ErrorCode.ERR_BindToBogus, "A.F2").WithArguments("A.F2()").WithLocation(11, 16),
+                // (11,16): error CS0648: '' is a type not supported by the language
                 //         Report(A.F2);
-                Diagnostic(ErrorCode.ERR_BadArgType, "A.F2").WithArguments("1", "method group", "System.Delegate").WithLocation(11, 16));
+                Diagnostic(ErrorCode.ERR_BogusType, "A.F2").WithArguments("").WithLocation(11, 16));
         }
 
         [Fact]
@@ -1449,6 +1913,10 @@ .class public sealed System.Int32 extends System.ValueType
   .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ret }
 }
 .class public abstract System.Delegate extends System.Object
+{
+  .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ret }
+}
+.class public abstract System.MulticastDelegate extends System.Delegate
 {
   .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ret }
 }";
@@ -1467,15 +1935,15 @@ static void Main()
 
             var comp = CreateEmptyCompilation(sourceB, new[] { refA }, parseOptions: TestOptions.RegularPreview);
             comp.VerifyDiagnostics(
-                // (6,13): error CS0518: Predefined type 'System.Action' is not defined or imported
+                // (6,13): error CS8917: The delegate type could not be inferred.
                 //         d = Main;
-                Diagnostic(ErrorCode.ERR_PredefinedTypeNotFound, "Main").WithArguments("System.Action").WithLocation(6, 13),
+                Diagnostic(ErrorCode.ERR_CannotInferDelegateType, "Main").WithLocation(6, 13),
                 // (6,13): error CS0518: Predefined type 'System.Action' is not defined or imported
                 //         d = Main;
                 Diagnostic(ErrorCode.ERR_PredefinedTypeNotFound, "Main").WithArguments("System.Action").WithLocation(6, 13),
-                // (6,13): error CS8917: The delegate type could not be inferred.
-                //         d = Main;
-                Diagnostic(ErrorCode.ERR_CannotInferDelegateType, "Main").WithLocation(6, 13),
+                // (7,13): error CS1660: Cannot convert lambda expression to type 'Delegate' because it is not a delegate type
+                //         d = () => 1;
+                Diagnostic(ErrorCode.ERR_AnonMethToNonDel, "() => 1").WithArguments("lambda expression", "System.Delegate").WithLocation(7, 13),
                 // (7,13): error CS0518: Predefined type 'System.Func`1' is not defined or imported
                 //         d = () => 1;
                 Diagnostic(ErrorCode.ERR_PredefinedTypeNotFound, "() => 1").WithArguments("System.Func`1").WithLocation(7, 13));
@@ -1568,9 +2036,6 @@ static void Main()
 
             var comp = CreateEmptyCompilation(sourceB, new[] { refA }, parseOptions: TestOptions.RegularPreview);
             comp.VerifyDiagnostics(
-                // (9,13): error CS0648: 'Action<T>' is a type not supported by the language
-                //         d = F;
-                Diagnostic(ErrorCode.ERR_BogusType, "F").WithArguments("System.Action<T>").WithLocation(9, 13),
                 // (9,13): error CS0648: 'Action<T>' is a type not supported by the language
                 //         d = F;
                 Diagnostic(ErrorCode.ERR_BogusType, "F").WithArguments("System.Action<T>").WithLocation(9, 13),
@@ -1645,6 +2110,9 @@ static void Main()
 
             var comp = CreateEmptyCompilation(sourceB, new[] { refA }, parseOptions: TestOptions.RegularPreview);
             comp.VerifyDiagnostics(
+                // (5,48): error CS1660: Cannot convert lambda expression to type 'Expression' because it is not a delegate type
+                //         System.Linq.Expressions.Expression e = () => 1;
+                Diagnostic(ErrorCode.ERR_AnonMethToNonDel, "() => 1").WithArguments("lambda expression", "System.Linq.Expressions.Expression").WithLocation(5, 48),
                 // (5,48): error CS0518: Predefined type 'System.Linq.Expressions.Expression`1' is not defined or imported
                 //         System.Linq.Expressions.Expression e = () => 1;
                 Diagnostic(ErrorCode.ERR_PredefinedTypeNotFound, "() => 1").WithArguments("System.Linq.Expressions.Expression`1").WithLocation(5, 48));
@@ -1738,6 +2206,113 @@ static void Main()
                 Diagnostic(ErrorCode.ERR_BogusType, "() => 1").WithArguments("System.Linq.Expressions.Expression<T>").WithLocation(5, 48));
         }
 
+        // Expression<T> not derived from Expression.
+        private static MetadataReference GetCorlibWithExpressionOfTNotDerivedType()
+        {
+            var sourceA =
+@".assembly mscorlib
+{
+  .ver 0:0:0:0
+}
+.class public System.Object
+{
+  .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ret }
+}
+.class public abstract System.ValueType extends System.Object
+{
+  .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ret }
+}
+.class public System.String extends System.Object
+{
+  .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ret }
+}
+.class public System.Type extends System.Object
+{
+  .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ret }
+}
+.class public sealed System.Void extends System.ValueType
+{
+  .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ret }
+}
+.class public sealed System.Boolean extends System.ValueType
+{
+  .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ret }
+}
+.class public sealed System.Int32 extends System.ValueType
+{
+  .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ret }
+}
+.class public abstract System.Delegate extends System.Object
+{
+  .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ret }
+}
+.class public abstract System.MulticastDelegate extends System.Delegate
+{
+  .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ret }
+}
+.class public sealed System.Func`1<T> extends System.MulticastDelegate
+{
+  .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ret }
+  .method public hidebysig instance !T Invoke() { ldnull throw }
+}
+.class public abstract System.Linq.Expressions.Expression extends System.Object
+{
+  .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ret }
+}
+.class public abstract System.Linq.Expressions.LambdaExpression extends System.Linq.Expressions.Expression
+{
+  .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ret }
+}
+.class public sealed System.Linq.Expressions.Expression`1<T> extends System.Object
+{
+  .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ret }
+}";
+            return CompileIL(sourceA, prependDefaultHeader: false, autoInherit: false);
+        }
+
+        [Fact]
+        public void SystemLinqExpressionsExpression_NotDerivedType_01()
+        {
+            var refA = GetCorlibWithExpressionOfTNotDerivedType();
+
+            var sourceB =
+@"class Program
+{
+    static void Main()
+    {
+        System.Linq.Expressions.Expression e = () => 1;
+    }
+}";
+
+            var comp = CreateEmptyCompilation(sourceB, new[] { refA });
+            comp.VerifyDiagnostics(
+                // (5,48): error CS1660: Cannot convert lambda expression to type 'Expression' because it is not a delegate type
+                //         System.Linq.Expressions.Expression e = () => 1;
+                Diagnostic(ErrorCode.ERR_AnonMethToNonDel, "() => 1").WithArguments("lambda expression", "System.Linq.Expressions.Expression").WithLocation(5, 48));
+        }
+
+        [Fact]
+        public void SystemLinqExpressionsExpression_NotDerivedType_02()
+        {
+            var refA = GetCorlibWithExpressionOfTNotDerivedType();
+
+            var sourceB =
+@"class Program
+{
+    static T F<T>(T t) where T : System.Linq.Expressions.Expression => t;
+    static void Main()
+    {
+        var e = F(() => 1);
+    }
+}";
+
+            var comp = CreateEmptyCompilation(sourceB, new[] { refA });
+            comp.VerifyDiagnostics(
+                // (6,17): error CS0311: The type 'System.Linq.Expressions.Expression<System.Func<int>>' cannot be used as type parameter 'T' in the generic type or method 'Program.F<T>(T)'. There is no implicit reference conversion from 'System.Linq.Expressions.Expression<System.Func<int>>' to 'System.Linq.Expressions.Expression'.
+                //         var e = F(() => 1);
+                Diagnostic(ErrorCode.ERR_GenericConstraintNotSatisfiedRefType, "F").WithArguments("Program.F<T>(T)", "System.Linq.Expressions.Expression", "T", "System.Linq.Expressions.Expression<System.Func<int>>").WithLocation(6, 17));
+        }
+
         [WorkItem(4674, "https://github.com/dotnet/csharplang/issues/4674")]
         [Fact]
         public void OverloadResolution_01()
@@ -1758,9 +2333,10 @@ static void Main()
     }
 }";
 
-            var expectedOutput = @"M(Action<string> a)";
-            CompileAndVerify(source, parseOptions: TestOptions.Regular9, expectedOutput: expectedOutput);
-            CompileAndVerify(source, parseOptions: TestOptions.RegularPreview, expectedOutput: expectedOutput);
+            CompileAndVerify(source, parseOptions: TestOptions.Regular9, expectedOutput: "M(Action<string> a)");
+
+            // Breaking change from C#9 which binds to M(Action<string> a).
+            CompileAndVerify(source, parseOptions: TestOptions.RegularPreview, expectedOutput: "M<T>(T t)");
         }
 
         [WorkItem(4674, "https://github.com/dotnet/csharplang/issues/4674")]
@@ -1787,12 +2363,16 @@ static class E
     public static void M(this object x, Action y) { Console.WriteLine(""E.M(object x, Action y)""); }
 }";
 
-            var expectedOutput =
+            CompileAndVerify(source, parseOptions: TestOptions.Regular9, expectedOutput:
 @"E.M(object x, Action y)
 E.M(object x, Action y)
-";
-            CompileAndVerify(source, parseOptions: TestOptions.Regular9, expectedOutput: expectedOutput);
-            CompileAndVerify(source, parseOptions: TestOptions.RegularPreview, expectedOutput: expectedOutput);
+");
+
+            // Breaking change from C#9 which binds to E.M(object x, Action y).
+            CompileAndVerify(source, parseOptions: TestOptions.RegularPreview, expectedOutput:
+@"C.M(object y)
+C.M(object y)
+");
         }
 
         [WorkItem(4674, "https://github.com/dotnet/csharplang/issues/4674")]
@@ -1930,209 +2510,2015 @@ static void Main()
         }
 
         [Fact]
-        public void OverloadResolution_06()
+        public void OverloadResolution_06()
+        {
+            var source =
+@"using System;
+using System.Linq.Expressions;
+class Program
+{
+    static void Report(string name, Expression e) { Console.WriteLine(""{0}: {1}"", name, e); }
+    static void F(Expression e) { Report(""F(Expression)"", e); }
+    static void F(Expression<Func<int>> e) { Report(""F(Expression<Func<int>>)"", e); }
+    static void Main()
+    {
+        F(() => 0);
+        F(() => string.Empty);
+    }
+}";
+
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
+            comp.VerifyDiagnostics(
+                // (11,17): error CS0029: Cannot implicitly convert type 'string' to 'int'
+                //         F(() => string.Empty);
+                Diagnostic(ErrorCode.ERR_NoImplicitConv, "string.Empty").WithArguments("string", "int").WithLocation(11, 17),
+                // (11,17): error CS1662: Cannot convert lambda expression to intended delegate type because some of the return types in the block are not implicitly convertible to the delegate return type
+                //         F(() => string.Empty);
+                Diagnostic(ErrorCode.ERR_CantConvAnonMethReturns, "string.Empty").WithArguments("lambda expression").WithLocation(11, 17));
+
+            CompileAndVerify(source, parseOptions: TestOptions.Regular10, expectedOutput:
+@"F(Expression<Func<int>>): () => 0
+F(Expression): () => String.Empty
+");
+        }
+
+        [Fact]
+        public void OverloadResolution_07()
+        {
+            var source =
+@"using System;
+using System.Linq.Expressions;
+class Program
+{
+    static void F(Expression e) { }
+    static void F(Expression<Func<int>> e) { }
+    static void Main()
+    {
+        F(delegate () { return 0; });
+        F(delegate () { return string.Empty; });
+    }
+}";
+
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
+            comp.VerifyDiagnostics(
+                // (9,11): error CS1660: Cannot convert anonymous method to type 'Expression' because it is not a delegate type
+                //         F(delegate () { return 0; });
+                Diagnostic(ErrorCode.ERR_AnonMethToNonDel, "delegate () { return 0; }").WithArguments("anonymous method", "System.Linq.Expressions.Expression").WithLocation(9, 11),
+                // (10,11): error CS1660: Cannot convert anonymous method to type 'Expression' because it is not a delegate type
+                //         F(delegate () { return string.Empty; });
+                Diagnostic(ErrorCode.ERR_AnonMethToNonDel, "delegate () { return string.Empty; }").WithArguments("anonymous method", "System.Linq.Expressions.Expression").WithLocation(10, 11));
+
+            comp = CreateCompilation(source, parseOptions: TestOptions.Regular10);
+            comp.VerifyDiagnostics(
+                // (9,11): error CS1946: An anonymous method expression cannot be converted to an expression tree
+                //         F(delegate () { return 0; });
+                Diagnostic(ErrorCode.ERR_AnonymousMethodToExpressionTree, "delegate () { return 0; }").WithLocation(9, 11),
+                // (10,11): error CS1946: An anonymous method expression cannot be converted to an expression tree
+                //         F(delegate () { return string.Empty; });
+                Diagnostic(ErrorCode.ERR_AnonymousMethodToExpressionTree, "delegate () { return string.Empty; }").WithLocation(10, 11));
+        }
+
+        [WorkItem(55319, "https://github.com/dotnet/roslyn/issues/55319")]
+        [Fact]
+        public void OverloadResolution_08()
+        {
+            var source =
+@"using System;
+using static System.Console;
+class C
+{
+    static void Main()
+    {
+        var c = new C();
+        c.F(x => x);
+        c.F((int x) => x);
+    }
+    void F(Delegate d) => Write(""instance, "");
+}
+static class Extensions
+{
+    public static void F(this C c, Func<int, int> f) => Write(""extension, "");
+}";
+
+            CompileAndVerify(source, parseOptions: TestOptions.Regular9, expectedOutput: "extension, extension, ");
+            CompileAndVerify(source, parseOptions: TestOptions.Regular10, expectedOutput: "extension, instance, ");
+            CompileAndVerify(source, expectedOutput: "extension, instance, ");
+        }
+
+        [WorkItem(55319, "https://github.com/dotnet/roslyn/issues/55319")]
+        [Fact]
+        public void OverloadResolution_09()
+        {
+            var source =
+@"using System;
+using System.Linq.Expressions;
+using static System.Console;
+class C
+{
+    static void Main()
+    {
+        var c = new C();
+        c.F(x => x);
+        c.F((int x) => x);
+    }
+    void F(Expression e) => Write(""instance, "");
+}
+static class Extensions
+{
+    public static void F(this C c, Expression<Func<int, int>> e) => Write(""extension, "");
+}";
+
+            CompileAndVerify(source, parseOptions: TestOptions.Regular9, expectedOutput: "extension, extension, ");
+            CompileAndVerify(source, parseOptions: TestOptions.Regular10, expectedOutput: "extension, instance, ");
+            CompileAndVerify(source, expectedOutput: "extension, instance, ");
+        }
+
+        [WorkItem(55319, "https://github.com/dotnet/roslyn/issues/55319")]
+        [Fact]
+        public void OverloadResolution_10()
+        {
+            var source =
+@"using System;
+using static System.Console;
+class C
+{
+    static object M1(object o) => o;
+    static int M1(int i) => i;
+    static int M2(int i) => i;
+    static void Main()
+    {
+        var c = new C();
+        c.F(M1);
+        c.F(M2);
+    }
+    void F(Delegate d) => Write(""instance, "");
+}
+static class Extensions
+{
+    public static void F(this C c, Func<int, int> f) => Write(""extension, "");
+}";
+
+            CompileAndVerify(source, parseOptions: TestOptions.Regular9, expectedOutput: "extension, extension, ");
+            CompileAndVerify(source, parseOptions: TestOptions.Regular10, expectedOutput: "extension, instance, ");
+            CompileAndVerify(source, expectedOutput: "extension, instance, ");
+        }
+
+        [Fact]
+        public void OverloadResolution_11()
+        {
+            var source =
+@"using System;
+using System.Linq.Expressions;
+class C
+{
+    static object M1(object o) => o;
+    static int M1(int i) => i;
+    static void Main()
+    {
+        F1(x => x);
+        F1(M1);
+        F2(x => x);
+    }
+    static void F1(Delegate d) { }
+    static void F2(Expression e) { }
+}";
+
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
+            comp.VerifyDiagnostics(
+                // (9,12): error CS1660: Cannot convert lambda expression to type 'Delegate' because it is not a delegate type
+                //         F1(x => x);
+                Diagnostic(ErrorCode.ERR_AnonMethToNonDel, "x => x").WithArguments("lambda expression", "System.Delegate").WithLocation(9, 12),
+                // (10,12): error CS1503: Argument 1: cannot convert from 'method group' to 'Delegate'
+                //         F1(M1);
+                Diagnostic(ErrorCode.ERR_BadArgType, "M1").WithArguments("1", "method group", "System.Delegate").WithLocation(10, 12),
+                // (11,12): error CS1660: Cannot convert lambda expression to type 'Expression' because it is not a delegate type
+                //         F2(x => x);
+                Diagnostic(ErrorCode.ERR_AnonMethToNonDel, "x => x").WithArguments("lambda expression", "System.Linq.Expressions.Expression").WithLocation(11, 12));
+
+            var expectedDiagnostics10AndLater = new[]
+            {
+                // (9,12): error CS8917: The delegate type could not be inferred.
+                //         F1(x => x);
+                Diagnostic(ErrorCode.ERR_CannotInferDelegateType, "x => x").WithLocation(9, 12),
+                // (10,12): error CS1503: Argument 1: cannot convert from 'method group' to 'Delegate'
+                //         F1(M1);
+                Diagnostic(ErrorCode.ERR_BadArgType, "M1").WithArguments("1", "method group", "System.Delegate").WithLocation(10, 12),
+                // (11,12): error CS8917: The delegate type could not be inferred.
+                //         F2(x => x);
+                Diagnostic(ErrorCode.ERR_CannotInferDelegateType, "x => x").WithLocation(11, 12)
+            };
+
+            comp = CreateCompilation(source, parseOptions: TestOptions.Regular10);
+            comp.VerifyDiagnostics(expectedDiagnostics10AndLater);
+
+            comp = CreateCompilation(source);
+            comp.VerifyDiagnostics(expectedDiagnostics10AndLater);
+        }
+
+        [WorkItem(55691, "https://github.com/dotnet/roslyn/issues/55691")]
+        [Fact]
+        public void OverloadResolution_12()
+        {
+            var source =
+@"using System;
+#nullable enable
+var app = new WebApp();
+app.Map(""/sub1"", builder =>
+{
+    builder.UseAuth();
+});
+app.Map(""/sub2"", (IAppBuilder builder) =>
+{
+    builder.UseAuth();
+});
+class WebApp : IAppBuilder, IRouteBuilder
+{
+    public void UseAuth() { }
+}
+interface IAppBuilder
+{
+    void UseAuth();
+}
+interface IRouteBuilder
+{
+}
+static class AppBuilderExtensions
+{
+    public static IAppBuilder Map(this IAppBuilder app, PathSring path, Action<IAppBuilder> callback) => app;
+}
+static class RouteBuilderExtensions
+{
+    public static IRouteBuilder Map(this IRouteBuilder routes, string path, Delegate callback) => routes;
+}
+struct PathSring
+{
+    public PathSring(string? path)
+    {
+        Path = path;
+    }
+    public string? Path { get; }
+    public static implicit operator PathSring(string? s) => new PathSring(s);
+    public static implicit operator string?(PathSring path) => path.Path;
+}";
+
+            CompileAndVerify(source, parseOptions: TestOptions.Regular9);
+
+            // Breaking change from C#9.
+            var expectedDiagnostics10AndLater = new[]
+            {
+                 // (8,5): error CS0121: The call is ambiguous between the following methods or properties: 'AppBuilderExtensions.Map(IAppBuilder, PathSring, Action<IAppBuilder>)' and 'RouteBuilderExtensions.Map(IRouteBuilder, string, Delegate)'
+                // app.Map("/sub2", (IAppBuilder builder) =>
+                Diagnostic(ErrorCode.ERR_AmbigCall, "Map").WithArguments("AppBuilderExtensions.Map(IAppBuilder, PathSring, System.Action<IAppBuilder>)", "RouteBuilderExtensions.Map(IRouteBuilder, string, System.Delegate)").WithLocation(8, 5)
+            };
+
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular10);
+            comp.VerifyDiagnostics(expectedDiagnostics10AndLater);
+
+            comp = CreateCompilation(source);
+            comp.VerifyDiagnostics(expectedDiagnostics10AndLater);
+        }
+
+        [WorkItem(55691, "https://github.com/dotnet/roslyn/issues/55691")]
+        [Fact]
+        public void OverloadResolution_13()
+        {
+            var source =
+@"using System;
+class Program
+{
+    static void Main()
+    {
+        F(1, () => { });
+        F(2, Main);
+    }
+    static void F(object obj, Action a) { }
+    static void F(int i, Delegate d) { }
+}";
+
+            CompileAndVerify(source, parseOptions: TestOptions.Regular9);
+
+            // Breaking change from C#9.
+            var expectedDiagnostics10AndLater = new[]
+            {
+                // (6,9): error CS0121: The call is ambiguous between the following methods or properties: 'Program.F(object, Action)' and 'Program.F(int, Delegate)'
+                //         F(1, () => { });
+                Diagnostic(ErrorCode.ERR_AmbigCall, "F").WithArguments("Program.F(object, System.Action)", "Program.F(int, System.Delegate)").WithLocation(6, 9),
+                // (7,9): error CS0121: The call is ambiguous between the following methods or properties: 'Program.F(object, Action)' and 'Program.F(int, Delegate)'
+                //         F(2, Main);
+                Diagnostic(ErrorCode.ERR_AmbigCall, "F").WithArguments("Program.F(object, System.Action)", "Program.F(int, System.Delegate)").WithLocation(7, 9)
+            };
+
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular10);
+            comp.VerifyDiagnostics(expectedDiagnostics10AndLater);
+
+            comp = CreateCompilation(source);
+            comp.VerifyDiagnostics(expectedDiagnostics10AndLater);
+        }
+
+        [WorkItem(55691, "https://github.com/dotnet/roslyn/issues/55691")]
+        [Fact]
+        public void OverloadResolution_14()
+        {
+            var source =
+@"using System;
+using System.Linq.Expressions;
+class Program
+{
+    static void Main()
+    {
+        F(() => 1, 2);
+    }
+    static void F(Expression<Func<object>> f, object obj) { }
+    static void F(Expression e, int i) { }
+}";
+
+            CompileAndVerify(source, parseOptions: TestOptions.Regular9);
+
+            // Breaking change from C#9.
+            var expectedDiagnostics10AndLater = new[]
+            {
+                // (7,9): error CS0121: The call is ambiguous between the following methods or properties: 'Program.F(Expression<Func<object>>, object)' and 'Program.F(Expression, int)'
+                //         F(() => 1, 2);
+                Diagnostic(ErrorCode.ERR_AmbigCall, "F").WithArguments("Program.F(System.Linq.Expressions.Expression<System.Func<object>>, object)", "Program.F(System.Linq.Expressions.Expression, int)").WithLocation(7, 9)
+            };
+
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular10);
+            comp.VerifyDiagnostics(expectedDiagnostics10AndLater);
+
+            comp = CreateCompilation(source);
+            comp.VerifyDiagnostics(expectedDiagnostics10AndLater);
+        }
+
+        [WorkItem(4674, "https://github.com/dotnet/csharplang/issues/4674")]
+        [Fact]
+        public void OverloadResolution_15()
+        {
+            var source =
+@"delegate void StringAction(string arg);
+class Program
+{
+    static void F<T>(T t) { }
+    static void F(StringAction a) { }
+    static void M(string arg) { }
+    static void Main()
+    {
+        F((string s) => { }); // C#9: F(StringAction)
+        F(M); // C#9: F(StringAction)
+    }
+}";
+
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
+            comp.VerifyDiagnostics();
+
+            // Breaking change from C#9 which binds calls to F(StringAction).
+            comp = CreateCompilation(source);
+            comp.VerifyDiagnostics(
+                // (9,9): error CS0121: The call is ambiguous between the following methods or properties: 'Program.F<T>(T)' and 'Program.F(StringAction)'
+                //         F((string s) => { }); // C#9: F(StringAction)
+                Diagnostic(ErrorCode.ERR_AmbigCall, "F").WithArguments("Program.F<T>(T)", "Program.F(StringAction)").WithLocation(9, 9),
+                // (10,9): error CS0121: The call is ambiguous between the following methods or properties: 'Program.F<T>(T)' and 'Program.F(StringAction)'
+                //         F(M); // C#9: F(StringAction)
+                Diagnostic(ErrorCode.ERR_AmbigCall, "F").WithArguments("Program.F<T>(T)", "Program.F(StringAction)").WithLocation(10, 9));
+        }
+
+        [Fact]
+        public void OverloadResolution_16()
+        {
+            var source =
+@"using System;
+class Program
+{
+    static void F(Func<Func<object>> f, int i) => Report(f);
+    static void F(Func<Func<int>> f, object o) => Report(f);
+    static void Main()
+    {
+        F(() => () => 1, 2);
+    }
+    static void Report(Delegate d) => Console.WriteLine(d.GetType());
+}";
+
+            CompileAndVerify(source, parseOptions: TestOptions.Regular9, expectedOutput:
+@"System.Func`1[System.Func`1[System.Object]]");
+
+            // Breaking change from C#9 which binds calls to F(Func<Func<object>>, int).
+            var comp = CreateCompilation(source);
+            comp.VerifyDiagnostics(
+                // (8,9): error CS0121: The call is ambiguous between the following methods or properties: 'Program.F(Func<Func<object>>, int)' and 'Program.F(Func<Func<int>>, object)'
+                //         F(() => () => 1, 2); // C#9: F(Func<Func<object>>, int)
+                Diagnostic(ErrorCode.ERR_AmbigCall, "F").WithArguments("Program.F(System.Func<System.Func<object>>, int)", "Program.F(System.Func<System.Func<int>>, object)").WithLocation(8, 9));
+        }
+
+        [Fact]
+        public void OverloadResolution_17()
+        {
+            var source =
+@"delegate void StringAction(string arg);
+class Program
+{
+    static void F<T>(System.Action<T> a) { }
+    static void F(StringAction a) { }
+    static void Main()
+    {
+        F((string s) => { });
+    }
+}";
+            var comp = CreateCompilation(source);
+            comp.VerifyDiagnostics(
+                // (8,9): error CS0121: The call is ambiguous between the following methods or properties: 'Program.F<T>(Action<T>)' and 'Program.F(StringAction)'
+                //         F((string s) => { });
+                Diagnostic(ErrorCode.ERR_AmbigCall, "F").WithArguments("Program.F<T>(System.Action<T>)", "Program.F(StringAction)").WithLocation(8, 9));
+        }
+
+        [Fact]
+        public void OverloadResolution_18()
+        {
+            var source =
+@"delegate void StringAction(string arg);
+class Program
+{
+    static void F0<T>(System.Action<T> a) { }
+    static void F1<T>(System.Action<T> a) { }
+    static void F1(StringAction a) { }
+    static void M(string arg) { }
+    static void Main()
+    {
+        F0(M);
+        F1(M);
+    }
+}";
+            var comp = CreateCompilation(source);
+            comp.VerifyDiagnostics(
+                // (10,9): error CS0411: The type arguments for method 'Program.F0<T>(Action<T>)' cannot be inferred from the usage. Try specifying the type arguments explicitly.
+                //         F0(M);
+                Diagnostic(ErrorCode.ERR_CantInferMethTypeArgs, "F0").WithArguments("Program.F0<T>(System.Action<T>)").WithLocation(10, 9));
+        }
+
+        [Fact]
+        public void OverloadResolution_19()
+        {
+            var source =
+@"delegate void MyAction<T>(T arg);
+class Program
+{
+    static void F<T>(System.Action<T> a) { }
+    static void F<T>(MyAction<T> a) { }
+    static void M(string arg) { }
+    static void Main()
+    {
+        F((string s) => { });
+        F(M);
+    }
+}";
+            var comp = CreateCompilation(source);
+            comp.VerifyDiagnostics(
+                // (9,9): error CS0121: The call is ambiguous between the following methods or properties: 'Program.F<T>(Action<T>)' and 'Program.F<T>(MyAction<T>)'
+                //         F((string s) => { });
+                Diagnostic(ErrorCode.ERR_AmbigCall, "F").WithArguments("Program.F<T>(System.Action<T>)", "Program.F<T>(MyAction<T>)").WithLocation(9, 9),
+                // (10,9): error CS0411: The type arguments for method 'Program.F<T>(Action<T>)' cannot be inferred from the usage. Try specifying the type arguments explicitly.
+                //         F(M);
+                Diagnostic(ErrorCode.ERR_CantInferMethTypeArgs, "F").WithArguments("Program.F<T>(System.Action<T>)").WithLocation(10, 9));
+        }
+
+        [Fact]
+        public void OverloadResolution_20()
+        {
+            var source =
+@"using System;
+delegate void StringAction(string s);
+class Program
+{
+    static void F(Action<string> a) { }
+    static void F(StringAction a) { }
+    static void M(string s) { }
+    static void Main()
+    {
+        F(M);
+        F((string s) => { });
+    }
+}";
+            var comp = CreateCompilation(source);
+            comp.VerifyDiagnostics(
+                // (10,9): error CS0121: The call is ambiguous between the following methods or properties: 'Program.F(Action<string>)' and 'Program.F(StringAction)'
+                //         F(M);
+                Diagnostic(ErrorCode.ERR_AmbigCall, "F").WithArguments("Program.F(System.Action<string>)", "Program.F(StringAction)").WithLocation(10, 9),
+                // (11,9): error CS0121: The call is ambiguous between the following methods or properties: 'Program.F(Action<string>)' and 'Program.F(StringAction)'
+                //         F((string s) => { });
+                Diagnostic(ErrorCode.ERR_AmbigCall, "F").WithArguments("Program.F(System.Action<string>)", "Program.F(StringAction)").WithLocation(11, 9));
+        }
+
+        [Fact]
+        public void OverloadResolution_21()
+        {
+            var source =
+@"using System;
+class C<T>
+{
+    public void F(Delegate d) => Report(""F(Delegate d)"", d);
+    public void F(T t) => Report(""F(T t)"", t);
+    public void F(Func<T> f) => Report(""F(Func<T> f)"", f);
+    static void Report(string method, object arg) => Console.WriteLine(""{0}, {1}"", method, arg.GetType());
+}
+class Program
+{
+    static void Main()
+    {
+        var c = new C<Delegate>();
+        c.F(() => (Action)null);
+    }
+}";
+
+            string expectedOutput = "F(Func<T> f), System.Func`1[System.Delegate]";
+            CompileAndVerify(source, parseOptions: TestOptions.Regular9, expectedOutput: expectedOutput);
+            CompileAndVerify(source, parseOptions: TestOptions.Regular10, expectedOutput: expectedOutput);
+            CompileAndVerify(source, expectedOutput: expectedOutput);
+        }
+
+        [WorkItem(1361172, "https://devdiv.visualstudio.com/DevDiv/_workitems/edit/1361172")]
+        [Fact]
+        public void OverloadResolution_22()
+        {
+            var source =
+@"using System;
+using System.Linq.Expressions;
+class C<T>
+{
+    public void F(Delegate d) => Report(""F(Delegate d)"", d);
+    public void F(T t) => Report(""F(T t)"", t);
+    public void F(Func<T> f) => Report(""F(Func<T> f)"", f);
+    static void Report(string method, object arg) => Console.WriteLine(""{0}, {1}"", method, arg.GetType());
+}
+class Program
+{
+    static void Main()
+    {
+        var c = new C<Expression>();
+        c.F(() => Expression.Constant(1));
+    }
+}";
+
+            string expectedOutput = "F(Func<T> f), System.Func`1[System.Linq.Expressions.Expression]";
+            CompileAndVerify(source, parseOptions: TestOptions.Regular9, expectedOutput: expectedOutput);
+
+            // Breaking change from C#9.
+            var expectedDiagnostics10AndLater = new[]
+            {
+                // (15,11): error CS0121: The call is ambiguous between the following methods or properties: 'C<T>.F(T)' and 'C<T>.F(Func<T>)'
+                //         c.F(() => Expression.Constant(1));
+                Diagnostic(ErrorCode.ERR_AmbigCall, "F").WithArguments("C<T>.F(T)", "C<T>.F(System.Func<T>)").WithLocation(15, 11)
+            };
+
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular10);
+            comp.VerifyDiagnostics(expectedDiagnostics10AndLater);
+
+            comp = CreateCompilation(source);
+            comp.VerifyDiagnostics(expectedDiagnostics10AndLater);
+        }
+
+        [Fact]
+        public void OverloadResolution_23()
+        {
+            var source =
+@"using System;
+class Program
+{
+    static void F(Delegate d) => Console.WriteLine(""F(Delegate d)"");
+    static void F(Func<object> f) => Console.WriteLine(""F(Func<int> f)"");
+    static void Main()
+    {
+        F(() => 1);
+    }
+}";
+
+            string expectedOutput = "F(Func<int> f)";
+            CompileAndVerify(source, parseOptions: TestOptions.Regular9, expectedOutput: expectedOutput);
+            CompileAndVerify(source, parseOptions: TestOptions.Regular10, expectedOutput: expectedOutput);
+            CompileAndVerify(source, expectedOutput: expectedOutput);
+        }
+
+        [Fact]
+        public void OverloadResolution_24()
+        {
+            var source =
+@"using System;
+using System.Linq.Expressions;
+class Program
+{
+    static void F(Expression e) => Console.WriteLine(""F(Expression e)"");
+    static void F(Func<Expression> f) => Console.WriteLine(""F(Func<Expression> f)"");
+    static void Main()
+    {
+        F(() => Expression.Constant(1));
+    }
+}";
+
+            string expectedOutput = "F(Func<Expression> f)";
+            CompileAndVerify(source, parseOptions: TestOptions.Regular9, expectedOutput: expectedOutput);
+
+            // Breaking change from C#9.
+            var expectedDiagnostics10AndLater = new[]
+            {
+                // (9,9): error CS0121: The call is ambiguous between the following methods or properties: 'Program.F(Expression)' and 'Program.F(Func<Expression>)'
+                //         F(() => Expression.Constant(1));
+                Diagnostic(ErrorCode.ERR_AmbigCall, "F").WithArguments("Program.F(System.Linq.Expressions.Expression)", "Program.F(System.Func<System.Linq.Expressions.Expression>)").WithLocation(9, 9)
+            };
+
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular10);
+            comp.VerifyDiagnostics(expectedDiagnostics10AndLater);
+
+            comp = CreateCompilation(source);
+            comp.VerifyDiagnostics(expectedDiagnostics10AndLater);
+        }
+
+        [Fact]
+        public void BestCommonType_01()
+        {
+            var source =
+@"using System;
+delegate int StringIntDelegate(string s);
+class Program
+{
+    static int M(string s) => s.Length;
+    static void Main()
+    {
+        StringIntDelegate d = M;
+        var a1 = new[] { d, (string s) => int.Parse(s) };
+        var a2 = new[] { (string s) => int.Parse(s), d };
+        Report(a1[1]);
+        Report(a2[0]);
+    }
+    static void Report(object obj) => Console.WriteLine(obj.GetType());
+}";
+            string expectedOutput =
+@"StringIntDelegate
+StringIntDelegate";
+            CompileAndVerify(source, parseOptions: TestOptions.Regular9, options: TestOptions.ReleaseExe, expectedOutput: expectedOutput);
+            CompileAndVerify(source, options: TestOptions.ReleaseExe, expectedOutput: expectedOutput);
+        }
+
+        [Fact]
+        public void BestCommonType_02()
+        {
+            var source =
+@"using System;
+delegate int StringIntDelegate(string s);
+class Program
+{
+    static int M(string s) => s.Length;
+    static void F(bool  b)
+    {
+        StringIntDelegate d = M;
+        var c1 = b ? d : ((string s) => int.Parse(s));
+        var c2 = b ? ((string s) => int.Parse(s)) : d;
+        Report(c1);
+        Report(c2);
+    }
+    static void Main()
+    {
+        F(false);
+    }
+    static void Report(object obj) => Console.WriteLine(obj.GetType());
+}";
+            string expectedOutput =
+@"StringIntDelegate
+StringIntDelegate";
+            CompileAndVerify(source, parseOptions: TestOptions.Regular9, options: TestOptions.ReleaseExe, expectedOutput: expectedOutput);
+            CompileAndVerify(source, options: TestOptions.ReleaseExe, expectedOutput: expectedOutput);
+        }
+
+        [Fact]
+        public void BestCommonType_03()
+        {
+            var source =
+@"using System;
+delegate int StringIntDelegate(string s);
+class Program
+{
+    static int M(string s) => s.Length;
+    static void Main()
+    {
+        var f1 = (bool b) => { if (b) return (StringIntDelegate)M; return ((string s) => int.Parse(s)); };
+        var f2 = (bool b) => { if (b) return ((string s) => int.Parse(s)); return (StringIntDelegate)M; };
+        Report(f1(true));
+        Report(f2(true));
+    }
+    static void Report(object obj) => Console.WriteLine(obj.GetType());
+}";
+            CompileAndVerify(source, options: TestOptions.ReleaseExe, expectedOutput:
+@"StringIntDelegate
+StringIntDelegate");
+        }
+
+        [Fact]
+        public void BestCommonType_04()
+        {
+            var source =
+@"using System;
+delegate int StringIntDelegate(string s);
+class Program
+{
+    static int M(string s) => s.Length;
+    static void Main()
+    {
+        var f1 = (bool b) => { if (b) return M; return ((string s) => int.Parse(s)); };
+        var f2 = (bool b) => { if (b) return ((string s) => int.Parse(s)); return M; };
+        Report(f1(true));
+        Report(f2(true));
+    }
+    static void Report(object obj) => Console.WriteLine(obj.GetType());
+}";
+            CompileAndVerify(source, options: TestOptions.ReleaseExe, expectedOutput:
+@"System.Func`2[System.String,System.Int32]
+System.Func`2[System.String,System.Int32]");
+        }
+
+        [Fact]
+        public void BestCommonType_05()
+        {
+            var source =
+@"using System;
+class Program
+{
+    static int M1(string s) => s.Length;
+    static int M2(string s) => int.Parse(s);
+    static void Main()
+    {
+        var a1 = new[] { M1, (string s) => int.Parse(s) };
+        var a2 = new[] { (string s) => s.Length, M2 };
+        Report(a1[1]);
+        Report(a2[1]);
+    }
+    static void Report(object obj) => Console.WriteLine(obj.GetType());
+}";
+
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
+            comp.VerifyDiagnostics(
+                // (8,18): error CS0826: No best type found for implicitly-typed array
+                //         var a1 = new[] { M1, (string s) => int.Parse(s) };
+                Diagnostic(ErrorCode.ERR_ImplicitlyTypedArrayNoBestType, "new[] { M1, (string s) => int.Parse(s) }").WithLocation(8, 18),
+                // (9,18): error CS0826: No best type found for implicitly-typed array
+                //         var a2 = new[] { (string s) => s.Length, M2 };
+                Diagnostic(ErrorCode.ERR_ImplicitlyTypedArrayNoBestType, "new[] { (string s) => s.Length, M2 }").WithLocation(9, 18));
+
+            CompileAndVerify(source, options: TestOptions.ReleaseExe, expectedOutput:
+@"System.Func`2[System.String,System.Int32]
+System.Func`2[System.String,System.Int32]");
+        }
+
+        [Fact]
+        public void BestCommonType_06()
+        {
+            var source =
+@"using System;
+class Program
+{
+    static void F1<T>(T t) { }
+    static T F2<T>() => default;
+    static void Main()
+    {
+        var a1 = new[] { F1<object>, F1<string> };
+        var a2 = new[] { F2<object>, F2<string> };
+        Report(a1[0]);
+        Report(a2[0]);
+    }
+    static void Report(object obj) => Console.WriteLine(obj.GetType());
+}";
+
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
+            comp.VerifyDiagnostics(
+                // (8,18): error CS0826: No best type found for implicitly-typed array
+                //         var a1 = new[] { F1<object>, F1<string> };
+                Diagnostic(ErrorCode.ERR_ImplicitlyTypedArrayNoBestType, "new[] { F1<object>, F1<string> }").WithLocation(8, 18),
+                // (9,18): error CS0826: No best type found for implicitly-typed array
+                //         var a2 = new[] { F2<object>, F2<string> };
+                Diagnostic(ErrorCode.ERR_ImplicitlyTypedArrayNoBestType, "new[] { F2<object>, F2<string> }").WithLocation(9, 18));
+
+            CompileAndVerify(source, options: TestOptions.ReleaseExe, expectedOutput:
+@"System.Action`1[System.String]
+System.Func`1[System.Object]");
+        }
+
+        [Fact]
+        public void BestCommonType_07()
+        {
+            var source =
+@"class Program
+{
+    static void F1<T>(T t) { }
+    static T F2<T>() => default;
+    static T F3<T>(T t) => t;
+    static void Main()
+    {
+        var a1 = new[] { F1<int>, F1<object> };
+        var a2 = new[] { F2<nint>, F2<System.IntPtr> };
+        var a3 = new[] { F3<string>, F3<object> };
+    }
+}";
+
+            var expectedDiagnostics = new[]
+            {
+                // (8,18): error CS0826: No best type found for implicitly-typed array
+                //         var a1 = new[] { F1<int>, F1<object> };
+                Diagnostic(ErrorCode.ERR_ImplicitlyTypedArrayNoBestType, "new[] { F1<int>, F1<object> }").WithLocation(8, 18),
+                // (9,18): error CS0826: No best type found for implicitly-typed array
+                //         var a2 = new[] { F2<nint>, F2<System.IntPtr> };
+                Diagnostic(ErrorCode.ERR_ImplicitlyTypedArrayNoBestType, "new[] { F2<nint>, F2<System.IntPtr> }").WithLocation(9, 18),
+                // (10,18): error CS0826: No best type found for implicitly-typed array
+                //         var a3 = new[] { F3<string>, F3<object> };
+                Diagnostic(ErrorCode.ERR_ImplicitlyTypedArrayNoBestType, "new[] { F3<string>, F3<object> }").WithLocation(10, 18)
+            };
+
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
+            comp.VerifyDiagnostics(expectedDiagnostics);
+
+            comp = CreateCompilation(source);
+            comp.VerifyDiagnostics(expectedDiagnostics);
+        }
+
+        [Fact]
+        public void BestCommonType_08()
+        {
+            var source =
+@"#nullable enable
+using System;
+class Program
+{
+    static void F<T>(T t) { }
+    static void Main()
+    {
+        var a1 = new[] { F<string?>, F<string> };
+        var a2 = new[] { F<(int X, object Y)>, F<(int, dynamic)> };
+        Report(a1[0]);
+        Report(a2[0]);
+    }
+    static void Report(object obj) => Console.WriteLine(obj.GetType());
+}";
+
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
+            comp.VerifyDiagnostics(
+                // (8,18): error CS0826: No best type found for implicitly-typed array
+                //         var a1 = new[] { F<string?>, F<string> };
+                Diagnostic(ErrorCode.ERR_ImplicitlyTypedArrayNoBestType, "new[] { F<string?>, F<string> }").WithLocation(8, 18),
+                // (9,18): error CS0826: No best type found for implicitly-typed array
+                //         var a2 = new[] { F<(int X, object Y)>, F<(int, dynamic)> };
+                Diagnostic(ErrorCode.ERR_ImplicitlyTypedArrayNoBestType, "new[] { F<(int X, object Y)>, F<(int, dynamic)> }").WithLocation(9, 18));
+
+            CompileAndVerify(source, options: TestOptions.ReleaseExe, expectedOutput:
+@"System.Action`1[System.String]
+System.Action`1[System.ValueTuple`2[System.Int32,System.Object]]");
+        }
+
+        [Fact]
+        public void BestCommonType_09()
+        {
+            var source =
+@"using System;
+class Program
+{
+    static void Main()
+    {
+        var a1 = new[] { (object o) => { }, (string s) => { } };
+        var a2 = new[] { () => (object)null, () => (string)null };
+        Report(a1[0]);
+        Report(a2[0]);
+    }
+    static void Report(object obj) => Console.WriteLine(obj.GetType());
+}";
+
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
+            comp.VerifyDiagnostics(
+                // (6,18): error CS0826: No best type found for implicitly-typed array
+                //         var a1 = new[] { (object o) => { }, (string s) => { } };
+                Diagnostic(ErrorCode.ERR_ImplicitlyTypedArrayNoBestType, "new[] { (object o) => { }, (string s) => { } }").WithLocation(6, 18),
+                // (7,18): error CS0826: No best type found for implicitly-typed array
+                //         var a2 = new[] { () => (object)null, () => (string)null };
+                Diagnostic(ErrorCode.ERR_ImplicitlyTypedArrayNoBestType, "new[] { () => (object)null, () => (string)null }").WithLocation(7, 18));
+
+            comp = CreateCompilation(source);
+            comp.VerifyDiagnostics(
+                // (6,26): error CS1661: Cannot convert lambda expression to type 'Action<string>' because the parameter types do not match the delegate parameter types
+                //         var a1 = new[] { (object o) => { }, (string s) => { } };
+                Diagnostic(ErrorCode.ERR_CantConvAnonMethParams, "(object o) => { }").WithArguments("lambda expression", "System.Action<string>").WithLocation(6, 26),
+                // (6,34): error CS1678: Parameter 1 is declared as type 'object' but should be 'string'
+                //         var a1 = new[] { (object o) => { }, (string s) => { } };
+                Diagnostic(ErrorCode.ERR_BadParamType, "o").WithArguments("1", "", "object", "", "string").WithLocation(6, 34));
+        }
+
+        [Fact]
+        public void BestCommonType_10()
+        {
+            var source =
+@"using System;
+class Program
+{
+    static void F1<T>(T t, ref object o) { }
+    static void F2<T, U>(ref T t, U u) { }
+    static void Main()
+    {
+        var a1 = new[] { F1<string>, F1<string> };
+        var a2 = new[] { F2<object, string>, F2<object, string> };
+        Report(a1[0]);
+        Report(a2[0]);
+    }
+    static void Report(object obj) => Console.WriteLine(obj.GetType());
+}";
+
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
+            comp.VerifyDiagnostics(
+                // (8,18): error CS0826: No best type found for implicitly-typed array
+                //         var a1 = new[] { F1<string>, F1<string> };
+                Diagnostic(ErrorCode.ERR_ImplicitlyTypedArrayNoBestType, "new[] { F1<string>, F1<string> }").WithLocation(8, 18),
+                // (9,18): error CS0826: No best type found for implicitly-typed array
+                //         var a2 = new[] { F2<object, string>, F2<object, string> };
+                Diagnostic(ErrorCode.ERR_ImplicitlyTypedArrayNoBestType, "new[] { F2<object, string>, F2<object, string> }").WithLocation(9, 18));
+
+            CompileAndVerify(source, options: TestOptions.ReleaseExe, expectedOutput:
+@"<>A{00000004}`2[System.String,System.Object]
+<>A{00000001}`2[System.Object,System.String]");
+        }
+
+        [Fact]
+        [WorkItem(55909, "https://github.com/dotnet/roslyn/issues/55909")]
+        public void BestCommonType_11()
+        {
+            var source =
+@"using System;
+class Program
+{
+    static void F1<T>(T t, ref object o) { }
+    static void F2<T, U>(ref T t, U u) { }
+    static void Main()
+    {
+        var a1 = new[] { F1<object>, F1<string> };
+        var a2 = new[] { F2<object, string>, F2<object, object> };
+        Report(a1[0]);
+        Report(a2[0]);
+    }
+    static void Report(object obj) => Console.WriteLine(obj.GetType());
+}";
+
+            var expectedDiagnostics = new[]
+            {
+                // (8,18): error CS0826: No best type found for implicitly-typed array
+                //         var a1 = new[] { F1<object>, F1<string> };
+                Diagnostic(ErrorCode.ERR_ImplicitlyTypedArrayNoBestType, "new[] { F1<object>, F1<string> }").WithLocation(8, 18),
+                // (9,18): error CS0826: No best type found for implicitly-typed array
+                //         var a2 = new[] { F2<object, string>, F2<object, object> };
+                Diagnostic(ErrorCode.ERR_ImplicitlyTypedArrayNoBestType, "new[] { F2<object, string>, F2<object, object> }").WithLocation(9, 18)
+            };
+
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
+            comp.VerifyDiagnostics(expectedDiagnostics);
+
+            // https://github.com/dotnet/roslyn/issues/55909: ConversionsBase.HasImplicitSignatureConversion()
+            // relies on the variance of FunctionTypeSymbol.GetInternalDelegateType() which fails for synthesized
+            // delegate types where the type parameters are invariant.
+            comp = CreateCompilation(source);
+            comp.VerifyDiagnostics(expectedDiagnostics);
+        }
+
+        [Fact]
+        public void BestCommonType_12()
+        {
+            var source =
+@"class Program
+{
+    static void F<T>(ref T t) { }
+    static void Main()
+    {
+        var a1 = new[] { F<object>, F<string> };
+        var a2 = new[] { (object x, ref object y) => { }, (string x, ref object y) => { } };
+        var a3 = new[] { (object x, ref object y) => { }, (object x, ref string y) => { } };
+    }
+}";
+
+            var expectedDiagnostics = new[]
+            {
+                // (6,18): error CS0826: No best type found for implicitly-typed array
+                //         var a1 = new[] { F<object>, F<string> };
+                Diagnostic(ErrorCode.ERR_ImplicitlyTypedArrayNoBestType, "new[] { F<object>, F<string> }").WithLocation(6, 18),
+                // (7,18): error CS0826: No best type found for implicitly-typed array
+                //         var a2 = new[] { (object x, ref object y) => { }, (string x, ref object y) => { } };
+                Diagnostic(ErrorCode.ERR_ImplicitlyTypedArrayNoBestType, "new[] { (object x, ref object y) => { }, (string x, ref object y) => { } }").WithLocation(7, 18),
+                // (8,18): error CS0826: No best type found for implicitly-typed array
+                //         var a3 = new[] { (object x, ref object y) => { }, (object x, ref string y) => { } };
+                Diagnostic(ErrorCode.ERR_ImplicitlyTypedArrayNoBestType, "new[] { (object x, ref object y) => { }, (object x, ref string y) => { } }").WithLocation(8, 18)
+            };
+
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
+            comp.VerifyDiagnostics(expectedDiagnostics);
+
+            comp = CreateCompilation(source);
+            comp.VerifyDiagnostics(expectedDiagnostics);
+        }
+
+        [Fact]
+        public void BestCommonType_13()
+        {
+            var source =
+@"using System;
+class Program
+{
+    static void F<T>(ref T t) { }
+    static void Main()
+    {
+        var a1 = new[] { F<object>, null };
+        var a2 = new[] { default, F<string> };
+        var a3 = new[] { null, default, (object x, ref string y) => { } };
+        Report(a1[0]);
+        Report(a2[1]);
+        Report(a3[2]);
+    }
+    static void Report(object obj) => Console.WriteLine(obj.GetType());
+}";
+
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
+            comp.VerifyDiagnostics(
+                // (7,18): error CS0826: No best type found for implicitly-typed array
+                //         var a1 = new[] { F<object>, null };
+                Diagnostic(ErrorCode.ERR_ImplicitlyTypedArrayNoBestType, "new[] { F<object>, null }").WithLocation(7, 18),
+                // (8,18): error CS0826: No best type found for implicitly-typed array
+                //         var a2 = new[] { default, F<string> };
+                Diagnostic(ErrorCode.ERR_ImplicitlyTypedArrayNoBestType, "new[] { default, F<string> }").WithLocation(8, 18),
+                // (9,18): error CS0826: No best type found for implicitly-typed array
+                //         var a3 = new[] { null, default, (object x, ref string y) => { } };
+                Diagnostic(ErrorCode.ERR_ImplicitlyTypedArrayNoBestType, "new[] { null, default, (object x, ref string y) => { } }").WithLocation(9, 18));
+
+            CompileAndVerify(source, options: TestOptions.ReleaseExe, expectedOutput:
+@"<>A{00000001}`1[System.Object]
+<>A{00000001}`1[System.String]
+<>A{00000004}`2[System.Object,System.String]
+");
+        }
+
+        /// <summary>
+        /// Best common type inference with delegate signatures that cannot be inferred.
+        /// </summary>
+        [Fact]
+        public void BestCommonType_NoInferredSignature()
+        {
+            var source =
+@"class Program
+{
+    static void F1() { }
+    static int F1(int i) => i;
+    static void F2() { }
+    static void Main()
+    {
+        var a1 = new[] { F1 };
+        var a2 = new[] { F1, F2 };
+        var a3 = new[] { F2, F1 };
+        var a4 = new[] { x => x };
+        var a5 = new[] { x => x, (int y) => y };
+        var a6 = new[] { (int y) => y, static x => x };
+        var a7 = new[] { x => x, F1 };
+        var a8 = new[] { F1, (int y) => y };
+    }
+}";
+
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
+            comp.VerifyDiagnostics(
+                // (8,18): error CS0826: No best type found for implicitly-typed array
+                //         var a1 = new[] { F1 };
+                Diagnostic(ErrorCode.ERR_ImplicitlyTypedArrayNoBestType, "new[] { F1 }").WithLocation(8, 18),
+                // (9,18): error CS0826: No best type found for implicitly-typed array
+                //         var a2 = new[] { F1, F2 };
+                Diagnostic(ErrorCode.ERR_ImplicitlyTypedArrayNoBestType, "new[] { F1, F2 }").WithLocation(9, 18),
+                // (10,18): error CS0826: No best type found for implicitly-typed array
+                //         var a3 = new[] { F2, F1 };
+                Diagnostic(ErrorCode.ERR_ImplicitlyTypedArrayNoBestType, "new[] { F2, F1 }").WithLocation(10, 18),
+                // (11,18): error CS0826: No best type found for implicitly-typed array
+                //         var a4 = new[] { x => x };
+                Diagnostic(ErrorCode.ERR_ImplicitlyTypedArrayNoBestType, "new[] { x => x }").WithLocation(11, 18),
+                // (12,18): error CS0826: No best type found for implicitly-typed array
+                //         var a5 = new[] { x => x, (int y) => y };
+                Diagnostic(ErrorCode.ERR_ImplicitlyTypedArrayNoBestType, "new[] { x => x, (int y) => y }").WithLocation(12, 18),
+                // (13,18): error CS0826: No best type found for implicitly-typed array
+                //         var a6 = new[] { (int y) => y, static x => x };
+                Diagnostic(ErrorCode.ERR_ImplicitlyTypedArrayNoBestType, "new[] { (int y) => y, static x => x }").WithLocation(13, 18),
+                // (14,18): error CS0826: No best type found for implicitly-typed array
+                //         var a7 = new[] { x => x, F1 };
+                Diagnostic(ErrorCode.ERR_ImplicitlyTypedArrayNoBestType, "new[] { x => x, F1 }").WithLocation(14, 18),
+                // (15,18): error CS0826: No best type found for implicitly-typed array
+                //         var a8 = new[] { F1, (int y) => y };
+                Diagnostic(ErrorCode.ERR_ImplicitlyTypedArrayNoBestType, "new[] { F1, (int y) => y }").WithLocation(15, 18));
+
+            comp = CreateCompilation(source);
+            comp.VerifyDiagnostics(
+                // (8,18): error CS0826: No best type found for implicitly-typed array
+                //         var a1 = new[] { F1 };
+                Diagnostic(ErrorCode.ERR_ImplicitlyTypedArrayNoBestType, "new[] { F1 }").WithLocation(8, 18),
+                // (11,18): error CS0826: No best type found for implicitly-typed array
+                //         var a4 = new[] { x => x };
+                Diagnostic(ErrorCode.ERR_ImplicitlyTypedArrayNoBestType, "new[] { x => x }").WithLocation(11, 18),
+                // (14,18): error CS0826: No best type found for implicitly-typed array
+                //         var a7 = new[] { x => x, F1 };
+                Diagnostic(ErrorCode.ERR_ImplicitlyTypedArrayNoBestType, "new[] { x => x, F1 }").WithLocation(14, 18));
+        }
+
+        [Fact]
+        public void ArrayInitializer_01()
+        {
+            var source =
+@"using System;
+using System.Linq.Expressions;
+class Program
+{
+    static void Main()
+    {
+        var a1 = new Func<int>[] { () => 1 };
+        var a2 = new Expression<Func<int>>[] { () => 2 };
+        Report(a1[0]);
+        Report(a2[0]);
+    }
+    static void Report(object obj) => Console.WriteLine(obj.GetType());
+}";
+
+            string expectedOutput =
+$@"System.Func`1[System.Int32]
+{s_expressionOfTDelegateTypeName}[System.Func`1[System.Int32]]";
+            CompileAndVerify(source, parseOptions: TestOptions.Regular9, options: TestOptions.ReleaseExe, expectedOutput: expectedOutput);
+            CompileAndVerify(source, options: TestOptions.ReleaseExe, expectedOutput: expectedOutput);
+        }
+
+        [Fact]
+        public void ArrayInitializer_02()
+        {
+            var source =
+@"using System;
+using System.Linq.Expressions;
+class Program
+{
+    static void Main()
+    {
+        var a1 = new Delegate[] { () => 1 };
+        var a2 = new Expression[] { () => 2 };
+        Report(a1[0]);
+        Report(a2[0]);
+    }
+    static void Report(object obj) => Console.WriteLine(obj.GetType());
+}";
+
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
+            comp.VerifyDiagnostics(
+                // (7,35): error CS1660: Cannot convert lambda expression to type 'Delegate' because it is not a delegate type
+                //         var a1 = new Delegate[] { () => 1 };
+                Diagnostic(ErrorCode.ERR_AnonMethToNonDel, "() => 1").WithArguments("lambda expression", "System.Delegate").WithLocation(7, 35),
+                // (8,37): error CS1660: Cannot convert lambda expression to type 'Expression' because it is not a delegate type
+                //         var a2 = new Expression[] { () => 2 };
+                Diagnostic(ErrorCode.ERR_AnonMethToNonDel, "() => 2").WithArguments("lambda expression", "System.Linq.Expressions.Expression").WithLocation(8, 37));
+
+            CompileAndVerify(source, options: TestOptions.ReleaseExe, expectedOutput:
+$@"System.Func`1[System.Int32]
+{s_expressionOfTDelegateTypeName}[System.Func`1[System.Int32]]");
+        }
+
+        [Fact]
+        public void ArrayInitializer_03()
+        {
+            var source =
+@"using System;
+class Program
+{
+    static void Main()
+    {
+        var a1 = new[] { () => 1 };
+        Report(a1[0]);
+    }
+    static void Report(object obj) => Console.WriteLine(obj.GetType());
+}";
+
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
+            comp.VerifyDiagnostics(
+                // (6,18): error CS0826: No best type found for implicitly-typed array
+                //         var a1 = new[] { () => 1 };
+                Diagnostic(ErrorCode.ERR_ImplicitlyTypedArrayNoBestType, "new[] { () => 1 }").WithLocation(6, 18));
+
+            CompileAndVerify(source, options: TestOptions.ReleaseExe, expectedOutput:
+@"System.Func`1[System.Int32]");
+        }
+
+        [Fact]
+        public void ConditionalOperator_01()
+        {
+            var source =
+@"class Program
+{
+    static void F<T>(T t) { }
+    static void Main()
+    {
+        var c1 = F<object> ?? F<string>;
+        var c2 = ((object o) => { }) ?? ((string s) => { });
+        var c3 = F<string> ?? ((object o) => { });
+    }
+}";
+
+            var expectedDiagnostics = new[]
+            {
+                // (6,18): error CS0019: Operator '??' cannot be applied to operands of type 'method group' and 'method group'
+                //         var c1 = F<object> ?? F<string>;
+                Diagnostic(ErrorCode.ERR_BadBinaryOps, "F<object> ?? F<string>").WithArguments("??", "method group", "method group").WithLocation(6, 18),
+                // (7,18): error CS0019: Operator '??' cannot be applied to operands of type 'lambda expression' and 'lambda expression'
+                //         var c2 = ((object o) => { }) ?? ((string s) => { });
+                Diagnostic(ErrorCode.ERR_BadBinaryOps, "((object o) => { }) ?? ((string s) => { })").WithArguments("??", "lambda expression", "lambda expression").WithLocation(7, 18),
+                // (8,18): error CS0019: Operator '??' cannot be applied to operands of type 'method group' and 'lambda expression'
+                //         var c3 = F<string> ?? ((object o) => { });
+                Diagnostic(ErrorCode.ERR_BadBinaryOps, "F<string> ?? ((object o) => { })").WithArguments("??", "method group", "lambda expression").WithLocation(8, 18)
+            };
+
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
+            comp.VerifyDiagnostics(expectedDiagnostics);
+
+            comp = CreateCompilation(source);
+            comp.VerifyDiagnostics(expectedDiagnostics);
+        }
+
+        [Fact]
+        public void LambdaReturn_01()
+        {
+            var source =
+@"using System;
+class Program
+{
+    static void Main()
+    {
+        var a1 = () => () => 1;
+        var a2 = () => Main;
+        Report(a1());
+        Report(a2());
+    }
+    static void Report(object obj) => Console.WriteLine(obj.GetType());
+}";
+            CompileAndVerify(source, options: TestOptions.ReleaseExe, expectedOutput:
+@"System.Func`1[System.Int32]
+System.Action");
+        }
+
+        [Fact]
+        public void InferredType_MethodGroup()
+        {
+            var source =
+@"class Program
+{
+    static void Main()
+    {
+        System.Delegate d = Main;
+        System.Console.Write(d.GetDelegateTypeName());
+    }
+}";
+            var comp = CreateCompilation(new[] { source, s_utils }, options: TestOptions.ReleaseExe);
+            CompileAndVerify(comp, expectedOutput: "System.Action");
+
+            var tree = comp.SyntaxTrees[0];
+            var model = comp.GetSemanticModel(tree);
+            var expr = tree.GetRoot().DescendantNodes().OfType<VariableDeclaratorSyntax>().Single().Initializer!.Value;
+            var typeInfo = model.GetTypeInfo(expr);
+            Assert.Null(typeInfo.Type);
+            Assert.Equal(SpecialType.System_Delegate, typeInfo.ConvertedType!.SpecialType);
+        }
+
+        [Fact]
+        public void InferredType_LambdaExpression()
+        {
+            var source =
+@"class Program
+{
+    static void Main()
+    {
+        System.Delegate d = () => { };
+        System.Console.Write(d.GetDelegateTypeName());
+    }
+}";
+            var comp = CreateCompilation(new[] { source, s_utils }, options: TestOptions.ReleaseExe);
+            CompileAndVerify(comp, expectedOutput: "System.Action");
+
+            var tree = comp.SyntaxTrees[0];
+            var model = comp.GetSemanticModel(tree);
+            var expr = tree.GetRoot().DescendantNodes().OfType<AnonymousFunctionExpressionSyntax>().Single();
+            var typeInfo = model.GetTypeInfo(expr);
+            Assert.Equal("System.Action", typeInfo.Type.ToTestDisplayString());
+            Assert.Equal(SpecialType.System_Delegate, typeInfo.ConvertedType!.SpecialType);
+
+            var symbolInfo = model.GetSymbolInfo(expr);
+            var method = (IMethodSymbol)symbolInfo.Symbol!;
+            Assert.Equal(MethodKind.LambdaMethod, method.MethodKind);
+            Assert.True(HaveMatchingSignatures(((INamedTypeSymbol)typeInfo.Type!).DelegateInvokeMethod!, method));
+        }
+
+        [Fact]
+        public void TypeInference_Constraints_01()
+        {
+            var source =
+@"using System;
+using System.Linq.Expressions;
+class Program
+{
+    static T F1<T>(T t) where T : Delegate => t;
+    static T F2<T>(T t) where T : Expression => t;
+    static void Main()
+    {
+        Report(F1((int i) => { }));
+        Report(F2(() => 1));
+    }
+    static void Report(object obj) => Console.WriteLine(obj.GetType());
+}";
+
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
+            comp.VerifyDiagnostics(
+                // (9,16): error CS0411: The type arguments for method 'Program.F1<T>(T)' cannot be inferred from the usage. Try specifying the type arguments explicitly.
+                //         Report(F1((int i) => { }));
+                Diagnostic(ErrorCode.ERR_CantInferMethTypeArgs, "F1").WithArguments("Program.F1<T>(T)").WithLocation(9, 16),
+                // (10,16): error CS0411: The type arguments for method 'Program.F2<T>(T)' cannot be inferred from the usage. Try specifying the type arguments explicitly.
+                //         Report(F2(() => 1));
+                Diagnostic(ErrorCode.ERR_CantInferMethTypeArgs, "F2").WithArguments("Program.F2<T>(T)").WithLocation(10, 16));
+
+            CompileAndVerify(source, options: TestOptions.ReleaseExe, expectedOutput:
+$@"System.Action`1[System.Int32]
+{s_expressionOfTDelegateTypeName}[System.Func`1[System.Int32]]
+");
+        }
+
+        [Fact]
+        public void TypeInference_Constraints_02()
+        {
+            var source =
+@"using System;
+using System.Linq.Expressions;
+class A<T>
+{
+    public static U F<U>(U u) where U : T => u;
+}
+class B
+{
+    static void Main()
+    {
+        Report(A<object>.F(() => 1));
+        Report(A<ICloneable>.F(() => 1));
+        Report(A<Delegate>.F(() => 1));
+        Report(A<MulticastDelegate>.F(() => 1));
+        Report(A<Func<int>>.F(() => 1));
+        Report(A<Expression>.F(() => 1));
+        Report(A<LambdaExpression>.F(() => 1));
+        Report(A<Expression<Func<int>>>.F(() => 1));
+    }
+    static void Report(object obj) => Console.WriteLine(obj.GetType());
+}";
+            CompileAndVerify(source, options: TestOptions.ReleaseExe, expectedOutput:
+$@"System.Func`1[System.Int32]
+System.Func`1[System.Int32]
+System.Func`1[System.Int32]
+System.Func`1[System.Int32]
+System.Func`1[System.Int32]
+{s_expressionOfTDelegateTypeName}[System.Func`1[System.Int32]]
+{s_expressionOfTDelegateTypeName}[System.Func`1[System.Int32]]
+{s_expressionOfTDelegateTypeName}[System.Func`1[System.Int32]]
+");
+        }
+
+        [Fact]
+        public void TypeInference_Constraints_03()
+        {
+            var source =
+@"using System;
+using System.Linq.Expressions;
+class A<T, U> where U : T
+{
+    public static V F<V>(V v) where V : U => v;
+}
+class B
+{
+    static void Main()
+    {
+        Report(A<object, object>.F(() => 1));
+        Report(A<object, Delegate>.F(() => 1));
+        Report(A<object, Func<int>>.F(() => 1));
+        Report(A<Delegate, Func<int>>.F(() => 1));
+        Report(A<object, Expression>.F(() => 1));
+        Report(A<object, Expression<Func<int>>>.F(() => 1));
+        Report(A<Expression, LambdaExpression>.F(() => 1));
+        Report(A<Expression, Expression<Func<int>>>.F(() => 1));
+    }
+    static void Report(object obj) => Console.WriteLine(obj.GetType());
+}";
+            CompileAndVerify(source, options: TestOptions.ReleaseExe, expectedOutput:
+$@"System.Func`1[System.Int32]
+System.Func`1[System.Int32]
+System.Func`1[System.Int32]
+System.Func`1[System.Int32]
+{s_expressionOfTDelegateTypeName}[System.Func`1[System.Int32]]
+{s_expressionOfTDelegateTypeName}[System.Func`1[System.Int32]]
+{s_expressionOfTDelegateTypeName}[System.Func`1[System.Int32]]
+{s_expressionOfTDelegateTypeName}[System.Func`1[System.Int32]]
+");
+        }
+
+        [Fact]
+        public void TypeInference_MatchingSignatures()
+        {
+            var source =
+@"using System;
+class Program
+{
+    static T F<T>(T x, T y) => x;
+    static int F1(string s) => s.Length;
+    static void F2(string s) { }
+    static void Main()
+    {
+        Report(F(F1, (string s) => int.Parse(s)));
+        Report(F((string s) => { }, F2));
+    }
+    static void Report(object obj) => Console.WriteLine(obj.GetType());
+}";
+
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
+            comp.VerifyDiagnostics(
+                // (9,16): error CS0411: The type arguments for method 'Program.F<T>(T, T)' cannot be inferred from the usage. Try specifying the type arguments explicitly.
+                //         Report(F(F1, (string s) => int.Parse(s)));
+                Diagnostic(ErrorCode.ERR_CantInferMethTypeArgs, "F").WithArguments("Program.F<T>(T, T)").WithLocation(9, 16),
+                // (10,16): error CS0411: The type arguments for method 'Program.F<T>(T, T)' cannot be inferred from the usage. Try specifying the type arguments explicitly.
+                //         Report(F((string s) => { }, F2));
+                Diagnostic(ErrorCode.ERR_CantInferMethTypeArgs, "F").WithArguments("Program.F<T>(T, T)").WithLocation(10, 16));
+
+            CompileAndVerify(source, options: TestOptions.ReleaseExe, expectedOutput:
+@"System.Func`2[System.String,System.Int32]
+System.Action`1[System.String]
+");
+        }
+
+        [Fact]
+        public void TypeInference_DistinctSignatures()
+        {
+            var source =
+@"using System;
+class Program
+{
+    static T F<T>(T x, T y) => x;
+    static int F1(object o) => o.GetHashCode();
+    static void F2(object o) { }
+    static void Main()
+    {
+        Report(F(F1, (string s) => int.Parse(s)));
+        Report(F((string s) => { }, F2));
+    }
+    static void Report(object obj) => Console.WriteLine(obj.GetType());
+}";
+
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
+            comp.VerifyDiagnostics(
+                // (9,16): error CS0411: The type arguments for method 'Program.F<T>(T, T)' cannot be inferred from the usage. Try specifying the type arguments explicitly.
+                //         Report(F(F1, (string s) => int.Parse(s)));
+                Diagnostic(ErrorCode.ERR_CantInferMethTypeArgs, "F").WithArguments("Program.F<T>(T, T)").WithLocation(9, 16),
+                // (10,16): error CS0411: The type arguments for method 'Program.F<T>(T, T)' cannot be inferred from the usage. Try specifying the type arguments explicitly.
+                //         Report(F((string s) => { }, F2));
+                Diagnostic(ErrorCode.ERR_CantInferMethTypeArgs, "F").WithArguments("Program.F<T>(T, T)").WithLocation(10, 16));
+
+            CompileAndVerify(source, options: TestOptions.ReleaseExe, expectedOutput:
+@"System.Func`2[System.String,System.Int32]
+System.Action`1[System.String]
+");
+        }
+
+        [Fact]
+        public void TypeInference_01()
+        {
+            var source =
+@"using System;
+class Program
+{
+    static T M<T>(T x, T y) => x;
+    static int F1(int i) => i;
+    static void F1() { }
+    static T F2<T>(T t) => t;
+    static void Main()
+    {
+        var f1 = M(x => x, (int y) => y);
+        var f2 = M(F1, F2<int>);
+        var f3 = M(F2<object>, z => z);
+        Report(f1);
+        Report(f2);
+        Report(f3);
+    }
+    static void Report(object obj) => Console.WriteLine(obj.GetType());
+}";
+
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
+            comp.VerifyDiagnostics(
+                // (10,18): error CS0411: The type arguments for method 'Program.M<T>(T, T)' cannot be inferred from the usage. Try specifying the type arguments explicitly.
+                //         var f1 = M(x => x, (int y) => y);
+                Diagnostic(ErrorCode.ERR_CantInferMethTypeArgs, "M").WithArguments("Program.M<T>(T, T)").WithLocation(10, 18),
+                // (11,18): error CS0411: The type arguments for method 'Program.M<T>(T, T)' cannot be inferred from the usage. Try specifying the type arguments explicitly.
+                //         var f2 = M(F1, F2<int>);
+                Diagnostic(ErrorCode.ERR_CantInferMethTypeArgs, "M").WithArguments("Program.M<T>(T, T)").WithLocation(11, 18),
+                // (12,18): error CS0411: The type arguments for method 'Program.M<T>(T, T)' cannot be inferred from the usage. Try specifying the type arguments explicitly.
+                //         var f3 = M(F2<object>, z => z);
+                Diagnostic(ErrorCode.ERR_CantInferMethTypeArgs, "M").WithArguments("Program.M<T>(T, T)").WithLocation(12, 18));
+
+            CompileAndVerify(source, options: TestOptions.ReleaseExe, expectedOutput:
+@"System.Func`2[System.Int32,System.Int32]
+System.Func`2[System.Int32,System.Int32]
+System.Func`2[System.Object,System.Object]
+");
+        }
+
+        [Fact]
+        public void TypeInference_02()
+        {
+            var source =
+@"using System;
+class Program
+{
+    static T M<T>(T x, T y) where T : class => x ?? y;
+    static T F<T>() => default;
+    static void Main()
+    {
+        var f1 = M(F<object>, null);
+        var f2 = M(default, F<string>);
+        var f3 = M((object x, ref string y) => { }, default);
+        var f4 = M(null, (ref object x, string y) => { });
+        Report(f1);
+        Report(f2);
+        Report(f3);
+        Report(f4);
+    }
+    static void Report(object obj) => Console.WriteLine(obj.GetType());
+}";
+
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
+            comp.VerifyDiagnostics(
+                // (8,18): error CS0411: The type arguments for method 'Program.M<T>(T, T)' cannot be inferred from the usage. Try specifying the type arguments explicitly.
+                //         var f1 = M(F<object>, null);
+                Diagnostic(ErrorCode.ERR_CantInferMethTypeArgs, "M").WithArguments("Program.M<T>(T, T)").WithLocation(8, 18),
+                // (9,18): error CS0411: The type arguments for method 'Program.M<T>(T, T)' cannot be inferred from the usage. Try specifying the type arguments explicitly.
+                //         var f2 = M(default, F<string>);
+                Diagnostic(ErrorCode.ERR_CantInferMethTypeArgs, "M").WithArguments("Program.M<T>(T, T)").WithLocation(9, 18),
+                // (10,18): error CS0411: The type arguments for method 'Program.M<T>(T, T)' cannot be inferred from the usage. Try specifying the type arguments explicitly.
+                //         var f3 = M((object x, ref string y) => { }, default);
+                Diagnostic(ErrorCode.ERR_CantInferMethTypeArgs, "M").WithArguments("Program.M<T>(T, T)").WithLocation(10, 18),
+                // (11,18): error CS0411: The type arguments for method 'Program.M<T>(T, T)' cannot be inferred from the usage. Try specifying the type arguments explicitly.
+                //         var f4 = M(null, (ref object x, string y) => { });
+                Diagnostic(ErrorCode.ERR_CantInferMethTypeArgs, "M").WithArguments("Program.M<T>(T, T)").WithLocation(11, 18));
+
+            CompileAndVerify(source, options: TestOptions.ReleaseExe, expectedOutput:
+@"System.Func`1[System.Object]
+System.Func`1[System.String]
+<>A{00000004}`2[System.Object,System.String]
+<>A{00000001}`2[System.Object,System.String]
+");
+        }
+
+        [Fact]
+        public void TypeInference_LowerBoundsMatchingSignature()
+        {
+            var source =
+@"using System;
+delegate void D1<T>(T t);
+delegate T D2<T>();
+class Program
+{
+    static T F<T>(T x, T y) => y;
+    static void Main()
+    {
+        D1<string> d1 = (string s) => { };
+        D2<int> d2 = () => 1;
+        Report(F(d1, (string s) => { }));
+        Report(F(() => 2, d2));
+    }
+    static void Report(object obj) => Console.WriteLine(obj.GetType());
+}";
+            var expectedOutput =
+@"D1`1[System.String]
+D2`1[System.Int32]
+";
+            CompileAndVerify(source, parseOptions: TestOptions.Regular9, options: TestOptions.ReleaseExe, expectedOutput: expectedOutput);
+            CompileAndVerify(source, options: TestOptions.ReleaseExe, expectedOutput: expectedOutput);
+        }
+
+        [Fact]
+        public void TypeInference_LowerBoundsDistinctSignature_01()
+        {
+            var source =
+@"using System;
+delegate void D1<T>(T t);
+delegate T D2<T>();
+class Program
+{
+    static T F<T>(T x, T y) => y;
+    static void Main()
+    {
+        D1<string> d1 = (string s) => { };
+        D2<int> d2 = () => 1;
+        Report(F(d1, (object o) => { }));
+        Report(F(() => 1.0, d2));
+    }
+    static void Report(object obj) => Console.WriteLine(obj.GetType());
+}";
+
+            var expectedDiagnostics = new[]
+            {
+                // (11,22): error CS1661: Cannot convert lambda expression to type 'D1<string>' because the parameter types do not match the delegate parameter types
+                //         Report(F(d1, (object o) => { }));
+                Diagnostic(ErrorCode.ERR_CantConvAnonMethParams, "(object o) => { }").WithArguments("lambda expression", "D1<string>").WithLocation(11, 22),
+                // (11,30): error CS1678: Parameter 1 is declared as type 'object' but should be 'string'
+                //         Report(F(d1, (object o) => { }));
+                Diagnostic(ErrorCode.ERR_BadParamType, "o").WithArguments("1", "", "object", "", "string").WithLocation(11, 30),
+                // (12,24): error CS0266: Cannot implicitly convert type 'double' to 'int'. An explicit conversion exists (are you missing a cast?)
+                //         Report(F(() => 1.0, d2));
+                Diagnostic(ErrorCode.ERR_NoImplicitConvCast, "1.0").WithArguments("double", "int").WithLocation(12, 24),
+                // (12,24): error CS1662: Cannot convert lambda expression to intended delegate type because some of the return types in the block are not implicitly convertible to the delegate return type
+                //         Report(F(() => 1.0, d2));
+                Diagnostic(ErrorCode.ERR_CantConvAnonMethReturns, "1.0").WithArguments("lambda expression").WithLocation(12, 24)
+            };
+
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
+            comp.VerifyDiagnostics(expectedDiagnostics);
+
+            comp = CreateCompilation(source);
+            comp.VerifyDiagnostics(expectedDiagnostics);
+        }
+
+        [Fact]
+        public void TypeInference_LowerBoundsDistinctSignature_02()
+        {
+            var source =
+@"using System;
+class Program
+{
+    static T F<T>(T x, T y) => y;
+    static void Main()
+    {
+        Report(F((string s) => { }, (object o) => { }));
+        Report(F(() => string.Empty, () => new object()));
+    }
+    static void Report(object obj) => Console.WriteLine(obj.GetType());
+}";
+
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
+            comp.VerifyDiagnostics(
+                // (7,16): error CS0411: The type arguments for method 'Program.F<T>(T, T)' cannot be inferred from the usage. Try specifying the type arguments explicitly.
+                //         Report(F((string s) => { }, (object o) => { }));
+                Diagnostic(ErrorCode.ERR_CantInferMethTypeArgs, "F").WithArguments("Program.F<T>(T, T)").WithLocation(7, 16),
+                // (8,16): error CS0411: The type arguments for method 'Program.F<T>(T, T)' cannot be inferred from the usage. Try specifying the type arguments explicitly.
+                //         Report(F(() => string.Empty, () => new object()));
+                Diagnostic(ErrorCode.ERR_CantInferMethTypeArgs, "F").WithArguments("Program.F<T>(T, T)").WithLocation(8, 16));
+
+            comp = CreateCompilation(source);
+            comp.VerifyDiagnostics(
+                // (7,37): error CS1661: Cannot convert lambda expression to type 'Action<string>' because the parameter types do not match the delegate parameter types
+                //         Report(F((string s) => { }, (object o) => { }));
+                Diagnostic(ErrorCode.ERR_CantConvAnonMethParams, "(object o) => { }").WithArguments("lambda expression", "System.Action<string>").WithLocation(7, 37),
+                // (7,45): error CS1678: Parameter 1 is declared as type 'object' but should be 'string'
+                //         Report(F((string s) => { }, (object o) => { }));
+                Diagnostic(ErrorCode.ERR_BadParamType, "o").WithArguments("1", "", "object", "", "string").WithLocation(7, 45));
+        }
+
+        [Fact]
+        public void TypeInference_UpperAndLowerBoundsMatchingSignature()
         {
             var source =
 @"using System;
-using System.Linq.Expressions;
+delegate void D1<T>(T t);
+delegate T D2<T>();
 class Program
 {
-    static void Report(string name, Expression e) { Console.WriteLine(""{0}: {1}"", name, e); }
-    static void F(Expression e) { Report(""F(Expression)"", e); }
-    static void F(Expression<Func<int>> e) { Report(""F(Expression<Func<int>>)"", e); }
+    static T F1<T>(Action<T> x, T y) => y;
+    static T F2<T>(T x, Action<T> y) => x;
     static void Main()
     {
-        F(() => 0);
-        F(() => string.Empty);
+        Action<D1<string>> a1 = null;
+        Action<D2<int>> a2 = null;
+        Report(F1(a1, (string s) => { }));
+        Report(F2(() => 2, a2));
+    }
+    static void Report(object obj) => Console.WriteLine(obj.GetType());
+}";
+            var expectedOutput =
+@"D1`1[System.String]
+D2`1[System.Int32]
+";
+            CompileAndVerify(source, parseOptions: TestOptions.Regular9, options: TestOptions.ReleaseExe, expectedOutput: expectedOutput);
+            CompileAndVerify(source, options: TestOptions.ReleaseExe, expectedOutput: expectedOutput);
+        }
+
+        [Fact]
+        public void TypeInference_UpperAndLowerBoundsDistinctSignature_01()
+        {
+            var source =
+@"using System;
+delegate void D1<T>(T t);
+delegate T D2<T>();
+class Program
+{
+    static T F1<T>(Action<T> x, T y) => y;
+    static T F2<T>(T x, Action<T> y) => x;
+    static void Main()
+    {
+        Action<D1<string>> a1 = null;
+        Action<D2<object>> a2 = null;
+        Report(F1(a1, (object o) => { }));
+        Report(F2(() => string.Empty, a2));
     }
+    static void Report(object obj) => Console.WriteLine(obj.GetType());
 }";
 
+            var expectedDiagnostics = new[]
+            {
+                // (12,23): error CS1661: Cannot convert lambda expression to type 'D1<string>' because the parameter types do not match the delegate parameter types
+                //         Report(F1(a1, (object o) => { }));
+                Diagnostic(ErrorCode.ERR_CantConvAnonMethParams, "(object o) => { }").WithArguments("lambda expression", "D1<string>").WithLocation(12, 23),
+                // (12,31): error CS1678: Parameter 1 is declared as type 'object' but should be 'string'
+                //         Report(F1(a1, (object o) => { }));
+                Diagnostic(ErrorCode.ERR_BadParamType, "o").WithArguments("1", "", "object", "", "string").WithLocation(12, 31)
+            };
+
             var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
-            comp.VerifyDiagnostics(
-                // (11,17): error CS0029: Cannot implicitly convert type 'string' to 'int'
-                //         F(() => string.Empty);
-                Diagnostic(ErrorCode.ERR_NoImplicitConv, "string.Empty").WithArguments("string", "int").WithLocation(11, 17),
-                // (11,17): error CS1662: Cannot convert lambda expression to intended delegate type because some of the return types in the block are not implicitly convertible to the delegate return type
-                //         F(() => string.Empty);
-                Diagnostic(ErrorCode.ERR_CantConvAnonMethReturns, "string.Empty").WithArguments("lambda expression").WithLocation(11, 17));
+            comp.VerifyDiagnostics(expectedDiagnostics);
 
-            CompileAndVerify(source, parseOptions: TestOptions.Regular10, expectedOutput:
-@"F(Expression<Func<int>>): () => 0
-F(Expression): () => String.Empty
-");
+            comp = CreateCompilation(source);
+            comp.VerifyDiagnostics(expectedDiagnostics);
         }
 
         [Fact]
-        public void OverloadResolution_07()
+        public void TypeInference_UpperAndLowerBoundsDistinctSignature_02()
         {
             var source =
 @"using System;
-using System.Linq.Expressions;
+delegate void D1<T>(T t);
+delegate T D2<T>();
 class Program
 {
-    static void F(Expression e) { }
-    static void F(Expression<Func<int>> e) { }
+    static T F1<T>(Action<T> x, T y) => y;
+    static T F2<T>(T x, Action<T> y) => x;
     static void Main()
     {
-        F(delegate () { return 0; });
-        F(delegate () { return string.Empty; });
+        Report(F1((D1<string> d) => { }, (object o) => { }));
+        Report(F2(() => string.Empty, (D2<object>  d) => { }));
     }
+    static void Report(object obj) => Console.WriteLine(obj.GetType());
 }";
 
+            var expectedDiagnostics = new[]
+            {
+                   // (10,42): error CS1661: Cannot convert lambda expression to type 'D1<string>' because the parameter types do not match the delegate parameter types
+                //         Report(F1((D1<string> d) => { }, (object o) => { }));
+                Diagnostic(ErrorCode.ERR_CantConvAnonMethParams, "(object o) => { }").WithArguments("lambda expression", "D1<string>").WithLocation(10, 42),
+                // (10,50): error CS1678: Parameter 1 is declared as type 'object' but should be 'string'
+                //         Report(F1((D1<string> d) => { }, (object o) => { }));
+                Diagnostic(ErrorCode.ERR_BadParamType, "o").WithArguments("1", "", "object", "", "string").WithLocation(10, 50)
+            };
+
             var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
-            comp.VerifyDiagnostics(
-                // (9,11): error CS1660: Cannot convert anonymous method to type 'Expression' because it is not a delegate type
-                //         F(delegate () { return 0; });
-                Diagnostic(ErrorCode.ERR_AnonMethToNonDel, "delegate () { return 0; }").WithArguments("anonymous method", "System.Linq.Expressions.Expression").WithLocation(9, 11),
-                // (10,11): error CS1660: Cannot convert anonymous method to type 'Expression' because it is not a delegate type
-                //         F(delegate () { return string.Empty; });
-                Diagnostic(ErrorCode.ERR_AnonMethToNonDel, "delegate () { return string.Empty; }").WithArguments("anonymous method", "System.Linq.Expressions.Expression").WithLocation(10, 11));
+            comp.VerifyDiagnostics(expectedDiagnostics);
 
-            comp = CreateCompilation(source, parseOptions: TestOptions.Regular10);
-            comp.VerifyDiagnostics(
-                // (9,11): error CS1946: An anonymous method expression cannot be converted to an expression tree
-                //         F(delegate () { return 0; });
-                Diagnostic(ErrorCode.ERR_AnonymousMethodToExpressionTree, "delegate () { return 0; }").WithLocation(9, 11),
-                // (10,11): error CS1946: An anonymous method expression cannot be converted to an expression tree
-                //         F(delegate () { return string.Empty; });
-                Diagnostic(ErrorCode.ERR_AnonymousMethodToExpressionTree, "delegate () { return string.Empty; }").WithLocation(10, 11));
+            comp = CreateCompilation(source);
+            comp.VerifyDiagnostics(expectedDiagnostics);
         }
 
-        [WorkItem(55319, "https://github.com/dotnet/roslyn/issues/55319")]
         [Fact]
-        public void OverloadResolution_08()
+        public void TypeInference_ExactAndLowerBoundsMatchingSignature()
         {
             var source =
 @"using System;
-using static System.Console;
-class C
+delegate void D1<T>(T t);
+delegate T D2<T>();
+class Program
 {
+    static T F1<T>(ref T x, T y) => y;
+    static T F2<T>(T x, ref T y) => y;
     static void Main()
     {
-        var c = new C();
-        c.F(x => x);
-        c.F((int x) => x);
+        D1<string> d1 = (string s) => { };
+        D2<int> d2 = () => 1;
+        Report(F1(ref d1, (string s) => { }));
+        Report(F2(() => 2, ref d2));
     }
-    void F(Delegate d) => Write(""instance, "");
-}
-static class Extensions
-{
-    public static void F(this C c, Func<int, int> f) => Write(""extension, "");
+    static void Report(object obj) => Console.WriteLine(obj.GetType());
 }";
-
-            CompileAndVerify(source, parseOptions: TestOptions.Regular9, expectedOutput: "extension, extension, ");
-            CompileAndVerify(source, parseOptions: TestOptions.Regular10, expectedOutput: "extension, instance, ");
-            CompileAndVerify(source, expectedOutput: "extension, instance, ");
+            var expectedOutput =
+@"D1`1[System.String]
+D2`1[System.Int32]
+";
+            CompileAndVerify(source, parseOptions: TestOptions.Regular9, options: TestOptions.ReleaseExe, expectedOutput: expectedOutput);
+            CompileAndVerify(source, options: TestOptions.ReleaseExe, expectedOutput: expectedOutput);
         }
 
-        [WorkItem(55319, "https://github.com/dotnet/roslyn/issues/55319")]
         [Fact]
-        public void OverloadResolution_09()
+        public void TypeInference_ExactAndLowerBoundsDistinctSignature_01()
         {
             var source =
 @"using System;
-using System.Linq.Expressions;
-using static System.Console;
-class C
+delegate void D1<T>(T t);
+delegate T D2<T>();
+class Program
 {
+    static T F1<T>(ref T x, T y) => y;
+    static T F2<T>(T x, ref T y) => y;
     static void Main()
     {
-        var c = new C();
-        c.F(x => x);
-        c.F((int x) => x);
+        D1<string> d1 = (string s) => { };
+        D2<object> d2 = () => new object();
+        Report(F1(ref d1, (object o) => { }));
+        Report(F2(() => string.Empty, ref d2));
     }
-    void F(Expression e) => Write(""instance, "");
-}
-static class Extensions
-{
-    public static void F(this C c, Expression<Func<int, int>> e) => Write(""extension, "");
+    static void Report(object obj) => Console.WriteLine(obj.GetType());
 }";
 
-            CompileAndVerify(source, parseOptions: TestOptions.Regular9, expectedOutput: "extension, extension, ");
-            CompileAndVerify(source, parseOptions: TestOptions.Regular10, expectedOutput: "extension, instance, ");
-            CompileAndVerify(source, expectedOutput: "extension, instance, ");
+            var expectedDiagnostics = new[]
+            {
+                    // (12,27): error CS1661: Cannot convert lambda expression to type 'D1<string>' because the parameter types do not match the delegate parameter types
+                    //         Report(F1(ref d1, (object o) => { }));
+                    Diagnostic(ErrorCode.ERR_CantConvAnonMethParams, "(object o) => { }").WithArguments("lambda expression", "D1<string>").WithLocation(12, 27),
+                    // (12,35): error CS1678: Parameter 1 is declared as type 'object' but should be 'string'
+                    //         Report(F1(ref d1, (object o) => { }));
+                    Diagnostic(ErrorCode.ERR_BadParamType, "o").WithArguments("1", "", "object", "", "string").WithLocation(12, 35)
+            };
+
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
+            comp.VerifyDiagnostics(expectedDiagnostics);
+
+            comp = CreateCompilation(source);
+            comp.VerifyDiagnostics(expectedDiagnostics);
         }
 
-        [WorkItem(55319, "https://github.com/dotnet/roslyn/issues/55319")]
         [Fact]
-        public void OverloadResolution_10()
+        public void TypeInference_ExactAndLowerBoundsDistinctSignature_02()
         {
             var source =
 @"using System;
-using static System.Console;
-class C
+delegate void D1<T>(T t);
+delegate T D2<T>();
+class Program
 {
-    static object M1(object o) => o;
-    static int M1(int i) => i;
-    static int M2(int i) => i;
+    static T F1<T>(in T x, T y) => y;
+    static T F2<T>(T x, in T y) => y;
     static void Main()
     {
-        var c = new C();
-        c.F(M1);
-        c.F(M2);
+        Report(F1((D1<string> d) => { }, (object o) => { }));
+        Report(F2(() => string.Empty, (D2<object> d) => { }));
     }
-    void F(Delegate d) => Write(""instance, "");
-}
-static class Extensions
-{
-    public static void F(this C c, Func<int, int> f) => Write(""extension, "");
+    static void Report(object obj) => Console.WriteLine(obj.GetType());
 }";
 
-            CompileAndVerify(source, parseOptions: TestOptions.Regular9, expectedOutput: "extension, extension, ");
-            CompileAndVerify(source, parseOptions: TestOptions.Regular10, expectedOutput: "extension, instance, ");
-            CompileAndVerify(source, expectedOutput: "extension, instance, ");
+            var expectedDiagnostics = new[]
+            {
+                // (10,16): error CS0411: The type arguments for method 'Program.F1<T>(in T, T)' cannot be inferred from the usage. Try specifying the type arguments explicitly.
+                //         Report(F1((D1<string> d) => { }, (object o) => { }));
+                Diagnostic(ErrorCode.ERR_CantInferMethTypeArgs, "F1").WithArguments("Program.F1<T>(in T, T)").WithLocation(10, 16),
+                // (11,16): error CS0411: The type arguments for method 'Program.F2<T>(T, in T)' cannot be inferred from the usage. Try specifying the type arguments explicitly.
+                //         Report(F2(() => 1.0, (D2<int> d) => { }));
+                Diagnostic(ErrorCode.ERR_CantInferMethTypeArgs, "F2").WithArguments("Program.F2<T>(T, in T)").WithLocation(11, 16)
+            };
+
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
+            comp.VerifyDiagnostics(expectedDiagnostics);
+
+            comp = CreateCompilation(source);
+            comp.VerifyDiagnostics(
+                // (10,42): error CS1661: Cannot convert lambda expression to type 'Action<D1<string>>' because the parameter types do not match the delegate parameter types
+                //         Report(F1((D1<string> d) => { }, (object o) => { }));
+                Diagnostic(ErrorCode.ERR_CantConvAnonMethParams, "(object o) => { }").WithArguments("lambda expression", "System.Action<D1<string>>").WithLocation(10, 42),
+                // (10,50): error CS1678: Parameter 1 is declared as type 'object' but should be 'D1<string>'
+                //         Report(F1((D1<string> d) => { }, (object o) => { }));
+                Diagnostic(ErrorCode.ERR_BadParamType, "o").WithArguments("1", "", "object", "", "D1<string>").WithLocation(10, 50),
+                // (11,16): error CS0411: The type arguments for method 'Program.F2<T>(T, in T)' cannot be inferred from the usage. Try specifying the type arguments explicitly.
+                //         Report(F2(() => 1.0, (D2<int> d) => { }));
+                Diagnostic(ErrorCode.ERR_CantInferMethTypeArgs, "F2").WithArguments("Program.F2<T>(T, in T)").WithLocation(11, 16));
         }
 
         [Fact]
-        public void OverloadResolution_11()
+        public void TypeInference_Nested_01()
         {
             var source =
-@"using System;
-using System.Linq.Expressions;
-class C
+@"delegate void D<T>(T t);
+class Program
 {
-    static object M1(object o) => o;
-    static int M1(int i) => i;
+    static T F1<T>(T t) => t;
+    static D<T> F2<T>(D<T> d) => d;
     static void Main()
     {
-        F1(x => x);
-        F1(M1);
-        F2(x => x);
+        F2(F1((string s) => { }));
     }
-    static void F1(Delegate d) { }
-    static void F2(Expression e) { }
 }";
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
+            comp.VerifyDiagnostics(
+                // (8,12): error CS0411: The type arguments for method 'Program.F1<T>(T)' cannot be inferred from the usage. Try specifying the type arguments explicitly.
+                //         F2(F1((string s) => { }));
+                Diagnostic(ErrorCode.ERR_CantInferMethTypeArgs, "F1").WithArguments("Program.F1<T>(T)").WithLocation(8, 12));
+
+            // Reports error on F1() in C#9, and reports error on F2() in C#10.
+            comp = CreateCompilation(source);
+            comp.VerifyDiagnostics(
+                // (8,9): error CS0411: The type arguments for method 'Program.F2<T>(D<T>)' cannot be inferred from the usage. Try specifying the type arguments explicitly.
+                //         F2(F1((string s) => { }));
+                Diagnostic(ErrorCode.ERR_CantInferMethTypeArgs, "F2").WithArguments("Program.F2<T>(D<T>)").WithLocation(8, 9));
+        }
 
+        [Fact]
+        public void TypeInference_Nested_02()
+        {
+            var source =
+@"using System.Linq.Expressions;
+class Program
+{
+    static T F1<T>(T x) => throw null;
+    static Expression<T> F2<T>(Expression<T> e) => e;
+    static void Main()
+    {
+        F2(F1((object x1) => 1));
+    }
+}";
             var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
             comp.VerifyDiagnostics(
-                // (9,12): error CS1660: Cannot convert lambda expression to type 'Delegate' because it is not a delegate type
-                //         F1(x => x);
-                Diagnostic(ErrorCode.ERR_AnonMethToNonDel, "x => x").WithArguments("lambda expression", "System.Delegate").WithLocation(9, 12),
-                // (10,12): error CS1503: Argument 1: cannot convert from 'method group' to 'Delegate'
-                //         F1(M1);
-                Diagnostic(ErrorCode.ERR_BadArgType, "M1").WithArguments("1", "method group", "System.Delegate").WithLocation(10, 12),
-                // (11,12): error CS1660: Cannot convert lambda expression to type 'Expression' because it is not a delegate type
-                //         F2(x => x);
-                Diagnostic(ErrorCode.ERR_AnonMethToNonDel, "x => x").WithArguments("lambda expression", "System.Linq.Expressions.Expression").WithLocation(11, 12));
+                // (8,12): error CS0411: The type arguments for method 'Program.F1<T>(T)' cannot be inferred from the usage. Try specifying the type arguments explicitly.
+                //         F2(F1((string s) => { }));
+                Diagnostic(ErrorCode.ERR_CantInferMethTypeArgs, "F1").WithArguments("Program.F1<T>(T)").WithLocation(8, 12));
 
-            var expectedDiagnostics10AndLater = new[]
-            {
-                // (9,12): error CS8917: The delegate type could not be inferred.
-                //         F1(x => x);
-                Diagnostic(ErrorCode.ERR_CannotInferDelegateType, "x => x").WithLocation(9, 12),
-                // (10,12): error CS1503: Argument 1: cannot convert from 'method group' to 'Delegate'
-                //         F1(M1);
-                Diagnostic(ErrorCode.ERR_BadArgType, "M1").WithArguments("1", "method group", "System.Delegate").WithLocation(10, 12),
-                // (11,12): error CS8917: The delegate type could not be inferred.
-                //         F2(x => x);
-                Diagnostic(ErrorCode.ERR_CannotInferDelegateType, "x => x").WithLocation(11, 12)
-            };
+            // Reports error on F1() in C#9, and reports error on F2() in C#10.
+            comp = CreateCompilation(source);
+            comp.VerifyDiagnostics(
+                // (8,9): error CS0411: The type arguments for method 'Program.F2<T>(Expression<T>)' cannot be inferred from the usage. Try specifying the type arguments explicitly.
+                //         F2(F1((object x1) => 1));
+                Diagnostic(ErrorCode.ERR_CantInferMethTypeArgs, "F2").WithArguments("Program.F2<T>(System.Linq.Expressions.Expression<T>)").WithLocation(8, 9));
+        }
 
-            comp = CreateCompilation(source, parseOptions: TestOptions.Regular10);
-            comp.VerifyDiagnostics(expectedDiagnostics10AndLater);
+        /// <summary>
+        /// Method type inference with delegate signatures that cannot be inferred.
+        /// </summary>
+        [Fact]
+        public void TypeInference_NoInferredSignature()
+        {
+            var source =
+@"class Program
+{
+    static void F1() { }
+    static void F1(int i) { }
+    static void F2() { }
+    static T M1<T>(T t) => t;
+    static T M2<T>(T x, T y) => x;
+    static void Main()
+    {
+        var a1 = M1(F1);
+        var a2 = M2(F1, F2);
+        var a3 = M2(F2, F1);
+        var a4 = M1(x => x);
+        var a5 = M2(x => x, (int y) => y);
+        var a6 = M2((int y) => y, x => x);
+    }
+}";
+
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
+            comp.VerifyDiagnostics(
+                // (10,18): error CS0411: The type arguments for method 'Program.M1<T>(T)' cannot be inferred from the usage. Try specifying the type arguments explicitly.
+                //         var a1 = M1(F1);
+                Diagnostic(ErrorCode.ERR_CantInferMethTypeArgs, "M1").WithArguments("Program.M1<T>(T)").WithLocation(10, 18),
+                // (11,18): error CS0411: The type arguments for method 'Program.M2<T>(T, T)' cannot be inferred from the usage. Try specifying the type arguments explicitly.
+                //         var a2 = M2(F1, F2);
+                Diagnostic(ErrorCode.ERR_CantInferMethTypeArgs, "M2").WithArguments("Program.M2<T>(T, T)").WithLocation(11, 18),
+                // (12,18): error CS0411: The type arguments for method 'Program.M2<T>(T, T)' cannot be inferred from the usage. Try specifying the type arguments explicitly.
+                //         var a3 = M2(F2, F1);
+                Diagnostic(ErrorCode.ERR_CantInferMethTypeArgs, "M2").WithArguments("Program.M2<T>(T, T)").WithLocation(12, 18),
+                // (13,18): error CS0411: The type arguments for method 'Program.M1<T>(T)' cannot be inferred from the usage. Try specifying the type arguments explicitly.
+                //         var a4 = M1(x => x);
+                Diagnostic(ErrorCode.ERR_CantInferMethTypeArgs, "M1").WithArguments("Program.M1<T>(T)").WithLocation(13, 18),
+                // (14,18): error CS0411: The type arguments for method 'Program.M2<T>(T, T)' cannot be inferred from the usage. Try specifying the type arguments explicitly.
+                //         var a5 = M2(x => x, (int y) => y);
+                Diagnostic(ErrorCode.ERR_CantInferMethTypeArgs, "M2").WithArguments("Program.M2<T>(T, T)").WithLocation(14, 18),
+                // (15,18): error CS0411: The type arguments for method 'Program.M2<T>(T, T)' cannot be inferred from the usage. Try specifying the type arguments explicitly.
+                //         var a6 = M2((int y) => y, x => x);
+                Diagnostic(ErrorCode.ERR_CantInferMethTypeArgs, "M2").WithArguments("Program.M2<T>(T, T)").WithLocation(15, 18));
 
             comp = CreateCompilation(source);
-            comp.VerifyDiagnostics(expectedDiagnostics10AndLater);
+            comp.VerifyDiagnostics(
+                // (10,18): error CS0411: The type arguments for method 'Program.M1<T>(T)' cannot be inferred from the usage. Try specifying the type arguments explicitly.
+                //         var a1 = M1(F1);
+                Diagnostic(ErrorCode.ERR_CantInferMethTypeArgs, "M1").WithArguments("Program.M1<T>(T)").WithLocation(10, 18),
+                // (13,18): error CS0411: The type arguments for method 'Program.M1<T>(T)' cannot be inferred from the usage. Try specifying the type arguments explicitly.
+                //         var a4 = M1(x => x);
+                Diagnostic(ErrorCode.ERR_CantInferMethTypeArgs, "M1").WithArguments("Program.M1<T>(T)").WithLocation(13, 18));
+        }
+
+        [Fact]
+        public void Variance()
+        {
+            var source =
+@"using System;
+delegate void StringAction(string s);
+class Program
+{
+    static void Main()
+    {
+        Action<string> a1 = s => { };
+        Action<string> a2 = (string s) => { };
+        Action<string> a3 = (object o) => { };
+        Action<string> a4 = (Action<object>)((object o) => { });
+    }
+}";
+            var comp = CreateCompilation(source);
+            comp.VerifyDiagnostics(
+                // (9,29): error CS1661: Cannot convert lambda expression to type 'Action<string>' because the parameter types do not match the delegate parameter types
+                //         Action<string> a3 = (object o) => { };
+                Diagnostic(ErrorCode.ERR_CantConvAnonMethParams, "(object o) => { }").WithArguments("lambda expression", "System.Action<string>").WithLocation(9, 29),
+                // (9,37): error CS1678: Parameter 1 is declared as type 'object' but should be 'string'
+                //         Action<string> a3 = (object o) => { };
+                Diagnostic(ErrorCode.ERR_BadParamType, "o").WithArguments("1", "", "object", "", "string").WithLocation(9, 37));
         }
 
         [Fact]
@@ -2583,6 +4969,37 @@ static void Main()
                 Diagnostic(ErrorCode.ERR_BogusType, "() => 1").WithArguments("System.Func<T>").WithLocation(7, 18));
         }
 
+        [Fact]
+        public void BinaryOperator()
+        {
+            var source =
+@"using System;
+class Program
+{
+    static void Main()
+    {
+        var b1 = (() => { }) == null;
+        var b2 = null == Main;
+        var b3 = Main == (() => { });
+        Console.WriteLine((b1, b2, b3));
+    }
+}";
+
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
+            comp.VerifyDiagnostics(
+                // (6,18): error CS0019: Operator '==' cannot be applied to operands of type 'lambda expression' and '<null>'
+                //         var b1 = (() => { }) == null;
+                Diagnostic(ErrorCode.ERR_BadBinaryOps, "(() => { }) == null").WithArguments("==", "lambda expression", "<null>").WithLocation(6, 18),
+                // (7,18): error CS0019: Operator '==' cannot be applied to operands of type '<null>' and 'method group'
+                //         var b2 = null == Main;
+                Diagnostic(ErrorCode.ERR_BadBinaryOps, "null == Main").WithArguments("==", "<null>", "method group").WithLocation(7, 18),
+                // (8,18): error CS0019: Operator '==' cannot be applied to operands of type 'method group' and 'lambda expression'
+                //         var b3 = Main == (() => { });
+                Diagnostic(ErrorCode.ERR_BadBinaryOps, "Main == (() => { })").WithArguments("==", "method group", "lambda expression").WithLocation(8, 18));
+
+            CompileAndVerify(source, expectedOutput: "(False, False, False)");
+        }
+
         /// <summary>
         /// Ensure the conversion group containing the implicit
         /// conversion is handled correctly in NullableWalker.
@@ -3519,6 +5936,53 @@ static void Main()
 ");
         }
 
+        /// <summary>
+        /// Synthesized delegate types should only be emitted if used.
+        /// </summary>
+        [Fact]
+        [WorkItem(55896, "https://github.com/dotnet/roslyn/issues/55896")]
+        public void SynthesizedDelegateTypes_18()
+        {
+            var source =
+@"using System;
+delegate void D2(object x, ref object y);
+delegate void D4(out object x, ref object y);
+class Program
+{
+    static void F1(ref object x, object y) { }
+    static void F2(object x, ref object y) { }
+    static void Main()
+    {
+        var d1 = F1;
+        D2 d2 = F2;
+        var d3 = (ref object x, out object y) => { y = null; };
+        D4 d4 = (out object x, ref object y) => { x = null; };
+        Report(d1);
+        Report(d2);
+        Report(d3);
+        Report(d4);
+    }
+    static void Report(Delegate d) => Console.WriteLine(d.GetType());
+}";
+
+            var comp = CreateCompilation(source, options: TestOptions.ReleaseExe);
+            var verifier = CompileAndVerify(comp, validator: validator, expectedOutput:
+@"<>A{00000001}`2[System.Object,System.Object]
+D2
+<>A{00000009}`2[System.Object,System.Object]
+D4");
+
+            static void validator(PEAssembly assembly)
+            {
+                var reader = assembly.GetMetadataReader();
+                var actualTypes = reader.GetTypeDefNames().Select(h => reader.GetString(h)).ToArray();
+
+                // https://github.com/dotnet/roslyn/issues/55896: Should not include <>A{00000004}`2 or <>A{00000006}`2.
+                string[] expectedTypes = new[] { "<Module>", "<>A{00000001}`2", "<>A{00000004}`2", "<>A{00000006}`2", "<>A{00000009}`2", "D2", "D4", "Program", "<>c", };
+                AssertEx.Equal(expectedTypes, actualTypes);
+            }
+        }
+
         private static void VerifyLocalDelegateType(SemanticModel model, VariableDeclaratorSyntax variable, string expectedLocal, string expectedInvokeMethod)
         {
             var local = (ILocalSymbol)model.GetDeclaredSymbol(variable)!;
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/DynamicTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/DynamicTests.cs
index d415815594392..ab4ac7ca2e852 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/DynamicTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/DynamicTests.cs
@@ -1231,7 +1231,9 @@ static void M()
     }
 }
 ";
-            CreateCompilationWithMscorlib40AndSystemCore(source, options: TestOptions.UnsafeReleaseDll).VerifyDiagnostics(
+
+            var expectedDiagnostics = new[]
+            {
                 // (13,17): error CS0173: Type of conditional expression cannot be determined because there is no implicit conversion between 'dynamic' and 'method group'
                 //         var y = s1 ? d2 : M;
                 Diagnostic(ErrorCode.ERR_InvalidQM, "s1 ? d2 : M").WithArguments("dynamic", "method group").WithLocation(13, 17),
@@ -1244,7 +1246,13 @@ static void M()
                 // (16,17): error CS0173: Type of conditional expression cannot be determined because there is no implicit conversion between 'dynamic' and 'void*'
                 //         var w = s1 ? d2 : ptr;
                 Diagnostic(ErrorCode.ERR_InvalidQM, "s1 ? d2 : ptr").WithArguments("dynamic", "void*").WithLocation(16, 17)
-                );
+            };
+
+            var comp = CreateCompilationWithMscorlib40AndSystemCore(source, parseOptions: TestOptions.Regular9, options: TestOptions.UnsafeReleaseDll);
+            comp.VerifyDiagnostics(expectedDiagnostics);
+
+            comp = CreateCompilationWithMscorlib40AndSystemCore(source, options: TestOptions.UnsafeReleaseDll);
+            comp.VerifyDiagnostics(expectedDiagnostics);
         }
 
         #endregion
@@ -2552,15 +2560,28 @@ static void M()
     }
 } 
 ";
-            CreateCompilationWithMscorlib40AndSystemCore(source, options: TestOptions.UnsafeReleaseDll).VerifyDiagnostics(
-                // (14,17): error CS0428: Cannot convert method group 'M' to non-delegate type 'dynamic'. Did you intend to invoke the method?
-                Diagnostic(ErrorCode.ERR_MethGrpToNonDel, "M").WithArguments("M", "dynamic"),
-                // (15,17): error CS0029: Cannot implicitly convert type 'int*' to 'dynamic'
-                Diagnostic(ErrorCode.ERR_NoImplicitConv, "ptr").WithArguments("int*", "dynamic"),
+
+            var expectedDiagnostics = new[]
+            {
+                // (16,17): error CS0428: Cannot convert method group 'M' to non-delegate type 'dynamic'. Did you intend to invoke the method?
+                //             A = M,
+                Diagnostic(ErrorCode.ERR_MethGrpToNonDel, "M").WithArguments("M", "dynamic").WithLocation(16, 17),
+                // (17,17): error CS0029: Cannot implicitly convert type 'int*' to 'dynamic'
+                //             B = ptr,
+                Diagnostic(ErrorCode.ERR_NoImplicitConv, "ptr").WithArguments("int*", "dynamic").WithLocation(17, 17),
                 // (18,17): error CS1660: Cannot convert lambda expression to type 'dynamic' because it is not a delegate type
-                Diagnostic(ErrorCode.ERR_AnonMethToNonDel, "() => {}").WithArguments("lambda expression", "dynamic"),
+                //             C = () => {},
+                Diagnostic(ErrorCode.ERR_AnonMethToNonDel, "() => {}").WithArguments("lambda expression", "dynamic").WithLocation(18, 17),
                 // (19,17): error CS0029: Cannot implicitly convert type 'System.TypedReference' to 'dynamic'
-                Diagnostic(ErrorCode.ERR_NoImplicitConv, "default(TypedReference)").WithArguments("System.TypedReference", "dynamic"));
+                //             D = default(TypedReference)
+                Diagnostic(ErrorCode.ERR_NoImplicitConv, "default(TypedReference)").WithArguments("System.TypedReference", "dynamic").WithLocation(19, 17)
+            };
+
+            var comp = CreateCompilationWithMscorlib40AndSystemCore(source, parseOptions: TestOptions.Regular9, options: TestOptions.UnsafeReleaseDll);
+            comp.VerifyDiagnostics(expectedDiagnostics);
+
+            comp = CreateCompilationWithMscorlib40AndSystemCore(source, options: TestOptions.UnsafeReleaseDll);
+            comp.VerifyDiagnostics(expectedDiagnostics);
         }
 
         [Fact]
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/InterpolationTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/InterpolationTests.cs
index 50f9984230e38..688705206687c 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/InterpolationTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/InterpolationTests.cs
@@ -966,7 +966,8 @@ public static void Main(string[] args)
         Console.WriteLine($""X = { Program.Main(null) }."");
     }
 }";
-            CreateCompilation(source).VerifyDiagnostics(
+
+            CreateCompilation(source, parseOptions: TestOptions.Regular9).VerifyDiagnostics(
                 // (5,35): error CS1660: Cannot convert lambda expression to type 'object' because it is not a delegate type
                 //         Console.WriteLine($"X = { x=>3 }.");
                 Diagnostic(ErrorCode.ERR_AnonMethToNonDel, "x=>3").WithArguments("lambda expression", "object").WithLocation(5, 35),
@@ -977,6 +978,15 @@ public static void Main(string[] args)
                 //         Console.WriteLine($"X = { Program.Main(null) }.");
                 Diagnostic(ErrorCode.ERR_NoImplicitConv, "Program.Main(null)").WithArguments("void", "object").WithLocation(7, 35)
                 );
+
+            CreateCompilation(source).VerifyDiagnostics(
+                // (5,35): error CS8917: The delegate type could not be inferred.
+                //         Console.WriteLine($"X = { x=>3 }.");
+                Diagnostic(ErrorCode.ERR_CannotInferDelegateType, "x=>3").WithLocation(5, 35),
+                // (7,35): error CS0029: Cannot implicitly convert type 'void' to 'object'
+                //         Console.WriteLine($"X = { Program.Main(null) }.");
+                Diagnostic(ErrorCode.ERR_NoImplicitConv, "Program.Main(null)").WithArguments("void", "object").WithLocation(7, 35)
+                );
         }
 
         [WorkItem(1097428, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/1097428")]
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/LambdaTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/LambdaTests.cs
index d79e4482688cc..8abf0d2c0a0b0 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/LambdaTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/LambdaTests.cs
@@ -1101,8 +1101,13 @@ static void M(IList<C> c)
 }
 
 ";
-            var tree = SyntaxFactory.ParseSyntaxTree(source);
+            var tree = SyntaxFactory.ParseSyntaxTree(source, options: TestOptions.Regular9);
             var comp = CreateCompilation(tree);
+            comp.VerifyDiagnostics(
+                // (9,15): error CS1660: Cannot convert lambda expression to type 'IList<C>' because it is not a delegate type
+                //         tmp.M((a, b) => c.Add);
+                Diagnostic(ErrorCode.ERR_AnonMethToNonDel, "(a, b) => c.Add").WithArguments("lambda expression", "System.Collections.Generic.IList<C>").WithLocation(9, 15));
+
             var model = comp.GetSemanticModel(tree);
 
             var expr = (ExpressionSyntax)tree.GetCompilationUnitRoot().DescendantNodes().OfType<ParenthesizedLambdaExpressionSyntax>().Single().Body;
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs
index 3967e1eb6c03d..ea91e1c668be8 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs
@@ -52759,15 +52759,9 @@ static void M(bool b)
 ", options: WithNullableEnable());
 
             comp.VerifyDiagnostics(
-                // (7,24): error CS1660: Cannot convert lambda expression to type 'object' because it is not a delegate type
-                //         object a = b ? () => s.ToString() : () => s?.ToString();
-                Diagnostic(ErrorCode.ERR_AnonMethToNonDel, "() => s.ToString()").WithArguments("lambda expression", "object").WithLocation(7, 24),
                 // (7,30): warning CS8602: Dereference of a possibly null reference.
                 //         object a = b ? () => s.ToString() : () => s?.ToString();
-                Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "s").WithLocation(7, 30),
-                // (7,45): error CS1660: Cannot convert lambda expression to type 'object' because it is not a delegate type
-                //         object a = b ? () => s.ToString() : () => s?.ToString();
-                Diagnostic(ErrorCode.ERR_AnonMethToNonDel, "() => s?.ToString()").WithArguments("lambda expression", "object").WithLocation(7, 45)
+                Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "s").WithLocation(7, 30)
             );
         }
 
@@ -74762,9 +74756,6 @@ object P { set { } }
 }";
             var comp = CreateCompilation(new[] { source }, options: WithNullableEnable());
             comp.VerifyDiagnostics(
-                // (5,11): error CS1503: Argument 1: cannot convert from 'method group' to 'object'
-                //         G(F!);
-                Diagnostic(ErrorCode.ERR_BadArgType, "F").WithArguments("1", "method group", "object").WithLocation(5, 11),
                 // (6,11): error CS0154: The property or indexer 'C.P' cannot be used in this context because it lacks the get accessor
                 //         G(c.P!);
                 Diagnostic(ErrorCode.ERR_PropertyLacksGet, "c.P").WithArguments("C.P").WithLocation(6, 11)
@@ -74783,10 +74774,7 @@ static void F()
     }
 }";
             var comp = CreateCompilation(new[] { source }, options: WithNullableEnable());
-            comp.VerifyDiagnostics(
-                // (5,46): error CS0428: Cannot convert method group 'F' to non-delegate type 'object'. Did you intend to invoke the method?
-                //         var a = new object[] { new object(), F! };
-                Diagnostic(ErrorCode.ERR_MethGrpToNonDel, "F").WithArguments("F", "object").WithLocation(5, 46));
+            comp.VerifyDiagnostics();
         }
 
         [Fact, WorkItem(31370, "https://github.com/dotnet/roslyn/issues/31370")]
@@ -74989,9 +74977,9 @@ static void G(object? o)
 }";
             var comp = CreateCompilation(new[] { source }, options: WithNullableEnable());
             comp.VerifyDiagnostics(
-                // (6,18): error CS0428: Cannot convert method group 'F' to non-delegate type 'object'. Did you intend to invoke the method?
+                // (6,18): error CS0150: A constant value is expected
                 //         if (o is F)
-                Diagnostic(ErrorCode.ERR_MethGrpToNonDel, "F").WithArguments("F", "object").WithLocation(6, 18),
+                Diagnostic(ErrorCode.ERR_ConstantExpected, "F").WithLocation(6, 18),
                 // (8,15): warning CS8604: Possible null reference argument for parameter 'o' in 'void C.F(object o)'.
                 //             F(o);
                 Diagnostic(ErrorCode.WRN_NullReferenceArgument, "o").WithArguments("o", "void C.F(object o)").WithLocation(8, 15));
@@ -131317,6 +131305,598 @@ partial interface I4<out T> where T : I1
                 );
         }
 
+        [Fact, WorkItem(45960, "https://github.com/dotnet/roslyn/issues/45960")]
+        public void PartialBaseTypeDifference_01()
+        {
+            var source0 = @"
+#nullable enable
+
+Base<string> base1 = new C();
+Base<string?> base2 = new C(); // 1
+
+class Base<T> { }
+";
+            var source1 = @"
+#nullable enable
+partial class C : Base<string> { }
+";
+            var source2 = @"
+#nullable disable
+partial class C : Base<string> { }
+";
+            var comp = CreateCompilation(new[] { source0, source1, source2 });
+            verify();
+
+            comp = CreateCompilation(new[] { source0, source2, source1 });
+            verify();
+
+            void verify()
+            {
+                comp.VerifyDiagnostics(
+                    // (5,23): warning CS8619: Nullability of reference types in value of type 'C' doesn't match target type 'Base<string?>'.
+                    // Base<string?> base2 = new C(); // 1
+                    Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, "new C()").WithArguments("C", "Base<string?>").WithLocation(5, 23)
+                    );
+
+                var cClass = comp.GetMember<NamedTypeSymbol>("C");
+                var @base = cClass.BaseTypeNoUseSiteDiagnostics;
+                // note: the symbol model doesn't include a nullable annotation for base types or implemented interfaces.
+                Assert.Equal("Base<System.String!>", @base.ToTestDisplayString(includeNonNullable: true));
+            }
+        }
+
+        [Fact, WorkItem(45960, "https://github.com/dotnet/roslyn/issues/45960")]
+        public void PartialBaseTypeDifference_02()
+        {
+            var source0 = @"
+#nullable enable
+
+Base<string> base1 = new C(); // 1
+Base<string?> base2 = new C();
+
+class Base<T> { }
+";
+            var source1 = @"
+#nullable enable
+partial class C : Base<string?> { }
+";
+            var source2 = @"
+#nullable disable
+partial class C : Base<string> { }
+";
+            var comp = CreateCompilation(new[] { source0, source1, source2 });
+            verify();
+
+            comp = CreateCompilation(new[] { source0, source2, source1 });
+            verify();
+
+            void verify()
+            {
+                comp.VerifyDiagnostics(
+                    // (4,22): warning CS8619: Nullability of reference types in value of type 'C' doesn't match target type 'Base<string>'.
+                    // Base<string> base1 = new C(); // 1
+                    Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, "new C()").WithArguments("C", "Base<string>").WithLocation(4, 22)
+                    );
+
+                var cClass = comp.GetMember<NamedTypeSymbol>("C");
+                var @base = cClass.BaseTypeNoUseSiteDiagnostics;
+                // note: the symbol model doesn't include a nullable annotation for base types or implemented interfaces.
+                Assert.Equal("Base<System.String?>", @base.ToTestDisplayString(includeNonNullable: true));
+            }
+        }
+
+        [Fact, WorkItem(45960, "https://github.com/dotnet/roslyn/issues/45960")]
+        public void PartialBaseTypeDifference_03()
+        {
+            var source0 = @"
+#nullable enable
+
+Base<string> base1 = new C();
+Base<string?> base2 = new C(); // 1
+
+class Base<T> { }
+";
+            var source1 = @"
+#nullable enable
+partial class C : Base<string> { }
+";
+            var source2 = @"
+#nullable enable
+partial class C : Base<
+#nullable disable
+    string
+#nullable enable
+> { }
+";
+            var comp = CreateCompilation(new[] { source0, source1, source2 });
+            verify();
+
+            comp = CreateCompilation(new[] { source0, source2, source1 });
+            verify();
+
+            void verify()
+            {
+                comp.VerifyDiagnostics(
+                    // (5,23): warning CS8619: Nullability of reference types in value of type 'C' doesn't match target type 'Base<string?>'.
+                    // Base<string?> base2 = new C(); // 1
+                    Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, "new C()").WithArguments("C", "Base<string?>").WithLocation(5, 23)
+                    );
+
+                var cClass = comp.GetMember<NamedTypeSymbol>("C");
+                var @base = cClass.BaseTypeNoUseSiteDiagnostics;
+                Assert.Equal("Base<System.String!>", @base.ToTestDisplayString(includeNonNullable: true));
+            }
+        }
+
+        [Fact, WorkItem(45960, "https://github.com/dotnet/roslyn/issues/45960")]
+        public void PartialBaseTypeDifference_04()
+        {
+            var source0 = @"
+#nullable enable
+
+Base<string> base1 = new C(); // 1
+Base<string?> base2 = new C();
+
+class Base<T> { }
+";
+            var source1 = @"
+#nullable enable
+partial class C : Base<string?> { }
+";
+            var source2 = @"
+#nullable enable
+partial class C : Base<
+#nullable disable
+    string
+#nullable enable
+> { }
+";
+            var comp = CreateCompilation(new[] { source0, source1, source2 });
+            verify();
+
+            comp = CreateCompilation(new[] { source0, source2, source1 });
+            verify();
+
+            void verify()
+            {
+                comp.VerifyDiagnostics(
+                    // (4,22): warning CS8619: Nullability of reference types in value of type 'C' doesn't match target type 'Base<string>'.
+                    // Base<string> base1 = new C(); // 1
+                    Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, "new C()").WithArguments("C", "Base<string>").WithLocation(4, 22)
+                    );
+
+                var cClass = comp.GetMember<NamedTypeSymbol>("C");
+                var @base = cClass.BaseTypeNoUseSiteDiagnostics;
+                Assert.Equal("Base<System.String?>", @base.ToTestDisplayString(includeNonNullable: true));
+            }
+        }
+
+        [Fact, WorkItem(45960, "https://github.com/dotnet/roslyn/issues/45960")]
+        public void PartialBaseTypeDifference_05()
+        {
+            var source0 = @"
+#nullable enable
+
+Base<string> base1 = new C();
+Base<string?> base2 = new C(); // 1
+
+class Base<T> { }
+";
+            var source1 = @"
+#nullable enable
+partial class C : Base<string> { }
+";
+            var source2 = @"
+#nullable enable
+partial class C : Base<
+#nullable disable
+    string
+> { } // Note: the top-level nullability is oblivious here.
+";
+            var comp = CreateCompilation(new[] { source0, source1, source2 });
+            verify();
+
+            comp = CreateCompilation(new[] { source0, source2, source1 });
+            verify();
+
+            void verify()
+            {
+                comp.VerifyDiagnostics(
+                    // (5,23): warning CS8619: Nullability of reference types in value of type 'C' doesn't match target type 'Base<string?>'.
+                    // Base<string?> base2 = new C(); // 1
+                    Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, "new C()").WithArguments("C", "Base<string?>").WithLocation(5, 23)
+                    );
+            }
+        }
+
+        [Fact, WorkItem(45960, "https://github.com/dotnet/roslyn/issues/45960")]
+        public void PartialBaseTypeDifference_06()
+        {
+            var source0 = @"
+#nullable enable
+
+Base<string, object?> base1 = new C();
+Base<string, object> base2 = new C(); // 1
+Base<string?, object?> base3 = new C(); // 2
+
+class Base<T, U> { }
+";
+            var source1 = @"
+#nullable enable
+partial class C : Base<string, object?> { }
+";
+            var source2 = @"
+#nullable disable
+partial class C : Base<string, object> { }
+";
+            var comp = CreateCompilation(new[] { source0, source1, source2 });
+            verify();
+
+            comp = CreateCompilation(new[] { source0, source2, source1 });
+            verify();
+
+            void verify()
+            {
+                comp.VerifyDiagnostics(
+                    // (5,30): warning CS8619: Nullability of reference types in value of type 'C' doesn't match target type 'Base<string, object>'.
+                    // Base<string, object> base2 = new C(); // 1
+                    Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, "new C()").WithArguments("C", "Base<string, object>").WithLocation(5, 30),
+                    // (6,32): warning CS8619: Nullability of reference types in value of type 'C' doesn't match target type 'Base<string?, object?>'.
+                    // Base<string?, object?> base3 = new C(); // 2
+                    Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, "new C()").WithArguments("C", "Base<string?, object?>").WithLocation(6, 32)
+                    );
+            }
+        }
+
+        [Fact, WorkItem(45960, "https://github.com/dotnet/roslyn/issues/45960")]
+        public void PartialBaseTypeDifference_07()
+        {
+            var source0 = @"
+#nullable enable
+
+Base<string, object?> base1 = new C(); // 1
+Base<string, object> base2 = new C(); // 2
+Base<string?, object?> base3 = new C(); // 3
+
+class Base<T, U> { }
+";
+            var source1 = @"
+#nullable enable
+partial class C : Base<string, object?> { } // 4
+";
+            var source2 = @"
+#nullable disable
+partial class C : Base<string, object> { }
+";
+            var source3 = @"
+#nullable enable
+partial class C : Base<string?, object> { }
+";
+            var comp = CreateCompilation(new[] { source0, source1, source2, source3 });
+            verify();
+
+            comp = CreateCompilation(new[] { source0, source3, source2, source1 });
+            verify();
+
+            void verify()
+            {
+                comp.VerifyDiagnostics(
+                    // (3,15): error CS0263: Partial declarations of 'C' must not specify different base classes
+                    // partial class C : Base<string, object?> { } // 4
+                    Diagnostic(ErrorCode.ERR_PartialMultipleBases, "C").WithArguments("C").WithLocation(3, 15),
+                    // (4,31): error CS0029: Cannot implicitly convert type 'C' to 'Base<string, object?>'
+                    // Base<string, object?> base1 = new C(); // 1
+                    Diagnostic(ErrorCode.ERR_NoImplicitConv, "new C()").WithArguments("C", "Base<string, object?>").WithLocation(4, 31),
+                    // (5,30): error CS0029: Cannot implicitly convert type 'C' to 'Base<string, object>'
+                    // Base<string, object> base2 = new C(); // 2
+                    Diagnostic(ErrorCode.ERR_NoImplicitConv, "new C()").WithArguments("C", "Base<string, object>").WithLocation(5, 30),
+                    // (6,32): error CS0029: Cannot implicitly convert type 'C' to 'Base<string?, object?>'
+                    // Base<string?, object?> base3 = new C(); // 3
+                    Diagnostic(ErrorCode.ERR_NoImplicitConv, "new C()").WithArguments("C", "Base<string?, object?>").WithLocation(6, 32)
+                    );
+            }
+        }
+
+        [Fact, WorkItem(45960, "https://github.com/dotnet/roslyn/issues/45960")]
+        public void PartialBaseTypeDifference_08()
+        {
+            var source0 = @"
+#nullable enable
+
+Base<S, object?> base1 = new C1();
+Base<S, object> base2 = new C1(); // 1
+
+Base<object?, S> base3 = new C2(); // 2
+Base<object, S> base4 = new C2();
+
+class Base<T, U> { }
+
+struct S { }
+";
+            var source1 = @"
+#nullable enable
+partial class C1 : Base<S, object?> { }
+partial class C2 : Base<object, S> { }
+";
+            var source2 = @"
+#nullable disable
+partial class C1 : Base<S, object> { }
+partial class C2 : Base<object, S> { }
+";
+            var comp = CreateCompilation(new[] { source0, source1, source2 });
+            verify();
+
+            comp = CreateCompilation(new[] { source0, source2, source1 });
+            verify();
+
+            void verify()
+            {
+                comp.VerifyDiagnostics(
+                    // (5,25): warning CS8619: Nullability of reference types in value of type 'C1' doesn't match target type 'Base<S, object>'.
+                    // Base<S, object> base2 = new C1(); // 1
+                    Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, "new C1()").WithArguments("C1", "Base<S, object>").WithLocation(5, 25),
+                    // (7,26): warning CS8619: Nullability of reference types in value of type 'C2' doesn't match target type 'Base<object?, S>'.
+                    // Base<object?, S> base3 = new C2(); // 2
+                    Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, "new C2()").WithArguments("C2", "Base<object?, S>").WithLocation(7, 26)
+                    );
+            }
+        }
+
+        [Fact, WorkItem(45960, "https://github.com/dotnet/roslyn/issues/45960")]
+        public void PartialBaseTypeDifference_09()
+        {
+            var source0 = @"
+#nullable enable
+
+Base<S?, object?> base1 = new C1();
+Base<S?, object> base2 = new C1(); // 1
+
+Base<object?, S?> base3 = new C2(); // 2
+Base<object, S?> base4 = new C2();
+
+class Base<T, U> { }
+
+struct S { }
+";
+            var source1 = @"
+#nullable enable
+partial class C1 : Base<S?, object?> { }
+partial class C2 : Base<object, S?> { }
+";
+            var source2 = @"
+#nullable disable
+partial class C1 : Base<S?, object> { }
+partial class C2 : Base<object, S?> { }
+";
+            var comp = CreateCompilation(new[] { source0, source1, source2 });
+            verify();
+
+            comp = CreateCompilation(new[] { source0, source2, source1 });
+            verify();
+
+            void verify()
+            {
+                comp.VerifyDiagnostics(
+                    // (5,26): warning CS8619: Nullability of reference types in value of type 'C1' doesn't match target type 'Base<S?, object>'.
+                    // Base<S?, object> base2 = new C1(); // 1
+                    Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, "new C1()").WithArguments("C1", "Base<S?, object>").WithLocation(5, 26),
+                    // (7,27): warning CS8619: Nullability of reference types in value of type 'C2' doesn't match target type 'Base<object?, S?>'.
+                    // Base<object?, S?> base3 = new C2(); // 2
+                    Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, "new C2()").WithArguments("C2", "Base<object?, S?>").WithLocation(7, 27)
+                    );
+            }
+        }
+
+        [Fact, WorkItem(45960, "https://github.com/dotnet/roslyn/issues/45960")]
+        public void PartialBaseTypeDifference_10()
+        {
+            var source0 = @"
+#nullable enable
+
+Base<S, object?> base1 = new C1();
+Base<S, object> base2 = new C1(); // 1
+
+Base<object?, S> base3 = new C2(); // 2
+Base<object, S> base4 = new C2();
+
+class Base<T, U> { }
+
+struct S { }
+";
+            var source1 = @"
+#nullable enable
+partial class C1 : Base<S, object?> { }
+partial class C2 : Base<object, S> { }
+";
+            var source2 = @"
+#nullable enable
+partial class C1 : Base<
+    S,
+#nullable disable
+    object> { }
+
+#nullable enable
+partial class C2 : Base<
+    object,
+#nullable disable
+    S> { }
+";
+            var comp = CreateCompilation(new[] { source0, source1, source2 });
+            verify();
+
+            comp = CreateCompilation(new[] { source0, source2, source1 });
+            verify();
+
+            void verify()
+            {
+                comp.VerifyDiagnostics(
+                    // (5,25): warning CS8619: Nullability of reference types in value of type 'C1' doesn't match target type 'Base<S, object>'.
+                    // Base<S, object> base2 = new C1(); // 1
+                    Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, "new C1()").WithArguments("C1", "Base<S, object>").WithLocation(5, 25),
+                    // (7,26): warning CS8619: Nullability of reference types in value of type 'C2' doesn't match target type 'Base<object?, S>'.
+                    // Base<object?, S> base3 = new C2(); // 2
+                    Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, "new C2()").WithArguments("C2", "Base<object?, S>").WithLocation(7, 26)
+                    );
+            }
+        }
+
+        [Fact, WorkItem(45960, "https://github.com/dotnet/roslyn/issues/45960")]
+        public void PartialBaseTypeDifference_11()
+        {
+            var source0 = @"
+#nullable enable
+
+Base<S?, object?> base1 = new C1();
+Base<S?, object> base2 = new C1(); // 1
+
+Base<object?, S?> base3 = new C2(); // 2
+Base<object, S?> base4 = new C2();
+
+class Base<T, U> { }
+
+struct S { }
+";
+            var source1 = @"
+#nullable enable
+partial class C1 : Base<S?, object?> { }
+partial class C2 : Base<object, S?> { }
+";
+            var source2 = @"
+#nullable enable
+partial class C1 : Base<
+    S?,
+#nullable disable
+    object> { }
+
+#nullable enable
+partial class C2 : Base<
+    object,
+#nullable disable
+    S?> { }
+";
+            var comp = CreateCompilation(new[] { source0, source1, source2 });
+            comp.VerifyDiagnostics(
+                // (5,26): warning CS8619: Nullability of reference types in value of type 'C1' doesn't match target type 'Base<S?, object>'.
+                // Base<S?, object> base2 = new C1(); // 1
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, "new C1()").WithArguments("C1", "Base<S?, object>").WithLocation(5, 26),
+                // (7,27): warning CS8619: Nullability of reference types in value of type 'C2' doesn't match target type 'Base<object?, S?>'.
+                // Base<object?, S?> base3 = new C2(); // 2
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, "new C2()").WithArguments("C2", "Base<object?, S?>").WithLocation(7, 27)
+                );
+        }
+
+        [Fact, WorkItem(45960, "https://github.com/dotnet/roslyn/issues/45960")]
+        public void PartialBaseTypeDifference_12()
+        {
+            var source0 = @"
+#nullable enable
+
+Base<S, object?> base1 = new C1<S>();
+Base<S, object> base2 = new C1<S>(); // 1
+
+Base<object?, S> base3 = new C2<S>(); // 2
+Base<object, S> base4 = new C2<S>();
+
+class Base<T, U> { }
+
+struct S { }
+";
+            var source1 = @"
+#nullable enable
+partial class C1<TStruct> : Base<TStruct, object?> where TStruct : struct { }
+partial class C2<TStruct> : Base<object, TStruct> where TStruct : struct { }
+";
+            var source2 = @"
+#nullable enable
+partial class C1<TStruct> : Base<
+    TStruct,
+#nullable disable
+    object> where TStruct : struct { }
+
+#nullable enable
+partial class C2<TStruct> : Base<
+    object,
+#nullable disable
+    TStruct> where TStruct : struct { }
+";
+            var comp = CreateCompilation(new[] { source0, source1, source2 });
+            verify();
+
+            comp = CreateCompilation(new[] { source0, source2, source1 });
+            verify();
+
+            void verify()
+            {
+                comp.VerifyDiagnostics(
+                    // (5,25): warning CS8619: Nullability of reference types in value of type 'C1<S>' doesn't match target type 'Base<S, object>'.
+                    // Base<S, object> base2 = new C1<S>(); // 1
+                    Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, "new C1<S>()").WithArguments("C1<S>", "Base<S, object>").WithLocation(5, 25),
+                    // (7,26): warning CS8619: Nullability of reference types in value of type 'C2<S>' doesn't match target type 'Base<object?, S>'.
+                    // Base<object?, S> base3 = new C2<S>(); // 2
+                    Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, "new C2<S>()").WithArguments("C2<S>", "Base<object?, S>").WithLocation(7, 26)
+                    );
+            }
+        }
+
+        [Theory, WorkItem(45960, "https://github.com/dotnet/roslyn/issues/45960")]
+        [InlineData("")]
+        [InlineData("where T : class")]
+        public void PartialBaseTypeDifference_13(string constraints)
+        {
+            var source0 = @"
+#nullable enable
+
+Base<C, object?> base1 = new C1<C>(); // 1
+Base<C, object> base2 = new C1<C>(); // 2
+
+Base<object?, C> base3 = new C2<C>(); // 3
+Base<object, C> base4 = new C2<C>(); // 4
+
+class Base<T, U> { }
+
+class C { }
+";
+            var source1 = @"
+#nullable enable
+partial class C1<T> : Base<T, object?> " + constraints + @" { } // 5
+partial class C2<T> : Base<object, T> " + constraints + @" { } // 6
+";
+            var source2 = @"
+#nullable enable
+partial class C1<T> : Base<
+    T,
+#nullable disable
+    object> " + constraints + @" { }
+
+#nullable enable
+partial class C2<T> : Base<
+    object,
+#nullable disable
+    T> " + constraints + @" { }
+";
+            var comp = CreateCompilation(new[] { source0, source1, source2 });
+            comp.VerifyDiagnostics(
+                // (3,15): error CS0263: Partial declarations of 'C1<T>' must not specify different base classes
+                // partial class C1<T> : Base<T, object?>  { } // 5
+                Diagnostic(ErrorCode.ERR_PartialMultipleBases, "C1").WithArguments("C1<T>").WithLocation(3, 15),
+                // (4,15): error CS0263: Partial declarations of 'C2<T>' must not specify different base classes
+                // partial class C2<T> : Base<object, T>  { } // 6
+                Diagnostic(ErrorCode.ERR_PartialMultipleBases, "C2").WithArguments("C2<T>").WithLocation(4, 15),
+                // (4,26): error CS0029: Cannot implicitly convert type 'C1<C>' to 'Base<C, object?>'
+                // Base<C, object?> base1 = new C1<C>(); // 1
+                Diagnostic(ErrorCode.ERR_NoImplicitConv, "new C1<C>()").WithArguments("C1<C>", "Base<C, object?>").WithLocation(4, 26),
+                // (5,25): error CS0029: Cannot implicitly convert type 'C1<C>' to 'Base<C, object>'
+                // Base<C, object> base2 = new C1<C>(); // 2
+                Diagnostic(ErrorCode.ERR_NoImplicitConv, "new C1<C>()").WithArguments("C1<C>", "Base<C, object>").WithLocation(5, 25),
+                // (7,26): error CS0029: Cannot implicitly convert type 'C2<C>' to 'Base<object?, C>'
+                // Base<object?, C> base3 = new C2<C>(); // 3
+                Diagnostic(ErrorCode.ERR_NoImplicitConv, "new C2<C>()").WithArguments("C2<C>", "Base<object?, C>").WithLocation(7, 26),
+                // (8,25): error CS0029: Cannot implicitly convert type 'C2<C>' to 'Base<object, C>'
+                // Base<object, C> base4 = new C2<C>(); // 4
+                Diagnostic(ErrorCode.ERR_NoImplicitConv, "new C2<C>()").WithArguments("C2<C>", "Base<object, C>").WithLocation(8, 25)
+                );
+        }
+
         [Fact]
         public void PartialMethodsWithConstraints_01()
         {
@@ -151569,5 +152149,63 @@ ref T Passthrough(ref T value)
                 Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, "value2").WithArguments("T?", "T").WithLocation(9, 20)
                 );
         }
+
+        [Fact, WorkItem(55227, "https://github.com/dotnet/roslyn/issues/55227")]
+        public void Issue55227_01()
+        {
+            var source = @"
+#nullable enable
+
+static class Program
+{
+    public static void Main()
+    {
+    }
+
+    public static object Test(object a)
+    {
+        var isNullCheck = new global::System.Func<object, object>((p) =>
+        {
+            switch (p == null)
+            {
+                case var isnull:
+                    return isnull;
+            }
+        });
+        return isNullCheck(a);
+    }
+}
+";
+
+            CreateCompilation(source).VerifyDiagnostics();
+        }
+
+        [Fact, WorkItem(55227, "https://github.com/dotnet/roslyn/issues/55227")]
+        public void Issue55227_02()
+        {
+            var source = @"
+#nullable enable
+
+static class Program
+{
+    public static void Main()
+    {
+    }
+
+    public static object Test(object a)
+    {
+        var isNullCheck = new global::System.Func<object, object>((p) =>
+            (p == null) switch 
+            {
+                var isnull => isnull
+            }
+        );
+        return isNullCheck(a);
+    }
+}
+";
+
+            CreateCompilation(source).VerifyDiagnostics();
+        }
     }
 }
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesVsPatterns.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesVsPatterns.cs
index 7a1343b353fa4..925da44dd794d 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesVsPatterns.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesVsPatterns.cs
@@ -2482,7 +2482,8 @@ static void M(bool b)
         [Fact, WorkItem(51461, "https://github.com/dotnet/roslyn/issues/51461")]
         public void TargetTypedSwitch_05()
         {
-            var comp = CreateCompilation(@"
+            var source =
+@"#nullable enable
 class C
 {
     static void M(bool b)
@@ -2494,9 +2495,9 @@ static void M(bool b)
             false => () => s?.ToString()
         };
     }
-}
-", options: WithNullableEnable());
+}";
 
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular9);
             comp.VerifyDiagnostics(
                 // (9,21): error CS1660: Cannot convert lambda expression to type 'object' because it is not a delegate type
                 //             true => () => s.ToString(),
@@ -2506,8 +2507,13 @@ static void M(bool b)
                 Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "s").WithLocation(9, 27),
                 // (10,22): error CS1660: Cannot convert lambda expression to type 'object' because it is not a delegate type
                 //             false => () => s?.ToString()
-                Diagnostic(ErrorCode.ERR_AnonMethToNonDel, "() => s?.ToString()").WithArguments("lambda expression", "object").WithLocation(10, 22)
-            );
+                Diagnostic(ErrorCode.ERR_AnonMethToNonDel, "() => s?.ToString()").WithArguments("lambda expression", "object").WithLocation(10, 22));
+
+            comp = CreateCompilation(source);
+            comp.VerifyDiagnostics(
+                // (9,27): warning CS8602: Dereference of a possibly null reference.
+                //             true => () => s.ToString(),
+                Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "s").WithLocation(9, 27));
         }
 
         [Fact, WorkItem(51461, "https://github.com/dotnet/roslyn/issues/51461")]
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/OverloadResolutionTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/OverloadResolutionTests.cs
index 2c8266801e997..bee449e17e6dd 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/OverloadResolutionTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/OverloadResolutionTests.cs
@@ -384,7 +384,13 @@ static void Main()
   }
 }";
 
-            CompileAndVerify(source2, expectedOutput: @"2");
+            CompileAndVerify(source2, parseOptions: TestOptions.Regular9, expectedOutput: @"2");
+
+            var comp = CreateCompilation(source2);
+            comp.VerifyDiagnostics(
+                // (15,5): error CS0121: The call is ambiguous between the following methods or properties: 'P.M1(P.DA, object)' and 'P.M1(P.DB, int)'
+                //     M1(() => () => i, i);
+                Diagnostic(ErrorCode.ERR_AmbigCall, "M1").WithArguments("P.M1(P.DA, object)", "P.M1(P.DB, int)").WithLocation(15, 5));
         }
 
         [Fact]
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/PatternMatchingTests2.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/PatternMatchingTests2.cs
index 7879756d321d7..033eef3174986 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/PatternMatchingTests2.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/PatternMatchingTests2.cs
@@ -3045,5 +3045,525 @@ void F(object o)
                 Diagnostic(ErrorCode.ERR_PatternNullableType, "int?").WithArguments("int").WithLocation(7, 24)
                 );
         }
+
+        [Fact, WorkItem(55668, "https://github.com/dotnet/roslyn/issues/55668")]
+        public void SharedWhenExpression_SwitchExpression()
+        {
+            var source = @"
+int count = 0;
+foreach (var position in new[] { Position.First, Position.Last })
+{
+    foreach (var wrap in new[] { new Wrap { Sub = new Zero() }, new Wrap { Sub = new One() }, new Wrap { Sub = new Two() }, new Wrap { Sub = new object() } })
+    {
+        count++;
+        if (M(position, wrap) != M2(position, wrap))
+            throw null;
+    }
+}
+
+System.Console.Write(count);
+
+static string M(Position position, Wrap wrap)
+{
+    return position switch
+    {
+        not Position.First when wrap.Sub is Zero => ""Not First and Zero"",
+        _ when wrap is { Sub: One or Two } => ""One or Two"",
+        Position.First => ""First"",
+        _ => ""Other""
+    };
+}
+
+static string M2(Position position, Wrap wrap)
+{
+    if (position is not Position.First && wrap.Sub is Zero)
+        return ""Not First and Zero"";
+    if (wrap is { Sub: One or Two })
+        return ""One or Two"";
+    if (position is Position.First)
+        return ""First"";
+    return ""Other"";
+}
+
+enum Position
+{
+    First,
+    Last,
+}
+
+class Zero { }
+class One { }
+class Two { }
+
+class Wrap
+{
+    public object Sub;
+}
+";
+
+            CompileAndVerify(source, expectedOutput: "8");
+        }
+
+        [Fact, WorkItem(55668, "https://github.com/dotnet/roslyn/issues/55668")]
+        public void SharedWhenExpression_SwitchStatement()
+        {
+            var source = @"
+M(Position.Last, new Wrap { Sub = new Zero() });
+M(Position.Last, new Wrap { Sub = new One() });
+M(Position.Last, new Wrap { Sub = new Two() });
+M(Position.First, new Wrap { Sub = new Zero() });
+M(Position.Last, new Wrap { Sub = new object() });
+
+static void M(Position position, Wrap wrap)
+{
+    string text;
+    switch (position)
+    {
+        case not Position.First when wrap.Sub is Zero: text = ""Not First and Zero""; break;
+        case var _ when wrap is { Sub: One or Two }: text = ""One or Two""; break;
+        case Position.First: text = ""First""; break;
+        default: text = ""Other""; break;
+    }
+
+    System.Console.WriteLine((position, wrap.Sub, text));
+}
+
+enum Position
+{
+    First,
+    Last,
+}
+
+class Zero { }
+class One { }
+class Two { }
+
+class Wrap
+{
+    public object Sub;
+}
+";
+
+            CompileAndVerify(source, expectedOutput: @"
+(Last, Zero, Not First and Zero)
+(Last, One, One or Two)
+(Last, Two, One or Two)
+(First, Zero, First)
+(Last, System.Object, Other)");
+        }
+
+        [Fact, WorkItem(55668, "https://github.com/dotnet/roslyn/issues/55668")]
+        public void SharedWhenExpression_SequencePoints()
+        {
+            var source = @"
+C.M(0, false, false);
+C.M(0, true, false);
+C.M(0, false, true);
+C.M(1, false, false);
+C.M(1, false, true);
+C.M(2, false, false);
+
+public class C
+{
+    public static void M(int i, bool b1, bool b2)
+    {
+        string text;
+        switch (i)
+        {
+            case not 1 when b1:
+                text = ""b1"";
+                break;
+            case var _ when b2:
+                text = ""b2"";
+                break;
+            case 1:
+                text = ""1"";
+                break;
+            default:
+                text = ""default"";
+                break;
+        }
+
+        System.Console.WriteLine((i, b1, b2, text));
+    }
+}
+";
+
+            var verifier = CompileAndVerify(source, expectedOutput: @"
+(0, False, False, default)
+(0, True, False, b1)
+(0, False, True, b2)
+(1, False, False, 1)
+(1, False, True, b2)
+(2, False, False, default)
+");
+
+            verifier.VerifyIL("C.M", @"
+{
+  // Code size       73 (0x49)
+  .maxstack  4
+  .locals init (string V_0, //text
+                int V_1)
+  // sequence point: switch (i)
+  IL_0000:  ldarg.0
+  // sequence point: <hidden>
+  IL_0001:  ldc.i4.1
+  IL_0002:  beq.s      IL_000f
+  // sequence point: when b1
+  IL_0004:  ldarg.1
+  IL_0005:  brfalse.s  IL_0013
+  // sequence point: text = ""b1"";
+  IL_0007:  ldstr      ""b1""
+  IL_000c:  stloc.0
+  // sequence point: break;
+  IL_000d:  br.s       IL_0035
+  // sequence point: <hidden>
+  IL_000f:  ldc.i4.0
+  IL_0010:  stloc.1
+  IL_0011:  br.s       IL_0015
+  IL_0013:  ldc.i4.2
+  IL_0014:  stloc.1
+  // sequence point: when b2
+  IL_0015:  ldarg.2
+  IL_0016:  brtrue.s   IL_001f
+  // sequence point: <hidden>
+  IL_0018:  ldloc.1
+  IL_0019:  brfalse.s  IL_0027
+  IL_001b:  ldloc.1
+  IL_001c:  ldc.i4.2
+  IL_001d:  beq.s      IL_002f
+  // sequence point: text = ""b2"";
+  IL_001f:  ldstr      ""b2""
+  IL_0024:  stloc.0
+  // sequence point: break;
+  IL_0025:  br.s       IL_0035
+  // sequence point: text = ""1"";
+  IL_0027:  ldstr      ""1""
+  IL_002c:  stloc.0
+  // sequence point: break;
+  IL_002d:  br.s       IL_0035
+  // sequence point: text = ""default"";
+  IL_002f:  ldstr      ""default""
+  IL_0034:  stloc.0
+  // sequence point: System.Console.WriteLine((i, b1, b2, text));
+  IL_0035:  ldarg.0
+  IL_0036:  ldarg.1
+  IL_0037:  ldarg.2
+  IL_0038:  ldloc.0
+  IL_0039:  newobj     ""System.ValueTuple<int, bool, bool, string>..ctor(int, bool, bool, string)""
+  IL_003e:  box        ""System.ValueTuple<int, bool, bool, string>""
+  IL_0043:  call       ""void System.Console.WriteLine(object)""
+  // sequence point: }
+  IL_0048:  ret
+}
+", source: source, sequencePoints: "C.M");
+        }
+
+        [Fact, WorkItem(55668, "https://github.com/dotnet/roslyn/issues/55668")]
+        public void SharedWhenExpression_MissingInt32Type()
+        {
+            var source = @"
+class C
+{
+    static void M(string s, bool b1, bool b2)
+    {
+        switch (s)
+        {
+            case not ""one"" when b1:
+                break;
+            case var _ when b2:
+                break;
+            case ""one"":
+                break;
+            default:
+                break;
+        }
+    }
+}
+";
+            var comp = CreateCompilation(source);
+            comp.MakeTypeMissing(SpecialType.System_Int32);
+            comp.VerifyEmitDiagnostics(
+                // (6,9): error CS0518: Predefined type 'System.Int32' is not defined or imported
+                //         switch (s)
+                Diagnostic(ErrorCode.ERR_PredefinedTypeNotFound, @"switch (s)
+        {
+            case not ""one"" when b1:
+                break;
+            case var _ when b2:
+                break;
+            case ""one"":
+                break;
+            default:
+                break;
+        }").WithArguments("System.Int32").WithLocation(6, 9),
+                // (6,9): error CS0518: Predefined type 'System.Int32' is not defined or imported
+                //         switch (s)
+                Diagnostic(ErrorCode.ERR_PredefinedTypeNotFound, @"switch (s)
+        {
+            case not ""one"" when b1:
+                break;
+            case var _ when b2:
+                break;
+            case ""one"":
+                break;
+            default:
+                break;
+        }").WithArguments("System.Int32").WithLocation(6, 9),
+                // (8,13): error CS0518: Predefined type 'System.Int32' is not defined or imported
+                //             case not "one" when b1:
+                Diagnostic(ErrorCode.ERR_PredefinedTypeNotFound, @"case not ""one"" when b1:").WithArguments("System.Int32").WithLocation(8, 13)
+                );
+        }
+
+        [Fact, WorkItem(55668, "https://github.com/dotnet/roslyn/issues/55668")]
+        public void SharedWhenExpression_WithBindings()
+        {
+            var source = @"
+C.M(""Alice"", false, true);
+C.M(""Bob"", false, true);
+
+public class C
+{
+    public static void M(string s, bool b1, bool b2)
+    {
+        switch (s)
+        {
+            case not ""x"" when b1:
+                throw null;
+            case { Length: var j and > 2 } when b2:
+                System.Console.WriteLine((s, b1, b2, j.ToString()));
+                break;
+            case ""x"":
+                throw null;
+            default:
+                throw null;
+        }
+    }
+}
+";
+
+            var verifier = CompileAndVerify(source, expectedOutput: @"
+(Alice, False, True, 5)
+(Bob, False, True, 3)
+");
+
+            verifier.VerifyIL("C.M", @"
+{
+  // Code size       95 (0x5f)
+  .maxstack  4
+  .locals init (int V_0,
+                int V_1, //j
+                string V_2)
+  // sequence point: switch (s)
+  IL_0000:  ldarg.0
+  IL_0001:  stloc.2
+  // sequence point: <hidden>
+  IL_0002:  ldloc.2
+  IL_0003:  ldstr      ""x""
+  IL_0008:  call       ""bool string.op_Equality(string, string)""
+  IL_000d:  brfalse.s  IL_002c
+  IL_000f:  ldloc.2
+  IL_0010:  callvirt   ""int string.Length.get""
+  IL_0015:  stloc.1
+  // sequence point: <hidden>
+  IL_0016:  ldloc.1
+  IL_0017:  ldc.i4.2
+  IL_0018:  bgt.s      IL_0031
+  IL_001a:  br.s       IL_005b
+  IL_001c:  ldloc.2
+  IL_001d:  brfalse.s  IL_005d
+  IL_001f:  ldloc.2
+  IL_0020:  callvirt   ""int string.Length.get""
+  IL_0025:  stloc.1
+  // sequence point: <hidden>
+  IL_0026:  ldloc.1
+  IL_0027:  ldc.i4.2
+  IL_0028:  bgt.s      IL_0035
+  IL_002a:  br.s       IL_005d
+  // sequence point: when b1
+  IL_002c:  ldarg.1
+  IL_002d:  brfalse.s  IL_001c
+  // sequence point: throw null;
+  IL_002f:  ldnull
+  IL_0030:  throw
+  // sequence point: <hidden>
+  IL_0031:  ldc.i4.0
+  IL_0032:  stloc.0
+  IL_0033:  br.s       IL_0037
+  IL_0035:  ldc.i4.2
+  IL_0036:  stloc.0
+  // sequence point: when b2
+  IL_0037:  ldarg.2
+  IL_0038:  brtrue.s   IL_0041
+  // sequence point: <hidden>
+  IL_003a:  ldloc.0
+  IL_003b:  brfalse.s  IL_005b
+  IL_003d:  ldloc.0
+  IL_003e:  ldc.i4.2
+  IL_003f:  beq.s      IL_005d
+  // sequence point: System.Console.WriteLine((s, b1, b2, j.ToString()));
+  IL_0041:  ldarg.0
+  IL_0042:  ldarg.1
+  IL_0043:  ldarg.2
+  IL_0044:  ldloca.s   V_1
+  IL_0046:  call       ""string int.ToString()""
+  IL_004b:  newobj     ""System.ValueTuple<string, bool, bool, string>..ctor(string, bool, bool, string)""
+  IL_0050:  box        ""System.ValueTuple<string, bool, bool, string>""
+  IL_0055:  call       ""void System.Console.WriteLine(object)""
+  // sequence point: break;
+  IL_005a:  ret
+  // sequence point: throw null;
+  IL_005b:  ldnull
+  IL_005c:  throw
+  // sequence point: throw null;
+  IL_005d:  ldnull
+  IL_005e:  throw
+}
+", source: source, sequencePoints: "C.M");
+        }
+
+        [Fact, WorkItem(55668, "https://github.com/dotnet/roslyn/issues/55668")]
+        public void SharedWhenExpression_Multiples()
+        {
+            // The `b3` condition ends up in the `when` clause on four leaves in the DAG
+            // and `b1` ends up in two leaves
+            var source = @"
+int count = 0;
+
+foreach (int i1 in new[] { 0, 1 })
+    foreach (int i2 in new[] { 0, 1 })
+        foreach (int i3 in new[] { 0, 1 })
+            foreach (bool b0 in new[] { false, true })
+                foreach (bool b1 in new[] { false, true })
+                    foreach (bool b2 in new[] { false, true })
+                        foreach (bool b3 in new[] { false, true })
+                        {
+                            count++;
+                            if (M(i1, i2, i3, b0, b1, b2, b3) != M2(i1, i2, i3, b0, b1, b2, b3))
+                                throw null;
+                        }
+
+System.Console.Write(count);
+
+static string M(int i1, int i2, int i3, bool b0, bool b1, bool b2, bool b3)
+{
+    object o = null;
+    switch (i1, i2, i3)
+    {
+        case (var x, var y, var z) when f(x, y, z):
+            throw null;
+        case (not 0, 0, _) when b0:
+            return ""b0"";
+        case (_, not 0, 0) when b1:
+            return ""b1"";
+        case (0, _, not 0) when b2:
+            return ""b2"";
+        case (_, _, _) when b3:
+            return ""b3"";
+        case (0, _, _):
+            return ""first"";
+        case (_, 0, _):
+            return ""second"";
+        case (_, _, 0):
+            return ""third"";
+    }
+    return ""last"";
+}
+
+static string M2(int i1, int i2, int i3, bool b0, bool b1, bool b2, bool b3)
+{
+    if (i1 is not 0 && i2 is 0 && b0)
+        return ""b0"";
+    if (i2 is not 0 && i3 is 0 && b1)
+        return ""b1"";
+    if (i3 is not 0 && i1 is 0 && b2)
+        return ""b2"";
+    if (b3)
+        return ""b3"";
+    if (i1 is 0)
+        return ""first"";
+    if (i2 is 0)
+        return ""second"";
+    if (i3 is 0)
+        return ""third"";
+    return ""last"";
+}
+
+static bool f(int i1, int i2, int i3) => false;
+";
+
+            CompileAndVerify(source, expectedOutput: "128");
+        }
+
+        [Fact, WorkItem(55668, "https://github.com/dotnet/roslyn/issues/55668")]
+        public void SharedWhenExpression_Multiples_LabelInSharedWhenExpression()
+        {
+            var source = @"
+int count = 0;
+var wrap = new Wrap { value = null };
+
+foreach (int i1 in new[] { 0, 1 })
+    foreach (int i2 in new[] { 0, 1 })
+        foreach (int i3 in new[] { 0, 1 })
+            foreach (bool b0 in new[] { false, true })
+                foreach (bool b1 in new[] { false, true })
+                    foreach (bool b2 in new[] { false, true })
+                        foreach (bool b3 in new[] { false, true })
+                        {
+                            count++;
+                            if (M(i1, i2, i3, b0, b1, b2, b3) != M2(i1, i2, i3, b0, b1, b2, b3))
+                                throw null;
+                        }
+
+System.Console.Write(count);
+
+string M(int i1, int i2, int i3, bool b0, bool b1, bool b2, bool b3)
+{
+    switch (i1, i2, i3)
+    {
+        case (var x, var y, var z) when f(x, y, z):
+            throw null;
+        case (not 0, 0, _) when b0 && wrap is { value: string or string[] }:
+            throw null;
+        case (_, not 0, 0) when b1 && wrap is { value: string or string[] }:
+            throw null;
+        case (0, _, not 0) when b2 && wrap is { value: string or string[] }:
+            throw null;
+        case (_, _, _) when b3:
+            return ""b3"";
+        case (0, _, _):
+            return ""first"";
+        case (_, 0, _):
+            return ""second"";
+        case (_, _, 0):
+            return ""third"";
+    }
+    return ""last"";
+}
+
+static string M2(int i1, int i2, int i3, bool b0, bool b1, bool b2, bool b3)
+{
+    if (b3)
+        return ""b3"";
+    if (i1 is 0)
+        return ""first"";
+    if (i2 is 0)
+        return ""second"";
+    if (i3 is 0)
+        return ""third"";
+    return ""last"";
+}
+
+static bool f(int i1, int i2, int i3) => false;
+
+public class Wrap
+{
+    public object value;
+}
+";
+
+            CompileAndVerify(source, expectedOutput: "128");
+        }
     }
 }
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/PatternMatchingTests4.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/PatternMatchingTests4.cs
index b070426011afd..3498f0aea23b6 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/PatternMatchingTests4.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/PatternMatchingTests4.cs
@@ -87,12 +87,12 @@ public void M2<T>(T t)
     }
 }");
             comp.VerifyDiagnostics(
-                // (6,18): error CS0428: Cannot convert method group 'M1' to non-delegate type 'object'. Did you intend to invoke the method?
+                // (6,18): error CS0150: A constant value is expected
                 //         _ = o is M1;
-                Diagnostic(ErrorCode.ERR_MethGrpToNonDel, "M1").WithArguments("M1", "object").WithLocation(6, 18),
-                // (9,18): error CS0428: Cannot convert method group 'M1' to non-delegate type 'object'. Did you intend to invoke the method?
+                Diagnostic(ErrorCode.ERR_ConstantExpected, "M1").WithLocation(6, 18),
+                // (9,18): error CS0150: A constant value is expected
                 //             case M1:
-                Diagnostic(ErrorCode.ERR_MethGrpToNonDel, "M1").WithArguments("M1", "object").WithLocation(9, 18),
+                Diagnostic(ErrorCode.ERR_ConstantExpected, "M1").WithLocation(9, 18),
                 // (15,18): error CS0150: A constant value is expected
                 //         _ = t is M2;
                 Diagnostic(ErrorCode.ERR_ConstantExpected, "M2").WithLocation(15, 18),
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/SemanticErrorTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/SemanticErrorTests.cs
index 6dffd2daad663..78ee679ca5466 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/SemanticErrorTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/SemanticErrorTests.cs
@@ -3227,9 +3227,6 @@ void M()
                 // (11,21): error CS0122: 'Base.P' is inaccessible due to its protection level
                 //         object o = (P p) => 0;
                 Diagnostic(ErrorCode.ERR_BadAccess, "P").WithArguments("Base.P"),
-                // (11,20): error CS1660: Cannot convert lambda expression to type 'object' because it is not a delegate type
-                //         object o = (P p) => 0;
-                Diagnostic(ErrorCode.ERR_AnonMethToNonDel, "(P p) => 0").WithArguments("lambda expression", "object"),
                 // (12,17): error CS0122: 'Base.P' is inaccessible due to its protection level
                 //         int x = P.X;
                 Diagnostic(ErrorCode.ERR_BadAccess, "P").WithArguments("Base.P"),
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/StackAllocInitializerTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/StackAllocInitializerTests.cs
index b2848eeecb968..c139d0ac1a256 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/StackAllocInitializerTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/StackAllocInitializerTests.cs
@@ -133,6 +133,7 @@ public struct ValueTuple<T1, T2> {
 ", TestOptions.UnsafeReleaseDll);
 
             comp.VerifyDiagnostics(
+                // (7,28): error CS0246: The type or namespace name 'RefStruct' could not be found (are you missing a using directive or an assembly reference?)
                 //     void Method(dynamic d, RefStruct r)
                 Diagnostic(ErrorCode.ERR_SingleTypeNameNotFound, "RefStruct").WithArguments("RefStruct").WithLocation(7, 28),
                 // (9,18): error CS0826: No best type found for implicitly-typed array
@@ -150,9 +151,9 @@ public struct ValueTuple<T1, T2> {
                 // (13,18): error CS0826: No best type found for implicitly-typed array
                 //         var p4 = stackalloc[] { (1, null) };
                 Diagnostic(ErrorCode.ERR_ImplicitlyTypedArrayNoBestType, "stackalloc[] { (1, null) }").WithLocation(13, 18),
-                // (14,18): error CS0826: No best type found for implicitly-typed array
+                // (14,18): error CS0208: Cannot take the address of, get the size of, or declare a pointer to a managed type ('Action')
                 //         var p5 = stackalloc[] { () => { } };
-                Diagnostic(ErrorCode.ERR_ImplicitlyTypedArrayNoBestType, "stackalloc[] { () => { } }").WithLocation(14, 18),
+                Diagnostic(ErrorCode.ERR_ManagedAddr, "stackalloc[] { () => { } }").WithArguments("System.Action").WithLocation(14, 18),
                 // (15,18): error CS0826: No best type found for implicitly-typed array
                 //         var p6 = stackalloc[] { new {} , new { i = 0 } };
                 Diagnostic(ErrorCode.ERR_ImplicitlyTypedArrayNoBestType, "stackalloc[] { new {} , new { i = 0 } }").WithLocation(15, 18),
@@ -212,9 +213,9 @@ public struct ValueTuple<T1, T2> {
                 // (13,32): error CS0826: No best type found for implicitly-typed array
                 //         var p4 = c ? default : stackalloc[] { (1, null) };
                 Diagnostic(ErrorCode.ERR_ImplicitlyTypedArrayNoBestType, "stackalloc[] { (1, null) }").WithLocation(13, 32),
-                // (14,32): error CS0826: No best type found for implicitly-typed array
+                // (14,32): error CS0208: Cannot take the address of, get the size of, or declare a pointer to a managed type ('Action')
                 //         var p5 = c ? default : stackalloc[] { () => { } };
-                Diagnostic(ErrorCode.ERR_ImplicitlyTypedArrayNoBestType, "stackalloc[] { () => { } }").WithLocation(14, 32),
+                Diagnostic(ErrorCode.ERR_ManagedAddr, "stackalloc[] { () => { } }").WithArguments("System.Action").WithLocation(14, 32),
                 // (15,32): error CS0826: No best type found for implicitly-typed array
                 //         var p6 = c ? default : stackalloc[] { new {} , new { i = 0 } };
                 Diagnostic(ErrorCode.ERR_ImplicitlyTypedArrayNoBestType, "stackalloc[] { new {} , new { i = 0 } }").WithLocation(15, 32),
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/UseSiteErrorTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/UseSiteErrorTests.cs
index 859abad6d7223..eff9158c26ef9 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/UseSiteErrorTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/UseSiteErrorTests.cs
@@ -934,28 +934,27 @@ public static void bar2(int p)
 
             var delegatesWithoutInvokeReference = TestReferences.SymbolsTests.DelegateImplementation.DelegatesWithoutInvoke;
             CreateCompilation(text, new MetadataReference[] { delegatesWithoutInvokeReference }).VerifyDiagnostics(
-                // (7,16): error CS7023: Delegate 'DelegateWithoutInvoke.DelegateGenericFunctionWithoutInvoke<T>' has no invoke method or an invoke method with a return type or parameter types that are not supported.
+                // (7,16): error CS7024: Delegate 'DelegateWithoutInvoke.DelegateGenericFunctionWithoutInvoke<T>' has no invoke method or an invoke method with a return type or parameter types that are not supported.
                 //         return del("goo"); // will show ERR_InvalidDelegateType instead of ERR_NoSuchMemberOrExtension
-                Diagnostic(ErrorCode.ERR_InvalidDelegateType, @"del(""goo"")").WithArguments("DelegateWithoutInvoke.DelegateGenericFunctionWithoutInvoke<T>"),
-                // (13,70): error CS7023: Delegate 'DelegateWithoutInvoke.DelegateSubWithoutInvoke' has no invoke method or an invoke method with a return type or parameter types that are not supported.
+                Diagnostic(ErrorCode.ERR_InvalidDelegateType, @"del(""goo"")").WithArguments("DelegateWithoutInvoke.DelegateGenericFunctionWithoutInvoke<T>").WithLocation(7, 16),
+                // (13,70): error CS7024: Delegate 'DelegateWithoutInvoke.DelegateSubWithoutInvoke' has no invoke method or an invoke method with a return type or parameter types that are not supported.
                 //         DelegateWithoutInvoke.DelegateSubWithoutInvoke myDelegate1 = bar;
-                Diagnostic(ErrorCode.ERR_InvalidDelegateType, "bar").WithArguments("DelegateWithoutInvoke.DelegateSubWithoutInvoke"),
-                // (14,21): error CS1061: 'DelegateWithoutInvoke.DelegateSubWithoutInvoke' does not contain a definition for 'Invoke' and no extension method 'Invoke' accepting a first argument of type 'DelegateWithoutInvoke.DelegateSubWithoutInvoke' could be found (are you missing a using directive or an assembly reference?)
+                Diagnostic(ErrorCode.ERR_InvalidDelegateType, "bar").WithArguments("DelegateWithoutInvoke.DelegateSubWithoutInvoke").WithLocation(13, 70),
+                // (14,21): error CS1061: 'DelegateWithoutInvoke.DelegateSubWithoutInvoke' does not contain a definition for 'Invoke' and no accessible extension method 'Invoke' accepting a first argument of type 'DelegateWithoutInvoke.DelegateSubWithoutInvoke' could be found (are you missing a using directive or an assembly reference?)
                 //         myDelegate1.Invoke("goo"); // will show an ERR_NoSuchMemberOrExtension
-                Diagnostic(ErrorCode.ERR_NoSuchMemberOrExtension, "Invoke").WithArguments("DelegateWithoutInvoke.DelegateSubWithoutInvoke", "Invoke"),
-                // (15,70): error CS7023: Delegate 'DelegateWithoutInvoke.DelegateSubWithoutInvoke' has no invoke method or an invoke method with a return type or parameter types that are not supported.
+                Diagnostic(ErrorCode.ERR_NoSuchMemberOrExtension, "Invoke").WithArguments("DelegateWithoutInvoke.DelegateSubWithoutInvoke", "Invoke").WithLocation(14, 21),
+                // (15,70): error CS7024: Delegate 'DelegateWithoutInvoke.DelegateSubWithoutInvoke' has no invoke method or an invoke method with a return type or parameter types that are not supported.
                 //         DelegateWithoutInvoke.DelegateSubWithoutInvoke myDelegate2 = new DelegateWithoutInvoke.DelegateSubWithoutInvoke(myDelegate1);
-                Diagnostic(ErrorCode.ERR_InvalidDelegateType, "new DelegateWithoutInvoke.DelegateSubWithoutInvoke(myDelegate1)").WithArguments("DelegateWithoutInvoke.DelegateSubWithoutInvoke"),
-                // (16,30): error CS7023: Delegate 'DelegateWithoutInvoke.DelegateSubWithoutInvoke' has no invoke method or an invoke method with a return type or parameter types that are not supported.
+                Diagnostic(ErrorCode.ERR_InvalidDelegateType, "new DelegateWithoutInvoke.DelegateSubWithoutInvoke(myDelegate1)").WithArguments("DelegateWithoutInvoke.DelegateSubWithoutInvoke").WithLocation(15, 70),
+                // (16,30): error CS7024: Delegate 'DelegateWithoutInvoke.DelegateSubWithoutInvoke' has no invoke method or an invoke method with a return type or parameter types that are not supported.
                 //         object myDelegate3 = new DelegateWithoutInvoke.DelegateSubWithoutInvoke(bar2);
-                Diagnostic(ErrorCode.ERR_InvalidDelegateType, "new DelegateWithoutInvoke.DelegateSubWithoutInvoke(bar2)").WithArguments("DelegateWithoutInvoke.DelegateSubWithoutInvoke"),
-                // (17,70): error CS7023: Delegate 'DelegateWithoutInvoke.DelegateSubWithoutInvoke' has no invoke method or an invoke method with a return type or parameter types that are not supported.
+                Diagnostic(ErrorCode.ERR_InvalidDelegateType, "new DelegateWithoutInvoke.DelegateSubWithoutInvoke(bar2)").WithArguments("DelegateWithoutInvoke.DelegateSubWithoutInvoke").WithLocation(16, 30),
+                // (17,70): error CS7024: Delegate 'DelegateWithoutInvoke.DelegateSubWithoutInvoke' has no invoke method or an invoke method with a return type or parameter types that are not supported.
                 //         DelegateWithoutInvoke.DelegateSubWithoutInvoke myDelegate4 = x => System.Console.WriteLine("Hello World");
-                Diagnostic(ErrorCode.ERR_InvalidDelegateType, @"x => System.Console.WriteLine(""Hello World"")").WithArguments("DelegateWithoutInvoke.DelegateSubWithoutInvoke"),
-                // (18,87): error CS7023: Delegate 'DelegateWithoutInvoke.DelegateFunctionWithoutInvoke' has no invoke method or an invoke method with a return type or parameter types that are not supported.
+                Diagnostic(ErrorCode.ERR_InvalidDelegateType, @"x => System.Console.WriteLine(""Hello World"")").WithArguments("DelegateWithoutInvoke.DelegateSubWithoutInvoke").WithLocation(17, 70),
+                // (18,87): error CS7024: Delegate 'DelegateWithoutInvoke.DelegateFunctionWithoutInvoke' has no invoke method or an invoke method with a return type or parameter types that are not supported.
                 //         object myDelegate6 = new DelegateWithoutInvoke.DelegateFunctionWithoutInvoke( x => "Hello World");
-                Diagnostic(ErrorCode.ERR_InvalidDelegateType, @"x => ""Hello World""").WithArguments("DelegateWithoutInvoke.DelegateFunctionWithoutInvoke")
-            );
+                Diagnostic(ErrorCode.ERR_InvalidDelegateType, @"x => ""Hello World""").WithArguments("DelegateWithoutInvoke.DelegateFunctionWithoutInvoke").WithLocation(18, 87));
         }
 
         [Fact]
@@ -964,11 +963,14 @@ public void TestDelegatesWithUseSiteErrors()
             var text =
 @"class C 
 {
+
+
     public static T goo<T>(CSharpErrors.DelegateParameterType3<T> del)
     {
         return del.Invoke(""goo"");
     }
 
+
     public static void Main() 
     {
         CSharpErrors.DelegateReturnType1 myDelegate1 = bar;
@@ -993,28 +995,27 @@ public static void bar2(int p)
             var csharpAssemblyReference = TestReferences.SymbolsTests.UseSiteErrors.CSharp;
             var ilAssemblyReference = TestReferences.SymbolsTests.UseSiteErrors.IL;
             CreateCompilation(text, new MetadataReference[] { csharpAssemblyReference, ilAssemblyReference }).VerifyDiagnostics(
-                // (5,16): error CS0012: The type 'UnavailableClass<>' is defined in an assembly that is not referenced. You must add a reference to assembly 'Unavailable, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null'.
+                // (7,16): error CS0012: The type 'UnavailableClass<>' is defined in an assembly that is not referenced. You must add a reference to assembly 'Unavailable, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null'.
                 //         return del.Invoke("goo");
-                Diagnostic(ErrorCode.ERR_NoTypeDef, "del.Invoke").WithArguments("UnavailableClass<>", "Unavailable, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null"),
+                Diagnostic(ErrorCode.ERR_NoTypeDef, "del.Invoke").WithArguments("UnavailableClass<>", "Unavailable, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null").WithLocation(7, 16),
                 // (13,56): error CS0012: The type 'UnavailableClass' is defined in an assembly that is not referenced. You must add a reference to assembly 'Unavailable, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null'.
                 //         CSharpErrors.DelegateReturnType1 myDelegate1 = bar;
-                Diagnostic(ErrorCode.ERR_NoTypeDef, "bar").WithArguments("UnavailableClass", "Unavailable, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null"),
+                Diagnostic(ErrorCode.ERR_NoTypeDef, "bar").WithArguments("UnavailableClass", "Unavailable, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null").WithLocation(13, 56),
                 // (14,9): error CS0012: The type 'UnavailableClass' is defined in an assembly that is not referenced. You must add a reference to assembly 'Unavailable, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null'.
                 //         myDelegate1("goo");
-                Diagnostic(ErrorCode.ERR_NoTypeDef, @"myDelegate1(""goo"")").WithArguments("UnavailableClass", "Unavailable, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null"),
+                Diagnostic(ErrorCode.ERR_NoTypeDef, @"myDelegate1(""goo"")").WithArguments("UnavailableClass", "Unavailable, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null").WithLocation(14, 9),
                 // (15,56): error CS0012: The type 'UnavailableClass' is defined in an assembly that is not referenced. You must add a reference to assembly 'Unavailable, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null'.
                 //         CSharpErrors.DelegateReturnType1 myDelegate2 = new CSharpErrors.DelegateReturnType1(myDelegate1);
-                Diagnostic(ErrorCode.ERR_NoTypeDef, "new CSharpErrors.DelegateReturnType1(myDelegate1)").WithArguments("UnavailableClass", "Unavailable, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null"),
+                Diagnostic(ErrorCode.ERR_NoTypeDef, "new CSharpErrors.DelegateReturnType1(myDelegate1)").WithArguments("UnavailableClass", "Unavailable, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null").WithLocation(15, 56),
                 // (16,30): error CS0012: The type 'UnavailableClass' is defined in an assembly that is not referenced. You must add a reference to assembly 'Unavailable, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null'.
                 //         object myDelegate3 = new CSharpErrors.DelegateReturnType1(bar);
-                Diagnostic(ErrorCode.ERR_NoTypeDef, "new CSharpErrors.DelegateReturnType1(bar)").WithArguments("UnavailableClass", "Unavailable, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null"),
+                Diagnostic(ErrorCode.ERR_NoTypeDef, "new CSharpErrors.DelegateReturnType1(bar)").WithArguments("UnavailableClass", "Unavailable, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null").WithLocation(16, 30),
                 // (17,56): error CS0012: The type 'UnavailableClass' is defined in an assembly that is not referenced. You must add a reference to assembly 'Unavailable, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null'.
                 //         CSharpErrors.DelegateReturnType1 myDelegate4 = x => System.Console.WriteLine("Hello World");
-                Diagnostic(ErrorCode.ERR_NoTypeDef, @"x => System.Console.WriteLine(""Hello World"")").WithArguments("UnavailableClass", "Unavailable, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null"),
+                Diagnostic(ErrorCode.ERR_NoTypeDef, @"x => System.Console.WriteLine(""Hello World"")").WithArguments("UnavailableClass", "Unavailable, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null").WithLocation(17, 56),
                 // (18,68): error CS0012: The type 'UnavailableClass' is defined in an assembly that is not referenced. You must add a reference to assembly 'Unavailable, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null'.
                 //         object myDelegate6 = new CSharpErrors.DelegateReturnType1( x => "Hello World");
-                Diagnostic(ErrorCode.ERR_NoTypeDef, @"x => ""Hello World""").WithArguments("UnavailableClass", "Unavailable, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null")
-                );
+                Diagnostic(ErrorCode.ERR_NoTypeDef, @"x => ""Hello World""").WithArguments("UnavailableClass", "Unavailable, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null").WithLocation(18, 68));
         }
 
         [Fact, WorkItem(531090, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/531090")]
diff --git a/src/Compilers/CSharp/Test/Semantic/SourceGeneration/GeneratorDriverTests.cs b/src/Compilers/CSharp/Test/Semantic/SourceGeneration/GeneratorDriverTests.cs
index 7f6821745ce04..abc660f38e4aa 100644
--- a/src/Compilers/CSharp/Test/Semantic/SourceGeneration/GeneratorDriverTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/SourceGeneration/GeneratorDriverTests.cs
@@ -2037,7 +2037,48 @@ class C { }
 
                 bool isTextForKind(GeneratedSourceResult s) => s.HintName == Enum.GetName(typeof(IncrementalGeneratorOutputKind), kind) + ".cs";
             }
+        }
+
+        [Fact]
+        public void Metadata_References_Provider()
+        {
+            var source = @"
+class C { }
+";
+            var parseOptions = TestOptions.RegularPreview;
+            var metadataRefs = new[] {
+                MetadataReference.CreateFromAssemblyInternal(this.GetType().Assembly),
+                MetadataReference.CreateFromAssemblyInternal(typeof(object).Assembly)
+            };
+            Compilation compilation = CreateEmptyCompilation(source, options: TestOptions.DebugDll, parseOptions: parseOptions, references: metadataRefs);
+            compilation.VerifyDiagnostics();
+            Assert.Single(compilation.SyntaxTrees);
+
+            List<string?> referenceList = new List<string?>();
 
+            var generator = new IncrementalGeneratorWrapper(new PipelineCallbackGenerator(ctx =>
+            {
+                ctx.RegisterSourceOutput(ctx.MetadataReferencesProvider, (spc, r) => { referenceList.Add(r.Display); });
+            }));
+
+            GeneratorDriver driver = CSharpGeneratorDriver.Create(new ISourceGenerator[] { generator }, parseOptions: parseOptions);
+            driver = driver.RunGenerators(compilation);
+            Assert.Equal(referenceList[0], metadataRefs[0].Display);
+            Assert.Equal(referenceList[1], metadataRefs[1].Display);
+
+            // re-run and check we didn't see anything new
+            referenceList.Clear();
+
+            driver = driver.RunGenerators(compilation);
+            Assert.Empty(referenceList);
+
+            // Modify the reference
+            var modifiedRef = metadataRefs[0].WithAliases(new[] { "Alias " });
+            metadataRefs[0] = modifiedRef;
+            compilation = compilation.WithReferences(metadataRefs);
+
+            driver = driver.RunGenerators(compilation);
+            Assert.Single(referenceList, modifiedRef.Display);
         }
     }
 }
diff --git a/src/Compilers/CSharp/Test/Symbol/Compilation/SemanticModelGetSemanticInfoTests.cs b/src/Compilers/CSharp/Test/Symbol/Compilation/SemanticModelGetSemanticInfoTests.cs
index 9a2c825f671bf..a844a058a5fc0 100644
--- a/src/Compilers/CSharp/Test/Symbol/Compilation/SemanticModelGetSemanticInfoTests.cs
+++ b/src/Compilers/CSharp/Test/Symbol/Compilation/SemanticModelGetSemanticInfoTests.cs
@@ -5630,7 +5630,7 @@ static int Main()
     }
 }
 ";
-            var semanticInfo = GetSemanticInfoForTest<ExpressionSyntax>(text);
+            var semanticInfo = GetSemanticInfoForTest<ExpressionSyntax>(text, parseOptions: TestOptions.Regular9);
             Assert.NotNull(semanticInfo);
             Assert.Null(semanticInfo.Type);
             Assert.Equal(SymbolKind.Method, semanticInfo.Symbol.Kind);
diff --git a/src/Compilers/CSharp/Test/Symbol/Symbols/ExtensionMethodTests.cs b/src/Compilers/CSharp/Test/Symbol/Symbols/ExtensionMethodTests.cs
index 2a7eda482e594..1f8542a22c1cc 100644
--- a/src/Compilers/CSharp/Test/Symbol/Symbols/ExtensionMethodTests.cs
+++ b/src/Compilers/CSharp/Test/Symbol/Symbols/ExtensionMethodTests.cs
@@ -1436,10 +1436,14 @@ static class S
 {
     internal static void E(this object o) { }
 }";
-            var compilation = CreateCompilation(source);
+
+            var compilation = CreateCompilation(source, parseOptions: TestOptions.Regular9);
             compilation.VerifyDiagnostics(
                 // (5,18): error CS0428: Cannot convert method group 'E' to non-delegate type 'object'. Did you intend to invoke the method?
                 Diagnostic(ErrorCode.ERR_MethGrpToNonDel, "E").WithArguments("E", "object").WithLocation(5, 18));
+
+            compilation = CreateCompilation(source);
+            compilation.VerifyDiagnostics();
         }
 
         [Fact]
diff --git a/src/Compilers/CSharp/Test/Symbol/Symbols/Source/DelegateTests.cs b/src/Compilers/CSharp/Test/Symbol/Symbols/Source/DelegateTests.cs
index ee273f95b51db..3272fbc03002f 100644
--- a/src/Compilers/CSharp/Test/Symbol/Symbols/Source/DelegateTests.cs
+++ b/src/Compilers/CSharp/Test/Symbol/Symbols/Source/DelegateTests.cs
@@ -317,9 +317,12 @@ static void Main()
   }
 }
 ";
-            CreateCompilation(text).VerifyDiagnostics(
+
+            CreateCompilation(text, parseOptions: TestOptions.Regular9).VerifyDiagnostics(
                 // (7,27): error CS0428: Cannot convert method group 'Main' to non-delegate type 'System.MulticastDelegate'. Did you intend to invoke the method?
                 Diagnostic(ErrorCode.ERR_MethGrpToNonDel, "Main").WithArguments("Main", "System.MulticastDelegate"));
+
+            CreateCompilation(text).VerifyDiagnostics();
         }
 
         [WorkItem(538706, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/538706")]
diff --git a/src/Compilers/CSharp/Test/Symbol/Symbols/Source/PropertyTests.cs b/src/Compilers/CSharp/Test/Symbol/Symbols/Source/PropertyTests.cs
index 9d79c9a48db7a..3bd41611340a8 100644
--- a/src/Compilers/CSharp/Test/Symbol/Symbols/Source/PropertyTests.cs
+++ b/src/Compilers/CSharp/Test/Symbol/Symbols/Source/PropertyTests.cs
@@ -2041,11 +2041,7 @@ static void M(B2 b)
     }
 }";
             var compilation3 = CreateCompilation(source3, new[] { reference1 });
-            compilation3.VerifyDiagnostics(
-                // (6,16): error CS0428: Cannot convert method group 'P' to non-delegate type 'object'. Did you intend to invoke the method?
-                Diagnostic(ErrorCode.ERR_MethGrpToNonDel, "P").WithArguments("P", "object").WithLocation(6, 16),
-                // (8,15): error CS0428: Cannot convert method group 'Q' to non-delegate type 'object'. Did you intend to invoke the method?
-                Diagnostic(ErrorCode.ERR_MethGrpToNonDel, "Q").WithArguments("Q", "object").WithLocation(8, 15));
+            compilation3.VerifyDiagnostics();
         }
 
         [ClrOnlyFact]
@@ -2097,9 +2093,7 @@ static class E
     internal static object P(this object o) { return null; }
 }";
             var compilation3 = CreateCompilationWithMscorlib40AndSystemCore(source3, new[] { reference1 });
-            compilation3.VerifyDiagnostics(
-                // (6,15): error CS0428: Cannot convert method group 'P' to non-delegate type 'object'. Did you intend to invoke the method?
-                Diagnostic(ErrorCode.ERR_MethGrpToNonDel, "P").WithArguments("P", "object").WithLocation(6, 15));
+            compilation3.VerifyDiagnostics();
         }
 
         [ClrOnlyFact]
diff --git a/src/Compilers/Core/Portable/Collections/BitVector.cs b/src/Compilers/Core/Portable/Collections/BitVector.cs
index 29a300741541d..7dfb863986580 100644
--- a/src/Compilers/Core/Portable/Collections/BitVector.cs
+++ b/src/Compilers/Core/Portable/Collections/BitVector.cs
@@ -151,6 +151,11 @@ public IEnumerable<int> TrueBits()
             }
         }
 
+        public static BitVector FromWords(Word bits0, Word[] bits, int capacity)
+        {
+            return new BitVector(bits0, bits, capacity);
+        }
+
         /// <summary>
         /// Create BitArray with at least the specified number of bits.
         /// </summary>
diff --git a/src/Compilers/Core/Portable/CommandLine/CommonCompiler.cs b/src/Compilers/Core/Portable/CommandLine/CommonCompiler.cs
index 11c8a1220ab40..d18b3650e8e89 100644
--- a/src/Compilers/Core/Portable/CommandLine/CommonCompiler.cs
+++ b/src/Compilers/Core/Portable/CommandLine/CommonCompiler.cs
@@ -72,6 +72,7 @@ internal abstract partial class CommonCompiler
         public CommonMessageProvider MessageProvider { get; }
         public CommandLineArguments Arguments { get; }
         public IAnalyzerAssemblyLoader AssemblyLoader { get; private set; }
+        public GeneratorDriverCache? GeneratorDriverCache { get; }
         public abstract DiagnosticFormatter DiagnosticFormatter { get; }
 
         /// <summary>
@@ -116,7 +117,7 @@ protected abstract void ResolveAnalyzersFromArguments(
             out ImmutableArray<DiagnosticAnalyzer> analyzers,
             out ImmutableArray<ISourceGenerator> generators);
 
-        public CommonCompiler(CommandLineParser parser, string? responseFile, string[] args, BuildPaths buildPaths, string? additionalReferenceDirectories, IAnalyzerAssemblyLoader assemblyLoader)
+        public CommonCompiler(CommandLineParser parser, string? responseFile, string[] args, BuildPaths buildPaths, string? additionalReferenceDirectories, IAnalyzerAssemblyLoader assemblyLoader, GeneratorDriverCache? driverCache)
         {
             IEnumerable<string> allArgs = args;
 
@@ -129,6 +130,7 @@ public CommonCompiler(CommandLineParser parser, string? responseFile, string[] a
             this.Arguments = parser.Parse(allArgs, buildPaths.WorkingDirectory, buildPaths.SdkDirectory, additionalReferenceDirectories);
             this.MessageProvider = parser.MessageProvider;
             this.AssemblyLoader = assemblyLoader;
+            this.GeneratorDriverCache = driverCache;
             this.EmbeddedSourcePaths = GetEmbeddedSourcePaths(Arguments);
 
             if (Arguments.ParseOptions.Features.ContainsKey("debug-determinism"))
@@ -734,7 +736,52 @@ public virtual int Run(TextWriter consoleOutput, CancellationToken cancellationT
         /// <param name="additionalTexts">Any additional texts that should be passed to the generators when run.</param>
         /// <param name="generatorDiagnostics">Any diagnostics that were produced during generation</param>
         /// <returns>A compilation that represents the original compilation with any additional, generated texts added to it.</returns>
-        private protected virtual Compilation RunGenerators(Compilation input, ParseOptions parseOptions, ImmutableArray<ISourceGenerator> generators, AnalyzerConfigOptionsProvider analyzerConfigOptionsProvider, ImmutableArray<AdditionalText> additionalTexts, DiagnosticBag generatorDiagnostics) { return input; }
+        private protected Compilation RunGenerators(Compilation input, ParseOptions parseOptions, ImmutableArray<ISourceGenerator> generators, AnalyzerConfigOptionsProvider analyzerConfigOptionsProvider, ImmutableArray<AdditionalText> additionalTexts, DiagnosticBag generatorDiagnostics)
+        {
+            GeneratorDriver? driver = null;
+            string cacheKey = string.Empty;
+            bool disableCache = Arguments.ParseOptions.Features.ContainsKey("disable-generator-cache") || string.IsNullOrWhiteSpace(Arguments.OutputFileName);
+            if (this.GeneratorDriverCache is object && !disableCache)
+            {
+                cacheKey = deriveCacheKey();
+                driver = this.GeneratorDriverCache.TryGetDriver(cacheKey);
+            }
+
+            driver ??= CreateGeneratorDriver(parseOptions, generators, analyzerConfigOptionsProvider, additionalTexts);
+            driver = driver.RunGeneratorsAndUpdateCompilation(input, out var compilationOut, out var diagnostics);
+            generatorDiagnostics.AddRange(diagnostics);
+
+            if (!disableCache)
+            {
+                this.GeneratorDriverCache?.CacheGenerator(cacheKey, driver);
+            }
+            return compilationOut;
+
+            string deriveCacheKey()
+            {
+                Debug.Assert(!string.IsNullOrWhiteSpace(Arguments.OutputFileName));
+
+                // CONSIDER: The only piece of the cache key that is required for correctness is the generators that were used.
+                //           We set up the graph statically based on the generators, so as long as the generator inputs haven't
+                //           changed we can technically run any project against another's cache and still get the correct results.
+                //           Obviously that would remove the point of the cache, so we also key off of the output file name
+                //           and output path so that collisions are unlikely and we'll usually get the correct cache for any 
+                //           given compilation. 
+
+                PooledStringBuilder sb = PooledStringBuilder.GetInstance();
+                sb.Builder.Append(Arguments.GetOutputFilePath(Arguments.OutputFileName));
+                foreach (var generator in generators)
+                {
+                    // append the generator FQN and the MVID of the assembly it came from, so any changes will invalidate the cache
+                    var type = generator.GetGeneratorType();
+                    sb.Builder.Append(type.AssemblyQualifiedName);
+                    sb.Builder.Append(type.Assembly.ManifestModule.ModuleVersionId.ToString());
+                }
+                return sb.ToStringAndFree();
+            }
+        }
+
+        private protected abstract GeneratorDriver CreateGeneratorDriver(ParseOptions parseOptions, ImmutableArray<ISourceGenerator> generators, AnalyzerConfigOptionsProvider analyzerConfigOptionsProvider, ImmutableArray<AdditionalText> additionalTexts);
 
         private int RunCore(TextWriter consoleOutput, ErrorLogger? errorLogger, CancellationToken cancellationToken)
         {
diff --git a/src/Compilers/Core/Portable/Emit/EditAndContinue/DeltaMetadataWriter.cs b/src/Compilers/Core/Portable/Emit/EditAndContinue/DeltaMetadataWriter.cs
index febd45638f2c1..69244750636ea 100644
--- a/src/Compilers/Core/Portable/Emit/EditAndContinue/DeltaMetadataWriter.cs
+++ b/src/Compilers/Core/Portable/Emit/EditAndContinue/DeltaMetadataWriter.cs
@@ -217,6 +217,7 @@ 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(),
                 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 fa7809a16fb33..6f5560169c21d 100644
--- a/src/Compilers/Core/Portable/Emit/EditAndContinue/EmitBaseline.cs
+++ b/src/Compilers/Core/Portable/Emit/EditAndContinue/EmitBaseline.cs
@@ -65,6 +65,8 @@ internal sealed class MetadataSymbols
         {
             public readonly IReadOnlyDictionary<AnonymousTypeKey, AnonymousTypeValue> AnonymousTypes;
 
+            public readonly IReadOnlyDictionary<SynthesizedDelegateKey, SynthesizedDelegateValue> SynthesizedDelegates;
+
             /// <summary>
             /// A map of the assembly identities of the baseline compilation to the identities of the original metadata AssemblyRefs.
             /// Only includes identities that differ between these two.
@@ -73,13 +75,19 @@ internal sealed class MetadataSymbols
 
             public readonly object MetadataDecoder;
 
-            public MetadataSymbols(IReadOnlyDictionary<AnonymousTypeKey, AnonymousTypeValue> anonymousTypes, object metadataDecoder, ImmutableDictionary<AssemblyIdentity, AssemblyIdentity> assemblyReferenceIdentityMap)
+            public MetadataSymbols(
+                IReadOnlyDictionary<AnonymousTypeKey, AnonymousTypeValue> anonymousTypes,
+                IReadOnlyDictionary<SynthesizedDelegateKey, SynthesizedDelegateValue> synthesizedDelegates,
+                object metadataDecoder,
+                ImmutableDictionary<AssemblyIdentity, AssemblyIdentity> assemblyReferenceIdentityMap)
             {
                 Debug.Assert(anonymousTypes != null);
+                Debug.Assert(synthesizedDelegates != null);
                 Debug.Assert(metadataDecoder != null);
                 Debug.Assert(assemblyReferenceIdentityMap != null);
 
                 this.AnonymousTypes = anonymousTypes;
+                this.SynthesizedDelegates = synthesizedDelegates;
                 this.MetadataDecoder = metadataDecoder;
                 this.AssemblyReferenceIdentityMap = assemblyReferenceIdentityMap;
             }
@@ -221,6 +229,7 @@ public static EmitBaseline CreateInitialBaseline(
                 userStringStreamLengthAdded: 0,
                 guidStreamLengthAdded: 0,
                 anonymousTypeMap: null, // Unset for initial metadata
+                synthesizedDelegates: null, // Unset for initial metadata
                 synthesizedMembers: ImmutableDictionary<ISymbolInternal, ImmutableArray<ISymbolInternal>>.Empty,
                 methodsAddedOrChanged: new Dictionary<int, AddedOrChangedMethodInfo>(),
                 debugInformationProvider: debugInformationProvider,
@@ -308,6 +317,7 @@ 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;
         internal readonly ImmutableDictionary<ISymbolInternal, ImmutableArray<ISymbolInternal>> SynthesizedMembers;
 
         private EmitBaseline(
@@ -336,6 +346,7 @@ private EmitBaseline(
             int userStringStreamLengthAdded,
             int guidStreamLengthAdded,
             IReadOnlyDictionary<AnonymousTypeKey, AnonymousTypeValue>? anonymousTypeMap,
+            IReadOnlyDictionary<SynthesizedDelegateKey, SynthesizedDelegateValue>? synthesizedDelegates,
             ImmutableDictionary<ISymbolInternal, ImmutableArray<ISymbolInternal>> synthesizedMembers,
             IReadOnlyDictionary<int, AddedOrChangedMethodInfo> methodsAddedOrChanged,
             Func<MethodDefinitionHandle, EditAndContinueMethodDebugInformation> debugInformationProvider,
@@ -348,6 +359,7 @@ 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(encId != module.GetModuleVersionId());
             Debug.Assert(debugInformationProvider != null);
             Debug.Assert(localSignatureProvider != null);
@@ -399,6 +411,7 @@ private EmitBaseline(
             UserStringStreamLengthAdded = userStringStreamLengthAdded;
             GuidStreamLengthAdded = guidStreamLengthAdded;
             _anonymousTypeMap = anonymousTypeMap;
+            _synthesizedDelegates = synthesizedDelegates;
             SynthesizedMembers = synthesizedMembers;
             AddedOrChangedMethods = methodsAddedOrChanged;
 
@@ -432,6 +445,7 @@ internal EmitBaseline With(
             int userStringStreamLengthAdded,
             int guidStreamLengthAdded,
             IReadOnlyDictionary<AnonymousTypeKey, AnonymousTypeValue> anonymousTypeMap,
+            IReadOnlyDictionary<SynthesizedDelegateKey, SynthesizedDelegateValue> synthesizedDelegates,
             ImmutableDictionary<ISymbolInternal, ImmutableArray<ISymbolInternal>> synthesizedMembers,
             IReadOnlyDictionary<int, AddedOrChangedMethodInfo> addedOrChangedMethods,
             Func<MethodDefinitionHandle, EditAndContinueMethodDebugInformation> debugInformationProvider,
@@ -440,6 +454,9 @@ 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);
+
             return new EmitBaseline(
                 InitialBaseline,
                 OriginalMetadata,
@@ -466,6 +483,7 @@ internal EmitBaseline With(
                 userStringStreamLengthAdded: userStringStreamLengthAdded,
                 guidStreamLengthAdded: guidStreamLengthAdded,
                 anonymousTypeMap: anonymousTypeMap,
+                synthesizedDelegates: synthesizedDelegates,
                 synthesizedMembers: synthesizedMembers,
                 methodsAddedOrChanged: addedOrChangedMethods,
                 debugInformationProvider: debugInformationProvider,
@@ -490,6 +508,21 @@ internal IReadOnlyDictionary<AnonymousTypeKey, AnonymousTypeValue> AnonymousType
             }
         }
 
+        internal IReadOnlyDictionary<SynthesizedDelegateKey, SynthesizedDelegateValue> SynthesizedDelegates
+        {
+            get
+            {
+                if (Ordinal > 0)
+                {
+                    Debug.Assert(_synthesizedDelegates is not null);
+                    return _synthesizedDelegates;
+                }
+
+                RoslynDebug.AssertNotNull(LazyMetadataSymbols);
+                return LazyMetadataSymbols.SynthesizedDelegates;
+            }
+        }
+
         internal MetadataReader MetadataReader
         {
             get { return this.OriginalMetadata.MetadataReader; }
diff --git a/src/Compilers/Core/Portable/Emit/EditAndContinue/IPEDeltaAssemblyBuilder.cs b/src/Compilers/Core/Portable/Emit/EditAndContinue/IPEDeltaAssemblyBuilder.cs
index f8fb5fb0d3882..c968ea595379a 100644
--- a/src/Compilers/Core/Portable/Emit/EditAndContinue/IPEDeltaAssemblyBuilder.cs
+++ b/src/Compilers/Core/Portable/Emit/EditAndContinue/IPEDeltaAssemblyBuilder.cs
@@ -10,5 +10,6 @@ internal interface IPEDeltaAssemblyBuilder
     {
         void OnCreatedIndices(DiagnosticBag diagnostics);
         IReadOnlyDictionary<AnonymousTypeKey, AnonymousTypeValue> GetAnonymousTypeMap();
+        IReadOnlyDictionary<SynthesizedDelegateKey, SynthesizedDelegateValue> GetSynthesizedDelegates();
     }
 }
diff --git a/src/Compilers/Core/Portable/Emit/EditAndContinue/SymbolMatcher.cs b/src/Compilers/Core/Portable/Emit/EditAndContinue/SymbolMatcher.cs
index 15ce2d0d8e0d1..75ae6c2ee81c4 100644
--- a/src/Compilers/Core/Portable/Emit/EditAndContinue/SymbolMatcher.cs
+++ b/src/Compilers/Core/Portable/Emit/EditAndContinue/SymbolMatcher.cs
@@ -61,6 +61,7 @@ public EmitBaseline MapBaselineToCompilation(
                 userStringStreamLengthAdded: baseline.UserStringStreamLengthAdded,
                 guidStreamLengthAdded: baseline.GuidStreamLengthAdded,
                 anonymousTypeMap: MapAnonymousTypes(baseline.AnonymousTypeMap),
+                synthesizedDelegates: MapSynthesizedDelegates(baseline.SynthesizedDelegates),
                 synthesizedMembers: mappedSynthesizedMembers,
                 addedOrChangedMethods: MapAddedOrChangedMethods(baseline.AddedOrChangedMethods),
                 debugInformationProvider: baseline.DebugInformationProvider,
@@ -103,10 +104,8 @@ private IReadOnlyDictionary<AnonymousTypeKey, AnonymousTypeValue> MapAnonymousTy
         {
             var result = new Dictionary<AnonymousTypeKey, AnonymousTypeValue>();
 
-            foreach (var pair in anonymousTypeMap)
+            foreach (var (key, value) in anonymousTypeMap)
             {
-                var key = pair.Key;
-                var value = pair.Value;
                 var type = (Cci.ITypeDefinition?)MapDefinition(value.Type);
                 RoslynDebug.Assert(type != null);
                 result.Add(key, new AnonymousTypeValue(value.Name, value.UniqueIndex, type));
@@ -115,6 +114,20 @@ private IReadOnlyDictionary<AnonymousTypeKey, AnonymousTypeValue> MapAnonymousTy
             return result;
         }
 
+        private IReadOnlyDictionary<SynthesizedDelegateKey, SynthesizedDelegateValue> MapSynthesizedDelegates(IReadOnlyDictionary<SynthesizedDelegateKey, SynthesizedDelegateValue> synthesizedDelegates)
+        {
+            var result = new Dictionary<SynthesizedDelegateKey, SynthesizedDelegateValue>();
+
+            foreach (var (key, value) in synthesizedDelegates)
+            {
+                var delegateTypeDef = (Cci.ITypeDefinition?)MapDefinition(value.Delegate);
+                RoslynDebug.Assert(delegateTypeDef != null);
+                result.Add(key, new SynthesizedDelegateValue(delegateTypeDef));
+            }
+
+            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/Core/Portable/Emit/SynthesizedDelegateKey.cs b/src/Compilers/Core/Portable/Emit/SynthesizedDelegateKey.cs
new file mode 100644
index 0000000000000..f8dad0422f0c8
--- /dev/null
+++ b/src/Compilers/Core/Portable/Emit/SynthesizedDelegateKey.cs
@@ -0,0 +1,27 @@
+// 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;
+
+namespace Microsoft.CodeAnalysis.Emit
+{
+    internal readonly struct SynthesizedDelegateKey : IEquatable<SynthesizedDelegateKey>
+    {
+        public readonly string Name;
+
+        public SynthesizedDelegateKey(string name)
+        {
+            Name = name;
+        }
+
+        public override bool Equals(object? obj)
+            => obj is SynthesizedDelegateKey other && Equals(other);
+
+        public bool Equals(SynthesizedDelegateKey other)
+            => Name.Equals(other.Name, StringComparison.Ordinal);
+
+        public override int GetHashCode()
+            => Name.GetHashCode();
+    }
+}
diff --git a/src/Compilers/Core/Portable/Emit/SynthesizedDelegateValue.cs b/src/Compilers/Core/Portable/Emit/SynthesizedDelegateValue.cs
new file mode 100644
index 0000000000000..e2313fa5f822e
--- /dev/null
+++ b/src/Compilers/Core/Portable/Emit/SynthesizedDelegateValue.cs
@@ -0,0 +1,18 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.Cci;
+
+namespace Microsoft.CodeAnalysis.Emit
+{
+    internal readonly struct SynthesizedDelegateValue
+    {
+        public readonly ITypeDefinition Delegate;
+
+        public SynthesizedDelegateValue(ITypeDefinition @delegate)
+        {
+            Delegate = @delegate;
+        }
+    }
+}
diff --git a/src/Compilers/Core/Portable/InternalUtilities/EnumUtilties.cs b/src/Compilers/Core/Portable/InternalUtilities/EnumUtilties.cs
index 65cd46ab5004a..8e0d40e161b1c 100644
--- a/src/Compilers/Core/Portable/InternalUtilities/EnumUtilties.cs
+++ b/src/Compilers/Core/Portable/InternalUtilities/EnumUtilties.cs
@@ -68,6 +68,11 @@ internal static bool ContainsAllValues<T>(int mask) where T : struct, Enum, ICon
             }
             return true;
         }
+
+        internal static bool ContainsValue<T>(T value) where T : struct, Enum
+        {
+            return Array.IndexOf(GetValues<T>(), value) >= 0;
+        }
 #endif
     }
 }
diff --git a/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt b/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt
index d88f692872cd2..00e6323456ca0 100644
--- a/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt
+++ b/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt
@@ -30,6 +30,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.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/GeneratorDriverCache.cs b/src/Compilers/Core/Portable/SourceGeneration/GeneratorDriverCache.cs
new file mode 100644
index 0000000000000..679d738779468
--- /dev/null
+++ b/src/Compilers/Core/Portable/SourceGeneration/GeneratorDriverCache.cs
@@ -0,0 +1,67 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Text;
+using Microsoft.CodeAnalysis;
+
+namespace Microsoft.CodeAnalysis
+{
+    internal sealed class GeneratorDriverCache
+    {
+        internal const int MaxCacheSize = 10;
+
+        private readonly (string cacheKey, GeneratorDriver driver)[] _cachedDrivers = new (string, GeneratorDriver)[MaxCacheSize];
+
+        private readonly object _cacheLock = new object();
+
+        private int _cacheSize = 0;
+
+        public GeneratorDriver? TryGetDriver(string cacheKey) => AddOrUpdateMostRecentlyUsed(cacheKey, driver: null);
+
+        public void CacheGenerator(string cacheKey, GeneratorDriver driver) => AddOrUpdateMostRecentlyUsed(cacheKey, driver);
+
+        public int CacheSize => _cacheSize;
+
+        /// <summary>
+        /// Attempts to find a driver based on <paramref name="cacheKey"/>. If a matching driver is found in the 
+        /// cache, or explicitly passed via <paramref name="driver"/>, the cache is updated so that it is at the
+        /// head of the list.
+        /// </summary>
+        /// <param name="cacheKey">The key to lookup the driver by in the cache</param>
+        /// <param name="driver">An optional driver that should be cached, if not already found in the cache</param>
+        /// <returns></returns>
+        private GeneratorDriver? AddOrUpdateMostRecentlyUsed(string cacheKey, GeneratorDriver? driver)
+        {
+            lock (_cacheLock)
+            {
+                // try and find the driver if it's present
+                int i = 0;
+                for (; i < _cacheSize; i++)
+                {
+                    if (_cachedDrivers[i].cacheKey == cacheKey)
+                    {
+                        driver ??= _cachedDrivers[i].driver;
+                        break;
+                    }
+                }
+
+                // if we found it (or were passed a new one), update the cache so its at the head of the list
+                if (driver is not null)
+                {
+                    for (i = Math.Min(i, MaxCacheSize - 1); i > 0; i--)
+                    {
+                        _cachedDrivers[i] = _cachedDrivers[i - 1];
+                    }
+                    _cachedDrivers[0] = (cacheKey, driver);
+                    _cacheSize = Math.Min(MaxCacheSize, _cacheSize + 1);
+                }
+
+                return driver;
+            }
+        }
+    }
+}
diff --git a/src/Compilers/Core/Portable/SourceGeneration/IncrementalContexts.cs b/src/Compilers/Core/Portable/SourceGeneration/IncrementalContexts.cs
index 693db2aaa088a..1f1c2290c6ac4 100644
--- a/src/Compilers/Core/Portable/SourceGeneration/IncrementalContexts.cs
+++ b/src/Compilers/Core/Portable/SourceGeneration/IncrementalContexts.cs
@@ -36,6 +36,8 @@ internal IncrementalGeneratorInitializationContext(ArrayBuilder<ISyntaxInputNode
 
         public IncrementalValueProvider<AnalyzerConfigOptionsProvider> AnalyzerConfigOptionsProvider => new IncrementalValueProvider<AnalyzerConfigOptionsProvider>(SharedInputNodes.AnalyzerConfigOptions.WithRegisterOutput(RegisterOutput));
 
+        public IncrementalValueProvider<MetadataReference> MetadataReferencesProvider => new IncrementalValueProvider<MetadataReference>(SharedInputNodes.MetadataReferences.WithRegisterOutput(RegisterOutput));
+
         public void RegisterSourceOutput<TSource>(IncrementalValueProvider<TSource> source, Action<SourceProductionContext, TSource> action) => RegisterSourceOutput(source.Node, action, IncrementalGeneratorOutputKind.Source);
 
         public void RegisterSourceOutput<TSource>(IncrementalValuesProvider<TSource> source, Action<SourceProductionContext, TSource> action) => RegisterSourceOutput(source.Node, action, IncrementalGeneratorOutputKind.Source);
diff --git a/src/Compilers/Core/Portable/SourceGeneration/Nodes/SharedInputNodes.cs b/src/Compilers/Core/Portable/SourceGeneration/Nodes/SharedInputNodes.cs
index 77d1346907130..5e6bd89ec6b05 100644
--- a/src/Compilers/Core/Portable/SourceGeneration/Nodes/SharedInputNodes.cs
+++ b/src/Compilers/Core/Portable/SourceGeneration/Nodes/SharedInputNodes.cs
@@ -24,5 +24,7 @@ internal static class SharedInputNodes
         public static readonly InputNode<SyntaxTree> SyntaxTrees = new InputNode<SyntaxTree>(b => b.Compilation.SyntaxTrees.ToImmutableArray());
 
         public static readonly InputNode<AnalyzerConfigOptionsProvider> AnalyzerConfigOptions = new InputNode<AnalyzerConfigOptionsProvider>(b => ImmutableArray.Create(b.DriverState.OptionsProvider));
+
+        public static readonly InputNode<MetadataReference> MetadataReferences = new InputNode<MetadataReference>(b => b.Compilation.ExternalReferences);
     }
 }
diff --git a/src/Compilers/Core/Portable/Symbols/SymbolKind.cs b/src/Compilers/Core/Portable/Symbols/SymbolKind.cs
index 0280ddcba27ba..795448963f061 100644
--- a/src/Compilers/Core/Portable/Symbols/SymbolKind.cs
+++ b/src/Compilers/Core/Portable/Symbols/SymbolKind.cs
@@ -2,6 +2,9 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System.Diagnostics;
+using Roslyn.Utilities;
+
 namespace Microsoft.CodeAnalysis
 {
     /// <summary>
@@ -114,4 +117,20 @@ public enum SymbolKind
         /// </summary>
         FunctionPointerType = 20,
     }
+
+    internal static class SymbolKindInternal
+    {
+        /// <summary>
+        /// Internal Symbol representing the inferred signature of
+        /// a lambda expression or method group.
+        /// </summary>
+        internal const SymbolKind FunctionType = (SymbolKind)255;
+
+#if DEBUG
+        static SymbolKindInternal()
+        {
+            Debug.Assert(!EnumUtilities.ContainsValue(FunctionType));
+        }
+#endif
+    }
 }
diff --git a/src/Compilers/Core/Portable/Symbols/TypeKind.cs b/src/Compilers/Core/Portable/Symbols/TypeKind.cs
index 8f77e1204496f..e0e2aec8b5165 100644
--- a/src/Compilers/Core/Portable/Symbols/TypeKind.cs
+++ b/src/Compilers/Core/Portable/Symbols/TypeKind.cs
@@ -2,6 +2,9 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System.Diagnostics;
+using Roslyn.Utilities;
+
 namespace Microsoft.CodeAnalysis
 {
     /// <summary>
@@ -84,4 +87,20 @@ public enum TypeKind : byte
         /// </summary>
         FunctionPointer = 13,
     }
+
+    internal static class TypeKindInternal
+    {
+        /// <summary>
+        /// Internal Symbol representing the inferred signature of
+        /// a lambda expression or method group.
+        /// </summary>
+        internal const TypeKind FunctionType = (TypeKind)255;
+
+#if DEBUG
+        static TypeKindInternal()
+        {
+            Debug.Assert(!EnumUtilities.ContainsValue(FunctionType));
+        }
+#endif
+    }
 }
diff --git a/src/Compilers/Core/Portable/TreeDumper.cs b/src/Compilers/Core/Portable/TreeDumper.cs
index 6eec8da558f03..c540ed30373bb 100644
--- a/src/Compilers/Core/Portable/TreeDumper.cs
+++ b/src/Compilers/Core/Portable/TreeDumper.cs
@@ -89,14 +89,10 @@ private void DoDumpCompact(TreeDumperNode node, string indent)
             }
 
             _sb.AppendLine();
-            var children = node.Children.ToList();
+            var children = node.Children.Where(c => !skip(c)).ToList();
             for (int i = 0; i < children.Count; ++i)
             {
                 var child = children[i];
-                if (child == null)
-                {
-                    continue;
-                }
 
                 _sb.Append(indent);
                 _sb.Append(i == children.Count - 1 ? '\u2514' : '\u251C');
@@ -106,6 +102,28 @@ private void DoDumpCompact(TreeDumperNode node, string indent)
                 // the child node's children:
                 DoDumpCompact(child, indent + (i == children.Count - 1 ? "  " : "\u2502 "));
             }
+
+            static bool skip(TreeDumperNode node)
+            {
+                if (node is null)
+                {
+                    return true;
+                }
+
+                if (node.Text is "locals" or "localFunctions"
+                    && node.Value is IList { Count: 0 })
+                {
+                    return true;
+                }
+
+                if (node.Text is "hasErrors" or "isSuppressed" or "isRef"
+                    && node.Value is false)
+                {
+                    return true;
+                }
+
+                return false;
+            }
         }
 
         public static string DumpXML(TreeDumperNode root, string? indent = null)
diff --git a/src/Compilers/Server/VBCSCompiler/CSharpCompilerServer.cs b/src/Compilers/Server/VBCSCompiler/CSharpCompilerServer.cs
index fe31e1832f00e..5dc1350149944 100644
--- a/src/Compilers/Server/VBCSCompiler/CSharpCompilerServer.cs
+++ b/src/Compilers/Server/VBCSCompiler/CSharpCompilerServer.cs
@@ -16,13 +16,13 @@ internal sealed class CSharpCompilerServer : CSharpCompiler
     {
         private readonly Func<string, MetadataReferenceProperties, PortableExecutableReference> _metadataProvider;
 
-        internal CSharpCompilerServer(Func<string, MetadataReferenceProperties, PortableExecutableReference> metadataProvider, string[] args, BuildPaths buildPaths, string? libDirectory, IAnalyzerAssemblyLoader analyzerLoader)
-            : this(metadataProvider, Path.Combine(buildPaths.ClientDirectory, ResponseFileName), args, buildPaths, libDirectory, analyzerLoader)
+        internal CSharpCompilerServer(Func<string, MetadataReferenceProperties, PortableExecutableReference> metadataProvider, string[] args, BuildPaths buildPaths, string? libDirectory, IAnalyzerAssemblyLoader analyzerLoader, GeneratorDriverCache driverCache)
+            : this(metadataProvider, Path.Combine(buildPaths.ClientDirectory, ResponseFileName), args, buildPaths, libDirectory, analyzerLoader, driverCache)
         {
         }
 
-        internal CSharpCompilerServer(Func<string, MetadataReferenceProperties, PortableExecutableReference> metadataProvider, string? responseFile, string[] args, BuildPaths buildPaths, string? libDirectory, IAnalyzerAssemblyLoader analyzerLoader)
-            : base(CSharpCommandLineParser.Default, responseFile, args, buildPaths, libDirectory, analyzerLoader)
+        internal CSharpCompilerServer(Func<string, MetadataReferenceProperties, PortableExecutableReference> metadataProvider, string? responseFile, string[] args, BuildPaths buildPaths, string? libDirectory, IAnalyzerAssemblyLoader analyzerLoader, GeneratorDriverCache driverCache)
+            : base(CSharpCommandLineParser.Default, responseFile, args, buildPaths, libDirectory, analyzerLoader, driverCache)
         {
             _metadataProvider = metadataProvider;
         }
diff --git a/src/Compilers/Server/VBCSCompiler/CompilerRequestHandler.cs b/src/Compilers/Server/VBCSCompiler/CompilerRequestHandler.cs
index 092893f5db947..9513b304ff182 100644
--- a/src/Compilers/Server/VBCSCompiler/CompilerRequestHandler.cs
+++ b/src/Compilers/Server/VBCSCompiler/CompilerRequestHandler.cs
@@ -62,6 +62,11 @@ internal sealed class CompilerServerHost : ICompilerServerHost
 
         public ICompilerServerLogger Logger { get; }
 
+        /// <summary>
+        /// A cache that can store generator drivers in order to enable incrementalism across builds for the lifetime of the server.
+        /// </summary>
+        private readonly GeneratorDriverCache _driverCache = new GeneratorDriverCache();
+
         internal CompilerServerHost(string clientDirectory, string sdkDirectory, ICompilerServerLogger logger)
         {
             ClientDirectory = clientDirectory;
@@ -84,7 +89,8 @@ public bool TryCreateCompiler(in RunRequest request, BuildPaths buildPaths, [Not
                         args: request.Arguments,
                         buildPaths: buildPaths,
                         libDirectory: request.LibDirectory,
-                        analyzerLoader: AnalyzerAssemblyLoader);
+                        analyzerLoader: AnalyzerAssemblyLoader,
+                        _driverCache);
                     return true;
                 case LanguageNames.VisualBasic:
                     compiler = new VisualBasicCompilerServer(
@@ -92,7 +98,8 @@ public bool TryCreateCompiler(in RunRequest request, BuildPaths buildPaths, [Not
                         args: request.Arguments,
                         buildPaths: buildPaths,
                         libDirectory: request.LibDirectory,
-                        analyzerLoader: AnalyzerAssemblyLoader);
+                        analyzerLoader: AnalyzerAssemblyLoader,
+                        _driverCache);
                     return true;
                 default:
                     compiler = null;
diff --git a/src/Compilers/Server/VBCSCompiler/VisualBasicCompilerServer.cs b/src/Compilers/Server/VBCSCompiler/VisualBasicCompilerServer.cs
index 3599ad566756d..0be389d526477 100644
--- a/src/Compilers/Server/VBCSCompiler/VisualBasicCompilerServer.cs
+++ b/src/Compilers/Server/VBCSCompiler/VisualBasicCompilerServer.cs
@@ -18,13 +18,13 @@ internal sealed class VisualBasicCompilerServer : VisualBasicCompiler
     {
         private readonly Func<string, MetadataReferenceProperties, PortableExecutableReference> _metadataProvider;
 
-        internal VisualBasicCompilerServer(Func<string, MetadataReferenceProperties, PortableExecutableReference> metadataProvider, string[] args, BuildPaths buildPaths, string? libDirectory, IAnalyzerAssemblyLoader analyzerLoader)
-            : this(metadataProvider, Path.Combine(buildPaths.ClientDirectory, ResponseFileName), args, buildPaths, libDirectory, analyzerLoader)
+        internal VisualBasicCompilerServer(Func<string, MetadataReferenceProperties, PortableExecutableReference> metadataProvider, string[] args, BuildPaths buildPaths, string? libDirectory, IAnalyzerAssemblyLoader analyzerLoader, GeneratorDriverCache driverCache)
+            : this(metadataProvider, Path.Combine(buildPaths.ClientDirectory, ResponseFileName), args, buildPaths, libDirectory, analyzerLoader, driverCache)
         {
         }
 
-        internal VisualBasicCompilerServer(Func<string, MetadataReferenceProperties, PortableExecutableReference> metadataProvider, string? responseFile, string[] args, BuildPaths buildPaths, string? libDirectory, IAnalyzerAssemblyLoader analyzerLoader)
-            : base(VisualBasicCommandLineParser.Default, responseFile, args, buildPaths, libDirectory, analyzerLoader)
+        internal VisualBasicCompilerServer(Func<string, MetadataReferenceProperties, PortableExecutableReference> metadataProvider, string? responseFile, string[] args, BuildPaths buildPaths, string? libDirectory, IAnalyzerAssemblyLoader analyzerLoader, GeneratorDriverCache driverCache)
+            : base(VisualBasicCommandLineParser.Default, responseFile, args, buildPaths, libDirectory, analyzerLoader, driverCache)
         {
             _metadataProvider = metadataProvider;
         }
diff --git a/src/Compilers/Server/VBCSCompilerTests/TouchedFileLoggingTests.cs b/src/Compilers/Server/VBCSCompilerTests/TouchedFileLoggingTests.cs
index abafacdbcfbaf..33f3d98b9f2c0 100644
--- a/src/Compilers/Server/VBCSCompilerTests/TouchedFileLoggingTests.cs
+++ b/src/Compilers/Server/VBCSCompilerTests/TouchedFileLoggingTests.cs
@@ -67,7 +67,8 @@ public void CSharpTrivialMetadataCaching()
                     new[] { "/nologo", "/touchedfiles:" + touchedBase, source1 },
                     new BuildPaths(clientDirectory, _baseDirectory, RuntimeEnvironment.GetRuntimeDirectory(), Path.GetTempPath()),
                     s_libDirectory,
-                    new TestAnalyzerAssemblyLoader());
+                    new TestAnalyzerAssemblyLoader(),
+                    driverCache: null);
 
                 List<string> expectedReads;
                 List<string> expectedWrites;
@@ -116,7 +117,8 @@ public void VisualBasicTrivialMetadataCaching()
                     new[] { "/nologo", "/touchedfiles:" + touchedBase, source1 },
                     new BuildPaths(clientDirectory, _baseDirectory, RuntimeEnvironment.GetRuntimeDirectory(), Path.GetTempPath()),
                     s_libDirectory,
-                    new TestAnalyzerAssemblyLoader());
+                    new TestAnalyzerAssemblyLoader(),
+                    driverCache: null);
 
                 List<string> expectedReads;
                 List<string> expectedWrites;
diff --git a/src/Compilers/Test/Core/Compilation/CompilationDifference.cs b/src/Compilers/Test/Core/Compilation/CompilationDifference.cs
index 0556b96aa7c96..1c2ba92547a86 100644
--- a/src/Compilers/Test/Core/Compilation/CompilationDifference.cs
+++ b/src/Compilers/Test/Core/Compilation/CompilationDifference.cs
@@ -134,7 +134,7 @@ private static string GetTypeName(SignatureTypeCode typeCode)
         public void VerifySynthesizedMembers(params string[] expectedSynthesizedTypesAndMemberCounts)
         {
             var actual = EmitResult.Baseline.SynthesizedMembers.Select(e => e.Key.ToString() + ": {" + string.Join(", ", e.Value.Select(v => v.Name)) + "}");
-            AssertEx.SetEqual(expectedSynthesizedTypesAndMemberCounts, actual, itemSeparator: "\r\n");
+            AssertEx.SetEqual(expectedSynthesizedTypesAndMemberCounts, actual, itemSeparator: ",\r\n", itemInspector: s => $"\"{s}\"");
         }
 
         public void VerifySynthesizedFields(string typeName, params string[] expectedSynthesizedTypesAndMemberCounts)
diff --git a/src/Compilers/Test/Utilities/CSharp/MockCSharpCompiler.cs b/src/Compilers/Test/Utilities/CSharp/MockCSharpCompiler.cs
index 615d39a77a6d2..be90ad0ef1d3b 100644
--- a/src/Compilers/Test/Utilities/CSharp/MockCSharpCompiler.cs
+++ b/src/Compilers/Test/Utilities/CSharp/MockCSharpCompiler.cs
@@ -26,8 +26,8 @@ public MockCSharpCompiler(string responseFile, string workingDirectory, string[]
         {
         }
 
-        public MockCSharpCompiler(string responseFile, BuildPaths buildPaths, string[] args, ImmutableArray<DiagnosticAnalyzer> analyzers = default, ImmutableArray<ISourceGenerator> generators = default, AnalyzerAssemblyLoader loader = null)
-            : base(CSharpCommandLineParser.Default, responseFile, args, buildPaths, Environment.GetEnvironmentVariable("LIB"), loader ?? new DefaultAnalyzerAssemblyLoader())
+        public MockCSharpCompiler(string responseFile, BuildPaths buildPaths, string[] args, ImmutableArray<DiagnosticAnalyzer> analyzers = default, ImmutableArray<ISourceGenerator> generators = default, AnalyzerAssemblyLoader loader = null, GeneratorDriverCache driverCache = null)
+            : base(CSharpCommandLineParser.Default, responseFile, args, buildPaths, Environment.GetEnvironmentVariable("LIB"), loader ?? new DefaultAnalyzerAssemblyLoader(), driverCache)
         {
             _analyzers = analyzers.NullToEmpty();
             _generators = generators.NullToEmpty();
diff --git a/src/Compilers/Test/Utilities/VisualBasic/CompilationTestUtils.vb b/src/Compilers/Test/Utilities/VisualBasic/CompilationTestUtils.vb
index b07088107c763..56b6f50bcde5d 100644
--- a/src/Compilers/Test/Utilities/VisualBasic/CompilationTestUtils.vb
+++ b/src/Compilers/Test/Utilities/VisualBasic/CompilationTestUtils.vb
@@ -1022,13 +1022,14 @@ Friend Module CompilationUtils
         Dim diag2 = diagAndIndex2.Diagnostic
         Dim loc1 = diag1.Location
         Dim loc2 = diag2.Location
+        Dim comparer = StringComparer.Ordinal
 
         If Not (loc1.IsInSource Or loc1.IsInMetadata) Then
             If Not (loc2.IsInSource Or loc2.IsInMetadata) Then
                 ' Both have no location. Sort by code, then by message.
                 If diag1.Code < diag2.Code Then Return -1
                 If diag1.Code > diag2.Code Then Return 1
-                Return diag1.GetMessage(EnsureEnglishUICulture.PreferredOrNull).CompareTo(diag2.GetMessage(EnsureEnglishUICulture.PreferredOrNull))
+                Return comparer.Compare(diag1.GetMessage(EnsureEnglishUICulture.PreferredOrNull), diag2.GetMessage(EnsureEnglishUICulture.PreferredOrNull))
             Else
                 Return -1
             End If
@@ -1039,7 +1040,7 @@ Friend Module CompilationUtils
             Dim sourceTree1 = loc1.SourceTree
             Dim sourceTree2 = loc2.SourceTree
 
-            If sourceTree1.FilePath <> sourceTree2.FilePath Then Return sourceTree1.FilePath.CompareTo(sourceTree2.FilePath)
+            If sourceTree1.FilePath <> sourceTree2.FilePath Then Return comparer.Compare(sourceTree1.FilePath, sourceTree2.FilePath)
             If loc1.SourceSpan.Start < loc2.SourceSpan.Start Then Return -1
             If loc1.SourceSpan.Start > loc2.SourceSpan.Start Then Return 1
             If loc1.SourceSpan.Length < loc2.SourceSpan.Length Then Return -1
@@ -1047,16 +1048,16 @@ Friend Module CompilationUtils
             If diag1.Code < diag2.Code Then Return -1
             If diag1.Code > diag2.Code Then Return 1
 
-            Return diag1.GetMessage(EnsureEnglishUICulture.PreferredOrNull).CompareTo(diag2.GetMessage(EnsureEnglishUICulture.PreferredOrNull))
+            Return comparer.Compare(diag1.GetMessage(EnsureEnglishUICulture.PreferredOrNull), diag2.GetMessage(EnsureEnglishUICulture.PreferredOrNull))
         ElseIf loc1.IsInMetadata AndAlso loc2.IsInMetadata Then
             ' sort by assembly name, then by error code
             Dim name1 = loc1.MetadataModule.ContainingAssembly.Name
             Dim name2 = loc2.MetadataModule.ContainingAssembly.Name
-            If name1 <> name2 Then Return name1.CompareTo(name2)
+            If name1 <> name2 Then Return comparer.Compare(name1, name2)
             If diag1.Code < diag2.Code Then Return -1
             If diag1.Code > diag2.Code Then Return 1
 
-            Return diag1.GetMessage(EnsureEnglishUICulture.PreferredOrNull).CompareTo(diag2.GetMessage(EnsureEnglishUICulture.PreferredOrNull))
+            Return comparer.Compare(diag1.GetMessage(EnsureEnglishUICulture.PreferredOrNull), diag2.GetMessage(EnsureEnglishUICulture.PreferredOrNull))
         ElseIf loc1.IsInSource Then
             Return -1
         ElseIf loc2.IsInSource Then
@@ -1145,9 +1146,9 @@ Friend Module CompilationUtils
         Loop
 
         If (isDistinct) Then
-            symType = (From temp In symType Distinct Select temp Order By temp.ToDisplayString()).ToList()
+            symType = symType.Distinct().OrderBy(Function(x) x.ToDisplayString(), StringComparer.OrdinalIgnoreCase).ToList()
         Else
-            symType = (From temp In symType Select temp Order By temp.ToDisplayString()).ToList()
+            symType = symType.OrderBy(Function(x) x.ToDisplayString(), StringComparer.OrdinalIgnoreCase).ToList()
         End If
         Return symType
 
@@ -1162,7 +1163,7 @@ Friend Module CompilationUtils
         Dim bindings1 = compilation.GetSemanticModel(tree)
         Dim symbols = GetTypeSymbol(compilation, treeName, symbolName, isDistinct)
         Assert.Equal(ExpectedDispName.Count, symbols.Count)
-        ExpectedDispName = (From temp In ExpectedDispName Select temp Order By temp).ToArray()
+        ExpectedDispName = ExpectedDispName.OrderBy(StringComparer.OrdinalIgnoreCase).ToArray()
         Dim count = 0
         For Each item In symbols
             Assert.NotNull(item)
diff --git a/src/Compilers/VisualBasic/Portable/CommandLine/VisualBasicCompiler.vb b/src/Compilers/VisualBasic/Portable/CommandLine/VisualBasicCompiler.vb
index 8e05ed7176cba..ecc22ddc8860e 100644
--- a/src/Compilers/VisualBasic/Portable/CommandLine/VisualBasicCompiler.vb
+++ b/src/Compilers/VisualBasic/Portable/CommandLine/VisualBasicCompiler.vb
@@ -22,8 +22,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
         Private ReadOnly _tempDirectory As String
         Private _additionalTextFiles As ImmutableArray(Of AdditionalTextFile)
 
-        Protected Sub New(parser As VisualBasicCommandLineParser, responseFile As String, args As String(), buildPaths As BuildPaths, additionalReferenceDirectories As String, analyzerLoader As IAnalyzerAssemblyLoader)
-            MyBase.New(parser, responseFile, args, buildPaths, additionalReferenceDirectories, analyzerLoader)
+        Protected Sub New(parser As VisualBasicCommandLineParser, responseFile As String, args As String(), buildPaths As BuildPaths, additionalReferenceDirectories As String, analyzerLoader As IAnalyzerAssemblyLoader, Optional driverCache As GeneratorDriverCache = Nothing)
+            MyBase.New(parser, responseFile, args, buildPaths, additionalReferenceDirectories, analyzerLoader, driverCache)
 
             _diagnosticFormatter = New CommandLineDiagnosticFormatter(buildPaths.WorkingDirectory, AddressOf GetAdditionalTextFiles)
             _additionalTextFiles = Nothing
@@ -298,12 +298,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             Next
         End Sub
 
-        Private Protected Overrides Function RunGenerators(input As Compilation, parseOptions As ParseOptions, generators As ImmutableArray(Of ISourceGenerator), analyzerConfigOptionsProvider As AnalyzerConfigOptionsProvider, additionalTexts As ImmutableArray(Of AdditionalText), diagnostics As DiagnosticBag) As Compilation
-            Dim driver = VisualBasicGeneratorDriver.Create(generators, additionalTexts, DirectCast(parseOptions, VisualBasicParseOptions), analyzerConfigOptionsProvider)
-            Dim compilationOut As Compilation = Nothing, generatorDiagnostics As ImmutableArray(Of Diagnostic) = Nothing
-            driver.RunGeneratorsAndUpdateCompilation(input, compilationOut, generatorDiagnostics)
-            diagnostics.AddRange(generatorDiagnostics)
-            Return compilationOut
+        Private Protected Overrides Function CreateGeneratorDriver(parseOptions As ParseOptions, generators As ImmutableArray(Of ISourceGenerator), analyzerConfigOptionsProvider As AnalyzerConfigOptionsProvider, additionalTexts As ImmutableArray(Of AdditionalText)) As GeneratorDriver
+            Return VisualBasicGeneratorDriver.Create(generators, additionalTexts, DirectCast(parseOptions, VisualBasicParseOptions), analyzerConfigOptionsProvider)
         End Function
 
     End Class
diff --git a/src/Compilers/VisualBasic/Portable/Emit/EditAndContinue/PEDeltaAssemblyBuilder.vb b/src/Compilers/VisualBasic/Portable/Emit/EditAndContinue/PEDeltaAssemblyBuilder.vb
index 2a174920422c4..1954808a25714 100644
--- a/src/Compilers/VisualBasic/Portable/Emit/EditAndContinue/PEDeltaAssemblyBuilder.vb
+++ b/src/Compilers/VisualBasic/Portable/Emit/EditAndContinue/PEDeltaAssemblyBuilder.vb
@@ -115,7 +115,9 @@ 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)
-            Dim metadataSymbols = New EmitBaseline.MetadataSymbols(metadataAnonymousTypes, metadataDecoder, assemblyReferenceIdentityMap)
+            ' 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)
 
             Return InterlockedOperations.Initialize(initialBaseline.LazyMetadataSymbols, metadataSymbols)
         End Function
@@ -233,6 +235,11 @@ 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
+            Return SpecializedCollections.EmptyReadOnlyDictionary(Of SynthesizedDelegateKey, SynthesizedDelegateValue)
+        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
diff --git a/src/Compilers/VisualBasic/Test/Emit/CodeGen/CodeGenVBCore.vb b/src/Compilers/VisualBasic/Test/Emit/CodeGen/CodeGenVBCore.vb
index d6f8f17bf0fe0..56b51ca60ebd2 100644
--- a/src/Compilers/VisualBasic/Test/Emit/CodeGen/CodeGenVBCore.vb
+++ b/src/Compilers/VisualBasic/Test/Emit/CodeGen/CodeGenVBCore.vb
@@ -2795,9 +2795,9 @@ End Namespace
 references:={SystemCoreRef, SystemXmlLinqRef, SystemXmlRef})
 
             CompilationUtils.AssertTheseDiagnostics(compilation1,
-            <errors>BC30560: Error in project-level import 'Microsoft.VisualBasic' at 'Microsoft.VisualBasic' : 'VisualBasic' is ambiguous in the namespace 'Microsoft'.
-BC30560: 'VisualBasic' is ambiguous in the namespace 'Microsoft'.
+            <errors>BC30560: 'VisualBasic' is ambiguous in the namespace 'Microsoft'.
 BC30560: 'VisualBasic' is ambiguous in the namespace 'Microsoft'.
+BC30560: Error in project-level import 'Microsoft.VisualBasic' at 'Microsoft.VisualBasic' : 'VisualBasic' is ambiguous in the namespace 'Microsoft'.
 BC30560: 'VisualBasic' is ambiguous in the namespace 'Microsoft'.
 Imports Microsoft.VisualBasic
         ~~~~~~~~~~~~~~~~~~~~~
@@ -2807,7 +2807,6 @@ BC30560: 'VisualBasic' is ambiguous in the namespace 'Microsoft'.
 BC31210: module 'VisualBasic' conflicts with a Visual Basic Runtime namespace 'VisualBasic'.
     Public Module VisualBasic  
                   ~~~~~~~~~~~
-
 </errors>)
 
             ' Remove the reference to System.XML.Linq and verify compilation behavior that the 
diff --git a/src/Compilers/VisualBasic/Test/IOperation/IOperation/IOperationTests_IForLoopStatement.vb b/src/Compilers/VisualBasic/Test/IOperation/IOperation/IOperationTests_IForLoopStatement.vb
index dd42f3c5fc6d4..fe95fd4c9bda7 100644
--- a/src/Compilers/VisualBasic/Test/IOperation/IOperation/IOperationTests_IForLoopStatement.vb
+++ b/src/Compilers/VisualBasic/Test/IOperation/IOperation/IOperationTests_IForLoopStatement.vb
@@ -2673,10 +2673,10 @@ Public Class C
 End Class]]>.Value
 
             Dim expectedDiagnostics = <![CDATA[
-BC33038: Type 'C' must define operator '-' to be used in a 'For' statement.
+BC33038: Type 'C' must define operator '+' to be used in a 'For' statement.
         For i = init To limit Step [step]
         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-BC33038: Type 'C' must define operator '+' to be used in a 'For' statement.
+BC33038: Type 'C' must define operator '-' to be used in a 'For' statement.
         For i = init To limit Step [step]
         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 BC33038: Type 'C' must define operator '<=' to be used in a 'For' statement.
@@ -2784,10 +2784,10 @@ Public Structure C
 End Structure]]>.Value
 
             Dim expectedDiagnostics = <![CDATA[
-BC33038: Type 'C?' must define operator '-' to be used in a 'For' statement.
+BC33038: Type 'C?' must define operator '+' to be used in a 'For' statement.
         For i = init To limit Step [step]
         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-BC33038: Type 'C?' must define operator '+' to be used in a 'For' statement.
+BC33038: Type 'C?' must define operator '-' to be used in a 'For' statement.
         For i = init To limit Step [step]
         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 BC33038: Type 'C?' must define operator '<=' to be used in a 'For' statement.
diff --git a/src/Compilers/VisualBasic/Test/Semantic/Binding/BindingErrorTests.vb b/src/Compilers/VisualBasic/Test/Semantic/Binding/BindingErrorTests.vb
index d27e722d373d1..a80379fb6f3a1 100644
--- a/src/Compilers/VisualBasic/Test/Semantic/Binding/BindingErrorTests.vb
+++ b/src/Compilers/VisualBasic/Test/Semantic/Binding/BindingErrorTests.vb
@@ -5200,10 +5200,10 @@ End Module        </file>
 BC30311: Value of type 'Integer' cannot be converted to 'base'.
                 For i = New base To New first()
                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-BC33038: Type 'base' must define operator '-' to be used in a 'For' statement.
+BC33038: Type 'base' must define operator '+' to be used in a 'For' statement.
                 For j = New base To New first() step new second()
                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-BC33038: Type 'base' must define operator '+' to be used in a 'For' statement.
+BC33038: Type 'base' must define operator '-' to be used in a 'For' statement.
                 For j = New base To New first() step new second()
                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 BC33038: Type 'base' must define operator '&lt;=' to be used in a 'For' statement.
diff --git a/src/Compilers/VisualBasic/Test/Semantic/Compilation/SemanticModelLookupSymbolsAPITests.vb b/src/Compilers/VisualBasic/Test/Semantic/Compilation/SemanticModelLookupSymbolsAPITests.vb
index 35b3cb527f2dd..e9eb1f6f65fa8 100644
--- a/src/Compilers/VisualBasic/Test/Semantic/Compilation/SemanticModelLookupSymbolsAPITests.vb
+++ b/src/Compilers/VisualBasic/Test/Semantic/Compilation/SemanticModelLookupSymbolsAPITests.vb
@@ -108,7 +108,7 @@ Imports System
             ' Outside the method, all B's are available.
             syms = semanticModel.LookupSymbols(posOutside, Nothing, "b", Nothing)
             Assert.Equal(3, syms.Length)
-            Dim fullNames = From s In syms.AsEnumerable Order By s.ToTestDisplayString() Select s.ToTestDisplayString()
+            Dim fullNames = syms.Select(Function(x) x.ToTestDisplayString()).OrderBy(StringComparer.Ordinal).ToArray()
             Assert.Equal("A.B(Of X)", fullNames(0))
             Assert.Equal("A.B(Of X, Y)", fullNames(1))
             Assert.Equal("B", fullNames(2))
@@ -116,7 +116,7 @@ Imports System
             ' Inside the method, all B's are available if only types/namespace are allowed
             syms = semanticModel.LookupNamespacesAndTypes(posOutside, Nothing, "b")
             Assert.Equal(3, syms.Length)
-            fullNames = From s In syms.AsEnumerable Order By s.ToTestDisplayString() Select s.ToTestDisplayString()
+            fullNames = syms.Select(Function(x) x.ToTestDisplayString()).OrderBy(StringComparer.Ordinal).ToArray()
             Assert.Equal("A.B(Of X)", fullNames(0))
             Assert.Equal("A.B(Of X, Y)", fullNames(1))
             Assert.Equal("B", fullNames(2))
diff --git a/src/Compilers/VisualBasic/Test/Semantic/ExtensionMethods/SemanticModelTests.vb b/src/Compilers/VisualBasic/Test/Semantic/ExtensionMethods/SemanticModelTests.vb
index 65fec54878089..5d1b745027904 100644
--- a/src/Compilers/VisualBasic/Test/Semantic/ExtensionMethods/SemanticModelTests.vb
+++ b/src/Compilers/VisualBasic/Test/Semantic/ExtensionMethods/SemanticModelTests.vb
@@ -301,7 +301,7 @@ End Namespace
             Dim actual_lookupSymbols = GetLookupSymbols(compilation, "a.vb", name:="F1", includeReducedExtensionMethods:=True)
 
             Assert.Equal(2, actual_lookupSymbols.Count)
-            Dim sortedMethodGroup = actual_lookupSymbols.AsEnumerable().OrderBy(Function(s) s.ToTestDisplayString()).ToArray()
+            Dim sortedMethodGroup = actual_lookupSymbols.AsEnumerable().OrderBy(Function(s) s.ToTestDisplayString(), StringComparer.Ordinal).ToArray()
             Assert.Equal("Function C1.F1() As System.Int32", sortedMethodGroup(0).ToTestDisplayString())
             Assert.Equal("Function C1.F1(x As System.Int32) As System.Int32", sortedMethodGroup(1).ToTestDisplayString())
         End Sub
@@ -410,7 +410,7 @@ End Namespace
             actual_lookupSymbols = GetLookupSymbols(compilation, "a.vb", name:="Test1", container:=c1, includeReducedExtensionMethods:=True)
 
             Assert.Equal(8, actual_lookupSymbols.Count)
-            Dim sortedMethodGroup = actual_lookupSymbols.AsEnumerable().OrderBy(Function(s) s.ToTestDisplayString()).ToArray()
+            Dim sortedMethodGroup = actual_lookupSymbols.AsEnumerable().OrderBy(Function(s) s.ToTestDisplayString(), StringComparer.Ordinal).ToArray()
             Dim expected() As String = {"Sub NS1.NS2.Module1.C1.Test1(Of T1)()",
                                         "Sub NS1.NS2.Module1.C1.Test1(Of T1, T2)()",
                                         "Sub NS1.NS2.Module1.C1.Test1(Of T1, T2, T3)()",
@@ -531,7 +531,7 @@ End Namespace
             Dim actual_lookupSymbols = GetLookupSymbols(compilation, "a.vb", name:="Test1", includeReducedExtensionMethods:=True)
 
             Assert.Equal(8, actual_lookupSymbols.Count)
-            Dim sortedMethodGroup = actual_lookupSymbols.AsEnumerable().OrderBy(Function(s) s.ToTestDisplayString()).ToArray()
+            Dim sortedMethodGroup = actual_lookupSymbols.AsEnumerable().OrderBy(Function(s) s.ToTestDisplayString(), StringComparer.Ordinal).ToArray()
             Dim expected() As String = {"Sub NS1.NS2.Module1.C1.Test1(Of T1)()",
                                         "Sub NS1.NS2.Module1.C1.Test1(Of T1, T2)()",
                                         "Sub NS1.NS2.Module1.C1.Test1(Of T1, T2, T3)()",
@@ -658,7 +658,7 @@ End Namespace
             actual_lookupSymbols = GetLookupSymbols(compilation, "a.vb", name:="Test1", container:=c1, includeReducedExtensionMethods:=True)
 
             Assert.Equal(8, actual_lookupSymbols.Count)
-            Dim sortedMethodGroup = actual_lookupSymbols.AsEnumerable().OrderBy(Function(s) s.ToTestDisplayString()).ToArray()
+            Dim sortedMethodGroup = actual_lookupSymbols.AsEnumerable().OrderBy(Function(s) s.ToTestDisplayString(), StringComparer.Ordinal).ToArray()
             Dim expected() As String = {"Sub NS1.NS2.Module1.C1.Test1(Of T1)()",
                                         "Sub NS1.NS2.Module1.C1.Test1(Of T1, T2)()",
                                         "Sub NS1.NS2.Module1.C1.Test1(Of T1, T2, T3)()",
@@ -784,7 +784,7 @@ End Namespace
             actual_lookupSymbols = GetLookupSymbols(compilation, "a.vb", name:="Test1", container:=t, includeReducedExtensionMethods:=True)
 
             Assert.Equal(8, actual_lookupSymbols.Count)
-            Dim sortedMethodGroup = actual_lookupSymbols.AsEnumerable().OrderBy(Function(s) s.ToTestDisplayString()).ToArray()
+            Dim sortedMethodGroup = actual_lookupSymbols.AsEnumerable().OrderBy(Function(s) s.ToTestDisplayString(), StringComparer.Ordinal).ToArray()
             Dim expected() As String = {"Sub T.Test1(Of T1)()",
                                         "Sub T.Test1(Of T1, T2)()",
                                         "Sub T.Test1(Of T1, T2, T3)()",
diff --git a/src/Compilers/VisualBasic/Test/Semantic/Semantics/GetExtendedSemanticInfoTests.vb b/src/Compilers/VisualBasic/Test/Semantic/Semantics/GetExtendedSemanticInfoTests.vb
index 209b1d76081b4..a4b859d6ef3a3 100644
--- a/src/Compilers/VisualBasic/Test/Semantic/Semantics/GetExtendedSemanticInfoTests.vb
+++ b/src/Compilers/VisualBasic/Test/Semantic/Semantics/GetExtendedSemanticInfoTests.vb
@@ -1669,7 +1669,7 @@ End Class
             Assert.Null(semanticSummary.Symbol)
             Assert.Equal(CandidateReason.OverloadResolutionFailure, semanticSummary.CandidateReason)
             Assert.Equal(2, semanticSummary.CandidateSymbols.Length)
-            Dim sortedCandidates = semanticSummary.CandidateSymbols.AsEnumerable().OrderBy(Function(s) s.ToTestDisplayString()).ToArray()
+            Dim sortedCandidates = semanticSummary.CandidateSymbols.AsEnumerable().OrderBy(Function(s) s.ToTestDisplayString(), StringComparer.Ordinal).ToArray()
             Assert.Equal("Sub I1.goo(x As System.Int32)", sortedCandidates(0).ToTestDisplayString())
             Assert.Equal(SymbolKind.Method, sortedCandidates(0).Kind)
             Assert.Equal("Sub I1.goo(x As System.Int32, y As System.Int32)", sortedCandidates(1).ToTestDisplayString())
@@ -2669,15 +2669,15 @@ End Module
             Assert.Equal(SymbolKind.Method, sortedCandidates(11).Kind)
 
             Assert.Equal(19, semanticInfo.MemberGroup.Length)
-            Dim sortedMethodGroup = semanticInfo.MemberGroup.AsEnumerable().OrderBy(Function(s) s.ToTestDisplayString(), StringComparer.InvariantCulture).ToArray()
+            Dim sortedMethodGroup = semanticInfo.MemberGroup.AsEnumerable().OrderBy(Function(s) s.ToTestDisplayString(), StringComparer.Ordinal).ToArray()
             Assert.Equal("Sub System.Console.WriteLine()", sortedMethodGroup(0).ToTestDisplayString())
             Assert.Equal("Sub System.Console.WriteLine(buffer As System.Char())", sortedMethodGroup(1).ToTestDisplayString())
             Assert.Equal("Sub System.Console.WriteLine(buffer As System.Char(), index As System.Int32, count As System.Int32)", sortedMethodGroup(2).ToTestDisplayString())
-            Assert.Equal("Sub System.Console.WriteLine(format As System.String, arg0 As System.Object)", sortedMethodGroup(3).ToTestDisplayString())
-            Assert.Equal("Sub System.Console.WriteLine(format As System.String, arg0 As System.Object, arg1 As System.Object)", sortedMethodGroup(4).ToTestDisplayString())
-            Assert.Equal("Sub System.Console.WriteLine(format As System.String, arg0 As System.Object, arg1 As System.Object, arg2 As System.Object)", sortedMethodGroup(5).ToTestDisplayString())
-            Assert.Equal("Sub System.Console.WriteLine(format As System.String, arg0 As System.Object, arg1 As System.Object, arg2 As System.Object, arg3 As System.Object)", sortedMethodGroup(6).ToTestDisplayString())
-            Assert.Equal("Sub System.Console.WriteLine(format As System.String, ParamArray arg As System.Object())", sortedMethodGroup(7).ToTestDisplayString())
+            Assert.Equal("Sub System.Console.WriteLine(format As System.String, ParamArray arg As System.Object())", sortedMethodGroup(3).ToTestDisplayString())
+            Assert.Equal("Sub System.Console.WriteLine(format As System.String, arg0 As System.Object)", sortedMethodGroup(4).ToTestDisplayString())
+            Assert.Equal("Sub System.Console.WriteLine(format As System.String, arg0 As System.Object, arg1 As System.Object)", sortedMethodGroup(5).ToTestDisplayString())
+            Assert.Equal("Sub System.Console.WriteLine(format As System.String, arg0 As System.Object, arg1 As System.Object, arg2 As System.Object)", sortedMethodGroup(6).ToTestDisplayString())
+            Assert.Equal("Sub System.Console.WriteLine(format As System.String, arg0 As System.Object, arg1 As System.Object, arg2 As System.Object, arg3 As System.Object)", sortedMethodGroup(7).ToTestDisplayString())
             Assert.Equal("Sub System.Console.WriteLine(value As System.Boolean)", sortedMethodGroup(8).ToTestDisplayString())
             Assert.Equal("Sub System.Console.WriteLine(value As System.Char)", sortedMethodGroup(9).ToTestDisplayString())
             Assert.Equal("Sub System.Console.WriteLine(value As System.Decimal)", sortedMethodGroup(10).ToTestDisplayString())
@@ -3807,7 +3807,7 @@ Imports System
             Assert.Null(semanticSummary.Symbol)
             Assert.Equal(CandidateReason.OverloadResolutionFailure, semanticSummary.CandidateReason)
             Assert.Equal(3, semanticSummary.CandidateSymbols.Length)
-            Dim sortedCandidates = semanticSummary.CandidateSymbols.AsEnumerable().OrderBy(Function(s) s.ToTestDisplayString()).ToArray()
+            Dim sortedCandidates = semanticSummary.CandidateSymbols.AsEnumerable().OrderBy(Function(s) s.ToTestDisplayString(), StringComparer.Ordinal).ToArray()
             Assert.Equal("Sub System.ObsoleteAttribute..ctor()", sortedCandidates(0).ToTestDisplayString())
             Assert.Equal(SymbolKind.Method, sortedCandidates(0).Kind)
             Assert.Equal("Sub System.ObsoleteAttribute..ctor(message As System.String)", sortedCandidates(1).ToTestDisplayString())
@@ -3818,7 +3818,7 @@ Imports System
             Assert.Null(semanticSummary.Alias)
 
             Assert.Equal(3, semanticSummary.MemberGroup.Length)
-            Dim sortedMethodGroup = semanticSummary.MemberGroup.AsEnumerable().OrderBy(Function(s) s.ToTestDisplayString()).ToArray()
+            Dim sortedMethodGroup = semanticSummary.MemberGroup.AsEnumerable().OrderBy(Function(s) s.ToTestDisplayString(), StringComparer.Ordinal).ToArray()
             Assert.Equal("Sub System.ObsoleteAttribute..ctor()", sortedMethodGroup(0).ToTestDisplayString())
             Assert.Equal("Sub System.ObsoleteAttribute..ctor(message As System.String)", sortedMethodGroup(1).ToTestDisplayString())
             Assert.Equal("Sub System.ObsoleteAttribute..ctor(message As System.String, [error] As System.Boolean)", sortedMethodGroup(2).ToTestDisplayString())
@@ -3845,7 +3845,7 @@ Imports System
             Assert.Null(semanticSummary.Symbol)
             Assert.Equal(CandidateReason.OverloadResolutionFailure, semanticSummary.CandidateReason)
             Assert.Equal(3, semanticSummary.CandidateSymbols.Length)
-            Dim sortedCandidates = semanticSummary.CandidateSymbols.AsEnumerable().OrderBy(Function(s) s.ToTestDisplayString()).ToArray()
+            Dim sortedCandidates = semanticSummary.CandidateSymbols.AsEnumerable().OrderBy(Function(s) s.ToTestDisplayString(), StringComparer.Ordinal).ToArray()
             Assert.Equal("Sub System.ObsoleteAttribute..ctor()", sortedCandidates(0).ToTestDisplayString())
             Assert.Equal(SymbolKind.Method, sortedCandidates(0).Kind)
             Assert.Equal("Sub System.ObsoleteAttribute..ctor(message As System.String)", sortedCandidates(1).ToTestDisplayString())
@@ -3856,7 +3856,7 @@ Imports System
             Assert.Null(semanticSummary.Alias)
 
             Assert.Equal(3, semanticSummary.MemberGroup.Length)
-            Dim sortedMethodGroup = semanticSummary.MemberGroup.AsEnumerable().OrderBy(Function(s) s.ToTestDisplayString()).ToArray()
+            Dim sortedMethodGroup = semanticSummary.MemberGroup.AsEnumerable().OrderBy(Function(s) s.ToTestDisplayString(), StringComparer.Ordinal).ToArray()
             Assert.Equal("Sub System.ObsoleteAttribute..ctor()", sortedMethodGroup(0).ToTestDisplayString())
             Assert.Equal("Sub System.ObsoleteAttribute..ctor(message As System.String)", sortedMethodGroup(1).ToTestDisplayString())
             Assert.Equal("Sub System.ObsoleteAttribute..ctor(message As System.String, [error] As System.Boolean)", sortedMethodGroup(2).ToTestDisplayString())
@@ -4723,7 +4723,7 @@ End Class
             Assert.Null(semanticInfo.Symbol)
             Assert.Equal(CandidateReason.OverloadResolutionFailure, semanticInfo.CandidateReason)
             Assert.Equal(2, semanticInfo.CandidateSymbols.Length)
-            Dim sortedCandidates = semanticInfo.CandidateSymbols.AsEnumerable().OrderBy(Function(s) s.ToTestDisplayString()).ToArray()
+            Dim sortedCandidates = semanticInfo.CandidateSymbols.AsEnumerable().OrderBy(Function(s) s.ToTestDisplayString(), StringComparer.Ordinal).ToArray()
             Assert.Equal("Property C1.P1(x As System.Int32) As System.String", sortedCandidates(0).ToTestDisplayString())
             Assert.Equal(SymbolKind.Property, sortedCandidates(0).Kind)
             Assert.Equal("Property C1.P1(x As System.Int32, y As System.Int32) As System.String", sortedCandidates(1).ToTestDisplayString())
@@ -9689,7 +9689,7 @@ End Class
             Assert.Equal(SymbolKind.Method, semanticInfo.Symbol.Kind)
             Assert.Equal(0, semanticInfo.CandidateSymbols.Length)
             Assert.Equal(3, semanticInfo.MemberGroup.Length)
-            Dim sortedMethodGroup = semanticInfo.MemberGroup.AsEnumerable().OrderBy(Function(s) s.ToTestDisplayString()).ToArray()
+            Dim sortedMethodGroup = semanticInfo.MemberGroup.AsEnumerable().OrderBy(Function(s) s.ToTestDisplayString(), StringComparer.Ordinal).ToArray()
             Assert.Equal("Sub System.ObsoleteAttribute..ctor()", sortedMethodGroup(0).ToTestDisplayString())
             Assert.Equal("Sub System.ObsoleteAttribute..ctor(message As System.String)", sortedMethodGroup(1).ToTestDisplayString())
             Assert.Equal("Sub System.ObsoleteAttribute..ctor(message As System.String, [error] As System.Boolean)", sortedMethodGroup(2).ToTestDisplayString())
@@ -9725,7 +9725,7 @@ End Class
             Assert.Equal(SymbolKind.Method, semanticInfo.Symbol.Kind)
             Assert.Equal(0, semanticInfo.CandidateSymbols.Length)
             Assert.Equal(3, semanticInfo.MemberGroup.Length)
-            Dim sortedMethodGroup = semanticInfo.MemberGroup.AsEnumerable().OrderBy(Function(s) s.ToTestDisplayString()).ToArray()
+            Dim sortedMethodGroup = semanticInfo.MemberGroup.AsEnumerable().OrderBy(Function(s) s.ToTestDisplayString(), StringComparer.Ordinal).ToArray()
             Assert.Equal("Sub System.ObsoleteAttribute..ctor()", sortedMethodGroup(0).ToTestDisplayString())
             Assert.Equal("Sub System.ObsoleteAttribute..ctor(message As System.String)", sortedMethodGroup(1).ToTestDisplayString())
             Assert.Equal("Sub System.ObsoleteAttribute..ctor(message As System.String, [error] As System.Boolean)", sortedMethodGroup(2).ToTestDisplayString())
@@ -9761,7 +9761,7 @@ End Class
             Assert.Equal(SymbolKind.Method, semanticInfo.Symbol.Kind)
             Assert.Equal(0, semanticInfo.CandidateSymbols.Length)
             Assert.Equal(3, semanticInfo.MemberGroup.Length)
-            Dim sortedMethodGroup = semanticInfo.MemberGroup.AsEnumerable().OrderBy(Function(s) s.ToTestDisplayString()).ToArray()
+            Dim sortedMethodGroup = semanticInfo.MemberGroup.AsEnumerable().OrderBy(Function(s) s.ToTestDisplayString(), StringComparer.Ordinal).ToArray()
             Assert.Equal("Sub System.ObsoleteAttribute..ctor()", sortedMethodGroup(0).ToTestDisplayString())
             Assert.Equal("Sub System.ObsoleteAttribute..ctor(message As System.String)", sortedMethodGroup(1).ToTestDisplayString())
             Assert.Equal("Sub System.ObsoleteAttribute..ctor(message As System.String, [error] As System.Boolean)", sortedMethodGroup(2).ToTestDisplayString())
@@ -9796,7 +9796,7 @@ End Class
             Assert.Equal(SymbolKind.Method, semanticInfo.Symbol.Kind)
             Assert.Equal(0, semanticInfo.CandidateSymbols.Length)
             Assert.Equal(3, semanticInfo.MemberGroup.Length)
-            Dim sortedMethodGroup = semanticInfo.MemberGroup.AsEnumerable().OrderBy(Function(s) s.ToTestDisplayString()).ToArray()
+            Dim sortedMethodGroup = semanticInfo.MemberGroup.AsEnumerable().OrderBy(Function(s) s.ToTestDisplayString(), StringComparer.Ordinal).ToArray()
             Assert.Equal("Sub System.ObsoleteAttribute..ctor()", sortedMethodGroup(0).ToTestDisplayString())
             Assert.Equal("Sub System.ObsoleteAttribute..ctor(message As System.String)", sortedMethodGroup(1).ToTestDisplayString())
             Assert.Equal("Sub System.ObsoleteAttribute..ctor(message As System.String, [error] As System.Boolean)", sortedMethodGroup(2).ToTestDisplayString())
diff --git a/src/Compilers/VisualBasic/Test/Semantic/Semantics/NameLengthTests.vb b/src/Compilers/VisualBasic/Test/Semantic/Semantics/NameLengthTests.vb
index ccf367fa258fc..7e2c51991b8b9 100644
--- a/src/Compilers/VisualBasic/Test/Semantic/Semantics/NameLengthTests.vb
+++ b/src/Compilers/VisualBasic/Test/Semantic/Semantics/NameLengthTests.vb
@@ -144,10 +144,10 @@ BC37220: Name 'get_<%= s_longSymbolName %>' exceeds the maximum length allowed i
 BC37220: Name 'set_<%= s_longSymbolName %>' exceeds the maximum length allowed in metadata.
     Property <%= s_longSymbolName %> As Integer     ' Fine (except accessors And backing field)
              <%= _longSquiggle_ %>
-BC37220: Name '_<%= s_longSymbolName %>1' exceeds the maximum length allowed in metadata.
+BC37220: Name '<%= s_longSymbolName %>1' exceeds the maximum length allowed in metadata.
     Property <%= s_longSymbolName %>1 As Integer    ' Too long
              <%= _longSquiggle_ %>~
-BC37220: Name '<%= s_longSymbolName %>1' exceeds the maximum length allowed in metadata.
+BC37220: Name '_<%= s_longSymbolName %>1' exceeds the maximum length allowed in metadata.
     Property <%= s_longSymbolName %>1 As Integer    ' Too long
              <%= _longSquiggle_ %>~
 BC37220: Name 'get_<%= s_longSymbolName %>1' exceeds the maximum length allowed in metadata.
diff --git a/src/Compilers/VisualBasic/Test/Semantic/Semantics/TooLongNameTests.vb b/src/Compilers/VisualBasic/Test/Semantic/Semantics/TooLongNameTests.vb
index 84839b2a5bac5..81034904f0467 100644
--- a/src/Compilers/VisualBasic/Test/Semantic/Semantics/TooLongNameTests.vb
+++ b/src/Compilers/VisualBasic/Test/Semantic/Semantics/TooLongNameTests.vb
@@ -65,10 +65,10 @@ End Module
 
             CompilationUtils.AssertTheseEmitDiagnostics(c,
 <expected>
-BC37220: Name '$STATIC$MaximumLengthIdentifierIn2012$001$abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzABCDEFGHJKLMNOPQRSTUVWXYZABCDEFGHIJ' exceeds the maximum length allowed in metadata.
+BC37220: Name '$STATIC$MaximumLengthIdentifierIn2012$001$abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzABCDEFGHJKLMNOPQRSTUVWXYZABCDEFGHIJ$Init' exceeds the maximum length allowed in metadata.
         Static abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzABCDEFGHJKLMNOPQRSTUVWXYZABCDEFGHIJ As Integer = 1
                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-BC37220: Name '$STATIC$MaximumLengthIdentifierIn2012$001$abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzABCDEFGHJKLMNOPQRSTUVWXYZABCDEFGHIJ$Init' exceeds the maximum length allowed in metadata.
+BC37220: Name '$STATIC$MaximumLengthIdentifierIn2012$001$abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzABCDEFGHJKLMNOPQRSTUVWXYZABCDEFGHIJ' exceeds the maximum length allowed in metadata.
         Static abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzABCDEFGHJKLMNOPQRSTUVWXYZABCDEFGHIJ As Integer = 1
                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 </expected>)
diff --git a/src/Compilers/VisualBasic/Test/Semantic/Semantics/UserDefinedForToLoop.vb b/src/Compilers/VisualBasic/Test/Semantic/Semantics/UserDefinedForToLoop.vb
index ba76208c22489..66bdbbf15fc80 100644
--- a/src/Compilers/VisualBasic/Test/Semantic/Semantics/UserDefinedForToLoop.vb
+++ b/src/Compilers/VisualBasic/Test/Semantic/Semantics/UserDefinedForToLoop.vb
@@ -582,10 +582,10 @@ End Module
 
             CompilationUtils.AssertTheseDiagnostics(compilation,
 <expected><![CDATA[
-BC33038: Type 'Module1.B1' must define operator '-' to be used in a 'For' statement.
+BC33038: Type 'Module1.B1' must define operator '+' to be used in a 'For' statement.
         For i = New B1(0) To New B1(3) Step New B1(2)
         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-BC33038: Type 'Module1.B1' must define operator '+' to be used in a 'For' statement.
+BC33038: Type 'Module1.B1' must define operator '-' to be used in a 'For' statement.
         For i = New B1(0) To New B1(3) Step New B1(2)
         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 BC33038: Type 'Module1.B1' must define operator '<=' to be used in a 'For' statement.
@@ -917,10 +917,10 @@ End Module
 BC30311: Value of type 'Module1.B1' cannot be converted to 'Boolean'.
         For i = New B1(0) To New B1(3) Step New B1(2)
         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-BC33038: Type 'Module1.B1' must define operator '-' to be used in a 'For' statement.
+BC33038: Type 'Module1.B1' must define operator '+' to be used in a 'For' statement.
         For i = New B1(0) To New B1(3) Step New B1(2)
         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-BC33038: Type 'Module1.B1' must define operator '+' to be used in a 'For' statement.
+BC33038: Type 'Module1.B1' must define operator '-' to be used in a 'For' statement.
         For i = New B1(0) To New B1(3) Step New B1(2)
         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 ]]></expected>)
@@ -984,10 +984,10 @@ End Module
 
             CompilationUtils.AssertTheseDiagnostics(compilation,
 <expected><![CDATA[
-BC33039: Return and parameter types of 'Public Shared Operator -(x As Module1.B1, y As Integer) As Module1.B1' must be 'Module1.B1' to be used in a 'For' statement.
+BC33039: Return and parameter types of 'Public Shared Operator +(x As Module1.B1, y As Module1.B1) As Integer' must be 'Module1.B1' to be used in a 'For' statement.
         For i = New B1(0) To New B1(3) Step New B1(2)
         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-BC33039: Return and parameter types of 'Public Shared Operator +(x As Module1.B1, y As Module1.B1) As Integer' must be 'Module1.B1' to be used in a 'For' statement.
+BC33039: Return and parameter types of 'Public Shared Operator -(x As Module1.B1, y As Integer) As Module1.B1' must be 'Module1.B1' to be used in a 'For' statement.
         For i = New B1(0) To New B1(3) Step New B1(2)
         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 BC33040: Parameter types of 'Public Shared Operator <=(x As Integer, y As Module1.B1) As Boolean' must be 'Module1.B1' to be used in a 'For' statement.
@@ -1058,10 +1058,10 @@ End Module
 
             CompilationUtils.AssertTheseDiagnostics(compilation,
 <expected><![CDATA[
-BC33039: Return and parameter types of 'Public Shared Operator -(x As Module1.B1, y As Module1.B2) As Module1.B1' must be 'Module1.B1' to be used in a 'For' statement.
+BC33039: Return and parameter types of 'Public Shared Operator +(x As Module1.B1, y As Module1.B1) As Module1.B2' must be 'Module1.B1' to be used in a 'For' statement.
         For i = New B1?() To New B1?() Step New B1?()
         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-BC33039: Return and parameter types of 'Public Shared Operator +(x As Module1.B1, y As Module1.B1) As Module1.B2' must be 'Module1.B1' to be used in a 'For' statement.
+BC33039: Return and parameter types of 'Public Shared Operator -(x As Module1.B1, y As Module1.B2) As Module1.B1' must be 'Module1.B1' to be used in a 'For' statement.
         For i = New B1?() To New B1?() Step New B1?()
         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 BC33040: Parameter types of 'Public Shared Operator <=(x As Module1.B2?, y As Module1.B1) As Boolean' must be 'Module1.B1?' to be used in a 'For' statement.
diff --git a/src/Compilers/VisualBasic/Test/Symbol/DocumentationComments/DocCommentTests.vb b/src/Compilers/VisualBasic/Test/Symbol/DocumentationComments/DocCommentTests.vb
index 5f793c9ffff46..e85ad481dbd9b 100644
--- a/src/Compilers/VisualBasic/Test/Symbol/DocumentationComments/DocCommentTests.vb
+++ b/src/Compilers/VisualBasic/Test/Symbol/DocumentationComments/DocCommentTests.vb
@@ -8346,13 +8346,13 @@ End Class
             CompileCheckDiagnosticsAndXmlDocument(FormatSourceXml(xmlSource, xmlFile),
     <error>
         <![CDATA[
+BC42306: XML comment tag 'returns' is not permitted on a 'WithEvents variable' language element.
 BC42306: XML comment tag 'returns' is not permitted on a 'class' language element.
 BC42306: XML comment tag 'returns' is not permitted on a 'delegate sub' language element.
 BC42306: XML comment tag 'returns' is not permitted on a 'enum' language element.
 BC42306: XML comment tag 'returns' is not permitted on a 'event' language element.
 BC42306: XML comment tag 'returns' is not permitted on a 'sub' language element.
 BC42306: XML comment tag 'returns' is not permitted on a 'variable' language element.
-BC42306: XML comment tag 'returns' is not permitted on a 'WithEvents variable' language element.
 BC42313: XML comment tag 'returns' is not permitted on a 'WriteOnly' Property.
 BC42315: XML comment tag 'returns' is not permitted on a 'declare sub' language element.
 ]]>
@@ -8504,8 +8504,8 @@ End Class
         <![CDATA[
 BC42306: XML comment tag 'value' is not permitted on a 'class' language element.
 BC42306: XML comment tag 'value' is not permitted on a 'declare' language element.
-BC42306: XML comment tag 'value' is not permitted on a 'delegate' language element.
 BC42306: XML comment tag 'value' is not permitted on a 'delegate sub' language element.
+BC42306: XML comment tag 'value' is not permitted on a 'delegate' language element.
 BC42306: XML comment tag 'value' is not permitted on a 'enum' language element.
 BC42306: XML comment tag 'value' is not permitted on a 'event' language element.
 BC42306: XML comment tag 'value' is not permitted on a 'function' language element.
@@ -8785,8 +8785,8 @@ BC42306: XML comment tag 'typeparam' is not permitted on a 'property' language e
 BC42306: XML comment tag 'typeparam' is not permitted on a 'variable' language element.
 BC42306: XML comment tag 'typeparamref' is not permitted on a 'module' language element.
 BC42317: XML comment type parameter 'P9' does not match a type parameter on the corresponding 'declare' statement.
-BC42317: XML comment type parameter 'P9' does not match a type parameter on the corresponding 'delegate' statement.
 BC42317: XML comment type parameter 'P9' does not match a type parameter on the corresponding 'delegate sub' statement.
+BC42317: XML comment type parameter 'P9' does not match a type parameter on the corresponding 'delegate' statement.
 BC42317: XML comment type parameter 'P9' does not match a type parameter on the corresponding 'function' statement.
 BC42317: XML comment type parameter 'P9' does not match a type parameter on the corresponding 'interface' statement.
 BC42317: XML comment type parameter 'P9' does not match a type parameter on the corresponding 'structure' statement.
diff --git a/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Source/ComClassTests.vb b/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Source/ComClassTests.vb
index 2c1360c763902..7fb6a889b3014 100644
--- a/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Source/ComClassTests.vb
+++ b/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/Source/ComClassTests.vb
@@ -2408,28 +2408,28 @@ End Class
 
             Dim expected =
 <expected>
-BC42101: 'Microsoft.VisualBasic.ComClassAttribute' on class 'ComClassTest1' implicitly declares Interface '__ComClassTest1', which conflicts with a member of the same name in Class 'ComClassBase'. Use 'Microsoft.VisualBasic.ComClassAttribute(InterfaceShadows:=True)' if you want to hide the name on the base ComClassBase.
+BC42101: 'Microsoft.VisualBasic.ComClassAttribute' on class 'ComClassTest1' implicitly declares Interface '_ComClassTest1', which conflicts with a member of the same name in Class 'ComClassBase'. Use 'Microsoft.VisualBasic.ComClassAttribute(InterfaceShadows:=True)' if you want to hide the name on the base ComClassBase.
 Public Class ComClassTest1
              ~~~~~~~~~~~~~
-BC42101: 'Microsoft.VisualBasic.ComClassAttribute' on class 'ComClassTest1' implicitly declares Interface '__ComClassTest1', which conflicts with a member of the same name in Class 'ComClassBase'. Use 'Microsoft.VisualBasic.ComClassAttribute(InterfaceShadows:=True)' if you want to hide the name on the base ComClassBase.
+BC42101: 'Microsoft.VisualBasic.ComClassAttribute' on class 'ComClassTest1' implicitly declares Interface '_ComClassTest1', which conflicts with a member of the same name in Class 'ComClassBase'. Use 'Microsoft.VisualBasic.ComClassAttribute(InterfaceShadows:=True)' if you want to hide the name on the base ComClassBase.
 Public Class ComClassTest1
              ~~~~~~~~~~~~~
-BC42101: 'Microsoft.VisualBasic.ComClassAttribute' on class 'ComClassTest1' implicitly declares Interface '__ComClassTest1', which conflicts with a member of the same name in Class 'ComClassBase'. Use 'Microsoft.VisualBasic.ComClassAttribute(InterfaceShadows:=True)' if you want to hide the name on the base ComClassBase.
+BC42101: 'Microsoft.VisualBasic.ComClassAttribute' on class 'ComClassTest1' implicitly declares Interface '_ComClassTest1', which conflicts with a member of the same name in Class 'ComClassBase'. Use 'Microsoft.VisualBasic.ComClassAttribute(InterfaceShadows:=True)' if you want to hide the name on the base ComClassBase.
 Public Class ComClassTest1
              ~~~~~~~~~~~~~
-BC42101: 'Microsoft.VisualBasic.ComClassAttribute' on class 'ComClassTest1' implicitly declares Interface '__ComClassTest1', which conflicts with a member of the same name in Class 'ComClassBase'. Use 'Microsoft.VisualBasic.ComClassAttribute(InterfaceShadows:=True)' if you want to hide the name on the base ComClassBase.
+BC42101: 'Microsoft.VisualBasic.ComClassAttribute' on class 'ComClassTest1' implicitly declares Interface '_ComClassTest1', which conflicts with a member of the same name in Class 'ComClassBase'. Use 'Microsoft.VisualBasic.ComClassAttribute(InterfaceShadows:=True)' if you want to hide the name on the base ComClassBase.
 Public Class ComClassTest1
              ~~~~~~~~~~~~~
-BC42101: 'Microsoft.VisualBasic.ComClassAttribute' on class 'ComClassTest1' implicitly declares Interface '_ComClassTest1', which conflicts with a member of the same name in Class 'ComClassBase'. Use 'Microsoft.VisualBasic.ComClassAttribute(InterfaceShadows:=True)' if you want to hide the name on the base ComClassBase.
+BC42101: 'Microsoft.VisualBasic.ComClassAttribute' on class 'ComClassTest1' implicitly declares Interface '__ComClassTest1', which conflicts with a member of the same name in Class 'ComClassBase'. Use 'Microsoft.VisualBasic.ComClassAttribute(InterfaceShadows:=True)' if you want to hide the name on the base ComClassBase.
 Public Class ComClassTest1
              ~~~~~~~~~~~~~
-BC42101: 'Microsoft.VisualBasic.ComClassAttribute' on class 'ComClassTest1' implicitly declares Interface '_ComClassTest1', which conflicts with a member of the same name in Class 'ComClassBase'. Use 'Microsoft.VisualBasic.ComClassAttribute(InterfaceShadows:=True)' if you want to hide the name on the base ComClassBase.
+BC42101: 'Microsoft.VisualBasic.ComClassAttribute' on class 'ComClassTest1' implicitly declares Interface '__ComClassTest1', which conflicts with a member of the same name in Class 'ComClassBase'. Use 'Microsoft.VisualBasic.ComClassAttribute(InterfaceShadows:=True)' if you want to hide the name on the base ComClassBase.
 Public Class ComClassTest1
              ~~~~~~~~~~~~~
-BC42101: 'Microsoft.VisualBasic.ComClassAttribute' on class 'ComClassTest1' implicitly declares Interface '_ComClassTest1', which conflicts with a member of the same name in Class 'ComClassBase'. Use 'Microsoft.VisualBasic.ComClassAttribute(InterfaceShadows:=True)' if you want to hide the name on the base ComClassBase.
+BC42101: 'Microsoft.VisualBasic.ComClassAttribute' on class 'ComClassTest1' implicitly declares Interface '__ComClassTest1', which conflicts with a member of the same name in Class 'ComClassBase'. Use 'Microsoft.VisualBasic.ComClassAttribute(InterfaceShadows:=True)' if you want to hide the name on the base ComClassBase.
 Public Class ComClassTest1
              ~~~~~~~~~~~~~
-BC42101: 'Microsoft.VisualBasic.ComClassAttribute' on class 'ComClassTest1' implicitly declares Interface '_ComClassTest1', which conflicts with a member of the same name in Class 'ComClassBase'. Use 'Microsoft.VisualBasic.ComClassAttribute(InterfaceShadows:=True)' if you want to hide the name on the base ComClassBase.
+BC42101: 'Microsoft.VisualBasic.ComClassAttribute' on class 'ComClassTest1' implicitly declares Interface '__ComClassTest1', which conflicts with a member of the same name in Class 'ComClassBase'. Use 'Microsoft.VisualBasic.ComClassAttribute(InterfaceShadows:=True)' if you want to hide the name on the base ComClassBase.
 Public Class ComClassTest1
              ~~~~~~~~~~~~~
 </expected>
@@ -2490,28 +2490,28 @@ End Class
 
             Dim expected =
 <expected>
-BC42101: 'Microsoft.VisualBasic.ComClassAttribute' on class 'ComClassTest1' implicitly declares Interface '__ComClassTest1', which conflicts with a member of the same name in Class 'ComClassBase'. Use 'Microsoft.VisualBasic.ComClassAttribute(InterfaceShadows:=True)' if you want to hide the name on the base ComClassBase.
+BC42101: 'Microsoft.VisualBasic.ComClassAttribute' on class 'ComClassTest1' implicitly declares Interface '_ComClassTest1', which conflicts with a member of the same name in Class 'ComClassBase'. Use 'Microsoft.VisualBasic.ComClassAttribute(InterfaceShadows:=True)' if you want to hide the name on the base ComClassBase.
 Public Class ComClassTest1
              ~~~~~~~~~~~~~
-BC42101: 'Microsoft.VisualBasic.ComClassAttribute' on class 'ComClassTest1' implicitly declares Interface '__ComClassTest1', which conflicts with a member of the same name in Class 'ComClassBase'. Use 'Microsoft.VisualBasic.ComClassAttribute(InterfaceShadows:=True)' if you want to hide the name on the base ComClassBase.
+BC42101: 'Microsoft.VisualBasic.ComClassAttribute' on class 'ComClassTest1' implicitly declares Interface '_ComClassTest1', which conflicts with a member of the same name in Class 'ComClassBase'. Use 'Microsoft.VisualBasic.ComClassAttribute(InterfaceShadows:=True)' if you want to hide the name on the base ComClassBase.
 Public Class ComClassTest1
              ~~~~~~~~~~~~~
-BC42101: 'Microsoft.VisualBasic.ComClassAttribute' on class 'ComClassTest1' implicitly declares Interface '__ComClassTest1', which conflicts with a member of the same name in Class 'ComClassBase'. Use 'Microsoft.VisualBasic.ComClassAttribute(InterfaceShadows:=True)' if you want to hide the name on the base ComClassBase.
+BC42101: 'Microsoft.VisualBasic.ComClassAttribute' on class 'ComClassTest1' implicitly declares Interface '_ComClassTest1', which conflicts with a member of the same name in Class 'ComClassBase'. Use 'Microsoft.VisualBasic.ComClassAttribute(InterfaceShadows:=True)' if you want to hide the name on the base ComClassBase.
 Public Class ComClassTest1
              ~~~~~~~~~~~~~
-BC42101: 'Microsoft.VisualBasic.ComClassAttribute' on class 'ComClassTest1' implicitly declares Interface '__ComClassTest1', which conflicts with a member of the same name in Class 'ComClassBase'. Use 'Microsoft.VisualBasic.ComClassAttribute(InterfaceShadows:=True)' if you want to hide the name on the base ComClassBase.
+BC42101: 'Microsoft.VisualBasic.ComClassAttribute' on class 'ComClassTest1' implicitly declares Interface '_ComClassTest1', which conflicts with a member of the same name in Class 'ComClassBase'. Use 'Microsoft.VisualBasic.ComClassAttribute(InterfaceShadows:=True)' if you want to hide the name on the base ComClassBase.
 Public Class ComClassTest1
              ~~~~~~~~~~~~~
-BC42101: 'Microsoft.VisualBasic.ComClassAttribute' on class 'ComClassTest1' implicitly declares Interface '_ComClassTest1', which conflicts with a member of the same name in Class 'ComClassBase'. Use 'Microsoft.VisualBasic.ComClassAttribute(InterfaceShadows:=True)' if you want to hide the name on the base ComClassBase.
+BC42101: 'Microsoft.VisualBasic.ComClassAttribute' on class 'ComClassTest1' implicitly declares Interface '__ComClassTest1', which conflicts with a member of the same name in Class 'ComClassBase'. Use 'Microsoft.VisualBasic.ComClassAttribute(InterfaceShadows:=True)' if you want to hide the name on the base ComClassBase.
 Public Class ComClassTest1
              ~~~~~~~~~~~~~
-BC42101: 'Microsoft.VisualBasic.ComClassAttribute' on class 'ComClassTest1' implicitly declares Interface '_ComClassTest1', which conflicts with a member of the same name in Class 'ComClassBase'. Use 'Microsoft.VisualBasic.ComClassAttribute(InterfaceShadows:=True)' if you want to hide the name on the base ComClassBase.
+BC42101: 'Microsoft.VisualBasic.ComClassAttribute' on class 'ComClassTest1' implicitly declares Interface '__ComClassTest1', which conflicts with a member of the same name in Class 'ComClassBase'. Use 'Microsoft.VisualBasic.ComClassAttribute(InterfaceShadows:=True)' if you want to hide the name on the base ComClassBase.
 Public Class ComClassTest1
              ~~~~~~~~~~~~~
-BC42101: 'Microsoft.VisualBasic.ComClassAttribute' on class 'ComClassTest1' implicitly declares Interface '_ComClassTest1', which conflicts with a member of the same name in Class 'ComClassBase'. Use 'Microsoft.VisualBasic.ComClassAttribute(InterfaceShadows:=True)' if you want to hide the name on the base ComClassBase.
+BC42101: 'Microsoft.VisualBasic.ComClassAttribute' on class 'ComClassTest1' implicitly declares Interface '__ComClassTest1', which conflicts with a member of the same name in Class 'ComClassBase'. Use 'Microsoft.VisualBasic.ComClassAttribute(InterfaceShadows:=True)' if you want to hide the name on the base ComClassBase.
 Public Class ComClassTest1
              ~~~~~~~~~~~~~
-BC42101: 'Microsoft.VisualBasic.ComClassAttribute' on class 'ComClassTest1' implicitly declares Interface '_ComClassTest1', which conflicts with a member of the same name in Class 'ComClassBase'. Use 'Microsoft.VisualBasic.ComClassAttribute(InterfaceShadows:=True)' if you want to hide the name on the base ComClassBase.
+BC42101: 'Microsoft.VisualBasic.ComClassAttribute' on class 'ComClassTest1' implicitly declares Interface '__ComClassTest1', which conflicts with a member of the same name in Class 'ComClassBase'. Use 'Microsoft.VisualBasic.ComClassAttribute(InterfaceShadows:=True)' if you want to hide the name on the base ComClassBase.
 Public Class ComClassTest1
              ~~~~~~~~~~~~~
 </expected>
@@ -2863,10 +2863,10 @@ End Class
 
             Dim warnings =
 <expected>
-BC42101: 'Microsoft.VisualBasic.ComClassAttribute' on class 'ComClassTest1' implicitly declares Interface '__ComClassTest1', which conflicts with a member of the same name in Class 'ComClassBase'. Use 'Microsoft.VisualBasic.ComClassAttribute(InterfaceShadows:=True)' if you want to hide the name on the base ComClassBase.
+BC42101: 'Microsoft.VisualBasic.ComClassAttribute' on class 'ComClassTest1' implicitly declares Interface '_ComClassTest1', which conflicts with a member of the same name in Class 'ComClassBase'. Use 'Microsoft.VisualBasic.ComClassAttribute(InterfaceShadows:=True)' if you want to hide the name on the base ComClassBase.
 Public Class ComClassTest1
              ~~~~~~~~~~~~~
-BC42101: 'Microsoft.VisualBasic.ComClassAttribute' on class 'ComClassTest1' implicitly declares Interface '_ComClassTest1', which conflicts with a member of the same name in Class 'ComClassBase'. Use 'Microsoft.VisualBasic.ComClassAttribute(InterfaceShadows:=True)' if you want to hide the name on the base ComClassBase.
+BC42101: 'Microsoft.VisualBasic.ComClassAttribute' on class 'ComClassTest1' implicitly declares Interface '__ComClassTest1', which conflicts with a member of the same name in Class 'ComClassBase'. Use 'Microsoft.VisualBasic.ComClassAttribute(InterfaceShadows:=True)' if you want to hide the name on the base ComClassBase.
 Public Class ComClassTest1
              ~~~~~~~~~~~~~
 BC42102: 'Public WriteOnly Property P2 As Object' cannot be exposed to COM as a property 'Let'. You will not be able to assign non-object values (such as numbers or strings) to this property from Visual Basic 6.0 using a 'Let' statement.
@@ -3556,10 +3556,10 @@ End Class
 BC32500: 'ComClassAttribute' cannot be applied because the format of the GUID '(7666AC25-855F-4534-BC55-27BF09D49D45)' is not correct.
 Public Class ComClassTest
              ~~~~~~~~~~~~
-BC32500: 'ComClassAttribute' cannot be applied because the format of the GUID '{7666AC25-855F-4534-BC55-27BF09D49D44}' is not correct.
+BC32500: 'ComClassAttribute' cannot be applied because the format of the GUID '7666AC25855F4534BC5527BF09D49D46' is not correct.
 Public Class ComClassTest
              ~~~~~~~~~~~~
-BC32500: 'ComClassAttribute' cannot be applied because the format of the GUID '7666AC25855F4534BC5527BF09D49D46' is not correct.
+BC32500: 'ComClassAttribute' cannot be applied because the format of the GUID '{7666AC25-855F-4534-BC55-27BF09D49D44}' is not correct.
 Public Class ComClassTest
              ~~~~~~~~~~~~
 </expected>
diff --git a/src/EditorFeatures/CSharpTest/CodeActions/InlineTemporary/InlineTemporaryTests.cs b/src/EditorFeatures/CSharpTest/CodeActions/InlineTemporary/InlineTemporaryTests.cs
index 32d5e70bee638..198428881d8f6 100644
--- a/src/EditorFeatures/CSharpTest/CodeActions/InlineTemporary/InlineTemporaryTests.cs
+++ b/src/EditorFeatures/CSharpTest/CodeActions/InlineTemporary/InlineTemporaryTests.cs
@@ -2291,7 +2291,7 @@ class Program
 {
     static void Main(string[] args)
     {
-        Console.WriteLine((Func<int?, int?>)((int? s) => { return s; }));
+        Console.WriteLine((int? s) => { return s; });
     }
 }");
         }
diff --git a/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/ExtensionMethodImportCompletionProviderTests.cs b/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/ExtensionMethodImportCompletionProviderTests.cs
index 1362cc9ea5e5c..4eee64c9b9f48 100644
--- a/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/ExtensionMethodImportCompletionProviderTests.cs
+++ b/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/ExtensionMethodImportCompletionProviderTests.cs
@@ -34,16 +34,13 @@ public class ExtensionMethodImportCompletionProviderTests : AbstractCSharpComple
 
         private bool HideAdvancedMembers { get; set; }
 
-        private bool UsePartialSemantic { get; set; } = false;
-
         protected override OptionSet WithChangedOptions(OptionSet options)
         {
-            return options
+            return base.WithChangedOptions(options)
                 .WithChangedOption(CompletionOptions.ShowItemsFromUnimportedNamespaces, LanguageNames.CSharp, ShowImportCompletionItemsOptionValue)
                 .WithChangedOption(CompletionServiceOptions.IsExpandedCompletion, IsExpandedCompletion)
                 .WithChangedOption(CompletionOptions.HideAdvancedMembers, LanguageNames.CSharp, HideAdvancedMembers)
-                .WithChangedOption(CompletionServiceOptions.TimeoutInMillisecondsForExtensionMethodImportCompletion, TimeoutInMilliseconds)
-                .WithChangedOption(CompletionServiceOptions.UsePartialSemanticForImportCompletion, UsePartialSemantic);
+                .WithChangedOption(CompletionServiceOptions.TimeoutInMillisecondsForExtensionMethodImportCompletion, TimeoutInMilliseconds);
         }
 
         protected override TestComposition GetComposition()
diff --git a/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/OverrideCompletionProviderTests.cs b/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/OverrideCompletionProviderTests.cs
index 98fbf90a80ee8..9b8ea9bfd8df9 100644
--- a/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/OverrideCompletionProviderTests.cs
+++ b/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/OverrideCompletionProviderTests.cs
@@ -30,7 +30,7 @@ internal override Type GetCompletionProviderType()
 
         protected override OptionSet WithChangedOptions(OptionSet options)
         {
-            return options
+            return base.WithChangedOptions(options)
                 .WithChangedOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement)
                 .WithChangedOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement);
         }
diff --git a/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/OverrideCompletionProviderTests_ExpressionBody.cs b/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/OverrideCompletionProviderTests_ExpressionBody.cs
index 68974f2752894..1bf07caa2951b 100644
--- a/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/OverrideCompletionProviderTests_ExpressionBody.cs
+++ b/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/OverrideCompletionProviderTests_ExpressionBody.cs
@@ -24,7 +24,7 @@ internal override Type GetCompletionProviderType()
 
         protected override OptionSet WithChangedOptions(OptionSet options)
         {
-            return options
+            return base.WithChangedOptions(options)
                 .WithChangedOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSuggestionEnforcement)
                 .WithChangedOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.WhenPossibleWithSuggestionEnforcement)
                 .WithChangedOption(CSharpCodeStyleOptions.PreferExpressionBodiedMethods, CSharpCodeStyleOptions.WhenPossibleWithSuggestionEnforcement);
diff --git a/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/TypeImportCompletionProviderTests.cs b/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/TypeImportCompletionProviderTests.cs
index 1f14a3e9dbf15..a04d042eb99b3 100644
--- a/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/TypeImportCompletionProviderTests.cs
+++ b/src/EditorFeatures/CSharpTest/Completion/CompletionProviders/TypeImportCompletionProviderTests.cs
@@ -31,15 +31,12 @@ internal override Type GetCompletionProviderType()
 
         private bool HideAdvancedMembers { get; set; }
 
-        private bool UsePartialSemantic { get; set; } = false;
-
         protected override OptionSet WithChangedOptions(OptionSet options)
         {
-            return options
+            return base.WithChangedOptions(options)
                 .WithChangedOption(CompletionOptions.ShowItemsFromUnimportedNamespaces, LanguageNames.CSharp, ShowImportCompletionItemsOptionValue)
                 .WithChangedOption(CompletionServiceOptions.IsExpandedCompletion, IsExpandedCompletion)
-                .WithChangedOption(CompletionOptions.HideAdvancedMembers, LanguageNames.CSharp, HideAdvancedMembers)
-                .WithChangedOption(CompletionServiceOptions.UsePartialSemanticForImportCompletion, UsePartialSemantic);
+                .WithChangedOption(CompletionOptions.HideAdvancedMembers, LanguageNames.CSharp, HideAdvancedMembers);
         }
 
         protected override TestComposition GetComposition()
diff --git a/src/EditorFeatures/CSharpTest/EditAndContinue/StatementEditingTests.cs b/src/EditorFeatures/CSharpTest/EditAndContinue/StatementEditingTests.cs
index fe1ac2345998c..17c798fa60422 100644
--- a/src/EditorFeatures/CSharpTest/EditAndContinue/StatementEditingTests.cs
+++ b/src/EditorFeatures/CSharpTest/EditAndContinue/StatementEditingTests.cs
@@ -1973,6 +1973,29 @@ public void SwitchStatement_Delete_Section()
 
         #region Lambdas
 
+        [Fact]
+        public void Lambdas_AddAttribute()
+        {
+            var src1 = "Func<int, int> x = (a) => a;";
+            var src2 = "Func<int, int> x = [A][return:A]([A]a) => a;";
+
+            var edits = GetMethodEdits(src1, src2);
+
+            edits.VerifyEdits(
+                "Update [(a) => a]@21 -> [[A][return:A]([A]a) => a]@21",
+                "Update [a]@22 -> [[A]a]@35");
+
+            GetTopEdits(edits).VerifyRudeDiagnostics(
+                Diagnostic(RudeEditKind.ChangingAttributesNotSupportedByRuntime, "([A]a)", FeaturesResources.method),
+                Diagnostic(RudeEditKind.ChangingAttributesNotSupportedByRuntime, "([A]a)", FeaturesResources.method),
+                Diagnostic(RudeEditKind.ChangingAttributesNotSupportedByRuntime, "([A]a)", FeaturesResources.parameter));
+
+            GetTopEdits(edits).VerifySemantics(
+                ActiveStatementsDescription.Empty,
+                new[] { SemanticEdit(SemanticEditKind.Update, c => c.GetMember("C.F"), preserveLocalVariables: true) },
+                capabilities: EditAndContinueTestHelpers.Net6RuntimeCapabilities);
+        }
+
         [Fact]
         public void Lambdas_InVariableDeclarator()
         {
@@ -3123,6 +3146,18 @@ void F()
                 Diagnostic(RudeEditKind.ChangingLambdaReturnType, "a", CSharpFeaturesResources.lambda));
         }
 
+        [Fact]
+        public void Lambdas_Update_Signature_ReturnType2()
+        {
+            var src1 = "var x = int (int a) => a;";
+            var src2 = "var x = long (int a) => a;";
+
+            var edits = GetMethodEdits(src1, src2);
+
+            GetTopEdits(edits).VerifySemanticDiagnostics(
+                Diagnostic(RudeEditKind.ChangingLambdaReturnType, "(int a)", CSharpFeaturesResources.lambda));
+        }
+
         [Fact]
         public void Lambdas_Update_Signature_BodySyntaxOnly()
         {
diff --git a/src/EditorFeatures/CSharpTest/EditAndContinue/TopLevelEditingTests.cs b/src/EditorFeatures/CSharpTest/EditAndContinue/TopLevelEditingTests.cs
index 08c4e5828835d..dca9939939b67 100644
--- a/src/EditorFeatures/CSharpTest/EditAndContinue/TopLevelEditingTests.cs
+++ b/src/EditorFeatures/CSharpTest/EditAndContinue/TopLevelEditingTests.cs
@@ -838,6 +838,50 @@ public void Type_Modifiers_ReadOnly_Remove()
                 Diagnostic(RudeEditKind.ModifiersUpdate, "public struct C", CSharpFeaturesResources.struct_));
         }
 
+        [Theory]
+        [InlineData("[System.CLSCompliantAttribute]", "CLSCompliantAttribute")]
+        [InlineData("[System.Diagnostics.CodeAnalysis.AllowNullAttribute]", "AllowNullAttribute")]
+        [InlineData("[System.Diagnostics.CodeAnalysis.DisallowNullAttribute]", "DisallowNullAttribute")]
+        [InlineData("[System.Diagnostics.CodeAnalysis.MaybeNullAttribute]", "MaybeNullAttribute")]
+        [InlineData("[System.Diagnostics.CodeAnalysis.NotNullAttribute]", "NotNullAttribute")]
+        [InlineData("[System.NonSerializedAttribute]", "NonSerializedAttribute")]
+        [InlineData("[System.Reflection.AssemblyAlgorithmIdAttribute]", "AssemblyAlgorithmIdAttribute")]
+        [InlineData("[System.Reflection.AssemblyCultureAttribute]", "AssemblyCultureAttribute")]
+        [InlineData("[System.Reflection.AssemblyFlagsAttribute]", "AssemblyFlagsAttribute")]
+        [InlineData("[System.Reflection.AssemblyVersionAttribute]", "AssemblyVersionAttribute")]
+        [InlineData("[System.Runtime.CompilerServices.DllImportAttribute]", "DllImportAttribute")]
+        [InlineData("[System.Runtime.CompilerServices.IndexerNameAttribute]", "IndexerNameAttribute")]
+        [InlineData("[System.Runtime.CompilerServices.MethodImplAttribute]", "MethodImplAttribute")]
+        [InlineData("[System.Runtime.CompilerServices.SpecialNameAttribute]", "SpecialNameAttribute")]
+        [InlineData("[System.Runtime.CompilerServices.TypeForwardedToAttribute]", "TypeForwardedToAttribute")]
+        [InlineData("[System.Runtime.InteropServices.ComImportAttribute]", "ComImportAttribute")]
+        [InlineData("[System.Runtime.InteropServices.DefaultParameterValueAttribute]", "DefaultParameterValueAttribute")]
+        [InlineData("[System.Runtime.InteropServices.FieldOffsetAttribute]", "FieldOffsetAttribute")]
+        [InlineData("[System.Runtime.InteropServices.InAttribute]", "InAttribute")]
+        [InlineData("[System.Runtime.InteropServices.MarshalAsAttribute]", "MarshalAsAttribute")]
+        [InlineData("[System.Runtime.InteropServices.OptionalAttribute]", "OptionalAttribute")]
+        [InlineData("[System.Runtime.InteropServices.OutAttribute]", "OutAttribute")]
+        [InlineData("[System.Runtime.InteropServices.PreserveSigAttribute]", "PreserveSigAttribute")]
+        [InlineData("[System.Runtime.InteropServices.StructLayoutAttribute]", "StructLayoutAttribute")]
+        [InlineData("[System.Runtime.InteropServices.WindowsRuntime.WindowsRuntimeImportAttribute]", "WindowsRuntimeImportAttribute")]
+        [InlineData("[System.Security.DynamicSecurityMethodAttribute]", "DynamicSecurityMethodAttribute")]
+        [InlineData("[System.SerializableAttribute]", "SerializableAttribute")]
+        [InlineData("[System.Runtime.CompilerServices.AsyncMethodBuilderAttribute]", "AsyncMethodBuilderAttribute")]
+        public void Type_Attribute_Insert_SupportedByRuntime_NonCustomAttribute(string attributeType, string attributeName)
+        {
+            var src1 = @"class C { public void M(int a) {} }";
+            var src2 = attributeType + @"class C { public void M(int a) {} } ";
+
+            var edits = GetTopEdits(src1, src2);
+
+            edits.VerifyEdits(
+                "Update [class C { public void M(int a) {} }]@0 -> [" + attributeType + "class C { public void M(int a) {} }]@0");
+
+            edits.VerifyRudeDiagnostics(
+                capabilities: EditAndContinueTestHelpers.Net6RuntimeCapabilities,
+                Diagnostic(RudeEditKind.ChangingNonCustomAttribute, "class C", attributeName, FeaturesResources.class_));
+        }
+
         [Fact]
         public void Type_Attribute_Update_NotSupportedByRuntime1()
         {
@@ -7256,7 +7300,7 @@ static void Main(string[] args)
 
 class Test
 {
-    [Obsolete, Serializable]
+    [Obsolete, STAThread]
     static void Main(string[] args)
     {
         System.Console.Write(5);
@@ -7288,7 +7332,7 @@ static void Main(string[] args)
 class Test
 {
     [Obsolete]
-    [Serializable]
+    [STAThread]
     static void Main(string[] args)
     {
         System.Console.Write(5);
@@ -7318,7 +7362,7 @@ static void Main(string[] args)
 
 class Test
 {
-    [Obsolete, Serializable]
+    [Obsolete, STAThread]
     static void Main(string[] args)
     {
         System.Console.Write(5);
@@ -7400,7 +7444,7 @@ public void MethodUpdate_DeleteAttribute2()
 
 class Test
 {
-    [Obsolete, Serializable]
+    [Obsolete, STAThread]
     static void Main(string[] args)
     {
         System.Console.Write(5);
@@ -7432,7 +7476,7 @@ public void MethodUpdate_DeleteAttribute3()
 class Test
 {
     [Obsolete]
-    [Serializable]
+    [STAThread]
     static void Main(string[] args)
     {
         System.Console.Write(5);
@@ -15188,22 +15232,6 @@ public void Parameter_Attribute_Insert()
                 capabilities: EditAndContinueTestHelpers.Net6RuntimeCapabilities);
         }
 
-        [Fact]
-        public void Parameter_Attribute_Insert_SupportedByRuntime_NonCustomAttribute()
-        {
-            var src1 = @"class C { public void M(int a) {} }";
-            var src2 = @"class C { public void M([System.Runtime.InteropServices.InAttribute]int a) {} } ";
-
-            var edits = GetTopEdits(src1, src2);
-
-            edits.VerifyEdits(
-                "Update [int a]@24 -> [[System.Runtime.InteropServices.InAttribute]int a]@24");
-
-            edits.VerifyRudeDiagnostics(
-                capabilities: EditAndContinueTestHelpers.Net6RuntimeCapabilities,
-                Diagnostic(RudeEditKind.ChangingAttributesNotSupportedByRuntime, "int a", FeaturesResources.parameter));
-        }
-
         [Fact]
         public void Parameter_Attribute_Insert_SupportedByRuntime_SecurityAttribute1()
         {
@@ -15219,7 +15247,7 @@ public void Parameter_Attribute_Insert_SupportedByRuntime_SecurityAttribute1()
 
             edits.VerifyRudeDiagnostics(
                 capabilities: EditAndContinueTestHelpers.Net6RuntimeCapabilities,
-                Diagnostic(RudeEditKind.ChangingAttributesNotSupportedByRuntime, "int a", FeaturesResources.parameter));
+                Diagnostic(RudeEditKind.ChangingNonCustomAttribute, "int a", "AAttribute", FeaturesResources.parameter));
         }
 
         [Fact]
@@ -15238,7 +15266,7 @@ public void Parameter_Attribute_Insert_SupportedByRuntime_SecurityAttribute2()
 
             edits.VerifyRudeDiagnostics(
                 capabilities: EditAndContinueTestHelpers.Net6RuntimeCapabilities,
-                Diagnostic(RudeEditKind.ChangingAttributesNotSupportedByRuntime, "int a", FeaturesResources.parameter));
+                Diagnostic(RudeEditKind.ChangingNonCustomAttribute, "int a", "AAttribute", FeaturesResources.parameter));
         }
 
         [Fact]
diff --git a/src/EditorFeatures/CSharpTest/QuickInfo/SyntacticQuickInfoSourceTests.cs b/src/EditorFeatures/CSharpTest/QuickInfo/SyntacticQuickInfoSourceTests.cs
index dea17fb102940..7af1d730b5b53 100644
--- a/src/EditorFeatures/CSharpTest/QuickInfo/SyntacticQuickInfoSourceTests.cs
+++ b/src/EditorFeatures/CSharpTest/QuickInfo/SyntacticQuickInfoSourceTests.cs
@@ -15,9 +15,11 @@
 using Microsoft.CodeAnalysis.Editor.UnitTests.QuickInfo;
 using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
 using Microsoft.CodeAnalysis.QuickInfo;
+using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.CodeAnalysis.Test.Utilities;
 using Microsoft.VisualStudio.Text;
 using Microsoft.VisualStudio.Text.Adornments;
+using Microsoft.VisualStudio.Utilities;
 using Moq;
 using Roslyn.Test.Utilities;
 using Xunit;
@@ -289,8 +291,13 @@ protected override async Task AssertContentIsAsync(
 
             var trackingSpan = new Mock<ITrackingSpan>(MockBehavior.Strict);
             var threadingContext = workspace.ExportProvider.GetExportedValue<IThreadingContext>();
+            var operationExecutor = workspace.ExportProvider.GetExportedValue<IUIThreadOperationExecutor>();
             var streamingPresenter = workspace.ExportProvider.GetExport<IStreamingFindUsagesPresenter>();
-            var quickInfoItem = await IntellisenseQuickInfoBuilder.BuildItemAsync(trackingSpan.Object, info, document, threadingContext, streamingPresenter, CancellationToken.None);
+            var quickInfoItem = await IntellisenseQuickInfoBuilder.BuildItemAsync(
+                trackingSpan.Object, info, document,
+                threadingContext, operationExecutor,
+                AsynchronousOperationListenerProvider.NullListener,
+                streamingPresenter, CancellationToken.None);
             var containerElement = quickInfoItem.Item as ContainerElement;
 
             var textElements = containerElement.Elements.OfType<ClassifiedTextElement>();
diff --git a/src/EditorFeatures/CSharpTest/ReplaceDefaultLiteral/ReplaceDefaultLiteralTests.cs b/src/EditorFeatures/CSharpTest/ReplaceDefaultLiteral/ReplaceDefaultLiteralTests.cs
index c2a2914d4bee8..24bf4d69af564 100644
--- a/src/EditorFeatures/CSharpTest/ReplaceDefaultLiteral/ReplaceDefaultLiteralTests.cs
+++ b/src/EditorFeatures/CSharpTest/ReplaceDefaultLiteral/ReplaceDefaultLiteralTests.cs
@@ -781,24 +781,38 @@ void M()
 
         [Fact]
         public async Task TestCSharp7_1_InIsPattern_Lambda()
+        {
+            await TestMissingWithLanguageVersionsAsync(
+@"class C
+{
+    void M()
+    { 
+        var value = () => { };
+        if (value is [||]default) { }
+    }
+}", ImmutableArray.Create(LanguageVersion.CSharp7_1));
+        }
+
+        [Fact]
+        public async Task TestCSharpLatest_InIsPattern_Lambda()
         {
             await TestWithLanguageVersionsAsync(
-$@"class C
-{{
+@"class C
+{
     void M()
-    {{ 
-        var value = () => {{ }};
-        if (value is [||]default) {{ }}
-    }}
-}}",
-$@"class C
-{{
+    { 
+        var value = () => { };
+        if (value is [||]default) { }
+    }
+}",
+@"class C
+{
     void M()
-    {{ 
-        var value = () => {{ }};
-        if (value is null) {{ }}
-    }}
-}}", s_csharp7_1above);
+    { 
+        var value = () => { };
+        if (value is null) { }
+    }
+}", ImmutableArray.Create(LanguageVersion.Latest));
         }
 
         [Fact]
diff --git a/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs b/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs
index 3a582b5722cd1..a0c1478b13109 100644
--- a/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs
+++ b/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTag.cs
@@ -36,12 +36,10 @@ internal class InlineHintsTag : IntraTextAdornmentTag
     {
         public const string TagId = "inline hints";
 
-        private readonly IToolTipService _toolTipService;
         private readonly ITextView _textView;
         private readonly SnapshotSpan _span;
         private readonly InlineHint _hint;
-        private readonly IThreadingContext _threadingContext;
-        private readonly Lazy<IStreamingFindUsagesPresenter> _streamingPresenter;
+        private readonly InlineHintsTaggerProvider _taggerProvider;
 
         private InlineHintsTag(
             FrameworkElement adornment,
@@ -56,9 +54,7 @@ private InlineHintsTag(
             _textView = textView;
             _span = span;
             _hint = hint;
-            _streamingPresenter = taggerProvider.StreamingFindUsagesPresenter;
-            _threadingContext = taggerProvider.ThreadingContext;
-            _toolTipService = taggerProvider.ToolTipService;
+            _taggerProvider = taggerProvider;
 
             // Sets the tooltip to a string so that the tool tip opening event can be triggered
             // Tooltip value does not matter at this point because it immediately gets overwritten by the correct
@@ -95,7 +91,12 @@ public async Task<IReadOnlyCollection<object>> CreateDescriptionAsync(Cancellati
                 var taggedText = await _hint.GetDescriptionAsync(document, cancellationToken).ConfigureAwait(false);
                 if (!taggedText.IsDefaultOrEmpty)
                 {
-                    var context = new IntellisenseQuickInfoBuilderContext(document, _threadingContext, _streamingPresenter);
+                    var context = new IntellisenseQuickInfoBuilderContext(
+                        document,
+                        _taggerProvider.ThreadingContext,
+                        _taggerProvider.OperationExecutor,
+                        _taggerProvider.AsynchronousOperationListener,
+                        _taggerProvider.StreamingFindUsagesPresenter);
                     return Implementation.IntelliSense.Helpers.BuildInteractiveTextElements(taggedText, context);
                 }
             }
@@ -237,7 +238,7 @@ bool KeepOpen()
                 return !(mousePoint.X > hintUIElement.ActualWidth || mousePoint.X < 0 || mousePoint.Y > hintUIElement.ActualHeight || mousePoint.Y < 0);
             }
 
-            var toolTipPresenter = _toolTipService.CreatePresenter(_textView, new ToolTipParameters(trackMouse: true, ignoreBufferChange: false, KeepOpen));
+            var toolTipPresenter = _taggerProvider.ToolTipService.CreatePresenter(_textView, new ToolTipParameters(trackMouse: true, ignoreBufferChange: false, KeepOpen));
             _ = StartToolTipServiceAsync(toolTipPresenter);
         }
 
@@ -246,8 +247,9 @@ bool KeepOpen()
         /// </summary>
         private async Task StartToolTipServiceAsync(IToolTipPresenter toolTipPresenter)
         {
-            var uiList = await Task.Run(() => CreateDescriptionAsync(_threadingContext.DisposalToken)).ConfigureAwait(false);
-            await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(_threadingContext.DisposalToken);
+            var threadingContext = _taggerProvider.ThreadingContext;
+            var uiList = await Task.Run(() => CreateDescriptionAsync(threadingContext.DisposalToken)).ConfigureAwait(false);
+            await threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(threadingContext.DisposalToken);
 
             toolTipPresenter.StartOrUpdate(_textView.TextSnapshot.CreateTrackingSpan(_span.Start, _span.Length, SpanTrackingMode.EdgeInclusive), uiList);
         }
diff --git a/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTaggerProvider.cs b/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTaggerProvider.cs
index 48b8fa3ed6147..38386268787be 100644
--- a/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTaggerProvider.cs
+++ b/src/EditorFeatures/Core.Wpf/InlineHints/InlineHintsTaggerProvider.cs
@@ -8,6 +8,7 @@
 using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
 using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.VisualStudio.Text;
 using Microsoft.VisualStudio.Text.Adornments;
 using Microsoft.VisualStudio.Text.Classification;
@@ -31,6 +32,8 @@ internal class InlineHintsTaggerProvider : IViewTaggerProvider
         public readonly IClassificationFormatMapService ClassificationFormatMapService;
         public readonly IClassificationTypeRegistryService ClassificationTypeRegistryService;
         public readonly IThreadingContext ThreadingContext;
+        public readonly IUIThreadOperationExecutor OperationExecutor;
+        public readonly IAsynchronousOperationListener AsynchronousOperationListener;
         public readonly IToolTipService ToolTipService;
         public readonly ClassificationTypeMap TypeMap;
         public readonly Lazy<IStreamingFindUsagesPresenter> StreamingFindUsagesPresenter;
@@ -42,6 +45,8 @@ public InlineHintsTaggerProvider(
             IClassificationFormatMapService classificationFormatMapService,
             IClassificationTypeRegistryService classificationTypeRegistryService,
             IThreadingContext threadingContext,
+            IUIThreadOperationExecutor operationExecutor,
+            IAsynchronousOperationListenerProvider listenerProvider,
             IToolTipService toolTipService,
             ClassificationTypeMap typeMap,
             Lazy<IStreamingFindUsagesPresenter> streamingFindUsagesPresenter)
@@ -50,9 +55,12 @@ public InlineHintsTaggerProvider(
             this.ClassificationFormatMapService = classificationFormatMapService;
             this.ClassificationTypeRegistryService = classificationTypeRegistryService;
             this.ThreadingContext = threadingContext;
+            this.OperationExecutor = operationExecutor;
             this.ToolTipService = toolTipService;
             this.StreamingFindUsagesPresenter = streamingFindUsagesPresenter;
             this.TypeMap = typeMap;
+
+            this.AsynchronousOperationListener = listenerProvider.GetListener(FeatureAttribute.InlineHints);
         }
 
         public ITagger<T>? CreateTagger<T>(ITextView textView, ITextBuffer buffer) where T : ITag
diff --git a/src/EditorFeatures/Core/GoToDefinition/GoToDefinitionHelpers.cs b/src/EditorFeatures/Core/GoToDefinition/GoToDefinitionHelpers.cs
index 9bf6adbd840f6..77a2cca7c48f6 100644
--- a/src/EditorFeatures/Core/GoToDefinition/GoToDefinitionHelpers.cs
+++ b/src/EditorFeatures/Core/GoToDefinition/GoToDefinitionHelpers.cs
@@ -107,18 +107,26 @@ public static bool TryGoToDefinition(
             IStreamingFindUsagesPresenter streamingPresenter,
             CancellationToken cancellationToken,
             bool thirdPartyNavigationAllowed = true)
+        {
+            return threadingContext.JoinableTaskFactory.Run(
+                () => TryGoToDefinitionAsync(symbol, solution, threadingContext, streamingPresenter, cancellationToken, thirdPartyNavigationAllowed));
+        }
+
+        public static async Task<bool> TryGoToDefinitionAsync(
+            ISymbol symbol,
+            Solution solution,
+            IThreadingContext threadingContext,
+            IStreamingFindUsagesPresenter streamingPresenter,
+            CancellationToken cancellationToken,
+            bool thirdPartyNavigationAllowed = true)
         {
             var title = string.Format(EditorFeaturesResources._0_declarations,
                 FindUsagesHelpers.GetDisplayName(symbol));
 
-            return threadingContext.JoinableTaskFactory.Run(
-                async () =>
-                {
-                    var definitions = await GetDefinitionsAsync(symbol, solution, thirdPartyNavigationAllowed, cancellationToken).ConfigureAwait(false);
+            var definitions = await GetDefinitionsAsync(symbol, solution, thirdPartyNavigationAllowed, cancellationToken).ConfigureAwait(false);
 
-                    return await streamingPresenter.TryNavigateToOrPresentItemsAsync(
-                        threadingContext, solution.Workspace, title, definitions, cancellationToken).ConfigureAwait(false);
-                });
+            return await streamingPresenter.TryNavigateToOrPresentItemsAsync(
+                threadingContext, solution.Workspace, title, definitions, cancellationToken).ConfigureAwait(false);
         }
     }
 }
diff --git a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/CompletionSource.cs b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/CompletionSource.cs
index 2381615c42cb2..fe554d7be96d7 100644
--- a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/CompletionSource.cs
+++ b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/CompletionSource.cs
@@ -19,6 +19,7 @@
 using Microsoft.CodeAnalysis.LanguageServices;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Shared.Extensions;
+using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.CodeAnalysis.Text.Shared.Extensions;
 using Microsoft.VisualStudio.Core.Imaging;
@@ -29,6 +30,7 @@
 using AsyncCompletionData = Microsoft.VisualStudio.Language.Intellisense.AsyncCompletion.Data;
 using RoslynCompletionItem = Microsoft.CodeAnalysis.Completion.CompletionItem;
 using VSCompletionItem = Microsoft.VisualStudio.Language.Intellisense.AsyncCompletion.Data.CompletionItem;
+using VSUtilities = Microsoft.VisualStudio.Utilities;
 
 namespace Microsoft.CodeAnalysis.Editor.Implementation.IntelliSense.AsyncCompletion
 {
@@ -60,16 +62,22 @@ internal sealed class CompletionSource : ForegroundThreadAffinitizedObject, IAsy
         private readonly bool _isDebuggerTextView;
         private readonly ImmutableHashSet<string> _roles;
         private readonly Lazy<IStreamingFindUsagesPresenter> _streamingPresenter;
+        private readonly VSUtilities.IUIThreadOperationExecutor _operationExecutor;
+        private readonly IAsynchronousOperationListener _asyncListener;
         private bool _snippetCompletionTriggeredIndirectly;
 
         internal CompletionSource(
             ITextView textView,
             Lazy<IStreamingFindUsagesPresenter> streamingPresenter,
-            IThreadingContext threadingContext)
+            IThreadingContext threadingContext,
+            VSUtilities.IUIThreadOperationExecutor operationExecutor,
+            IAsynchronousOperationListener asyncListener)
             : base(threadingContext)
         {
             _textView = textView;
             _streamingPresenter = streamingPresenter;
+            _operationExecutor = operationExecutor;
+            _asyncListener = asyncListener;
             _isDebuggerTextView = textView is IDebuggerTextView;
             _roles = textView.Roles.ToImmutableHashSet();
         }
@@ -369,19 +377,16 @@ private bool TryInvokeSnippetCompletion(
 
             var document = triggerLocation.Snapshot.GetOpenDocumentInCurrentContextWithChanges();
             if (document == null)
-            {
                 return null;
-            }
 
             var service = document.GetLanguageService<CompletionService>();
             if (service == null)
-            {
                 return null;
-            }
 
             var description = await service.GetDescriptionAsync(document, roslynItem, cancellationToken).ConfigureAwait(false);
 
-            var context = new IntellisenseQuickInfoBuilderContext(document, ThreadingContext, _streamingPresenter);
+            var context = new IntellisenseQuickInfoBuilderContext(
+                document, ThreadingContext, _operationExecutor, _asyncListener, _streamingPresenter);
             var elements = IntelliSense.Helpers.BuildInteractiveTextElements(description.TaggedParts, context).ToArray();
             if (elements.Length == 0)
             {
diff --git a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/CompletionSourceProvider.cs b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/CompletionSourceProvider.cs
index 024737ced4e26..67090d4d53ed8 100644
--- a/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/CompletionSourceProvider.cs
+++ b/src/EditorFeatures/Core/Implementation/IntelliSense/AsyncCompletion/CompletionSourceProvider.cs
@@ -8,6 +8,7 @@
 using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
 using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.VisualStudio.Language.Intellisense.AsyncCompletion;
 using Microsoft.VisualStudio.Text.Editor;
 using Microsoft.VisualStudio.Utilities;
@@ -20,26 +21,30 @@ namespace Microsoft.CodeAnalysis.Editor.Implementation.IntelliSense.AsyncComplet
     internal class CompletionSourceProvider : IAsyncCompletionSourceProvider
     {
         private readonly IThreadingContext _threadingContext;
+        private readonly IUIThreadOperationExecutor _operationExecutor;
         private readonly Lazy<IStreamingFindUsagesPresenter> _streamingPresenter;
+        private readonly IAsynchronousOperationListener _listener;
 
         [ImportingConstructor]
         [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
         public CompletionSourceProvider(
             IThreadingContext threadingContext,
+            IUIThreadOperationExecutor operationExecutor,
+            IAsynchronousOperationListenerProvider listenerProvider,
             Lazy<IStreamingFindUsagesPresenter> streamingPresenter)
         {
             _threadingContext = threadingContext;
+            _operationExecutor = operationExecutor;
             _streamingPresenter = streamingPresenter;
+            _listener = listenerProvider.GetListener(FeatureAttribute.CompletionSet);
         }
 
         public IAsyncCompletionSource? GetOrCreate(ITextView textView)
         {
             if (textView.TextBuffer.IsInLspEditorContext())
-            {
                 return null;
-            }
 
-            return new CompletionSource(textView, _streamingPresenter, _threadingContext);
+            return new CompletionSource(textView, _streamingPresenter, _threadingContext, _operationExecutor, _listener);
         }
     }
 }
diff --git a/src/EditorFeatures/Core/Implementation/IntelliSense/Helpers.cs b/src/EditorFeatures/Core/Implementation/IntelliSense/Helpers.cs
index 6e9ceb2cf3624..ebeed0b970d8c 100644
--- a/src/EditorFeatures/Core/Implementation/IntelliSense/Helpers.cs
+++ b/src/EditorFeatures/Core/Implementation/IntelliSense/Helpers.cs
@@ -7,13 +7,17 @@
 using System.Collections.Immutable;
 using System.Linq;
 using System.Threading;
+using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Classification;
 using Microsoft.CodeAnalysis.Editor.GoToDefinition;
 using Microsoft.CodeAnalysis.Editor.Host;
 using Microsoft.CodeAnalysis.Editor.Implementation.IntelliSense.QuickInfo;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
+using Microsoft.CodeAnalysis.ErrorReporting;
 using Microsoft.CodeAnalysis.Shared.Extensions;
+using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.VisualStudio.Text.Adornments;
+using Microsoft.VisualStudio.Utilities;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.Editor.Implementation.IntelliSense
@@ -132,9 +136,11 @@ private static IReadOnlyCollection<object> BuildInteractiveTextElements(
                 {
                     // This is tagged text getting added to the current line we are building.
                     var style = GetClassifiedTextRunStyle(part.Style);
-                    if (part.NavigationTarget is object &&
-                        context?.ThreadingContext is ThreadingContext threadingContext &&
-                        context.StreamingPresenter is Lazy<IStreamingFindUsagesPresenter> streamingPresenter)
+                    if (part.NavigationTarget is not null &&
+                        context?.ThreadingContext is { } threadingContext &&
+                        context?.OperationExecutor is { } operationExecutor &&
+                        context?.AsynchronousOperationListener is { } asyncListener &&
+                        context?.StreamingPresenter is { } streamingPresenter)
                     {
                         var document = context.Document;
                         if (Uri.TryCreate(part.NavigationTarget, UriKind.Absolute, out var absoluteUri))
@@ -153,7 +159,8 @@ private static IReadOnlyCollection<object> BuildInteractiveTextElements(
                             var workspace = document.Project.Solution.Workspace;
                             currentRuns.Add(new ClassifiedTextRun(
                                 part.Tag.ToClassificationTypeName(), part.Text,
-                                () => NavigateToQuickInfoTarget(target, workspace, documentId, threadingContext, streamingPresenter.Value), tooltip, style));
+                                () => _ = NavigateToQuickInfoTargetAsync(target, workspace, documentId, threadingContext, operationExecutor, asyncListener, streamingPresenter.Value),
+                                tooltip, style));
                         }
                     }
                     else
@@ -180,30 +187,46 @@ private static IReadOnlyCollection<object> BuildInteractiveTextElements(
             return paragraphs;
         }
 
-        private static void NavigateToQuickInfoTarget(
+        private static async Task NavigateToQuickInfoTargetAsync(
             string navigationTarget,
             Workspace workspace,
             DocumentId documentId,
             IThreadingContext threadingContext,
+            IUIThreadOperationExecutor operationExecutor,
+            IAsynchronousOperationListener asyncListener,
             IStreamingFindUsagesPresenter streamingPresenter)
         {
-            var solution = workspace.CurrentSolution;
-            SymbolKeyResolution resolvedSymbolKey;
             try
             {
-                var project = solution.GetRequiredProject(documentId.ProjectId);
-                resolvedSymbolKey = SymbolKey.ResolveString(navigationTarget, project.GetRequiredCompilationAsync(CancellationToken.None).WaitAndGetResult(CancellationToken.None), cancellationToken: CancellationToken.None);
+                using var token = asyncListener.BeginAsyncOperation(nameof(NavigateToQuickInfoTargetAsync));
+                using var context = operationExecutor.BeginExecute(EditorFeaturesResources.IntelliSense, EditorFeaturesResources.Navigating, allowCancellation: true, showProgress: false);
+
+                var cancellationToken = context.UserCancellationToken;
+                var solution = workspace.CurrentSolution;
+                SymbolKeyResolution resolvedSymbolKey;
+                try
+                {
+                    var project = solution.GetRequiredProject(documentId.ProjectId);
+                    var compilation = await project.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false);
+                    resolvedSymbolKey = SymbolKey.ResolveString(navigationTarget, compilation, cancellationToken: cancellationToken);
+                }
+                catch
+                {
+                    // Ignore symbol resolution failures. It likely is just a badly formed URI.
+                    return;
+                }
+
+                if (resolvedSymbolKey.GetAnySymbol() is { } symbol)
+                {
+                    await GoToDefinitionHelpers.TryGoToDefinitionAsync(
+                        symbol, solution, threadingContext, streamingPresenter, cancellationToken).ConfigureAwait(false);
+                }
             }
-            catch
+            catch (OperationCanceledException)
             {
-                // Ignore symbol resolution failures. It likely is just a badly formed URI.
-                return;
             }
-
-            if (resolvedSymbolKey.GetAnySymbol() is { } symbol)
+            catch (Exception ex) when (FatalError.ReportAndCatch(ex))
             {
-                GoToDefinitionHelpers.TryGoToDefinition(symbol, solution, threadingContext, streamingPresenter, CancellationToken.None);
-                return;
             }
         }
 
diff --git a/src/EditorFeatures/Core/Implementation/IntelliSense/QuickInfo/IntellisenseQuickInfoBuilder.cs b/src/EditorFeatures/Core/Implementation/IntelliSense/QuickInfo/IntellisenseQuickInfoBuilder.cs
index 89a300097727c..a6f30d0f39a27 100644
--- a/src/EditorFeatures/Core/Implementation/IntelliSense/QuickInfo/IntellisenseQuickInfoBuilder.cs
+++ b/src/EditorFeatures/Core/Implementation/IntelliSense/QuickInfo/IntellisenseQuickInfoBuilder.cs
@@ -14,9 +14,10 @@
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
 using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.QuickInfo;
+using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.VisualStudio.Text;
 using Microsoft.VisualStudio.Text.Adornments;
-
+using Microsoft.VisualStudio.Utilities;
 using CodeAnalysisQuickInfoItem = Microsoft.CodeAnalysis.QuickInfo.QuickInfoItem;
 using IntellisenseQuickInfoItem = Microsoft.VisualStudio.Language.Intellisense.QuickInfoItem;
 
@@ -127,10 +128,12 @@ internal static async Task<IntellisenseQuickInfoItem> BuildItemAsync(
             CodeAnalysisQuickInfoItem quickInfoItem,
             Document document,
             IThreadingContext threadingContext,
+            IUIThreadOperationExecutor operationExecutor,
+            IAsynchronousOperationListener asyncListener,
             Lazy<IStreamingFindUsagesPresenter> streamingPresenter,
             CancellationToken cancellationToken)
         {
-            var context = new IntellisenseQuickInfoBuilderContext(document, threadingContext, streamingPresenter);
+            var context = new IntellisenseQuickInfoBuilderContext(document, threadingContext, operationExecutor, asyncListener, streamingPresenter);
             var content = await BuildInteractiveContentAsync(quickInfoItem, context, cancellationToken).ConfigureAwait(false);
 
             return new IntellisenseQuickInfoItem(trackingSpan, content);
diff --git a/src/EditorFeatures/Core/Implementation/IntelliSense/QuickInfo/IntellisenseQuickInfoBuilderContext.cs b/src/EditorFeatures/Core/Implementation/IntelliSense/QuickInfo/IntellisenseQuickInfoBuilderContext.cs
index ca453d49c4b66..1ea0c1ebecc2d 100644
--- a/src/EditorFeatures/Core/Implementation/IntelliSense/QuickInfo/IntellisenseQuickInfoBuilderContext.cs
+++ b/src/EditorFeatures/Core/Implementation/IntelliSense/QuickInfo/IntellisenseQuickInfoBuilderContext.cs
@@ -5,6 +5,8 @@
 using System;
 using Microsoft.CodeAnalysis.Editor.Host;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
+using Microsoft.CodeAnalysis.Shared.TestHooks;
+using Microsoft.VisualStudio.Utilities;
 
 namespace Microsoft.CodeAnalysis.Editor.Implementation.IntelliSense.QuickInfo
 {
@@ -16,15 +18,21 @@ internal sealed class IntellisenseQuickInfoBuilderContext
         public IntellisenseQuickInfoBuilderContext(
             Document document,
             IThreadingContext? threadingContext,
+            IUIThreadOperationExecutor? operationExecutor,
+            IAsynchronousOperationListener? asynchronousOperationListener,
             Lazy<IStreamingFindUsagesPresenter>? streamingPresenter)
         {
             Document = document;
             ThreadingContext = threadingContext;
+            OperationExecutor = operationExecutor;
             StreamingPresenter = streamingPresenter;
+            AsynchronousOperationListener = asynchronousOperationListener;
         }
 
         public Document Document { get; }
         public IThreadingContext? ThreadingContext { get; }
+        public IUIThreadOperationExecutor? OperationExecutor { get; }
+        public IAsynchronousOperationListener? AsynchronousOperationListener { get; }
         public Lazy<IStreamingFindUsagesPresenter>? StreamingPresenter { get; }
     }
 }
diff --git a/src/EditorFeatures/Core/Implementation/IntelliSense/QuickInfo/QuickInfoSourceProvider.QuickInfoSource.cs b/src/EditorFeatures/Core/Implementation/IntelliSense/QuickInfo/QuickInfoSourceProvider.QuickInfoSource.cs
index d823111a2c14e..5dc55ed918d27 100644
--- a/src/EditorFeatures/Core/Implementation/IntelliSense/QuickInfo/QuickInfoSourceProvider.QuickInfoSource.cs
+++ b/src/EditorFeatures/Core/Implementation/IntelliSense/QuickInfo/QuickInfoSourceProvider.QuickInfoSource.cs
@@ -12,10 +12,12 @@
 using Microsoft.CodeAnalysis.ErrorReporting;
 using Microsoft.CodeAnalysis.Internal.Log;
 using Microsoft.CodeAnalysis.QuickInfo;
+using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.CodeAnalysis.Text.Shared.Extensions;
 using Microsoft.VisualStudio.Language.Intellisense;
 using Microsoft.VisualStudio.Text;
+using Microsoft.VisualStudio.Utilities;
 using Roslyn.Utilities;
 
 using IntellisenseQuickInfoItem = Microsoft.VisualStudio.Language.Intellisense.QuickInfoItem;
@@ -28,15 +30,21 @@ private class QuickInfoSource : IAsyncQuickInfoSource
         {
             private readonly ITextBuffer _subjectBuffer;
             private readonly IThreadingContext _threadingContext;
+            private readonly IUIThreadOperationExecutor _operationExecutor;
+            private readonly IAsynchronousOperationListener _asyncListener;
             private readonly Lazy<IStreamingFindUsagesPresenter> _streamingPresenter;
 
             public QuickInfoSource(
                 ITextBuffer subjectBuffer,
                 IThreadingContext threadingContext,
+                IUIThreadOperationExecutor operationExecutor,
+                IAsynchronousOperationListener asyncListener,
                 Lazy<IStreamingFindUsagesPresenter> streamingPresenter)
             {
                 _subjectBuffer = subjectBuffer;
                 _threadingContext = threadingContext;
+                _operationExecutor = operationExecutor;
+                _asyncListener = asyncListener;
                 _streamingPresenter = streamingPresenter;
             }
 
@@ -44,26 +52,20 @@ public async Task<IntellisenseQuickInfoItem> GetQuickInfoItemAsync(IAsyncQuickIn
             {
                 var triggerPoint = session.GetTriggerPoint(_subjectBuffer.CurrentSnapshot);
                 if (!triggerPoint.HasValue)
-                {
                     return null;
-                }
 
                 var snapshot = triggerPoint.Value.Snapshot;
                 var document = snapshot.GetOpenDocumentInCurrentContextWithChanges();
                 if (document == null)
-                {
                     return null;
-                }
 
                 var service = QuickInfoService.GetService(document);
                 if (service == null)
-                {
                     return null;
-                }
 
                 try
                 {
-                    using (Internal.Log.Logger.LogBlock(FunctionId.Get_QuickInfo_Async, cancellationToken))
+                    using (Logger.LogBlock(FunctionId.Get_QuickInfo_Async, cancellationToken))
                     {
                         cancellationToken.ThrowIfCancellationRequested();
 
@@ -72,7 +74,10 @@ public async Task<IntellisenseQuickInfoItem> GetQuickInfoItemAsync(IAsyncQuickIn
                         {
                             var textVersion = snapshot.Version;
                             var trackingSpan = textVersion.CreateTrackingSpan(item.Span.ToSpan(), SpanTrackingMode.EdgeInclusive);
-                            return await IntellisenseQuickInfoBuilder.BuildItemAsync(trackingSpan, item, document, _threadingContext, _streamingPresenter, cancellationToken).ConfigureAwait(false);
+                            return await IntellisenseQuickInfoBuilder.BuildItemAsync(
+                                trackingSpan, item, document,
+                                _threadingContext, _operationExecutor,
+                                _asyncListener, _streamingPresenter, cancellationToken).ConfigureAwait(false);
                         }
 
                         return null;
diff --git a/src/EditorFeatures/Core/Implementation/IntelliSense/QuickInfo/QuickInfoSourceProvider.cs b/src/EditorFeatures/Core/Implementation/IntelliSense/QuickInfo/QuickInfoSourceProvider.cs
index a21be43950a8f..f77a9a333b724 100644
--- a/src/EditorFeatures/Core/Implementation/IntelliSense/QuickInfo/QuickInfoSourceProvider.cs
+++ b/src/EditorFeatures/Core/Implementation/IntelliSense/QuickInfo/QuickInfoSourceProvider.cs
@@ -10,6 +10,7 @@
 using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
 using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.VisualStudio.Language.Intellisense;
 using Microsoft.VisualStudio.Text;
 using Microsoft.VisualStudio.Utilities;
@@ -22,26 +23,31 @@ namespace Microsoft.CodeAnalysis.Editor.Implementation.IntelliSense.QuickInfo
     internal partial class QuickInfoSourceProvider : IAsyncQuickInfoSourceProvider
     {
         private readonly IThreadingContext _threadingContext;
+        private readonly IUIThreadOperationExecutor _operationExecutor;
         private readonly Lazy<IStreamingFindUsagesPresenter> _streamingPresenter;
+        private readonly IAsynchronousOperationListener _listener;
 
         [ImportingConstructor]
         [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
         public QuickInfoSourceProvider(
             IThreadingContext threadingContext,
+            IUIThreadOperationExecutor operationExecutor,
+            IAsynchronousOperationListenerProvider listenerProvider,
             Lazy<IStreamingFindUsagesPresenter> streamingPresenter)
         {
             _threadingContext = threadingContext;
+            _operationExecutor = operationExecutor;
             _streamingPresenter = streamingPresenter;
+            _listener = listenerProvider.GetListener(FeatureAttribute.QuickInfo);
         }
 
         public IAsyncQuickInfoSource TryCreateQuickInfoSource(ITextBuffer textBuffer)
         {
             if (textBuffer.IsInLspEditorContext())
-            {
                 return null;
-            }
 
-            return new QuickInfoSource(textBuffer, _threadingContext, _streamingPresenter);
+            return new QuickInfoSource(
+                textBuffer, _threadingContext, _operationExecutor, _listener, _streamingPresenter);
         }
     }
 }
diff --git a/src/EditorFeatures/Core/InlineHints/InlineHintsDataTaggerProvider.cs b/src/EditorFeatures/Core/InlineHints/InlineHintsDataTaggerProvider.cs
index f4943e33c4618..20a4170bf62c8 100644
--- a/src/EditorFeatures/Core/InlineHints/InlineHintsDataTaggerProvider.cs
+++ b/src/EditorFeatures/Core/InlineHints/InlineHintsDataTaggerProvider.cs
@@ -50,9 +50,9 @@ internal class InlineHintsDataTaggerProvider : AsynchronousViewTaggerProvider<In
         public InlineHintsDataTaggerProvider(
             IThreadingContext threadingContext,
             IAsynchronousOperationListenerProvider listenerProvider)
-            : base(threadingContext, listenerProvider.GetListener(FeatureAttribute.InlineParameterNameHints))
+            : base(threadingContext, listenerProvider.GetListener(FeatureAttribute.InlineHints))
         {
-            _listener = listenerProvider.GetListener(FeatureAttribute.InlineParameterNameHints);
+            _listener = listenerProvider.GetListener(FeatureAttribute.InlineHints);
         }
 
         protected override TaggerDelay EventChangeDelay => TaggerDelay.Short;
diff --git a/src/EditorFeatures/Core/Shared/Options/FeatureOnOffOptions.cs b/src/EditorFeatures/Core/Shared/Options/FeatureOnOffOptions.cs
index 8f552821c6cc7..93b57a44dd600 100644
--- a/src/EditorFeatures/Core/Shared/Options/FeatureOnOffOptions.cs
+++ b/src/EditorFeatures/Core/Shared/Options/FeatureOnOffOptions.cs
@@ -84,6 +84,12 @@ internal static class FeatureOnOffOptions
                 defaultValue: true,
                 new RoamingProfileStorageLocation("TextEditor.%LANGUAGE%.Specific.ShowInheritanceMargin"));
 
+        public static readonly Option2<bool> InheritanceMarginCombinedWithIndicatorMargin =
+            new(nameof(FeatureOnOffOptions),
+                nameof(InheritanceMarginCombinedWithIndicatorMargin),
+                defaultValue: true,
+                new RoamingProfileStorageLocation($"TextEditor.{nameof(InheritanceMarginCombinedWithIndicatorMargin)}"));
+
         public static readonly Option2<bool> AutomaticallyCompleteStatementOnSemicolon = new(
             nameof(FeatureOnOffOptions), nameof(AutomaticallyCompleteStatementOnSemicolon), defaultValue: true,
             storageLocation: new RoamingProfileStorageLocation($"TextEditor.{nameof(AutomaticallyCompleteStatementOnSemicolon)}"));
@@ -120,6 +126,7 @@ public FeatureOnOffOptionsProvider()
             FeatureOnOffOptions.AddImportsOnPaste,
             FeatureOnOffOptions.OfferRemoveUnusedReferences,
             FeatureOnOffOptions.ShowInheritanceMargin,
+            FeatureOnOffOptions.InheritanceMarginCombinedWithIndicatorMargin,
             FeatureOnOffOptions.AutomaticallyCompleteStatementOnSemicolon,
             FeatureOnOffOptions.SkipAnalyzersForImplicitlyTriggeredBuilds);
     }
diff --git a/src/EditorFeatures/Test/EditAndContinue/RudeEditDiagnosticTests.cs b/src/EditorFeatures/Test/EditAndContinue/RudeEditDiagnosticTests.cs
index 3ab0c795fd1a9..d8f5ddbe4975e 100644
--- a/src/EditorFeatures/Test/EditAndContinue/RudeEditDiagnosticTests.cs
+++ b/src/EditorFeatures/Test/EditAndContinue/RudeEditDiagnosticTests.cs
@@ -63,6 +63,7 @@ public void ToDiagnostic()
                 RudeEditKind.ChangingStateMachineShape,
                 RudeEditKind.InternalError,
                 RudeEditKind.MemberBodyInternalError,
+                RudeEditKind.ChangingNonCustomAttribute
             };
 
             var arg3 = new HashSet<RudeEditKind>()
diff --git a/src/EditorFeatures/Test2/IntelliSense/AbstractIntellisenseQuickInfoBuilderTests.vb b/src/EditorFeatures/Test2/IntelliSense/AbstractIntellisenseQuickInfoBuilderTests.vb
index 73e1ce86b5559..573049bddb9e7 100644
--- a/src/EditorFeatures/Test2/IntelliSense/AbstractIntellisenseQuickInfoBuilderTests.vb
+++ b/src/EditorFeatures/Test2/IntelliSense/AbstractIntellisenseQuickInfoBuilderTests.vb
@@ -10,10 +10,12 @@ Imports Microsoft.CodeAnalysis.Editor.Implementation.IntelliSense.QuickInfo
 Imports Microsoft.CodeAnalysis.Editor.Shared.Utilities
 Imports Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces
 Imports Microsoft.CodeAnalysis.QuickInfo
+Imports Microsoft.CodeAnalysis.Shared.TestHooks
 Imports Microsoft.VisualStudio.Core.Imaging
 Imports Microsoft.VisualStudio.Imaging
 Imports Microsoft.VisualStudio.Text
 Imports Microsoft.VisualStudio.Text.Adornments
+Imports Microsoft.VisualStudio.Utilities
 Imports Moq
 
 Imports VSQuickInfoItem = Microsoft.VisualStudio.Language.Intellisense.QuickInfoItem
@@ -43,8 +45,13 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.IntelliSense
                 }
 
                 Dim threadingContext = workspace.ExportProvider.GetExportedValue(Of IThreadingContext)()
+                Dim operationExecutor = workspace.ExportProvider.GetExportedValue(Of IUIThreadOperationExecutor)()
                 Dim streamingPresenter = workspace.ExportProvider.GetExport(Of IStreamingFindUsagesPresenter)()
-                Return Await IntellisenseQuickInfoBuilder.BuildItemAsync(trackingSpan.Object, quickInfoItem, document, threadingContext, streamingPresenter, CancellationToken.None)
+                Return Await IntellisenseQuickInfoBuilder.BuildItemAsync(
+                    trackingSpan.Object, quickInfoItem, document,
+                    threadingContext, operationExecutor,
+                    AsynchronousOperationListenerProvider.NullListener,
+                    streamingPresenter, CancellationToken.None)
             End Using
         End Function
 
@@ -67,8 +74,13 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.IntelliSense
                 }
 
                 Dim threadingContext = workspace.ExportProvider.GetExportedValue(Of IThreadingContext)()
+                Dim operationExecutor = workspace.ExportProvider.GetExportedValue(Of IUIThreadOperationExecutor)()
                 Dim streamingPresenter = workspace.ExportProvider.GetExport(Of IStreamingFindUsagesPresenter)()
-                Return Await IntellisenseQuickInfoBuilder.BuildItemAsync(trackingSpan.Object, codeAnalysisQuickInfoItem, document, threadingContext, streamingPresenter, CancellationToken.None)
+                Return Await IntellisenseQuickInfoBuilder.BuildItemAsync(
+                    trackingSpan.Object, codeAnalysisQuickInfoItem, document,
+                    threadingContext, operationExecutor,
+                    AsynchronousOperationListenerProvider.NullListener,
+                    streamingPresenter, CancellationToken.None)
             End Using
         End Function
     End Class
diff --git a/src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests.vb b/src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests.vb
index 69b462ee266af..56bec9e3dbfbd 100644
--- a/src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests.vb
+++ b/src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests.vb
@@ -8,6 +8,7 @@ Imports System.Globalization
 Imports System.Threading
 Imports Microsoft.CodeAnalysis.Completion
 Imports Microsoft.CodeAnalysis.Completion.Providers
+Imports Microsoft.CodeAnalysis.Completion.Providers.ImportCompletion
 Imports Microsoft.CodeAnalysis.CSharp
 Imports Microsoft.CodeAnalysis.CSharp.Formatting
 Imports Microsoft.CodeAnalysis.Editor.Implementation.IntelliSense.AsyncCompletion
@@ -6648,6 +6649,118 @@ class C
             End Using
         End Function
 
+        <WpfTheory, CombinatorialData>
+        <Trait(Traits.Feature, Traits.Features.Completion)>
+        Public Async Function WarmUpTypeImportCompletionCache(populateCache As Boolean) As Task
+
+            Using state = TestStateFactory.CreateTestStateFromWorkspace(
+                <Workspace>
+                    <Project Language="C#" LanguageVersion="Preview" CommonReferences="true">
+                        <ProjectReference>RefProj</ProjectReference>
+                        <Document FilePath="C.cs"><![CDATA[
+namespace NS1
+    public class C1
+    {
+        void M()
+        {
+            $$
+        }
+    }
+}
+                        ]]></Document>
+                    </Project>
+                    <Project Language="C#" AssemblyName="RefProj" CommonReferences="true">
+                        <Document><![CDATA[
+namespace NS2
+{
+    public class UnimportedType
+    {
+    }
+}
+                        ]]></Document>
+                    </Project>
+                </Workspace>)
+
+                If populateCache Then
+                    Dim service = state.Workspace.Services.GetLanguageServices(LanguageNames.CSharp).GetRequiredService(Of ITypeImportCompletionService)()
+                    Dim document = state.Workspace.CurrentSolution.GetDocument(state.Workspace.Documents.Single(Function(d) d.Name = "C.cs").Id)
+                    Await service.WarmUpCacheAsync(document.Project, CancellationToken.None)
+                End If
+
+                Dim workspace = state.Workspace
+                workspace.TryApplyChanges(workspace.CurrentSolution.WithOptions(workspace.Options _
+                    .WithChangedOption(CompletionServiceOptions.UsePartialSemanticForCompletion, False) _
+                    .WithChangedOption(CompletionOptions.ShowItemsFromUnimportedNamespaces, LanguageNames.CSharp, True)))
+
+                state.SendInvokeCompletionList()
+                Await state.WaitForUIRenderedAsync()
+
+                ' w/o warming up cache in advance, the first time import completion get triggered we will not return anything from references
+                If populateCache Then
+                    Await state.AssertCompletionItemsContain(displayText:="UnimportedType", displayTextSuffix:="")
+                Else
+                    Await state.AssertCompletionItemsDoNotContainAny("UnimportedType")
+                End If
+            End Using
+        End Function
+
+        <WpfTheory, CombinatorialData>
+        <Trait(Traits.Feature, Traits.Features.Completion)>
+        Public Async Function WarmUpExtensionMethodImportCompletionCache(populateCache As Boolean) As Task
+
+            Using state = TestStateFactory.CreateTestStateFromWorkspace(
+                <Workspace>
+                    <Project Language="C#" LanguageVersion="Preview" CommonReferences="true">
+                        <ProjectReference>RefProj</ProjectReference>
+                        <Document FilePath="C.cs"><![CDATA[
+namespace NS1
+    public class C1
+    {
+        void M(int x)
+        {
+            x.$$
+        }
+    }
+}
+                        ]]></Document>
+                    </Project>
+                    <Project Language="C#" AssemblyName="RefProj" CommonReferences="true">
+                        <Document><![CDATA[
+namespace NS2
+{
+    public static class Ext
+    {
+        public static bool IntegerExtMethod(this int x) => false;
+    }
+}
+                        ]]></Document>
+                    </Project>
+                </Workspace>)
+
+                If populateCache Then
+                    Dim service = state.Workspace.Services.GetLanguageServices(LanguageNames.CSharp).GetRequiredService(Of ITypeImportCompletionService)()
+                    Dim document = state.Workspace.CurrentSolution.GetDocument(state.Workspace.Documents.Single(Function(d) d.Name = "C.cs").Id)
+                    Await ExtensionMethodImportCompletionHelper.WarmUpCacheAsync(document, CancellationToken.None)
+                End If
+
+                Dim workspace = state.Workspace
+                workspace.TryApplyChanges(workspace.CurrentSolution.WithOptions(workspace.Options _
+                    .WithChangedOption(CompletionServiceOptions.UsePartialSemanticForCompletion, False) _
+                    .WithChangedOption(CompletionServiceOptions.TimeoutInMillisecondsForExtensionMethodImportCompletion, -1) _
+                    .WithChangedOption(CompletionOptions.ShowItemsFromUnimportedNamespaces, LanguageNames.CSharp, True)))
+
+                state.SendInvokeCompletionList()
+                Await state.WaitForUIRenderedAsync()
+
+                ' w/o warming up cache in advance, the first time import completion get triggered we will not return anything from references
+                If populateCache Then
+                    Await state.AssertCompletionItemsContain(displayText:="IntegerExtMethod", displayTextSuffix:="")
+                Else
+                    Await state.AssertCompletionItemsDoNotContainAny("IntegerExtMethod")
+                End If
+            End Using
+        End Function
+
         <WpfTheory, CombinatorialData>
         <Trait(Traits.Feature, Traits.Features.Completion)>
         Public Async Function TestExpanderWithImportCompletionDisabled(showCompletionInArgumentLists As Boolean) As Task
@@ -9295,7 +9408,7 @@ class C
                 Await state.AssertNoCompletionSession()
                 Assert.Contains(NotifyCommittingItemCompletionProvider.DisplayText, state.GetLineTextFromCaretPosition(), StringComparison.Ordinal)
 
-                Await notifyProvider.checkpoint.Task
+                Await notifyProvider.Checkpoint.Task
                 Assert.False(notifyProvider.CalledOnMainThread)
             End Using
         End Function
diff --git a/src/EditorFeatures/TestUtilities/Completion/AbstractCompletionProviderTests.cs b/src/EditorFeatures/TestUtilities/Completion/AbstractCompletionProviderTests.cs
index 8c2e838bc5354..03f208aa36a53 100644
--- a/src/EditorFeatures/TestUtilities/Completion/AbstractCompletionProviderTests.cs
+++ b/src/EditorFeatures/TestUtilities/Completion/AbstractCompletionProviderTests.cs
@@ -506,7 +506,9 @@ private async Task VerifyCustomCommitProviderCheckResultsAsync(Document document
             }
         }
 
-        protected virtual OptionSet WithChangedOptions(OptionSet options) => options;
+        protected virtual OptionSet WithChangedOptions(OptionSet options)
+            => options;
+
         private Document WithChangedOptions(Document document)
         {
             var workspace = document.Project.Solution.Workspace;
diff --git a/src/EditorFeatures/TestUtilities/EditAndContinue/EditAndContinueTestHelpers.cs b/src/EditorFeatures/TestUtilities/EditAndContinue/EditAndContinueTestHelpers.cs
index 649f4bc7a42d8..241be2f1e1d07 100644
--- a/src/EditorFeatures/TestUtilities/EditAndContinue/EditAndContinueTestHelpers.cs
+++ b/src/EditorFeatures/TestUtilities/EditAndContinue/EditAndContinueTestHelpers.cs
@@ -381,6 +381,6 @@ public static MatchingPairs ToMatchingPairs(IEnumerable<KeyValuePair<SyntaxNode,
     internal static class EditScriptTestUtils
     {
         public static void VerifyEdits<TNode>(this EditScript<TNode> actual, params string[] expected)
-            => AssertEx.Equal(expected, actual.Edits.Select(e => e.GetDebuggerDisplay()), itemSeparator: ",\r\n");
+            => AssertEx.Equal(expected, actual.Edits.Select(e => e.GetDebuggerDisplay()), itemSeparator: ",\r\n", itemInspector: s => $"\"{s}\"");
     }
 }
diff --git a/src/EditorFeatures/VisualBasicTest/Completion/CompletionProviders/ExtensionMethodImportCompletionProviderTests.vb b/src/EditorFeatures/VisualBasicTest/Completion/CompletionProviders/ExtensionMethodImportCompletionProviderTests.vb
index 93a087195ce35..8b0900b5f9120 100644
--- a/src/EditorFeatures/VisualBasicTest/Completion/CompletionProviders/ExtensionMethodImportCompletionProviderTests.vb
+++ b/src/EditorFeatures/VisualBasicTest/Completion/CompletionProviders/ExtensionMethodImportCompletionProviderTests.vb
@@ -18,14 +18,12 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.Completion.Complet
         Private Property TimeoutInMilliseconds As Integer = -1
 
         Private Property ShowImportCompletionItemsOptionValue As Boolean = True
-        Private Property UsePartialSemantic As Boolean = False
 
         Protected Overrides Function WithChangedOptions(options As OptionSet) As OptionSet
-            Return options _
+            Return MyBase.WithChangedOptions(options) _
                 .WithChangedOption(CompletionOptions.ShowItemsFromUnimportedNamespaces, LanguageNames.VisualBasic, ShowImportCompletionItemsOptionValue) _
                 .WithChangedOption(CompletionServiceOptions.IsExpandedCompletion, IsExpandedCompletion) _
-                .WithChangedOption(CompletionServiceOptions.TimeoutInMillisecondsForExtensionMethodImportCompletion, TimeoutInMilliseconds) _
-                .WithChangedOption(CompletionServiceOptions.UsePartialSemanticForImportCompletion, UsePartialSemantic)
+                .WithChangedOption(CompletionServiceOptions.TimeoutInMillisecondsForExtensionMethodImportCompletion, TimeoutInMilliseconds)
         End Function
 
         Protected Overrides Function GetComposition() As TestComposition
diff --git a/src/EditorFeatures/VisualBasicTest/Completion/CompletionProviders/TypeImportCompletionProviderTests.vb b/src/EditorFeatures/VisualBasicTest/Completion/CompletionProviders/TypeImportCompletionProviderTests.vb
index 706dcba795447..0f54ffdd89771 100644
--- a/src/EditorFeatures/VisualBasicTest/Completion/CompletionProviders/TypeImportCompletionProviderTests.vb
+++ b/src/EditorFeatures/VisualBasicTest/Completion/CompletionProviders/TypeImportCompletionProviderTests.vb
@@ -15,13 +15,11 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.Completion.Complet
         Private Property ShowImportCompletionItemsOptionValue As Boolean = True
 
         Private Property IsExpandedCompletion As Boolean = True
-        Private Property UsePartialSemantic As Boolean = False
 
         Protected Overrides Function WithChangedOptions(options As OptionSet) As OptionSet
-            Return options _
+            Return MyBase.WithChangedOptions(options) _
                 .WithChangedOption(CompletionOptions.ShowItemsFromUnimportedNamespaces, LanguageNames.VisualBasic, ShowImportCompletionItemsOptionValue) _
-                .WithChangedOption(CompletionServiceOptions.IsExpandedCompletion, IsExpandedCompletion) _
-                .WithChangedOption(CompletionServiceOptions.UsePartialSemanticForImportCompletion, UsePartialSemantic)
+                .WithChangedOption(CompletionServiceOptions.IsExpandedCompletion, IsExpandedCompletion)
         End Function
 
         Protected Overrides Function GetComposition() As TestComposition
diff --git a/src/EditorFeatures/VisualBasicTest/InvertIf/InvertMultiLineIfTests.vb b/src/EditorFeatures/VisualBasicTest/InvertIf/InvertMultiLineIfTests.vb
index 49615cd184a06..6641a926c17f3 100644
--- a/src/EditorFeatures/VisualBasicTest/InvertIf/InvertMultiLineIfTests.vb
+++ b/src/EditorFeatures/VisualBasicTest/InvertIf/InvertMultiLineIfTests.vb
@@ -707,6 +707,30 @@ end class",
 
     sub DoSomething()
     end sub
+end class")
+        End Function
+
+        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsInvertIf)>
+        Public Async Function InvertIfWithoutElse() As Task
+            Await TestInRegularAndScriptAsync(
+"class C
+    sub M(x as String)
+        [||]If x = ""a"" Then
+          ' Comment
+          x += 1
+        End If
+    end sub
+
+end class",
+"class C
+    sub M(x as String)
+        If x IsNot ""a"" Then
+            Return
+        End If
+        ' Comment
+        x += 1
+    end sub
+
 end class")
         End Function
     End Class
diff --git a/src/Features/CSharp/Portable/Completion/CompletionProviders/ImportCompletion/ExtensionMethodImportCompletionProvider.cs b/src/Features/CSharp/Portable/Completion/CompletionProviders/ImportCompletion/ExtensionMethodImportCompletionProvider.cs
index da74b72eff123..02e8cc228aba9 100644
--- a/src/Features/CSharp/Portable/Completion/CompletionProviders/ImportCompletion/ExtensionMethodImportCompletionProvider.cs
+++ b/src/Features/CSharp/Portable/Completion/CompletionProviders/ImportCompletion/ExtensionMethodImportCompletionProvider.cs
@@ -44,8 +44,8 @@ protected override ImmutableArray<string> GetImportedNamespaces(
             CancellationToken cancellationToken)
             => ImportCompletionProviderHelper.GetImportedNamespaces(location, semanticModel);
 
-        protected override Task<SyntaxContext> CreateContextAsync(Document document, int position, bool usePartialSemantic, CancellationToken cancellationToken)
-            => ImportCompletionProviderHelper.CreateContextAsync(document, position, usePartialSemantic, cancellationToken);
+        protected override Task<SyntaxContext> CreateContextAsync(Document document, int position, CancellationToken cancellationToken)
+            => ImportCompletionProviderHelper.CreateContextAsync(document, position, cancellationToken);
 
         protected override bool IsFinalSemicolonOfUsingOrExtern(SyntaxNode directive, SyntaxToken token)
         {
diff --git a/src/Features/CSharp/Portable/Completion/CompletionProviders/ImportCompletion/ImportCompletionProviderHelper.cs b/src/Features/CSharp/Portable/Completion/CompletionProviders/ImportCompletion/ImportCompletionProviderHelper.cs
index 5115b26714e29..0e1ef9c666ead 100644
--- a/src/Features/CSharp/Portable/Completion/CompletionProviders/ImportCompletion/ImportCompletionProviderHelper.cs
+++ b/src/Features/CSharp/Portable/Completion/CompletionProviders/ImportCompletion/ImportCompletionProviderHelper.cs
@@ -21,14 +21,11 @@ public static ImmutableArray<string> GetImportedNamespaces(
             => semanticModel.GetUsingNamespacesInScope(location)
                 .SelectAsArray(namespaceSymbol => namespaceSymbol.ToDisplayString(SymbolDisplayFormats.NameFormat));
 
-        public static async Task<SyntaxContext> CreateContextAsync(Document document, int position, bool usePartialSemantic, CancellationToken cancellationToken)
+        public static async Task<SyntaxContext> CreateContextAsync(Document document, int position, CancellationToken cancellationToken)
         {
             // Need regular semantic model because we will use it to get imported namespace symbols. Otherwise we will try to 
             // reach outside of the span and ended up with "node not within syntax tree" error from the speculative model.
-            // Also we use partial model unless full model is explictly request (e.g. in tests) so that we don't have to wait for all semantics to be computed.
-            var semanticModel = usePartialSemantic
-                ? await document.GetPartialSemanticModelAsync(cancellationToken).ConfigureAwait(false)
-                : await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
+            var semanticModel = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
             Contract.ThrowIfNull(semanticModel);
             return CSharpSyntaxContext.CreateContext(document.Project.Solution.Workspace, semanticModel, position, cancellationToken);
         }
diff --git a/src/Features/CSharp/Portable/Completion/CompletionProviders/ImportCompletion/TypeImportCompletionProvider.cs b/src/Features/CSharp/Portable/Completion/CompletionProviders/ImportCompletion/TypeImportCompletionProvider.cs
index 59e6118414cbd..6d7dd6cc3a0e4 100644
--- a/src/Features/CSharp/Portable/Completion/CompletionProviders/ImportCompletion/TypeImportCompletionProvider.cs
+++ b/src/Features/CSharp/Portable/Completion/CompletionProviders/ImportCompletion/TypeImportCompletionProvider.cs
@@ -45,8 +45,8 @@ protected override ImmutableArray<string> GetImportedNamespaces(
             CancellationToken cancellationToken)
             => ImportCompletionProviderHelper.GetImportedNamespaces(location, semanticModel);
 
-        protected override Task<SyntaxContext> CreateContextAsync(Document document, int position, bool usePartialSemantic, CancellationToken cancellationToken)
-            => ImportCompletionProviderHelper.CreateContextAsync(document, position, usePartialSemantic, cancellationToken);
+        protected override Task<SyntaxContext> CreateContextAsync(Document document, int position, CancellationToken cancellationToken)
+            => ImportCompletionProviderHelper.CreateContextAsync(document, position, cancellationToken);
 
         protected override bool IsFinalSemicolonOfUsingOrExtern(SyntaxNode directive, SyntaxToken token)
         {
diff --git a/src/Features/CSharp/Portable/Completion/CompletionProviders/ImportCompletion/TypeImportCompletionServiceFactory.cs b/src/Features/CSharp/Portable/Completion/CompletionProviders/ImportCompletion/TypeImportCompletionServiceFactory.cs
index a555421c52ca0..08440678f07c7 100644
--- a/src/Features/CSharp/Portable/Completion/CompletionProviders/ImportCompletion/TypeImportCompletionServiceFactory.cs
+++ b/src/Features/CSharp/Portable/Completion/CompletionProviders/ImportCompletion/TypeImportCompletionServiceFactory.cs
@@ -33,6 +33,8 @@ protected override string GenericTypeSuffix
                 => "<>";
 
             protected override bool IsCaseSensitive => true;
+
+            protected override string Language => LanguageNames.CSharp;
         }
     }
 }
diff --git a/src/Features/CSharp/Portable/Debugging/DataTipInfoGetter.cs b/src/Features/CSharp/Portable/Debugging/DataTipInfoGetter.cs
index e713c7e1366df..b78c65f9bcfec 100644
--- a/src/Features/CSharp/Portable/Debugging/DataTipInfoGetter.cs
+++ b/src/Features/CSharp/Portable/Debugging/DataTipInfoGetter.cs
@@ -44,7 +44,7 @@ internal static async Task<DebugDataTipInfo> GetInfoAsync(Document document, int
                     // literal they're hovering over.
                     // Partial semantics should always be sufficient because the (unconverted) type
                     // of a literal can always easily be determined.
-                    var semanticModel = await document.GetPartialSemanticModelAsync(cancellationToken).ConfigureAwait(false);
+                    var (_, semanticModel) = await document.GetPartialSemanticModelAsync(cancellationToken).ConfigureAwait(false);
                     var type = semanticModel.GetTypeInfo(expression, cancellationToken).Type;
                     return type == null
                         ? default
diff --git a/src/Features/Core/Portable/Completion/CompletionServiceOptions.cs b/src/Features/Core/Portable/Completion/CompletionServiceOptions.cs
index ce7cafc42f10a..6dbd7f9f8eee2 100644
--- a/src/Features/Core/Portable/Completion/CompletionServiceOptions.cs
+++ b/src/Features/Core/Portable/Completion/CompletionServiceOptions.cs
@@ -17,8 +17,8 @@ public static readonly Option2<bool> IsExpandedCompletion
         /// <summary>
         /// For testing only. Changing the default value in actual product might cause perf issues.
         /// </summary>
-        public static readonly Option2<bool> UsePartialSemanticForImportCompletion
-            = new(nameof(CompletionServiceOptions), nameof(UsePartialSemanticForImportCompletion), defaultValue: true);
+        public static readonly Option2<bool> UsePartialSemanticForCompletion
+            = new(nameof(CompletionServiceOptions), nameof(UsePartialSemanticForCompletion), defaultValue: true);
 
         /// <summary>
         /// Timeout value used for time-boxing completion of unimported extension methods.
diff --git a/src/Features/Core/Portable/Completion/CompletionServiceWithProviders.cs b/src/Features/Core/Portable/Completion/CompletionServiceWithProviders.cs
index c9e5747660048..ea33f071f70f3 100644
--- a/src/Features/Core/Portable/Completion/CompletionServiceWithProviders.cs
+++ b/src/Features/Core/Portable/Completion/CompletionServiceWithProviders.cs
@@ -255,6 +255,23 @@ public override async Task<CompletionList> GetCompletionsAsync(
             return completionList;
         }
 
+        /// <summary>
+        /// Returns a document with frozen partial semantic unless we already have a complete compilation available.
+        /// Getting full semantic could be costly in certains scenarios and would cause significant delay in completion. 
+        /// In most cases we'd still end up with complete document, but we'd consider it an acceptable trade-off even when 
+        /// we get into this transient state.
+        /// </summary>
+        private async Task<(Document document, SemanticModel semanticModel)> GetDocumentWithFrozenPartialSemanticsAsync(Document document, CancellationToken cancellationToken)
+        {
+            var usePartialSemantic = _workspace.Options.GetOption(CompletionServiceOptions.UsePartialSemanticForCompletion);
+            if (usePartialSemantic)
+            {
+                return await document.GetPartialSemanticModelAsync(cancellationToken).ConfigureAwait(false);
+            }
+
+            return (document, await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false));
+        }
+
         private protected async Task<(CompletionList completionList, bool expandItemsAvailable)> GetCompletionsWithAvailabilityOfExpandedItemsAsync(
             Document document,
             int caretPosition,
@@ -263,6 +280,9 @@ public override async Task<CompletionList> GetCompletionsAsync(
             OptionSet options,
             CancellationToken cancellationToken)
         {
+            // We don't need SemanticModel here, just want to make sure it won't get GC'd before CompletionProviders are able to get it.
+            (document, var semanticModel) = await GetDocumentWithFrozenPartialSemanticsAsync(document, cancellationToken).ConfigureAwait(false);
+
             var text = await document.GetTextAsync(cancellationToken).ConfigureAwait(false);
             var defaultItemSpan = GetDefaultCompletionListSpan(text, caretPosition);
 
@@ -353,6 +373,8 @@ public override async Task<CompletionList> GetCompletionsAsync(
                 document, caretPosition, trigger, options, defaultItemSpan,
                 augmentingProviders, cancellationToken).ConfigureAwait(false);
 
+            GC.KeepAlive(semanticModel);
+
             var allContexts = triggeredCompletionContexts.Concat(augmentingCompletionContexts);
             Debug.Assert(allContexts.Length > 0);
 
@@ -524,12 +546,17 @@ private async Task<CompletionContext> GetContextAsync(
             return context;
         }
 
-        public override Task<CompletionDescription> GetDescriptionAsync(Document document, CompletionItem item, CancellationToken cancellationToken = default)
+        public override async Task<CompletionDescription> GetDescriptionAsync(Document document, CompletionItem item, CancellationToken cancellationToken = default)
         {
             var provider = GetProvider(item);
-            return provider != null
-                ? provider.GetDescriptionAsync(document, item, cancellationToken)
-                : Task.FromResult(CompletionDescription.Empty);
+            if (provider is null)
+                return CompletionDescription.Empty;
+
+            // We don't need SemanticModel here, just want to make sure it won't get GC'd before CompletionProviders are able to get it.
+            (document, var semanticModel) = await GetDocumentWithFrozenPartialSemanticsAsync(document, cancellationToken).ConfigureAwait(false);
+            var description = await provider.GetDescriptionAsync(document, item, cancellationToken).ConfigureAwait(false);
+            GC.KeepAlive(semanticModel);
+            return description;
         }
 
         public override bool ShouldTriggerCompletion(SourceText text, int caretPosition, CompletionTrigger trigger, ImmutableHashSet<string> roles = null, OptionSet options = null)
@@ -568,7 +595,11 @@ public override async Task<CompletionChange> GetChangeAsync(
             var provider = GetProvider(item);
             if (provider != null)
             {
-                return await provider.GetChangeAsync(document, item, commitKey, cancellationToken).ConfigureAwait(false);
+                // We don't need SemanticModel here, just want to make sure it won't get GC'd before CompletionProviders are able to get it.
+                (document, var semanticModel) = await GetDocumentWithFrozenPartialSemanticsAsync(document, cancellationToken).ConfigureAwait(false);
+                var change = await provider.GetChangeAsync(document, item, commitKey, cancellationToken).ConfigureAwait(false);
+                GC.KeepAlive(semanticModel);
+                return change;
             }
             else
             {
diff --git a/src/Features/Core/Portable/Completion/Providers/ImportCompletionProvider/AbstractImportCompletionProvider.cs b/src/Features/Core/Portable/Completion/Providers/ImportCompletionProvider/AbstractImportCompletionProvider.cs
index ae5265a605f61..1a66b3cfec723 100644
--- a/src/Features/Core/Portable/Completion/Providers/ImportCompletionProvider/AbstractImportCompletionProvider.cs
+++ b/src/Features/Core/Portable/Completion/Providers/ImportCompletionProvider/AbstractImportCompletionProvider.cs
@@ -22,7 +22,7 @@ namespace Microsoft.CodeAnalysis.Completion.Providers
 {
     internal abstract class AbstractImportCompletionProvider : LSPCompletionProvider
     {
-        protected abstract Task<SyntaxContext> CreateContextAsync(Document document, int position, bool usePartialSemantic, CancellationToken cancellationToken);
+        protected abstract Task<SyntaxContext> CreateContextAsync(Document document, int position, CancellationToken cancellationToken);
         protected abstract ImmutableArray<string> GetImportedNamespaces(SyntaxNode location, SemanticModel semanticModel, CancellationToken cancellationToken);
         protected abstract bool ShouldProvideCompletion(CompletionContext completionContext, SyntaxContext syntaxContext);
         protected abstract Task AddCompletionItemsAsync(CompletionContext completionContext, SyntaxContext syntaxContext, HashSet<string> namespacesInScope, bool isExpandedCompletion, CancellationToken cancellationToken);
@@ -54,8 +54,7 @@ public override async Task ProvideCompletionsAsync(CompletionContext completionC
 
             // We need to check for context before option values, so we can tell completion service that we are in a context to provide expanded items
             // even though import completion might be disabled. This would show the expander in completion list which user can then use to explicitly ask for unimported items.
-            var usePartialSemantic = completionContext.Options.GetOption(CompletionServiceOptions.UsePartialSemanticForImportCompletion);
-            var syntaxContext = await CreateContextAsync(document, completionContext.Position, usePartialSemantic, cancellationToken).ConfigureAwait(false);
+            var syntaxContext = await CreateContextAsync(document, completionContext.Position, cancellationToken).ConfigureAwait(false);
             if (!ShouldProvideCompletion(completionContext, syntaxContext))
             {
                 return;
diff --git a/src/Features/Core/Portable/Completion/Providers/ImportCompletionProvider/AbstractTypeImportCompletionService.cs b/src/Features/Core/Portable/Completion/Providers/ImportCompletionProvider/AbstractTypeImportCompletionService.cs
index ea0955c11d75a..774854699e283 100644
--- a/src/Features/Core/Portable/Completion/Providers/ImportCompletionProvider/AbstractTypeImportCompletionService.cs
+++ b/src/Features/Core/Portable/Completion/Providers/ImportCompletionProvider/AbstractTypeImportCompletionService.cs
@@ -31,17 +31,25 @@ internal abstract partial class AbstractTypeImportCompletionService : ITypeImpor
 
         protected abstract bool IsCaseSensitive { get; }
 
+        protected abstract string Language { get; }
+
         internal AbstractTypeImportCompletionService(Workspace workspace)
             => CacheService = workspace.Services.GetRequiredService<IImportCompletionCacheService<CacheEntry, CacheEntry>>();
 
+        public Task WarmUpCacheAsync(Project? project, CancellationToken cancellationToken)
+        {
+            return project is null
+                ? Task.CompletedTask
+                : GetCacheEntriesAsync(project, forceCacheCreation: true, cancellationToken);
+        }
+
         public async Task<ImmutableArray<ImmutableArray<CompletionItem>>?> GetAllTopLevelTypesAsync(
             Project currentProject,
             SyntaxContext syntaxContext,
             bool forceCacheCreation,
             CancellationToken cancellationToken)
         {
-            var hideAdvancedmembers = currentProject.Solution.Options.GetOption(CompletionOptions.HideAdvancedMembers, currentProject.Language);
-            var getCacheResults = await GetCacheEntriesAsync(currentProject, syntaxContext, forceCacheCreation, cancellationToken).ConfigureAwait(false);
+            var getCacheResults = await GetCacheEntriesAsync(currentProject, forceCacheCreation, cancellationToken).ConfigureAwait(false);
 
             if (getCacheResults == null)
             {
@@ -52,36 +60,40 @@ internal AbstractTypeImportCompletionService(Workspace workspace)
                 {
                     if (s_cachingTask.IsCompleted)
                     {
-                        s_cachingTask = Task.Run(() => GetCacheEntriesAsync(currentProject, syntaxContext, forceCacheCreation: true, CancellationToken.None));
+                        // When building cache in the background, make sure we always use latest snapshot with full semantic
+                        var projectId = currentProject.Id;
+                        var workspace = currentProject.Solution.Workspace;
+                        s_cachingTask = Task.Run(() => WarmUpCacheAsync(workspace.CurrentSolution.GetProject(projectId), CancellationToken.None), CancellationToken.None);
                     }
                 }
 
                 return null;
             }
 
+            var hideAdvancedMembers = currentProject.Solution.Options.GetOption(CompletionOptions.HideAdvancedMembers, currentProject.Language);
             var currentCompilation = await currentProject.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false);
             return getCacheResults.Value.SelectAsArray(GetItemsFromCacheResult);
 
             ImmutableArray<CompletionItem> GetItemsFromCacheResult(GetCacheResult cacheResult)
             {
                 return cacheResult.Entry.GetItemsForContext(
-                         syntaxContext.SemanticModel.Language,
+                         Language,
                          GenericTypeSuffix,
                          currentCompilation.Assembly.IsSameAssemblyOrHasFriendAccessTo(cacheResult.Assembly),
                          syntaxContext.IsAttributeNameContext,
                          IsCaseSensitive,
-                         hideAdvancedmembers);
+                         hideAdvancedMembers);
             }
         }
 
-        private async Task<ImmutableArray<GetCacheResult>?> GetCacheEntriesAsync(Project currentProject, SyntaxContext syntaxContext, bool forceCacheCreation, CancellationToken cancellationToken)
+        private async Task<ImmutableArray<GetCacheResult>?> GetCacheEntriesAsync(Project currentProject, bool forceCacheCreation, CancellationToken cancellationToken)
         {
             var _ = ArrayBuilder<GetCacheResult>.GetInstance(out var builder);
 
             var currentCompilation = await currentProject.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false);
             var editorBrowsableInfo = new Lazy<EditorBrowsableInfo>(() => new EditorBrowsableInfo(currentCompilation));
 
-            var cacheResult = await GetCacheForProjectAsync(currentProject, syntaxContext, forceCacheCreation: true, editorBrowsableInfo, cancellationToken).ConfigureAwait(false);
+            var cacheResult = await GetCacheForProjectAsync(currentProject, forceCacheCreation: true, editorBrowsableInfo, cancellationToken).ConfigureAwait(false);
 
             // We always force create a cache for current project.
             Debug.Assert(cacheResult.HasValue);
@@ -101,7 +113,6 @@ ImmutableArray<CompletionItem> GetItemsFromCacheResult(GetCacheResult cacheResul
                 {
                     cacheResult = await GetCacheForProjectAsync(
                         referencedProject,
-                        syntaxContext,
                         forceCacheCreation,
                         editorBrowsableInfo: null,
                         cancellationToken).ConfigureAwait(false);
@@ -123,7 +134,7 @@ ImmutableArray<CompletionItem> GetItemsFromCacheResult(GetCacheResult cacheResul
             {
                 if (HasGlobalAlias(peReference) &&
                     currentCompilation.GetAssemblyOrModuleSymbol(peReference) is IAssemblySymbol assembly &&
-                    TryGetCacheForPEReference(solution, assembly, editorBrowsableInfo, peReference, syntaxContext, forceCacheCreation, cancellationToken, out cacheResult))
+                    TryGetCacheForPEReference(solution, assembly, editorBrowsableInfo, peReference, forceCacheCreation, cancellationToken, out cacheResult))
                 {
                     if (cacheResult.HasValue)
                     {
@@ -151,7 +162,6 @@ static bool HasGlobalAlias(MetadataReference? metadataReference)
         /// </summary>
         private async Task<GetCacheResult?> GetCacheForProjectAsync(
             Project project,
-            SyntaxContext syntaxContext,
             bool forceCacheCreation,
             Lazy<EditorBrowsableInfo>? editorBrowsableInfo,
             CancellationToken cancellationToken)
@@ -165,7 +175,6 @@ static bool HasGlobalAlias(MetadataReference? metadataReference)
                 project.Id,
                 compilation.Assembly,
                 checksum,
-                syntaxContext,
                 forceCacheCreation,
                 CacheService.ProjectItemsCache,
                 editorBrowsableInfo ?? new Lazy<EditorBrowsableInfo>(() => new EditorBrowsableInfo(compilation)),
@@ -180,7 +189,6 @@ private bool TryGetCacheForPEReference(
             IAssemblySymbol assemblySymbol,
             Lazy<EditorBrowsableInfo> editorBrowsableInfo,
             PortableExecutableReference peReference,
-            SyntaxContext syntaxContext,
             bool forceCacheCreation,
             CancellationToken cancellationToken,
             out GetCacheResult? result)
@@ -201,7 +209,6 @@ private bool TryGetCacheForPEReference(
                 key,
                 assemblySymbol,
                 checksum,
-                syntaxContext,
                 forceCacheCreation,
                 CacheService.PEItemsCache,
                 editorBrowsableInfo,
@@ -220,15 +227,12 @@ private bool TryGetCacheForPEReference(
             TKey key,
             IAssemblySymbol assembly,
             Checksum checksum,
-            SyntaxContext syntaxContext,
             bool forceCacheCreation,
             IDictionary<TKey, CacheEntry> cache,
             Lazy<EditorBrowsableInfo> editorBrowsableInfo,
             CancellationToken cancellationToken)
             where TKey : notnull
         {
-            var language = syntaxContext.SemanticModel.Language;
-
             // Cache hit
             if (cache.TryGetValue(key, out var cacheEntry) && cacheEntry.Checksum == checksum)
             {
@@ -238,7 +242,7 @@ private bool TryGetCacheForPEReference(
             // Cache miss, create all items only when asked.
             if (forceCacheCreation)
             {
-                using var builder = new CacheEntry.Builder(checksum, language, GenericTypeSuffix, editorBrowsableInfo.Value);
+                using var builder = new CacheEntry.Builder(checksum, Language, GenericTypeSuffix, editorBrowsableInfo.Value);
                 GetCompletionItemsForTopLevelTypeDeclarations(assembly.GlobalNamespace, builder, cancellationToken);
                 cacheEntry = builder.ToReferenceCacheEntry();
                 cache[key] = cacheEntry;
diff --git a/src/Features/Core/Portable/Completion/Providers/ImportCompletionProvider/ExtensionMethodImportCompletionHelper.ExtensionMethodSymbolComputer.cs b/src/Features/Core/Portable/Completion/Providers/ImportCompletionProvider/ExtensionMethodImportCompletionHelper.ExtensionMethodSymbolComputer.cs
index d111b4bd14e21..24e67bf3e3d08 100644
--- a/src/Features/Core/Portable/Completion/Providers/ImportCompletionProvider/ExtensionMethodImportCompletionHelper.ExtensionMethodSymbolComputer.cs
+++ b/src/Features/Core/Portable/Completion/Providers/ImportCompletionProvider/ExtensionMethodImportCompletionHelper.ExtensionMethodSymbolComputer.cs
@@ -34,9 +34,6 @@ private class ExtensionMethodSymbolComputer
             // The value indicates if we can reduce an extension method with this receiver type given receiver type.
             private readonly ConcurrentDictionary<ITypeSymbol, bool> _checkedReceiverTypes;
 
-            private Project OriginatingProject => _originatingDocument.Project;
-            private Solution Solution => OriginatingProject.Solution;
-
             public ExtensionMethodSymbolComputer(
                 Document document,
                 SemanticModel semanticModel,
@@ -71,31 +68,39 @@ public static async Task<ExtensionMethodSymbolComputer> CreateAsync(
             /// <summary>
             /// Force create all relevant indices
             /// </summary>
-            public Task PopulateIndicesAsync(CancellationToken cancellationToken)
+            public static Task PopulateIndicesAsync(Project? project, IImportCompletionCacheService<CacheEntry, object> cacheService, CancellationToken cancellationToken)
             {
+                if (project is null)
+                {
+                    return Task.CompletedTask;
+                }
+
                 using var _ = ArrayBuilder<Task>.GetInstance(out var tasks);
 
-                foreach (var project in GetAllRelevantProjects())
+                foreach (var relevantProject in GetAllRelevantProjects(project))
                 {
                     tasks.Add(Task.Run(()
-                        => GetCacheEntryAsync(project, loadOnly: false, _cacheService, cancellationToken), cancellationToken));
+                        => GetCacheEntryAsync(relevantProject, loadOnly: false, cacheService, cancellationToken), cancellationToken));
                 }
 
-                foreach (var peReference in GetAllRelevantPeReferences())
+                foreach (var peReference in GetAllRelevantPeReferences(project))
                 {
                     tasks.Add(Task.Run(()
-                        => SymbolTreeInfo.GetInfoForMetadataReferenceAsync(Solution, peReference, loadOnly: false, cancellationToken).AsTask(), cancellationToken));
+                        => SymbolTreeInfo.GetInfoForMetadataReferenceAsync(project.Solution, peReference, loadOnly: false, cancellationToken).AsTask(), cancellationToken));
                 }
 
                 return Task.WhenAll(tasks.ToImmutable());
             }
 
+            public Task PopulateIndicesAsync(Project? project, CancellationToken cancellationToken)
+                => PopulateIndicesAsync(project, _cacheService, cancellationToken);
+
             public async Task<(ImmutableArray<IMethodSymbol> symbols, bool isPartialResult)> GetExtensionMethodSymbolsAsync(bool forceIndexCreation, CancellationToken cancellationToken)
             {
                 // Find applicable symbols in parallel
                 using var _1 = ArrayBuilder<Task<ImmutableArray<IMethodSymbol>?>>.GetInstance(out var tasks);
 
-                foreach (var peReference in GetAllRelevantPeReferences())
+                foreach (var peReference in GetAllRelevantPeReferences(_originatingDocument.Project))
                 {
                     tasks.Add(Task.Run(() => GetExtensionMethodSymbolsFromPeReferenceAsync(
                         peReference,
@@ -103,7 +108,7 @@ public Task PopulateIndicesAsync(CancellationToken cancellationToken)
                         cancellationToken).AsTask(), cancellationToken));
                 }
 
-                foreach (var project in GetAllRelevantProjects())
+                foreach (var project in GetAllRelevantProjects(_originatingDocument.Project))
                 {
                     tasks.Add(Task.Run(() => GetExtensionMethodSymbolsFromProjectAsync(
                         project,
@@ -136,16 +141,16 @@ public Task PopulateIndicesAsync(CancellationToken cancellationToken)
             }
 
             // Returns all referenced projects and originating project itself.
-            private ImmutableArray<Project> GetAllRelevantProjects()
+            private static ImmutableArray<Project> GetAllRelevantProjects(Project project)
             {
-                var graph = Solution.GetProjectDependencyGraph();
-                var relevantProjectIds = graph.GetProjectsThatThisProjectTransitivelyDependsOn(OriginatingProject.Id).Concat(OriginatingProject.Id);
-                return relevantProjectIds.Select(id => Solution.GetRequiredProject(id)).Where(p => p.SupportsCompilation).ToImmutableArray();
+                var graph = project.Solution.GetProjectDependencyGraph();
+                var relevantProjectIds = graph.GetProjectsThatThisProjectTransitivelyDependsOn(project.Id).Concat(project.Id);
+                return relevantProjectIds.Select(id => project.Solution.GetRequiredProject(id)).Where(p => p.SupportsCompilation).ToImmutableArray();
             }
 
             // Returns all PEs referenced by originating project.
-            private ImmutableArray<PortableExecutableReference> GetAllRelevantPeReferences()
-                => OriginatingProject.MetadataReferences.OfType<PortableExecutableReference>().ToImmutableArray();
+            private static ImmutableArray<PortableExecutableReference> GetAllRelevantPeReferences(Project project)
+                => project.MetadataReferences.OfType<PortableExecutableReference>().ToImmutableArray();
 
             private async Task<ImmutableArray<IMethodSymbol>?> GetExtensionMethodSymbolsFromProjectAsync(
                 Project project,
@@ -153,7 +158,7 @@ private ImmutableArray<PortableExecutableReference> GetAllRelevantPeReferences()
                 CancellationToken cancellationToken)
             {
                 // By default, don't trigger index creation except for documents in originating project.
-                var isOriginatingProject = project == OriginatingProject;
+                var isOriginatingProject = project == _originatingDocument.Project;
                 forceIndexCreation = forceIndexCreation || isOriginatingProject;
 
                 var cacheEntry = await GetCacheEntryAsync(
@@ -190,7 +195,7 @@ private ImmutableArray<PortableExecutableReference> GetAllRelevantPeReferences()
                 CancellationToken cancellationToken)
             {
                 var index = await SymbolTreeInfo.GetInfoForMetadataReferenceAsync(
-                    Solution, peReference, loadOnly: !forceIndexCreation, cancellationToken).ConfigureAwait(false);
+                    _originatingDocument.Project.Solution, peReference, loadOnly: !forceIndexCreation, cancellationToken).ConfigureAwait(false);
 
                 if (index == null)
                 {
diff --git a/src/Features/Core/Portable/Completion/Providers/ImportCompletionProvider/ExtensionMethodImportCompletionHelper.cs b/src/Features/Core/Portable/Completion/Providers/ImportCompletionProvider/ExtensionMethodImportCompletionHelper.cs
index de61d2d025cca..38ad3edf03aed 100644
--- a/src/Features/Core/Portable/Completion/Providers/ImportCompletionProvider/ExtensionMethodImportCompletionHelper.cs
+++ b/src/Features/Core/Portable/Completion/Providers/ImportCompletionProvider/ExtensionMethodImportCompletionHelper.cs
@@ -24,6 +24,30 @@ internal static partial class ExtensionMethodImportCompletionHelper
         private static readonly object s_gate = new();
         private static Task s_indexingTask = Task.CompletedTask;
 
+        public static async Task WarmUpCacheAsync(Document document, CancellationToken cancellationToken)
+        {
+            var project = document.Project;
+            var client = await RemoteHostClient.TryGetClientAsync(project, cancellationToken).ConfigureAwait(false);
+            if (client != null)
+            {
+                var result = await client.TryInvokeAsync<IRemoteExtensionMethodImportCompletionService>(
+                    project,
+                    (service, solutionInfo, cancellationToken) => service.WarmUpCacheAsync(
+                        solutionInfo, document.Id, cancellationToken),
+                    cancellationToken).ConfigureAwait(false);
+            }
+            else
+            {
+                await WarmUpCacheInCurrentProcessAsync(document, cancellationToken).ConfigureAwait(false);
+            }
+        }
+
+        public static Task WarmUpCacheInCurrentProcessAsync(Document document, CancellationToken cancellationToken)
+        {
+            var cacheService = GetCacheService(document.Project.Solution.Workspace);
+            return ExtensionMethodSymbolComputer.PopulateIndicesAsync(document.Project, cacheService, cancellationToken);
+        }
+
         public static async Task<ImmutableArray<SerializableImportCompletionItem>> GetUnimportedExtensionMethodsAsync(
             Document document,
             int position,
@@ -117,7 +141,10 @@ public static async Task<SerializableUnimportedExtensionMethods> GetUnimportedEx
                     // index is being constrcuted, which might take some time.
                     if (s_indexingTask.IsCompleted)
                     {
-                        s_indexingTask = symbolComputer.PopulateIndicesAsync(CancellationToken.None);
+                        // When building cache in the background, make sure we always use latest snapshot with full semantic
+                        var id = document.Id;
+                        var workspace = document.Project.Solution.Workspace;
+                        s_indexingTask = Task.Run(() => symbolComputer.PopulateIndicesAsync(workspace.CurrentSolution.GetDocument(id)?.Project, CancellationToken.None), CancellationToken.None);
                     }
                 }
             }
@@ -125,7 +152,6 @@ public static async Task<SerializableUnimportedExtensionMethods> GetUnimportedEx
             var createItemsTicks = Environment.TickCount - ticks;
 
             return new SerializableUnimportedExtensionMethods(items, isPartialResult, getSymbolsTicks, createItemsTicks);
-
         }
 
         private static ImmutableArray<SerializableImportCompletionItem> ConvertSymbolsToCompletionItems(
diff --git a/src/Features/Core/Portable/Completion/Providers/ImportCompletionProvider/IRemoteExtensionMethodImportCompletionService.cs b/src/Features/Core/Portable/Completion/Providers/ImportCompletionProvider/IRemoteExtensionMethodImportCompletionService.cs
index 8a9f1e1965b35..07e398c01d163 100644
--- a/src/Features/Core/Portable/Completion/Providers/ImportCompletionProvider/IRemoteExtensionMethodImportCompletionService.cs
+++ b/src/Features/Core/Portable/Completion/Providers/ImportCompletionProvider/IRemoteExtensionMethodImportCompletionService.cs
@@ -11,7 +11,7 @@ namespace Microsoft.CodeAnalysis.Completion.Providers
 {
     internal interface IRemoteExtensionMethodImportCompletionService
     {
-        public ValueTask<SerializableUnimportedExtensionMethods> GetUnimportedExtensionMethodsAsync(
+        ValueTask<SerializableUnimportedExtensionMethods> GetUnimportedExtensionMethodsAsync(
             PinnedSolutionInfo solutionInfo,
             DocumentId documentId,
             int position,
@@ -20,5 +20,7 @@ public ValueTask<SerializableUnimportedExtensionMethods> GetUnimportedExtensionM
             ImmutableArray<string> targetTypesSymbolKeyData,
             bool forceIndexCreation,
             CancellationToken cancellationToken);
+
+        ValueTask WarmUpCacheAsync(PinnedSolutionInfo solutionInfo, DocumentId documentId, CancellationToken cancellationToken);
     }
 }
diff --git a/src/Features/Core/Portable/Completion/Providers/ImportCompletionProvider/ITypeImportCompletionService.cs b/src/Features/Core/Portable/Completion/Providers/ImportCompletionProvider/ITypeImportCompletionService.cs
index 7d8280d8e3fab..d72954c4605f2 100644
--- a/src/Features/Core/Portable/Completion/Providers/ImportCompletionProvider/ITypeImportCompletionService.cs
+++ b/src/Features/Core/Portable/Completion/Providers/ImportCompletionProvider/ITypeImportCompletionService.cs
@@ -26,5 +26,7 @@ internal interface ITypeImportCompletionService : ILanguageService
             SyntaxContext syntaxContext,
             bool forceCacheCreation,
             CancellationToken cancellationToken);
+
+        Task WarmUpCacheAsync(Project project, CancellationToken cancellationToken);
     }
 }
diff --git a/src/Features/Core/Portable/EditAndContinue/AbstractEditAndContinueAnalyzer.cs b/src/Features/Core/Portable/EditAndContinue/AbstractEditAndContinueAnalyzer.cs
index 804f14fe9e98b..94c6354d9365b 100644
--- a/src/Features/Core/Portable/EditAndContinue/AbstractEditAndContinueAnalyzer.cs
+++ b/src/Features/Core/Portable/EditAndContinue/AbstractEditAndContinueAnalyzer.cs
@@ -3812,17 +3812,29 @@ private bool ReportCustomAttributeRudeEdits(
                 return false;
             }
 
-            // We need diagnostics reported if the runtime doesn't support changing attributes,
-            // but even if it does, only attributes stored in the CustomAttributes table are editable
-            if (!capabilities.HasFlag(EditAndContinueCapabilities.ChangeCustomAttributes) ||
-                changedAttributes.Any(IsNonCustomAttribute))
+            // If the runtime doesn't support changing attributes we don't need to check anything else
+            if (!capabilities.HasFlag(EditAndContinueCapabilities.ChangeCustomAttributes))
             {
                 ReportUpdateRudeEdit(diagnostics, RudeEditKind.ChangingAttributesNotSupportedByRuntime, oldSymbol, newSymbol, newNode, newCompilation, cancellationToken);
-
-                // If the runtime doesn't support edits then pretend there weren't changes, so no edits are produced
                 return false;
             }
 
+            // Even if the runtime supports attribute changes, only attributes stored in the CustomAttributes table are editable
+            foreach (var attributeData in changedAttributes)
+            {
+                if (IsNonCustomAttribute(attributeData))
+                {
+                    var node = newNode ?? GetRudeEditDiagnosticNode(newSymbol, cancellationToken);
+                    diagnostics.Add(new RudeEditDiagnostic(RudeEditKind.ChangingNonCustomAttribute, GetDiagnosticSpan(node, EditKind.Update), node, new[]
+                    {
+                        attributeData.AttributeClass!.Name,
+                        GetDisplayName(newSymbol)
+                    }));
+
+                    return false;
+                }
+            }
+
             return true;
 
             static void FindChangedAttributes(ImmutableArray<AttributeData>? oldAttributes, ImmutableArray<AttributeData> newAttributes, ArrayBuilder<AttributeData> changedAttributes)
@@ -3864,12 +3876,13 @@ static void FindChangedAttributes(ImmutableArray<AttributeData>? oldAttributes,
 
             static bool IsNonCustomAttribute(AttributeData attribute)
             {
-                // TODO: Use a compiler API to get this information rather than hard coding a list: https://github.com/dotnet/roslyn/issues/53410
-
-                // This list comes from ShouldEmitAttribute in src\Compilers\CSharp\Portable\Symbols\Attributes\AttributeData.cs
-                // and src\Compilers\VisualBasic\Portable\Symbols\Attributes\AttributeData.vb
                 return attribute.AttributeClass?.ToNameDisplayString() switch
                 {
+                    //
+                    // This list comes from ShouldEmitAttribute in src\Compilers\CSharp\Portable\Symbols\Attributes\AttributeData.cs
+                    // and src\Compilers\VisualBasic\Portable\Symbols\Attributes\AttributeData.vb
+                    // TODO: Use a compiler API to get this information rather than hard coding a list: https://github.com/dotnet/roslyn/issues/53410
+                    //
                     "System.CLSCompliantAttribute" => true,
                     "System.Diagnostics.CodeAnalysis.AllowNullAttribute" => true,
                     "System.Diagnostics.CodeAnalysis.DisallowNullAttribute" => true,
@@ -3897,6 +3910,20 @@ static bool IsNonCustomAttribute(AttributeData attribute)
                     "System.Runtime.InteropServices.WindowsRuntime.WindowsRuntimeImportAttribute" => true,
                     "System.Security.DynamicSecurityMethodAttribute" => true,
                     "System.SerializableAttribute" => true,
+
+                    //
+                    // This list is not from the compiler, but included explicitly for Edit and Continue purposes
+                    //
+
+                    // Applying [AsyncMethodBuilder] changes the code that is emitted:
+                    // * When the target is a method, for any await call to the method
+                    // * When the target is a type, for any await call to a method that returns that type
+                    //
+                    // Therefore applying this attribute can cause unbounded changes to emitted code anywhere in a project
+                    // which EnC wouldn't pick up, so we block it with a rude edit
+                    "System.Runtime.CompilerServices.AsyncMethodBuilderAttribute" => true,
+
+                    // Also security attributes
                     not null => IsSecurityAttribute(attribute.AttributeClass),
                     _ => false
                 };
diff --git a/src/Features/Core/Portable/EditAndContinue/EditAndContinueDiagnosticDescriptors.cs b/src/Features/Core/Portable/EditAndContinue/EditAndContinueDiagnosticDescriptors.cs
index 38f028a9ceb5f..96b14f7799dc8 100644
--- a/src/Features/Core/Portable/EditAndContinue/EditAndContinueDiagnosticDescriptors.cs
+++ b/src/Features/Core/Portable/EditAndContinue/EditAndContinueDiagnosticDescriptors.cs
@@ -152,6 +152,7 @@ void AddGeneralDiagnostic(EditAndContinueErrorCode code, string resourceName, Di
             AddRudeEdit(RudeEditKind.ChangingConstraints, nameof(FeaturesResources.Changing_constraints_of_0_requires_restarting_the_application));
             AddRudeEdit(RudeEditKind.ChangeImplicitMainReturnType, nameof(FeaturesResources.An_update_that_causes_the_return_type_of_implicit_main_to_change_requires_restarting_the_application));
             AddRudeEdit(RudeEditKind.RenamingNotSupportedByRuntime, nameof(FeaturesResources.Renaming_0_requires_restarting_the_application_because_it_is_not_supported_by_the_runtime));
+            AddRudeEdit(RudeEditKind.ChangingNonCustomAttribute, nameof(FeaturesResources.Changing_pseudo_custom_attribute_0_of_1_requires_restarting_th_application));
 
             // VB specific
             AddRudeEdit(RudeEditKind.HandlesClauseUpdate, nameof(FeaturesResources.Updating_the_Handles_clause_of_0_requires_restarting_the_application));
diff --git a/src/Features/Core/Portable/EditAndContinue/RudeEditKind.cs b/src/Features/Core/Portable/EditAndContinue/RudeEditKind.cs
index 2f0b9455e4593..d02defb0c7f72 100644
--- a/src/Features/Core/Portable/EditAndContinue/RudeEditKind.cs
+++ b/src/Features/Core/Portable/EditAndContinue/RudeEditKind.cs
@@ -134,5 +134,6 @@ internal enum RudeEditKind : ushort
         ChangingConstraints = 105,
         ChangingReloadableTypeNotSupportedByRuntime = 106,
         RenamingNotSupportedByRuntime = 107,
+        ChangingNonCustomAttribute = 108
     }
 }
diff --git a/src/Features/Core/Portable/FeaturesResources.resx b/src/Features/Core/Portable/FeaturesResources.resx
index 8e0bb77512efc..d3088f977847b 100644
--- a/src/Features/Core/Portable/FeaturesResources.resx
+++ b/src/Features/Core/Portable/FeaturesResources.resx
@@ -2920,6 +2920,9 @@ Zero-width positive lookbehind assertions are typically used at the beginning of
   <data name="Renaming_0_requires_restarting_the_application_because_it_is_not_supported_by_the_runtime" xml:space="preserve">
     <value>Renaming {0} requires restarting the application because it is not supported by the runtime.</value>
   </data>
+  <data name="Changing_pseudo_custom_attribute_0_of_1_requires_restarting_th_application" xml:space="preserve">
+    <value>Changing pseudo-custom attribute '{0}' of {1} requires restarting the application</value>
+  </data>
   <data name="ChangesRequiredSynthesizedType" xml:space="preserve">
     <value>One or more changes result in a new type being created by the compiler, which requires restarting the application because it is not supported by the runtime</value>
   </data>
diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.cs.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.cs.xlf
index ece65257486f7..fbe365bb3ced7 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.cs.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.cs.xlf
@@ -350,6 +350,11 @@ Ujistěte se, že specifikátor tt použijete pro jazyky, pro které je nezbytn
         <target state="new">Changing parameter types of {0} requires restarting the application.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Changing_pseudo_custom_attribute_0_of_1_requires_restarting_th_application">
+        <source>Changing pseudo-custom attribute '{0}' of {1} requires restarting the application</source>
+        <target state="new">Changing pseudo-custom attribute '{0}' of {1} requires restarting the application</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Changing_the_declaration_scope_of_a_captured_variable_0_requires_restarting_the_application">
         <source>Changing the declaration scope of a captured variable '{0}' requires restarting the application.</source>
         <target state="new">Changing the declaration scope of a captured variable '{0}' requires restarting the application.</target>
diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.de.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.de.xlf
index 6249849382ae9..7a91c55c2a013 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.de.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.de.xlf
@@ -350,6 +350,11 @@ Stellen Sie sicher, dass Sie den Bezeichner "tt" für Sprachen verwenden, für d
         <target state="new">Changing parameter types of {0} requires restarting the application.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Changing_pseudo_custom_attribute_0_of_1_requires_restarting_th_application">
+        <source>Changing pseudo-custom attribute '{0}' of {1} requires restarting the application</source>
+        <target state="new">Changing pseudo-custom attribute '{0}' of {1} requires restarting the application</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Changing_the_declaration_scope_of_a_captured_variable_0_requires_restarting_the_application">
         <source>Changing the declaration scope of a captured variable '{0}' requires restarting the application.</source>
         <target state="new">Changing the declaration scope of a captured variable '{0}' requires restarting the application.</target>
diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.es.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.es.xlf
index 6d0d52faf57f9..8062884d90af5 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.es.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.es.xlf
@@ -350,6 +350,11 @@ Asegúrese de usar el especificador "tt" para los idiomas para los que es necesa
         <target state="new">Changing parameter types of {0} requires restarting the application.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Changing_pseudo_custom_attribute_0_of_1_requires_restarting_th_application">
+        <source>Changing pseudo-custom attribute '{0}' of {1} requires restarting the application</source>
+        <target state="new">Changing pseudo-custom attribute '{0}' of {1} requires restarting the application</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Changing_the_declaration_scope_of_a_captured_variable_0_requires_restarting_the_application">
         <source>Changing the declaration scope of a captured variable '{0}' requires restarting the application.</source>
         <target state="new">Changing the declaration scope of a captured variable '{0}' requires restarting the application.</target>
diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.fr.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.fr.xlf
index 7ada0aec37579..a735ff9f1afa4 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.fr.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.fr.xlf
@@ -350,6 +350,11 @@ Veillez à utiliser le spécificateur "tt" pour les langues où il est nécessai
         <target state="new">Changing parameter types of {0} requires restarting the application.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Changing_pseudo_custom_attribute_0_of_1_requires_restarting_th_application">
+        <source>Changing pseudo-custom attribute '{0}' of {1} requires restarting the application</source>
+        <target state="new">Changing pseudo-custom attribute '{0}' of {1} requires restarting the application</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Changing_the_declaration_scope_of_a_captured_variable_0_requires_restarting_the_application">
         <source>Changing the declaration scope of a captured variable '{0}' requires restarting the application.</source>
         <target state="new">Changing the declaration scope of a captured variable '{0}' requires restarting the application.</target>
diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.it.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.it.xlf
index 7a5b79b1f745c..aca2a0708cf4a 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.it.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.it.xlf
@@ -350,6 +350,11 @@ Assicurarsi di usare l'identificatore "tt" per le lingue per le quali è necessa
         <target state="new">Changing parameter types of {0} requires restarting the application.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Changing_pseudo_custom_attribute_0_of_1_requires_restarting_th_application">
+        <source>Changing pseudo-custom attribute '{0}' of {1} requires restarting the application</source>
+        <target state="new">Changing pseudo-custom attribute '{0}' of {1} requires restarting the application</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Changing_the_declaration_scope_of_a_captured_variable_0_requires_restarting_the_application">
         <source>Changing the declaration scope of a captured variable '{0}' requires restarting the application.</source>
         <target state="new">Changing the declaration scope of a captured variable '{0}' requires restarting the application.</target>
diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.ja.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.ja.xlf
index f0665927bd2af..a540515ce2e88 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.ja.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.ja.xlf
@@ -350,6 +350,11 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
         <target state="new">Changing parameter types of {0} requires restarting the application.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Changing_pseudo_custom_attribute_0_of_1_requires_restarting_th_application">
+        <source>Changing pseudo-custom attribute '{0}' of {1} requires restarting the application</source>
+        <target state="new">Changing pseudo-custom attribute '{0}' of {1} requires restarting the application</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Changing_the_declaration_scope_of_a_captured_variable_0_requires_restarting_the_application">
         <source>Changing the declaration scope of a captured variable '{0}' requires restarting the application.</source>
         <target state="new">Changing the declaration scope of a captured variable '{0}' requires restarting the application.</target>
diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.ko.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.ko.xlf
index 17a32d90a2ecf..0550ca3e31ab0 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.ko.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.ko.xlf
@@ -350,6 +350,11 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
         <target state="new">Changing parameter types of {0} requires restarting the application.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Changing_pseudo_custom_attribute_0_of_1_requires_restarting_th_application">
+        <source>Changing pseudo-custom attribute '{0}' of {1} requires restarting the application</source>
+        <target state="new">Changing pseudo-custom attribute '{0}' of {1} requires restarting the application</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Changing_the_declaration_scope_of_a_captured_variable_0_requires_restarting_the_application">
         <source>Changing the declaration scope of a captured variable '{0}' requires restarting the application.</source>
         <target state="new">Changing the declaration scope of a captured variable '{0}' requires restarting the application.</target>
diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.pl.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.pl.xlf
index 4caaeb4f6c220..25001b8ba9e06 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.pl.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.pl.xlf
@@ -350,6 +350,11 @@ Pamiętaj, aby nie używać specyfikatora „tt” dla wszystkich języków, w k
         <target state="new">Changing parameter types of {0} requires restarting the application.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Changing_pseudo_custom_attribute_0_of_1_requires_restarting_th_application">
+        <source>Changing pseudo-custom attribute '{0}' of {1} requires restarting the application</source>
+        <target state="new">Changing pseudo-custom attribute '{0}' of {1} requires restarting the application</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Changing_the_declaration_scope_of_a_captured_variable_0_requires_restarting_the_application">
         <source>Changing the declaration scope of a captured variable '{0}' requires restarting the application.</source>
         <target state="new">Changing the declaration scope of a captured variable '{0}' requires restarting the application.</target>
diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.pt-BR.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.pt-BR.xlf
index 5c7d67395f825..b14044758a257 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.pt-BR.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.pt-BR.xlf
@@ -350,6 +350,11 @@ Verifique se o especificador "tt" foi usado para idiomas para os quais é necess
         <target state="new">Changing parameter types of {0} requires restarting the application.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Changing_pseudo_custom_attribute_0_of_1_requires_restarting_th_application">
+        <source>Changing pseudo-custom attribute '{0}' of {1} requires restarting the application</source>
+        <target state="new">Changing pseudo-custom attribute '{0}' of {1} requires restarting the application</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Changing_the_declaration_scope_of_a_captured_variable_0_requires_restarting_the_application">
         <source>Changing the declaration scope of a captured variable '{0}' requires restarting the application.</source>
         <target state="new">Changing the declaration scope of a captured variable '{0}' requires restarting the application.</target>
diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.ru.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.ru.xlf
index 5239562b40621..ae0f2f58299b1 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.ru.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.ru.xlf
@@ -350,6 +350,11 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
         <target state="new">Changing parameter types of {0} requires restarting the application.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Changing_pseudo_custom_attribute_0_of_1_requires_restarting_th_application">
+        <source>Changing pseudo-custom attribute '{0}' of {1} requires restarting the application</source>
+        <target state="new">Changing pseudo-custom attribute '{0}' of {1} requires restarting the application</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Changing_the_declaration_scope_of_a_captured_variable_0_requires_restarting_the_application">
         <source>Changing the declaration scope of a captured variable '{0}' requires restarting the application.</source>
         <target state="new">Changing the declaration scope of a captured variable '{0}' requires restarting the application.</target>
diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.tr.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.tr.xlf
index 4398fd724ea19..2a0ef35fde7fd 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.tr.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.tr.xlf
@@ -350,6 +350,11 @@ AM ve PM arasındaki farkın korunmasının gerekli olduğu diller için "tt" be
         <target state="new">Changing parameter types of {0} requires restarting the application.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Changing_pseudo_custom_attribute_0_of_1_requires_restarting_th_application">
+        <source>Changing pseudo-custom attribute '{0}' of {1} requires restarting the application</source>
+        <target state="new">Changing pseudo-custom attribute '{0}' of {1} requires restarting the application</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Changing_the_declaration_scope_of_a_captured_variable_0_requires_restarting_the_application">
         <source>Changing the declaration scope of a captured variable '{0}' requires restarting the application.</source>
         <target state="new">Changing the declaration scope of a captured variable '{0}' requires restarting the application.</target>
diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hans.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hans.xlf
index d44d45e4660e5..8205db9790852 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hans.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hans.xlf
@@ -350,6 +350,11 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
         <target state="new">Changing parameter types of {0} requires restarting the application.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Changing_pseudo_custom_attribute_0_of_1_requires_restarting_th_application">
+        <source>Changing pseudo-custom attribute '{0}' of {1} requires restarting the application</source>
+        <target state="new">Changing pseudo-custom attribute '{0}' of {1} requires restarting the application</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Changing_the_declaration_scope_of_a_captured_variable_0_requires_restarting_the_application">
         <source>Changing the declaration scope of a captured variable '{0}' requires restarting the application.</source>
         <target state="new">Changing the declaration scope of a captured variable '{0}' requires restarting the application.</target>
diff --git a/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hant.xlf b/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hant.xlf
index 507396bc505b3..d12abd467ff88 100644
--- a/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hant.xlf
+++ b/src/Features/Core/Portable/xlf/FeaturesResources.zh-Hant.xlf
@@ -350,6 +350,11 @@ Make sure to use the "tt" specifier for languages for which it's necessary to ma
         <target state="new">Changing parameter types of {0} requires restarting the application.</target>
         <note />
       </trans-unit>
+      <trans-unit id="Changing_pseudo_custom_attribute_0_of_1_requires_restarting_th_application">
+        <source>Changing pseudo-custom attribute '{0}' of {1} requires restarting the application</source>
+        <target state="new">Changing pseudo-custom attribute '{0}' of {1} requires restarting the application</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Changing_the_declaration_scope_of_a_captured_variable_0_requires_restarting_the_application">
         <source>Changing the declaration scope of a captured variable '{0}' requires restarting the application.</source>
         <target state="new">Changing the declaration scope of a captured variable '{0}' requires restarting the application.</target>
diff --git a/src/Features/LanguageServer/Protocol/Handler/Hover/HoverHandler.cs b/src/Features/LanguageServer/Protocol/Handler/Hover/HoverHandler.cs
index dfd9c8ae4bdd6..154bea40f8d6e 100644
--- a/src/Features/LanguageServer/Protocol/Handler/Hover/HoverHandler.cs
+++ b/src/Features/LanguageServer/Protocol/Handler/Hover/HoverHandler.cs
@@ -90,9 +90,14 @@ private static async Task<Hover> GetHoverAsync(
 
             if (supportsVSExtensions)
             {
-                var context = document != null
-                    ? new IntellisenseQuickInfoBuilderContext(document, threadingContext: null, streamingPresenter: null)
-                    : null;
+                var context = document == null
+                    ? null
+                    : new IntellisenseQuickInfoBuilderContext(
+                        document,
+                        threadingContext: null,
+                        operationExecutor: null,
+                        asynchronousOperationListener: null,
+                        streamingPresenter: null);
                 return new VSInternalHover
                 {
                     Range = ProtocolConversions.TextSpanToRange(info.Span, text),
diff --git a/src/Features/VisualBasic/Portable/Completion/CompletionProviders/ImportCompletionProvider/ExtensionMethodImportCompletionProvider.vb b/src/Features/VisualBasic/Portable/Completion/CompletionProviders/ImportCompletionProvider/ExtensionMethodImportCompletionProvider.vb
index ff0e435bcafcc..532159840d425 100644
--- a/src/Features/VisualBasic/Portable/Completion/CompletionProviders/ImportCompletionProvider/ExtensionMethodImportCompletionProvider.vb
+++ b/src/Features/VisualBasic/Portable/Completion/CompletionProviders/ImportCompletionProvider/ExtensionMethodImportCompletionProvider.vb
@@ -37,8 +37,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Completion.Providers
 
         Public Overrides ReadOnly Property TriggerCharacters As ImmutableHashSet(Of Char) = CompletionUtilities.CommonTriggerCharsAndParen
 
-        Protected Overrides Function CreateContextAsync(document As Document, position As Integer, usePartialSemantic As Boolean, cancellationToken As CancellationToken) As Task(Of SyntaxContext)
-            Return ImportCompletionProviderHelper.CreateContextAsync(document, position, usePartialSemantic, cancellationToken)
+        Protected Overrides Function CreateContextAsync(document As Document, position As Integer, cancellationToken As CancellationToken) As Task(Of SyntaxContext)
+            Return ImportCompletionProviderHelper.CreateContextAsync(document, position, cancellationToken)
         End Function
 
         Protected Overrides Function GetImportedNamespaces(location As SyntaxNode, semanticModel As SemanticModel, cancellationToken As CancellationToken) As ImmutableArray(Of String)
diff --git a/src/Features/VisualBasic/Portable/Completion/CompletionProviders/ImportCompletionProvider/ImportCompletionProviderHelper.vb b/src/Features/VisualBasic/Portable/Completion/CompletionProviders/ImportCompletionProvider/ImportCompletionProviderHelper.vb
index 8de0fc9964150..045619b6e0243 100644
--- a/src/Features/VisualBasic/Portable/Completion/CompletionProviders/ImportCompletionProvider/ImportCompletionProviderHelper.vb
+++ b/src/Features/VisualBasic/Portable/Completion/CompletionProviders/ImportCompletionProvider/ImportCompletionProviderHelper.vb
@@ -30,13 +30,10 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Completion.Providers
             Return builder.ToImmutableAndFree()
         End Function
 
-        Public Shared Async Function CreateContextAsync(document As Document, position As Integer, usePartialSemantic As Boolean, cancellationToken As CancellationToken) As Task(Of SyntaxContext)
+        Public Shared Async Function CreateContextAsync(document As Document, position As Integer, cancellationToken As CancellationToken) As Task(Of SyntaxContext)
             ' Need regular semantic model because we will use it to get imported namespace symbols. Otherwise we will try to 
             ' reach outside of the span And ended up with "node not within syntax tree" error from the speculative model.
-            ' Also we use partial model unless full model is explictly request (e.g. in tests) so that we don't have to wait for all semantics to be computed.
-            Dim semanticModel = If(usePartialSemantic,
-                Await document.GetPartialSemanticModelAsync(cancellationToken).ConfigureAwait(False),
-                Await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(False))
+            Dim semanticModel = (Await document.GetPartialSemanticModelAsync(cancellationToken).ConfigureAwait(False)).semanticModel
             Contract.ThrowIfNull(semanticModel)
             Return VisualBasicSyntaxContext.CreateContext(document.Project.Solution.Workspace, semanticModel, position, cancellationToken)
         End Function
diff --git a/src/Features/VisualBasic/Portable/Completion/CompletionProviders/ImportCompletionProvider/TypeImportCompletionProvider.vb b/src/Features/VisualBasic/Portable/Completion/CompletionProviders/ImportCompletionProvider/TypeImportCompletionProvider.vb
index 70b9147188e26..5e3cf4798c8c4 100644
--- a/src/Features/VisualBasic/Portable/Completion/CompletionProviders/ImportCompletionProvider/TypeImportCompletionProvider.vb
+++ b/src/Features/VisualBasic/Portable/Completion/CompletionProviders/ImportCompletionProvider/TypeImportCompletionProvider.vb
@@ -32,8 +32,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Completion.Providers
 
         Public Overrides ReadOnly Property TriggerCharacters As ImmutableHashSet(Of Char) = CompletionUtilities.CommonTriggerCharsAndParen
 
-        Protected Overrides Function CreateContextAsync(document As Document, position As Integer, usePartialSemantic As Boolean, cancellationToken As CancellationToken) As Task(Of SyntaxContext)
-            Return ImportCompletionProviderHelper.CreateContextAsync(document, position, usePartialSemantic, cancellationToken)
+        Protected Overrides Function CreateContextAsync(document As Document, position As Integer, cancellationToken As CancellationToken) As Task(Of SyntaxContext)
+            Return ImportCompletionProviderHelper.CreateContextAsync(document, position, cancellationToken)
         End Function
 
         Protected Overrides Function GetImportedNamespaces(location As SyntaxNode, semanticModel As SemanticModel, cancellationToken As CancellationToken) As ImmutableArray(Of String)
diff --git a/src/Features/VisualBasic/Portable/Completion/CompletionProviders/ImportCompletionProvider/TypeImportCompletionServiceFactory.vb b/src/Features/VisualBasic/Portable/Completion/CompletionProviders/ImportCompletionProvider/TypeImportCompletionServiceFactory.vb
index 169a767b19d9a..9cd3ef4718d73 100644
--- a/src/Features/VisualBasic/Portable/Completion/CompletionProviders/ImportCompletionProvider/TypeImportCompletionServiceFactory.vb
+++ b/src/Features/VisualBasic/Portable/Completion/CompletionProviders/ImportCompletionProvider/TypeImportCompletionServiceFactory.vb
@@ -39,6 +39,12 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Completion.Providers
                     Return False
                 End Get
             End Property
+
+            Protected Overrides ReadOnly Property Language As String
+                Get
+                    Return LanguageNames.VisualBasic
+                End Get
+            End Property
         End Class
     End Class
 End Namespace
diff --git a/src/Features/VisualBasic/Portable/InvertIf/VisualBasicInvertIfCodeRefactoringProvider.MultiLine.vb b/src/Features/VisualBasic/Portable/InvertIf/VisualBasicInvertIfCodeRefactoringProvider.MultiLine.vb
index 00a9e55be5864..2cadad82d13ef 100644
--- a/src/Features/VisualBasic/Portable/InvertIf/VisualBasicInvertIfCodeRefactoringProvider.MultiLine.vb
+++ b/src/Features/VisualBasic/Portable/InvertIf/VisualBasicInvertIfCodeRefactoringProvider.MultiLine.vb
@@ -67,7 +67,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.InvertIf
         End Function
 
         Private Shared Function HasComment(elseBlock As ElseBlockSyntax) As Boolean
-            Return elseBlock.GetLeadingTrivia().Any(Function(trivia) trivia.IsKind(SyntaxKind.CommentTrivia))
+            Return elseBlock IsNot Nothing AndAlso elseBlock.GetLeadingTrivia().Any(Function(trivia) trivia.IsKind(SyntaxKind.CommentTrivia))
         End Function
     End Class
 End Namespace
diff --git a/src/Features/VisualBasic/Portable/Structure/Providers/ConstructorDeclarationStructureProvider.vb b/src/Features/VisualBasic/Portable/Structure/Providers/ConstructorDeclarationStructureProvider.vb
index ab0a78fc32ff0..ff861ec423769 100644
--- a/src/Features/VisualBasic/Portable/Structure/Providers/ConstructorDeclarationStructureProvider.vb
+++ b/src/Features/VisualBasic/Portable/Structure/Providers/ConstructorDeclarationStructureProvider.vb
@@ -16,7 +16,6 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Structure
                                                   ByRef spans As TemporaryArray(Of BlockSpan),
                                                   optionProvider As BlockStructureOptionProvider,
                                                   cancellationToken As CancellationToken)
-            Dim regions As New List(Of BlockSpan)
 
             CollectCommentsRegions(constructorDeclaration, spans, optionProvider)
 
diff --git a/src/VisualStudio/CSharp/Impl/LanguageService/CSharpCreateServicesOnTextViewConnection.cs b/src/VisualStudio/CSharp/Impl/LanguageService/CSharpCreateServicesOnTextViewConnection.cs
index 75dc78e576d68..082f372e7186c 100644
--- a/src/VisualStudio/CSharp/Impl/LanguageService/CSharpCreateServicesOnTextViewConnection.cs
+++ b/src/VisualStudio/CSharp/Impl/LanguageService/CSharpCreateServicesOnTextViewConnection.cs
@@ -3,11 +3,18 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
+using System.Collections.Generic;
 using System.ComponentModel.Composition;
+using System.Threading;
+using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Completion;
+using Microsoft.CodeAnalysis.Completion.Providers;
+using Microsoft.CodeAnalysis.Completion.Providers.ImportCompletion;
 using Microsoft.CodeAnalysis.Editor;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
 using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.VisualStudio.LanguageServices.Implementation.LanguageService;
 using Microsoft.VisualStudio.Text.Editor;
@@ -20,6 +27,11 @@ namespace Microsoft.VisualStudio.LanguageServices.CSharp.Snippets
     [TextViewRole(PredefinedTextViewRoles.Interactive)]
     internal class CSharpCreateServicesOnTextViewConnection : AbstractCreateServicesOnTextViewConnection
     {
+        private readonly object _gate = new();
+        private readonly HashSet<ProjectId> _processedProjects = new();
+        private Task _typeTask = Task.CompletedTask;
+        private Task _extensionMethodTask = Task.CompletedTask;
+
         [ImportingConstructor]
         [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
         public CSharpCreateServicesOnTextViewConnection(
@@ -29,5 +41,64 @@ public CSharpCreateServicesOnTextViewConnection(
             : base(workspace, listenerProvider, threadingContext, LanguageNames.CSharp)
         {
         }
+
+        protected override void OnSolutionRemoved()
+        {
+            lock (_gate)
+            {
+                _processedProjects.Clear();
+            }
+        }
+
+        protected override Task InitializeServiceForOpenedDocumentAsync(Document document)
+        {
+            // Only pre-populate cache if import completion is enabled
+            if (this.Workspace.Options.GetOption(CompletionOptions.ShowItemsFromUnimportedNamespaces, LanguageNames.CSharp) != true)
+                return Task.CompletedTask;
+
+            lock (_gate)
+            {
+                if (!_processedProjects.Contains(document.Project.Id))
+                {
+                    // Make sure we don't capture the entire snapshot
+                    var documentId = document.Id;
+
+                    _typeTask = _typeTask.ContinueWith(_ => PopulateTypeImportCompletionCacheAsync(this.Workspace, documentId), TaskScheduler.Default);
+                    _extensionMethodTask = _extensionMethodTask.ContinueWith(_ => PopulateExtensionMethodImportCompletionCacheAsync(this.Workspace, documentId), TaskScheduler.Default);
+                }
+
+                return Task.WhenAll(_typeTask, _extensionMethodTask);
+            }
+
+            static async Task PopulateTypeImportCompletionCacheAsync(Workspace workspace, DocumentId documentId, CancellationToken cancellationToken = default)
+            {
+                var document = workspace.CurrentSolution.GetDocument(documentId);
+                if (document is null)
+                    return;
+
+                var service = document.GetRequiredLanguageService<ITypeImportCompletionService>();
+
+                // First use partial semantic to build mostly correct cache fast
+                var partialDocument = document.WithFrozenPartialSemantics(cancellationToken);
+                await service.WarmUpCacheAsync(partialDocument.Project, CancellationToken.None).ConfigureAwait(false);
+
+                // Then try to update the cache with full semantic
+                await service.WarmUpCacheAsync(document.Project, CancellationToken.None).ConfigureAwait(false);
+            }
+
+            static async Task PopulateExtensionMethodImportCompletionCacheAsync(Workspace workspace, DocumentId documentId, CancellationToken cancellationToken = default)
+            {
+                var document = workspace.CurrentSolution.GetDocument(documentId);
+                if (document is null)
+                    return;
+
+                // First use partial semantic to build mostly correct cache fast
+                var partialDocument = document.WithFrozenPartialSemantics(cancellationToken);
+                await ExtensionMethodImportCompletionHelper.WarmUpCacheAsync(partialDocument, cancellationToken).ConfigureAwait(false);
+
+                // Then try to update the cache with full semantic
+                await ExtensionMethodImportCompletionHelper.WarmUpCacheAsync(document, cancellationToken).ConfigureAwait(false);
+            }
+        }
     }
 }
diff --git a/src/VisualStudio/CSharp/Impl/ObjectBrowser/ObjectBrowserLibraryManager.cs b/src/VisualStudio/CSharp/Impl/ObjectBrowser/ObjectBrowserLibraryManager.cs
index 965cf8f28d0ae..d3dcae31f60a1 100644
--- a/src/VisualStudio/CSharp/Impl/ObjectBrowser/ObjectBrowserLibraryManager.cs
+++ b/src/VisualStudio/CSharp/Impl/ObjectBrowser/ObjectBrowserLibraryManager.cs
@@ -14,7 +14,10 @@ namespace Microsoft.VisualStudio.LanguageServices.CSharp.ObjectBrowser
 {
     internal class ObjectBrowserLibraryManager : AbstractObjectBrowserLibraryManager
     {
-        public ObjectBrowserLibraryManager(IServiceProvider serviceProvider, IComponentModel componentModel, VisualStudioWorkspace workspace)
+        public ObjectBrowserLibraryManager(
+            IServiceProvider serviceProvider,
+            IComponentModel componentModel,
+            VisualStudioWorkspace workspace)
             : base(LanguageNames.CSharp, Guids.CSharpLibraryId, serviceProvider, componentModel, workspace)
         {
         }
diff --git a/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml b/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml
index 8836e417cc81a..3ea02278b425b 100644
--- a/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml
+++ b/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml
@@ -285,6 +285,9 @@
                     <CheckBox x:Uid="ShowInheritanceMargin"
                               x:Name="ShowInheritanceMargin"
                               Content="{x:Static local:AdvancedOptionPageStrings.Show_inheritance_margin}"/>
+                    <CheckBox x:Uid="InheritanceMarginCombinedWithIndicatorMargin"
+                              x:Name="InheritanceMarginCombinedWithIndicatorMargin"
+                              Content="{x:Static local:AdvancedOptionPageStrings.Combine_inheritance_margin_with_indicator_margin}"/>
                 </StackPanel>
             </GroupBox>
         </StackPanel>
diff --git a/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml.cs b/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml.cs
index 5d5241e25a15a..f8d55fe7324a2 100644
--- a/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml.cs
+++ b/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageControl.xaml.cs
@@ -148,6 +148,7 @@ 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);
         }
 
         // 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 1e22427816a81..78b3555694c96 100644
--- a/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageStrings.cs
+++ b/src/VisualStudio/CSharp/Impl/Options/AdvancedOptionPageStrings.cs
@@ -282,6 +282,9 @@ public static string Option_Skip_analyzers_for_implicitly_triggered_builds
         public static string Show_inheritance_margin
             => ServicesVSResources.Show_inheritance_margin;
 
+        public static string Combine_inheritance_margin_with_indicator_margin
+            => ServicesVSResources.Combine_inheritance_margin_with_indicator_margin;
+
         public static string Inheritance_Margin_experimental
             => ServicesVSResources.Inheritance_Margin_experimental;
     }
diff --git a/src/VisualStudio/Core/Def/Commands.vsct b/src/VisualStudio/Core/Def/Commands.vsct
index 1f5a13b8eb7eb..fcd6404ea35cb 100644
--- a/src/VisualStudio/Core/Def/Commands.vsct
+++ b/src/VisualStudio/Core/Def/Commands.vsct
@@ -451,7 +451,7 @@
         <CommandFlag>DefaultInvisible</CommandFlag>
         <CommandFlag>DefaultDisabled</CommandFlag>
         <Strings>
-          <ButtonText>Remove &amp;Unused References...</ButtonText>
+          <ButtonText>Remove Unused References...</ButtonText>
           <CommandName>RemoveUnusedReferences</CommandName>
           <CanonicalName>RemoveUnusedReferences</CanonicalName>
           <LocCanonicalName>RemoveUnusedReferences</LocCanonicalName>
@@ -606,7 +606,7 @@
     <CommandPlacement guid="guidRoslynGrpId" id="cmdidSyncNamespaces" priority="0xF200">
       <Parent guid="guidSHLMainMenu" id="IDG_VS_CTXT_SOLUTION_ADD" />
     </CommandPlacement>
-  
+
     <CommandPlacement guid="guidRoslynGrpId" id="cmdidshowValueTracking" priority="0xF200">
       <Parent guid="guidSHLMainMenu" id="IDG_VS_CODEWIN_NAVIGATETOLOCATION"/>
     </CommandPlacement>
@@ -704,7 +704,7 @@
       <IDSymbol name="cmdidRunCodeAnalysisForProject"  value="0x0201" />
 
       <IDSymbol name="cmdidRemoveUnusedReferences" value="0x202" />
-    
+
       <IDSymbol name="cmdidshowValueTracking"  value="0x0203" />
 
       <IDSymbol name="cmdidSyncNamespaces" value="0x204" />
diff --git a/src/VisualStudio/Core/Def/Implementation/FindReferences/Entries/DocumentSpanEntry.cs b/src/VisualStudio/Core/Def/Implementation/FindReferences/Entries/DocumentSpanEntry.cs
index 3819d7bf0a4a6..c8d8240113c86 100644
--- a/src/VisualStudio/Core/Def/Implementation/FindReferences/Entries/DocumentSpanEntry.cs
+++ b/src/VisualStudio/Core/Def/Implementation/FindReferences/Entries/DocumentSpanEntry.cs
@@ -36,7 +36,7 @@ internal partial class StreamingFindUsagesPresenter
         /// contents of that line, and hovering will reveal a tooltip showing that line along
         /// with a few lines above/below it.
         /// </summary>
-        private class DocumentSpanEntry : AbstractDocumentSpanEntry, ISupportsNavigation
+        private sealed class DocumentSpanEntry : AbstractDocumentSpanEntry, ISupportsNavigation
         {
             private readonly HighlightSpanKind _spanKind;
             private readonly ExcerptResult _excerptResult;
@@ -280,30 +280,37 @@ private static Span GetRegionSpanForReference(SourceText sourceText, TextSpan so
                     sourceText.Lines[lastLineNumber].End);
             }
 
-            async Task<bool> ISupportsNavigation.TryNavigateToAsync(bool isPreview, CancellationToken cancellationToken)
+            public bool CanNavigateTo()
             {
-                // If the document is a source generated document, we need to do the navigation ourselves;
-                // this is because the file path given to the table control isn't a real file path to a file
-                // on disk.
                 if (_excerptResult.Document is SourceGeneratedDocument)
                 {
                     var workspace = _excerptResult.Document.Project.Solution.Workspace;
                     var documentNavigationService = workspace.Services.GetService<IDocumentNavigationService>();
 
-                    if (documentNavigationService != null)
-                    {
-                        await this.Presenter.ThreadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
-                        return documentNavigationService.TryNavigateToSpan(
-                            workspace,
-                            _excerptResult.Document.Id,
-                            _excerptResult.Span,
-                            workspace.Options.WithChangedOption(NavigationOptions.PreferProvisionalTab, isPreview),
-                            cancellationToken);
-                    }
+                    return documentNavigationService != null;
                 }
 
                 return false;
             }
+
+            public Task NavigateToAsync(bool isPreview, CancellationToken cancellationToken)
+            {
+                Contract.ThrowIfFalse(CanNavigateTo());
+
+                // If the document is a source generated document, we need to do the navigation ourselves;
+                // this is because the file path given to the table control isn't a real file path to a file
+                // on disk.
+
+                var workspace = _excerptResult.Document.Project.Solution.Workspace;
+                var documentNavigationService = workspace.Services.GetRequiredService<IDocumentNavigationService>();
+
+                return documentNavigationService.TryNavigateToSpanAsync(
+                    workspace,
+                    _excerptResult.Document.Id,
+                    _excerptResult.Span,
+                    workspace.Options.WithChangedOption(NavigationOptions.PreferProvisionalTab, isPreview),
+                    cancellationToken);
+            }
         }
     }
 }
diff --git a/src/VisualStudio/Core/Def/Implementation/FindReferences/Entries/Entry.cs b/src/VisualStudio/Core/Def/Implementation/FindReferences/Entries/Entry.cs
index c8683248ec7a4..2ab874137c2aa 100644
--- a/src/VisualStudio/Core/Def/Implementation/FindReferences/Entries/Entry.cs
+++ b/src/VisualStudio/Core/Def/Implementation/FindReferences/Entries/Entry.cs
@@ -3,6 +3,8 @@
 // See the LICENSE file in the project root for more information.
 
 using System.Diagnostics.CodeAnalysis;
+using System.Threading;
+using System.Threading.Tasks;
 using System.Windows;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Editor.Wpf;
diff --git a/src/VisualStudio/Core/Def/Implementation/FindReferences/Entries/MetadataDefinitionItemEntry.cs b/src/VisualStudio/Core/Def/Implementation/FindReferences/Entries/MetadataDefinitionItemEntry.cs
index 6895c3a9d8c6f..54cd2dd673991 100644
--- a/src/VisualStudio/Core/Def/Implementation/FindReferences/Entries/MetadataDefinitionItemEntry.cs
+++ b/src/VisualStudio/Core/Def/Implementation/FindReferences/Entries/MetadataDefinitionItemEntry.cs
@@ -34,13 +34,16 @@ public MetadataDefinitionItemEntry(
                 return null;
             }
 
-            Task<bool> ISupportsNavigation.TryNavigateToAsync(bool isPreview, CancellationToken cancellationToken)
+            public bool CanNavigateTo()
+                => true;
+
+            public Task NavigateToAsync(bool isPreview, CancellationToken cancellationToken)
                 => DefinitionBucket.DefinitionItem.TryNavigateToAsync(
                     Presenter._workspace, showInPreviewTab: isPreview, activateTab: !isPreview, cancellationToken); // Only activate the tab if not opening in preview
 
             protected override IList<Inline> CreateLineTextInlines()
                 => DefinitionBucket.DefinitionItem.DisplayParts
-                .ToInlines(Presenter.ClassificationFormatMap, Presenter.TypeMap);
+                    .ToInlines(Presenter.ClassificationFormatMap, Presenter.TypeMap);
         }
     }
 }
diff --git a/src/VisualStudio/Core/Def/Implementation/FindReferences/Entries/SimpleMessageEntry.cs b/src/VisualStudio/Core/Def/Implementation/FindReferences/Entries/SimpleMessageEntry.cs
index ee68ad11f7bb6..0548a82889cd9 100644
--- a/src/VisualStudio/Core/Def/Implementation/FindReferences/Entries/SimpleMessageEntry.cs
+++ b/src/VisualStudio/Core/Def/Implementation/FindReferences/Entries/SimpleMessageEntry.cs
@@ -5,12 +5,13 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.VisualStudio.Shell.TableManager;
+using Roslyn.Utilities;
 
 namespace Microsoft.VisualStudio.LanguageServices.FindUsages
 {
     internal partial class StreamingFindUsagesPresenter
     {
-        private class SimpleMessageEntry : Entry, ISupportsNavigation
+        private sealed class SimpleMessageEntry : Entry, ISupportsNavigation
         {
             private readonly RoslynDefinitionBucket? _navigationBucket;
             private readonly string _message;
@@ -44,8 +45,15 @@ public static Task<Entry> CreateAsync(
                 };
             }
 
-            public async Task<bool> TryNavigateToAsync(bool isPreview, CancellationToken cancellationToken)
-                => _navigationBucket != null && await _navigationBucket.TryNavigateToAsync(isPreview, cancellationToken).ConfigureAwait(false);
+            public bool CanNavigateTo()
+                => _navigationBucket != null && _navigationBucket.CanNavigateTo();
+
+            public Task NavigateToAsync(bool isPreview, CancellationToken cancellationToken)
+            {
+                Contract.ThrowIfFalse(CanNavigateTo());
+                Contract.ThrowIfNull(_navigationBucket);
+                return _navigationBucket.NavigateToAsync(isPreview, cancellationToken);
+            }
         }
     }
 }
diff --git a/src/VisualStudio/Core/Def/Implementation/FindReferences/FindReferencesTableControlEventProcessorProvider.cs b/src/VisualStudio/Core/Def/Implementation/FindReferences/FindReferencesTableControlEventProcessorProvider.cs
index d0f704671f7e8..4c17453d718ba 100644
--- a/src/VisualStudio/Core/Def/Implementation/FindReferences/FindReferencesTableControlEventProcessorProvider.cs
+++ b/src/VisualStudio/Core/Def/Implementation/FindReferences/FindReferencesTableControlEventProcessorProvider.cs
@@ -59,16 +59,15 @@ public override void PreprocessNavigate(ITableEntryHandle entry, TableEntryNavig
             {
                 var supportsNavigation = entry.Identity as ISupportsNavigation ??
                     (entry.TryGetValue(StreamingFindUsagesPresenter.SelfKeyName, out var item) ? item as ISupportsNavigation : null);
-                if (supportsNavigation == null)
+                if (supportsNavigation != null &&
+                    supportsNavigation.CanNavigateTo())
                 {
-                    base.PreprocessNavigate(entry, e);
-                    return;
+                    // Fire and forget
+                    e.Handled = true;
+                    _ = ProcessNavigateAsync(supportsNavigation, e, _listener, _operationExecutor);
                 }
 
-                // Fire and forget
-                e.Handled = true;
-                _ = ProcessNavigateAsync(supportsNavigation, e, _listener, _operationExecutor);
-
+                base.PreprocessNavigate(entry, e);
                 return;
 
                 async static Task ProcessNavigateAsync(
@@ -83,7 +82,7 @@ async static Task ProcessNavigateAsync(
                         allowCancellation: true,
                         showProgress: false);
 
-                    await supportsNavigation.TryNavigateToAsync(e.IsPreview, context.UserCancellationToken).ConfigureAwait(false);
+                    await supportsNavigation.NavigateToAsync(e.IsPreview, context.UserCancellationToken).ConfigureAwait(false);
                 }
             }
         }
diff --git a/src/VisualStudio/Core/Def/Implementation/FindReferences/ISupportsNavigation.cs b/src/VisualStudio/Core/Def/Implementation/FindReferences/ISupportsNavigation.cs
index e447dc9745b7c..7b9cac4600b7c 100644
--- a/src/VisualStudio/Core/Def/Implementation/FindReferences/ISupportsNavigation.cs
+++ b/src/VisualStudio/Core/Def/Implementation/FindReferences/ISupportsNavigation.cs
@@ -9,6 +9,7 @@ namespace Microsoft.VisualStudio.LanguageServices.FindUsages
 {
     internal interface ISupportsNavigation
     {
-        Task<bool> TryNavigateToAsync(bool isPreview, CancellationToken cancellationToken);
+        bool CanNavigateTo();
+        Task NavigateToAsync(bool isPreview, CancellationToken cancellationToken);
     }
 }
diff --git a/src/VisualStudio/Core/Def/Implementation/FindReferences/RoslynDefinitionBucket.cs b/src/VisualStudio/Core/Def/Implementation/FindReferences/RoslynDefinitionBucket.cs
index 1f7e02bfaefae..850970c700cb1 100644
--- a/src/VisualStudio/Core/Def/Implementation/FindReferences/RoslynDefinitionBucket.cs
+++ b/src/VisualStudio/Core/Def/Implementation/FindReferences/RoslynDefinitionBucket.cs
@@ -63,7 +63,10 @@ public static RoslynDefinitionBucket Create(
                     name, expandedByDefault, presenter, context, definitionItem);
             }
 
-            public Task<bool> TryNavigateToAsync(bool isPreview, CancellationToken cancellationToken)
+            public bool CanNavigateTo()
+                => true;
+
+            public Task NavigateToAsync(bool isPreview, CancellationToken cancellationToken)
                 => DefinitionItem.TryNavigateToAsync(
                     _presenter._workspace, showInPreviewTab: isPreview, activateTab: !isPreview, cancellationToken); // Only activate the tab if not opening in preview
 
diff --git a/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/InheritanceGlyphFactory.cs b/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/InheritanceGlyphFactory.cs
index 970d61feaa3be..af42774be7869 100644
--- a/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/InheritanceGlyphFactory.cs
+++ b/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/InheritanceGlyphFactory.cs
@@ -4,7 +4,11 @@
 
 using System.Windows;
 using Microsoft.CodeAnalysis.Editor.Host;
+using Microsoft.CodeAnalysis.Editor.Shared.Options;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
+using Microsoft.CodeAnalysis.Options;
+using Microsoft.CodeAnalysis.Text;
+using Microsoft.VisualStudio.LanguageServices.Implementation.InheritanceMargin.MarginGlyph;
 using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.VisualStudio.Text.Classification;
 using Microsoft.VisualStudio.Text.Editor;
@@ -14,6 +18,9 @@
 
 namespace Microsoft.VisualStudio.LanguageServices.Implementation.InheritanceMargin
 {
+    /// <summary>
+    /// GlyphFactory provides the InheritanceMargin shows in IndicatorMargin. (Margin shared with breakpoint)
+    /// </summary>
     internal sealed class InheritanceGlyphFactory : IGlyphFactory
     {
         private readonly IThreadingContext _threadingContext;
@@ -45,12 +52,31 @@ public InheritanceGlyphFactory(
         public UIElement? GenerateGlyph(IWpfTextViewLine line, IGlyphTag tag)
         {
             if (tag is not InheritanceMarginTag inheritanceMarginTag)
+            {
                 return null;
+            }
+
+            var workspace = _textView.TextBuffer.GetWorkspace();
+            if (workspace == null)
+            {
+                return null;
+            }
+
+            var optionService = workspace.Services.GetRequiredService<IOptionService>();
+            // The life cycle of the glyphs in Indicator Margin is controlled by the editor,
+            // so in order to get the glyphs removed when FeatureOnOffOptions.InheritanceMarginCombinedWithIndicatorMargin is off,
+            // we need
+            // 1. Generate tags when this option changes.
+            // 2. Always return null here to force the editor to remove the glyphs.
+            var combineWithIndicatorMargin = optionService.GetOption(FeatureOnOffOptions.InheritanceMarginCombinedWithIndicatorMargin);
+            if (!combineWithIndicatorMargin)
+            {
+                return null;
+            }
 
             var membersOnLine = inheritanceMarginTag.MembersOnLine;
             Contract.ThrowIfTrue(membersOnLine.IsEmpty);
-
-            return new MarginGlyph.InheritanceMargin(
+            return new InheritanceMarginGlyph(
                 _threadingContext,
                 _streamingFindUsagesPresenter,
                 _classificationTypeMap,
diff --git a/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/InheritanceGlyphManager.cs b/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/InheritanceGlyphManager.cs
new file mode 100644
index 0000000000000..cbe7a184cb3a7
--- /dev/null
+++ b/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/InheritanceGlyphManager.cs
@@ -0,0 +1,222 @@
+// 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.Windows.Controls;
+using System.Windows.Media;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Editor.Host;
+using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
+using Microsoft.CodeAnalysis.Shared.Collections;
+using Microsoft.CodeAnalysis.Shared.TestHooks;
+using Microsoft.VisualStudio.LanguageServices.Implementation.InheritanceMargin.MarginGlyph;
+using Microsoft.VisualStudio.PlatformUI;
+using Microsoft.VisualStudio.Text;
+using Microsoft.VisualStudio.Text.Classification;
+using Microsoft.VisualStudio.Text.Editor;
+using Microsoft.VisualStudio.Text.Formatting;
+using Microsoft.VisualStudio.Utilities;
+
+namespace Microsoft.VisualStudio.LanguageServices.Implementation.InheritanceMargin
+{
+    /// <summary>
+    /// Manager controls all the glyphs of Inheritance Margin in <see cref="InheritanceMarginViewMargin"/>.
+    /// </summary>
+    internal partial class InheritanceGlyphManager : ForegroundThreadAffinitizedObject, IDisposable
+    {
+        // We want to our glyphs to have the same background color as the glyphs in GlyphMargin.
+        private const string GlyphMarginName = "Indicator Margin";
+
+        private readonly double _heightAndWidthOfTheGlyph;
+        private readonly IWpfTextView _textView;
+        private readonly IThreadingContext _threadingContext;
+        private readonly IStreamingFindUsagesPresenter _streamingFindUsagesPresenter;
+        private readonly ClassificationTypeMap _classificationTypeMap;
+        private readonly IClassificationFormatMap _classificationFormatMap;
+        private readonly IUIThreadOperationExecutor _operationExecutor;
+        private readonly IEditorFormatMap _editorFormatMap;
+        private readonly IAsynchronousOperationListener _listener;
+        private readonly Canvas _glyphsContainer;
+        private readonly SimpleIntervalTree<GlyphData, GlyphDataIntrospector> _glyphDataTree;
+
+        public InheritanceGlyphManager(
+            IWpfTextView textView,
+            IThreadingContext threadingContext,
+            IStreamingFindUsagesPresenter streamingFindUsagesPresenter,
+            IClassificationFormatMap classificationFormatMap,
+            ClassificationTypeMap classificationTypeMap,
+            IUIThreadOperationExecutor operationExecutor,
+            IEditorFormatMap editorFormatMap,
+            IAsynchronousOperationListener listener,
+            Canvas canvas,
+            double heightAndWidthOfTheGlyph) : base(threadingContext)
+        {
+            _textView = textView;
+            _threadingContext = threadingContext;
+            _streamingFindUsagesPresenter = streamingFindUsagesPresenter;
+            _classificationTypeMap = classificationTypeMap;
+            _classificationFormatMap = classificationFormatMap;
+            _operationExecutor = operationExecutor;
+            _editorFormatMap = editorFormatMap;
+            _glyphsContainer = canvas;
+            _listener = listener;
+            _heightAndWidthOfTheGlyph = heightAndWidthOfTheGlyph;
+            _editorFormatMap.FormatMappingChanged += FormatMappingChanged;
+
+            // _glyphToTaggedSpan = new Dictionary<InheritanceMarginGlyph, SnapshotSpan>();
+            _glyphDataTree = new SimpleIntervalTree<GlyphData, GlyphDataIntrospector>(new GlyphDataIntrospector(), values: null);
+            UpdateBackgroundColor();
+        }
+
+        void IDisposable.Dispose()
+        {
+            _editorFormatMap.FormatMappingChanged -= FormatMappingChanged;
+        }
+
+        /// <summary>
+        /// Generate the glyph by the given <paramref name="tag"/>, and add it to the margin.
+        /// It should only be called by UI thread because UI elements are manipulated by this method.
+        /// </summary>
+        public void AddGlyph(InheritanceMarginTag tag, SnapshotSpan span)
+        {
+            AssertIsForeground();
+            var lines = _textView.TextViewLines;
+            if (lines.IntersectsBufferSpan(span) && GetStartingLine(lines, span) is IWpfTextViewLine line)
+            {
+                var glyph = CreateNewGlyph(tag);
+                SetTop(line, glyph);
+                _glyphDataTree.AddIntervalInPlace(new GlyphData(span, glyph));
+                _glyphsContainer.Children.Add(glyph);
+            }
+        }
+
+        /// <summary>
+        /// Remove the glyphs covered by <paramref name="snapshotSpan"/>.
+        /// It should only be called by UI thread because UI elements are manipulated by this method.
+        /// </summary>
+        public void RemoveGlyphs(SnapshotSpan snapshotSpan)
+        {
+            AssertIsForeground();
+            var glyphDataToRemove = _glyphDataTree.GetIntervalsThatIntersectWith(snapshotSpan.Start, snapshotSpan.Length);
+            foreach (var (_, glyph) in glyphDataToRemove)
+            {
+                _glyphsContainer.Children.Remove(glyph);
+            }
+
+            var remainingGlyphData = _glyphDataTree.Except(glyphDataToRemove).ToImmutableArray();
+            _glyphDataTree.ClearInPlace();
+            foreach (var glyphData in remainingGlyphData)
+            {
+                _glyphDataTree.AddIntervalInPlace(glyphData);
+            }
+        }
+
+        /// <summary>
+        /// Remove the glyphs that are no long visible or covered by the <paramref name="newOrReformattedLines"/>.
+        /// Refresh all the other the existing glyphs with the <paramref name="snapshot"/>.
+        /// It should only be called by UI thread because UI elements are manipulated by this method.
+        /// </summary>
+        public void SetSnapshotAndUpdate(ITextSnapshot snapshot, IList<ITextViewLine> newOrReformattedLines, IList<ITextViewLine> translatedLines)
+        {
+            AssertIsForeground();
+            if (!_glyphDataTree.IsEmpty())
+            {
+                // Go through all the existing visuals and invalidate or transform as appropriate.
+                var allGlyphData = _glyphDataTree.ToImmutableArray();
+                _glyphDataTree.ClearInPlace();
+                foreach (var (span, glyph) in allGlyphData)
+                {
+                    var newSpan = span.TranslateTo(snapshot, SpanTrackingMode.EdgeInclusive);
+                    if (!_textView.TextViewLines.IntersectsBufferSpan(newSpan) || GetStartingLine(newOrReformattedLines, newSpan) != null)
+                    {
+                        //Either visual is no longer visible or it crosses a line
+                        //that was reformatted.
+                        _glyphsContainer.Children.Remove(glyph);
+                    }
+                    else
+                    {
+                        _glyphDataTree.AddIntervalInPlace(new GlyphData(newSpan, glyph));
+                        var line = GetStartingLine(translatedLines, newSpan);
+                        if (line != null)
+                        {
+                            SetTop(line, glyph);
+                        }
+                    }
+                }
+            }
+        }
+
+        private void SetTop(ITextViewLine line, InheritanceMarginGlyph glyph)
+            => Canvas.SetTop(glyph, line.TextTop - _textView.ViewportTop);
+
+        private static ITextViewLine? GetStartingLine(IList<ITextViewLine> lines, Span span)
+        {
+            if (lines.Count > 0)
+            {
+                var index = lines.ToImmutableArray().BinarySearch(span.Start, CompareWithLineStartAndEnd);
+                if (index >= 0)
+                {
+                    return lines[index];
+                }
+
+                var lastLine = lines[^1];
+                if (lastLine.EndIncludingLineBreak == lastLine.Snapshot.Length && span.Start == lastLine.EndIncludingLineBreak)
+                {
+                    // As a special case, if the last line ends at the end of the buffer and the span starts at the end of the buffer
+                    // as well, treat is as crossing the last line in the buffer.
+                    return lastLine;
+                }
+            }
+
+            return null;
+        }
+
+        private static int CompareWithLineStartAndEnd(ITextViewLine line, int value)
+        {
+            if (value < line.Start)
+            {
+                return 1;
+            }
+
+            // EndIncludingLineBreak usually equals the start of next line (the exclusion is if this is the last line, which will be handled separately),
+            // and we always prefer to use the line start, so still return -1 when value == line.EndIncludingLineBreak.
+            if (value >= line.EndIncludingLineBreak)
+            {
+                return -1;
+            }
+
+            return 0;
+        }
+
+        private InheritanceMarginGlyph CreateNewGlyph(InheritanceMarginTag tag)
+            => new(
+                _threadingContext,
+                _streamingFindUsagesPresenter,
+                _classificationTypeMap,
+                _classificationFormatMap,
+                _operationExecutor,
+                tag,
+                _textView,
+                _listener)
+            { Height = _heightAndWidthOfTheGlyph, Width = _heightAndWidthOfTheGlyph };
+
+        private void FormatMappingChanged(object sender, FormatItemsEventArgs e)
+            => UpdateBackgroundColor();
+
+        private void UpdateBackgroundColor()
+        {
+            AssertIsForeground();
+            var resourceDictionary = _editorFormatMap.GetProperties(GlyphMarginName);
+            if (resourceDictionary.Contains(EditorFormatDefinition.BackgroundColorId))
+            {
+                var backgroundColor = (Color)resourceDictionary[EditorFormatDefinition.BackgroundColorId];
+                // Set background color for all the glyphs
+                ImageThemingUtilities.SetImageBackgroundColor(_glyphsContainer, backgroundColor);
+            }
+        }
+    }
+}
diff --git a/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/InheritanceGlyphManager_IntervalTreeData.cs b/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/InheritanceGlyphManager_IntervalTreeData.cs
new file mode 100644
index 0000000000000..d7b26f4f0163f
--- /dev/null
+++ b/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/InheritanceGlyphManager_IntervalTreeData.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 Microsoft.CodeAnalysis.Shared.Collections;
+using Microsoft.VisualStudio.LanguageServices.Implementation.InheritanceMargin.MarginGlyph;
+using Microsoft.VisualStudio.Text;
+
+namespace Microsoft.VisualStudio.LanguageServices.Implementation.InheritanceMargin
+{
+    internal partial class InheritanceGlyphManager
+    {
+        private record GlyphData
+        {
+            public SnapshotSpan SnapshotSpan { get; }
+            public InheritanceMarginGlyph Glyph { get; }
+
+            public GlyphData(SnapshotSpan snapshotSpan, InheritanceMarginGlyph glyph)
+            {
+                SnapshotSpan = snapshotSpan;
+                Glyph = glyph;
+            }
+
+            public void Deconstruct(out SnapshotSpan span, out InheritanceMarginGlyph glyph)
+            {
+                span = SnapshotSpan;
+                glyph = Glyph;
+            }
+        }
+
+        private readonly struct GlyphDataIntrospector : IIntervalIntrospector<GlyphData>
+        {
+            public int GetStart(GlyphData data)
+                => data.SnapshotSpan.Start;
+
+            public int GetLength(GlyphData data)
+                => data.SnapshotSpan.Length;
+        }
+    }
+}
diff --git a/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/InheritanceMarginHelpers.cs b/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/InheritanceMarginHelpers.cs
index 42c4e51308420..54317e85fdfcc 100644
--- a/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/InheritanceMarginHelpers.cs
+++ b/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/InheritanceMarginHelpers.cs
@@ -92,7 +92,7 @@ public static ImageMoniker GetMoniker(InheritanceRelationship inheritanceRelatio
             throw ExceptionUtilities.UnexpectedValue(inheritanceRelationship);
         }
 
-        public static ImmutableArray<InheritanceMenuItemViewModel> CreateMenuItemViewModelsForSingleMember(ImmutableArray<InheritanceTargetItem> targets)
+        public static ImmutableArray<MenuItemViewModel> CreateMenuItemViewModelsForSingleMember(ImmutableArray<InheritanceTargetItem> targets)
             => targets.OrderBy(target => target.DisplayName)
                 .GroupBy(target => target.RelationToMember)
                 .SelectMany(grouping => CreateMenuItemsWithHeader(grouping.Key, grouping))
@@ -110,20 +110,20 @@ public static ImmutableArray<InheritanceMenuItemViewModel> CreateMenuItemViewMod
         ///                     HeaderViewModel
         ///                     Target5ViewModel
         /// </summary>
-        public static ImmutableArray<InheritanceMenuItemViewModel> CreateMenuItemViewModelsForMultipleMembers(ImmutableArray<InheritanceMarginItem> members)
+        public static ImmutableArray<MenuItemViewModel> CreateMenuItemViewModelsForMultipleMembers(ImmutableArray<InheritanceMarginItem> members)
         {
             Contract.ThrowIfTrue(members.Length <= 1);
             // For multiple members, check if all the targets have the same inheritance relationship.
             // If so, then don't add the header, because it is already indicated by the margin.
             // Otherwise, add the Header.
-            return members.SelectAsArray(MemberMenuItemViewModel.CreateWithHeaderInTargets).CastArray<InheritanceMenuItemViewModel>();
+            return members.SelectAsArray(MemberMenuItemViewModel.CreateWithHeaderInTargets).CastArray<MenuItemViewModel>();
         }
 
-        public static ImmutableArray<InheritanceMenuItemViewModel> CreateMenuItemsWithHeader(
+        public static ImmutableArray<MenuItemViewModel> CreateMenuItemsWithHeader(
             InheritanceRelationship relationship,
             IEnumerable<InheritanceTargetItem> targets)
         {
-            using var _ = CodeAnalysis.PooledObjects.ArrayBuilder<InheritanceMenuItemViewModel>.GetInstance(out var builder);
+            using var _ = CodeAnalysis.PooledObjects.ArrayBuilder<MenuItemViewModel>.GetInstance(out var builder);
             var displayContent = relationship switch
             {
                 InheritanceRelationship.ImplementedInterface => ServicesVSResources.Implemented_interfaces,
diff --git a/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/InheritanceMarginTaggerProvider.cs b/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/InheritanceMarginTaggerProvider.cs
index 50c77ec781484..37c2f9448e3fc 100644
--- a/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/InheritanceMarginTaggerProvider.cs
+++ b/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/InheritanceMarginTaggerProvider.cs
@@ -50,13 +50,16 @@ protected override ITaggerEventSource CreateEventSource(ITextView textViewOpt, I
             // Because we use frozen-partial documents for semantic classification, we may end up with incomplete
             // semantics (esp. during solution load).  Because of this, we also register to hear when the full
             // compilation is available so that reclassify and bring ourselves up to date.
+            // Note: Also generate tags when FeatureOnOffOptions.InheritanceMarginCombinedWithIndicatorMargin is changed,
+            // because we want to refresh the glyphs in indicator margin.
             => new CompilationAvailableTaggerEventSource(
                 subjectBuffer,
                 AsyncListener,
                 TaggerEventSources.OnWorkspaceChanged(subjectBuffer, AsyncListener),
                 TaggerEventSources.OnViewSpanChanged(ThreadingContext, textViewOpt),
                 TaggerEventSources.OnDocumentActiveContextChanged(subjectBuffer),
-                TaggerEventSources.OnOptionChanged(subjectBuffer, FeatureOnOffOptions.ShowInheritanceMargin));
+                TaggerEventSources.OnOptionChanged(subjectBuffer, FeatureOnOffOptions.ShowInheritanceMargin),
+                TaggerEventSources.OnOptionChanged(subjectBuffer, FeatureOnOffOptions.InheritanceMarginCombinedWithIndicatorMargin));
 
         protected override IEnumerable<SnapshotSpan> GetSpansToTag(ITextView textView, ITextBuffer subjectBuffer)
         {
diff --git a/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/InheritanceMarginViewMargin.cs b/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/InheritanceMarginViewMargin.cs
new file mode 100644
index 0000000000000..95c4049492d91
--- /dev/null
+++ b/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/InheritanceMarginViewMargin.cs
@@ -0,0 +1,244 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Media;
+using Microsoft.CodeAnalysis.Editor.Host;
+using Microsoft.CodeAnalysis.Editor.Shared.Options;
+using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
+using Microsoft.CodeAnalysis.Options;
+using Microsoft.CodeAnalysis.Shared.TestHooks;
+using Microsoft.VisualStudio.Text;
+using Microsoft.VisualStudio.Text.Classification;
+using Microsoft.VisualStudio.Text.Editor;
+using Microsoft.VisualStudio.Text.Formatting;
+using Microsoft.VisualStudio.Text.Tagging;
+using Microsoft.VisualStudio.Utilities;
+
+namespace Microsoft.VisualStudio.LanguageServices.Implementation.InheritanceMargin
+{
+    internal class InheritanceMarginViewMargin : ForegroundThreadAffinitizedObject, IWpfTextViewMargin
+    {
+        // Same size as the Glyph Margin
+        private const double HeightAndWidthOfMargin = 17;
+        private readonly IWpfTextView _textView;
+        private readonly ITagAggregator<InheritanceMarginTag> _tagAggregator;
+        private readonly IOptionService _optionService;
+        private readonly InheritanceGlyphManager _glyphManager;
+        private readonly string _languageName;
+        private readonly Grid _grid;
+        private readonly Canvas _mainCanvas;
+
+        /// <summary>
+        /// A flag indicates all the glyphs in this margin needs be refreshed when the Layout of the TextView changes.
+        /// Should only be read or written to by the UI thread.
+        /// </summary>
+        private bool _refreshAllGlyphs;
+        private bool _disposed;
+
+        public InheritanceMarginViewMargin(IWpfTextView textView,
+            IThreadingContext threadingContext,
+            IStreamingFindUsagesPresenter streamingFindUsagesPresenter,
+            IUIThreadOperationExecutor operationExecutor,
+            IClassificationFormatMap classificationFormatMap,
+            ClassificationTypeMap classificationTypeMap,
+            ITagAggregator<InheritanceMarginTag> tagAggregator,
+            IEditorFormatMap editorFormatMap,
+            IOptionService optionService,
+            IAsynchronousOperationListener listener,
+            string languageName) : base(threadingContext)
+        {
+            _textView = textView;
+            _tagAggregator = tagAggregator;
+            _optionService = optionService;
+            _languageName = languageName;
+            _mainCanvas = new Canvas { ClipToBounds = true, Width = HeightAndWidthOfMargin };
+            _grid = new Grid();
+            _grid.Children.Add(_mainCanvas);
+            _glyphManager = new InheritanceGlyphManager(
+                textView,
+                threadingContext,
+                streamingFindUsagesPresenter,
+                classificationFormatMap,
+                classificationTypeMap,
+                operationExecutor,
+                editorFormatMap,
+                listener,
+                _mainCanvas,
+                HeightAndWidthOfMargin);
+            _refreshAllGlyphs = true;
+            _disposed = false;
+
+            _tagAggregator.BatchedTagsChanged += OnTagsChanged;
+            _textView.LayoutChanged += OnLayoutChanged;
+            _textView.ZoomLevelChanged += OnZoomLevelChanged;
+            _optionService.OptionChanged += OnRoslynOptionChanged;
+
+            _grid.LayoutTransform = new ScaleTransform(
+                scaleX: _textView.ZoomLevel / 100,
+                scaleY: _textView.ZoomLevel / 100);
+            _grid.LayoutTransform.Freeze();
+            UpdateMarginVisibility();
+        }
+
+        void IDisposable.Dispose()
+        {
+            AssertIsForeground();
+            if (!_disposed)
+            {
+                _disposed = true;
+                _tagAggregator.BatchedTagsChanged -= OnTagsChanged;
+                _textView.LayoutChanged -= OnLayoutChanged;
+                _textView.ZoomLevelChanged -= OnZoomLevelChanged;
+                _optionService.OptionChanged -= OnRoslynOptionChanged;
+                _tagAggregator.Dispose();
+                ((IDisposable)_glyphManager).Dispose();
+            }
+        }
+
+        private void OnZoomLevelChanged(object sender, ZoomLevelChangedEventArgs e)
+        {
+            _grid.LayoutTransform = e.ZoomTransform;
+            _refreshAllGlyphs = true;
+        }
+
+        private void OnLayoutChanged(object sender, TextViewLayoutChangedEventArgs e)
+        {
+            _glyphManager.SetSnapshotAndUpdate(
+                _textView.TextSnapshot,
+                e.NewOrReformattedLines,
+                e.VerticalTranslation ? _textView.TextViewLines : e.TranslatedLines);
+
+            IList<ITextViewLine> lines = _refreshAllGlyphs ? _textView.TextViewLines : e.NewOrReformattedLines;
+            foreach (var line in lines)
+            {
+                _glyphManager.RemoveGlyphs(line.Extent);
+                RefreshGlyphsOver(line);
+            }
+
+            _refreshAllGlyphs = false;
+        }
+
+        private void OnRoslynOptionChanged(object sender, OptionChangedEventArgs e)
+        {
+            if (e.Option.Equals(FeatureOnOffOptions.ShowInheritanceMargin) || e.Option.Equals(FeatureOnOffOptions.InheritanceMarginCombinedWithIndicatorMargin))
+            {
+                UpdateMarginVisibility();
+            }
+        }
+
+        private void UpdateMarginVisibility()
+        {
+            var featureEnabled = _optionService.GetOption(FeatureOnOffOptions.ShowInheritanceMargin, _languageName) ?? true;
+            if (featureEnabled)
+            {
+                var showMargin = !_optionService.GetOption(FeatureOnOffOptions.InheritanceMarginCombinedWithIndicatorMargin);
+                if (showMargin)
+                {
+                    _mainCanvas.Visibility = Visibility.Visible;
+                    return;
+                }
+            }
+
+            _mainCanvas.Visibility = Visibility.Collapsed;
+        }
+
+        private void OnTagsChanged(object sender, BatchedTagsChangedEventArgs e)
+        {
+            if (_textView.IsClosed)
+            {
+                return;
+            }
+
+            using var _ = CodeAnalysis.PooledObjects.ArrayBuilder<SnapshotSpan>.GetInstance(out var builder);
+            foreach (var mappingSpan in e.Spans)
+            {
+                var normalizedSpan = mappingSpan.GetSpans(_textView.TextSnapshot);
+                builder.AddRange(normalizedSpan);
+            }
+
+            var changedSnapshotSpans = builder.ToImmutable();
+            if (changedSnapshotSpans.Length == 0)
+            {
+                return;
+            }
+
+            var startOfChangedSpan = changedSnapshotSpans.Min(span => span.Start);
+            var endOfChangedSpan = changedSnapshotSpans.Max(span => span.End);
+            var changedSpan = new SnapshotSpan(startOfChangedSpan, endOfChangedSpan);
+
+            _glyphManager.RemoveGlyphs(changedSpan);
+
+            foreach (var line in _textView.TextViewLines.GetTextViewLinesIntersectingSpan(changedSpan))
+            {
+                if (line.IsValid)
+                {
+                    RefreshGlyphsOver(line);
+                }
+            }
+        }
+
+        private void RefreshGlyphsOver(ITextViewLine textViewLine)
+        {
+            if (!_optionService.GetOption(FeatureOnOffOptions.InheritanceMarginCombinedWithIndicatorMargin))
+            {
+                foreach (var mappingTagSpan in _tagAggregator.GetTags(textViewLine.ExtentAsMappingSpan))
+                {
+                    // Only take tag spans with a visible start point and that map to something
+                    // in the edit buffer and *start* on this line
+                    if (mappingTagSpan.Span.Start.GetPoint(_textView.VisualSnapshot.TextBuffer, PositionAffinity.Predecessor) != null)
+                    {
+                        var tagSpans = mappingTagSpan.Span.GetSpans(_textView.TextSnapshot);
+                        if (tagSpans.Count > 0)
+                        {
+                            _glyphManager.AddGlyph(mappingTagSpan.Tag, tagSpans[0]);
+                        }
+                    }
+                }
+            }
+        }
+
+        private void ThrowIfDisposed()
+        {
+            if (_disposed)
+            {
+                throw new ObjectDisposedException(nameof(InheritanceMarginViewMargin));
+            }
+        }
+
+        FrameworkElement IWpfTextViewMargin.VisualElement
+        {
+            get
+            {
+                ThrowIfDisposed();
+                return _grid;
+            }
+        }
+
+        double ITextViewMargin.MarginSize
+        {
+            get
+            {
+                ThrowIfDisposed();
+                return _grid.ActualWidth;
+            }
+        }
+
+        bool ITextViewMargin.Enabled
+        {
+            get
+            {
+                ThrowIfDisposed();
+                return true;
+            }
+        }
+
+        ITextViewMargin? ITextViewMargin.GetTextViewMargin(string marginName)
+            => marginName == nameof(InheritanceMarginViewMargin) ? this : null;
+    }
+}
diff --git a/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/InheritanceMarginViewMarginProvider.cs b/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/InheritanceMarginViewMarginProvider.cs
new file mode 100644
index 0000000000000..268f69c6ea35b
--- /dev/null
+++ b/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/InheritanceMarginViewMarginProvider.cs
@@ -0,0 +1,89 @@
+// 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.ComponentModel.Composition;
+using Microsoft.CodeAnalysis.Editor;
+using Microsoft.CodeAnalysis.Editor.Host;
+using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
+using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.CodeAnalysis.Options;
+using Microsoft.CodeAnalysis.Shared.TestHooks;
+using Microsoft.CodeAnalysis.Text;
+using Microsoft.VisualStudio.Text.Classification;
+using Microsoft.VisualStudio.Text.Editor;
+using Microsoft.VisualStudio.Text.Tagging;
+using Microsoft.VisualStudio.Utilities;
+
+namespace Microsoft.VisualStudio.LanguageServices.Implementation.InheritanceMargin
+{
+    [Export(typeof(IWpfTextViewMarginProvider))]
+    [ContentType(ContentTypeNames.CSharpContentType)]
+    [ContentType(ContentTypeNames.VisualBasicContentType)]
+    [Name(nameof(InheritanceMarginViewMarginProvider))]
+    [MarginContainer(PredefinedMarginNames.Left)]
+    [Order(After = PredefinedMarginNames.Glyph)]
+    [TextViewRole(PredefinedTextViewRoles.Document)]
+    internal class InheritanceMarginViewMarginProvider : IWpfTextViewMarginProvider
+    {
+        private readonly IViewTagAggregatorFactoryService _tagAggregatorFactoryService;
+        private readonly IThreadingContext _threadingContext;
+        private readonly IStreamingFindUsagesPresenter _streamingFindUsagesPresenter;
+        private readonly IClassificationFormatMapService _classificationFormatMapService;
+        private readonly ClassificationTypeMap _classificationTypeMap;
+        private readonly IUIThreadOperationExecutor _operationExecutor;
+        private readonly IEditorFormatMapService _editorFormatMapService;
+        private readonly IAsynchronousOperationListenerProvider _listenerProvider;
+
+        [ImportingConstructor]
+        [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+        public InheritanceMarginViewMarginProvider(
+            IThreadingContext threadingContext,
+            IStreamingFindUsagesPresenter streamingFindUsagesPresenter,
+            ClassificationTypeMap classificationTypeMap,
+            IClassificationFormatMapService classificationFormatMapService,
+            IUIThreadOperationExecutor operationExecutor,
+            IViewTagAggregatorFactoryService tagAggregatorFactoryService,
+            IEditorFormatMapService editorFormatMapService,
+            IAsynchronousOperationListenerProvider listenerProvider)
+        {
+            _threadingContext = threadingContext;
+            _streamingFindUsagesPresenter = streamingFindUsagesPresenter;
+            _classificationTypeMap = classificationTypeMap;
+            _classificationFormatMapService = classificationFormatMapService;
+            _operationExecutor = operationExecutor;
+            _tagAggregatorFactoryService = tagAggregatorFactoryService;
+            _editorFormatMapService = editorFormatMapService;
+            _listenerProvider = listenerProvider;
+        }
+
+        public IWpfTextViewMargin? CreateMargin(IWpfTextViewHost wpfTextViewHost, IWpfTextViewMargin marginContainer)
+        {
+            var textView = wpfTextViewHost.TextView;
+            var tagAggregator = _tagAggregatorFactoryService.CreateTagAggregator<InheritanceMarginTag>(textView);
+            var editorFormatMap = _editorFormatMapService.GetEditorFormatMap(textView);
+
+            var document = wpfTextViewHost.TextView.TextBuffer.CurrentSnapshot.GetOpenDocumentInCurrentContextWithChanges();
+            if (document == null)
+            {
+                return null;
+            }
+
+            var optionService = document.Project.Solution.Workspace.Services.GetRequiredService<IOptionService>();
+            var listener = _listenerProvider.GetListener(FeatureAttribute.InheritanceMargin);
+            return new InheritanceMarginViewMargin(
+                textView,
+                _threadingContext,
+                _streamingFindUsagesPresenter,
+                _operationExecutor,
+                _classificationFormatMapService.GetClassificationFormatMap("tooltip"),
+                _classificationTypeMap,
+                tagAggregator,
+                editorFormatMap,
+                optionService,
+                listener,
+                document.Project.Language);
+        }
+    }
+}
diff --git a/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/HeaderMenuItemViewModel.cs b/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/HeaderMenuItemViewModel.cs
index ae8e6d1a71fd8..7b97f8e3bfffe 100644
--- a/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/HeaderMenuItemViewModel.cs
+++ b/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/HeaderMenuItemViewModel.cs
@@ -12,7 +12,7 @@ namespace Microsoft.VisualStudio.LanguageServices.Implementation.InheritanceMarg
     /// 'I↓ Implementing members'
     ///       Method 'Bar'
     /// </summary>
-    internal class HeaderMenuItemViewModel : InheritanceMenuItemViewModel
+    internal class HeaderMenuItemViewModel : MenuItemViewModel
     {
         public HeaderMenuItemViewModel(string displayContent, ImageMoniker imageMoniker, string automationName)
             : base(displayContent, imageMoniker, automationName)
diff --git a/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/InheritanceMargin.xaml b/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/InheritanceMarginGlyph.xaml
similarity index 99%
rename from src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/InheritanceMargin.xaml
rename to src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/InheritanceMarginGlyph.xaml
index a94eca369413a..5fe5f517c54f5 100644
--- a/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/InheritanceMargin.xaml
+++ b/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/InheritanceMarginGlyph.xaml
@@ -1,4 +1,4 @@
-<Button x:Class="Microsoft.VisualStudio.LanguageServices.Implementation.InheritanceMargin.MarginGlyph.InheritanceMargin"
+<Button x:Class="Microsoft.VisualStudio.LanguageServices.Implementation.InheritanceMargin.MarginGlyph.InheritanceMarginGlyph"
         x:ClassModifier="internal"
         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
diff --git a/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/InheritanceMargin.xaml.cs b/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/InheritanceMarginGlyph.xaml.cs
similarity index 96%
rename from src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/InheritanceMargin.xaml.cs
rename to src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/InheritanceMarginGlyph.xaml.cs
index fd22a9b565e0d..db3e61113a8d0 100644
--- a/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/InheritanceMargin.xaml.cs
+++ b/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/InheritanceMarginGlyph.xaml.cs
@@ -25,7 +25,7 @@
 
 namespace Microsoft.VisualStudio.LanguageServices.Implementation.InheritanceMargin.MarginGlyph
 {
-    internal partial class InheritanceMargin
+    internal partial class InheritanceMarginGlyph
     {
         private readonly IThreadingContext _threadingContext;
         private readonly IStreamingFindUsagesPresenter _streamingFindUsagesPresenter;
@@ -34,7 +34,7 @@ internal partial class InheritanceMargin
         private readonly IWpfTextView _textView;
         private readonly IAsynchronousOperationListener _listener;
 
-        public InheritanceMargin(
+        public InheritanceMarginGlyph(
             IThreadingContext threadingContext,
             IStreamingFindUsagesPresenter streamingFindUsagesPresenter,
             ClassificationTypeMap classificationTypeMap,
@@ -52,7 +52,7 @@ public InheritanceMargin(
             _listener = listener;
             InitializeComponent();
 
-            var viewModel = InheritanceMarginViewModel.Create(classificationTypeMap, classificationFormatMap, tag, textView.ZoomLevel);
+            var viewModel = InheritanceMarginGlyphViewModel.Create(classificationTypeMap, classificationFormatMap, tag, textView.ZoomLevel);
             DataContext = viewModel;
             ContextMenu.DataContext = viewModel;
             ToolTip = new ToolTip { Content = viewModel.ToolTipTextBlock, Style = (Style)FindResource("ToolTipStyle") };
@@ -134,7 +134,7 @@ private void ContextMenu_OnClose(object sender, RoutedEventArgs e)
 
         private void ContextMenu_OnOpen(object sender, RoutedEventArgs e)
         {
-            if (e.OriginalSource is ContextMenu { DataContext: InheritanceMarginViewModel inheritanceMarginViewModel }
+            if (e.OriginalSource is ContextMenu { DataContext: InheritanceMarginGlyphViewModel inheritanceMarginViewModel }
                 && inheritanceMarginViewModel.MenuItemViewModels.Any(vm => vm is TargetMenuItemViewModel))
             {
                 // We have two kinds of context menu. e.g.
diff --git a/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/InheritanceMarginViewModel.cs b/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/InheritanceMarginGlyphViewModel.cs
similarity index 87%
rename from src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/InheritanceMarginViewModel.cs
rename to src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/InheritanceMarginGlyphViewModel.cs
index 6616e87e1cc81..2490e009231bf 100644
--- a/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/InheritanceMarginViewModel.cs
+++ b/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/InheritanceMarginGlyphViewModel.cs
@@ -15,7 +15,7 @@
 
 namespace Microsoft.VisualStudio.LanguageServices.Implementation.InheritanceMargin.MarginGlyph
 {
-    internal class InheritanceMarginViewModel
+    internal class InheritanceMarginGlyphViewModel
     {
         /// <summary>
         /// ImageMoniker used for the margin.
@@ -35,7 +35,7 @@ internal class InheritanceMarginViewModel
         /// <summary>
         /// ViewModels for the context menu items.
         /// </summary>
-        public ImmutableArray<InheritanceMenuItemViewModel> MenuItemViewModels { get; }
+        public ImmutableArray<MenuItemViewModel> MenuItemViewModels { get; }
 
         /// <summary>
         /// Scale factor for the margin.
@@ -43,12 +43,12 @@ internal class InheritanceMarginViewModel
         public double ScaleFactor { get; }
 
         // Internal for testing purpose
-        internal InheritanceMarginViewModel(
+        internal InheritanceMarginGlyphViewModel(
             ImageMoniker imageMoniker,
             TextBlock toolTipTextBlock,
             string automationName,
             double scaleFactor,
-            ImmutableArray<InheritanceMenuItemViewModel> menuItemViewModels)
+            ImmutableArray<MenuItemViewModel> menuItemViewModels)
         {
             ImageMoniker = imageMoniker;
             ToolTipTextBlock = toolTipTextBlock;
@@ -57,7 +57,7 @@ internal InheritanceMarginViewModel(
             ScaleFactor = scaleFactor;
         }
 
-        public static InheritanceMarginViewModel Create(
+        public static InheritanceMarginGlyphViewModel Create(
             ClassificationTypeMap classificationTypeMap,
             IClassificationFormatMap classificationFormatMap,
             InheritanceMarginTag tag,
@@ -86,7 +86,7 @@ public static InheritanceMarginViewModel Create(
 
                 var automationName = string.Format(ServicesVSResources._0_is_inherited, member.DisplayTexts.JoinText());
                 var menuItemViewModels = InheritanceMarginHelpers.CreateMenuItemViewModelsForSingleMember(member.TargetItems);
-                return new InheritanceMarginViewModel(tag.Moniker, toolTipTextBlock, automationName, scaleFactor, menuItemViewModels);
+                return new InheritanceMarginGlyphViewModel(tag.Moniker, toolTipTextBlock, automationName, scaleFactor, menuItemViewModels);
             }
             else
             {
@@ -98,7 +98,7 @@ public static InheritanceMarginViewModel Create(
                 // Same automation name can't be set for control for accessibility purpose. So add the line number info.
                 var automationName = string.Format(ServicesVSResources.Multiple_members_are_inherited_on_line_0, tag.LineNumber);
                 var menuItemViewModels = InheritanceMarginHelpers.CreateMenuItemViewModelsForMultipleMembers(tag.MembersOnLine);
-                return new InheritanceMarginViewModel(tag.Moniker, textBlock, automationName, scaleFactor, menuItemViewModels);
+                return new InheritanceMarginGlyphViewModel(tag.Moniker, textBlock, automationName, scaleFactor, menuItemViewModels);
             }
         }
     }
diff --git a/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/MemberMenuItemViewModel.cs b/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/MemberMenuItemViewModel.cs
index 49186e2bb773f..3c040ace50f64 100644
--- a/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/MemberMenuItemViewModel.cs
+++ b/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/MemberMenuItemViewModel.cs
@@ -25,18 +25,18 @@ namespace Microsoft.VisualStudio.LanguageServices.Implementation.InheritanceMarg
     /// }
     /// And this view model is used to show the first level entry to let the user choose member.
     /// </summary>
-    internal class MemberMenuItemViewModel : InheritanceMenuItemViewModel
+    internal class MemberMenuItemViewModel : MenuItemViewModel
     {
         /// <summary>
         /// Inheritance Targets for this member.
         /// </summary>
-        public ImmutableArray<InheritanceMenuItemViewModel> Targets { get; }
+        public ImmutableArray<MenuItemViewModel> Targets { get; }
 
         public MemberMenuItemViewModel(
             string displayContent,
             ImageMoniker imageMoniker,
             string automationName,
-            ImmutableArray<InheritanceMenuItemViewModel> targets) : base(displayContent, imageMoniker, automationName)
+            ImmutableArray<MenuItemViewModel> targets) : base(displayContent, imageMoniker, automationName)
         {
             Targets = targets;
         }
diff --git a/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/InheritanceContextMenuItemViewModel.cs b/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/MenuItemViewModel.cs
similarity index 83%
rename from src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/InheritanceContextMenuItemViewModel.cs
rename to src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/MenuItemViewModel.cs
index a6b9f5e179d4c..32498ed0bf137 100644
--- a/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/InheritanceContextMenuItemViewModel.cs
+++ b/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/MenuItemViewModel.cs
@@ -6,7 +6,7 @@
 
 namespace Microsoft.VisualStudio.LanguageServices.Implementation.InheritanceMargin.MarginGlyph
 {
-    internal abstract class InheritanceMenuItemViewModel
+    internal abstract class MenuItemViewModel
     {
         /// <summary>
         /// Display content for the target.
@@ -23,7 +23,7 @@ internal abstract class InheritanceMenuItemViewModel
         /// </summary>
         public string AutomationName { get; }
 
-        protected InheritanceMenuItemViewModel(string displayContent, ImageMoniker imageMoniker, string automationName)
+        protected MenuItemViewModel(string displayContent, ImageMoniker imageMoniker, string automationName)
         {
             ImageMoniker = imageMoniker;
             DisplayContent = displayContent;
diff --git a/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/TargetMenuItemViewModel.cs b/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/TargetMenuItemViewModel.cs
index 7cc30d6392bed..7d7816a3f2701 100644
--- a/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/TargetMenuItemViewModel.cs
+++ b/src/VisualStudio/Core/Def/Implementation/InheritanceMargin/MarginGlyph/TargetMenuItemViewModel.cs
@@ -12,7 +12,7 @@ namespace Microsoft.VisualStudio.LanguageServices.Implementation.InheritanceMarg
     /// <summary>
     /// View model used to show the MenuItem for inheritance target.
     /// </summary>
-    internal class TargetMenuItemViewModel : InheritanceMenuItemViewModel
+    internal class TargetMenuItemViewModel : MenuItemViewModel
     {
         /// <summary>
         /// DefinitionItem used for navigation.
diff --git a/src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractCreateServicesOnTextViewConnection.cs b/src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractCreateServicesOnTextViewConnection.cs
index eb20f478b451b..d04cbe4013da0 100644
--- a/src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractCreateServicesOnTextViewConnection.cs
+++ b/src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractCreateServicesOnTextViewConnection.cs
@@ -4,6 +4,7 @@
 
 using System.Collections.ObjectModel;
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Completion;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
 using Microsoft.CodeAnalysis.Host;
@@ -22,22 +23,34 @@ namespace Microsoft.VisualStudio.LanguageServices.Implementation.LanguageService
     /// </summary>
     internal abstract class AbstractCreateServicesOnTextViewConnection : IWpfTextViewConnectionListener
     {
-        private readonly VisualStudioWorkspace _workspace;
         private readonly IAsynchronousOperationListener _listener;
         private readonly IThreadingContext _threadingContext;
         private readonly string _languageName;
         private bool _initialized = false;
 
+        protected VisualStudioWorkspace Workspace { get; }
+
+        protected virtual Task InitializeServiceForOpenedDocumentAsync(Document document)
+            => Task.CompletedTask;
+
+        protected virtual void OnSolutionRemoved()
+        {
+            return;
+        }
+
         public AbstractCreateServicesOnTextViewConnection(
             VisualStudioWorkspace workspace,
             IAsynchronousOperationListenerProvider listenerProvider,
             IThreadingContext threadingContext,
             string languageName)
         {
-            _workspace = workspace;
+            Workspace = workspace;
             _listener = listenerProvider.GetListener(FeatureAttribute.Workspace);
             _threadingContext = threadingContext;
             _languageName = languageName;
+
+            Workspace.DocumentOpened += InitializeServiceOnDocumentOpened;
+            Workspace.WorkspaceChanged += OnWorkspaceChanged;
         }
 
         void IWpfTextViewConnectionListener.SubjectBuffersConnected(IWpfTextView textView, ConnectionReason reason, Collection<ITextBuffer> subjectBuffers)
@@ -55,11 +68,36 @@ void IWpfTextViewConnectionListener.SubjectBuffersDisconnected(IWpfTextView text
         {
         }
 
+        private void OnWorkspaceChanged(object sender, WorkspaceChangeEventArgs e)
+        {
+            if (e.Kind == WorkspaceChangeKind.SolutionRemoved)
+            {
+                OnSolutionRemoved();
+            }
+        }
+
+        private void InitializeServiceOnDocumentOpened(object sender, DocumentEventArgs e)
+        {
+            if (e.Document.Project.Language != _languageName)
+            {
+                return;
+            }
+
+            var token = _listener.BeginAsyncOperation(nameof(InitializeServiceForOpenedDocumentOnBackgroundAsync));
+            InitializeServiceForOpenedDocumentOnBackgroundAsync(e.Document).CompletesAsyncOperation(token);
+
+            async Task InitializeServiceForOpenedDocumentOnBackgroundAsync(Document document)
+            {
+                await TaskScheduler.Default;
+                await InitializeServiceForOpenedDocumentAsync(document).ConfigureAwait(false);
+            }
+        }
+
         private async Task InitializeServicesAsync()
         {
             await TaskScheduler.Default;
 
-            var languageServices = _workspace.Services.GetExtendedLanguageServices(_languageName);
+            var languageServices = Workspace.Services.GetExtendedLanguageServices(_languageName);
 
             _ = languageServices.GetService<ISnippetInfoService>();
 
diff --git a/src/VisualStudio/Core/Def/Implementation/Library/AbstractObjectList.cs b/src/VisualStudio/Core/Def/Implementation/Library/AbstractObjectList.cs
index d98bb4371a8b6..bd6e49a3fbdf5 100644
--- a/src/VisualStudio/Core/Def/Implementation/Library/AbstractObjectList.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Library/AbstractObjectList.cs
@@ -6,6 +6,7 @@
 
 using System;
 using System.Runtime.InteropServices;
+using System.Threading.Tasks;
 using Microsoft.VisualStudio.OLE.Interop;
 using Microsoft.VisualStudio.Shell.Interop;
 
@@ -27,7 +28,7 @@ protected AbstractObjectList(TLibraryManager libraryManager)
         protected abstract IVsSimpleObjectList2 GetList(uint index, uint listType, uint flags, VSOBSEARCHCRITERIA2[] pobSrch);
         protected abstract string GetText(uint index, VSTREETEXTOPTIONS tto);
         protected abstract string GetTipText(uint index, VSTREETOOLTIPTYPE eTipType);
-        protected abstract int GoToSource(uint index, VSOBJGOTOSRCTYPE srcType);
+        protected abstract Task GoToSourceAsync(uint index, VSOBJGOTOSRCTYPE srcType);
         protected abstract uint GetUpdateCounter();
 
         protected virtual bool SupportsBrowseContainers
@@ -311,11 +312,11 @@ int IVsSimpleObjectList2.GetUserContext(uint index, out object ppunkUserCtx)
         int IVsSimpleObjectList2.GoToSource(uint index, VSOBJGOTOSRCTYPE srcType)
         {
             if (index >= GetItemCount())
-            {
                 return VSConstants.E_INVALIDARG;
-            }
 
-            return GoToSource(index, srcType);
+            // Fire and forget
+            _ = GoToSourceAsync(index, srcType);
+            return VSConstants.S_OK;
         }
 
         int IVsSimpleObjectList2.LocateNavInfoNode(IVsNavInfoNode pNavInfoNode, out uint pulIndex)
diff --git a/src/VisualStudio/Core/Def/Implementation/Library/ObjectBrowser/AbstractObjectBrowserLibraryManager.cs b/src/VisualStudio/Core/Def/Implementation/Library/ObjectBrowser/AbstractObjectBrowserLibraryManager.cs
index 5bca469a14289..6f51d8148d9a2 100644
--- a/src/VisualStudio/Core/Def/Implementation/Library/ObjectBrowser/AbstractObjectBrowserLibraryManager.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Library/ObjectBrowser/AbstractObjectBrowserLibraryManager.cs
@@ -13,11 +13,13 @@
 using Microsoft.CodeAnalysis.Editor.FindUsages;
 using Microsoft.CodeAnalysis.Editor.Host;
 using Microsoft.CodeAnalysis.ErrorReporting;
+using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.VisualStudio.ComponentModelHost;
 using Microsoft.VisualStudio.LanguageServices.Implementation.Library.ObjectBrowser.Lists;
 using Microsoft.VisualStudio.OLE.Interop;
 using Microsoft.VisualStudio.Shell;
 using Microsoft.VisualStudio.Shell.Interop;
+using Microsoft.VisualStudio.Utilities;
 using IServiceProvider = System.IServiceProvider;
 using Task = System.Threading.Tasks.Task;
 
@@ -42,6 +44,9 @@ internal abstract partial class AbstractObjectBrowserLibraryManager : AbstractLi
 
         private readonly IStreamingFindUsagesPresenter _streamingPresenter;
 
+        public readonly IUIThreadOperationExecutor OperationExecutor;
+        public readonly IAsynchronousOperationListener AsynchronousOperationListener;
+
         protected AbstractObjectBrowserLibraryManager(
             string languageName,
             Guid libraryGuid,
@@ -57,6 +62,9 @@ protected AbstractObjectBrowserLibraryManager(
 
             _libraryService = new Lazy<ILibraryService>(() => Workspace.Services.GetLanguageServices(_languageName).GetService<ILibraryService>());
             _streamingPresenter = componentModel.DefaultExportProvider.GetExportedValue<IStreamingFindUsagesPresenter>();
+
+            OperationExecutor = componentModel.DefaultExportProvider.GetExportedValue<IUIThreadOperationExecutor>();
+            AsynchronousOperationListener = componentModel.DefaultExportProvider.GetExportedValue<IAsynchronousOperationListenerProvider>().GetListener(FeatureAttribute.LibraryManager);
         }
 
         internal abstract AbstractDescriptionBuilder CreateDescriptionBuilder(
diff --git a/src/VisualStudio/Core/Def/Implementation/Library/ObjectBrowser/ObjectList.cs b/src/VisualStudio/Core/Def/Implementation/Library/ObjectBrowser/ObjectList.cs
index e6bfa36009792..5701a5212ab15 100644
--- a/src/VisualStudio/Core/Def/Implementation/Library/ObjectBrowser/ObjectList.cs
+++ b/src/VisualStudio/Core/Def/Implementation/Library/ObjectBrowser/ObjectList.cs
@@ -8,12 +8,18 @@
 using System.Collections.Immutable;
 using System.Diagnostics;
 using System.Threading;
+using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Editor;
+using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
+using Microsoft.CodeAnalysis.ErrorReporting;
+using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.VisualStudio.LanguageServices.Implementation.F1Help;
 using Microsoft.VisualStudio.LanguageServices.Implementation.Library.ObjectBrowser.Lists;
 using Microsoft.VisualStudio.LanguageServices.Implementation.Library.VsNavInfo;
 using Microsoft.VisualStudio.Shell;
 using Microsoft.VisualStudio.Shell.Interop;
+using Microsoft.VisualStudio.Utilities;
 using Roslyn.Utilities;
 
 namespace Microsoft.VisualStudio.LanguageServices.Implementation.Library.ObjectBrowser
@@ -737,28 +743,31 @@ protected override string GetText(uint index, VSTREETEXTOPTIONS tto)
         protected override string GetTipText(uint index, VSTREETOOLTIPTYPE eTipType)
             => null;
 
-        protected override int GoToSource(uint index, VSOBJGOTOSRCTYPE srcType)
+        protected override async Task GoToSourceAsync(uint index, VSOBJGOTOSRCTYPE srcType)
         {
-            if (srcType == VSOBJGOTOSRCTYPE.GS_DEFINITION)
+            try
             {
-                if (GetListItem(index) is SymbolListItem symbolItem && symbolItem.SupportsGoToDefinition)
+                using var token = _manager.AsynchronousOperationListener.BeginAsyncOperation(nameof(GoToSourceAsync));
+                using var context = _manager.OperationExecutor.BeginExecute(ServicesVSResources.IntelliSense, EditorFeaturesResources.Navigating, allowCancellation: true, showProgress: false);
+
+                var cancellationToken = context.UserCancellationToken;
+                if (srcType == VSOBJGOTOSRCTYPE.GS_DEFINITION &&
+                    GetListItem(index) is SymbolListItem symbolItem &&
+                    symbolItem.SupportsGoToDefinition)
                 {
                     var project = this.LibraryManager.Workspace.CurrentSolution.GetProject(symbolItem.ProjectId);
-                    var compilation = project.GetCompilationAsync(CancellationToken.None).WaitAndGetResult(CancellationToken.None);
+                    var compilation = await project.GetCompilationAsync(cancellationToken).ConfigureAwait(false);
                     var symbol = symbolItem.ResolveSymbol(compilation);
 
-                    if (this.LibraryManager.Workspace.TryGoToDefinition(symbol, project, CancellationToken.None))
-                    {
-                        return VSConstants.S_OK;
-                    }
-                    else
-                    {
-                        return VSConstants.S_FALSE;
-                    }
+                    await this.LibraryManager.Workspace.TryGoToDefinitionAsync(symbol, project, cancellationToken).ConfigureAwait(false);
                 }
             }
-
-            return VSConstants.E_FAIL;
+            catch (OperationCanceledException)
+            {
+            }
+            catch (Exception ex) when (FatalError.ReportAndCatch(ex))
+            {
+            }
         }
 
         protected override uint GetUpdateCounter()
diff --git a/src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioWorkspace.cs b/src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioWorkspace.cs
index 27e9ce87328b2..390fe7b8ac861 100644
--- a/src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioWorkspace.cs
+++ b/src/VisualStudio/Core/Def/Implementation/ProjectSystem/VisualStudioWorkspace.cs
@@ -5,6 +5,7 @@
 using System;
 using System.Collections.Generic;
 using System.Threading;
+using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.ErrorReporting;
 using Microsoft.CodeAnalysis.FindSymbols;
@@ -97,7 +98,10 @@ protected override void OnDocumentClosing(DocumentId documentId)
 
         internal abstract object? GetBrowseObject(SymbolListItem symbolListItem);
 
+        [Obsolete("Use TryGoToDefinitionAsync instead", error: false)]
         public abstract bool TryGoToDefinition(ISymbol symbol, Project project, CancellationToken cancellationToken);
+        public abstract Task<bool> TryGoToDefinitionAsync(ISymbol symbol, Project project, CancellationToken cancellationToken);
+
         public abstract bool TryFindAllReferences(ISymbol symbol, Project project, CancellationToken cancellationToken);
 
         public abstract void DisplayReferencedSymbols(Solution solution, IEnumerable<ReferencedSymbol> referencedSymbols);
diff --git a/src/VisualStudio/Core/Def/Microsoft.VisualStudio.LanguageServices.csproj b/src/VisualStudio/Core/Def/Microsoft.VisualStudio.LanguageServices.csproj
index 12568fe9f103e..77fef56f1d2c9 100644
--- a/src/VisualStudio/Core/Def/Microsoft.VisualStudio.LanguageServices.csproj
+++ b/src/VisualStudio/Core/Def/Microsoft.VisualStudio.LanguageServices.csproj
@@ -188,8 +188,8 @@
       <PkgDefBrokeredService Include="@(ServiceHubService->'%(Identity)64S')" Condition="'%(ServiceHubService.IsBrokered)' == 'true'" />
       
       <!-- Add registrations for 64-bit and 64-bit Server GC on .Net Core host -->
-      <PkgDefBrokeredService Include="@(ServiceHubService->'%(Identity)Core64')" Condition="'%(ServiceHubService.IsBrokered)' == 'true'" SubFolder="$(ServiceHubCoreSubPath)"/>
-      <PkgDefBrokeredService Include="@(ServiceHubService->'%(Identity)Core64S')" Condition="'%(ServiceHubService.IsBrokered)' == 'true'" SubFolder="$(ServiceHubCoreSubPath)"/>
+      <PkgDefBrokeredService Include="@(ServiceHubService->'%(Identity)Core64')" Condition="'%(ServiceHubService.IsBrokered)' == 'true'" SubFolder="$(ServiceHubCoreSubPath)" />
+      <PkgDefBrokeredService Include="@(ServiceHubService->'%(Identity)Core64S')" Condition="'%(ServiceHubService.IsBrokered)' == 'true'" SubFolder="$(ServiceHubCoreSubPath)" />
 
       <PkgDefBrokeredService Include="@(InProcService)" ProfferingPackageId="$(RoslynPackageGuid)" />
     </ItemGroup>
diff --git a/src/VisualStudio/Core/Def/PublicAPI.Unshipped.txt b/src/VisualStudio/Core/Def/PublicAPI.Unshipped.txt
index 8b137891791fe..7111c2ce6f7ca 100644
--- a/src/VisualStudio/Core/Def/PublicAPI.Unshipped.txt
+++ b/src/VisualStudio/Core/Def/PublicAPI.Unshipped.txt
@@ -1 +1 @@
-
+abstract Microsoft.VisualStudio.LanguageServices.VisualStudioWorkspace.TryGoToDefinitionAsync(Microsoft.CodeAnalysis.ISymbol symbol, Microsoft.CodeAnalysis.Project project, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task<bool>
diff --git a/src/VisualStudio/Core/Def/ServicesVSResources.resx b/src/VisualStudio/Core/Def/ServicesVSResources.resx
index 9e1530329a0ea..c80424540e626 100644
--- a/src/VisualStudio/Core/Def/ServicesVSResources.resx
+++ b/src/VisualStudio/Core/Def/ServicesVSResources.resx
@@ -1797,6 +1797,9 @@ Additional information: {1}</value>
     <value>{0} failed to initialize. Status = {1}. Exception = {2}</value>
     <comment>{0} is the language server name.  Status is the status of the initialization.  Exception is the exception encountered during initialization.</comment>
   </data>
+  <data name="Combine_inheritance_margin_with_indicator_margin" xml:space="preserve">
+    <value>Combine inheritance margin with indicator margin</value>
+  </data>
   <data name="Package_install_canceled" xml:space="preserve">
     <value>Package install canceled</value>
   </data>
diff --git a/src/VisualStudio/Core/Def/xlf/Commands.vsct.cs.xlf b/src/VisualStudio/Core/Def/xlf/Commands.vsct.cs.xlf
index 42887521e967e..9e5caa3605e6d 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.cs.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.cs.xlf
@@ -288,7 +288,7 @@
         <note />
       </trans-unit>
       <trans-unit id="cmdidRemoveUnusedReferences|ButtonText">
-        <source>Remove &amp;Unused References...</source>
+        <source>Remove Unused References...</source>
         <target state="translated">Odebrat nepo&amp;užívané odkazy...</target>
         <note />
       </trans-unit>
diff --git a/src/VisualStudio/Core/Def/xlf/Commands.vsct.de.xlf b/src/VisualStudio/Core/Def/xlf/Commands.vsct.de.xlf
index 9cd3ed638682c..8c51ab9a6a898 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.de.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.de.xlf
@@ -288,7 +288,7 @@
         <note />
       </trans-unit>
       <trans-unit id="cmdidRemoveUnusedReferences|ButtonText">
-        <source>Remove &amp;Unused References...</source>
+        <source>Remove Unused References...</source>
         <target state="translated">&amp;Nicht verwendete Verweise entfernen...</target>
         <note />
       </trans-unit>
diff --git a/src/VisualStudio/Core/Def/xlf/Commands.vsct.es.xlf b/src/VisualStudio/Core/Def/xlf/Commands.vsct.es.xlf
index 9e24b2fe843c1..0bd0d6231ec55 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.es.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.es.xlf
@@ -288,7 +288,7 @@
         <note />
       </trans-unit>
       <trans-unit id="cmdidRemoveUnusedReferences|ButtonText">
-        <source>Remove &amp;Unused References...</source>
+        <source>Remove Unused References...</source>
         <target state="translated">&amp;Quitar referencias sin usar...</target>
         <note />
       </trans-unit>
diff --git a/src/VisualStudio/Core/Def/xlf/Commands.vsct.fr.xlf b/src/VisualStudio/Core/Def/xlf/Commands.vsct.fr.xlf
index 99544f7eb201a..092a78a78349d 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.fr.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.fr.xlf
@@ -288,7 +288,7 @@
         <note />
       </trans-unit>
       <trans-unit id="cmdidRemoveUnusedReferences|ButtonText">
-        <source>Remove &amp;Unused References...</source>
+        <source>Remove Unused References...</source>
         <target state="translated">&amp;Supprimer les références inutilisées...</target>
         <note />
       </trans-unit>
diff --git a/src/VisualStudio/Core/Def/xlf/Commands.vsct.it.xlf b/src/VisualStudio/Core/Def/xlf/Commands.vsct.it.xlf
index ddf67c5497611..20767db7a15a3 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.it.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.it.xlf
@@ -288,7 +288,7 @@
         <note />
       </trans-unit>
       <trans-unit id="cmdidRemoveUnusedReferences|ButtonText">
-        <source>Remove &amp;Unused References...</source>
+        <source>Remove Unused References...</source>
         <target state="translated">Rim&amp;uovi riferimenti inutilizzati...</target>
         <note />
       </trans-unit>
diff --git a/src/VisualStudio/Core/Def/xlf/Commands.vsct.ja.xlf b/src/VisualStudio/Core/Def/xlf/Commands.vsct.ja.xlf
index 0dd655db5e123..6596eb6443cbf 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.ja.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.ja.xlf
@@ -288,7 +288,7 @@
         <note />
       </trans-unit>
       <trans-unit id="cmdidRemoveUnusedReferences|ButtonText">
-        <source>Remove &amp;Unused References...</source>
+        <source>Remove Unused References...</source>
         <target state="translated">未使用の参照を削除する(&amp;U)...</target>
         <note />
       </trans-unit>
diff --git a/src/VisualStudio/Core/Def/xlf/Commands.vsct.ko.xlf b/src/VisualStudio/Core/Def/xlf/Commands.vsct.ko.xlf
index 1e10704c2d94b..d59cfe5a63031 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.ko.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.ko.xlf
@@ -288,7 +288,7 @@
         <note />
       </trans-unit>
       <trans-unit id="cmdidRemoveUnusedReferences|ButtonText">
-        <source>Remove &amp;Unused References...</source>
+        <source>Remove Unused References...</source>
         <target state="translated">사용하지 않는 참조 제거(&amp;U)...</target>
         <note />
       </trans-unit>
diff --git a/src/VisualStudio/Core/Def/xlf/Commands.vsct.pl.xlf b/src/VisualStudio/Core/Def/xlf/Commands.vsct.pl.xlf
index 01209cd60cb93..2c0e97ad3add6 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.pl.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.pl.xlf
@@ -288,7 +288,7 @@
         <note />
       </trans-unit>
       <trans-unit id="cmdidRemoveUnusedReferences|ButtonText">
-        <source>Remove &amp;Unused References...</source>
+        <source>Remove Unused References...</source>
         <target state="translated">&amp;Usuń nieużywane odwołania...</target>
         <note />
       </trans-unit>
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 ba3cdff6b66f2..d5664d118bf91 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.pt-BR.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.pt-BR.xlf
@@ -288,7 +288,7 @@
         <note />
       </trans-unit>
       <trans-unit id="cmdidRemoveUnusedReferences|ButtonText">
-        <source>Remove &amp;Unused References...</source>
+        <source>Remove Unused References...</source>
         <target state="translated">Remover as Referências Não &amp;Usadas...</target>
         <note />
       </trans-unit>
diff --git a/src/VisualStudio/Core/Def/xlf/Commands.vsct.ru.xlf b/src/VisualStudio/Core/Def/xlf/Commands.vsct.ru.xlf
index a5ee7ea9451ba..c4f028f9e0dad 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.ru.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.ru.xlf
@@ -288,7 +288,7 @@
         <note />
       </trans-unit>
       <trans-unit id="cmdidRemoveUnusedReferences|ButtonText">
-        <source>Remove &amp;Unused References...</source>
+        <source>Remove Unused References...</source>
         <target state="translated">&amp;Удалить неиспользуемые ссылки…</target>
         <note />
       </trans-unit>
diff --git a/src/VisualStudio/Core/Def/xlf/Commands.vsct.tr.xlf b/src/VisualStudio/Core/Def/xlf/Commands.vsct.tr.xlf
index 55ecc017aafa4..66e95695d92b1 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.tr.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.tr.xlf
@@ -288,7 +288,7 @@
         <note />
       </trans-unit>
       <trans-unit id="cmdidRemoveUnusedReferences|ButtonText">
-        <source>Remove &amp;Unused References...</source>
+        <source>Remove Unused References...</source>
         <target state="translated">&amp;Kullanılmayan Başvuruları Kaldır...</target>
         <note />
       </trans-unit>
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 7801aae6d4063..7a4cc77ebe18b 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.zh-Hans.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.zh-Hans.xlf
@@ -288,7 +288,7 @@
         <note />
       </trans-unit>
       <trans-unit id="cmdidRemoveUnusedReferences|ButtonText">
-        <source>Remove &amp;Unused References...</source>
+        <source>Remove Unused References...</source>
         <target state="translated">删除未使用的引用(&amp;U)…</target>
         <note />
       </trans-unit>
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 ad7319b6afca0..b4890f42b130d 100644
--- a/src/VisualStudio/Core/Def/xlf/Commands.vsct.zh-Hant.xlf
+++ b/src/VisualStudio/Core/Def/xlf/Commands.vsct.zh-Hant.xlf
@@ -288,7 +288,7 @@
         <note />
       </trans-unit>
       <trans-unit id="cmdidRemoveUnusedReferences|ButtonText">
-        <source>Remove &amp;Unused References...</source>
+        <source>Remove Unused References...</source>
         <target state="translated">移除未使用的參考(&amp;U)...</target>
         <note />
       </trans-unit>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.cs.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.cs.xlf
index 15cf87fbdd98f..265f7aeb0f601 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.cs.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.cs.xlf
@@ -222,6 +222,11 @@
         <target state="translated">Obarvit regulární výrazy</target>
         <note />
       </trans-unit>
+      <trans-unit id="Combine_inheritance_margin_with_indicator_margin">
+        <source>Combine inheritance margin with indicator margin</source>
+        <target state="new">Combine inheritance margin with indicator margin</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Comments">
         <source>Comments</source>
         <target state="translated">Komentáře</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.de.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.de.xlf
index 339ddd938b02c..c9955e9b56f14 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.de.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.de.xlf
@@ -222,6 +222,11 @@
         <target state="translated">Reguläre Ausdrücke farbig hervorheben</target>
         <note />
       </trans-unit>
+      <trans-unit id="Combine_inheritance_margin_with_indicator_margin">
+        <source>Combine inheritance margin with indicator margin</source>
+        <target state="new">Combine inheritance margin with indicator margin</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Comments">
         <source>Comments</source>
         <target state="translated">Kommentare</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.es.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.es.xlf
index d23d545d0d4a3..7d2a30724b80d 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.es.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.es.xlf
@@ -222,6 +222,11 @@
         <target state="translated">Colorear expresiones regulares</target>
         <note />
       </trans-unit>
+      <trans-unit id="Combine_inheritance_margin_with_indicator_margin">
+        <source>Combine inheritance margin with indicator margin</source>
+        <target state="new">Combine inheritance margin with indicator margin</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Comments">
         <source>Comments</source>
         <target state="translated">Comentarios</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.fr.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.fr.xlf
index 1002a45a06fdf..8a0a1d68bc1a7 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.fr.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.fr.xlf
@@ -222,6 +222,11 @@
         <target state="translated">Coloriser les expressions régulières</target>
         <note />
       </trans-unit>
+      <trans-unit id="Combine_inheritance_margin_with_indicator_margin">
+        <source>Combine inheritance margin with indicator margin</source>
+        <target state="new">Combine inheritance margin with indicator margin</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Comments">
         <source>Comments</source>
         <target state="translated">Commentaires</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.it.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.it.xlf
index 5eef932e1fac6..586cf5a1bb810 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.it.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.it.xlf
@@ -222,6 +222,11 @@
         <target state="translated">Colora espressioni regolari</target>
         <note />
       </trans-unit>
+      <trans-unit id="Combine_inheritance_margin_with_indicator_margin">
+        <source>Combine inheritance margin with indicator margin</source>
+        <target state="new">Combine inheritance margin with indicator margin</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Comments">
         <source>Comments</source>
         <target state="translated">Commenti</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ja.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ja.xlf
index 81e62a7221b3d..7ca4c87e7c352 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ja.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ja.xlf
@@ -222,6 +222,11 @@
         <target state="translated">正規表現をカラー化</target>
         <note />
       </trans-unit>
+      <trans-unit id="Combine_inheritance_margin_with_indicator_margin">
+        <source>Combine inheritance margin with indicator margin</source>
+        <target state="new">Combine inheritance margin with indicator margin</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Comments">
         <source>Comments</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 82bb908c4bff8..59c3785342a3d 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ko.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ko.xlf
@@ -222,6 +222,11 @@
         <target state="translated">정규식 색 지정</target>
         <note />
       </trans-unit>
+      <trans-unit id="Combine_inheritance_margin_with_indicator_margin">
+        <source>Combine inheritance margin with indicator margin</source>
+        <target state="new">Combine inheritance margin with indicator margin</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Comments">
         <source>Comments</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 8557c16533424..83aea3c5205b8 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pl.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pl.xlf
@@ -222,6 +222,11 @@
         <target state="translated">Koloruj wyrażenia regularne</target>
         <note />
       </trans-unit>
+      <trans-unit id="Combine_inheritance_margin_with_indicator_margin">
+        <source>Combine inheritance margin with indicator margin</source>
+        <target state="new">Combine inheritance margin with indicator margin</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Comments">
         <source>Comments</source>
         <target state="translated">Komentarze</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pt-BR.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pt-BR.xlf
index 8e94131517557..f2a7bea7fca01 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pt-BR.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.pt-BR.xlf
@@ -222,6 +222,11 @@
         <target state="translated">Colorir expressões regulares</target>
         <note />
       </trans-unit>
+      <trans-unit id="Combine_inheritance_margin_with_indicator_margin">
+        <source>Combine inheritance margin with indicator margin</source>
+        <target state="new">Combine inheritance margin with indicator margin</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Comments">
         <source>Comments</source>
         <target state="translated">Comentários</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ru.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ru.xlf
index 3dce8e7f35540..b1cab18950a53 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ru.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.ru.xlf
@@ -222,6 +222,11 @@
         <target state="translated">Выделить регулярные выражения цветом</target>
         <note />
       </trans-unit>
+      <trans-unit id="Combine_inheritance_margin_with_indicator_margin">
+        <source>Combine inheritance margin with indicator margin</source>
+        <target state="new">Combine inheritance margin with indicator margin</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Comments">
         <source>Comments</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 803c171a3e777..bb6e0a5a45f4d 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.tr.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.tr.xlf
@@ -222,6 +222,11 @@
         <target state="translated">Normal ifadeleri renklendir</target>
         <note />
       </trans-unit>
+      <trans-unit id="Combine_inheritance_margin_with_indicator_margin">
+        <source>Combine inheritance margin with indicator margin</source>
+        <target state="new">Combine inheritance margin with indicator margin</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Comments">
         <source>Comments</source>
         <target state="translated">Açıklamalar</target>
diff --git a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hans.xlf b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hans.xlf
index 11582b87ec5a3..b25f2214c1a46 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hans.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hans.xlf
@@ -222,6 +222,11 @@
         <target state="translated">为正规表达式着色</target>
         <note />
       </trans-unit>
+      <trans-unit id="Combine_inheritance_margin_with_indicator_margin">
+        <source>Combine inheritance margin with indicator margin</source>
+        <target state="new">Combine inheritance margin with indicator margin</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Comments">
         <source>Comments</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 360436ce640d3..7441e82f4d67b 100644
--- a/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hant.xlf
+++ b/src/VisualStudio/Core/Def/xlf/ServicesVSResources.zh-Hant.xlf
@@ -222,6 +222,11 @@
         <target state="translated">為規則運算式添加色彩</target>
         <note />
       </trans-unit>
+      <trans-unit id="Combine_inheritance_margin_with_indicator_margin">
+        <source>Combine inheritance margin with indicator margin</source>
+        <target state="new">Combine inheritance margin with indicator margin</target>
+        <note />
+      </trans-unit>
       <trans-unit id="Comments">
         <source>Comments</source>
         <target state="translated">註解</target>
diff --git a/src/VisualStudio/Core/Impl/RoslynVisualStudioWorkspace.cs b/src/VisualStudio/Core/Impl/RoslynVisualStudioWorkspace.cs
index f5bb61cf97863..20f0fc088c78e 100644
--- a/src/VisualStudio/Core/Impl/RoslynVisualStudioWorkspace.cs
+++ b/src/VisualStudio/Core/Impl/RoslynVisualStudioWorkspace.cs
@@ -8,6 +8,7 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Threading;
+using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Editor.GoToDefinition;
 using Microsoft.CodeAnalysis.Editor.Host;
@@ -87,49 +88,26 @@ internal override IInvisibleEditor OpenInvisibleEditor(DocumentId documentId)
             return new InvisibleEditor(ServiceProvider.GlobalProvider, textDocument.FilePath, GetHierarchy(documentId.ProjectId), needsSave, needsUndoDisabled);
         }
 
-        private static bool TryResolveSymbol(
-            ISymbol symbol,
-            Project project,
-            CancellationToken cancellationToken,
-            [NotNullWhen(returnValue: true)] out ISymbol? resolvedSymbol,
-            [NotNullWhen(returnValue: true)] out Project? resolvedProject)
-        {
-            resolvedSymbol = null;
-            resolvedProject = null;
+        [Obsolete("Use TryGoToDefinitionAsync instead", error: true)]
+        public override bool TryGoToDefinition(ISymbol symbol, Project project, CancellationToken cancellationToken)
+            => _threadingContext.JoinableTaskFactory.Run(() => TryGoToDefinitionAsync(symbol, project, cancellationToken));
 
+        public override async Task<bool> TryGoToDefinitionAsync(
+            ISymbol symbol, Project project, CancellationToken cancellationToken)
+        {
             var currentProject = project.Solution.Workspace.CurrentSolution.GetProject(project.Id);
             if (currentProject == null)
-            {
                 return false;
-            }
 
             var symbolId = SymbolKey.Create(symbol, cancellationToken);
-            var currentCompilation = currentProject.GetRequiredCompilationAsync(cancellationToken).WaitAndGetResult(cancellationToken);
+            var currentCompilation = await currentProject.GetRequiredCompilationAsync(cancellationToken).ConfigureAwait(false);
             var symbolInfo = symbolId.Resolve(currentCompilation, cancellationToken: cancellationToken);
-
             if (symbolInfo.Symbol == null)
-            {
                 return false;
-            }
-
-            resolvedSymbol = symbolInfo.Symbol;
-            resolvedProject = currentProject;
-
-            return true;
-        }
-
-        public override bool TryGoToDefinition(
-            ISymbol symbol, Project project, CancellationToken cancellationToken)
-        {
-            if (!TryResolveSymbol(symbol, project, cancellationToken,
-                    out var searchSymbol, out var searchProject))
-            {
-                return false;
-            }
 
-            return GoToDefinitionHelpers.TryGoToDefinition(
-                searchSymbol, searchProject.Solution,
-                _threadingContext, _streamingPresenter.Value, cancellationToken);
+            return await GoToDefinitionHelpers.TryGoToDefinitionAsync(
+                symbolInfo.Symbol, currentProject.Solution,
+                _threadingContext, _streamingPresenter.Value, cancellationToken).ConfigureAwait(false);
         }
 
         public override bool TryFindAllReferences(ISymbol symbol, Project project, CancellationToken cancellationToken)
diff --git a/src/VisualStudio/Core/Test/GoToDefinition/GoToDefinitionApiTests.vb b/src/VisualStudio/Core/Test/GoToDefinition/GoToDefinitionApiTests.vb
index edf450443e9e2..1d0a28b524af4 100644
--- a/src/VisualStudio/Core/Test/GoToDefinition/GoToDefinitionApiTests.vb
+++ b/src/VisualStudio/Core/Test/GoToDefinition/GoToDefinitionApiTests.vb
@@ -42,8 +42,8 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.GoToDefinition
                 Dim threadingContext = workspace.ExportProvider.GetExportedValue(Of IThreadingContext)()
                 Dim presenter = New MockStreamingFindUsagesPresenter(Sub() Exit Sub)
 
-                WpfTestRunner.RequireWpfFact($"{NameOf(GoToDefinitionHelpers)}.{NameOf(GoToDefinitionHelpers.TryGoToDefinition)} assumes it's on the UI thread with a {NameOf(TaskExtensions.WaitAndGetResult)} call")
-                Dim success = GoToDefinitionHelpers.TryGoToDefinition(
+                WpfTestRunner.RequireWpfFact($"{NameOf(GoToDefinitionHelpers)}.{NameOf(GoToDefinitionHelpers.TryGoToDefinitionAsync)} assumes it's on the UI thread with a {NameOf(TaskExtensions.WaitAndGetResult)} call")
+                Dim success = Await GoToDefinitionHelpers.TryGoToDefinitionAsync(
                     symbolInfo.Symbol, document.Project.Solution,
                     threadingContext,
                     presenter,
diff --git a/src/VisualStudio/Core/Test/InheritanceMargin/InheritanceMarginViewModelTests.vb b/src/VisualStudio/Core/Test/InheritanceMargin/InheritanceMarginViewModelTests.vb
index 84e5a27300947..96ae2f2fcdd45 100644
--- a/src/VisualStudio/Core/Test/InheritanceMargin/InheritanceMarginViewModelTests.vb
+++ b/src/VisualStudio/Core/Test/InheritanceMargin/InheritanceMarginViewModelTests.vb
@@ -30,7 +30,7 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.InheritanceMargin
 
         Private Shared s_indentMargin As Thickness = New Thickness(22, 1, 4, 1)
 
-        Private Shared Async Function VerifyAsync(markup As String, languageName As String, expectedViewModels As Dictionary(Of Integer, InheritanceMarginViewModel)) As Task
+        Private Shared Async Function VerifyAsync(markup As String, languageName As String, expectedViewModels As Dictionary(Of Integer, InheritanceMarginGlyphViewModel)) As Task
             ' Add an lf before the document so that the line number starts
             ' with 1, which meets the line number in the editor (but in fact all things start from 0)
             Dim workspaceFile =
@@ -71,7 +71,7 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.InheritanceMargin
 
                     Dim acutalTag = acutalLineToTagDictionary(lineNumber)
                     ' Editor TestView zoom level is 100 based.
-                    Dim actualViewModel = InheritanceMarginViewModel.Create(
+                    Dim actualViewModel = InheritanceMarginGlyphViewModel.Create(
                         classificationTypeMap, classificationFormatMap.GetClassificationFormatMap("tooltip"), acutalTag, 100)
 
                     VerifyTwoViewModelAreSame(expectedViewModel, actualViewModel)
@@ -80,7 +80,7 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.InheritanceMargin
             End Using
         End Function
 
-        Private Shared Sub VerifyTwoViewModelAreSame(expected As InheritanceMarginViewModel, actual As InheritanceMarginViewModel)
+        Private Shared Sub VerifyTwoViewModelAreSame(expected As InheritanceMarginGlyphViewModel, actual As InheritanceMarginGlyphViewModel)
             Assert.Equal(expected.ImageMoniker, actual.ImageMoniker)
             Dim actualTextGetFromTextBlock = actual.ToolTipTextBlock.Inlines _
                 .OfType(Of Run).Select(Function(run) run.Text) _
@@ -102,7 +102,7 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.InheritanceMargin
 
         End Sub
 
-        Private Shared Sub VerifyMenuItem(expected As InheritanceMenuItemViewModel, actual As InheritanceMenuItemViewModel)
+        Private Shared Sub VerifyMenuItem(expected As MenuItemViewModel, actual As MenuItemViewModel)
             Assert.Equal(expected.AutomationName, actual.AutomationName)
             Assert.Equal(expected.DisplayContent, actual.DisplayContent)
             Assert.Equal(expected.ImageMoniker, actual.ImageMoniker)
@@ -145,21 +145,21 @@ public class Bar : IBar
 {
 }"
             Dim tooltipTextForIBar = String.Format(ServicesVSResources._0_is_inherited, "interface IBar")
-            Dim targetForIBar = ImmutableArray.Create(Of InheritanceMenuItemViewModel)(New HeaderMenuItemViewModel(ServicesVSResources.Implementing_types, KnownMonikers.Implemented, ServicesVSResources.Implementing_types)).
+            Dim targetForIBar = ImmutableArray.Create(Of MenuItemViewModel)(New HeaderMenuItemViewModel(ServicesVSResources.Implementing_types, KnownMonikers.Implemented, ServicesVSResources.Implementing_types)).
                 Add(New TargetMenuItemViewModel("Bar", KnownMonikers.ClassPublic, "Bar", Nothing))
 
             Dim tooltipTextForBar = String.Format(ServicesVSResources._0_is_inherited, "class Bar")
-            Dim targetForBar = ImmutableArray.Create(Of InheritanceMenuItemViewModel)(New HeaderMenuItemViewModel(ServicesVSResources.Implemented_interfaces, KnownMonikers.Implementing, ServicesVSResources.Implemented_interfaces)).
+            Dim targetForBar = ImmutableArray.Create(Of MenuItemViewModel)(New HeaderMenuItemViewModel(ServicesVSResources.Implemented_interfaces, KnownMonikers.Implementing, ServicesVSResources.Implemented_interfaces)).
                 Add(New TargetMenuItemViewModel("IBar", KnownMonikers.InterfacePublic, "IBar", Nothing))
 
-            Return VerifyAsync(markup, LanguageNames.CSharp, New Dictionary(Of Integer, InheritanceMarginViewModel) From {
-                {2, New InheritanceMarginViewModel(
+            Return VerifyAsync(markup, LanguageNames.CSharp, New Dictionary(Of Integer, InheritanceMarginGlyphViewModel) From {
+                {2, New InheritanceMarginGlyphViewModel(
                     KnownMonikers.Implemented,
                     CreateTextBlock(tooltipTextForIBar),
                     tooltipTextForIBar,
                     1,
                     targetForIBar)},
-                {5, New InheritanceMarginViewModel(
+                {5, New InheritanceMarginGlyphViewModel(
                     KnownMonikers.Implementing,
                     CreateTextBlock(tooltipTextForBar),
                     tooltipTextForBar,
@@ -181,41 +181,41 @@ public class Bar : AbsBar
 }"
 
             Dim tooltipTextForAbsBar = String.Format(ServicesVSResources._0_is_inherited, "class AbsBar")
-            Dim targetForAbsBar = ImmutableArray.Create(Of InheritanceMenuItemViewModel)(New HeaderMenuItemViewModel(ServicesVSResources.Derived_types, KnownMonikers.Overridden, ServicesVSResources.Derived_types)).
+            Dim targetForAbsBar = ImmutableArray.Create(Of MenuItemViewModel)(New HeaderMenuItemViewModel(ServicesVSResources.Derived_types, KnownMonikers.Overridden, ServicesVSResources.Derived_types)).
                 Add(New TargetMenuItemViewModel("Bar", KnownMonikers.ClassPublic, "Bar", Nothing))
 
             Dim tooltipTextForAbstractFoo = String.Format(ServicesVSResources._0_is_inherited, "abstract void AbsBar.Foo()")
-            Dim targetForAbsFoo = ImmutableArray.Create(Of InheritanceMenuItemViewModel)(New HeaderMenuItemViewModel(ServicesVSResources.Overriding_members, KnownMonikers.Overridden, ServicesVSResources.Overriding_members)).
+            Dim targetForAbsFoo = ImmutableArray.Create(Of MenuItemViewModel)(New HeaderMenuItemViewModel(ServicesVSResources.Overriding_members, KnownMonikers.Overridden, ServicesVSResources.Overriding_members)).
                 Add(New TargetMenuItemViewModel("Bar.Foo", KnownMonikers.MethodPublic, "Bar.Foo", Nothing))
 
             Dim tooltipTextForBar = String.Format(ServicesVSResources._0_is_inherited, "class Bar")
-            Dim targetForBar = ImmutableArray.Create(Of InheritanceMenuItemViewModel)(New HeaderMenuItemViewModel(ServicesVSResources.Base_Types, KnownMonikers.Overriding, ServicesVSResources.Base_Types)).
+            Dim targetForBar = ImmutableArray.Create(Of MenuItemViewModel)(New HeaderMenuItemViewModel(ServicesVSResources.Base_Types, KnownMonikers.Overriding, ServicesVSResources.Base_Types)).
                 Add(New TargetMenuItemViewModel("AbsBar", KnownMonikers.ClassPublic, "AbsBar", Nothing))
 
             Dim tooltipTextForOverrideFoo = String.Format(ServicesVSResources._0_is_inherited, "override void Bar.Foo()")
-            Dim targetForOverrideFoo = ImmutableArray.Create(Of InheritanceMenuItemViewModel)(New HeaderMenuItemViewModel(ServicesVSResources.Overridden_members, KnownMonikers.Overriding, ServicesVSResources.Overridden_members)).
+            Dim targetForOverrideFoo = ImmutableArray.Create(Of MenuItemViewModel)(New HeaderMenuItemViewModel(ServicesVSResources.Overridden_members, KnownMonikers.Overriding, ServicesVSResources.Overridden_members)).
                 Add(New TargetMenuItemViewModel("AbsBar.Foo", KnownMonikers.MethodPublic, "AbsBar.Foo", Nothing))
 
-            Return VerifyAsync(markup, LanguageNames.CSharp, New Dictionary(Of Integer, InheritanceMarginViewModel) From {
-                {2, New InheritanceMarginViewModel(
+            Return VerifyAsync(markup, LanguageNames.CSharp, New Dictionary(Of Integer, InheritanceMarginGlyphViewModel) From {
+                {2, New InheritanceMarginGlyphViewModel(
                     KnownMonikers.Overridden,
                     CreateTextBlock(tooltipTextForAbsBar),
                     tooltipTextForAbsBar,
                     1,
                     targetForAbsBar)},
-                {4, New InheritanceMarginViewModel(
+                {4, New InheritanceMarginGlyphViewModel(
                     KnownMonikers.Overridden,
                     CreateTextBlock(tooltipTextForAbstractFoo),
                     tooltipTextForAbstractFoo,
                     1,
                     targetForAbsFoo)},
-                {7, New InheritanceMarginViewModel(
+                {7, New InheritanceMarginGlyphViewModel(
                     KnownMonikers.Overriding,
                     CreateTextBlock(tooltipTextForBar),
                     tooltipTextForBar,
                     1,
                     targetForBar)},
-                {9, New InheritanceMarginViewModel(
+                {9, New InheritanceMarginGlyphViewModel(
                     KnownMonikers.Overriding,
                     CreateTextBlock(tooltipTextForOverrideFoo),
                     tooltipTextForOverrideFoo,
@@ -231,38 +231,38 @@ public interface IBar2 : IBar1 { }
 public interface IBar3 : IBar2 { }
 "
             Dim tooltipTextForIBar1 = String.Format(ServicesVSResources._0_is_inherited, "interface IBar1")
-            Dim targetForIBar1 = ImmutableArray.Create(Of InheritanceMenuItemViewModel)(
+            Dim targetForIBar1 = ImmutableArray.Create(Of MenuItemViewModel)(
                 New HeaderMenuItemViewModel(ServicesVSResources.Implementing_types, KnownMonikers.Implemented, ServicesVSResources.Implementing_types),
                 New TargetMenuItemViewModel("IBar2", KnownMonikers.InterfacePublic, "IBar2", Nothing),
                 New TargetMenuItemViewModel("IBar3", KnownMonikers.InterfacePublic, "IBar3", Nothing))
 
             Dim tooltipTextForIBar2 = String.Format(ServicesVSResources._0_is_inherited, "interface IBar2")
-            Dim targetForIBar2 = ImmutableArray.Create(Of InheritanceMenuItemViewModel)(
+            Dim targetForIBar2 = ImmutableArray.Create(Of MenuItemViewModel)(
                 New HeaderMenuItemViewModel(ServicesVSResources.Inherited_interfaces, KnownMonikers.Implementing, ServicesVSResources.Inherited_interfaces),
                 New TargetMenuItemViewModel("IBar1", KnownMonikers.InterfacePublic, "IBar1", Nothing),
                 New HeaderMenuItemViewModel(ServicesVSResources.Implementing_types, KnownMonikers.Implemented, ServicesVSResources.Implementing_types),
                 New TargetMenuItemViewModel("IBar3", KnownMonikers.InterfacePublic, "IBar3", Nothing))
 
             Dim tooltipTextForIBar3 = String.Format(ServicesVSResources._0_is_inherited, "interface IBar3")
-            Dim targetForIBar3 = ImmutableArray.Create(Of InheritanceMenuItemViewModel)(
+            Dim targetForIBar3 = ImmutableArray.Create(Of MenuItemViewModel)(
                 New HeaderMenuItemViewModel(ServicesVSResources.Inherited_interfaces, KnownMonikers.Implementing, ServicesVSResources.Inherited_interfaces),
                 New TargetMenuItemViewModel("IBar1", KnownMonikers.InterfacePublic, "IBar1", Nothing),
-                New TargetMenuItemViewModel("IBar2", KnownMonikers.InterfacePublic, "IBar2", Nothing)).CastArray(Of InheritanceMenuItemViewModel)
+                New TargetMenuItemViewModel("IBar2", KnownMonikers.InterfacePublic, "IBar2", Nothing)).CastArray(Of MenuItemViewModel)
 
-            Return VerifyAsync(markup, LanguageNames.CSharp, New Dictionary(Of Integer, InheritanceMarginViewModel) From {
-                {2, New InheritanceMarginViewModel(
+            Return VerifyAsync(markup, LanguageNames.CSharp, New Dictionary(Of Integer, InheritanceMarginGlyphViewModel) From {
+                {2, New InheritanceMarginGlyphViewModel(
                     KnownMonikers.Implemented,
                     CreateTextBlock(tooltipTextForIBar1),
                     tooltipTextForIBar1,
                     1,
                     targetForIBar1)},
-                {3, New InheritanceMarginViewModel(
+                {3, New InheritanceMarginGlyphViewModel(
                     KnownMonikers.ImplementingImplemented,
                     CreateTextBlock(tooltipTextForIBar2),
                     tooltipTextForIBar2,
                     1,
                     targetForIBar2)},
-                {4, New InheritanceMarginViewModel(
+                {4, New InheritanceMarginGlyphViewModel(
                     KnownMonikers.Implementing,
                     CreateTextBlock(tooltipTextForIBar3),
                     tooltipTextForIBar3,
@@ -271,39 +271,39 @@ public interface IBar3 : IBar2 { }
         End Function
 
         <WpfFact>
-        Public Function Test() As Task
+        Public Function TestClassDerivesClass() As Task
             Dim markup = "
 public class Bar1 {}
 public class Bar2 : Bar1 {}
 public class Bar3 : Bar2 {}"
 
             Dim tooltipTextForBar1 = String.Format(ServicesVSResources._0_is_inherited, "class Bar1")
-            Dim targetForBar1 = ImmutableArray.Create(Of InheritanceMenuItemViewModel)(New HeaderMenuItemViewModel(ServicesVSResources.Derived_types, KnownMonikers.Overridden, ServicesVSResources.Derived_types)).
+            Dim targetForBar1 = ImmutableArray.Create(Of MenuItemViewModel)(New HeaderMenuItemViewModel(ServicesVSResources.Derived_types, KnownMonikers.Overridden, ServicesVSResources.Derived_types)).
                 Add(New TargetMenuItemViewModel("Bar2", KnownMonikers.ClassPublic, "Bar2", Nothing)).Add(New TargetMenuItemViewModel("Bar3", KnownMonikers.ClassPublic, "Bar3", Nothing))
 
             Dim tooltipTextForBar2 = String.Format(ServicesVSResources._0_is_inherited, "class Bar2")
-            Dim targetForBar2 = ImmutableArray.Create(Of InheritanceMenuItemViewModel)(New HeaderMenuItemViewModel(ServicesVSResources.Base_Types, KnownMonikers.Overriding, ServicesVSResources.Base_Types)).Add(New TargetMenuItemViewModel("Bar1", KnownMonikers.ClassPublic, "Bar1", Nothing)).
+            Dim targetForBar2 = ImmutableArray.Create(Of MenuItemViewModel)(New HeaderMenuItemViewModel(ServicesVSResources.Base_Types, KnownMonikers.Overriding, ServicesVSResources.Base_Types)).Add(New TargetMenuItemViewModel("Bar1", KnownMonikers.ClassPublic, "Bar1", Nothing)).
                 Add(New HeaderMenuItemViewModel(ServicesVSResources.Derived_types, KnownMonikers.Overridden, ServicesVSResources.Derived_types)).Add(New TargetMenuItemViewModel("Bar3", KnownMonikers.ClassPublic, "Bar3", Nothing))
 
             Dim tooltipTextForBar3 = String.Format(ServicesVSResources._0_is_inherited, "class Bar3")
-            Dim targetForBar3 = ImmutableArray.Create(Of InheritanceMenuItemViewModel)(New HeaderMenuItemViewModel(ServicesVSResources.Base_Types, KnownMonikers.Overriding, ServicesVSResources.Base_Types)).
+            Dim targetForBar3 = ImmutableArray.Create(Of MenuItemViewModel)(New HeaderMenuItemViewModel(ServicesVSResources.Base_Types, KnownMonikers.Overriding, ServicesVSResources.Base_Types)).
                 Add(New TargetMenuItemViewModel("Bar1", KnownMonikers.ClassPublic, "Bar1", Nothing)).
                 Add(New TargetMenuItemViewModel("Bar2", KnownMonikers.ClassPublic, "Bar2", Nothing))
 
-            Return VerifyAsync(markup, LanguageNames.CSharp, New Dictionary(Of Integer, InheritanceMarginViewModel) From {
-                {2, New InheritanceMarginViewModel(
+            Return VerifyAsync(markup, LanguageNames.CSharp, New Dictionary(Of Integer, InheritanceMarginGlyphViewModel) From {
+                {2, New InheritanceMarginGlyphViewModel(
                     KnownMonikers.Overridden,
                     CreateTextBlock(tooltipTextForBar1),
                     tooltipTextForBar1,
                     1,
                     targetForBar1)},
-                {3, New InheritanceMarginViewModel(
+                {3, New InheritanceMarginGlyphViewModel(
                     KnownMonikers.OverridingOverridden,
                     CreateTextBlock(tooltipTextForBar2),
                     tooltipTextForBar2,
                     1,
                     targetForBar2)},
-                {4, New InheritanceMarginViewModel(
+                {4, New InheritanceMarginGlyphViewModel(
                     KnownMonikers.Overriding,
                     CreateTextBlock(tooltipTextForBar3),
                     tooltipTextForBar3,
@@ -327,54 +327,54 @@ public class BarSample : IBar1
 }"
 
             Dim tooltipTextForIBar1 = String.Format(ServicesVSResources._0_is_inherited, "interface IBar1")
-            Dim targetForIBar1 = ImmutableArray.Create(Of InheritanceMenuItemViewModel)(
+            Dim targetForIBar1 = ImmutableArray.Create(Of MenuItemViewModel)(
                 New HeaderMenuItemViewModel(ServicesVSResources.Implementing_types, KnownMonikers.Implemented, ServicesVSResources.Implementing_types),
                 New TargetMenuItemViewModel("BarSample", KnownMonikers.ClassPublic, "BarSample", Nothing))
 
             Dim tooltipTextForE1AndE2InInterface = ServicesVSResources.Multiple_members_are_inherited
-            Dim targetForE1AndE2InInterface = ImmutableArray.Create(Of InheritanceMenuItemViewModel)(
-                New MemberMenuItemViewModel("event EventHandler IBar1.e1", KnownMonikers.EventPublic, "event EventHandler IBar1.e1", ImmutableArray.Create(Of InheritanceMenuItemViewModel)(
+            Dim targetForE1AndE2InInterface = ImmutableArray.Create(Of MenuItemViewModel)(
+                New MemberMenuItemViewModel("event EventHandler IBar1.e1", KnownMonikers.EventPublic, "event EventHandler IBar1.e1", ImmutableArray.Create(Of MenuItemViewModel)(
                     New HeaderMenuItemViewModel(ServicesVSResources.Implementing_members, KnownMonikers.Implemented, ServicesVSResources.Implementing_members),
                     New TargetMenuItemViewModel("BarSample.e1", KnownMonikers.EventPublic, "BarSample.e1", Nothing))),
-                New MemberMenuItemViewModel("event EventHandler IBar1.e2", KnownMonikers.EventPublic, "event EventHandler IBar1.e2", ImmutableArray.Create(Of InheritanceMenuItemViewModel)(
+                New MemberMenuItemViewModel("event EventHandler IBar1.e2", KnownMonikers.EventPublic, "event EventHandler IBar1.e2", ImmutableArray.Create(Of MenuItemViewModel)(
                     New HeaderMenuItemViewModel(ServicesVSResources.Implementing_members, KnownMonikers.Implemented, ServicesVSResources.Implementing_members),
                     New TargetMenuItemViewModel("BarSample.e2", KnownMonikers.EventPublic, "BarSample.e2", Nothing))))
 
             Dim tooltipTextForBarSample = String.Format(ServicesVSResources._0_is_inherited, "class BarSample")
-            Dim targetForBarSample = ImmutableArray.Create(Of InheritanceMenuItemViewModel)(
+            Dim targetForBarSample = ImmutableArray.Create(Of MenuItemViewModel)(
                 New HeaderMenuItemViewModel(ServicesVSResources.Implemented_interfaces, KnownMonikers.Implementing, ServicesVSResources.Implemented_interfaces),
                 New TargetMenuItemViewModel("IBar1", KnownMonikers.InterfaceInternal, "IBar1", Nothing))
 
             Dim tooltipTextForE1AndE2InBarSample = ServicesVSResources.Multiple_members_are_inherited
-            Dim targetForE1AndE2InInBarSample = ImmutableArray.Create(Of InheritanceMenuItemViewModel)(
-                New MemberMenuItemViewModel("virtual event EventHandler BarSample.e1", KnownMonikers.EventPublic, "virtual event EventHandler BarSample.e1", ImmutableArray.Create(Of InheritanceMenuItemViewModel)(
+            Dim targetForE1AndE2InInBarSample = ImmutableArray.Create(Of MenuItemViewModel)(
+                New MemberMenuItemViewModel("virtual event EventHandler BarSample.e1", KnownMonikers.EventPublic, "virtual event EventHandler BarSample.e1", ImmutableArray.Create(Of MenuItemViewModel)(
                     New HeaderMenuItemViewModel(ServicesVSResources.Implemented_members, KnownMonikers.Implementing, ServicesVSResources.Implemented_members),
-                    New TargetMenuItemViewModel("IBar1.e1", KnownMonikers.EventPublic, "IBar1.e1", Nothing)).CastArray(Of InheritanceMenuItemViewModel)),
-                New MemberMenuItemViewModel("virtual event EventHandler BarSample.e2", KnownMonikers.EventPublic, "virtual event EventHandler BarSample.e2", ImmutableArray.Create(Of InheritanceMenuItemViewModel)(
+                    New TargetMenuItemViewModel("IBar1.e1", KnownMonikers.EventPublic, "IBar1.e1", Nothing)).CastArray(Of MenuItemViewModel)),
+                New MemberMenuItemViewModel("virtual event EventHandler BarSample.e2", KnownMonikers.EventPublic, "virtual event EventHandler BarSample.e2", ImmutableArray.Create(Of MenuItemViewModel)(
                     New HeaderMenuItemViewModel(ServicesVSResources.Implemented_members, KnownMonikers.Implementing, ServicesVSResources.Implemented_members),
-                    New TargetMenuItemViewModel("IBar1.e2", KnownMonikers.EventPublic, "IBar1.e2", Nothing)).CastArray(Of InheritanceMenuItemViewModel))) _
-            .CastArray(Of InheritanceMenuItemViewModel)
+                    New TargetMenuItemViewModel("IBar1.e2", KnownMonikers.EventPublic, "IBar1.e2", Nothing)).CastArray(Of MenuItemViewModel))) _
+            .CastArray(Of MenuItemViewModel)
 
-            Return VerifyAsync(markup, LanguageNames.CSharp, New Dictionary(Of Integer, InheritanceMarginViewModel) From {
-                {3, New InheritanceMarginViewModel(
+            Return VerifyAsync(markup, LanguageNames.CSharp, New Dictionary(Of Integer, InheritanceMarginGlyphViewModel) From {
+                {3, New InheritanceMarginGlyphViewModel(
                     KnownMonikers.Implemented,
                     CreateTextBlock(tooltipTextForIBar1),
                     tooltipTextForIBar1,
                     1,
                     targetForIBar1)},
-                {5, New InheritanceMarginViewModel(
+                {5, New InheritanceMarginGlyphViewModel(
                     KnownMonikers.Implemented,
                     CreateTextBlock(tooltipTextForE1AndE2InInterface),
                     String.Format(ServicesVSResources.Multiple_members_are_inherited_on_line_0, 5),
                     1,
                     targetForE1AndE2InInterface)},
-                {8, New InheritanceMarginViewModel(
+                {8, New InheritanceMarginGlyphViewModel(
                     KnownMonikers.Implementing,
                     CreateTextBlock(tooltipTextForBarSample),
                     tooltipTextForBarSample,
                     1,
                     targetForBarSample)},
-                {10, New InheritanceMarginViewModel(
+                {10, New InheritanceMarginGlyphViewModel(
                     KnownMonikers.Implementing,
                     CreateTextBlock(tooltipTextForE1AndE2InBarSample),
                     String.Format(ServicesVSResources.Multiple_members_are_inherited_on_line_0, 10),
diff --git a/src/VisualStudio/TestUtilities2/CodeModel/Mocks/MockVisualStudioWorkspace.vb b/src/VisualStudio/TestUtilities2/CodeModel/Mocks/MockVisualStudioWorkspace.vb
index eaf3bfe4418af..ab14e0881f40a 100644
--- a/src/VisualStudio/TestUtilities2/CodeModel/Mocks/MockVisualStudioWorkspace.vb
+++ b/src/VisualStudio/TestUtilities2/CodeModel/Mocks/MockVisualStudioWorkspace.vb
@@ -64,6 +64,10 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.CodeModel.Mocks
             Throw New NotImplementedException()
         End Function
 
+        Public Overrides Function TryGoToDefinitionAsync(symbol As ISymbol, project As Project, cancellationToken As CancellationToken) As Task(Of Boolean)
+            Throw New NotImplementedException()
+        End Function
+
         Public Overrides Function TryFindAllReferences(symbol As ISymbol, project As Project, cancellationToken As CancellationToken) As Boolean
             Throw New NotImplementedException()
         End Function
diff --git a/src/VisualStudio/TestUtilities2/ProjectSystemShim/Framework/TestEnvironment.vb b/src/VisualStudio/TestUtilities2/ProjectSystemShim/Framework/TestEnvironment.vb
index ae71ae62b3194..6caf57435b3f6 100644
--- a/src/VisualStudio/TestUtilities2/ProjectSystemShim/Framework/TestEnvironment.vb
+++ b/src/VisualStudio/TestUtilities2/ProjectSystemShim/Framework/TestEnvironment.vb
@@ -106,15 +106,19 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.ProjectSystemShim.Fr
                            exportProvider.GetExportedValue(Of MockServiceProvider))
             End Sub
 
-            Public Overrides Sub DisplayReferencedSymbols(solution As Microsoft.CodeAnalysis.Solution, referencedSymbols As IEnumerable(Of ReferencedSymbol))
+            Public Overrides Sub DisplayReferencedSymbols(solution As Solution, referencedSymbols As IEnumerable(Of ReferencedSymbol))
                 Throw New NotImplementedException()
             End Sub
 
-            Public Overrides Function TryGoToDefinition(symbol As ISymbol, project As Microsoft.CodeAnalysis.Project, cancellationToken As CancellationToken) As Boolean
+            Public Overrides Function TryGoToDefinition(symbol As ISymbol, project As Project, cancellationToken As CancellationToken) As Boolean
                 Throw New NotImplementedException()
             End Function
 
-            Public Overrides Function TryFindAllReferences(symbol As ISymbol, project As Microsoft.CodeAnalysis.Project, cancellationToken As CancellationToken) As Boolean
+            Public Overrides Function TryGoToDefinitionAsync(symbol As ISymbol, project As Project, cancellationToken As CancellationToken) As Task(Of Boolean)
+                Throw New NotImplementedException()
+            End Function
+
+            Public Overrides Function TryFindAllReferences(symbol As ISymbol, project As Project, cancellationToken As CancellationToken) As Boolean
                 Throw New NotImplementedException()
             End Function
 
@@ -167,9 +171,9 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.ProjectSystemShim.Fr
         <Export>
         <Export(GetType(SVsServiceProvider))>
         Friend Class MockServiceProvider
-            Implements System.IServiceProvider
+            Implements IServiceProvider
             Implements SVsServiceProvider ' The shell service provider actually implements this too for people using that type directly
-            Implements Shell.IAsyncServiceProvider
+            Implements IAsyncServiceProvider
 
             Private ReadOnly _exportProvider As Composition.ExportProvider
             Private ReadOnly _fileChangeEx As MockVsFileChangeEx = New MockVsFileChangeEx
@@ -182,7 +186,7 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.ProjectSystemShim.Fr
                 _exportProvider = exportProvider
             End Sub
 
-            Public Function GetService(serviceType As Type) As Object Implements System.IServiceProvider.GetService
+            Public Function GetService(serviceType As Type) As Object Implements IServiceProvider.GetService
                 Select Case serviceType
                     Case GetType(SVsSolution)
                         ' Return a loose mock that just is a big no-op
@@ -209,7 +213,7 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.ProjectSystemShim.Fr
                 End Select
             End Function
 
-            Public Function GetServiceAsync(serviceType As Type) As Task(Of Object) Implements Shell.IAsyncServiceProvider.GetServiceAsync
+            Public Function GetServiceAsync(serviceType As Type) As Task(Of Object) Implements IAsyncServiceProvider.GetServiceAsync
                 Return System.Threading.Tasks.Task.FromResult(GetService(serviceType))
             End Function
 
diff --git a/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageControl.xaml b/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageControl.xaml
index 6877e4d93ee00..8ea67c0c7e6cb 100644
--- a/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageControl.xaml
+++ b/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageControl.xaml
@@ -261,6 +261,9 @@
                     <CheckBox x:Uid="ShowInheritanceMargin"
                               x:Name="ShowInheritanceMargin"
                               Content="{x:Static local:AdvancedOptionPageStrings.Show_inheritance_margin}"/>
+                    <CheckBox x:Uid="InheritanceMarginCombinedWithIndicatorMargin"
+                              x:Name="InheritanceMarginCombinedWithIndicatorMargin"
+                              Content="{x:Static local:AdvancedOptionPageStrings.Combine_inheritance_margin_with_indicator_margin}"/>
                 </StackPanel>
             </GroupBox>
         </StackPanel>
diff --git a/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageControl.xaml.vb b/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageControl.xaml.vb
index 1a27d07b98dab..cc8d42f46cfdd 100644
--- a/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageControl.xaml.vb
+++ b/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageControl.xaml.vb
@@ -151,6 +151,7 @@ Namespace Microsoft.VisualStudio.LanguageServices.VisualBasic.Options
                              ' 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
                              Return True
                          End Function)
+            BindToOption(InheritanceMarginCombinedWithIndicatorMargin, FeatureOnOffOptions.InheritanceMarginCombinedWithIndicatorMargin)
         End Sub
 
         ' 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/VisualBasic/Impl/Options/AdvancedOptionPageStrings.vb b/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageStrings.vb
index 7e9e6c2ad4999..0a28c0280fe42 100644
--- a/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageStrings.vb
+++ b/src/VisualStudio/VisualBasic/Impl/Options/AdvancedOptionPageStrings.vb
@@ -296,6 +296,9 @@ Namespace Microsoft.VisualStudio.LanguageServices.VisualBasic.Options
         Public ReadOnly Property Show_inheritance_margin As String =
             ServicesVSResources.Show_inheritance_margin
 
+        Public ReadOnly Property Combine_inheritance_margin_with_indicator_margin As String =
+            ServicesVSResources.Combine_inheritance_margin_with_indicator_margin
+
         Public ReadOnly Property Inheritance_Margin_experimental As String =
             ServicesVSResources.Inheritance_Margin_experimental
     End Module
diff --git a/src/VisualStudio/VisualBasic/Impl/VSPackage.resx b/src/VisualStudio/VisualBasic/Impl/VSPackage.resx
index e75e5a640b154..fa7e3f08fafd6 100644
--- a/src/VisualStudio/VisualBasic/Impl/VSPackage.resx
+++ b/src/VisualStudio/VisualBasic/Impl/VSPackage.resx
@@ -128,7 +128,7 @@
     <value>Visual Basic Editor</value>
   </data>
   <data name="10160" xml:space="preserve">
-    <value>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;Inheritance Margin;</value>
+    <value>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;Inheritance Margin;Import Directives;</value>
     <comment>Advanced options page keywords</comment>
   </data>
   <data name="102" xml:space="preserve">
diff --git a/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.cs.xlf b/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.cs.xlf
index c43220b35bb48..d6c2e4b9b93da 100644
--- a/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.cs.xlf
+++ b/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.cs.xlf
@@ -18,7 +18,7 @@
         <note />
       </trans-unit>
       <trans-unit id="10160">
-        <source>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;Inheritance Margin;</source>
+        <source>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;Inheritance Margin;Import Directives;</source>
         <target state="needs-review-translation">Zobrazovat vložené nápovědy;Automatické vložení koncových konstruktorů;Změnit nastavení přehledného výpisu;Změnit režim sbalení;Automatické vkládání členů Interface a MustOverride;Zobrazit nebo skrýt oddělovače řádků procedur;Zapnout nebo vypnout návrhy oprav;Zapnout nebo vypnout zvýrazňování odkazů a klíčových slov;Regex;Obarvit regulární výrazy;Zvýrazňovat související komponenty pod kurzorem;Nahlásit neplatné regulární výrazy;reg. výr.;regulární výraz;Používat rozšířené barvy;Barevné schéma editoru;</target>
         <note>Advanced options page keywords</note>
       </trans-unit>
diff --git a/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.de.xlf b/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.de.xlf
index 72eb3a80f58fd..51ed371916fa3 100644
--- a/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.de.xlf
+++ b/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.de.xlf
@@ -18,7 +18,7 @@
         <note />
       </trans-unit>
       <trans-unit id="10160">
-        <source>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;Inheritance Margin;</source>
+        <source>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;Inheritance Margin;Import Directives;</source>
         <target state="needs-review-translation">Inline-Hinweise anzeigen;Endkonstrukte automatisch einfügen;Einstellungen für automatische Strukturierung und Einrückung ändern;Gliederungsmodus ändern;Schnittstellen- und MustOverride-Member automatisch einfügen;Zeilentrennzeichen zwischen Prozeduren anzeigen oder ausblenden;Vorschläge für Fehlerkorrektur ein- oder ausschalten;Hervorhebung von Verweisen und Schlüsselwörtern ein- oder ausschalten;Regex;Reguläre Ausdrücke farbig markieren;Verwandte Komponenten unter Cursor hervorheben;Ungültige reguläre Ausdrücke melden;regex;regulärer Ausdruck;nErweiterte Farben verwenden;Editor-Farbschema;</target>
         <note>Advanced options page keywords</note>
       </trans-unit>
diff --git a/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.es.xlf b/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.es.xlf
index 4774410bcdb3d..0145d5dc16a77 100644
--- a/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.es.xlf
+++ b/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.es.xlf
@@ -18,7 +18,7 @@
         <note />
       </trans-unit>
       <trans-unit id="10160">
-        <source>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;Inheritance Margin;</source>
+        <source>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;Inheritance Margin;Import Directives;</source>
         <target state="needs-review-translation">Mostrar sugerencias insertadas;Inserción automática de construcciones End;Cambiar configuración de la lista descriptiva;Cambiar modo de esquematización;Inserción automática de miembros Interface y MustOverride;Mostrar u ocultar separadores de línea de procedimientos;Activar o desactivar sugerencias de corrección de errores;Activar o desactivar resaltado de referencias y palabras clave;Regex;Colorear expresiones regulares;Resaltar componentes relacionados bajo el cursor;Informar sobre expresiones regulares no válidas;regex;expresión regular;Usar colores mejorados;Combinación de colores del editor;</target>
         <note>Advanced options page keywords</note>
       </trans-unit>
diff --git a/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.fr.xlf b/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.fr.xlf
index 3743b36090c47..2ae710ef7c0db 100644
--- a/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.fr.xlf
+++ b/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.fr.xlf
@@ -18,7 +18,7 @@
         <note />
       </trans-unit>
       <trans-unit id="10160">
-        <source>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;Inheritance Margin;</source>
+        <source>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;Inheritance Margin;Import Directives;</source>
         <target state="needs-review-translation">Afficher les indicateurs inline;Insertion automatique des constructions de fin;Changer les paramètres de listing en mode Pretty;Changer le mode Plan;Insertion automatique des membres Interface et MustOverride;Afficher ou masquer les séparateurs de ligne de procédure;Activer ou désactiver les suggestions de correction d'erreurs;Activer ou désactiver la mise en surbrillance des références et des mots clés;Regex;Mettre en couleurs les expressions régulières;Mettre en surbrillance les composants connexes sous le curseur;Signaler les expressions régulières non valides;regex;expression régulière;Utiliser des couleurs améliorées;Modèle de couleurs de l'éditeur;</target>
         <note>Advanced options page keywords</note>
       </trans-unit>
diff --git a/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.it.xlf b/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.it.xlf
index e299dd534c67d..a5f23630213e6 100644
--- a/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.it.xlf
+++ b/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.it.xlf
@@ -18,7 +18,7 @@
         <note />
       </trans-unit>
       <trans-unit id="10160">
-        <source>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;Inheritance Margin;</source>
+        <source>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;Inheritance Margin;Import Directives;</source>
         <target state="needs-review-translation">Visualizza suggerimenti inline;Inserimento automatico di costrutti End;Modifica impostazioni di riformattazione;Modifica modalità struttura;Inserimento automatico di membri Interface e MustOverride;Mostra o nascondi separatori di riga routine;Attiva o disattiva i suggerimenti per la correzione degli errori;Attiva o disattiva l'evidenziazione di riferimenti e parole chiave;Regex;Colora espressioni regolari;Evidenzia i componenti correlati sotto il cursore;Segnala espressioni regolari non valide;regex;espressione regolare;Usa colori migliorati;Combinazione colori editor;</target>
         <note>Advanced options page keywords</note>
       </trans-unit>
diff --git a/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.ja.xlf b/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.ja.xlf
index a9e2a1ad494ea..ec3f7b0e84d1a 100644
--- a/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.ja.xlf
+++ b/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.ja.xlf
@@ -18,7 +18,7 @@
         <note />
       </trans-unit>
       <trans-unit id="10160">
-        <source>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;Inheritance Margin;</source>
+        <source>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;Inheritance Margin;Import Directives;</source>
         <target state="needs-review-translation">インラインのヒントを表示する;コンストラクトの終端の自動挿入;再フォーマット設定の変更;アウトライン モードの変更;Interface と MustOverride メンバーの自動挿入;プロシージャ行の区切り記号の表示/非表示;エラー修正候補のオン/オフの切り替え;参照とキーワードの強調表示のオン/オフの切り替え;Regex;正規表現の色付け;カーソルの下の関連コンポーネントの強調表示;無効な正規表現の報告;Regex;正規表現;拡張された色を使用する;エディターの配色;</target>
         <note>Advanced options page keywords</note>
       </trans-unit>
diff --git a/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.ko.xlf b/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.ko.xlf
index ff9afb9de86da..526b06d304a06 100644
--- a/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.ko.xlf
+++ b/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.ko.xlf
@@ -18,7 +18,7 @@
         <note />
       </trans-unit>
       <trans-unit id="10160">
-        <source>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;Inheritance Margin;</source>
+        <source>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;Inheritance Margin;Import Directives;</source>
         <target state="needs-review-translation">인라인 힌트 표시; 맺음 구문 자동 삽입; 자동 서식 지정 설정 변경; 개요 모드 변경; 인터페이스 및 MustOverride 멤버 자동 삽입; 프로시저 줄 구분 기호 표시/숨기기; 오류 수정 제안 설정/해제; 참조 및 키워드 강조 표시 설정/해제; Regex; 정규식 색 지정; 커서 아래의 관련 구성 요소 강조 표시; 잘못된 정규식 보고; regex; 정규식; 향상된 색 사용; 편집기 색 구성표;</target>
         <note>Advanced options page keywords</note>
       </trans-unit>
diff --git a/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.pl.xlf b/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.pl.xlf
index 454538178e9a0..fbbb865012bc7 100644
--- a/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.pl.xlf
+++ b/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.pl.xlf
@@ -18,7 +18,7 @@
         <note />
       </trans-unit>
       <trans-unit id="10160">
-        <source>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;Inheritance Margin;</source>
+        <source>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;Inheritance Margin;Import Directives;</source>
         <target state="needs-review-translation">Wyświetlaj wskazówki w tekście;Automatyczne wstawianie konstrukcji końcowych;Zmień ustawienia formatowania kodu;Zmień tryb konspektu;Automatyczne wstawianie składowych Interface i MustOverride;Pokaż lub ukryj separatory wierszy procedury;Włącz lub wyłącz sugestie dotyczące poprawy błędów;Włącz lub wyłącz wyróżnianie odwołań i słów kluczowych;Wyrażenie regularne;Koloruj wyrażenia regularne;Wyróżnij pokrewne składniki wskazane przez kursor;Zgłaszaj nieprawidłowe wyrażenia regularne;wyrażenie regularne;wyrażenie regularne;Użyj ulepszonych kolorów;Schemat kolorów edytora;</target>
         <note>Advanced options page keywords</note>
       </trans-unit>
diff --git a/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.pt-BR.xlf b/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.pt-BR.xlf
index fa9542d479d66..5e11660e9e3d6 100644
--- a/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.pt-BR.xlf
+++ b/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.pt-BR.xlf
@@ -18,7 +18,7 @@
         <note />
       </trans-unit>
       <trans-unit id="10160">
-        <source>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;Inheritance Margin;</source>
+        <source>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;Inheritance Margin;Import Directives;</source>
         <target state="needs-review-translation">Exibir as dicas embutidas;Inserção automática de constructos finais;Alterar as configurações de reformatação automática;Alterar o modo de estrutura de tópicos;Inserção automática dos membros Interface e MustOverride;Mostrar ou ocultar os separadores de linha de procedimento;Ativar ou desativar as sugestões para correção de erros;Ativar ou desativar o realce de referências e palavras-chave;Regex;Colorir as expressões regulares;Realçar os componentes relacionados sob o cursor;Relatar as expressões regulares inválidas;regex;expressão regular;Usar cores avançadas;Esquema de Cores do Editor;</target>
         <note>Advanced options page keywords</note>
       </trans-unit>
diff --git a/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.ru.xlf b/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.ru.xlf
index 145b6d4db2350..c41c2e5d4a9f4 100644
--- a/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.ru.xlf
+++ b/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.ru.xlf
@@ -18,7 +18,7 @@
         <note />
       </trans-unit>
       <trans-unit id="10160">
-        <source>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;Inheritance Margin;</source>
+        <source>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;Inheritance Margin;Import Directives;</source>
         <target state="needs-review-translation">Отображать встроенные подсказки;Автоматическая вставка конечных конструкций;Изменение параметров автоматического форматирования;Изменение режима структуры;Автоматическая вставка интерфейса и элементов MustOverride;Отображение или скрытие разделителей строк для процедуры;Включение или отключение предложений об исправлении ошибок;Включение или отключение выделения ссылок и ключевых слов;Регулярные выражения;Выделение регулярных выражений цветом;Выделение связанных компонентов под курсором;Выделение недопустимых регулярных выражений;регулярное выражение;регулярное выражение;Использование расширенных цветов;Цветовая схема редактора;</target>
         <note>Advanced options page keywords</note>
       </trans-unit>
diff --git a/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.tr.xlf b/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.tr.xlf
index 4c2ed918a7510..35d3d76939ca4 100644
--- a/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.tr.xlf
+++ b/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.tr.xlf
@@ -18,7 +18,7 @@
         <note />
       </trans-unit>
       <trans-unit id="10160">
-        <source>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;Inheritance Margin;</source>
+        <source>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;Inheritance Margin;Import Directives;</source>
         <target state="needs-review-translation">Satır içi ipuçlarını göster;Bitiş yapılarının otomatik olarak eklenmesi;Düzgün listeleme ayarlarını değiştir;Ana hat modunu değiştir;Interface ve MustOverride üyelerinin otomatik olarak eklenmesi;Yordam satır ayıraçlarını göster veya gizle;Hata düzeltme önerilerini aç veya kapat;Başvuruları ve anahtar sözcükleri vurgulamayı aç veya kapat;Normal ifade;Normal ifadeleri renklendir;İmlecin altındaki ilgili bileşenleri vurgula;Geçersiz normal ifadeleri bildir;normal ifade;normal ifade;Gelişmiş renkleri kullan;Düzenleyici Renk Düzeni;</target>
         <note>Advanced options page keywords</note>
       </trans-unit>
diff --git a/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.zh-Hans.xlf b/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.zh-Hans.xlf
index bd6c97c23ba89..e91f5ad2b5b57 100644
--- a/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.zh-Hans.xlf
+++ b/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.zh-Hans.xlf
@@ -18,7 +18,7 @@
         <note />
       </trans-unit>
       <trans-unit id="10160">
-        <source>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;Inheritance Margin;</source>
+        <source>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;Inheritance Margin;Import Directives;</source>
         <target state="needs-review-translation">显示内联提示;自动插入 End 构造;更改整齐排列设置;更改大纲模式;自动插入 Interface 和 MustOverride 成员;显示或隐藏过程行分隔符;打开或关闭错误纠正建议;打开或关闭引用和关键字的突出显示;正则表达式;对正则表达式着色;突出显示光标下的相关部分;报告无效正则表达式;regex;正则表达式;使用增强色;编辑器配色方案;</target>
         <note>Advanced options page keywords</note>
       </trans-unit>
diff --git a/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.zh-Hant.xlf b/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.zh-Hant.xlf
index 906a7cf8f668a..945b6da08aaee 100644
--- a/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.zh-Hant.xlf
+++ b/src/VisualStudio/VisualBasic/Impl/xlf/VSPackage.zh-Hant.xlf
@@ -18,7 +18,7 @@
         <note />
       </trans-unit>
       <trans-unit id="10160">
-        <source>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;Inheritance Margin;</source>
+        <source>Underline reassigned variables;Display inline hints;Automatic insertion of end constructs;Change pretty listing settings;Change outlining mode;Automatic insertion of Interface and MustOverride members;Show or hide procedure line separators;Turn error correction suggestions on or off;Turn highlighting of references and keywords on or off;Regex;Colorize regular expressions;Highlight related components under cursor;Report invalid regular expressions;regex;regular expression;Use enhanced colors;Editor Color Scheme;Inheritance Margin;Import Directives;</source>
         <target state="needs-review-translation">顯示內嵌提示;自動插入 End 建構;變更美化列表設定;變更大綱模式;自動插入 Interface 和 MustOverride 成員;顯示或隱藏程序行分隔符號;開啟或關閉錯誤修正建議;開啟或關閉參考及關鍵字的醒目提示;Regex;為規則運算式著色;醒目提示游標下的相關元件;回報無效的規則運算式;regex;規則運算式;使用進階色彩;編輯器色彩配置;</target>
         <note>Advanced options page keywords</note>
       </trans-unit>
diff --git a/src/VisualStudio/Xaml/Impl/Features/Definitions/XamlSourceDefinition.cs b/src/VisualStudio/Xaml/Impl/Features/Definitions/XamlSourceDefinition.cs
index c472acc05fb95..bb4b78a7dda5e 100644
--- a/src/VisualStudio/Xaml/Impl/Features/Definitions/XamlSourceDefinition.cs
+++ b/src/VisualStudio/Xaml/Impl/Features/Definitions/XamlSourceDefinition.cs
@@ -2,56 +2,35 @@
 // 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 Microsoft.CodeAnalysis.Text;
 
 namespace Microsoft.VisualStudio.LanguageServices.Xaml.Features.Definitions
 {
     /// <summary>
     /// XamlDefinition with file path and TextSpan or line and column.
+    /// When XamlSourceDefinition was created, the creator may have had a textSpan or line/column.
+    /// We should either use Span or Line Column.
     /// </summary>
     internal sealed class XamlSourceDefinition : XamlDefinition
     {
-        private readonly TextSpan? _span;
-        private readonly int _line, _column;
-
         public XamlSourceDefinition(string filePath, TextSpan span)
         {
             FilePath = filePath;
-            _span = span;
+            Span = span;
         }
 
         public XamlSourceDefinition(string filePath, int line, int column)
         {
             FilePath = filePath;
-            _line = line;
-            _column = column;
+            Line = line;
+            Column = column;
         }
 
         public string FilePath { get; }
 
-        /// <summary>
-        /// When XamlSourceDefinition was created, the creator may have had a textSpan or line/column.
-        /// We should either use _span or _line _column. This property will tell you which one to use.
-        /// </summary>
-        private bool CanUseSpan => _span != null;
-
-        public TextSpan? GetTextSpan(SourceText text)
-        {
-            if (CanUseSpan)
-            {
-                return _span;
-            }
+        public int Line { get; }
+        public int Column { get; }
 
-            // Convert the line column to TextSpan
-            if (_line < text.Lines.Count)
-            {
-                var column = Math.Min(_column, text.Lines[_line].Span.Length);
-                var start = text.Lines.GetPosition(new LinePosition(_line, column));
-                return new TextSpan(start, 0);
-            }
-
-            return null;
-        }
+        public TextSpan? Span { get; }
     }
 }
diff --git a/src/VisualStudio/Xaml/Impl/Implementation/LanguageClient/XamlCapabilities.cs b/src/VisualStudio/Xaml/Impl/Implementation/LanguageClient/XamlCapabilities.cs
index 063780444944a..b03d34482da22 100644
--- a/src/VisualStudio/Xaml/Impl/Implementation/LanguageClient/XamlCapabilities.cs
+++ b/src/VisualStudio/Xaml/Impl/Implementation/LanguageClient/XamlCapabilities.cs
@@ -27,8 +27,8 @@ internal static class XamlCapabilities
             FoldingRangeProvider = new FoldingRangeOptions { },
             DocumentFormattingProvider = true,
             DocumentRangeFormattingProvider = true,
-            DocumentOnTypeFormattingProvider = new DocumentOnTypeFormattingOptions { FirstTriggerCharacter = ">", MoreTriggerCharacter = new string[] { "\n" } },
-            OnAutoInsertProvider = new VSInternalDocumentOnAutoInsertOptions { TriggerCharacters = new[] { "=", "/", ">" } },
+            DocumentOnTypeFormattingProvider = new DocumentOnTypeFormattingOptions { FirstTriggerCharacter = ">" },
+            OnAutoInsertProvider = new VSInternalDocumentOnAutoInsertOptions { TriggerCharacters = new[] { "=", "/" } },
             TextDocumentSync = new TextDocumentSyncOptions
             {
                 Change = TextDocumentSyncKind.None,
diff --git a/src/VisualStudio/Xaml/Impl/Implementation/LanguageServer/Handler/Definitions/GoToDefinitionHandler.cs b/src/VisualStudio/Xaml/Impl/Implementation/LanguageServer/Handler/Definitions/GoToDefinitionHandler.cs
index c574b80b0e90b..c69865a6f7fec 100644
--- a/src/VisualStudio/Xaml/Impl/Implementation/LanguageServer/Handler/Definitions/GoToDefinitionHandler.cs
+++ b/src/VisualStudio/Xaml/Impl/Implementation/LanguageServer/Handler/Definitions/GoToDefinitionHandler.cs
@@ -108,38 +108,42 @@ public GoToDefinitionHandler(IMetadataAsSourceFileService metadataAsSourceFileSe
         {
             Contract.ThrowIfNull(sourceDefinition.FilePath);
 
-            var document = context.Solution?.GetDocuments(ProtocolConversions.GetUriFromFilePath(sourceDefinition.FilePath)).FirstOrDefault();
-            if (document != null)
+            if (sourceDefinition.Span != null)
             {
-                var sourceText = await document.GetTextAsync(cancellationToken).ConfigureAwait(false);
-                var span = sourceDefinition.GetTextSpan(sourceText);
-                if (span != null)
+                // If the Span is not null, use the span.
+                var document = context.Solution?.GetDocuments(ProtocolConversions.GetUriFromFilePath(sourceDefinition.FilePath)).FirstOrDefault();
+                if (document != null)
                 {
                     return await ProtocolConversions.TextSpanToLocationAsync(
                                                 document,
-                                                span.Value,
+                                                sourceDefinition.Span.Value,
                                                 isStale: false,
                                                 cancellationToken).ConfigureAwait(false);
                 }
-            }
-            else
-            {
-                // Cannot find the file in solution. This is probably a file lives outside of the solution like generic.xaml
-                // which lives in the Windows SDK folder. Try getting the SourceText from the file path.
-                using var fileStream = new FileStream(sourceDefinition.FilePath, FileMode.Open, FileAccess.Read);
-                var sourceText = SourceText.From(fileStream);
-                var span = sourceDefinition.GetTextSpan(sourceText);
-                if (span != null)
+                else
                 {
+                    // Cannot find the file in solution. This is probably a file lives outside of the solution like generic.xaml
+                    // which lives in the Windows SDK folder. Try getting the SourceText from the file path.
+                    using var fileStream = new FileStream(sourceDefinition.FilePath, FileMode.Open, FileAccess.Read);
+                    var sourceText = SourceText.From(fileStream);
                     return new LSP.Location
                     {
                         Uri = new Uri(sourceDefinition.FilePath),
-                        Range = ProtocolConversions.TextSpanToRange(span.Value, sourceText),
+                        Range = ProtocolConversions.TextSpanToRange(sourceDefinition.Span.Value, sourceText)
                     };
                 }
             }
+            else
+            {
+                // We should have the line and column, so use them to build the LSP Range.
+                var position = new Position(sourceDefinition.Line, sourceDefinition.Column);
 
-            return null;
+                return new LSP.Location
+                {
+                    Uri = new Uri(sourceDefinition.FilePath),
+                    Range = new LSP.Range() { Start = position, End = position }
+                };
+            }
         }
 
         private static async Task<LSP.Location[]> GetSymbolDefinitionLocationsAsync(XamlSymbolDefinition symbolDefinition, RequestContext context, IMetadataAsSourceFileService metadataAsSourceFileService, CancellationToken cancellationToken)
diff --git a/src/Workspaces/Core/Portable/Shared/Extensions/DocumentExtensions.cs b/src/Workspaces/Core/Portable/Shared/Extensions/DocumentExtensions.cs
index 7db39792c50f6..9042957444581 100644
--- a/src/Workspaces/Core/Portable/Shared/Extensions/DocumentExtensions.cs
+++ b/src/Workspaces/Core/Portable/Shared/Extensions/DocumentExtensions.cs
@@ -30,7 +30,7 @@ public static async ValueTask<SyntaxTreeIndex> GetSyntaxTreeIndexAsync(this Docu
         /// Returns the semantic model for this document that may be produced from partial semantics. The semantic model
         /// is only guaranteed to contain the syntax tree for <paramref name="document"/> and nothing else.
         /// </summary>
-        public static async Task<SemanticModel?> GetPartialSemanticModelAsync(this Document document, CancellationToken cancellationToken)
+        public static async Task<(Document document, SemanticModel? semanticModel)> GetPartialSemanticModelAsync(this Document document, CancellationToken cancellationToken)
         {
             if (document.Project.TryGetCompilation(out var compilation))
             {
@@ -39,12 +39,12 @@ public static async ValueTask<SyntaxTreeIndex> GetSyntaxTreeIndexAsync(this Docu
 
                 // Make sure the compilation is kept alive so that GetSemanticModelAsync() doesn't become expensive
                 GC.KeepAlive(compilation);
-                return semanticModel;
+                return (document, semanticModel);
             }
             else
             {
                 var frozenDocument = document.WithFrozenPartialSemantics(cancellationToken);
-                return await frozenDocument.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
+                return (frozenDocument, await frozenDocument.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false));
             }
         }
 
diff --git a/src/Workspaces/Core/Portable/Shared/TestHooks/FeatureAttribute.cs b/src/Workspaces/Core/Portable/Shared/TestHooks/FeatureAttribute.cs
index 5e6378a3700d7..ba1135e86bffd 100644
--- a/src/Workspaces/Core/Portable/Shared/TestHooks/FeatureAttribute.cs
+++ b/src/Workspaces/Core/Portable/Shared/TestHooks/FeatureAttribute.cs
@@ -25,9 +25,10 @@ internal static class FeatureAttribute
         public const string GraphProvider = nameof(GraphProvider);
         public const string InfoBar = nameof(InfoBar);
         public const string InheritanceMargin = nameof(InheritanceMargin);
-        public const string InlineParameterNameHints = nameof(InlineParameterNameHints);
+        public const string InlineHints = nameof(InlineHints);
         public const string InteractiveEvaluator = nameof(InteractiveEvaluator);
         public const string KeywordHighlighting = nameof(KeywordHighlighting);
+        public const string LibraryManager = nameof(LibraryManager);
         public const string LightBulb = nameof(LightBulb);
         public const string LineSeparators = nameof(LineSeparators);
         public const string NavigableSymbols = nameof(NavigableSymbols);
@@ -36,6 +37,7 @@ internal static class FeatureAttribute
         public const string Outlining = nameof(Outlining);
         public const string PackageInstaller = nameof(PackageInstaller);
         public const string PersistentStorage = nameof(PersistentStorage);
+        public const string QuickInfo = nameof(QuickInfo);
         public const string ReferenceHighlighting = nameof(ReferenceHighlighting);
         public const string Rename = nameof(Rename);
         public const string RenameTracking = nameof(RenameTracking);
diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/BranchId.cs b/src/Workspaces/Core/Portable/Workspace/Solution/BranchId.cs
index 6f04d4623b262..63f8970e5b9b6 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/BranchId.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/BranchId.cs
@@ -2,8 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-#nullable disable
-
+using System.Diagnostics;
 using System.Threading;
 
 namespace Microsoft.CodeAnalysis
@@ -11,6 +10,7 @@ namespace Microsoft.CodeAnalysis
     /// <summary>
     /// solution branch Id
     /// </summary>
+    [DebuggerDisplay("{_id}")]
     internal class BranchId
     {
         private static int s_nextId;
diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/Document.cs b/src/Workspaces/Core/Portable/Workspace/Solution/Document.cs
index d18412e3f4bd7..36e124ca40c92 100644
--- a/src/Workspaces/Core/Portable/Workspace/Solution/Document.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Solution/Document.cs
@@ -447,13 +447,11 @@ internal virtual Document WithFrozenPartialSemantics(CancellationToken cancellat
             var solution = this.Project.Solution;
             var workspace = solution.Workspace;
 
-            // only produce doc with frozen semantics if this document is part of the workspace's
-            // primary branch and there is actual background compilation going on, since w/o
+            // only produce doc with frozen semantics if this workspace has support for that, as without
             // background compilation the semantics won't be moving toward completeness.  Also,
             // ensure that the project that this document is part of actually supports compilations,
             // as partial semantics don't make sense otherwise.
-            if (solution.BranchId == workspace.PrimaryBranchId &&
-                workspace.PartialSemanticsEnabled &&
+            if (workspace.PartialSemanticsEnabled &&
                 this.Project.SupportsCompilation)
             {
                 var newSolution = this.Project.Solution.WithFrozenPartialCompilationIncludingSpecificDocument(this.Id, cancellationToken);
diff --git a/src/Workspaces/CoreTest/SolutionTests/SolutionTestHelpers.cs b/src/Workspaces/CoreTest/SolutionTests/SolutionTestHelpers.cs
index 4268b5f07bc65..f45898746fc88 100644
--- a/src/Workspaces/CoreTest/SolutionTests/SolutionTestHelpers.cs
+++ b/src/Workspaces/CoreTest/SolutionTests/SolutionTestHelpers.cs
@@ -32,6 +32,18 @@ public static Workspace CreateWorkspaceWithRecoverableSyntaxTreesAndWeakCompilat
             return workspace;
         }
 
+        public static Workspace CreateWorkspaceWithPartalSemantics(Type[]? additionalParts = null)
+            => new WorkspaceWithPartialSemantics(FeaturesTestCompositions.Features.AddParts(additionalParts).GetHostServices());
+
+        private class WorkspaceWithPartialSemantics : Workspace
+        {
+            public WorkspaceWithPartialSemantics(HostServices hostServices) : base(hostServices, workspaceKind: nameof(WorkspaceWithPartialSemantics))
+            {
+            }
+
+            protected internal override bool PartialSemanticsEnabled => true;
+        }
+
         public static Project AddEmptyProject(Solution solution, string languageName = LanguageNames.CSharp)
         {
             var id = ProjectId.CreateNewId();
@@ -106,7 +118,5 @@ public static void TestListProperty<T, TValue>(T instance, Func<T, IEnumerable<T
                 Assert.Throws<ArgumentException>(() => factory(instanceWithNoItem, new TValue[] { item, item }));
             }
         }
-
-#nullable enable
     }
 }
diff --git a/src/Workspaces/CoreTest/SolutionTests/SolutionTests.cs b/src/Workspaces/CoreTest/SolutionTests/SolutionTests.cs
index 5978c4fc4b511..6defbd22ea7da 100644
--- a/src/Workspaces/CoreTest/SolutionTests/SolutionTests.cs
+++ b/src/Workspaces/CoreTest/SolutionTests/SolutionTests.cs
@@ -2566,6 +2566,31 @@ public void TestProjectWithBrokenCrossLanguageReferenceHasIncompleteReferences()
             Assert.Empty(project2.GetCompilationAsync().Result.ExternalReferences);
         }
 
+        [Fact]
+        public async Task TestFrozenPartialProjectHasDifferentSemanticVersions()
+        {
+            using var workspace = CreateWorkspaceWithPartalSemantics();
+            var project = workspace.CurrentSolution.AddProject("CSharpProject", "CSharpProject", LanguageNames.CSharp);
+            project = project.AddDocument("Extra.cs", SourceText.From("class Extra { }")).Project;
+
+            var documentToFreeze = project.AddDocument("DocumentToFreeze.cs", SourceText.From(""));
+            var frozenDocument = documentToFreeze.WithFrozenPartialSemantics(CancellationToken.None);
+
+            // Because we had no compilation produced yet, we expect that only the DocumentToFreeze is in the compilation
+            Assert.NotSame(frozenDocument, documentToFreeze);
+            var tree = Assert.Single((await frozenDocument.Project.GetCompilationAsync()).SyntaxTrees);
+            Assert.Equal("DocumentToFreeze.cs", tree.FilePath);
+
+            // Versions should be different
+            Assert.NotEqual(
+                await documentToFreeze.Project.GetDependentSemanticVersionAsync(),
+                await frozenDocument.Project.GetDependentSemanticVersionAsync());
+
+            Assert.NotEqual(
+                await documentToFreeze.Project.GetSemanticVersionAsync(),
+                await frozenDocument.Project.GetSemanticVersionAsync());
+        }
+
         [Fact]
         public void TestFrozenPartialProjectAlwaysIsIncomplete()
         {
diff --git a/src/Workspaces/CoreTest/SolutionTests/SolutionWithSourceGeneratorTests.cs b/src/Workspaces/CoreTest/SolutionTests/SolutionWithSourceGeneratorTests.cs
index a268cc0ba6e43..4b37f8c774ced 100644
--- a/src/Workspaces/CoreTest/SolutionTests/SolutionWithSourceGeneratorTests.cs
+++ b/src/Workspaces/CoreTest/SolutionTests/SolutionWithSourceGeneratorTests.cs
@@ -166,7 +166,7 @@ static async Task AssertCompilationContainsGeneratedFile(Project project, string
         [Fact]
         public async Task PartialCompilationsIncludeGeneratedFilesAfterFullGeneration()
         {
-            using var workspace = CreateWorkspace();
+            using var workspace = CreateWorkspaceWithPartalSemantics();
             var analyzerReference = new TestGeneratorReference(new GenerateFileForEachAdditionalFileWithContentsCommented());
             var project = WithPreviewLanguageVersion(AddEmptyProject(workspace.CurrentSolution))
                 .AddAnalyzerReference(analyzerReference)
@@ -178,6 +178,7 @@ public async Task PartialCompilationsIncludeGeneratedFilesAfterFullGeneration()
             Assert.Equal(2, fullCompilation.SyntaxTrees.Count());
 
             var partialProject = project.Documents.Single().WithFrozenPartialSemantics(CancellationToken.None).Project;
+            Assert.NotSame(partialProject, project);
             var partialCompilation = await partialProject.GetRequiredCompilationAsync(CancellationToken.None);
 
             Assert.Same(fullCompilation, partialCompilation);
@@ -301,7 +302,7 @@ public async Task GetDocumentWithGeneratedTreeReturnsGeneratedDocument()
         [Fact]
         public async Task GetDocumentWithGeneratedTreeForInProgressReturnsGeneratedDocument()
         {
-            using var workspace = CreateWorkspace();
+            using var workspace = CreateWorkspaceWithPartalSemantics();
             var analyzerReference = new TestGeneratorReference(new GenerateFileForEachAdditionalFileWithContentsCommented());
             var project = WithPreviewLanguageVersion(AddEmptyProject(workspace.CurrentSolution))
                 .AddAnalyzerReference(analyzerReference)
@@ -555,5 +556,38 @@ public async Task OpenSourceGeneratedDocumentsUpdateIsDocumentOpenAndCloseWorks(
             Assert.False(workspace.IsDocumentOpen(generatedDocumentIdentity.DocumentId));
             Assert.Null(differentOpenTextContainer.CurrentText.GetOpenDocumentInCurrentContextWithChanges());
         }
+
+        [Theory, CombinatorialData]
+        public async Task FreezingSolutionEnsuresGeneratorsDoNotRun(bool forkBeforeFreeze)
+        {
+            var generatorRan = false;
+            var generator = new CallbackGenerator(onInit: _ => { }, onExecute: _ => { generatorRan = true; });
+
+            using var workspace = CreateWorkspaceWithPartalSemantics();
+            var analyzerReference = new TestGeneratorReference(generator);
+            var project = AddEmptyProject(workspace.CurrentSolution)
+                .AddAnalyzerReference(analyzerReference)
+                .AddDocument("RegularDocument.cs", "// Source File", filePath: "RegularDocument.cs").Project;
+
+            Assert.True(workspace.SetCurrentSolution(_ => project.Solution, WorkspaceChangeKind.SolutionChanged));
+
+            var documentToFreeze = workspace.CurrentSolution.Projects.Single().Documents.Single();
+
+            // The generator shouldn't have ran before any of this since we didn't do anything that would ask for a compilation
+            Assert.False(generatorRan);
+
+            if (forkBeforeFreeze)
+            {
+                // Forking before freezing means we'll have to do extra work to produce the final compilation, but we should still
+                // not be running generators
+                documentToFreeze = documentToFreeze.WithText(SourceText.From("// Changed Source File"));
+            }
+
+            var frozenDocument = documentToFreeze.WithFrozenPartialSemantics(CancellationToken.None);
+            Assert.NotSame(frozenDocument, documentToFreeze);
+            await frozenDocument.GetSemanticModelAsync(CancellationToken.None);
+
+            Assert.False(generatorRan);
+        }
     }
 }
diff --git a/src/Workspaces/Remote/ServiceHub/Services/ExtensionMethodImportCompletion/RemoteExtensionMethodImportCompletionService.cs b/src/Workspaces/Remote/ServiceHub/Services/ExtensionMethodImportCompletion/RemoteExtensionMethodImportCompletionService.cs
index a19655a666538..7a48f8ea17cda 100644
--- a/src/Workspaces/Remote/ServiceHub/Services/ExtensionMethodImportCompletion/RemoteExtensionMethodImportCompletionService.cs
+++ b/src/Workspaces/Remote/ServiceHub/Services/ExtensionMethodImportCompletion/RemoteExtensionMethodImportCompletionService.cs
@@ -61,5 +61,15 @@ public ValueTask<SerializableUnimportedExtensionMethods> GetUnimportedExtensionM
                 return new SerializableUnimportedExtensionMethods(ImmutableArray<SerializableImportCompletionItem>.Empty, isPartialResult: false, getSymbolsTicks: 0, createItemsTicks: 0);
             }, cancellationToken);
         }
+
+        public ValueTask WarmUpCacheAsync(PinnedSolutionInfo solutionInfo, DocumentId documentId, CancellationToken cancellationToken)
+        {
+            return RunServiceAsync(async cancellationToken =>
+            {
+                var solution = await GetSolutionAsync(solutionInfo, cancellationToken).ConfigureAwait(false);
+                var document = solution.GetRequiredDocument(documentId);
+                await ExtensionMethodImportCompletionHelper.WarmUpCacheInCurrentProcessAsync(document, cancellationToken).ConfigureAwait(false);
+            }, cancellationToken);
+        }
     }
 }
diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Collections/SimpleIntervalTree`2.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Collections/SimpleIntervalTree`2.cs
index 7097a1ba7b9dc..f0926b7878de6 100644
--- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Collections/SimpleIntervalTree`2.cs
+++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Collections/SimpleIntervalTree`2.cs
@@ -37,6 +37,12 @@ public void AddIntervalInPlace(T value)
             this.root = Insert(root, newNode, in Introspector);
         }
 
+        /// <summary>
+        /// Warning.  Mutates the tree in place.
+        /// </summary>
+        public void ClearInPlace()
+            => this.root = null;
+
         public ImmutableArray<T> GetIntervalsThatOverlapWith(int start, int length)
             => GetIntervalsThatOverlapWith(start, length, in _introspector);