diff --git a/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml b/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml
index 86e5bc1451224..fad4b595c41ca 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml
+++ b/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml
@@ -727,7 +727,7 @@
   <!-- Instrumentation info attached to BoundBlock -->
   <Node Name="BoundBlockInstrumentation" Base="BoundNode">
     <!-- Local variables with scope that cover the entire block including the instrumentation prologue and epilogue. -->
-    <Field Name="Locals" Type="OneOrMany&lt;LocalSymbol&gt;" Null="disallow"/>
+    <Field Name="Locals" Type="ImmutableArray&lt;LocalSymbol&gt;" Null="disallow"/>
     <!-- Optional prologue emitted in front of any instructions of the block, so that it always executes. -->
     <Field Name="Prologue" Type="BoundStatement?" Null="allow"/>
     <!--
diff --git a/src/Compilers/CSharp/Portable/CodeGen/EmitExpression.cs b/src/Compilers/CSharp/Portable/CodeGen/EmitExpression.cs
index 127509552c312..0dac511a539c5 100644
--- a/src/Compilers/CSharp/Portable/CodeGen/EmitExpression.cs
+++ b/src/Compilers/CSharp/Portable/CodeGen/EmitExpression.cs
@@ -3593,7 +3593,7 @@ private void EmitParameterIdExpression(BoundParameterId node)
 
             if (node.HoistedField is null)
             {
-                _builder.EmitIntConstant(node.Parameter.Ordinal); // Tracked by https://github.com/dotnet/roslyn/issues/78963 : Follow up
+                _builder.EmitIntConstant(node.Parameter.Ordinal);
             }
             else
             {
diff --git a/src/Compilers/CSharp/Portable/FlowAnalysis/DefiniteAssignment.cs b/src/Compilers/CSharp/Portable/FlowAnalysis/DefiniteAssignment.cs
index 9a0abb4afede5..e6e11d2093ab0 100644
--- a/src/Compilers/CSharp/Portable/FlowAnalysis/DefiniteAssignment.cs
+++ b/src/Compilers/CSharp/Portable/FlowAnalysis/DefiniteAssignment.cs
@@ -2305,14 +2305,6 @@ private void DeclareVariables(ImmutableArray<LocalSymbol> locals)
             }
         }
 
-        private void DeclareVariables(OneOrMany<LocalSymbol> locals)
-        {
-            foreach (var symbol in locals)
-            {
-                DeclareVariable(symbol);
-            }
-        }
-
         private void DeclareVariable(LocalSymbol symbol)
         {
             var initiallyAssigned =
diff --git a/src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs b/src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs
index 2a470a46ea216..f32c6317e930f 100644
--- a/src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs
+++ b/src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs
@@ -6660,14 +6660,15 @@ static ImmutableArray<ParameterSymbol> getParameters(ImmutableArray<ParameterSym
             }
         }
 
-        private static ImmutableArray<RefKind> GetArgumentRefKinds(ImmutableArray<RefKind> argumentRefKindsOpt, bool isNewExtension,
+        internal static ImmutableArray<RefKind> GetArgumentRefKinds(ImmutableArray<RefKind> argumentRefKindsOpt, bool adjustForNewExtension,
             MethodSymbol method, int argumentCount)
         {
-            if (!isNewExtension)
+            if (!adjustForNewExtension)
             {
                 return argumentRefKindsOpt;
             }
 
+            Debug.Assert(method.GetIsNewExtensionMember());
             RefKind receiverRefKind = GetExtensionReceiverRefKind(method);
 
             if (argumentRefKindsOpt.IsDefault)
diff --git a/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs b/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs
index eeec7d5d47a64..0094469cbef5c 100644
--- a/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs
+++ b/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs
@@ -2248,7 +2248,7 @@ public BoundTypeOfOperator Update(BoundTypeExpression sourceType, MethodSymbol?
 
     internal sealed partial class BoundBlockInstrumentation : BoundNode
     {
-        public BoundBlockInstrumentation(SyntaxNode syntax, OneOrMany<LocalSymbol> locals, BoundStatement? prologue, BoundStatement? epilogue, bool hasErrors = false)
+        public BoundBlockInstrumentation(SyntaxNode syntax, ImmutableArray<LocalSymbol> locals, BoundStatement? prologue, BoundStatement? epilogue, bool hasErrors = false)
             : base(BoundKind.BlockInstrumentation, syntax, hasErrors || prologue.HasErrors() || epilogue.HasErrors())
         {
 
@@ -2259,16 +2259,16 @@ public BoundBlockInstrumentation(SyntaxNode syntax, OneOrMany<LocalSymbol> local
             this.Epilogue = epilogue;
         }
 
-        public OneOrMany<LocalSymbol> Locals { get; }
+        public ImmutableArray<LocalSymbol> Locals { get; }
         public BoundStatement? Prologue { get; }
         public BoundStatement? Epilogue { get; }
 
         [DebuggerStepThrough]
         public override BoundNode? Accept(BoundTreeVisitor visitor) => visitor.VisitBlockInstrumentation(this);
 
-        public BoundBlockInstrumentation Update(OneOrMany<LocalSymbol> locals, BoundStatement? prologue, BoundStatement? epilogue)
+        public BoundBlockInstrumentation Update(ImmutableArray<LocalSymbol> locals, BoundStatement? prologue, BoundStatement? epilogue)
         {
-            if (!locals.SequenceEqual(Locals) || prologue != this.Prologue || epilogue != this.Epilogue)
+            if (locals != this.Locals || prologue != this.Prologue || epilogue != this.Epilogue)
             {
                 var result = new BoundBlockInstrumentation(this.Syntax, locals, prologue, epilogue, this.HasErrors);
                 result.CopyAttributes(this);
@@ -11190,9 +11190,10 @@ internal abstract partial class BoundTreeRewriter : BoundTreeVisitor
         }
         public override BoundNode? VisitBlockInstrumentation(BoundBlockInstrumentation node)
         {
+            ImmutableArray<LocalSymbol> locals = this.VisitLocals(node.Locals);
             BoundStatement? prologue = (BoundStatement?)this.Visit(node.Prologue);
             BoundStatement? epilogue = (BoundStatement?)this.Visit(node.Epilogue);
-            return node.Update(node.Locals, prologue, epilogue);
+            return node.Update(locals, prologue, epilogue);
         }
         public override BoundNode? VisitMethodDefIndex(BoundMethodDefIndex node)
         {
@@ -13146,6 +13147,14 @@ public NullabilityRewriter(ImmutableDictionary<BoundExpression, (NullabilityInfo
             return updatedNode;
         }
 
+        public override BoundNode? VisitBlockInstrumentation(BoundBlockInstrumentation node)
+        {
+            ImmutableArray<LocalSymbol> locals = GetUpdatedArray(node, node.Locals);
+            BoundStatement? prologue = (BoundStatement?)this.Visit(node.Prologue);
+            BoundStatement? epilogue = (BoundStatement?)this.Visit(node.Epilogue);
+            return node.Update(locals, prologue, epilogue);
+        }
+
         public override BoundNode? VisitMethodDefIndex(BoundMethodDefIndex node)
         {
             MethodSymbol method = GetUpdatedSymbol(node, node.Method);
diff --git a/src/Compilers/CSharp/Portable/Lowering/ExtensionMethodBodyRewriter.cs b/src/Compilers/CSharp/Portable/Lowering/ExtensionMethodBodyRewriter.cs
index d2c8f6b6dccf1..61c5f3ed28e30 100644
--- a/src/Compilers/CSharp/Portable/Lowering/ExtensionMethodBodyRewriter.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/ExtensionMethodBodyRewriter.cs
@@ -17,8 +17,6 @@ namespace Microsoft.CodeAnalysis.CSharp
     /// </summary>
     internal sealed class ExtensionMethodBodyRewriter : BoundTreeToDifferentEnclosingContextRewriter
     {
-        private readonly SourceExtensionImplementationMethodSymbol _implementationMethod;
-
         /// <summary>
         /// Maps parameters and local functions from original enclosing context to corresponding rewritten symbols for rewritten context.
         /// </summary>
@@ -37,7 +35,6 @@ public ExtensionMethodBodyRewriter(MethodSymbol sourceMethod, SourceExtensionImp
             Debug.Assert(implementationMethod is not null);
             Debug.Assert(sourceMethod == (object)implementationMethod.UnderlyingMethod);
 
-            _implementationMethod = implementationMethod;
             _symbolMap = ImmutableDictionary<Symbol, Symbol>.Empty.WithComparers(ReferenceEqualityComparer.Instance, ReferenceEqualityComparer.Instance);
 
             bool haveExtraParameter = sourceMethod.ParameterCount != implementationMethod.ParameterCount;
@@ -97,6 +94,10 @@ public override ParameterSymbol VisitParameterSymbol(ParameterSymbol symbol)
             var rewritten = new RewrittenLambdaOrLocalFunctionSymbol(node.Symbol, _rewrittenContainingMethod);
 
             var savedState = EnterMethod(node.Symbol, rewritten);
+
+            // BoundMethodDefIndex in instrumentation will refer to the lambda method symbol, so we need to map it.
+            _symbolMap = _symbolMap.Add(node.Symbol, rewritten);
+
             BoundBlock body = (BoundBlock)this.Visit(node.Body);
             (_rewrittenContainingMethod, _symbolMap) = savedState;
 
@@ -150,7 +151,7 @@ protected override ImmutableArray<MethodSymbol> VisitDeclaredLocalFunctions(Immu
             switch (symbol?.MethodKind)
             {
                 case MethodKind.LambdaMethod:
-                    throw ExceptionUtilities.Unreachable();
+                    return (MethodSymbol)_symbolMap[symbol];
 
                 case MethodKind.LocalFunction:
                     if (symbol.IsDefinition)
@@ -208,5 +209,10 @@ public override BoundNode VisitUnaryOperator(BoundUnaryOperator node)
         {
             return ExtensionMethodReferenceRewriter.VisitBinaryOperatorData(this, node);
         }
+
+        public override BoundNode? VisitMethodDefIndex(BoundMethodDefIndex node)
+        {
+            return ExtensionMethodReferenceRewriter.VisitMethodDefIndex(this, node);
+        }
     }
 }
diff --git a/src/Compilers/CSharp/Portable/Lowering/ExtensionMethodReferenceRewriter.cs b/src/Compilers/CSharp/Portable/Lowering/ExtensionMethodReferenceRewriter.cs
index c06bd5efc479c..7b3b60f4c5625 100644
--- a/src/Compilers/CSharp/Portable/Lowering/ExtensionMethodReferenceRewriter.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/ExtensionMethodReferenceRewriter.cs
@@ -194,9 +194,13 @@ method.OriginalDefinition is ErrorMethodSymbol ||
 
         public override BoundNode? VisitMethodDefIndex(BoundMethodDefIndex node)
         {
-            MethodSymbol method = node.Method;
-            Debug.Assert(method.IsDefinition); // Tracked by https://github.com/dotnet/roslyn/issues/78962 : From the code coverage and other instrumentations perspective, should we remap the index to the implementation symbol? 
-            TypeSymbol? type = this.VisitType(node.Type);
+            return VisitMethodDefIndex(this, node);
+        }
+
+        public static BoundNode VisitMethodDefIndex(BoundTreeRewriter rewriter, BoundMethodDefIndex node)
+        {
+            MethodSymbol method = VisitMethodSymbolWithExtensionRewrite(rewriter, node.Method);
+            TypeSymbol? type = rewriter.VisitType(node.Type);
             return node.Update(method, type);
         }
 
diff --git a/src/Compilers/CSharp/Portable/Lowering/Instrumentation/LocalStateTracingInstrumenter.cs b/src/Compilers/CSharp/Portable/Lowering/Instrumentation/LocalStateTracingInstrumenter.cs
index 3062aac04cda0..05a639756fe73 100644
--- a/src/Compilers/CSharp/Portable/Lowering/Instrumentation/LocalStateTracingInstrumenter.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/Instrumentation/LocalStateTracingInstrumenter.cs
@@ -302,7 +302,7 @@ public override void InstrumentBlock(BoundBlock original, LocalRewriter rewriter
 
             var prologueBuilder = ArrayBuilder<BoundStatement>.GetInstance(_factory.CurrentFunction.ParameterCount);
 
-            foreach (var parameter in _factory.CurrentFunction.Parameters)
+            foreach (var parameter in _factory.CurrentFunction.GetParametersIncludingExtensionParameter(skipExtensionIfStatic: true))
             {
                 if (parameter.RefKind == RefKind.Out || parameter.IsDiscard)
                 {
@@ -312,8 +312,12 @@ public override void InstrumentBlock(BoundBlock original, LocalRewriter rewriter
                 var parameterLogger = GetLocalOrParameterStoreLogger(parameter.Type, parameter, refAssignmentSourceIsLocal: null, _factory.Syntax);
                 if (parameterLogger != null)
                 {
+                    int ordinal = parameter.ContainingSymbol.GetIsNewExtensionMember()
+                        ? SourceExtensionImplementationMethodSymbol.GetImplementationParameterOrdinal(parameter)
+                        : parameter.Ordinal;
+
                     prologueBuilder.Add(_factory.ExpressionStatement(_factory.Call(receiver: _factory.Local(_scope.ContextVariable), parameterLogger,
-                        MakeStoreLoggerArguments(parameterLogger.Parameters[0], parameter, parameter.Type, _factory.Parameter(parameter), refAssignmentSourceIndex: null, _factory.Literal((ushort)parameter.Ordinal)))));
+                        MakeStoreLoggerArguments(parameterLogger.Parameters[0], parameter, parameter.Type, _factory.Parameter(parameter), refAssignmentSourceIndex: null, _factory.Literal((ushort)ordinal)))));
                 }
             }
 
@@ -440,6 +444,7 @@ private ImmutableArray<BoundExpression> MakeStoreLoggerArguments(
             BoundExpression? refAssignmentSourceIndex,
             BoundExpression index)
         {
+            Debug.Assert(index is BoundParameterId or BoundLocalId or BoundLiteral);
             if (refAssignmentSourceIndex != null)
             {
                 return ImmutableArray.Create(_factory.Sequence(new[] { value }, refAssignmentSourceIndex), index);
@@ -541,7 +546,20 @@ public override void InstrumentCatchBlock(
         }
 
         public override BoundExpression InstrumentCall(BoundCall original, BoundExpression rewritten)
-            => InstrumentCall(base.InstrumentCall(original, rewritten), original.Arguments, original.ArgumentRefKindsOpt);
+        {
+            ImmutableArray<BoundExpression> arguments = original.Arguments;
+            MethodSymbol method = original.Method;
+            bool adjustForNewExtension = method.GetIsNewExtensionMember() && !method.IsStatic;
+            ImmutableArray<RefKind> argumentRefKindsOpt = NullableWalker.GetArgumentRefKinds(original.ArgumentRefKindsOpt, adjustForNewExtension, method, arguments.Length);
+
+            if (adjustForNewExtension)
+            {
+                Debug.Assert(original.ReceiverOpt is not null);
+                arguments = [original.ReceiverOpt, .. arguments];
+            }
+
+            return InstrumentCall(base.InstrumentCall(original, rewritten), arguments, argumentRefKindsOpt);
+        }
 
         public override BoundExpression InstrumentObjectCreationExpression(BoundObjectCreationExpression original, BoundExpression rewritten)
             => InstrumentCall(base.InstrumentObjectCreationExpression(original, rewritten), original.Arguments, original.ArgumentRefKindsOpt);
@@ -572,6 +590,7 @@ private BoundExpression InstrumentCall(BoundExpression invocation, ImmutableArra
                 builder.Add(invocation);
             }
 
+            // Record outbound assignments
             for (int i = 0; i < arguments.Length; i++)
             {
                 if (refKinds[i] is not (RefKind.Ref or RefKind.Out))
diff --git a/src/Compilers/CSharp/Portable/Lowering/SyntheticBoundNodeFactory.cs b/src/Compilers/CSharp/Portable/Lowering/SyntheticBoundNodeFactory.cs
index f5b0564e0e5bc..ab1eac579b2ea 100644
--- a/src/Compilers/CSharp/Portable/Lowering/SyntheticBoundNodeFactory.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/SyntheticBoundNodeFactory.cs
@@ -522,7 +522,7 @@ public BoundBlockInstrumentation CombineInstrumentation(BoundBlockInstrumentatio
                     (epilogue != null) ? Concat(innerInstrumentation.Epilogue, epilogue) : innerInstrumentation.Epilogue)
                 : new BoundBlockInstrumentation(
                     Syntax,
-                    OneOrMany.OneOrNone(local),
+                    (local != null) ? [local] : [],
                     prologue,
                     epilogue);
         }
@@ -550,7 +550,7 @@ public BoundStatement Instrument(BoundStatement statement, BoundBlockInstrumenta
                 statements.Add(statement);
             }
 
-            return Block(instrumentation.Locals.ToImmutable(), statements.ToImmutableAndClear());
+            return Block(instrumentation.Locals, statements.ToImmutableAndClear());
         }
 
         public BoundReturnStatement Return(BoundExpression? expression = null)
diff --git a/src/Compilers/CSharp/Portable/Symbols/Extensions/SourceExtensionImplementationMethodSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Extensions/SourceExtensionImplementationMethodSymbol.cs
index e4d8d0ea5c543..09af02fa62632 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Extensions/SourceExtensionImplementationMethodSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Extensions/SourceExtensionImplementationMethodSymbol.cs
@@ -124,8 +124,6 @@ protected override ImmutableArray<ParameterSymbol> MakeParameters()
 
             if (!_originalMethod.IsStatic)
             {
-                // Tracked by https://github.com/dotnet/roslyn/issues/78962 : Need to confirm if this rewrite going to break LocalStateTracingInstrumenter
-                //            Specifically BoundParameterId, etc.   
                 parameters.Add(new ExtensionMetadataMethodParameterSymbol(this, ((SourceNamedTypeSymbol)_originalMethod.ContainingType).ExtensionParameter!));
             }
 
@@ -138,6 +136,23 @@ protected override ImmutableArray<ParameterSymbol> MakeParameters()
             return parameters.ToImmutableAndFree();
         }
 
+        internal static int GetImplementationParameterOrdinal(ParameterSymbol underlyingParameter)
+        {
+            if (underlyingParameter.ContainingSymbol is NamedTypeSymbol)
+            {
+                return 0;
+            }
+
+            var ordinal = underlyingParameter.Ordinal;
+
+            if (underlyingParameter.ContainingSymbol.IsStatic)
+            {
+                return ordinal;
+            }
+
+            return ordinal + 1;
+        }
+
         internal override bool TryGetThisParameter(out ParameterSymbol? thisParameter)
         {
             thisParameter = null;
@@ -181,19 +196,7 @@ public override int Ordinal
             {
                 get
                 {
-                    if (this._underlyingParameter.ContainingSymbol is NamedTypeSymbol)
-                    {
-                        return 0;
-                    }
-
-                    var ordinal = this._underlyingParameter.Ordinal;
-
-                    if (this._underlyingParameter.ContainingSymbol.IsStatic)
-                    {
-                        return ordinal;
-                    }
-
-                    return ordinal + 1;
+                    return GetImplementationParameterOrdinal(this._underlyingParameter);
                 }
             }
 
diff --git a/src/Compilers/CSharp/Test/Emit/Emit/DynamicAnalysis/DynamicInstrumentationTests.cs b/src/Compilers/CSharp/Test/Emit/Emit/DynamicAnalysis/DynamicInstrumentationTests.cs
index 5cce98de1e34c..7111d5c8c6819 100644
--- a/src/Compilers/CSharp/Test/Emit/Emit/DynamicAnalysis/DynamicInstrumentationTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/Emit/DynamicAnalysis/DynamicInstrumentationTests.cs
@@ -3625,8 +3625,9 @@ static void Test()
         }
 
         [Fact, CompilerTrait(CompilerFeature.Extensions)]
-        public void ExcludeFromCodeCoverageAttribute_Method_Extension()
+        public void Extension_01()
         {
+            // ExcludeFromCodeCoverage on extension method
             string source = @"
 using System;
 using System.Diagnostics.CodeAnalysis;
@@ -3652,8 +3653,9 @@ static class C
         }
 
         [Fact, CompilerTrait(CompilerFeature.Extensions)]
-        public void ExcludeFromCodeCoverageAttribute_Accessors_Extension()
+        public void Extension_02()
         {
+            // ExcludeFromCodeCoverage on extension property
             string source = @"
 using System;
 using System.Diagnostics.CodeAnalysis;
@@ -3682,6 +3684,431 @@ static class C
             AssertInstrumented(verifier, "C.set_P2");
         }
 
+        [Fact, CompilerTrait(CompilerFeature.Extensions)]
+        public void Extensions_03()
+        {
+            // instrumentation of extension method
+            var source = """
+42.M();
+Microsoft.CodeAnalysis.Runtime.Instrumentation.FlushPayload();
+
+public static class E
+{
+    extension(int i)
+    {
+        public void M()
+        {
+            System.Console.WriteLine("Test");
+        }
+    }
+}
+""" + InstrumentationHelperSource;
+
+            var checker = new CSharpInstrumentationChecker();
+            checker.Method(3, 1, snippet: "", expectBodySpan: false)
+                .True("42.M();")
+                .True("Microsoft.CodeAnalysis.Runtime.Instrumentation.FlushPayload();");
+            checker.Method(5, 1, snippet: "public void M()")
+                .True("""System.Console.WriteLine("Test");""");
+            checker.Method(7, 1)
+                .True()
+                .False()
+                .True()
+                .True()
+                .True()
+                .True()
+                .True()
+                .True()
+                .True()
+                .True()
+                .True()
+                .True()
+                .True()
+                .True()
+                .True();
+
+            var expectedOutput = @"Test
+" + checker.ExpectedOutput;
+
+            var verifier = CompileAndVerify(source, expectedOutput, options: TestOptions.ReleaseExe);
+            checker.CompleteCheck(verifier.Compilation, source);
+            verifier.VerifyDiagnostics();
+
+            verifier = CompileAndVerify(source, expectedOutput, options: TestOptions.DebugExe);
+            checker.CompleteCheck(verifier.Compilation, source);
+            verifier.VerifyDiagnostics();
+            verifier.VerifyMethodBody("E.M", """
+{
+  // Code size       72 (0x48)
+  .maxstack  5
+  .locals init (bool[] V_0)
+  // sequence point: {
+  IL_0000:  ldsfld     "bool[][] <PrivateImplementationDetails>.PayloadRoot0"
+  IL_0005:  ldtoken    "void E.M(int)"
+  IL_000a:  ldelem.ref
+  IL_000b:  stloc.0
+  IL_000c:  ldloc.0
+  IL_000d:  brtrue.s   IL_0034
+  IL_000f:  ldsfld     "System.Guid <PrivateImplementationDetails>.MVID"
+  IL_0014:  ldtoken    "void E.M(int)"
+  IL_0019:  ldtoken    Source Document 0
+  IL_001e:  ldsfld     "bool[][] <PrivateImplementationDetails>.PayloadRoot0"
+  IL_0023:  ldtoken    "void E.M(int)"
+  IL_0028:  ldelema    "bool[]"
+  IL_002d:  ldc.i4.2
+  IL_002e:  call       "bool[] Microsoft.CodeAnalysis.Runtime.Instrumentation.CreatePayload(System.Guid, int, int, ref bool[], int)"
+  IL_0033:  stloc.0
+  IL_0034:  ldloc.0
+  IL_0035:  ldc.i4.0
+  IL_0036:  ldc.i4.1
+  IL_0037:  stelem.i1
+  // sequence point: System.Console.WriteLine("Test");
+  IL_0038:  ldloc.0
+  IL_0039:  ldc.i4.1
+  IL_003a:  ldc.i4.1
+  IL_003b:  stelem.i1
+  IL_003c:  ldstr      "Test"
+  IL_0041:  call       "void System.Console.WriteLine(string)"
+  IL_0046:  nop
+  // sequence point: }
+  IL_0047:  ret
+}
+""");
+        }
+
+        [Fact, CompilerTrait(CompilerFeature.Extensions)]
+        public void Extensions_04()
+        {
+            // instrumentation of extension getter
+            var source = """
+_ = 42.P;
+Microsoft.CodeAnalysis.Runtime.Instrumentation.FlushPayload();
+
+public static class E
+{
+    extension(int i)
+    {
+        public int P
+        {
+            get
+            {
+                System.Console.WriteLine("Test");
+                return 0;
+            }
+        }
+    }
+}
+""" + InstrumentationHelperSource;
+
+            var checker = new CSharpInstrumentationChecker();
+            checker.Method(3, 1, snippet: "", expectBodySpan: false)
+                .True("_ = 42.P;")
+                .True("Microsoft.CodeAnalysis.Runtime.Instrumentation.FlushPayload();");
+            checker.Method(5, 1, snippet: "get")
+                .True("""System.Console.WriteLine("Test");""")
+                .True("return 0;");
+            checker.Method(7, 1)
+                .True()
+                .False()
+                .True()
+                .True()
+                .True()
+                .True()
+                .True()
+                .True()
+                .True()
+                .True()
+                .True()
+                .True()
+                .True()
+                .True()
+                .True();
+
+            var expectedOutput = @"Test
+" + checker.ExpectedOutput;
+
+            var verifier = CompileAndVerify(source, expectedOutput, options: TestOptions.ReleaseExe);
+            checker.CompleteCheck(verifier.Compilation, source);
+            verifier.VerifyDiagnostics();
+
+            verifier = CompileAndVerify(source, expectedOutput, options: TestOptions.DebugExe);
+            checker.CompleteCheck(verifier.Compilation, source);
+            verifier.VerifyDiagnostics();
+        }
+
+        [Fact, CompilerTrait(CompilerFeature.Extensions)]
+        public void Extensions_05()
+        {
+            // instrumentation of lambda in extension method
+            var source = """
+42.M();
+Microsoft.CodeAnalysis.Runtime.Instrumentation.FlushPayload();
+
+public static class E
+{
+    extension(int i)
+    {
+        public void M()
+        {
+            var f = () =>
+            {
+                System.Console.WriteLine("Test");
+            };
+
+            f();
+        }
+    }
+}
+""" + InstrumentationHelperSource;
+
+            var checker = new CSharpInstrumentationChecker();
+            checker.Method(3, 1, snippet: "", expectBodySpan: false)
+                .True("42.M();")
+                .True("Microsoft.CodeAnalysis.Runtime.Instrumentation.FlushPayload();");
+            checker.Method(5, 1, snippet: "public void M()")
+                .True("""System.Console.WriteLine("Test");""")
+                .True("var f = () =>")
+                .True("f();");
+            checker.Method(7, 1)
+                .True()
+                .False()
+                .True()
+                .True()
+                .True()
+                .True()
+                .True()
+                .True()
+                .True()
+                .True()
+                .True()
+                .True()
+                .True()
+                .True()
+                .True();
+
+            var expectedOutput = @"Test
+" + checker.ExpectedOutput;
+
+            var verifier = CompileAndVerify(source, expectedOutput, options: TestOptions.ReleaseExe);
+            checker.CompleteCheck(verifier.Compilation, source);
+            verifier.VerifyDiagnostics();
+
+            verifier = CompileAndVerify(source, expectedOutput, options: TestOptions.DebugExe);
+            checker.CompleteCheck(verifier.Compilation, source);
+            verifier.VerifyDiagnostics();
+        }
+
+        [Fact, CompilerTrait(CompilerFeature.Extensions)]
+        public void Extensions_06()
+        {
+            // instrumentation of local function in extension method
+            var source = """
+42.M();
+Microsoft.CodeAnalysis.Runtime.Instrumentation.FlushPayload();
+
+public static class E
+{
+    extension(int i)
+    {
+        public void M()
+        {
+            local();
+
+            static void local()
+            {
+                System.Console.WriteLine("Test");
+            }
+        }
+    }
+}
+""" + InstrumentationHelperSource;
+
+            var checker = new CSharpInstrumentationChecker();
+            checker.Method(3, 1, snippet: "", expectBodySpan: false)
+                .True("42.M();")
+                .True("Microsoft.CodeAnalysis.Runtime.Instrumentation.FlushPayload();");
+            checker.Method(5, 1, snippet: "public void M()")
+                .True("local();")
+                .True("""System.Console.WriteLine("Test");""");
+            checker.Method(8, 1)
+                .True()
+                .False()
+                .True()
+                .True()
+                .True()
+                .True()
+                .True()
+                .True()
+                .True()
+                .True()
+                .True()
+                .True()
+                .True()
+                .True()
+                .True();
+
+            var expectedOutput = @"Test
+" + checker.ExpectedOutput;
+
+            var verifier = CompileAndVerify(source, expectedOutput, options: TestOptions.ReleaseExe);
+            checker.CompleteCheck(verifier.Compilation, source);
+            verifier.VerifyDiagnostics();
+
+            verifier = CompileAndVerify(source, expectedOutput, options: TestOptions.DebugExe);
+            checker.CompleteCheck(verifier.Compilation, source);
+            verifier.VerifyDiagnostics();
+        }
+
+        [Theory, CombinatorialData, CompilerTrait(CompilerFeature.Extensions)]
+        public void Extensions_07(bool classic)
+        {
+            // instrumentation of local function in extension method, using the extension parameter
+            string classicSource = """
+42.M();
+Microsoft.CodeAnalysis.Runtime.Instrumentation.FlushPayload();
+
+public static class E
+{
+    public static void M(this int i)
+    {
+        local();
+
+        void local()
+        {
+            System.Console.WriteLine(i);
+        }
+    }
+}
+""" + InstrumentationHelperSource;
+
+            string newSource = """
+42.M();
+Microsoft.CodeAnalysis.Runtime.Instrumentation.FlushPayload();
+
+public static class E
+{
+    extension(int i)
+    {
+        public void M()
+        {
+            local();
+
+            void local()
+            {
+                System.Console.WriteLine(i);
+            }
+        }
+    }
+}
+""" + InstrumentationHelperSource;
+
+            var source = classic ? classicSource : newSource;
+
+            var checker = new CSharpInstrumentationChecker();
+            checker.Method(3, 1, snippet: "", expectBodySpan: false)
+                .True("42.M();")
+                .True("Microsoft.CodeAnalysis.Runtime.Instrumentation.FlushPayload();");
+            checker.Method(5, 1, snippet: classic ? "public static void M(this int i)" : "public void M()")
+                .True("local();")
+                .True("""System.Console.WriteLine(i);""");
+            checker.Method(8, 1)
+                .True()
+                .False()
+                .True()
+                .True()
+                .True()
+                .True()
+                .True()
+                .True()
+                .True()
+                .True()
+                .True()
+                .True()
+                .True()
+                .True()
+                .True();
+
+            var expectedOutput = @"42
+" + checker.ExpectedOutput;
+
+            var verifier = CompileAndVerify(source, expectedOutput, options: TestOptions.ReleaseExe);
+            checker.CompleteCheck(verifier.Compilation, source);
+            verifier.VerifyDiagnostics();
+
+            verifier = CompileAndVerify(source, expectedOutput, options: TestOptions.DebugExe);
+            checker.CompleteCheck(verifier.Compilation, source);
+            verifier.VerifyDiagnostics();
+
+            string index = classic ? "0" : "1";
+            verifier.VerifyMethodBody("E.M(this int)", $$"""
+{
+  // Code size      105 (0x69)
+  .maxstack  6
+  .locals init (E.<>c__DisplayClass{{index}}_0 V_0) //CS$<>8__locals0
+  // sequence point: <hidden>
+  IL_0000:  ldloca.s   V_0
+  IL_0002:  ldarg.0
+  IL_0003:  stfld      "int E.<>c__DisplayClass{{index}}_0.i"
+  // sequence point: {
+  IL_0008:  ldloca.s   V_0
+  IL_000a:  ldsfld     "bool[][] <PrivateImplementationDetails>.PayloadRoot0"
+  IL_000f:  ldtoken    "void E.M(int)"
+  IL_0014:  ldelem.ref
+  IL_0015:  stfld      "bool[] E.<>c__DisplayClass{{index}}_0.CS$InstrumentationPayload1"
+  IL_001a:  ldloc.0
+  IL_001b:  ldfld      "bool[] E.<>c__DisplayClass{{index}}_0.CS$InstrumentationPayload1"
+  IL_0020:  brtrue.s   IL_004d
+  IL_0022:  ldloca.s   V_0
+  IL_0024:  ldsfld     "System.Guid <PrivateImplementationDetails>.MVID"
+  IL_0029:  ldtoken    "void E.M(int)"
+  IL_002e:  ldtoken    Source Document 0
+  IL_0033:  ldsfld     "bool[][] <PrivateImplementationDetails>.PayloadRoot0"
+  IL_0038:  ldtoken    "void E.M(int)"
+  IL_003d:  ldelema    "bool[]"
+  IL_0042:  ldc.i4.3
+  IL_0043:  call       "bool[] Microsoft.CodeAnalysis.Runtime.Instrumentation.CreatePayload(System.Guid, int, int, ref bool[], int)"
+  IL_0048:  stfld      "bool[] E.<>c__DisplayClass{{index}}_0.CS$InstrumentationPayload1"
+  IL_004d:  ldloc.0
+  IL_004e:  ldfld      "bool[] E.<>c__DisplayClass{{index}}_0.CS$InstrumentationPayload1"
+  IL_0053:  ldc.i4.0
+  IL_0054:  ldc.i4.1
+  IL_0055:  stelem.i1
+  // sequence point: local();
+  IL_0056:  ldloc.0
+  IL_0057:  ldfld      "bool[] E.<>c__DisplayClass{{index}}_0.CS$InstrumentationPayload1"
+  IL_005c:  ldc.i4.1
+  IL_005d:  ldc.i4.1
+  IL_005e:  stelem.i1
+  IL_005f:  ldloca.s   V_0
+  IL_0061:  call       "void E.<M>g__local|{{index}}_0(ref E.<>c__DisplayClass{{index}}_0)"
+  IL_0066:  nop
+  IL_0067:  nop
+  // sequence point: }
+  IL_0068:  ret
+}
+""");
+            verifier.VerifyMethodBody($$"""E.<M>g__local|{{index}}_0(ref E.<>c__DisplayClass{{index}}_0)""", $$"""
+{
+  // Code size       23 (0x17)
+  .maxstack  3
+  // sequence point: {
+  IL_0000:  nop
+  // sequence point: System.Console.WriteLine(i);
+  IL_0001:  ldarg.0
+  IL_0002:  ldfld      "bool[] E.<>c__DisplayClass{{index}}_0.CS$InstrumentationPayload1"
+  IL_0007:  ldc.i4.2
+  IL_0008:  ldc.i4.1
+  IL_0009:  stelem.i1
+  IL_000a:  ldarg.0
+  IL_000b:  ldfld      "int E.<>c__DisplayClass{{index}}_0.i"
+  IL_0010:  call       "void System.Console.WriteLine(int)"
+  IL_0015:  nop
+  // sequence point: }
+  IL_0016:  ret
+}
+""");
+        }
+
         private static void AssertNotInstrumented(CompilationVerifier verifier, string qualifiedMethodName)
             => AssertInstrumented(verifier, qualifiedMethodName, expected: false);
 
diff --git a/src/Compilers/CSharp/Test/Emit2/Emit/LocalStateTracing/LocalStateTracingTests.cs b/src/Compilers/CSharp/Test/Emit2/Emit/LocalStateTracing/LocalStateTracingTests.cs
index 892b3022e0749..c9973dc4bfc37 100644
--- a/src/Compilers/CSharp/Test/Emit2/Emit/LocalStateTracing/LocalStateTracingTests.cs
+++ b/src/Compilers/CSharp/Test/Emit2/Emit/LocalStateTracing/LocalStateTracingTests.cs
@@ -6,7 +6,6 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.Collections.Immutable;
-using System.IO;
 using System.Linq;
 using System.Runtime.CompilerServices;
 using Microsoft.CodeAnalysis.CSharp.EditAndContinue.UnitTests;
@@ -75,7 +74,7 @@ public static LocalStoreTracker LogStateMachineLambdaEntry(int methodId, int lam
             => Entry(methodId, lambdaId, stateMachineId);
 
         public void LogReturn()
-            => WriteLine($"{M.Name}: Returned");
+            => WriteLine($"{MethodDisplay(M)}: Returned");
 
         public static ulong GetNewStateMachineInstanceId()
             => unchecked((ulong)Interlocked.Increment(ref s_stateMachineId));
@@ -84,12 +83,12 @@ private static LocalStoreTracker Entry(int methodId, int lambdaId, ulong stateMa
         {
             var module = typeof(LocalStoreTracker).Assembly.Modules.Single();
             var method = module.ResolveMethod(methodId + 0x06000000);
-            var message = $"{method.Name}: Entered";
+            var message = $"{MethodDisplay(method)}: Entered";
 
             if (lambdaId > 0)
             {
                 var lambda = module.ResolveMethod(lambdaId + 0x06000000);
-                message += $" lambda '{lambda.Name}'";
+                message += $" lambda '{MethodDisplay(lambda)}'";
                 method = lambda;
             }
 
@@ -103,10 +102,10 @@ private static LocalStoreTracker Entry(int methodId, int lambdaId, ulong stateMa
         }
 
         private void WL(object value, int index)
-            => WriteLine($"{M.Name}: {L(index)} = {ConvertToString(value)}");
+            => WriteLine($"{MethodDisplay(M)}: {L(index)} = {ConvertToString(value)}");
 
         private void WP(object value, int index)
-            => WriteLine($"{M.Name}: {P(index)} = {ConvertToString(value)}");
+            => WriteLine($"{MethodDisplay(M)}: {P(index)} = {ConvertToString(value)}");
 
         private string L(int index)
             => (index >= 0x10000) ? $"L'{UnmangleFieldName(M.Module.ResolveField(index - 0x10000 + 0x04000000).Name)}'" : $"L{index}";
@@ -156,11 +155,22 @@ private static string MemoryToString(void* address, int size)
         public void LogParameterStoreParameterAlias(int sourceParameterIndex, int targetParameterIndex) { WriteLine($"{M.Name}: {P(targetParameterIndex)} -> {P(sourceParameterIndex)}"); }
 
         public void LogLocalStoreLocalAlias(int sourceLocalIndex, int targetLocalIndex) { WriteLine($"{M.Name}: {L(targetLocalIndex)} -> {L(sourceLocalIndex)}"); }
+
+        private static string MethodDisplay(MethodBase method)
+        {
+            bool includeContainingType = INCLUDE_CONTAINING_TYPE;
+            return includeContainingType
+                ? method.DeclaringType.FullName + "." + method.Name
+                : method.Name;
+        }
     }
 }
 """;
-        private static string WithHelpers(string source)
-            => source + s_helpers;
+        /// <param name="displayContainingType">Set to true to include the containing type when displaying a method being entered.</param>
+        private static string WithHelpers(string source, bool displayContainingType = false)
+        {
+            return source + s_helpers.Replace("INCLUDE_CONTAINING_TYPE", displayContainingType ? "true" : "false");
+        }
 
         private const TargetFramework s_targetFramework = TargetFramework.Net70;
 
@@ -458,7 +468,7 @@ .maxstack  3
   IL_0016:  call       0x06000018
   IL_001b:  nop
   IL_001c:  nop
-  IL_001d:  call       0x06000030
+  IL_001d:  call       0x06000031
   IL_0022:  nop
   IL_0023:  leave.s    IL_002e
   IL_0025:  ldloca.s   V_0
@@ -471,7 +481,7 @@ .maxstack  3
   // Code size       45 (0x2d)
   .maxstack  3
   IL_0000:  ldc.i4     0x3
-  IL_0005:  ldc.i4     0x30
+  IL_0005:  ldc.i4     0x31
   IL_000a:  call       0x06000008
   IL_000f:  stloc.0
   IL_0010:  nop
@@ -6628,6 +6638,701 @@ public void Discards()
 <Main>$: Returned
 ");
         }
+
+        [Fact, CompilerTrait(CompilerFeature.Extensions)]
+        public void Extensions_01()
+        {
+            // non-static extension method
+            var source = WithHelpers("""
+42.M(43);
+
+static class E
+{
+    extension(int i1)
+    {
+        public void M(int i2) { }
+    }
+}
+""", displayContainingType: true);
+
+            CompileAndVerify(source, expectedOutput: """
+Program.<Main>$: Entered
+Program.<Main>$: P'args'[0] = System.String[]
+E.M: Entered
+E.M: P'i1'[0] = 42
+E.M: P'i2'[1] = 43
+E.M: Returned
+Program.<Main>$: Returned
+""");
+        }
+
+        [Fact, CompilerTrait(CompilerFeature.Extensions)]
+        public void Extensions_02()
+        {
+            // non-static extension method with ref parameters and assignments
+            var source = WithHelpers("""
+int x1 = 42;
+int x2 = 43;
+x1.M(ref x2);
+
+static class E
+{
+    extension(ref int i1)
+    {
+        public void M(ref int i2)
+        {
+            i1 = 52;
+            i2 = 53;
+        }
+    }
+}
+""", displayContainingType: true);
+
+            CompileAndVerify(source, expectedOutput: """
+Program.<Main>$: Entered
+Program.<Main>$: P'args'[0] = System.String[]
+Program.<Main>$: L1 = 42
+Program.<Main>$: L2 = 43
+E.M: Entered
+E.M: P'i1'[0] = 42
+E.M: P'i2'[1] = 43
+E.M: P'i1'[0] = 52
+E.M: P'i2'[1] = 53
+E.M: Returned
+Program.<Main>$: L1 = 52
+Program.<Main>$: L2 = 53
+Program.<Main>$: Returned
+""");
+        }
+
+        [Fact, CompilerTrait(CompilerFeature.Extensions)]
+        public void Extensions_03()
+        {
+            // assignment to parameter, static extension method
+            var source = WithHelpers("""
+int i = 0;
+int.M(ref i);
+
+static class E
+{
+    extension(int)
+    {
+        public static void M(ref int i2)
+        {
+            i2 = 42;
+        }
+    }
+}
+""", displayContainingType: true);
+
+            CompileAndVerify(source, expectedOutput: """
+Program.<Main>$: Entered
+Program.<Main>$: P'args'[0] = System.String[]
+Program.<Main>$: L1 = 0
+E.M: Entered
+E.M: P'i2'[0] = 0
+E.M: P'i2'[0] = 42
+E.M: Returned
+Program.<Main>$: L1 = 42
+Program.<Main>$: Returned
+""");
+        }
+
+        [Fact, CompilerTrait(CompilerFeature.Extensions)]
+        public void Extensions_04()
+        {
+            // only receiver parameter has ref kind
+            var source = WithHelpers("""
+int i = 42;
+i.M(43);
+
+static class E
+{
+    extension(ref int i1)
+    {
+        public void M(int i2)
+        {
+            i1 = 52;
+        }
+    }
+}
+""", displayContainingType: true);
+
+            CompileAndVerify(source, expectedOutput: """
+Program.<Main>$: Entered
+Program.<Main>$: P'args'[0] = System.String[]
+Program.<Main>$: L1 = 42
+E.M: Entered
+E.M: P'i1'[0] = 42
+E.M: P'i2'[1] = 43
+E.M: P'i1'[0] = 52
+E.M: Returned
+Program.<Main>$: L1 = 52
+Program.<Main>$: Returned
+""");
+        }
+
+        [Fact, CompilerTrait(CompilerFeature.Extensions)]
+        public void Extensions_05()
+        {
+            // non-static extension property
+            var source = WithHelpers("""
+_ = 42.P;
+
+int i = 43;
+i.P = 44;
+
+static class E
+{
+    extension(int i1)
+    {
+        public int P { get => 0; set { } }
+    }
+}
+""", displayContainingType: true);
+
+            CompileAndVerify(source, expectedOutput: """
+Program.<Main>$: Entered
+Program.<Main>$: P'args'[0] = System.String[]
+E.get_P: Entered
+E.get_P: P'i1'[0] = 42
+E.get_P: Returned
+Program.<Main>$: L1 = 43
+E.set_P: Entered
+E.set_P: P'i1'[0] = 43
+E.set_P: P'value'[1] = 44
+E.set_P: Returned
+Program.<Main>$: Returned
+""");
+        }
+
+        [Fact, CompilerTrait(CompilerFeature.Extensions)]
+        public void Extensions_06()
+        {
+            // static extension property
+            var source = WithHelpers("""
+_ = int.P;
+int.P = 42;
+
+static class E
+{
+    extension(int)
+    {
+        public static int P { get => 0; set { } }
+    }
+}
+""", displayContainingType: true);
+
+            CompileAndVerify(source, expectedOutput: """
+Program.<Main>$: Entered
+Program.<Main>$: P'args'[0] = System.String[]
+E.get_P: Entered
+E.get_P: Returned
+E.set_P: Entered
+E.set_P: P'value'[0] = 42
+E.set_P: Returned
+Program.<Main>$: Returned
+""");
+        }
+
+        [Fact, CompilerTrait(CompilerFeature.Extensions)]
+        public void Extensions_07()
+        {
+            // local function in extension
+            var source = WithHelpers("""
+42.M();
+
+static class E
+{
+    extension(int i1)
+    {
+        public void M()
+        {
+            local(i1);
+
+            void local(int i2) { }
+        }
+    }
+}
+""", displayContainingType: true);
+
+            CompileAndVerify(source, expectedOutput: """
+Program.<Main>$: Entered
+Program.<Main>$: P'args'[0] = System.String[]
+E.M: Entered
+E.M: P'i1'[0] = 42
+E.M: Entered lambda 'E.<M>g__local|1_0'
+E.<M>g__local|1_0: P'i2'[0] = 42
+E.<M>g__local|1_0: Returned
+E.M: Returned
+Program.<Main>$: Returned
+""");
+        }
+
+        [Fact, CompilerTrait(CompilerFeature.Extensions)]
+        public void Extensions_08()
+        {
+            // lambda in extension
+            var source = WithHelpers("""
+42.M();
+
+static class E
+{
+    extension(int i1)
+    {
+        public void M()
+        {
+            var x = (int i2) => { };
+            x(i1);
+        }
+    }
+}
+""", displayContainingType: true);
+
+            var verifier = CompileAndVerify(source, expectedOutput: """
+Program.<Main>$: Entered
+Program.<Main>$: P'args'[0] = System.String[]
+E.M: Entered
+E.M: P'i1'[0] = 42
+E.M: L1 = System.Action`1[System.Int32]
+E.M: Entered lambda 'E+<>c.<M>b__1_0'
+E+<>c.<M>b__1_0: P'i2'[0] = 42
+E+<>c.<M>b__1_0: Returned
+E.M: Returned
+Program.<Main>$: Returned
+""");
+
+            verifier.VerifyMethodBody("E.<>c.<M>b__1_0", """
+{
+  // Code size       38 (0x26)
+  .maxstack  3
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0)
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    "void E.M(int)"
+  IL_0005:  ldtoken    "void E.<>c.<M>b__1_0(int)"
+  IL_000a:  call       "Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLambdaEntry(int, int)"
+  IL_000f:  stloc.0
+  .try
+  {
+    // sequence point: {
+    IL_0010:  ldloca.s   V_0
+    IL_0012:  ldarg.1
+    IL_0013:  ldc.i4.0
+    IL_0014:  call       "void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogParameterStore(uint, int)"
+    IL_0019:  nop
+    // sequence point: }
+    IL_001a:  leave.s    IL_0025
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_001c:  ldloca.s   V_0
+    IL_001e:  call       "void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()"
+    IL_0023:  nop
+    IL_0024:  endfinally
+  }
+  // sequence point: }
+  IL_0025:  ret
+}
+""");
+        }
+
+        [Fact, CompilerTrait(CompilerFeature.Extensions)]
+        public void Extensions_09()
+        {
+            // nested lambda in extension
+            var source = WithHelpers("""
+42.M();
+
+static class E
+{
+    extension(int i1)
+    {
+        public void M()
+        {
+            var f1 = (int i2) =>
+            {
+                var f2 = (int i3) => { };
+                f2(i2);
+            };
+
+            f1(i1);
+        }
+    }
+}
+""", displayContainingType: true);
+
+            CompileAndVerify(source, expectedOutput: """
+Program.<Main>$: Entered
+Program.<Main>$: P'args'[0] = System.String[]
+E.M: Entered
+E.M: P'i1'[0] = 42
+E.M: L1 = System.Action`1[System.Int32]
+E.M: Entered lambda 'E+<>c.<M>b__1_0'
+E+<>c.<M>b__1_0: P'i2'[0] = 42
+E+<>c.<M>b__1_0: L1 = System.Action`1[System.Int32]
+E.M: Entered lambda 'E+<>c.<M>b__1_1'
+E+<>c.<M>b__1_1: P'i3'[0] = 42
+E+<>c.<M>b__1_1: Returned
+E+<>c.<M>b__1_0: Returned
+E.M: Returned
+Program.<Main>$: Returned
+""");
+        }
+
+        [Fact, CompilerTrait(CompilerFeature.Extensions)]
+        public void Extensions_10()
+        {
+            // local function parameter uses type parameter from extension block
+            var source = WithHelpers("""
+42.M();
+
+static class E
+{
+    extension<T>(T t)
+    {
+        public void M()
+        {
+            local(t);
+
+            void local(T t) { }
+        }
+    }
+}
+""", displayContainingType: true);
+
+            CompileAndVerify(source, expectedOutput: """
+Program.<Main>$: Entered
+Program.<Main>$: P'args'[0] = System.String[]
+E.M: Entered
+E.M: P't'[0] = 42
+E.M: Entered lambda 'E.<M>g__local|1_0'
+E.<M>g__local|1_0: P't'[0] = 42
+E.<M>g__local|1_0: Returned
+E.M: Returned
+Program.<Main>$: Returned
+""");
+        }
+
+        [Fact, CompilerTrait(CompilerFeature.Extensions)]
+        public void Extensions_11()
+        {
+            // extension method local uses type parameter from extension block
+            var source = WithHelpers("""
+42.M();
+
+static class E
+{
+    extension<T>(T t)
+    {
+        public void M()
+        {
+            T t2 = t;
+            t2.ToString();
+        }
+    }
+}
+""", displayContainingType: true);
+
+            CompileAndVerify(source, expectedOutput: """
+Program.<Main>$: Entered
+Program.<Main>$: P'args'[0] = System.String[]
+E.M: Entered
+E.M: P't'[0] = 42
+E.M: L1 = 42
+E.M: Returned
+Program.<Main>$: Returned
+""");
+        }
+
+        [Fact, CompilerTrait(CompilerFeature.Extensions)]
+        public void Extensions_12()
+        {
+            // anonymous function in extension
+            var source = WithHelpers("""
+42.M();
+
+static class E
+{
+    extension(int i1)
+    {
+        public void M()
+        {
+            System.Action<int> x = delegate { };
+            x(i1);
+        }
+    }
+}
+""", displayContainingType: true);
+
+            CompileAndVerify(source, expectedOutput: """
+Program.<Main>$: Entered
+Program.<Main>$: P'args'[0] = System.String[]
+E.M: Entered
+E.M: P'i1'[0] = 42
+E.M: L1 = System.Action`1[System.Int32]
+E.M: Entered lambda 'E+<>c.<M>b__1_0'
+E+<>c.<M>b__1_0: P'<p0>'[0] = 42
+E+<>c.<M>b__1_0: Returned
+E.M: Returned
+Program.<Main>$: Returned
+""");
+        }
+
+        [Fact, CompilerTrait(CompilerFeature.Extensions)]
+        public void Extensions_13()
+        {
+            // iterator in extension
+            var source = WithHelpers("""
+foreach (var i in 42.M())
+{
+}
+
+static class E
+{
+    extension(int i)
+    {
+        public System.Collections.Generic.IEnumerable<int> M()
+        {
+            yield return i;
+        }
+    }
+}
+""", displayContainingType: true);
+
+            CompileAndVerify(source, expectedOutput: """
+Program.<Main>$: Entered
+Program.<Main>$: P'args'[0] = System.String[]
+E.M: Entered state machine #1
+E.M: P'i'[0] = 42
+E.M: Returned
+Program.<Main>$: L2 = 42
+E.M: Entered state machine #1
+E.M: Returned
+Program.<Main>$: Returned
+""");
+        }
+
+        [Fact, CompilerTrait(CompilerFeature.Extensions)]
+        public void Extensions_14()
+        {
+            // iterator local function in extension
+            var source = WithHelpers("""
+42.M();
+
+static class E
+{
+    extension(int i)
+    {
+        public void M()
+        {
+            foreach (var j in local())
+            {
+                System.Console.WriteLine(j);
+            }
+            return;
+
+            System.Collections.Generic.IEnumerable<int> local()
+            {
+                yield return i;
+            }
+        }
+    }
+}
+""", displayContainingType: true);
+
+            CompileAndVerify(source, expectedOutput: """
+Program.<Main>$: Entered
+Program.<Main>$: P'args'[0] = System.String[]
+E.M: Entered
+E.M: P'i'[0] = 42
+E.M: Entered lambda 'E+<>c__DisplayClass1_0.<M>g__local|0' state machine #1
+E+<>c__DisplayClass1_0.<M>g__local|0: Returned
+E.M: L3 = 42
+42
+E.M: Entered lambda 'E+<>c__DisplayClass1_0.<M>g__local|0' state machine #1
+E+<>c__DisplayClass1_0.<M>g__local|0: Returned
+E.M: Returned
+Program.<Main>$: Returned
+""");
+        }
+
+        [Fact, CompilerTrait(CompilerFeature.Extensions)]
+        public void Extensions_15()
+        {
+            // async lambda in extension
+            var source = WithHelpers("""
+await 42.M();
+
+static class E
+{
+    extension(int i)
+    {
+        public async System.Threading.Tasks.Task M()
+        {
+            var f = async () =>
+            {
+                await System.Threading.Tasks.Task.FromResult(0);
+            };
+
+            await f();
+        }
+    }
+}
+""", displayContainingType: true);
+
+            CompileAndVerify(source, expectedOutput: """
+Program.<Main>$: Entered state machine #1
+Program.<Main>$: P'args'[0] = System.String[]
+E.M: Entered state machine #2
+E.M: P'i'[0] = 42
+E.M: L'f' = System.Func`1[System.Threading.Tasks.Task]
+E.M: Entered lambda 'E+<>c.<M>b__1_0' state machine #3
+E+<>c.<M>b__1_0: Returned
+E.M: Returned
+Program.<Main>$: Returned
+""");
+        }
+
+        [Fact, CompilerTrait(CompilerFeature.Extensions)]
+        public void Extensions_16()
+        {
+            // extension operator
+            var source = WithHelpers("""
+_ = new C() + 10;
+
+static class E
+{
+    extension(C)
+    {
+        public static C operator +(C c, int i)
+        {
+            return new C();
+        }
+    }
+}
+
+class C { }
+""", displayContainingType: true);
+
+            CompileAndVerify(source, expectedOutput: """
+Program.<Main>$: Entered
+Program.<Main>$: P'args'[0] = System.String[]
+C..ctor: Entered
+C..ctor: Returned
+E.op_Addition: Entered
+E.op_Addition: P'c'[0] = C
+E.op_Addition: P'i'[1] = 10
+C..ctor: Entered
+C..ctor: Returned
+E.op_Addition: Returned
+Program.<Main>$: Returned
+""");
+        }
+
+        [Fact, CompilerTrait(CompilerFeature.Extensions)]
+        public void Extensions_17()
+        {
+            // ref assignment from parameter
+            var source = WithHelpers("""
+42.M(43);
+
+static class E
+{
+    extension(int i1)
+    {
+        public void M(int i2)
+        {
+            ref int x1 = ref i1;
+            ref int x2 = ref i2;
+        }
+    }
+}
+""", displayContainingType: true);
+
+            CompileAndVerify(source, expectedOutput: """
+Program.<Main>$: Entered
+Program.<Main>$: P'args'[0] = System.String[]
+E.M: Entered
+E.M: P'i1'[0] = 42
+E.M: P'i2'[1] = 43
+M: L1 -> P'i1'[0]
+M: L2 -> P'i2'[1]
+E.M: Returned
+Program.<Main>$: Returned
+""");
+        }
+
+        [Fact, CompilerTrait(CompilerFeature.Extensions)]
+        public void Extensions_18()
+        {
+            // ref assignment from hoisted parameter
+            var source = WithHelpers("""
+42.M(43);
+
+static class E
+{
+    extension(int i1)
+    {
+        public void M(int i2)
+        {
+            var f = () =>
+            {
+                ref int x1 = ref i1;
+                ref int x2 = ref i2;
+            };
+
+            f();
+        }
+    }
+}
+""", displayContainingType: true);
+
+            CompileAndVerify(source, expectedOutput: """
+Program.<Main>$: Entered
+Program.<Main>$: P'args'[0] = System.String[]
+E.M: Entered
+E.M: P'i1'[0] = 42
+E.M: P'i2'[1] = 43
+E.M: L2 = System.Action
+E.M: Entered lambda 'E+<>c__DisplayClass1_0.<M>b__0'
+<M>b__0: L1 -> P'i1'
+<M>b__0: L2 -> P'i2'
+E+<>c__DisplayClass1_0.<M>b__0: Returned
+E.M: Returned
+Program.<Main>$: Returned
+""");
+        }
+
+        [Fact, CompilerTrait(CompilerFeature.Extensions)]
+        public void Extensions_19()
+        {
+            // ref readonly extension parameter
+            var source = WithHelpers("""
+42.M();
+
+static class E
+{
+    extension(ref readonly int i1)
+    {
+        public void M()
+        {
+            ref readonly int x1 = ref i1;
+        }
+    }
+}
+""", displayContainingType: true);
+
+            CompileAndVerify(source, expectedOutput: """
+Program.<Main>$: Entered
+Program.<Main>$: P'args'[0] = System.String[]
+E.M: Entered
+E.M: P'i1'[0] = 42
+M: L1 -> P'i1'[0]
+E.M: Returned
+Program.<Main>$: Returned
+""");
+        }
     }
 }
 #endif