From 680a9ac48db6f0cb4005ebd6596cbf18ee96edf9 Mon Sep 17 00:00:00 2001
From: tmat <tomas.matousek@microsoft.com>
Date: Wed, 8 Feb 2023 17:34:59 -0800
Subject: [PATCH] Local state tracing instrumentation

---
 .../CSharp/Portable/Binder/Binder.cs          |    2 +-
 .../Portable/Binder/Binder_Statements.cs      |    1 +
 .../CSharp/Portable/BoundTree/BoundNode.cs    |   17 +
 .../CSharp/Portable/BoundTree/BoundNodes.xml  |   38 +-
 .../CSharp/Portable/BoundTree/Constructors.cs |    3 +-
 .../CSharp/Portable/CodeGen/CodeGenerator.cs  |    6 +-
 .../CSharp/Portable/CodeGen/EmitExpression.cs |   47 +
 .../CSharp/Portable/CodeGen/EmitStatement.cs  |   58 +-
 .../CSharp/Portable/CodeGen/Optimizer.cs      |    5 +
 .../Portable/Compilation/CSharpCompilation.cs |    9 +-
 .../Portable/Compiler/MethodCompiler.cs       |  126 +-
 .../EditAndContinue/PEDeltaAssemblyBuilder.cs |    8 +
 .../Portable/Emitter/Model/PEModuleBuilder.cs |    3 +
 .../Portable/FlowAnalysis/AbstractFlowPass.cs |   15 +
 .../FlowAnalysis/DefiniteAssignment.cs        |   20 +
 .../Portable/FlowAnalysis/FlowAnalysisPass.cs |    6 +-
 .../FlowAnalysis/LocalDataFlowPass.cs         |    9 +
 .../Generated/BoundNodes.xml.Generated.cs     |  323 +-
 ...yncIteratorMethodToStateMachineRewriter.cs |   11 +-
 .../AsyncMethodToStateMachineRewriter.cs      |   19 +-
 .../AsyncRewriter.AsyncIteratorRewriter.cs    |    8 +-
 .../Lowering/AsyncRewriter/AsyncRewriter.cs   |   36 +-
 .../ClosureConversion/ClosureConversion.cs    |   24 +-
 .../LambdaCapturedVariable.cs                 |    6 +-
 .../CodeCoverageInstrumenter.cs               |    8 +-
 .../Instrumentation/CompoundInstrumenter.cs   |   53 +-
 .../Instrumentation/DebugInfoInjector.cs      |   43 +-
 .../Lowering/Instrumentation/Instrumenter.cs  |   48 +-
 .../LocalStateTracingInstrumenter.cs          |  508 ++
 .../IteratorMethodToStateMachineRewriter.cs   |   50 +-
 .../IteratorRewriter/IteratorRewriter.cs      |   18 +-
 .../Lowering/LocalRewriter/LocalRewriter.cs   |   35 +-
 .../LocalRewriter_AssignmentOperator.cs       |    8 +-
 .../LocalRewriter/LocalRewriter_Block.cs      |   10 +-
 .../LocalRewriter/LocalRewriter_Call.cs       |   11 +-
 ...LocalRewriter_FunctionPointerInvocation.cs |   16 +-
 .../LocalRewriter_LocalDeclaration.cs         |    4 +-
 .../LocalRewriter_ObjectCreationExpression.cs |    5 +
 .../LocalRewriter_TryStatement.cs             |   20 +-
 .../Lowering/MethodToClassRewriter.cs         |   41 +-
 .../MethodToStateMachineRewriter.cs           |   36 +-
 .../StateMachineRewriter.cs                   |   21 +-
 .../Lowering/SyntheticBoundNodeFactory.cs     |   57 +-
 .../Symbols/Synthesized/GeneratedNameKind.cs  |    1 +
 .../Symbols/Synthesized/GeneratedNames.cs     |    6 +
 .../CSharp/Test/Emit/CodeGen/CodeGenTests.cs  |    1 -
 .../DynamicInstrumentationTests.cs            |   19 +-
 .../LocalStateTracingTests.cs                 | 5898 +++++++++++++++++
 .../Test/Emit2/FlowAnalysis/FlowTestBase.cs   |    2 +-
 .../Semantics/ImplicitlyTypeArraysTests.cs    |    2 +-
 .../Test/Semantic/Semantics/OperatorTests.cs  |    2 +-
 .../Semantics/OverloadResolutionTestBase.cs   |    2 +-
 .../Symbol/Symbols/MissingSpecialMember.cs    |   28 +
 .../CodeAnalysisTest/Emit/EmitOptionsTests.cs |    1 -
 .../Core/Portable/CodeAnalysisResources.resx  |    3 +
 .../CodeGen/DynamicAnalysisMethodBodyData.cs  |   20 -
 .../Core/Portable/CodeGen/ILBuilderEmit.cs    |   14 +-
 .../Core/Portable/CodeGen/MethodBody.cs       |   10 +-
 .../Portable/CommandLine/CommonCompiler.cs    |    2 -
 .../Core/Portable/Compilation/Compilation.cs  |    8 +-
 .../Emit/EditAndContinue/DefinitionMap.cs     |   10 +-
 .../Emit/EditAndContinue/DeletedMethodBody.cs |    2 +-
 .../Core/Portable/Emit/EmitOptions.cs         |    3 +-
 .../Core/Portable/Emit/InstrumentationKind.cs |    9 +-
 .../Portable/Emit/MethodInstrumentation.cs    |   26 +
 .../Emit/NoPia/CommonEmbeddedMethod.cs        |    2 +-
 .../Core/Portable/Emit/SemanticEdit.cs        |   47 +-
 .../InternalUtilities/EnumerableExtensions.cs |    2 +-
 .../Core/Portable/PEWriter/Members.cs         |    6 +-
 .../MetadataWriter.DynamicAnalysis.cs         |   15 +-
 .../Core/Portable/PEWriter/MetadataWriter.cs  |   73 +-
 .../PEWriter/RootModuleStaticConstructor.cs   |    2 +-
 .../Core/Portable/PublicAPI.Unshipped.txt     |    9 +
 .../Core/Portable/SynthesizedLocalKind.cs     |    6 +
 .../Core/Portable/WellKnownMember.cs          |   36 +
 .../Core/Portable/WellKnownMembers.cs         |  275 +
 src/Compilers/Core/Portable/WellKnownTypes.cs |    2 +
 .../Portable/xlf/CodeAnalysisResources.cs.xlf |    5 +
 .../Portable/xlf/CodeAnalysisResources.de.xlf |    5 +
 .../Portable/xlf/CodeAnalysisResources.es.xlf |    5 +
 .../Portable/xlf/CodeAnalysisResources.fr.xlf |    5 +
 .../Portable/xlf/CodeAnalysisResources.it.xlf |    5 +
 .../Portable/xlf/CodeAnalysisResources.ja.xlf |    5 +
 .../Portable/xlf/CodeAnalysisResources.ko.xlf |    5 +
 .../Portable/xlf/CodeAnalysisResources.pl.xlf |    5 +
 .../xlf/CodeAnalysisResources.pt-BR.xlf       |    5 +
 .../Portable/xlf/CodeAnalysisResources.ru.xlf |    5 +
 .../Portable/xlf/CodeAnalysisResources.tr.xlf |    5 +
 .../xlf/CodeAnalysisResources.zh-Hans.xlf     |    5 +
 .../xlf/CodeAnalysisResources.zh-Hant.xlf     |    5 +
 src/Compilers/Test/Core/CommonTestBase.cs     |    4 +-
 .../Test/Core/CompilationVerifier.cs          |   11 +-
 .../Test/Core/InstrumentationChecker.cs       |    8 +-
 .../Test/Core/Metadata/ILBuilderVisualizer.cs |   20 +-
 .../Desktop/DesktopRuntimeEnvironment.cs      |    2 +-
 .../Utilities/CSharp/CompilingTestBase.cs     |    2 +-
 .../Portable/CodeGen/CodeGenerator.vb         |    3 +-
 .../Portable/Compilation/MethodCompiler.vb    |   83 +-
 .../Compilation/VisualBasicCompilation.vb     |   19 +-
 .../EditAndContinue/PEDeltaAssemblyBuilder.vb |    4 +
 .../Portable/Emit/PEModuleBuilder.vb          |    4 +
 .../VisualBasic/Portable/Lowering/Rewriter.vb |   16 +-
 .../Source/SourceMemberContainerTypeSymbol.vb |    2 +-
 .../WellKnownTypeValidationTests.vb           |   56 +
 .../Rewriters/CapturedVariableRewriter.cs     |    2 +-
 .../Symbols/EEMethodSymbol.cs                 |   19 +-
 106 files changed, 8231 insertions(+), 425 deletions(-)
 create mode 100644 src/Compilers/CSharp/Portable/Lowering/Instrumentation/LocalStateTracingInstrumenter.cs
 create mode 100644 src/Compilers/CSharp/Test/Emit/Emit/LocalStateTracing/LocalStateTracingTests.cs
 delete mode 100644 src/Compilers/Core/Portable/CodeGen/DynamicAnalysisMethodBodyData.cs
 create mode 100644 src/Compilers/Core/Portable/Emit/MethodInstrumentation.cs

diff --git a/src/Compilers/CSharp/Portable/Binder/Binder.cs b/src/Compilers/CSharp/Portable/Binder/Binder.cs
index fd01285289f2b..ca2362131ea6c 100644
--- a/src/Compilers/CSharp/Portable/Binder/Binder.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Binder.cs
@@ -882,7 +882,7 @@ internal BoundStatement WrapWithVariablesAndLocalFunctionsIfAny(CSharpSyntaxNode
                 return statement;
             }
 
-            return new BoundBlock(statement.Syntax, locals, localFunctions, hasUnsafeModifier: false,
+            return new BoundBlock(statement.Syntax, locals, localFunctions, hasUnsafeModifier: false, instrumentation: null,
                                   ImmutableArray.Create(statement))
             { WasCompilerGenerated = true };
         }
diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Statements.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Statements.cs
index eef9856fb8f9b..bb25cbb9c9960 100644
--- a/src/Compilers/CSharp/Portable/Binder/Binder_Statements.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Binder_Statements.cs
@@ -1889,6 +1889,7 @@ private BoundBlock FinishBindBlockParts(CSharpSyntaxNode node, ImmutableArray<Bo
                 locals,
                 GetDeclaredLocalFunctionsForScope(node),
                 hasUnsafeModifier: node.Parent?.Kind() == SyntaxKind.UnsafeStatement,
+                instrumentation: null,
                 boundStatements);
         }
 
diff --git a/src/Compilers/CSharp/Portable/BoundTree/BoundNode.cs b/src/Compilers/CSharp/Portable/BoundTree/BoundNode.cs
index c34aeafd8359b..a406f548b27d5 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/BoundNode.cs
+++ b/src/Compilers/CSharp/Portable/BoundTree/BoundNode.cs
@@ -498,9 +498,26 @@ private void CheckDeclared(LocalSymbol local)
 
             public override BoundNode? VisitBlock(BoundBlock node)
             {
+                if (node.Instrumentation != null)
+                {
+                    var added = DeclaredLocals.Add(node.Instrumentation.Local);
+                    Debug.Assert(added);
+
+                    _ = Visit(node.Instrumentation.Prologue);
+                }
+
                 AddAll(node.Locals);
                 base.VisitBlock(node);
                 RemoveAll(node.Locals);
+
+                if (node.Instrumentation != null)
+                {
+                    _ = Visit(node.Instrumentation.Epilogue);
+
+                    var removed = DeclaredLocals.Remove(node.Instrumentation.Local);
+                    Debug.Assert(removed);
+                }
+
                 return null;
             }
 
diff --git a/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml b/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml
index c42355980fe3d..69d67729542e5 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml
+++ b/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml
@@ -699,8 +699,15 @@
   <Node Name="BoundTypeOfOperator" Base="BoundTypeOf">
     <Field Name="SourceType" Type="BoundTypeExpression"/>
   </Node>
+
+  <!-- Instrumentation info attached to BoundBlock -->
+  <Node Name="BoundBlockInstrumentation" Base="BoundNode">
+    <Field Name="Local" Type="LocalSymbol" Null="disallow"/>
+    <Field Name="Prologue" Type="BoundStatement" Null="disallow"/>
+    <Field Name="Epilogue" Type="BoundStatement" Null="disallow"/>
+  </Node>
   
-   <!-- Represents the raw metadata token index value for a method definition.
+   <!-- Represents the raw metadata RowId value for a method definition.
         Used by dynamic instrumentation to index into tables or arrays of per-method information. -->
   <Node Name="BoundMethodDefIndex" Base="BoundExpression">
     <!-- Non-null type is required for this node kind -->
@@ -708,6 +715,32 @@
     <Field Name="Method" Type="MethodSymbol"/>
   </Node>
 
+  <!-- Represents local id - a unique int value that represents local variable.-->
+  <Node Name="BoundLocalId" Base="BoundExpression">
+    <!-- Non-null type is required for this node kind -->
+    <Field Name="Type" Type="TypeSymbol" Override="true" Null="disallow"/>
+    <!-- Local symbol representing the variable. -->
+    <Field Name="Local" Type="LocalSymbol" Null="disallow"/>
+    <!-- Field symbol representing the variable if it has been lifted. -->
+    <Field Name="HoistedField" Type="FieldSymbol?" Null="allow"/>
+  </Node>
+
+  <!-- Represents parameter id - a unique int value that represents parameter.-->
+  <Node Name="BoundParameterId" Base="BoundExpression">
+    <!-- Non-null type is required for this node kind -->
+    <Field Name="Type" Type="TypeSymbol" Override="true" Null="disallow"/>
+    <!-- Local symbol representing the variable. -->
+    <Field Name="Parameter" Type="ParameterSymbol" Null="disallow"/>
+    <!-- Field symbol representing the parameter if it has been lifted. -->
+    <Field Name="HoistedField" Type="FieldSymbol?" Null="allow"/>
+  </Node>
+
+  <!-- Represents state machine instance id - a unique ulong value that represents an instance of a state machine.-->
+  <Node Name="BoundStateMachineInstanceId" Base="BoundExpression">
+    <!-- Non-null type is required for this node kind -->
+    <Field Name="Type" Type="TypeSymbol" Override="true" Null="disallow"/>
+  </Node>
+
   <!-- Represents the maximum raw metadata token index value for any method definition in the current module. -->
   <Node Name="BoundMaximumMethodDefIndex" Base="BoundExpression">
     <!-- Non-null type is required for this node kind -->
@@ -974,6 +1007,9 @@
     <Field Name="Locals" Type="ImmutableArray&lt;LocalSymbol&gt;"/>
     <Field Name="LocalFunctions" Type="ImmutableArray&lt;LocalFunctionSymbol&gt;"/>
     <Field Name="HasUnsafeModifier" Type="bool" Null="NotApplicable"/>
+    
+    <!-- Optional block-level instrumentation info -->
+    <Field Name="Instrumentation" Type="BoundBlockInstrumentation?" Null="allow" />
   </Node>
 
   <!--
diff --git a/src/Compilers/CSharp/Portable/BoundTree/Constructors.cs b/src/Compilers/CSharp/Portable/BoundTree/Constructors.cs
index fb92093a9846f..b617f0b867fda 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/Constructors.cs
+++ b/src/Compilers/CSharp/Portable/BoundTree/Constructors.cs
@@ -595,7 +595,8 @@ public BoundGotoStatement(SyntaxNode syntax, LabelSymbol label, bool hasErrors =
 
     internal partial class BoundBlock
     {
-        public BoundBlock(SyntaxNode syntax, ImmutableArray<LocalSymbol> locals, ImmutableArray<BoundStatement> statements, bool hasErrors = false) : this(syntax, locals, ImmutableArray<LocalFunctionSymbol>.Empty, hasUnsafeModifier: false, statements, hasErrors)
+        public BoundBlock(SyntaxNode syntax, ImmutableArray<LocalSymbol> locals, ImmutableArray<BoundStatement> statements, bool hasErrors = false)
+            : this(syntax, locals, ImmutableArray<LocalFunctionSymbol>.Empty, hasUnsafeModifier: false, instrumentation: null, statements, hasErrors)
         {
         }
 
diff --git a/src/Compilers/CSharp/Portable/CodeGen/CodeGenerator.cs b/src/Compilers/CSharp/Portable/CodeGen/CodeGenerator.cs
index 00281e39e2914..ce7045499e411 100644
--- a/src/Compilers/CSharp/Portable/CodeGen/CodeGenerator.cs
+++ b/src/Compilers/CSharp/Portable/CodeGen/CodeGenerator.cs
@@ -348,12 +348,14 @@ private void EmitSymbolToken(TypeSymbol symbol, SyntaxNode syntaxNode)
 
         private void EmitSymbolToken(MethodSymbol method, SyntaxNode syntaxNode, BoundArgListOperator optArgList, bool encodeAsRawDefinitionToken = false)
         {
-            _builder.EmitToken(_module.Translate(method, syntaxNode, _diagnostics.DiagnosticBag, optArgList, needDeclaration: encodeAsRawDefinitionToken), syntaxNode, _diagnostics.DiagnosticBag, encodeAsRawDefinitionToken);
+            var methodRef = _module.Translate(method, syntaxNode, _diagnostics.DiagnosticBag, optArgList, needDeclaration: encodeAsRawDefinitionToken);
+            _builder.EmitToken(methodRef, syntaxNode, _diagnostics.DiagnosticBag, encodeAsRawDefinitionToken ? Cci.MetadataWriter.RawTokenEncoding.RowId : 0);
         }
 
         private void EmitSymbolToken(FieldSymbol symbol, SyntaxNode syntaxNode)
         {
-            _builder.EmitToken(_module.Translate(symbol, syntaxNode, _diagnostics.DiagnosticBag), syntaxNode, _diagnostics.DiagnosticBag);
+            var fieldRef = _module.Translate(symbol, syntaxNode, _diagnostics.DiagnosticBag);
+            _builder.EmitToken(fieldRef, syntaxNode, _diagnostics.DiagnosticBag);
         }
 
         private void EmitSignatureToken(FunctionPointerTypeSymbol symbol, SyntaxNode syntaxNode)
diff --git a/src/Compilers/CSharp/Portable/CodeGen/EmitExpression.cs b/src/Compilers/CSharp/Portable/CodeGen/EmitExpression.cs
index f676195b93dbf..b34e3fa65ab71 100644
--- a/src/Compilers/CSharp/Portable/CodeGen/EmitExpression.cs
+++ b/src/Compilers/CSharp/Portable/CodeGen/EmitExpression.cs
@@ -257,6 +257,16 @@ private void EmitExpressionCore(BoundExpression expression, bool used)
                     EmitSourceDocumentIndex((BoundSourceDocumentIndex)expression);
                     break;
 
+                case BoundKind.LocalId:
+                    Debug.Assert(used);
+                    EmitLocalIdExpression((BoundLocalId)expression);
+                    break;
+
+                case BoundKind.ParameterId:
+                    Debug.Assert(used);
+                    EmitParameterIdExpression((BoundParameterId)expression);
+                    break;
+
                 case BoundKind.MethodInfo:
                     if (used)
                     {
@@ -3310,6 +3320,43 @@ private void EmitMethodDefIndexExpression(BoundMethodDefIndex node)
             EmitSymbolToken(symbol, node.Syntax, null, encodeAsRawDefinitionToken: true);
         }
 
+        private void EmitLocalIdExpression(BoundLocalId node)
+        {
+            Debug.Assert(node.Type.SpecialType == SpecialType.System_Int32);
+
+            if (node.HoistedField is null)
+            {
+                _builder.EmitIntConstant(GetLocal(node.Local).SlotIndex);
+            }
+            else
+            {
+                EmitHoistedVariableId(node.HoistedField, node.Syntax);
+            }
+        }
+
+        private void EmitParameterIdExpression(BoundParameterId node)
+        {
+            Debug.Assert(node.Type.SpecialType == SpecialType.System_Int32);
+
+            if (node.HoistedField is null)
+            {
+                _builder.EmitIntConstant(node.Parameter.Ordinal);
+            }
+            else
+            {
+                EmitHoistedVariableId(node.HoistedField, node.Syntax);
+            }
+        }
+
+        private void EmitHoistedVariableId(FieldSymbol field, SyntaxNode syntax)
+        {
+            Debug.Assert(field.IsDefinition);
+            var fieldRef = _module.Translate(field, syntax, _diagnostics.DiagnosticBag, needDeclaration: true);
+
+            _builder.EmitOpCode(ILOpCode.Ldtoken);
+            _builder.EmitToken(fieldRef, syntax, _diagnostics.DiagnosticBag, Cci.MetadataWriter.RawTokenEncoding.LiftedVariableId);
+        }
+
         private void EmitMaximumMethodDefIndexExpression(BoundMaximumMethodDefIndex node)
         {
             Debug.Assert(node.Type.SpecialType == SpecialType.System_Int32);
diff --git a/src/Compilers/CSharp/Portable/CodeGen/EmitStatement.cs b/src/Compilers/CSharp/Portable/CodeGen/EmitStatement.cs
index 30f8e1f7b5877..02bd5622010fe 100644
--- a/src/Compilers/CSharp/Portable/CodeGen/EmitStatement.cs
+++ b/src/Compilers/CSharp/Portable/CodeGen/EmitStatement.cs
@@ -622,6 +622,54 @@ private bool IsLastBlockInMethod(BoundBlock block)
         }
 
         private void EmitBlock(BoundBlock block)
+        {
+            if (block.Instrumentation is not null)
+            {
+                EmitInstrumentedBlock(block.Instrumentation, block);
+            }
+            else
+            {
+                EmitUninstrumentedBlock(block);
+            }
+        }
+
+        private void EmitInstrumentedBlock(BoundBlockInstrumentation instrumentation, BoundBlock block)
+        {
+            _builder.OpenLocalScope();
+            DefineLocal(instrumentation.Local, block.Syntax);
+
+            if (_emitPdbSequencePoints)
+            {
+                EmitHiddenSequencePoint();
+            }
+
+            EmitStatement(instrumentation.Prologue);
+
+            _builder.AssertStackEmpty();
+
+            _builder.OpenLocalScope(ScopeType.TryCatchFinally);
+
+            _builder.OpenLocalScope(ScopeType.Try);
+            EmitUninstrumentedBlock(block);
+            _builder.CloseLocalScope(); // try
+
+            _builder.OpenLocalScope(ScopeType.Finally);
+
+            if (_emitPdbSequencePoints)
+            {
+                EmitHiddenSequencePoint();
+            }
+
+            EmitStatement(instrumentation.Epilogue);
+            _builder.CloseLocalScope(); // finally
+
+            _builder.CloseLocalScope(); // try-finally
+
+            FreeLocal(instrumentation.Local);
+            _builder.CloseLocalScope();
+        }
+
+        private void EmitUninstrumentedBlock(BoundBlock block)
         {
             var hasLocals = !block.Locals.IsEmpty;
 
@@ -644,7 +692,15 @@ private void EmitBlock(BoundBlock block)
             if (_indirectReturnState == IndirectReturnState.Needed &&
                 IsLastBlockInMethod(block))
             {
-                HandleReturn();
+                if (block.Instrumentation != null)
+                {
+                    // jump out of try-finally
+                    _builder.EmitBranch(ILOpCode.Br, s_returnLabel);
+                }
+                else
+                {
+                    HandleReturn();
+                }
             }
 
             if (hasLocals)
diff --git a/src/Compilers/CSharp/Portable/CodeGen/Optimizer.cs b/src/Compilers/CSharp/Portable/CodeGen/Optimizer.cs
index 792fc52b75b42..03905c87e77ac 100644
--- a/src/Compilers/CSharp/Portable/CodeGen/Optimizer.cs
+++ b/src/Compilers/CSharp/Portable/CodeGen/Optimizer.cs
@@ -614,6 +614,11 @@ public override BoundNode VisitBlock(BoundBlock node)
         {
             Debug.Assert(EvalStackIsEmpty(), "entering blocks when evaluation stack is not empty?");
 
+            if (node.Instrumentation != null)
+            {
+                DeclareLocal(node.Instrumentation.Local, stack: 0);
+            }
+
             // normally we would not allow stack locals
             // when evaluation stack is not empty.
             DeclareLocals(node.Locals, 0);
diff --git a/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs b/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs
index 098fe0f6e130e..739cf2884f80d 100644
--- a/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs
+++ b/src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs
@@ -2791,7 +2791,6 @@ private void GetDiagnosticsForAllMethodBodies(BindingDiagnosticBag diagnostics,
                                                                        cancellationToken: cancellationToken)
                                                 : null,
                 emittingPdb: false,
-                emitTestCoverageData: false,
                 hasDeclarationErrors: false,
                 emitMethodBodies: false,
                 diagnostics: diagnostics,
@@ -2905,7 +2904,6 @@ void compileMethodBodiesAndDocComments(SyntaxTree? filterTree, TextSpan? filterS
                                 compilation: this,
                                 moduleBeingBuiltOpt: null,
                                 emittingPdb: false,
-                                emitTestCoverageData: false,
                                 hasDeclarationErrors: false,
                                 emitMethodBodies: false,
                                 diagnostics: bindingDiagnostics,
@@ -3191,12 +3189,12 @@ internal override StrongNameKeys StrongNameKeys
         internal override bool CompileMethods(
             CommonPEModuleBuilder moduleBuilder,
             bool emittingPdb,
-            bool emitMetadataOnly,
-            bool emitTestCoverageData,
             DiagnosticBag diagnostics,
             Predicate<ISymbolInternal>? filterOpt,
             CancellationToken cancellationToken)
         {
+            var emitMetadataOnly = moduleBuilder.EmitOptions.EmitMetadataOnly;
+
             // The diagnostics should include syntax and declaration errors. We insert these before calling Emitter.Emit, so that the emitter
             // does not attempt to emit if there are declaration errors (but we do insert all errors from method body binding...)
             PooledHashSet<int>? excludeDiagnostics = null;
@@ -3233,7 +3231,7 @@ internal override bool CompileMethods(
             }
             else
             {
-                if ((emittingPdb || emitTestCoverageData) &&
+                if ((emittingPdb || moduleBeingBuilt.EmitOptions.InstrumentationKinds.Contains(InstrumentationKind.TestCoverage)) &&
                     !CreateDebugDocuments(moduleBeingBuilt.DebugDocumentsBuilder, moduleBeingBuilt.EmbeddedTexts, diagnostics))
                 {
                     return false;
@@ -3251,7 +3249,6 @@ internal override bool CompileMethods(
                     this,
                     moduleBeingBuilt,
                     emittingPdb,
-                    emitTestCoverageData,
                     hasDeclarationErrors,
                     emitMethodBodies: true,
                     diagnostics: new BindingDiagnosticBag(methodBodyDiagnosticBag),
diff --git a/src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs b/src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs
index 55d82663ec0e6..c7e8f8c7c39af 100644
--- a/src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs
+++ b/src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs
@@ -29,16 +29,16 @@ internal sealed class MethodCompiler : CSharpSymbolVisitor<TypeCompilationState,
     {
         private readonly CSharpCompilation _compilation;
         private readonly bool _emittingPdb;
-        private readonly bool _emitTestCoverageData;
         private readonly CancellationToken _cancellationToken;
         private readonly BindingDiagnosticBag _diagnostics;
         private readonly bool _hasDeclarationErrors;
         private readonly bool _emitMethodBodies;
         private readonly PEModuleBuilder _moduleBeingBuiltOpt; // Null if compiling for diagnostics
         private readonly Predicate<Symbol> _filterOpt;         // If not null, limit analysis to specific symbols
-        private readonly DebugDocumentProvider _debugDocumentProvider;
         private readonly SynthesizedEntryPointSymbol.AsyncForwardEntryPoint _entryPointOpt;
 
+        private DebugDocumentProvider _lazyDebugDocumentProvider;
+
         //
         // MethodCompiler employs concurrency by following flattened fork/join pattern.
         //
@@ -83,7 +83,7 @@ private void SetGlobalErrorIfTrue(bool arg)
         }
 
         // Internal for testing only.
-        internal MethodCompiler(CSharpCompilation compilation, PEModuleBuilder moduleBeingBuiltOpt, bool emittingPdb, bool emitTestCoverageData, bool hasDeclarationErrors, bool emitMethodBodies,
+        internal MethodCompiler(CSharpCompilation compilation, PEModuleBuilder moduleBeingBuiltOpt, bool emittingPdb, bool hasDeclarationErrors, bool emitMethodBodies,
             BindingDiagnosticBag diagnostics, Predicate<Symbol> filterOpt, SynthesizedEntryPointSymbol.AsyncForwardEntryPoint entryPointOpt, CancellationToken cancellationToken)
         {
             Debug.Assert(compilation != null);
@@ -102,12 +102,6 @@ internal MethodCompiler(CSharpCompilation compilation, PEModuleBuilder moduleBei
             _hasDeclarationErrors = hasDeclarationErrors;
             SetGlobalErrorIfTrue(hasDeclarationErrors);
 
-            if (emittingPdb || emitTestCoverageData)
-            {
-                _debugDocumentProvider = (path, basePath) => moduleBeingBuiltOpt.DebugDocumentsBuilder.GetOrAddDebugDocument(path, basePath, CreateDebugDocumentForFile);
-            }
-
-            _emitTestCoverageData = emitTestCoverageData;
             _emitMethodBodies = emitMethodBodies;
         }
 
@@ -115,7 +109,6 @@ public static void CompileMethodBodies(
             CSharpCompilation compilation,
             PEModuleBuilder moduleBeingBuiltOpt,
             bool emittingPdb,
-            bool emitTestCoverageData,
             bool hasDeclarationErrors,
             bool emitMethodBodies,
             BindingDiagnosticBag diagnostics,
@@ -147,7 +140,6 @@ public static void CompileMethodBodies(
                 compilation,
                 moduleBeingBuiltOpt,
                 emittingPdb,
-                emitTestCoverageData,
                 hasDeclarationErrors,
                 emitMethodBodies,
                 diagnostics,
@@ -260,7 +252,6 @@ private static MethodSymbol GetEntryPoint(CSharpCompilation compilation, PEModul
                     return entryPoint;
                 }
 
-                var dynamicAnalysisSpans = ImmutableArray<SourceSpan>.Empty;
                 VariableSlotAllocator lazyVariableSlotAllocator = null;
                 var lambdaDebugInfoBuilder = ArrayBuilder<LambdaDebugInfo>.GetInstance();
                 var closureDebugInfoBuilder = ArrayBuilder<ClosureDebugInfo>.GetInstance();
@@ -272,11 +263,11 @@ private static MethodSymbol GetEntryPoint(CSharpCompilation compilation, PEModul
                     synthesizedEntryPoint,
                     methodOrdinal,
                     body,
-                    null,
+                    previousSubmissionFields: null,
                     new TypeCompilationState(synthesizedEntryPoint.ContainingType, compilation, moduleBeingBuilt),
-                    false,
-                    null,
-                    ref dynamicAnalysisSpans,
+                    instrumentation: MethodInstrumentation.Empty,
+                    debugDocumentProvider: null,
+                    out ImmutableArray<SourceSpan> codeCoverageSpans,
                     diagnostics,
                     ref lazyVariableSlotAllocator,
                     lambdaDebugInfoBuilder,
@@ -284,9 +275,9 @@ private static MethodSymbol GetEntryPoint(CSharpCompilation compilation, PEModul
                     stateMachineStateDebugInfoBuilder,
                     out stateMachineTypeOpt);
 
-                Debug.Assert((object)lazyVariableSlotAllocator == null);
-                Debug.Assert((object)stateMachineTypeOpt == null);
-                Debug.Assert(dynamicAnalysisSpans.IsEmpty);
+                Debug.Assert(lazyVariableSlotAllocator is null);
+                Debug.Assert(stateMachineTypeOpt is null);
+                Debug.Assert(codeCoverageSpans.IsEmpty);
                 Debug.Assert(lambdaDebugInfoBuilder.IsEmpty());
                 Debug.Assert(closureDebugInfoBuilder.IsEmpty());
                 Debug.Assert(stateMachineStateDebugInfoBuilder.IsEmpty());
@@ -311,8 +302,7 @@ private static MethodSymbol GetEntryPoint(CSharpCompilation compilation, PEModul
                         debugDocumentProvider: null,
                         importChainOpt: null,
                         emittingPdb: false,
-                        emitTestCoverageData: false,
-                        dynamicAnalysisSpans: ImmutableArray<SourceSpan>.Empty,
+                        codeCoverageSpans: ImmutableArray<SourceSpan>.Empty,
                         entryPointOpt: null);
                     moduleBeingBuilt.SetMethodBody(synthesizedEntryPoint, emittedBody);
                 }
@@ -346,6 +336,18 @@ private static void WarnUnusedFields(CSharpCompilation compilation, BindingDiagn
         private bool ReportNullableDiagnostics
             => _moduleBeingBuiltOpt?.IsEncDelta != true;
 
+        private DebugDocumentProvider GetDebugDocumentProvider(MethodInstrumentation instrumentation)
+        {
+            if (_emittingPdb || instrumentation.Kinds.Contains(InstrumentationKind.TestCoverage))
+            {
+                Debug.Assert(_moduleBeingBuiltOpt != null);
+                return _lazyDebugDocumentProvider ??= new DebugDocumentProvider((path, basePath) =>
+                    _moduleBeingBuiltOpt.DebugDocumentsBuilder.GetOrAddDebugDocument(path, basePath, CreateDebugDocumentForFile));
+            }
+
+            return null;
+        }
+
         public override object VisitNamespace(NamespaceSymbol symbol, TypeCompilationState arg)
         {
             if (!PassesFilter(_filterOpt, symbol))
@@ -746,7 +748,6 @@ private void CompileSynthesizedMethods(TypeCompilationState compilationState)
                             stateMachine = stateMachine ?? asyncStateMachine;
                         }
 
-                        var factory = new SyntheticBoundNodeFactory(method, methodWithBody.Body.Syntax, compilationState, diagnosticsThisMethod);
                         SetGlobalErrorIfTrue(diagnosticsThisMethod.HasAnyErrors());
 
                         if (_emitMethodBodies && !diagnosticsThisMethod.HasAnyErrors() && !_globalHasErrors)
@@ -762,11 +763,10 @@ private void CompileSynthesizedMethods(TypeCompilationState compilationState)
                                 stateMachine,
                                 variableSlotAllocatorOpt,
                                 diagnosticsThisMethod,
-                                _debugDocumentProvider,
+                                GetDebugDocumentProvider(MethodInstrumentation.Empty),
                                 method.GenerateDebugInfo ? importChain : null,
                                 emittingPdb: _emittingPdb,
-                                emitTestCoverageData: _emitTestCoverageData,
-                                dynamicAnalysisSpans: ImmutableArray<SourceSpan>.Empty,
+                                codeCoverageSpans: ImmutableArray<SourceSpan>.Empty,
                                 _entryPointOpt);
                         }
                     }
@@ -856,11 +856,15 @@ private void CompileSynthesizedSealedAccessors(SourcePropertySymbolBase sourcePr
 
         private void CompileFieldLikeEventAccessor(SourceEventSymbol eventSymbol, bool isAddMethod)
         {
+            Debug.Assert(_moduleBeingBuiltOpt != null);
+
             MethodSymbol accessor = isAddMethod ? eventSymbol.AddMethod : eventSymbol.RemoveMethod;
 
             var diagnosticsThisMethod = BindingDiagnosticBag.GetInstance(_diagnostics);
             try
             {
+                var instrumentation = _moduleBeingBuiltOpt.GetMethodBodyInstrumentations(accessor);
+
                 BoundBlock boundBody = MethodBodySynthesizer.ConstructFieldLikeEventAccessorBody(eventSymbol, isAddMethod, _compilation, diagnosticsThisMethod);
                 var hasErrors = diagnosticsThisMethod.HasAnyErrors();
                 SetGlobalErrorIfTrue(hasErrors);
@@ -883,11 +887,10 @@ private void CompileFieldLikeEventAccessor(SourceEventSymbol eventSymbol, bool i
                         stateMachineTypeOpt: null,
                         variableSlotAllocatorOpt: null,
                         diagnostics: diagnosticsThisMethod,
-                        debugDocumentProvider: _debugDocumentProvider,
+                        debugDocumentProvider: GetDebugDocumentProvider(instrumentation),
                         importChainOpt: null,
                         emittingPdb: false,
-                        emitTestCoverageData: _emitTestCoverageData,
-                        dynamicAnalysisSpans: ImmutableArray<SourceSpan>.Empty,
+                        codeCoverageSpans: ImmutableArray<SourceSpan>.Empty,
                         entryPointOpt: null);
 
                     _moduleBeingBuiltOpt.SetMethodBody(accessor, emittedBody);
@@ -986,6 +989,7 @@ private void CompileMethod(
                 bool includeNonEmptyInitializersInBody = false;
                 BoundBlock body;
                 bool originalBodyNested = false;
+                var instrumentation = compilationState.ModuleBuilderOpt?.GetMethodBodyInstrumentations(methodSymbol) ?? MethodInstrumentation.Empty;
 
                 // initializers that have been analyzed but not yet lowered.
                 BoundStatementList analyzedInitializers = null;
@@ -1067,9 +1071,14 @@ private void CompileMethod(
                     // appended to its body.
                     if (includeNonEmptyInitializersInBody && processedInitializers.LoweredInitializers == null)
                     {
-                        if (body != null && ((methodSymbol.ContainingType.IsStructType() && !methodSymbol.IsImplicitConstructor) || methodSymbol is SynthesizedRecordConstructor || _emitTestCoverageData))
+                        if (body != null &&
+                            ((methodSymbol.ContainingType.IsStructType() && !methodSymbol.IsImplicitConstructor) ||
+                            methodSymbol is SynthesizedRecordConstructor ||
+                            instrumentation.Kinds.Contains(InstrumentationKind.TestCoverage) ||
+                            instrumentation.Kinds.Contains(InstrumentationKind.LocalStateTracing)))
                         {
-                            if (_emitTestCoverageData && methodSymbol.IsImplicitConstructor)
+                            if (methodSymbol.IsImplicitConstructor &&
+                                (instrumentation.Kinds.Contains(InstrumentationKind.TestCoverage) || instrumentation.Kinds.Contains(InstrumentationKind.LocalStateTracing)))
                             {
                                 // Flow analysis over the initializers is necessary in order to find assignments to fields.
                                 // Bodies of implicit constructors do not get flow analysis later, so the initializers
@@ -1084,7 +1093,7 @@ private void CompileMethod(
                             {
                                 insertAt = 1;
                             }
-                            body = body.Update(body.Locals, body.LocalFunctions, body.HasUnsafeModifier, body.Statements.Insert(insertAt, analyzedInitializers));
+                            body = body.Update(body.Locals, body.LocalFunctions, body.HasUnsafeModifier, body.Instrumentation, body.Statements.Insert(insertAt, analyzedInitializers));
                             includeNonEmptyInitializersInBody = false;
                             analyzedInitializers = null;
                         }
@@ -1187,7 +1196,7 @@ forSemanticModel.Syntax is { } semanticModelSyntax &&
                 // Any errors generated below here are considered Emit diagnostics
                 // and will not be reported to callers Compilation.GetDiagnostics()
 
-                ImmutableArray<SourceSpan> dynamicAnalysisSpans = ImmutableArray<SourceSpan>.Empty;
+                ImmutableArray<SourceSpan> codeCoverageSpans;
                 bool hasBody = flowAnalyzedBody != null;
                 VariableSlotAllocator lazyVariableSlotAllocator = null;
                 StateMachineTypeSymbol stateMachineTypeOpt = null;
@@ -1206,9 +1215,9 @@ forSemanticModel.Syntax is { } semanticModelSyntax &&
                             flowAnalyzedBody,
                             previousSubmissionFields,
                             compilationState,
-                            _emitTestCoverageData,
-                            _debugDocumentProvider,
-                            ref dynamicAnalysisSpans,
+                            instrumentation,
+                            GetDebugDocumentProvider(instrumentation),
+                            out codeCoverageSpans,
                             diagsForCurrentMethod,
                             ref lazyVariableSlotAllocator,
                             lambdaDebugInfoBuilder,
@@ -1221,6 +1230,7 @@ forSemanticModel.Syntax is { } semanticModelSyntax &&
                     else
                     {
                         loweredBodyOpt = null;
+                        codeCoverageSpans = ImmutableArray<SourceSpan>.Empty;
                     }
 
                     hasErrors = hasErrors || (hasBody && loweredBodyOpt.HasErrors) || diagsForCurrentMethod.HasAnyErrors();
@@ -1248,10 +1258,9 @@ forSemanticModel.Syntax is { } semanticModelSyntax &&
 
                             if (analyzedInitializers != null)
                             {
-                                // For dynamic analysis, field initializers are instrumented as part of constructors,
+                                // For test coverage, field initializers are instrumented as part of constructors,
                                 // and so are never instrumented here.
-                                Debug.Assert(!_emitTestCoverageData);
-                                StateMachineTypeSymbol initializerStateMachineTypeOpt;
+                                Debug.Assert(!instrumentation.Kinds.Contains(InstrumentationKind.TestCoverage));
 
                                 BoundStatement lowered = LowerBodyOrInitializer(
                                     methodSymbol,
@@ -1259,20 +1268,22 @@ forSemanticModel.Syntax is { } semanticModelSyntax &&
                                     analyzedInitializers,
                                     previousSubmissionFields,
                                     compilationState,
-                                    _emitTestCoverageData,
-                                    _debugDocumentProvider,
-                                    ref dynamicAnalysisSpans,
+                                    instrumentation,
+                                    GetDebugDocumentProvider(instrumentation),
+                                    out ImmutableArray<SourceSpan> initializerCodeCoverageSpans,
                                     diagsForCurrentMethod,
                                     ref lazyVariableSlotAllocator,
                                     lambdaDebugInfoBuilder,
                                     closureDebugInfoBuilder,
                                     stateMachineStateDebugInfoBuilder,
-                                    out initializerStateMachineTypeOpt);
+                                    out StateMachineTypeSymbol initializerStateMachineTypeOpt);
+
+                                Debug.Assert(initializerCodeCoverageSpans.IsEmpty);
 
                                 processedInitializers.LoweredInitializers = lowered;
 
                                 // initializers can't produce state machines
-                                Debug.Assert((object)initializerStateMachineTypeOpt == null);
+                                Debug.Assert(initializerStateMachineTypeOpt is null);
                                 Debug.Assert(!hasErrors);
                                 hasErrors = lowered.HasAnyErrors || diagsForCurrentMethod.HasAnyErrors();
                                 SetGlobalErrorIfTrue(hasErrors);
@@ -1331,11 +1342,10 @@ forSemanticModel.Syntax is { } semanticModelSyntax &&
                                 stateMachineTypeOpt,
                                 lazyVariableSlotAllocator,
                                 diagsForCurrentMethod,
-                                _debugDocumentProvider,
+                                GetDebugDocumentProvider(instrumentation),
                                 importChain,
                                 _emittingPdb,
-                                _emitTestCoverageData,
-                                dynamicAnalysisSpans,
+                                codeCoverageSpans,
                                 entryPointOpt: null);
 
                             _moduleBeingBuiltOpt.SetMethodBody(methodSymbol.PartialDefinitionPart ?? methodSymbol, emittedBody);
@@ -1365,9 +1375,9 @@ internal static BoundStatement LowerBodyOrInitializer(
             BoundStatement body,
             SynthesizedSubmissionFields previousSubmissionFields,
             TypeCompilationState compilationState,
-            bool instrumentForDynamicAnalysis,
+            MethodInstrumentation instrumentation,
             DebugDocumentProvider debugDocumentProvider,
-            ref ImmutableArray<SourceSpan> dynamicAnalysisSpans,
+            out ImmutableArray<SourceSpan> codeCoverageSpans,
             BindingDiagnosticBag diagnostics,
             ref VariableSlotAllocator lazyVariableSlotAllocator,
             ArrayBuilder<LambdaDebugInfo> lambdaDebugInfoBuilder,
@@ -1380,6 +1390,7 @@ internal static BoundStatement LowerBodyOrInitializer(
 
             if (body.HasErrors)
             {
+                codeCoverageSpans = ImmutableArray<SourceSpan>.Empty;
                 return body;
             }
 
@@ -1394,10 +1405,10 @@ internal static BoundStatement LowerBodyOrInitializer(
                     compilationState,
                     previousSubmissionFields: previousSubmissionFields,
                     allowOmissionOfConditionalCalls: true,
-                    instrumentForDynamicAnalysis: instrumentForDynamicAnalysis,
+                    instrumentation: instrumentation,
                     debugDocumentProvider: debugDocumentProvider,
-                    dynamicAnalysisSpans: ref dynamicAnalysisSpans,
                     diagnostics: diagnostics,
+                    codeCoverageSpans: out codeCoverageSpans,
                     sawLambdas: out bool sawLambdas,
                     sawLocalFunctions: out bool sawLocalFunctions,
                     sawAwaitInExceptionHandler: out bool sawAwaitInExceptionHandler);
@@ -1470,6 +1481,7 @@ internal static BoundStatement LowerBodyOrInitializer(
             }
             catch (BoundTreeVisitor.CancelledByStackGuardException ex)
             {
+                codeCoverageSpans = ImmutableArray<SourceSpan>.Empty;
                 ex.AddAnError(diagnostics);
                 return new BoundBadStatement(body.Syntax, ImmutableArray.Create<BoundNode>(body), hasErrors: true);
             }
@@ -1492,8 +1504,7 @@ private static MethodBody GenerateMethodBody(
             DebugDocumentProvider debugDocumentProvider,
             ImportChain importChainOpt,
             bool emittingPdb,
-            bool emitTestCoverageData,
-            ImmutableArray<SourceSpan> dynamicAnalysisSpans,
+            ImmutableArray<SourceSpan> codeCoverageSpans,
             SynthesizedEntryPointSymbol.AsyncForwardEntryPoint entryPointOpt)
         {
             // Note: don't call diagnostics.HasAnyErrors() in release; could be expensive if compilation has many warnings.
@@ -1605,13 +1616,6 @@ private static MethodBody GenerateMethodBody(
                     Debug.Assert(!diagnostics.HasAnyErrors());
                 }
 
-                DynamicAnalysisMethodBodyData dynamicAnalysisDataOpt = null;
-                if (emitTestCoverageData)
-                {
-                    Debug.Assert(debugDocumentProvider != null);
-                    dynamicAnalysisDataOpt = new DynamicAnalysisMethodBodyData(dynamicAnalysisSpans);
-                }
-
                 return new MethodBody(
                     builder.RealizedIL,
                     builder.MaxStack,
@@ -1634,7 +1638,7 @@ private static MethodBody GenerateMethodBody(
                     stateMachineAwaiterSlots,
                     StateMachineStatesDebugInfo.Create(variableSlotAllocatorOpt, stateMachineStateDebugInfos),
                     moveNextBodyDebugInfoOpt,
-                    dynamicAnalysisDataOpt);
+                    codeCoverageSpans);
             }
             finally
             {
@@ -1715,7 +1719,7 @@ private static void GetStateMachineSlotDebugInfo(
 
         // NOTE: can return null if the method has no body.
 #nullable enable
-        internal static BoundBlock? BindMethodBody(MethodSymbol method, TypeCompilationState compilationState, BindingDiagnosticBag diagnostics)
+        internal static BoundBlock? BindSynthesizedMethodBody(MethodSymbol method, TypeCompilationState compilationState, BindingDiagnosticBag diagnostics)
         {
             return BindMethodBody(
                 method,
diff --git a/src/Compilers/CSharp/Portable/Emitter/EditAndContinue/PEDeltaAssemblyBuilder.cs b/src/Compilers/CSharp/Portable/Emitter/EditAndContinue/PEDeltaAssemblyBuilder.cs
index 49728110865e6..5a09cbfae53f0 100644
--- a/src/Compilers/CSharp/Portable/Emitter/EditAndContinue/PEDeltaAssemblyBuilder.cs
+++ b/src/Compilers/CSharp/Portable/Emitter/EditAndContinue/PEDeltaAssemblyBuilder.cs
@@ -304,6 +304,14 @@ public IReadOnlyDictionary<string, AnonymousTypeValue> GetAnonymousDelegatesWith
             return _previousDefinitions.TryCreateVariableSlotAllocator(_previousGeneration, Compilation, method, topLevelMethod, diagnostics);
         }
 
+        internal override MethodInstrumentation GetMethodBodyInstrumentations(MethodSymbol method)
+        {
+            // EmitDifference does not allow settings these:
+            Debug.Assert(EmitOptions.InstrumentationKinds.IsEmpty);
+
+            return _previousDefinitions.GetMethodBodyInstrumentations(method);
+        }
+
         internal override ImmutableArray<AnonymousTypeKey> GetPreviousAnonymousTypes()
         {
             return ImmutableArray.CreateRange(_previousGeneration.AnonymousTypeMap.Keys);
diff --git a/src/Compilers/CSharp/Portable/Emitter/Model/PEModuleBuilder.cs b/src/Compilers/CSharp/Portable/Emitter/Model/PEModuleBuilder.cs
index 9ae34a1d53d11..231d6ebd18091 100644
--- a/src/Compilers/CSharp/Portable/Emitter/Model/PEModuleBuilder.cs
+++ b/src/Compilers/CSharp/Portable/Emitter/Model/PEModuleBuilder.cs
@@ -495,6 +495,9 @@ internal virtual VariableSlotAllocator TryCreateVariableSlotAllocator(MethodSymb
             return null;
         }
 
+        internal virtual MethodInstrumentation GetMethodBodyInstrumentations(MethodSymbol method)
+            => new MethodInstrumentation { Kinds = EmitOptions.InstrumentationKinds };
+
         internal virtual ImmutableArray<AnonymousTypeKey> GetPreviousAnonymousTypes()
         {
             return ImmutableArray<AnonymousTypeKey>.Empty;
diff --git a/src/Compilers/CSharp/Portable/FlowAnalysis/AbstractFlowPass.cs b/src/Compilers/CSharp/Portable/FlowAnalysis/AbstractFlowPass.cs
index f3268b5e9ae7d..ee6e5f6d613a0 100644
--- a/src/Compilers/CSharp/Portable/FlowAnalysis/AbstractFlowPass.cs
+++ b/src/Compilers/CSharp/Portable/FlowAnalysis/AbstractFlowPass.cs
@@ -1583,11 +1583,26 @@ protected void SplitIfBooleanConstant(BoundExpression node)
             }
         }
 
+        public override BoundNode VisitLocalId(BoundLocalId node)
+        {
+            return null;
+        }
+
+        public override BoundNode VisitParameterId(BoundParameterId node)
+        {
+            return null;
+        }
+
         public override BoundNode VisitMethodDefIndex(BoundMethodDefIndex node)
         {
             return null;
         }
 
+        public override BoundNode VisitStateMachineInstanceId(BoundStateMachineInstanceId node)
+        {
+            return null;
+        }
+
         public override BoundNode VisitMaximumMethodDefIndex(BoundMaximumMethodDefIndex node)
         {
             return null;
diff --git a/src/Compilers/CSharp/Portable/FlowAnalysis/DefiniteAssignment.cs b/src/Compilers/CSharp/Portable/FlowAnalysis/DefiniteAssignment.cs
index c2c61e05fabe2..f41ea90fa51c7 100644
--- a/src/Compilers/CSharp/Portable/FlowAnalysis/DefiniteAssignment.cs
+++ b/src/Compilers/CSharp/Portable/FlowAnalysis/DefiniteAssignment.cs
@@ -1884,6 +1884,12 @@ void assignPatternVariablesAndMarkReadFields(BoundPattern pattern, bool definite
 
         public override BoundNode VisitBlock(BoundBlock node)
         {
+            if (node.Instrumentation != null)
+            {
+                DeclareVariable(node.Instrumentation.Local);
+                Visit(node.Instrumentation.Prologue);
+            }
+
             DeclareVariables(node.Locals);
 
             VisitStatementsWithLocalFunctions(node);
@@ -1900,6 +1906,11 @@ public override BoundNode VisitBlock(BoundBlock node)
             ReportUnusedVariables(node.Locals);
             ReportUnusedVariables(node.LocalFunctions);
 
+            if (node.Instrumentation != null)
+            {
+                Visit(node.Instrumentation.Epilogue);
+            }
+
             return null;
         }
 
@@ -2136,6 +2147,15 @@ public override BoundNode VisitLocalDeclaration(BoundLocalDeclaration node)
             return result;
         }
 
+        public override BoundNode VisitLocalId(BoundLocalId node)
+            => null;
+
+        public override BoundNode VisitParameterId(BoundParameterId node)
+            => null;
+
+        public override BoundNode VisitStateMachineInstanceId(BoundStateMachineInstanceId node)
+            => null;
+
         public override BoundNode VisitMethodGroup(BoundMethodGroup node)
         {
             foreach (var method in node.Methods)
diff --git a/src/Compilers/CSharp/Portable/FlowAnalysis/FlowAnalysisPass.cs b/src/Compilers/CSharp/Portable/FlowAnalysis/FlowAnalysisPass.cs
index e1c94fdf8826c..bea4590292441 100644
--- a/src/Compilers/CSharp/Portable/FlowAnalysis/FlowAnalysisPass.cs
+++ b/src/Compilers/CSharp/Portable/FlowAnalysis/FlowAnalysisPass.cs
@@ -139,7 +139,7 @@ private static BoundBlock PrependImplicitInitializations(BoundBlock body, Method
             }
             var initializations = F.HiddenSequencePoint(F.Block(builder.ToImmutableAndFree()));
 
-            return body.Update(body.Locals, body.LocalFunctions, body.HasUnsafeModifier, body.Statements.Insert(index: 0, initializations));
+            return body.Update(body.Locals, body.LocalFunctions, body.HasUnsafeModifier, body.Instrumentation, body.Statements.Insert(index: 0, initializations));
         }
 
         private static BoundBlock AppendImplicitReturn(BoundBlock body, MethodSymbol method, bool originalBodyNested)
@@ -153,7 +153,7 @@ private static BoundBlock AppendImplicitReturn(BoundBlock body, MethodSymbol met
                 builder.AddRange(statements, n - 1);
                 builder.Add(AppendImplicitReturn((BoundBlock)statements[n - 1], method));
 
-                return body.Update(body.Locals, ImmutableArray<LocalFunctionSymbol>.Empty, body.HasUnsafeModifier, builder.ToImmutableAndFree());
+                return body.Update(body.Locals, ImmutableArray<LocalFunctionSymbol>.Empty, body.HasUnsafeModifier, body.Instrumentation, builder.ToImmutableAndFree());
             }
             else
             {
@@ -181,7 +181,7 @@ internal static BoundBlock AppendImplicitReturn(BoundBlock body, MethodSymbol me
                 ? (BoundStatement)BoundYieldBreakStatement.Synthesized(syntax)
                 : BoundReturnStatement.Synthesized(syntax, RefKind.None, null);
 
-            return body.Update(body.Locals, body.LocalFunctions, body.HasUnsafeModifier, body.Statements.Add(ret));
+            return body.Update(body.Locals, body.LocalFunctions, body.HasUnsafeModifier, body.Instrumentation, body.Statements.Add(ret));
         }
 
         private static bool Analyze(
diff --git a/src/Compilers/CSharp/Portable/FlowAnalysis/LocalDataFlowPass.cs b/src/Compilers/CSharp/Portable/FlowAnalysis/LocalDataFlowPass.cs
index 8b97a9acee215..18a66cec0a6de 100644
--- a/src/Compilers/CSharp/Portable/FlowAnalysis/LocalDataFlowPass.cs
+++ b/src/Compilers/CSharp/Portable/FlowAnalysis/LocalDataFlowPass.cs
@@ -74,6 +74,15 @@ protected LocalDataFlowPass(
         /// </summary>
         protected int VariableSlot(Symbol symbol, int containingSlot = 0)
         {
+            // Skip LocalStoreTracker from data flow analysis.
+            // The variable is declared by synthesized instrumentation code in every instrumented method (including async, iterators and lambdas).
+            // It is of a ref-struct type, which is normally not allowed to be used in some of these methods, but is designed to not be lifted to
+            // a closure or state machine field and only directly accessed from the frame it is declared in.
+            if (symbol is LocalSymbol { SynthesizedKind: SynthesizedLocalKind.LocalStoreTracker })
+            {
+                return -1;
+            }
+
             containingSlot = DescendThroughTupleRestFields(ref symbol, containingSlot, forceContainingSlotsToExist: false);
 
             int slot;
diff --git a/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs b/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs
index 23a95b8825bd2..7061cfdad42c1 100644
--- a/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs
+++ b/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs
@@ -73,7 +73,11 @@ internal enum BoundKind : byte
         AwaitableInfo,
         AwaitExpression,
         TypeOfOperator,
+        BlockInstrumentation,
         MethodDefIndex,
+        LocalId,
+        ParameterId,
+        StateMachineInstanceId,
         MaximumMethodDefIndex,
         InstrumentationPayloadRoot,
         ModuleVersionId,
@@ -2209,6 +2213,40 @@ public BoundTypeOfOperator Update(BoundTypeExpression sourceType, MethodSymbol?
         }
     }
 
+    internal sealed partial class BoundBlockInstrumentation : BoundNode
+    {
+        public BoundBlockInstrumentation(SyntaxNode syntax, LocalSymbol local, BoundStatement prologue, BoundStatement epilogue, bool hasErrors = false)
+            : base(BoundKind.BlockInstrumentation, syntax, hasErrors || prologue.HasErrors() || epilogue.HasErrors())
+        {
+
+            RoslynDebug.Assert(local is object, "Field 'local' cannot be null (make the type nullable in BoundNodes.xml to remove this check)");
+            RoslynDebug.Assert(prologue is object, "Field 'prologue' cannot be null (make the type nullable in BoundNodes.xml to remove this check)");
+            RoslynDebug.Assert(epilogue is object, "Field 'epilogue' cannot be null (make the type nullable in BoundNodes.xml to remove this check)");
+
+            this.Local = local;
+            this.Prologue = prologue;
+            this.Epilogue = epilogue;
+        }
+
+        public LocalSymbol Local { get; }
+        public BoundStatement Prologue { get; }
+        public BoundStatement Epilogue { get; }
+
+        [DebuggerStepThrough]
+        public override BoundNode? Accept(BoundTreeVisitor visitor) => visitor.VisitBlockInstrumentation(this);
+
+        public BoundBlockInstrumentation Update(LocalSymbol local, BoundStatement prologue, BoundStatement epilogue)
+        {
+            if (!Symbols.SymbolEqualityComparer.ConsiderEverything.Equals(local, this.Local) || prologue != this.Prologue || epilogue != this.Epilogue)
+            {
+                var result = new BoundBlockInstrumentation(this.Syntax, local, prologue, epilogue, this.HasErrors);
+                result.CopyAttributes(this);
+                return result;
+            }
+            return this;
+        }
+    }
+
     internal sealed partial class BoundMethodDefIndex : BoundExpression
     {
         public BoundMethodDefIndex(SyntaxNode syntax, MethodSymbol method, TypeSymbol type, bool hasErrors)
@@ -2249,6 +2287,130 @@ public BoundMethodDefIndex Update(MethodSymbol method, TypeSymbol type)
         }
     }
 
+    internal sealed partial class BoundLocalId : BoundExpression
+    {
+        public BoundLocalId(SyntaxNode syntax, LocalSymbol local, FieldSymbol? hoistedField, TypeSymbol type, bool hasErrors)
+            : base(BoundKind.LocalId, syntax, type, hasErrors)
+        {
+
+            RoslynDebug.Assert(local is object, "Field 'local' cannot be null (make the type nullable in BoundNodes.xml to remove this check)");
+            RoslynDebug.Assert(type is object, "Field 'type' cannot be null (make the type nullable in BoundNodes.xml to remove this check)");
+
+            this.Local = local;
+            this.HoistedField = hoistedField;
+        }
+
+        public BoundLocalId(SyntaxNode syntax, LocalSymbol local, FieldSymbol? hoistedField, TypeSymbol type)
+            : base(BoundKind.LocalId, syntax, type)
+        {
+
+            RoslynDebug.Assert(local is object, "Field 'local' cannot be null (make the type nullable in BoundNodes.xml to remove this check)");
+            RoslynDebug.Assert(type is object, "Field 'type' cannot be null (make the type nullable in BoundNodes.xml to remove this check)");
+
+            this.Local = local;
+            this.HoistedField = hoistedField;
+        }
+
+        public new TypeSymbol Type => base.Type!;
+        public LocalSymbol Local { get; }
+        public FieldSymbol? HoistedField { get; }
+
+        [DebuggerStepThrough]
+        public override BoundNode? Accept(BoundTreeVisitor visitor) => visitor.VisitLocalId(this);
+
+        public BoundLocalId Update(LocalSymbol local, FieldSymbol? hoistedField, TypeSymbol type)
+        {
+            if (!Symbols.SymbolEqualityComparer.ConsiderEverything.Equals(local, this.Local) || !Symbols.SymbolEqualityComparer.ConsiderEverything.Equals(hoistedField, this.HoistedField) || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything))
+            {
+                var result = new BoundLocalId(this.Syntax, local, hoistedField, type, this.HasErrors);
+                result.CopyAttributes(this);
+                return result;
+            }
+            return this;
+        }
+    }
+
+    internal sealed partial class BoundParameterId : BoundExpression
+    {
+        public BoundParameterId(SyntaxNode syntax, ParameterSymbol parameter, FieldSymbol? hoistedField, TypeSymbol type, bool hasErrors)
+            : base(BoundKind.ParameterId, syntax, type, hasErrors)
+        {
+
+            RoslynDebug.Assert(parameter is object, "Field 'parameter' cannot be null (make the type nullable in BoundNodes.xml to remove this check)");
+            RoslynDebug.Assert(type is object, "Field 'type' cannot be null (make the type nullable in BoundNodes.xml to remove this check)");
+
+            this.Parameter = parameter;
+            this.HoistedField = hoistedField;
+        }
+
+        public BoundParameterId(SyntaxNode syntax, ParameterSymbol parameter, FieldSymbol? hoistedField, TypeSymbol type)
+            : base(BoundKind.ParameterId, syntax, type)
+        {
+
+            RoslynDebug.Assert(parameter is object, "Field 'parameter' cannot be null (make the type nullable in BoundNodes.xml to remove this check)");
+            RoslynDebug.Assert(type is object, "Field 'type' cannot be null (make the type nullable in BoundNodes.xml to remove this check)");
+
+            this.Parameter = parameter;
+            this.HoistedField = hoistedField;
+        }
+
+        public new TypeSymbol Type => base.Type!;
+        public ParameterSymbol Parameter { get; }
+        public FieldSymbol? HoistedField { get; }
+
+        [DebuggerStepThrough]
+        public override BoundNode? Accept(BoundTreeVisitor visitor) => visitor.VisitParameterId(this);
+
+        public BoundParameterId Update(ParameterSymbol parameter, FieldSymbol? hoistedField, TypeSymbol type)
+        {
+            if (!Symbols.SymbolEqualityComparer.ConsiderEverything.Equals(parameter, this.Parameter) || !Symbols.SymbolEqualityComparer.ConsiderEverything.Equals(hoistedField, this.HoistedField) || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything))
+            {
+                var result = new BoundParameterId(this.Syntax, parameter, hoistedField, type, this.HasErrors);
+                result.CopyAttributes(this);
+                return result;
+            }
+            return this;
+        }
+    }
+
+    internal sealed partial class BoundStateMachineInstanceId : BoundExpression
+    {
+        public BoundStateMachineInstanceId(SyntaxNode syntax, FieldSymbol? field, TypeSymbol type, bool hasErrors)
+            : base(BoundKind.StateMachineInstanceId, syntax, type, hasErrors)
+        {
+
+            RoslynDebug.Assert(type is object, "Field 'type' cannot be null (make the type nullable in BoundNodes.xml to remove this check)");
+
+            this.Field = field;
+        }
+
+        public BoundStateMachineInstanceId(SyntaxNode syntax, FieldSymbol? field, TypeSymbol type)
+            : base(BoundKind.StateMachineInstanceId, syntax, type)
+        {
+
+            RoslynDebug.Assert(type is object, "Field 'type' cannot be null (make the type nullable in BoundNodes.xml to remove this check)");
+
+            this.Field = field;
+        }
+
+        public new TypeSymbol Type => base.Type!;
+        public FieldSymbol? Field { get; }
+
+        [DebuggerStepThrough]
+        public override BoundNode? Accept(BoundTreeVisitor visitor) => visitor.VisitStateMachineInstanceId(this);
+
+        public BoundStateMachineInstanceId Update(FieldSymbol? field, TypeSymbol type)
+        {
+            if (!Symbols.SymbolEqualityComparer.ConsiderEverything.Equals(field, this.Field) || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything))
+            {
+                var result = new BoundStateMachineInstanceId(this.Syntax, field, type, this.HasErrors);
+                result.CopyAttributes(this);
+                return result;
+            }
+            return this;
+        }
+    }
+
     internal sealed partial class BoundMaximumMethodDefIndex : BoundExpression
     {
         public BoundMaximumMethodDefIndex(SyntaxNode syntax, TypeSymbol type, bool hasErrors)
@@ -3031,8 +3193,8 @@ public BoundStepThroughSequencePoint Update(TextSpan span)
 
     internal sealed partial class BoundBlock : BoundStatementList
     {
-        public BoundBlock(SyntaxNode syntax, ImmutableArray<LocalSymbol> locals, ImmutableArray<LocalFunctionSymbol> localFunctions, bool hasUnsafeModifier, ImmutableArray<BoundStatement> statements, bool hasErrors = false)
-            : base(BoundKind.Block, syntax, statements, hasErrors || statements.HasErrors())
+        public BoundBlock(SyntaxNode syntax, ImmutableArray<LocalSymbol> locals, ImmutableArray<LocalFunctionSymbol> localFunctions, bool hasUnsafeModifier, BoundBlockInstrumentation? instrumentation, ImmutableArray<BoundStatement> statements, bool hasErrors = false)
+            : base(BoundKind.Block, syntax, statements, hasErrors || instrumentation.HasErrors() || statements.HasErrors())
         {
 
             RoslynDebug.Assert(!locals.IsDefault, "Field 'locals' cannot be null (use Null=\"allow\" in BoundNodes.xml to remove this check)");
@@ -3042,20 +3204,22 @@ public BoundBlock(SyntaxNode syntax, ImmutableArray<LocalSymbol> locals, Immutab
             this.Locals = locals;
             this.LocalFunctions = localFunctions;
             this.HasUnsafeModifier = hasUnsafeModifier;
+            this.Instrumentation = instrumentation;
         }
 
         public ImmutableArray<LocalSymbol> Locals { get; }
         public ImmutableArray<LocalFunctionSymbol> LocalFunctions { get; }
         public bool HasUnsafeModifier { get; }
+        public BoundBlockInstrumentation? Instrumentation { get; }
 
         [DebuggerStepThrough]
         public override BoundNode? Accept(BoundTreeVisitor visitor) => visitor.VisitBlock(this);
 
-        public BoundBlock Update(ImmutableArray<LocalSymbol> locals, ImmutableArray<LocalFunctionSymbol> localFunctions, bool hasUnsafeModifier, ImmutableArray<BoundStatement> statements)
+        public BoundBlock Update(ImmutableArray<LocalSymbol> locals, ImmutableArray<LocalFunctionSymbol> localFunctions, bool hasUnsafeModifier, BoundBlockInstrumentation? instrumentation, ImmutableArray<BoundStatement> statements)
         {
-            if (locals != this.Locals || localFunctions != this.LocalFunctions || hasUnsafeModifier != this.HasUnsafeModifier || statements != this.Statements)
+            if (locals != this.Locals || localFunctions != this.LocalFunctions || hasUnsafeModifier != this.HasUnsafeModifier || instrumentation != this.Instrumentation || statements != this.Statements)
             {
-                var result = new BoundBlock(this.Syntax, locals, localFunctions, hasUnsafeModifier, statements, this.HasErrors);
+                var result = new BoundBlock(this.Syntax, locals, localFunctions, hasUnsafeModifier, instrumentation, statements, this.HasErrors);
                 result.CopyAttributes(this);
                 return result;
             }
@@ -8450,8 +8614,16 @@ internal R VisitInternal(BoundNode node, A arg)
                     return VisitAwaitExpression((BoundAwaitExpression)node, arg);
                 case BoundKind.TypeOfOperator:
                     return VisitTypeOfOperator((BoundTypeOfOperator)node, arg);
+                case BoundKind.BlockInstrumentation:
+                    return VisitBlockInstrumentation((BoundBlockInstrumentation)node, arg);
                 case BoundKind.MethodDefIndex:
                     return VisitMethodDefIndex((BoundMethodDefIndex)node, arg);
+                case BoundKind.LocalId:
+                    return VisitLocalId((BoundLocalId)node, arg);
+                case BoundKind.ParameterId:
+                    return VisitParameterId((BoundParameterId)node, arg);
+                case BoundKind.StateMachineInstanceId:
+                    return VisitStateMachineInstanceId((BoundStateMachineInstanceId)node, arg);
                 case BoundKind.MaximumMethodDefIndex:
                     return VisitMaximumMethodDefIndex((BoundMaximumMethodDefIndex)node, arg);
                 case BoundKind.InstrumentationPayloadRoot:
@@ -8845,7 +9017,11 @@ internal abstract partial class BoundTreeVisitor<A, R>
         public virtual R VisitAwaitableInfo(BoundAwaitableInfo node, A arg) => this.DefaultVisit(node, arg);
         public virtual R VisitAwaitExpression(BoundAwaitExpression node, A arg) => this.DefaultVisit(node, arg);
         public virtual R VisitTypeOfOperator(BoundTypeOfOperator node, A arg) => this.DefaultVisit(node, arg);
+        public virtual R VisitBlockInstrumentation(BoundBlockInstrumentation node, A arg) => this.DefaultVisit(node, arg);
         public virtual R VisitMethodDefIndex(BoundMethodDefIndex node, A arg) => this.DefaultVisit(node, arg);
+        public virtual R VisitLocalId(BoundLocalId node, A arg) => this.DefaultVisit(node, arg);
+        public virtual R VisitParameterId(BoundParameterId node, A arg) => this.DefaultVisit(node, arg);
+        public virtual R VisitStateMachineInstanceId(BoundStateMachineInstanceId node, A arg) => this.DefaultVisit(node, arg);
         public virtual R VisitMaximumMethodDefIndex(BoundMaximumMethodDefIndex node, A arg) => this.DefaultVisit(node, arg);
         public virtual R VisitInstrumentationPayloadRoot(BoundInstrumentationPayloadRoot node, A arg) => this.DefaultVisit(node, arg);
         public virtual R VisitModuleVersionId(BoundModuleVersionId node, A arg) => this.DefaultVisit(node, arg);
@@ -9069,7 +9245,11 @@ internal abstract partial class BoundTreeVisitor
         public virtual BoundNode? VisitAwaitableInfo(BoundAwaitableInfo node) => this.DefaultVisit(node);
         public virtual BoundNode? VisitAwaitExpression(BoundAwaitExpression node) => this.DefaultVisit(node);
         public virtual BoundNode? VisitTypeOfOperator(BoundTypeOfOperator node) => this.DefaultVisit(node);
+        public virtual BoundNode? VisitBlockInstrumentation(BoundBlockInstrumentation node) => this.DefaultVisit(node);
         public virtual BoundNode? VisitMethodDefIndex(BoundMethodDefIndex node) => this.DefaultVisit(node);
+        public virtual BoundNode? VisitLocalId(BoundLocalId node) => this.DefaultVisit(node);
+        public virtual BoundNode? VisitParameterId(BoundParameterId node) => this.DefaultVisit(node);
+        public virtual BoundNode? VisitStateMachineInstanceId(BoundStateMachineInstanceId node) => this.DefaultVisit(node);
         public virtual BoundNode? VisitMaximumMethodDefIndex(BoundMaximumMethodDefIndex node) => this.DefaultVisit(node);
         public virtual BoundNode? VisitInstrumentationPayloadRoot(BoundInstrumentationPayloadRoot node) => this.DefaultVisit(node);
         public virtual BoundNode? VisitModuleVersionId(BoundModuleVersionId node) => this.DefaultVisit(node);
@@ -9460,7 +9640,16 @@ internal abstract partial class BoundTreeWalker : BoundTreeVisitor
             this.Visit(node.SourceType);
             return null;
         }
+        public override BoundNode? VisitBlockInstrumentation(BoundBlockInstrumentation node)
+        {
+            this.Visit(node.Prologue);
+            this.Visit(node.Epilogue);
+            return null;
+        }
         public override BoundNode? VisitMethodDefIndex(BoundMethodDefIndex node) => null;
+        public override BoundNode? VisitLocalId(BoundLocalId node) => null;
+        public override BoundNode? VisitParameterId(BoundParameterId node) => null;
+        public override BoundNode? VisitStateMachineInstanceId(BoundStateMachineInstanceId node) => null;
         public override BoundNode? VisitMaximumMethodDefIndex(BoundMaximumMethodDefIndex node) => null;
         public override BoundNode? VisitInstrumentationPayloadRoot(BoundInstrumentationPayloadRoot node) => null;
         public override BoundNode? VisitModuleVersionId(BoundModuleVersionId node) => null;
@@ -9523,6 +9712,7 @@ internal abstract partial class BoundTreeWalker : BoundTreeVisitor
         public override BoundNode? VisitStepThroughSequencePoint(BoundStepThroughSequencePoint node) => null;
         public override BoundNode? VisitBlock(BoundBlock node)
         {
+            this.Visit(node.Instrumentation);
             this.VisitList(node.Statements);
             return null;
         }
@@ -10553,11 +10743,32 @@ internal abstract partial class BoundTreeRewriter : BoundTreeVisitor
             TypeSymbol? type = this.VisitType(node.Type);
             return node.Update(sourceType, node.GetTypeFromHandle, type);
         }
+        public override BoundNode? VisitBlockInstrumentation(BoundBlockInstrumentation node)
+        {
+            BoundStatement prologue = (BoundStatement)this.Visit(node.Prologue);
+            BoundStatement epilogue = (BoundStatement)this.Visit(node.Epilogue);
+            return node.Update(node.Local, prologue, epilogue);
+        }
         public override BoundNode? VisitMethodDefIndex(BoundMethodDefIndex node)
         {
             TypeSymbol? type = this.VisitType(node.Type);
             return node.Update(node.Method, type);
         }
+        public override BoundNode? VisitLocalId(BoundLocalId node)
+        {
+            TypeSymbol? type = this.VisitType(node.Type);
+            return node.Update(node.Local, node.HoistedField, type);
+        }
+        public override BoundNode? VisitParameterId(BoundParameterId node)
+        {
+            TypeSymbol? type = this.VisitType(node.Type);
+            return node.Update(node.Parameter, node.HoistedField, type);
+        }
+        public override BoundNode? VisitStateMachineInstanceId(BoundStateMachineInstanceId node)
+        {
+            TypeSymbol? type = this.VisitType(node.Type);
+            return node.Update(node.Field, type);
+        }
         public override BoundNode? VisitMaximumMethodDefIndex(BoundMaximumMethodDefIndex node)
         {
             TypeSymbol? type = this.VisitType(node.Type);
@@ -10673,8 +10884,9 @@ internal abstract partial class BoundTreeRewriter : BoundTreeVisitor
         public override BoundNode? VisitStepThroughSequencePoint(BoundStepThroughSequencePoint node) => node;
         public override BoundNode? VisitBlock(BoundBlock node)
         {
+            BoundBlockInstrumentation? instrumentation = (BoundBlockInstrumentation?)this.Visit(node.Instrumentation);
             ImmutableArray<BoundStatement> statements = this.VisitList(node.Statements);
-            return node.Update(node.Locals, node.LocalFunctions, node.HasUnsafeModifier, statements);
+            return node.Update(node.Locals, node.LocalFunctions, node.HasUnsafeModifier, instrumentation, statements);
         }
         public override BoundNode? VisitScope(BoundScope node)
         {
@@ -12327,6 +12539,14 @@ public NullabilityRewriter(ImmutableDictionary<BoundExpression, (NullabilityInfo
             return updatedNode;
         }
 
+        public override BoundNode? VisitBlockInstrumentation(BoundBlockInstrumentation node)
+        {
+            LocalSymbol local = GetUpdatedSymbol(node, node.Local);
+            BoundStatement prologue = (BoundStatement)this.Visit(node.Prologue);
+            BoundStatement epilogue = (BoundStatement)this.Visit(node.Epilogue);
+            return node.Update(local, prologue, epilogue);
+        }
+
         public override BoundNode? VisitMethodDefIndex(BoundMethodDefIndex node)
         {
             MethodSymbol method = GetUpdatedSymbol(node, node.Method);
@@ -12344,6 +12564,59 @@ public NullabilityRewriter(ImmutableDictionary<BoundExpression, (NullabilityInfo
             return updatedNode;
         }
 
+        public override BoundNode? VisitLocalId(BoundLocalId node)
+        {
+            LocalSymbol local = GetUpdatedSymbol(node, node.Local);
+            FieldSymbol? hoistedField = GetUpdatedSymbol(node, node.HoistedField);
+            BoundLocalId updatedNode;
+
+            if (_updatedNullabilities.TryGetValue(node, out (NullabilityInfo Info, TypeSymbol? Type) infoAndType))
+            {
+                updatedNode = node.Update(local, hoistedField, infoAndType.Type!);
+                updatedNode.TopLevelNullability = infoAndType.Info;
+            }
+            else
+            {
+                updatedNode = node.Update(local, hoistedField, node.Type);
+            }
+            return updatedNode;
+        }
+
+        public override BoundNode? VisitParameterId(BoundParameterId node)
+        {
+            ParameterSymbol parameter = GetUpdatedSymbol(node, node.Parameter);
+            FieldSymbol? hoistedField = GetUpdatedSymbol(node, node.HoistedField);
+            BoundParameterId updatedNode;
+
+            if (_updatedNullabilities.TryGetValue(node, out (NullabilityInfo Info, TypeSymbol? Type) infoAndType))
+            {
+                updatedNode = node.Update(parameter, hoistedField, infoAndType.Type!);
+                updatedNode.TopLevelNullability = infoAndType.Info;
+            }
+            else
+            {
+                updatedNode = node.Update(parameter, hoistedField, node.Type);
+            }
+            return updatedNode;
+        }
+
+        public override BoundNode? VisitStateMachineInstanceId(BoundStateMachineInstanceId node)
+        {
+            FieldSymbol? field = GetUpdatedSymbol(node, node.Field);
+            BoundStateMachineInstanceId updatedNode;
+
+            if (_updatedNullabilities.TryGetValue(node, out (NullabilityInfo Info, TypeSymbol? Type) infoAndType))
+            {
+                updatedNode = node.Update(field, infoAndType.Type!);
+                updatedNode.TopLevelNullability = infoAndType.Info;
+            }
+            else
+            {
+                updatedNode = node.Update(field, node.Type);
+            }
+            return updatedNode;
+        }
+
         public override BoundNode? VisitMaximumMethodDefIndex(BoundMaximumMethodDefIndex node)
         {
             if (!_updatedNullabilities.TryGetValue(node, out (NullabilityInfo Info, TypeSymbol? Type) infoAndType))
@@ -12614,8 +12887,9 @@ public NullabilityRewriter(ImmutableDictionary<BoundExpression, (NullabilityInfo
         {
             ImmutableArray<LocalSymbol> locals = GetUpdatedArray(node, node.Locals);
             ImmutableArray<LocalFunctionSymbol> localFunctions = GetUpdatedArray(node, node.LocalFunctions);
+            BoundBlockInstrumentation? instrumentation = (BoundBlockInstrumentation?)this.Visit(node.Instrumentation);
             ImmutableArray<BoundStatement> statements = this.VisitList(node.Statements);
-            return node.Update(locals, localFunctions, node.HasUnsafeModifier, statements);
+            return node.Update(locals, localFunctions, node.HasUnsafeModifier, instrumentation, statements);
         }
 
         public override BoundNode? VisitScope(BoundScope node)
@@ -14646,6 +14920,14 @@ private BoundTreeDumperNodeProducer()
             new TreeDumperNode("hasErrors", node.HasErrors, null)
         }
         );
+        public override TreeDumperNode VisitBlockInstrumentation(BoundBlockInstrumentation node, object? arg) => new TreeDumperNode("blockInstrumentation", null, new TreeDumperNode[]
+        {
+            new TreeDumperNode("local", node.Local, null),
+            new TreeDumperNode("prologue", null, new TreeDumperNode[] { Visit(node.Prologue, null) }),
+            new TreeDumperNode("epilogue", null, new TreeDumperNode[] { Visit(node.Epilogue, null) }),
+            new TreeDumperNode("hasErrors", node.HasErrors, null)
+        }
+        );
         public override TreeDumperNode VisitMethodDefIndex(BoundMethodDefIndex node, object? arg) => new TreeDumperNode("methodDefIndex", null, new TreeDumperNode[]
         {
             new TreeDumperNode("method", node.Method, null),
@@ -14654,6 +14936,32 @@ private BoundTreeDumperNodeProducer()
             new TreeDumperNode("hasErrors", node.HasErrors, null)
         }
         );
+        public override TreeDumperNode VisitLocalId(BoundLocalId node, object? arg) => new TreeDumperNode("localId", null, new TreeDumperNode[]
+        {
+            new TreeDumperNode("local", node.Local, null),
+            new TreeDumperNode("hoistedField", node.HoistedField, null),
+            new TreeDumperNode("type", node.Type, null),
+            new TreeDumperNode("isSuppressed", node.IsSuppressed, null),
+            new TreeDumperNode("hasErrors", node.HasErrors, null)
+        }
+        );
+        public override TreeDumperNode VisitParameterId(BoundParameterId node, object? arg) => new TreeDumperNode("parameterId", null, new TreeDumperNode[]
+        {
+            new TreeDumperNode("parameter", node.Parameter, null),
+            new TreeDumperNode("hoistedField", node.HoistedField, null),
+            new TreeDumperNode("type", node.Type, null),
+            new TreeDumperNode("isSuppressed", node.IsSuppressed, null),
+            new TreeDumperNode("hasErrors", node.HasErrors, null)
+        }
+        );
+        public override TreeDumperNode VisitStateMachineInstanceId(BoundStateMachineInstanceId node, object? arg) => new TreeDumperNode("stateMachineInstanceId", null, new TreeDumperNode[]
+        {
+            new TreeDumperNode("field", node.Field, null),
+            new TreeDumperNode("type", node.Type, null),
+            new TreeDumperNode("isSuppressed", node.IsSuppressed, null),
+            new TreeDumperNode("hasErrors", node.HasErrors, null)
+        }
+        );
         public override TreeDumperNode VisitMaximumMethodDefIndex(BoundMaximumMethodDefIndex node, object? arg) => new TreeDumperNode("maximumMethodDefIndex", null, new TreeDumperNode[]
         {
             new TreeDumperNode("type", node.Type, null),
@@ -14843,6 +15151,7 @@ private BoundTreeDumperNodeProducer()
             new TreeDumperNode("locals", node.Locals, null),
             new TreeDumperNode("localFunctions", node.LocalFunctions, null),
             new TreeDumperNode("hasUnsafeModifier", node.HasUnsafeModifier, null),
+            new TreeDumperNode("instrumentation", null, new TreeDumperNode[] { Visit(node.Instrumentation, null) }),
             new TreeDumperNode("statements", null, from x in node.Statements select Visit(x, null)),
             new TreeDumperNode("hasErrors", node.HasErrors, null)
         }
diff --git a/src/Compilers/CSharp/Portable/Lowering/AsyncRewriter/AsyncIteratorMethodToStateMachineRewriter.cs b/src/Compilers/CSharp/Portable/Lowering/AsyncRewriter/AsyncIteratorMethodToStateMachineRewriter.cs
index 7b9e2eb374a75..373dd5e281c66 100644
--- a/src/Compilers/CSharp/Portable/Lowering/AsyncRewriter/AsyncIteratorMethodToStateMachineRewriter.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/AsyncRewriter/AsyncIteratorMethodToStateMachineRewriter.cs
@@ -2,8 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-#nullable disable
-
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics;
@@ -45,22 +43,24 @@ internal sealed class AsyncIteratorMethodToStateMachineRewriter : AsyncMethodToS
         /// </summary>
         private readonly ResumableStateMachineStateAllocator _iteratorStateAllocator;
 
-        internal AsyncIteratorMethodToStateMachineRewriter(MethodSymbol method,
+        internal AsyncIteratorMethodToStateMachineRewriter(
+            MethodSymbol method,
             int methodOrdinal,
             AsyncMethodBuilderMemberCollection asyncMethodBuilderMemberCollection,
             AsyncIteratorInfo asyncIteratorInfo,
             SyntheticBoundNodeFactory F,
             FieldSymbol state,
             FieldSymbol builder,
+            FieldSymbol? instanceIdField,
             Roslyn.Utilities.IReadOnlySet<Symbol> hoistedVariables,
             IReadOnlyDictionary<Symbol, CapturedSymbolReplacement> nonReusableLocalProxies,
             SynthesizedLocalOrdinalsDispenser synthesizedLocalOrdinals,
             ArrayBuilder<StateMachineStateDebugInfo> stateMachineStateDebugInfoBuilder,
-            VariableSlotAllocator slotAllocatorOpt,
+            VariableSlotAllocator? slotAllocatorOpt,
             int nextFreeHoistedLocalSlot,
             BindingDiagnosticBag diagnostics)
             : base(method, methodOrdinal, asyncMethodBuilderMemberCollection, F,
-                  state, builder, hoistedVariables, nonReusableLocalProxies, synthesizedLocalOrdinals,
+                  state, builder, instanceIdField, hoistedVariables, nonReusableLocalProxies, synthesizedLocalOrdinals,
                   stateMachineStateDebugInfoBuilder, slotAllocatorOpt, nextFreeHoistedLocalSlot, diagnostics)
         {
             Debug.Assert(asyncIteratorInfo != null);
@@ -75,7 +75,6 @@ internal AsyncIteratorMethodToStateMachineRewriter(MethodSymbol method,
                 increasing: false);
         }
 
-#nullable enable
         protected override BoundStatement? GenerateMissingStateDispatch()
         {
             var asyncDispatch = base.GenerateMissingStateDispatch();
diff --git a/src/Compilers/CSharp/Portable/Lowering/AsyncRewriter/AsyncMethodToStateMachineRewriter.cs b/src/Compilers/CSharp/Portable/Lowering/AsyncRewriter/AsyncMethodToStateMachineRewriter.cs
index 1b226cd8cf903..fe5b105e6a046 100644
--- a/src/Compilers/CSharp/Portable/Lowering/AsyncRewriter/AsyncMethodToStateMachineRewriter.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/AsyncRewriter/AsyncMethodToStateMachineRewriter.cs
@@ -2,8 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-#nullable disable
-
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
@@ -55,7 +53,7 @@ internal class AsyncMethodToStateMachineRewriter : MethodToStateMachineRewriter
         /// of rewritten return expressions. The return-handling code then uses <c>SetResult</c> on the async method builder
         /// to make the result available to the caller.
         /// </summary>
-        private readonly LocalSymbol _exprRetValue;
+        private readonly LocalSymbol? _exprRetValue;
 
         private readonly LoweredDynamicOperationFactory _dynamicFactory;
 
@@ -71,14 +69,15 @@ internal AsyncMethodToStateMachineRewriter(
             SyntheticBoundNodeFactory F,
             FieldSymbol state,
             FieldSymbol builder,
+            FieldSymbol? instanceIdField,
             Roslyn.Utilities.IReadOnlySet<Symbol> hoistedVariables,
             IReadOnlyDictionary<Symbol, CapturedSymbolReplacement> nonReusableLocalProxies,
             SynthesizedLocalOrdinalsDispenser synthesizedLocalOrdinals,
             ArrayBuilder<StateMachineStateDebugInfo> stateMachineStateDebugInfoBuilder,
-            VariableSlotAllocator slotAllocatorOpt,
+            VariableSlotAllocator? slotAllocatorOpt,
             int nextFreeHoistedLocalSlot,
             BindingDiagnosticBag diagnostics)
-            : base(F, method, state, hoistedVariables, nonReusableLocalProxies, synthesizedLocalOrdinals, stateMachineStateDebugInfoBuilder, slotAllocatorOpt, nextFreeHoistedLocalSlot, diagnostics)
+            : base(F, method, state, instanceIdField, hoistedVariables, nonReusableLocalProxies, synthesizedLocalOrdinals, stateMachineStateDebugInfoBuilder, slotAllocatorOpt, nextFreeHoistedLocalSlot, diagnostics)
         {
             _method = method;
             _asyncMethodBuilderMemberCollection = asyncMethodBuilderMemberCollection;
@@ -97,6 +96,8 @@ internal AsyncMethodToStateMachineRewriter(
             _placeholderMap = new Dictionary<BoundValuePlaceholderBase, BoundExpression>();
         }
 
+#nullable disable
+
         private FieldSymbol GetAwaiterField(TypeSymbol awaiterType)
         {
             FieldSymbol result;
@@ -202,6 +203,14 @@ internal void GenerateMoveNext(BoundStatement body, MethodSymbol moveNextMethod)
                 newBody = MakeStateMachineScope(rootScopeHoistedLocals, newBody);
             }
 
+            if (_instrumentation != null)
+            {
+                newBody = F.Block(
+                    ImmutableArray.Create(_instrumentation.Local),
+                    _instrumentation.Prologue,
+                    F.Try(F.Block(newBody), ImmutableArray<BoundCatchBlock>.Empty, F.Block(_instrumentation.Epilogue)));
+            }
+
             F.CloseMethod(newBody);
         }
 
diff --git a/src/Compilers/CSharp/Portable/Lowering/AsyncRewriter/AsyncRewriter.AsyncIteratorRewriter.cs b/src/Compilers/CSharp/Portable/Lowering/AsyncRewriter/AsyncRewriter.AsyncIteratorRewriter.cs
index 52d39ced4976c..5c81336330c45 100644
--- a/src/Compilers/CSharp/Portable/Lowering/AsyncRewriter/AsyncRewriter.AsyncIteratorRewriter.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/AsyncRewriter/AsyncRewriter.AsyncIteratorRewriter.cs
@@ -175,9 +175,14 @@ protected override void GenerateConstructor()
                     bodyBuilder.Add(F.Assignment(F.InstanceField(initialThreadIdField), managedThreadId));
                 }
 
+                if (instanceIdField is not null &&
+                    F.WellKnownMethod(WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__GetNewStateMachineInstanceId) is { } getId)
+                {
+                    bodyBuilder.Add(F.Assignment(F.InstanceField(instanceIdField), F.Call(receiver: null, getId)));
+                }
+
                 bodyBuilder.Add(F.Return());
                 F.CloseMethod(F.Block(bodyBuilder.ToImmutableAndFree()));
-                bodyBuilder = null;
             }
 
             private BoundExpressionStatement GenerateCreateAndAssignBuilder()
@@ -694,6 +699,7 @@ protected override void GenerateMoveNext(SynthesizedImplementationMethod moveNex
                     F: F,
                     state: stateField,
                     builder: _builderField,
+                    instanceIdField: instanceIdField,
                     hoistedVariables: hoistedVariables,
                     nonReusableLocalProxies: nonReusableLocalProxies,
                     synthesizedLocalOrdinals: synthesizedLocalOrdinals,
diff --git a/src/Compilers/CSharp/Portable/Lowering/AsyncRewriter/AsyncRewriter.cs b/src/Compilers/CSharp/Portable/Lowering/AsyncRewriter/AsyncRewriter.cs
index 28bfc2bbc0906..a5ebcf7acdcc9 100644
--- a/src/Compilers/CSharp/Portable/Lowering/AsyncRewriter/AsyncRewriter.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/AsyncRewriter/AsyncRewriter.cs
@@ -2,12 +2,12 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-#nullable disable
-
 using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.Diagnostics;
 using Microsoft.CodeAnalysis.CodeGen;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
+using Microsoft.CodeAnalysis.Emit;
 using Microsoft.CodeAnalysis.PooledObjects;
 
 namespace Microsoft.CodeAnalysis.CSharp
@@ -18,7 +18,7 @@ internal partial class AsyncRewriter : StateMachineRewriter
         private readonly bool _constructedSuccessfully;
         private readonly int _methodOrdinal;
 
-        private FieldSymbol _builderField;
+        private FieldSymbol? _builderField;
 
         private AsyncRewriter(
             BoundStatement body,
@@ -26,7 +26,7 @@ private AsyncRewriter(
             int methodOrdinal,
             AsyncStateMachine stateMachineType,
             ArrayBuilder<StateMachineStateDebugInfo> stateMachineStateDebugInfoBuilder,
-            VariableSlotAllocator slotAllocatorOpt,
+            VariableSlotAllocator? slotAllocatorOpt,
             TypeCompilationState compilationState,
             BindingDiagnosticBag diagnostics)
             : base(body, method, stateMachineType, stateMachineStateDebugInfoBuilder, slotAllocatorOpt, compilationState, diagnostics)
@@ -43,11 +43,13 @@ internal static BoundStatement Rewrite(
             MethodSymbol method,
             int methodOrdinal,
             ArrayBuilder<StateMachineStateDebugInfo> stateMachineStateDebugInfoBuilder,
-            VariableSlotAllocator slotAllocatorOpt,
+            VariableSlotAllocator? slotAllocatorOpt,
             TypeCompilationState compilationState,
             BindingDiagnosticBag diagnostics,
-            out AsyncStateMachine stateMachineType)
+            out AsyncStateMachine? stateMachineType)
         {
+            Debug.Assert(compilationState.ModuleBuilderOpt != null);
+
             if (!method.IsAsync)
             {
                 stateMachineType = null;
@@ -94,6 +96,8 @@ internal static BoundStatement Rewrite(
             }
         }
 
+#nullable disable
+
         /// <returns>
         /// Returns true if all types and members we need are present and good
         /// </returns>
@@ -134,9 +138,14 @@ protected override bool PreserveInitialParameterValuesAndThreadId
         protected override void GenerateControlFields()
         {
             // the fields are initialized from async method, so they need to be public:
-
-            this.stateField = F.StateMachineField(F.SpecialType(SpecialType.System_Int32), GeneratedNames.MakeStateMachineStateFieldName(), isPublic: true);
+            stateField = F.StateMachineField(F.SpecialType(SpecialType.System_Int32), GeneratedNames.MakeStateMachineStateFieldName(), isPublic: true);
             _builderField = F.StateMachineField(_asyncMethodBuilderMemberCollection.BuilderType, GeneratedNames.AsyncBuilderFieldName(), isPublic: true);
+
+            var instrumentations = F.ModuleBuilderOpt.GetMethodBodyInstrumentations(method);
+            if (instrumentations.Kinds.Contains(InstrumentationKind.LocalStateTracing))
+            {
+                instanceIdField = F.StateMachineField(F.SpecialType(SpecialType.System_UInt64), GeneratedNames.MakeStateMachineStateIdFieldName(), isPublic: true);
+            }
         }
 
         protected override void GenerateMethodImplementations()
@@ -232,6 +241,16 @@ protected override BoundStatement GenerateStateMachineCreation(LocalSymbol state
                     F.Field(F.Local(stateMachineVariable), stateField.AsMember(frameType)),
                     F.Literal(StateMachineState.NotStartedOrRunningState)));
 
+            // local.$instanceIdField = LocalStoreTracker.GetNewStateMachineInstanceId()
+            if (instanceIdField is not null &&
+                F.WellKnownMethod(WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__GetNewStateMachineInstanceId) is { } getId)
+            {
+                bodyBuilder.Add(
+                    F.Assignment(
+                        F.Field(F.Local(stateMachineVariable), instanceIdField.AsMember(frameType)),
+                        F.Call(receiver: null, getId)));
+            }
+
             // local.$builder.Start(ref local) -- binding to the method AsyncTaskMethodBuilder<typeArgs>.Start()
             var startMethod = methodScopeAsyncMethodBuilderMemberCollection.Start.Construct(frameType);
             if (methodScopeAsyncMethodBuilderMemberCollection.CheckGenericMethodConstraints)
@@ -264,6 +283,7 @@ protected virtual void GenerateMoveNext(SynthesizedImplementationMethod moveNext
                 F: F,
                 state: stateField,
                 builder: _builderField,
+                instanceIdField: instanceIdField,
                 hoistedVariables: hoistedVariables,
                 nonReusableLocalProxies: nonReusableLocalProxies,
                 synthesizedLocalOrdinals: synthesizedLocalOrdinals,
diff --git a/src/Compilers/CSharp/Portable/Lowering/ClosureConversion/ClosureConversion.cs b/src/Compilers/CSharp/Portable/Lowering/ClosureConversion/ClosureConversion.cs
index 60e5904d86ae1..74547985cd76f 100644
--- a/src/Compilers/CSharp/Portable/Lowering/ClosureConversion/ClosureConversion.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/ClosureConversion/ClosureConversion.cs
@@ -346,7 +346,7 @@ private void SynthesizeClosureEnvironments(ArrayBuilder<ClosureDebugInfo> closur
                         AddSynthesizedMethod(
                             frame.Constructor,
                             FlowAnalysisPass.AppendImplicitReturn(
-                                MethodCompiler.BindMethodBody(frame.Constructor, CompilationState, Diagnostics),
+                                MethodCompiler.BindSynthesizedMethodBody(frame.Constructor, CompilationState, Diagnostics),
                                 frame.Constructor));
                     }
 
@@ -540,7 +540,7 @@ private SynthesizedClosureEnvironment GetStaticFrame(BindingDiagnosticBag diagno
                     AddSynthesizedMethod(
                         frame.Constructor,
                         FlowAnalysisPass.AppendImplicitReturn(
-                            MethodCompiler.BindMethodBody(frame.Constructor, CompilationState, diagnostics),
+                            MethodCompiler.BindSynthesizedMethodBody(frame.Constructor, CompilationState, diagnostics),
                             frame.Constructor));
 
                     // add cctor
@@ -824,6 +824,16 @@ public override BoundNode VisitBaseReference(BoundBaseReference node)
                 : FramePointer(node.Syntax, _topLevelMethod.ContainingType); // technically, not the correct static type
         }
 
+        public override BoundNode VisitMethodDefIndex(BoundMethodDefIndex node)
+        {
+            TypeSymbol type = VisitType(node.Type);
+
+            var loweredSymbol = (node.Method.MethodKind is MethodKind.LambdaMethod or MethodKind.LocalFunction) ?
+                Analysis.GetNestedFunctionInTree(_analysis.ScopeTree, node.Method.OriginalDefinition).SynthesizedLoweredMethod : node.Method;
+
+            return node.Update(loweredSymbol, type);
+        }
+
         /// <summary>
         /// Rewrites a reference to an unlowered local function to the newly
         /// lowered local function.
@@ -1145,8 +1155,16 @@ private BoundBlock RewriteBlock(BoundBlock node, ArrayBuilder<BoundExpression> p
                 }
             }
 
+            var newInstrumentation = node.Instrumentation;
+            if (newInstrumentation != null)
+            {
+                var newPrologue = (BoundStatement)Visit(newInstrumentation.Prologue);
+                var newEpilogue = (BoundStatement)Visit(newInstrumentation.Epilogue);
+                newInstrumentation = newInstrumentation.Update(newInstrumentation.Local, newPrologue, newEpilogue);
+            }
+
             // TODO: we may not need to update if there was nothing to rewrite.
-            return node.Update(newLocals.ToImmutableAndFree(), node.LocalFunctions, node.HasUnsafeModifier, newStatements.ToImmutableAndFree());
+            return node.Update(newLocals.ToImmutableAndFree(), node.LocalFunctions, node.HasUnsafeModifier, newInstrumentation, newStatements.ToImmutableAndFree());
         }
 
         public override BoundNode VisitScope(BoundScope node)
diff --git a/src/Compilers/CSharp/Portable/Lowering/ClosureConversion/LambdaCapturedVariable.cs b/src/Compilers/CSharp/Portable/Lowering/ClosureConversion/LambdaCapturedVariable.cs
index 6bbb8027b6639..276339c998645 100644
--- a/src/Compilers/CSharp/Portable/Lowering/ClosureConversion/LambdaCapturedVariable.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/ClosureConversion/LambdaCapturedVariable.cs
@@ -57,8 +57,7 @@ private static string GetCapturedVariableFieldName(Symbol variable, ref int uniq
                 return GeneratedNames.ThisProxyFieldName();
             }
 
-            var local = variable as LocalSymbol;
-            if ((object)local != null)
+            if (variable is LocalSymbol local)
             {
                 if (local.SynthesizedKind == SynthesizedLocalKind.LambdaDisplayClass)
                 {
@@ -75,6 +74,9 @@ private static string GetCapturedVariableFieldName(Symbol variable, ref int uniq
                     return GeneratedNames.MakeSynthesizedInstrumentationPayloadLocalFieldName(uniqueId++);
                 }
 
+                // should never be captured:
+                Debug.Assert(local.SynthesizedKind != SynthesizedLocalKind.LocalStoreTracker);
+
                 if (local.SynthesizedKind == SynthesizedLocalKind.UserDefined &&
                     (local.ScopeDesignatorOpt?.Kind() == SyntaxKind.SwitchSection ||
                      local.ScopeDesignatorOpt?.Kind() == SyntaxKind.SwitchExpressionArm))
diff --git a/src/Compilers/CSharp/Portable/Lowering/Instrumentation/CodeCoverageInstrumenter.cs b/src/Compilers/CSharp/Portable/Lowering/Instrumentation/CodeCoverageInstrumenter.cs
index 2a8de79140946..7f0e79edfd813 100644
--- a/src/Compilers/CSharp/Portable/Lowering/Instrumentation/CodeCoverageInstrumenter.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/Instrumentation/CodeCoverageInstrumenter.cs
@@ -234,9 +234,9 @@ private static BoundExpressionStatement GetCreatePayloadStatement(
                     methodBodyFactory.Literal(dynamicAnalysisSpans.Length)));
         }
 
-        public override void InstrumentBlock(BoundBlock original, LocalRewriter rewriter, ref TemporaryArray<LocalSymbol> additionalLocals, out BoundStatement? prologue, out BoundStatement? epilogue)
+        public override void InstrumentBlock(BoundBlock original, LocalRewriter rewriter, ref TemporaryArray<LocalSymbol> additionalLocals, out BoundStatement? prologue, out BoundStatement? epilogue, out BoundBlockInstrumentation? instrumentation)
         {
-            base.InstrumentBlock(original, rewriter, ref additionalLocals, out var previousPrologue, out epilogue);
+            base.InstrumentBlock(original, rewriter, ref additionalLocals, out var previousPrologue, out epilogue, out instrumentation);
 
             // only instrument method body block:
             if (original != rewriter.CurrentMethodBody)
@@ -381,9 +381,9 @@ public override BoundStatement InstrumentWhileStatementConditionalGotoStartOrBre
             return AddDynamicAnalysis(original, base.InstrumentWhileStatementConditionalGotoStartOrBreak(original, ifConditionGotoStart));
         }
 
-        public override BoundStatement InstrumentLocalInitialization(BoundLocalDeclaration original, BoundStatement rewritten)
+        public override BoundStatement InstrumentUserDefinedLocalInitialization(BoundLocalDeclaration original, BoundStatement rewritten)
         {
-            return AddDynamicAnalysis(original, base.InstrumentLocalInitialization(original, rewritten));
+            return AddDynamicAnalysis(original, base.InstrumentUserDefinedLocalInitialization(original, rewritten));
         }
 
         public override BoundStatement InstrumentLockTargetCapture(BoundLockStatement original, BoundStatement lockTargetCapture)
diff --git a/src/Compilers/CSharp/Portable/Lowering/Instrumentation/CompoundInstrumenter.cs b/src/Compilers/CSharp/Portable/Lowering/Instrumentation/CompoundInstrumenter.cs
index d21afbaa8bd8a..54033c05e80a9 100644
--- a/src/Compilers/CSharp/Portable/Lowering/Instrumentation/CompoundInstrumenter.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/Instrumentation/CompoundInstrumenter.cs
@@ -79,9 +79,14 @@ public override BoundStatement InstrumentBreakStatement(BoundBreakStatement orig
             return Previous.InstrumentBreakStatement(original, rewritten);
         }
 
-        public override void InstrumentBlock(BoundBlock original, LocalRewriter rewriter, ref TemporaryArray<LocalSymbol> additionalLocals, out BoundStatement? prologue, out BoundStatement? epilogue)
+        public override void PreInstrumentBlock(BoundBlock original, LocalRewriter rewriter)
         {
-            Previous.InstrumentBlock(original, rewriter, ref additionalLocals, out prologue, out epilogue);
+            Previous.PreInstrumentBlock(original, rewriter);
+        }
+
+        public override void InstrumentBlock(BoundBlock original, LocalRewriter rewriter, ref TemporaryArray<LocalSymbol> additionalLocals, out BoundStatement? prologue, out BoundStatement? epilogue, out BoundBlockInstrumentation? instrumentation)
+        {
+            Previous.InstrumentBlock(original, rewriter, ref additionalLocals, out prologue, out epilogue, out instrumentation);
         }
 
         public override BoundExpression InstrumentDoStatementCondition(BoundDoStatement original, BoundExpression rewrittenCondition, SyntheticBoundNodeFactory factory)
@@ -139,9 +144,29 @@ public override BoundStatement InstrumentLabelStatement(BoundLabeledStatement or
             return Previous.InstrumentLabelStatement(original, rewritten);
         }
 
-        public override BoundStatement InstrumentLocalInitialization(BoundLocalDeclaration original, BoundStatement rewritten)
+        public override BoundStatement InstrumentUserDefinedLocalInitialization(BoundLocalDeclaration original, BoundStatement rewritten)
+        {
+            return Previous.InstrumentUserDefinedLocalInitialization(original, rewritten);
+        }
+
+        public override BoundExpression InstrumentUserDefinedLocalAssignment(BoundAssignmentOperator original)
+        {
+            return Previous.InstrumentUserDefinedLocalAssignment(original);
+        }
+
+        public override BoundExpression InstrumentCall(BoundCall original, BoundExpression rewritten)
+        {
+            return Previous.InstrumentCall(original, rewritten);
+        }
+
+        public override BoundExpression InstrumentObjectCreationExpression(BoundObjectCreationExpression original, BoundExpression rewritten)
         {
-            return Previous.InstrumentLocalInitialization(original, rewritten);
+            return Previous.InstrumentObjectCreationExpression(original, rewritten);
+        }
+
+        public override BoundExpression InstrumentFunctionPointerInvocation(BoundFunctionPointerInvocation original, BoundExpression rewritten)
+        {
+            return Previous.InstrumentFunctionPointerInvocation(original, rewritten);
         }
 
         public override BoundStatement InstrumentLockTargetCapture(BoundLockStatement original, BoundStatement lockTargetCapture)
@@ -179,9 +204,23 @@ public override BoundStatement InstrumentWhileStatementConditionalGotoStartOrBre
             return Previous.InstrumentWhileStatementConditionalGotoStartOrBreak(original, ifConditionGotoStart);
         }
 
-        public override BoundExpression InstrumentCatchClauseFilter(BoundCatchBlock original, BoundExpression rewrittenFilter, SyntheticBoundNodeFactory factory)
-        {
-            return Previous.InstrumentCatchClauseFilter(original, rewrittenFilter, factory);
+        public override void InstrumentCatchBlock(
+            BoundCatchBlock original,
+            ref BoundExpression? rewrittenSource,
+            ref BoundStatementList? rewrittenFilterPrologue,
+            ref BoundExpression? rewrittenFilter,
+            ref BoundBlock rewrittenBody,
+            ref TypeSymbol? rewrittenType,
+            SyntheticBoundNodeFactory factory)
+        {
+            Previous.InstrumentCatchBlock(
+                original,
+                ref rewrittenSource,
+                ref rewrittenFilterPrologue,
+                ref rewrittenFilter,
+                ref rewrittenBody,
+                ref rewrittenType,
+                factory);
         }
 
         public override BoundExpression InstrumentSwitchStatementExpression(BoundStatement original, BoundExpression rewrittenExpression, SyntheticBoundNodeFactory factory)
diff --git a/src/Compilers/CSharp/Portable/Lowering/Instrumentation/DebugInfoInjector.cs b/src/Compilers/CSharp/Portable/Lowering/Instrumentation/DebugInfoInjector.cs
index 877ceebd531b5..29dbfd4a3326d 100644
--- a/src/Compilers/CSharp/Portable/Lowering/Instrumentation/DebugInfoInjector.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/Instrumentation/DebugInfoInjector.cs
@@ -83,7 +83,7 @@ public override BoundStatement InstrumentFieldOrPropertyInitializer(BoundStateme
             if (rewritten.Kind == BoundKind.Block)
             {
                 var block = (BoundBlock)rewritten;
-                return block.Update(block.Locals, block.LocalFunctions, block.HasUnsafeModifier, ImmutableArray.Create(InstrumentFieldOrPropertyInitializer(block.Statements.Single(), syntax)));
+                return block.Update(block.Locals, block.LocalFunctions, block.HasUnsafeModifier, block.Instrumentation, ImmutableArray.Create(InstrumentFieldOrPropertyInitializer(block.Statements.Single(), syntax)));
             }
 
             return InstrumentFieldOrPropertyInitializer(rewritten, syntax);
@@ -142,9 +142,9 @@ public override BoundStatement InstrumentYieldReturnStatement(BoundYieldReturnSt
             return AddSequencePoint(base.InstrumentYieldReturnStatement(original, rewritten));
         }
 
-        public override void InstrumentBlock(BoundBlock original, LocalRewriter rewriter, ref TemporaryArray<LocalSymbol> additionalLocals, out BoundStatement? prologue, out BoundStatement? epilogue)
+        public override void InstrumentBlock(BoundBlock original, LocalRewriter rewriter, ref TemporaryArray<LocalSymbol> additionalLocals, out BoundStatement? prologue, out BoundStatement? epilogue, out BoundBlockInstrumentation? instrumentation)
         {
-            base.InstrumentBlock(original, rewriter, ref additionalLocals, out var previousPrologue, out var previousEpilogue);
+            base.InstrumentBlock(original, rewriter, ref additionalLocals, out var previousPrologue, out var previousEpilogue, out instrumentation);
 
             prologue = previousPrologue;
             epilogue = previousEpilogue;
@@ -338,12 +338,12 @@ public override BoundStatement InstrumentLabelStatement(BoundLabeledStatement or
                                                   span);
         }
 
-        public override BoundStatement InstrumentLocalInitialization(BoundLocalDeclaration original, BoundStatement rewritten)
+        public override BoundStatement InstrumentUserDefinedLocalInitialization(BoundLocalDeclaration original, BoundStatement rewritten)
         {
             return AddSequencePoint(original.Syntax.Kind() == SyntaxKind.VariableDeclarator ?
                                         (VariableDeclaratorSyntax)original.Syntax :
                                         ((LocalDeclarationStatementSyntax)original.Syntax).Declaration.Variables.First(),
-                                    base.InstrumentLocalInitialization(original, rewritten));
+                                    base.InstrumentUserDefinedLocalInitialization(original, rewritten));
         }
 
         public override BoundStatement InstrumentLockTargetCapture(BoundLockStatement original, BoundStatement lockTargetCapture)
@@ -398,15 +398,36 @@ public override BoundStatement InstrumentUsingTargetCapture(BoundUsingStatement
                                     base.InstrumentUsingTargetCapture(original, usingTargetCapture));
         }
 
-        public override BoundExpression InstrumentCatchClauseFilter(BoundCatchBlock original, BoundExpression rewrittenFilter, SyntheticBoundNodeFactory factory)
-        {
-            rewrittenFilter = base.InstrumentCatchClauseFilter(original, rewrittenFilter, factory);
+        public override void InstrumentCatchBlock(
+            BoundCatchBlock original,
+            ref BoundExpression? rewrittenSource,
+            ref BoundStatementList? rewrittenFilterPrologue,
+            ref BoundExpression? rewrittenFilter,
+            ref BoundBlock rewrittenBody,
+            ref TypeSymbol? rewrittenType,
+            SyntheticBoundNodeFactory factory)
+        {
+            base.InstrumentCatchBlock(
+                original,
+                ref rewrittenSource,
+                ref rewrittenFilterPrologue,
+                ref rewrittenFilter,
+                ref rewrittenBody,
+                ref rewrittenType,
+                factory);
+
+            if (original.WasCompilerGenerated || rewrittenFilter is null)
+            {
+                return;
+            }
 
             // EnC: We need to insert a hidden sequence point to handle function remapping in case 
             // the containing method is edited while methods invoked in the condition are being executed.
-            CatchFilterClauseSyntax? filterClause = ((CatchClauseSyntax)original.Syntax).Filter;
-            Debug.Assert(filterClause is { });
-            return AddConditionSequencePoint(new BoundSequencePointExpression(filterClause, rewrittenFilter, rewrittenFilter.Type), filterClause, factory);
+
+            var filterClause = ((CatchClauseSyntax)original.Syntax).Filter;
+            Debug.Assert(filterClause is not null);
+
+            rewrittenFilter = AddConditionSequencePoint(new BoundSequencePointExpression(filterClause, rewrittenFilter, rewrittenFilter.Type), filterClause, factory);
         }
 
         public override BoundExpression InstrumentSwitchStatementExpression(BoundStatement original, BoundExpression rewrittenExpression, SyntheticBoundNodeFactory factory)
diff --git a/src/Compilers/CSharp/Portable/Lowering/Instrumentation/Instrumenter.cs b/src/Compilers/CSharp/Portable/Lowering/Instrumentation/Instrumenter.cs
index 026ed1b42680f..f9b1e9c63fcfd 100644
--- a/src/Compilers/CSharp/Portable/Lowering/Instrumentation/Instrumenter.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/Instrumentation/Instrumenter.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
@@ -54,6 +55,13 @@ public virtual BoundStatement InstrumentYieldReturnStatement(BoundYieldReturnSta
             return InstrumentStatement(original, rewritten);
         }
 
+        /// <summary>
+        /// Called before the statements of the <paramref name="original"/> block are lowered.
+        /// </summary>
+        public virtual void PreInstrumentBlock(BoundBlock original, LocalRewriter rewriter)
+        {
+        }
+
         /// <summary>
         /// Instruments <paramref name="original"/> block.
         /// </summary>
@@ -62,10 +70,11 @@ public virtual BoundStatement InstrumentYieldReturnStatement(BoundYieldReturnSta
         /// <param name="additionalLocals">Local symbols to be added to <see cref="BoundBlock.Locals"/> of the resulting block.</param>
         /// <param name="prologue">Node to be added to the beginning of the statement list of the instrumented block.</param>
         /// <param name="epilogue">Node to be added at the end of the statement list of the instrumented block.</param>
-        public virtual void InstrumentBlock(BoundBlock original, LocalRewriter rewriter, ref TemporaryArray<LocalSymbol> additionalLocals, out BoundStatement? prologue, out BoundStatement? epilogue)
+        public virtual void InstrumentBlock(BoundBlock original, LocalRewriter rewriter, ref TemporaryArray<LocalSymbol> additionalLocals, out BoundStatement? prologue, out BoundStatement? epilogue, out BoundBlockInstrumentation? instrumentation)
         {
             prologue = null;
             epilogue = null;
+            instrumentation = null;
         }
 
         public virtual BoundStatement InstrumentThrowStatement(BoundThrowStatement original, BoundStatement rewritten)
@@ -199,7 +208,7 @@ public virtual BoundStatement InstrumentLabelStatement(BoundLabeledStatement ori
             return InstrumentStatement(original, rewritten);
         }
 
-        public virtual BoundStatement InstrumentLocalInitialization(BoundLocalDeclaration original, BoundStatement rewritten)
+        public virtual BoundStatement InstrumentUserDefinedLocalInitialization(BoundLocalDeclaration original, BoundStatement rewritten)
         {
             Debug.Assert(original.Syntax.Kind() == SyntaxKind.VariableDeclarator ||
                          (original.Syntax.Kind() == SyntaxKind.LocalDeclarationStatement &&
@@ -207,6 +216,28 @@ public virtual BoundStatement InstrumentLocalInitialization(BoundLocalDeclaratio
             return InstrumentStatement(original, rewritten);
         }
 
+        public virtual BoundExpression InstrumentUserDefinedLocalAssignment(BoundAssignmentOperator original)
+        {
+            Debug.Assert(original.Left is BoundLocal { LocalSymbol.SynthesizedKind: SynthesizedLocalKind.UserDefined } or BoundParameter);
+
+            return original;
+        }
+
+        public virtual BoundExpression InstrumentCall(BoundCall original, BoundExpression rewritten)
+        {
+            return rewritten;
+        }
+
+        public virtual BoundExpression InstrumentObjectCreationExpression(BoundObjectCreationExpression original, BoundExpression rewritten)
+        {
+            return rewritten;
+        }
+
+        public virtual BoundExpression InstrumentFunctionPointerInvocation(BoundFunctionPointerInvocation original, BoundExpression rewritten)
+        {
+            return rewritten;
+        }
+
         public virtual BoundStatement InstrumentLockTargetCapture(BoundLockStatement original, BoundStatement lockTargetCapture)
         {
             Debug.Assert(!original.WasCompilerGenerated);
@@ -244,13 +275,16 @@ public virtual BoundStatement InstrumentUsingTargetCapture(BoundUsingStatement o
             return usingTargetCapture;
         }
 
-        public virtual BoundExpression InstrumentCatchClauseFilter(BoundCatchBlock original, BoundExpression rewrittenFilter, SyntheticBoundNodeFactory factory)
+        public virtual void InstrumentCatchBlock(
+            BoundCatchBlock original,
+            ref BoundExpression? rewrittenSource,
+            ref BoundStatementList? rewrittenFilterPrologue,
+            ref BoundExpression? rewrittenFilter,
+            ref BoundBlock rewrittenBody,
+            ref TypeSymbol? rewrittenType,
+            SyntheticBoundNodeFactory factory)
         {
-            Debug.Assert(!original.WasCompilerGenerated);
             Debug.Assert(original.Syntax.Kind() == SyntaxKind.CatchClause);
-            Debug.Assert(((CatchClauseSyntax)original.Syntax).Filter != null);
-            Debug.Assert(factory != null);
-            return rewrittenFilter;
         }
 
         public virtual BoundExpression InstrumentSwitchStatementExpression(BoundStatement original, BoundExpression rewrittenExpression, SyntheticBoundNodeFactory factory)
diff --git a/src/Compilers/CSharp/Portable/Lowering/Instrumentation/LocalStateTracingInstrumenter.cs b/src/Compilers/CSharp/Portable/Lowering/Instrumentation/LocalStateTracingInstrumenter.cs
new file mode 100644
index 0000000000000..e9b3b0cb1339b
--- /dev/null
+++ b/src/Compilers/CSharp/Portable/Lowering/Instrumentation/LocalStateTracingInstrumenter.cs
@@ -0,0 +1,508 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Immutable;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using Microsoft.CodeAnalysis.CSharp.Symbols;
+using Microsoft.CodeAnalysis.PooledObjects;
+using Microsoft.CodeAnalysis.Shared.Collections;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis.CSharp
+{
+    internal sealed class LocalStateTracingInstrumenter : CompoundInstrumenter
+    {
+        /// <summary>
+        /// Represents instrumentation scope - i.e. method, lambda or local function body.
+        /// We define a new <see cref="Scope.ContextVariable"/> (of LocalStoreTracker well-known type) in each scope,
+        /// so that this variable is always directly accessible within any instrumented code and always stack-allocated.
+        /// </summary>
+        private sealed class Scope
+        {
+            public LocalSymbol ContextVariable;
+            private ArrayBuilder<LocalSymbol>? _lazyPreviousContextVariables;
+
+            public Scope(LocalSymbol contextVariable)
+            {
+                ContextVariable = contextVariable;
+            }
+
+            public void Open(LocalSymbol local)
+            {
+                _lazyPreviousContextVariables ??= ArrayBuilder<LocalSymbol>.GetInstance();
+                _lazyPreviousContextVariables.Push(ContextVariable);
+                ContextVariable = local;
+            }
+
+            public void Close(bool isMethodBody)
+            {
+                if (_lazyPreviousContextVariables is { Count: > 0 })
+                {
+                    ContextVariable = _lazyPreviousContextVariables.Pop();
+                }
+
+                if (isMethodBody)
+                {
+                    Debug.Assert(_lazyPreviousContextVariables?.IsEmpty() != false);
+                    _lazyPreviousContextVariables?.Free();
+                }
+            }
+        }
+
+        private readonly Scope _scope;
+        private readonly SyntheticBoundNodeFactory _factory;
+        private readonly BindingDiagnosticBag _diagnostics;
+        private readonly TypeSymbol _instrumentationType;
+
+        private LocalStateTracingInstrumenter(
+            Scope state,
+            TypeSymbol instrumentationType,
+            SyntheticBoundNodeFactory factory,
+            BindingDiagnosticBag diagnostics,
+            Instrumenter previous)
+            : base(previous)
+        {
+            _scope = state;
+            _instrumentationType = instrumentationType;
+            _factory = factory;
+            _diagnostics = diagnostics;
+        }
+
+        protected override CompoundInstrumenter WithPreviousImpl(Instrumenter previous)
+            => new LocalStateTracingInstrumenter(
+                _scope,
+                _instrumentationType,
+                _factory,
+                _diagnostics,
+                previous);
+
+        public static bool TryCreate(
+            MethodSymbol method,
+            BoundStatement methodBody,
+            SyntheticBoundNodeFactory factory,
+            BindingDiagnosticBag diagnostics,
+            Instrumenter previous,
+            [NotNullWhen(true)] out LocalStateTracingInstrumenter? instrumenter)
+        {
+            instrumenter = null;
+
+            // Do not instrument implicitly-declared methods, except for constructors.
+            // Instrument implicit constructors in order to instrument member initializers.
+            if (method.IsImplicitlyDeclared && !method.IsImplicitConstructor)
+            {
+                return false;
+            }
+
+            // Method has no user-defined body
+            if (method is SourceMemberMethodSymbol { Bodies: { arrowBody: null, blockBody: null } } and not SynthesizedSimpleProgramEntryPointSymbol)
+            {
+                return false;
+            }
+
+            var instrumentationType = factory.Compilation.GetWellKnownType(WellKnownType.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker);
+            if (method.ContainingType.Equals(instrumentationType))
+            {
+                return false;
+            }
+
+            var scope = new Scope(factory.SynthesizedLocal(instrumentationType, methodBody.Syntax, kind: SynthesizedLocalKind.LocalStoreTracker));
+            instrumenter = new LocalStateTracingInstrumenter(scope, instrumentationType, factory, diagnostics, previous);
+            return true;
+        }
+
+        private MethodSymbol? GetLocalOrParameterStoreLogger(TypeSymbol variableType, Symbol targetSymbol, bool? refAssignmentSourceIsLocal, SyntaxNode syntax)
+        {
+            var enumDelta = (targetSymbol.Kind == SymbolKind.Parameter) ?
+                WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreBoolean - WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreBoolean : 0;
+
+            var overload = refAssignmentSourceIsLocal switch
+            {
+                true => WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreLocalAlias,
+                false => WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreParameterAlias,
+                null => variableType.EnumUnderlyingTypeOrSelf().SpecialType switch
+                {
+                    SpecialType.System_Boolean
+                        => WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreBoolean,
+                    SpecialType.System_SByte or SpecialType.System_Byte
+                        => WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreByte,
+                    SpecialType.System_Int16 or SpecialType.System_UInt16 or SpecialType.System_Char
+                        => WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreUInt16,
+                    SpecialType.System_Int32 or SpecialType.System_UInt32 or SpecialType.System_Single
+                        => WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreUInt32,
+                    SpecialType.System_Int64 or SpecialType.System_UInt64 or SpecialType.System_Double
+                        => WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreUInt64,
+                    SpecialType.System_String
+                        => WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreString,
+                    _ when variableType.IsPointerOrFunctionPointer()
+                        => WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStorePointer,
+                    _ when !variableType.IsManagedTypeNoUseSiteDiagnostics
+                        => WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreUnmanaged,
+                    _ when variableType.TypeKind is TypeKind.Struct
+                        // well emit ToString constrained virtcall to avoid boxing the struct
+                        => WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreString,
+                    _
+                        => WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreObject,
+                }
+            };
+
+            // LogLocalStoreLocalAlias does not have a corresponding parameter version,
+            // since it is not possible to assign address of a local to a by-ref parameter.
+            Debug.Assert(enumDelta == 0 || overload != WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreLocalAlias);
+
+            overload += enumDelta;
+
+            var symbol = GetWellKnownMethodSymbol(overload, syntax);
+            if (symbol is not null)
+            {
+                return symbol.IsGenericMethod ? symbol.Construct(variableType) : symbol;
+            }
+
+            var objectOverload = enumDelta + WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreObject;
+
+            if (refAssignmentSourceIsLocal.HasValue || variableType.IsRefLikeType || variableType.IsPointerOrFunctionPointer() || overload == objectOverload)
+            {
+                return null;
+            }
+
+            // fall back to Object overload if the specialized one is not present
+            return GetWellKnownMethodSymbol(objectOverload, syntax);
+        }
+
+        private MethodSymbol? GetWellKnownMethodSymbol(WellKnownMember overload, SyntaxNode syntax)
+            => (MethodSymbol?)Binder.GetWellKnownTypeMember(_factory.Compilation, overload, _diagnostics, syntax: syntax, isOptional: false);
+
+        public override void PreInstrumentBlock(BoundBlock original, LocalRewriter rewriter)
+        {
+            Previous.PreInstrumentBlock(original, rewriter);
+
+            if (rewriter.CurrentLambdaBody == original)
+            {
+                _scope.Open(_factory.SynthesizedLocal(_instrumentationType, original.Syntax, kind: SynthesizedLocalKind.LocalStoreTracker));
+            }
+        }
+
+        public override void InstrumentBlock(BoundBlock original, LocalRewriter rewriter, ref TemporaryArray<LocalSymbol> additionalLocals, out BoundStatement? prologue, out BoundStatement? epilogue, out BoundBlockInstrumentation? instrumentation)
+        {
+            base.InstrumentBlock(original, rewriter, ref additionalLocals, out var previousPrologue, out epilogue, out instrumentation);
+
+            var isMethodBody = rewriter.CurrentMethodBody == original;
+            var isLambdaBody = rewriter.CurrentLambdaBody == original;
+
+            // Don't instrument blocks that are not a method or lambda body
+            if (!isMethodBody && !isLambdaBody)
+            {
+                prologue = previousPrologue;
+                return;
+            }
+
+            Debug.Assert(_factory.TopLevelMethod is not null);
+            Debug.Assert(_factory.CurrentFunction is not null);
+
+            var isStateMachine = _factory.CurrentFunction.IsAsync || _factory.CurrentFunction.IsIterator;
+
+            var prologueBuilder = ArrayBuilder<BoundStatement>.GetInstance(_factory.CurrentFunction.ParameterCount);
+
+            foreach (var parameter in _factory.CurrentFunction.Parameters)
+            {
+                if (parameter.RefKind == RefKind.Out)
+                {
+                    continue;
+                }
+
+                var parameterLogger = GetLocalOrParameterStoreLogger(parameter.Type, parameter, refAssignmentSourceIsLocal: null, _factory.Syntax);
+                if (parameterLogger != null)
+                {
+                    prologueBuilder.Add(_factory.ExpressionStatement(_factory.Call(receiver: _factory.Local(_scope.ContextVariable), parameterLogger, new[]
+                    {
+                        MakeSourceArgument(parameterLogger.Parameters[0], parameter, parameter.Type, _factory.Parameter(parameter), refAssignmentSourceIndex: null),
+                        _factory.Literal((ushort)parameter.Ordinal)
+                    })));
+                }
+            }
+
+            if (previousPrologue != null)
+            {
+                prologueBuilder.Add(previousPrologue);
+            }
+
+            prologue = _factory.StatementList(prologueBuilder.ToImmutableAndFree());
+
+            var (entryOverload, entryArgs) = (isLambdaBody, isStateMachine) switch
+            {
+                (isLambdaBody: false, isStateMachine: false) =>
+                    (WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogMethodEntry,
+                    new[] { _factory.MethodDefIndex(_factory.TopLevelMethod) }),
+                (isLambdaBody: true, isStateMachine: false) =>
+                    (WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLambdaEntry,
+                    new[] { _factory.MethodDefIndex(_factory.TopLevelMethod), _factory.MethodDefIndex(_factory.CurrentFunction) }),
+                (isLambdaBody: false, isStateMachine: true) =>
+                    (WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogStateMachineMethodEntry,
+                    new[] { _factory.MethodDefIndex(_factory.TopLevelMethod), _factory.StateMachineInstanceId() }),
+                (isLambdaBody: true, isStateMachine: true) =>
+                    (WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogStateMachineLambdaEntry,
+                    new[] { _factory.MethodDefIndex(_factory.TopLevelMethod), _factory.MethodDefIndex(_factory.CurrentFunction), _factory.StateMachineInstanceId() }),
+            };
+
+            var entryLogger = GetWellKnownMethodSymbol(entryOverload, _factory.Syntax);
+            var instrumentationPrologue = (entryLogger != null) ?
+                _factory.Assignment(_factory.Local(_scope.ContextVariable), _factory.Call(receiver: null, entryLogger, entryArgs)) : _factory.NoOp(NoOpStatementFlavor.Default);
+
+            var returnLogger = GetWellKnownMethodSymbol(WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogReturn, _factory.Syntax);
+            var instrumentationEpilogue = (returnLogger != null) ?
+                _factory.ExpressionStatement(_factory.Call(receiver: _factory.Local(_scope.ContextVariable), returnLogger)) : _factory.NoOp(NoOpStatementFlavor.Default);
+
+            // currently don't need to compose multiple instrumentations
+            Debug.Assert(instrumentation is null);
+
+            instrumentation = new BoundBlockInstrumentation(
+                _factory.Syntax,
+                _scope.ContextVariable,
+                instrumentationPrologue,
+                instrumentationEpilogue);
+
+            _scope.Close(isMethodBody);
+        }
+
+        public override BoundExpression InstrumentUserDefinedLocalAssignment(BoundAssignmentOperator original)
+        {
+            Debug.Assert(original.Left is BoundLocal { LocalSymbol.SynthesizedKind: SynthesizedLocalKind.UserDefined } or BoundParameter);
+
+            var assignment = base.InstrumentUserDefinedLocalAssignment(original);
+
+            bool? refAssignmentSourceIsLocal;
+            BoundExpression? refAssignmentSourceIndex;
+            if (original.IsRef)
+            {
+                if (original.Right is BoundLocal { LocalSymbol.SynthesizedKind: SynthesizedLocalKind.UserDefined } rightLocal)
+                {
+                    refAssignmentSourceIsLocal = true;
+                    refAssignmentSourceIndex = _factory.LocalId(rightLocal.LocalSymbol);
+                }
+                else if (original.Right is BoundParameter rightParameter)
+                {
+                    refAssignmentSourceIsLocal = false;
+                    refAssignmentSourceIndex = _factory.ParameterId(rightParameter.ParameterSymbol);
+                }
+                else
+                {
+                    // We don't track field aliases.
+                    return assignment;
+                }
+            }
+            else
+            {
+                refAssignmentSourceIsLocal = null;
+                refAssignmentSourceIndex = null;
+            }
+
+            var isLocalOrParameter = TryGetLocalOrParameterInfo(original.Left, out var targetSymbol, out var targetType, out var targetIndex);
+            Debug.Assert(isLocalOrParameter);
+            Debug.Assert(targetType is not null); // TODO: why are these needed?
+            Debug.Assert(targetSymbol is not null);
+            Debug.Assert(targetIndex is not null);
+
+            var logger = GetLocalOrParameterStoreLogger(targetType, targetSymbol, refAssignmentSourceIsLocal, original.Syntax);
+            if (logger is null)
+            {
+                return assignment;
+            }
+
+            return _factory.Sequence(new[]
+            {
+                _factory.Call(
+                    receiver: _factory.Local(_scope.ContextVariable),
+                    logger,
+                    new[] { MakeSourceArgument(logger.Parameters[0], targetSymbol, targetType, assignment, refAssignmentSourceIndex), targetIndex })
+            }, VariableRead(targetSymbol));
+        }
+
+        private bool TryGetLocalOrParameterInfo(BoundNode node, [NotNullWhen(true)] out Symbol? symbol, [NotNullWhen(true)] out TypeSymbol? type, [NotNullWhen(true)] out BoundExpression? indexExpression)
+        {
+            if (node is BoundLocal { LocalSymbol: var localSymbol })
+            {
+                symbol = localSymbol;
+                type = localSymbol.Type;
+                indexExpression = _factory.LocalId(localSymbol);
+                return true;
+            }
+
+            if (node is BoundParameter { ParameterSymbol: var parameterSymbol })
+            {
+                symbol = parameterSymbol;
+                type = parameterSymbol.Type;
+                indexExpression = _factory.ParameterId(parameterSymbol);
+                return true;
+            }
+
+            symbol = null;
+            indexExpression = null;
+            type = null;
+            return false;
+        }
+
+        private BoundExpression MakeSourceArgument(ParameterSymbol parameter, Symbol targetSymbol, TypeSymbol targetType, BoundExpression value, BoundExpression? refAssignmentSourceIndex)
+        {
+            if (refAssignmentSourceIndex != null)
+            {
+                return _factory.Sequence(new[] { value }, refAssignmentSourceIndex);
+            }
+
+            if (parameter.RefKind == RefKind.None)
+            {
+                if (parameter.Type.SpecialType == SpecialType.System_String && targetType.SpecialType != SpecialType.System_String)
+                {
+                    var toString = GetWellKnownMethodSymbol(WellKnownMember.System_Object__ToString, value.Syntax);
+                    if (toString is null)
+                    {
+                        // arbitrary string, won't happen in practice
+                        return _factory.Literal("");
+                    }
+
+                    return _factory.Call(value, toString);
+                }
+
+                return _factory.Convert(parameter.Type, value);
+            }
+
+            // address of assigned value:
+            Debug.Assert(parameter.RefKind == RefKind.Ref);
+            if (value is BoundLocal or BoundParameter)
+            {
+                return value;
+            }
+
+            return _factory.Sequence(new[] { value }, VariableRead(targetSymbol));
+        }
+
+        private BoundExpression VariableRead(Symbol localOrParameterSymbol)
+            => localOrParameterSymbol switch
+            {
+                LocalSymbol local => _factory.Local(local),
+                ParameterSymbol param => _factory.Parameter(param),
+                _ => throw ExceptionUtilities.UnexpectedValue(localOrParameterSymbol)
+            };
+
+        public override void InstrumentCatchBlock(
+            BoundCatchBlock original,
+            ref BoundExpression? rewrittenSource,
+            ref BoundStatementList? rewrittenFilterPrologue,
+            ref BoundExpression? rewrittenFilter,
+            ref BoundBlock rewrittenBody,
+            ref TypeSymbol? rewrittenType,
+            SyntheticBoundNodeFactory factory)
+        {
+            base.InstrumentCatchBlock(
+                original,
+                ref rewrittenSource,
+                ref rewrittenFilterPrologue,
+                ref rewrittenFilter,
+                ref rewrittenBody,
+                ref rewrittenType,
+                factory);
+
+            if (original.WasCompilerGenerated)
+            {
+                return;
+            }
+
+            var targetSymbol = original.Locals.FirstOrDefault(l => l.SynthesizedKind == SynthesizedLocalKind.UserDefined);
+            if (targetSymbol is null)
+            {
+                return;
+            }
+
+            var targetType = targetSymbol.Type;
+            var targetIndex = _factory.LocalId(targetSymbol);
+
+            var logger = GetLocalOrParameterStoreLogger(targetType, targetSymbol, refAssignmentSourceIsLocal: null, original.Syntax);
+            if (logger is null)
+            {
+                return;
+            }
+
+            var logCallStatement = _factory.ExpressionStatement(
+                _factory.Call(
+                    receiver: _factory.Local(_scope.ContextVariable),
+                    logger,
+                    new[] { MakeSourceArgument(logger.Parameters[0], targetSymbol, targetType, VariableRead(targetSymbol), refAssignmentSourceIndex: null), targetIndex }));
+
+            rewrittenFilterPrologue = _factory.StatementList(
+                (rewrittenFilterPrologue != null) ?
+                    ImmutableArray.Create<BoundStatement>(logCallStatement, rewrittenFilterPrologue) :
+                    ImmutableArray.Create<BoundStatement>(logCallStatement));
+        }
+
+        public override BoundExpression InstrumentCall(BoundCall original, BoundExpression rewritten)
+            => InstrumentCall(base.InstrumentCall(original, rewritten), original.Arguments, original.ArgumentRefKindsOpt);
+
+        public override BoundExpression InstrumentObjectCreationExpression(BoundObjectCreationExpression original, BoundExpression rewritten)
+            => InstrumentCall(base.InstrumentObjectCreationExpression(original, rewritten), original.Arguments, original.ArgumentRefKindsOpt);
+
+        public override BoundExpression InstrumentFunctionPointerInvocation(BoundFunctionPointerInvocation original, BoundExpression rewritten)
+            => InstrumentCall(base.InstrumentFunctionPointerInvocation(original, rewritten), original.Arguments, original.ArgumentRefKindsOpt);
+
+        private BoundExpression InstrumentCall(BoundExpression invocation, ImmutableArray<BoundExpression> arguments, ImmutableArray<RefKind> refKinds)
+        {
+            Debug.Assert(refKinds.IsDefault || arguments.Length == refKinds.Length);
+            Debug.Assert(invocation.Type is not null);
+
+            if (refKinds.IsDefaultOrEmpty)
+            {
+                return invocation;
+            }
+
+            var builder = ArrayBuilder<BoundExpression>.GetInstance();
+
+            BoundLocal? temp = null;
+            if (invocation.Type.SpecialType != SpecialType.System_Void)
+            {
+                temp = _factory.StoreToTemp(invocation, out var store);
+                builder.Add(store);
+            }
+            else
+            {
+                builder.Add(invocation);
+            }
+
+            for (int i = 0; i < arguments.Length; i++)
+            {
+                if (refKinds[i] is not (RefKind.Ref or RefKind.Out))
+                {
+                    // not by-ref
+                    continue;
+                }
+
+                if (!TryGetLocalOrParameterInfo(arguments[i], out var targetSymbol, out var targetType, out var targetIndex))
+                {
+                    // not a local or parameter
+                    continue;
+                }
+
+                var logger = GetLocalOrParameterStoreLogger(targetType, targetSymbol, refAssignmentSourceIsLocal: null, invocation.Syntax);
+                if (logger is null)
+                {
+                    return invocation;
+                }
+
+                builder.Add(_factory.Call(
+                    receiver: _factory.Local(_scope.ContextVariable),
+                    logger,
+                    new[] { MakeSourceArgument(logger.Parameters[0], targetSymbol, targetType, VariableRead(targetSymbol), refAssignmentSourceIndex: null), targetIndex }));
+            }
+
+            if (temp != null)
+            {
+                return _factory.Sequence(ImmutableArray.Create(temp.LocalSymbol), builder.ToImmutableAndFree(), temp);
+            }
+
+            // The call is void returning.
+            var lastExpression = builder.Last();
+            builder.RemoveLast();
+            return _factory.Sequence(ImmutableArray<LocalSymbol>.Empty, builder.ToImmutableAndFree(), lastExpression);
+        }
+    }
+}
diff --git a/src/Compilers/CSharp/Portable/Lowering/IteratorRewriter/IteratorMethodToStateMachineRewriter.cs b/src/Compilers/CSharp/Portable/Lowering/IteratorRewriter/IteratorMethodToStateMachineRewriter.cs
index 33b598188d96f..90b403c3c6d8d 100644
--- a/src/Compilers/CSharp/Portable/Lowering/IteratorRewriter/IteratorMethodToStateMachineRewriter.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/IteratorRewriter/IteratorMethodToStateMachineRewriter.cs
@@ -2,8 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-#nullable disable
-
 using System.Collections.Immutable;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
 using Microsoft.CodeAnalysis.PooledObjects;
@@ -13,7 +11,6 @@
 using System.Linq;
 using Roslyn.Utilities;
 using Microsoft.CodeAnalysis.CodeGen;
-using Microsoft.CodeAnalysis.Symbols;
 
 namespace Microsoft.CodeAnalysis.CSharp
 {
@@ -27,14 +24,14 @@ internal sealed partial class IteratorMethodToStateMachineRewriter : MethodToSta
         /// <summary>
         /// Tells us if a particular try contains yield returns
         /// </summary>
-        private YieldsInTryAnalysis _yieldsInTryAnalysis;
+        private YieldsInTryAnalysis? _yieldsInTryAnalysis;
 
         /// <summary>
         /// When this is more that 0, returns are emitted as "methodValue = value; goto exitLabel;"
         /// </summary>
         private int _tryNestingLevel;
-        private LabelSymbol _exitLabel;
-        private LocalSymbol _methodValue;
+        private LabelSymbol? _exitLabel;
+        private LocalSymbol? _methodValue;
 
         /// <summary>
         /// The current iterator finally frame in the tree of finally frames.
@@ -60,6 +57,7 @@ internal IteratorMethodToStateMachineRewriter(
             MethodSymbol originalMethod,
             FieldSymbol state,
             FieldSymbol current,
+            FieldSymbol? instanceIdField,
             Roslyn.Utilities.IReadOnlySet<Symbol> hoistedVariables,
             IReadOnlyDictionary<Symbol, CapturedSymbolReplacement> nonReusableLocalProxies,
             SynthesizedLocalOrdinalsDispenser synthesizedLocalOrdinals,
@@ -67,13 +65,14 @@ internal IteratorMethodToStateMachineRewriter(
             VariableSlotAllocator slotAllocatorOpt,
             int nextFreeHoistedLocalSlot,
             BindingDiagnosticBag diagnostics)
-            : base(F, originalMethod, state, hoistedVariables, nonReusableLocalProxies, synthesizedLocalOrdinals, stateMachineStateDebugInfoBuilder, slotAllocatorOpt, nextFreeHoistedLocalSlot, diagnostics)
+            : base(F, originalMethod, state, instanceIdField, hoistedVariables, nonReusableLocalProxies, synthesizedLocalOrdinals, stateMachineStateDebugInfoBuilder, slotAllocatorOpt, nextFreeHoistedLocalSlot, diagnostics)
         {
             _current = current;
 
             _nextFinalizeState = slotAllocatorOpt?.GetFirstUnusedStateMachineState(increasing: false) ?? StateMachineState.FirstIteratorFinalizeState;
         }
 
+#nullable disable
         protected override string EncMissingStateMessage
             => CodeAnalysisResources.EncCannotResumeSuspendedIteratorMethod;
 
@@ -147,8 +146,17 @@ internal void GenerateMoveNextAndDispose(BoundStatement body, SynthesizedImpleme
                 newBody = F.Fault((BoundBlock)newBody, faultBlock);
             }
 
-            newBody = HandleReturn(newBody);
-            F.CloseMethod(F.SequencePoint(body.Syntax, newBody));
+            newBody = F.SequencePoint(body.Syntax, HandleReturn(newBody));
+
+            if (_instrumentation != null)
+            {
+                newBody = F.Block(
+                    ImmutableArray.Create(_instrumentation.Local),
+                    _instrumentation.Prologue,
+                    F.Try(F.Block(newBody), ImmutableArray<BoundCatchBlock>.Empty, F.Block(_instrumentation.Epilogue)));
+            }
+
+            F.CloseMethod(newBody);
 
             ///////////////////////////////////
             // Generate the body for Dispose().
@@ -176,15 +184,15 @@ internal void GenerateMoveNextAndDispose(BoundStatement body, SynthesizedImpleme
             }
         }
 
-        private BoundStatement HandleReturn(BoundStatement newBody)
+        private BoundBlock HandleReturn(BoundStatement newBody)
         {
-            if ((object)_exitLabel == null)
+            if (_exitLabel is null)
             {
                 //   body;
                 //   return false;
-                newBody = F.Block(
-                        newBody,
-                        F.Return(F.Literal(false)));
+                return F.Block(
+                    newBody,
+                    F.Return(F.Literal(false)));
             }
             else
             {
@@ -192,15 +200,13 @@ private BoundStatement HandleReturn(BoundStatement newBody)
                 //   methodValue = false;
                 // exitLabel:
                 //   return methodValue;
-                newBody = F.Block(
-                        ImmutableArray.Create<LocalSymbol>(_methodValue),
-                        newBody,
-                        F.Assignment(this.F.Local(_methodValue), this.F.Literal(true)),
-                        F.Label(_exitLabel),
-                        F.Return(this.F.Local(_methodValue)));
+                return F.Block(
+                    ImmutableArray.Create<LocalSymbol>(_methodValue),
+                    newBody,
+                    F.Assignment(this.F.Local(_methodValue), this.F.Literal(true)),
+                    F.Label(_exitLabel),
+                    F.Return(this.F.Local(_methodValue)));
             }
-
-            return newBody;
         }
 
         /// <summary>
diff --git a/src/Compilers/CSharp/Portable/Lowering/IteratorRewriter/IteratorRewriter.cs b/src/Compilers/CSharp/Portable/Lowering/IteratorRewriter/IteratorRewriter.cs
index 0ba9b23ab9113..a18ebde1cad4f 100644
--- a/src/Compilers/CSharp/Portable/Lowering/IteratorRewriter/IteratorRewriter.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/IteratorRewriter/IteratorRewriter.cs
@@ -10,6 +10,7 @@
 using System.Diagnostics;
 using Microsoft.CodeAnalysis.CodeGen;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
+using Microsoft.CodeAnalysis.Emit;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Roslyn.Utilities;
 
@@ -171,7 +172,15 @@ protected override bool PreserveInitialParameterValuesAndThreadId
 
         protected override void GenerateControlFields()
         {
-            this.stateField = F.StateMachineField(F.SpecialType(SpecialType.System_Int32), GeneratedNames.MakeStateMachineStateFieldName());
+            Debug.Assert(F.ModuleBuilderOpt is not null);
+
+            stateField = F.StateMachineField(F.SpecialType(SpecialType.System_Int32), GeneratedNames.MakeStateMachineStateFieldName());
+
+            var instrumentations = F.ModuleBuilderOpt.GetMethodBodyInstrumentations(method);
+            if (instrumentations.Kinds.Contains(InstrumentationKind.LocalStateTracing))
+            {
+                instanceIdField = F.StateMachineField(F.SpecialType(SpecialType.System_UInt64), GeneratedNames.MakeStateMachineStateIdFieldName());
+            }
 
             // Add a field: T current
             _currentField = F.StateMachineField(_elementType, GeneratedNames.MakeIteratorCurrentFieldName());
@@ -278,6 +287,12 @@ private void GenerateConstructor(BoundExpression managedThreadId)
                 bodyBuilder.Add(F.Assignment(F.Field(F.This(), initialThreadIdField), managedThreadId));
             }
 
+            if (instanceIdField is not null &&
+                F.WellKnownMethod(WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__GetNewStateMachineInstanceId) is { } getId)
+            {
+                bodyBuilder.Add(F.Assignment(F.InstanceField(instanceIdField), F.Call(receiver: null, getId)));
+            }
+
             bodyBuilder.Add(F.Return());
             F.CloseMethod(F.Block(bodyBuilder.ToImmutableAndFree()));
             bodyBuilder = null;
@@ -317,6 +332,7 @@ private void GenerateMoveNextAndDispose(
                 method,
                 stateField,
                 _currentField,
+                instanceIdField,
                 hoistedVariables,
                 nonReusableLocalProxies,
                 synthesizedLocalOrdinals,
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.cs
index 6b284b9c88aaf..b01b2c835dba4 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.cs
@@ -32,6 +32,11 @@ internal sealed partial class LocalRewriter : BoundTreeRewriterWithStackGuard
         private DelegateCacheRewriter? _lazyDelegateCacheRewriter;
         private bool _inExpressionLambda;
 
+        /// <summary>
+        /// The original body of the current lambda or local function body, or null if not currently lowering a lambda.
+        /// </summary>
+        private BoundBlock? _currentLambdaBody;
+
         private bool _sawAwait;
         private bool _sawAwaitInExceptionHandler;
         private bool _needsSpilling;
@@ -78,10 +83,10 @@ public static BoundStatement Rewrite(
             TypeCompilationState compilationState,
             SynthesizedSubmissionFields previousSubmissionFields,
             bool allowOmissionOfConditionalCalls,
-            bool instrumentForDynamicAnalysis,
-            ref ImmutableArray<SourceSpan> dynamicAnalysisSpans,
+            MethodInstrumentation instrumentation,
             DebugDocumentProvider debugDocumentProvider,
             BindingDiagnosticBag diagnostics,
+            out ImmutableArray<SourceSpan> codeCoverageSpans,
             out bool sawLambdas,
             out bool sawLocalFunctions,
             out bool sawAwaitInExceptionHandler)
@@ -98,8 +103,14 @@ public static BoundStatement Rewrite(
 
                 var instrumenter = Instrumenter.NoOp;
 
+                if (instrumentation.Kinds.Contains(InstrumentationKind.LocalStateTracing) &&
+                    LocalStateTracingInstrumenter.TryCreate(method, statement, factory, diagnostics, instrumenter, out var localStateTracingInstrumenter))
+                {
+                    instrumenter = localStateTracingInstrumenter;
+                }
+
                 CodeCoverageInstrumenter? codeCoverageInstrumenter = null;
-                if (instrumentForDynamicAnalysis &&
+                if (instrumentation.Kinds.Contains(InstrumentationKind.TestCoverage) &&
                     CodeCoverageInstrumenter.TryCreate(method, statement, factory, diagnostics, debugDocumentProvider, instrumenter, out codeCoverageInstrumenter))
                 {
                     instrumenter = codeCoverageInstrumenter;
@@ -126,10 +137,7 @@ public static BoundStatement Rewrite(
                     loweredStatement = spilledStatement;
                 }
 
-                if (codeCoverageInstrumenter != null)
-                {
-                    dynamicAnalysisSpans = codeCoverageInstrumenter.DynamicAnalysisSpans;
-                }
+                codeCoverageSpans = codeCoverageInstrumenter?.DynamicAnalysisSpans ?? ImmutableArray<SourceSpan>.Empty;
 #if DEBUG
                 LocalRewritingValidator.Validate(loweredStatement);
                 localRewriter.AssertNoPlaceholderReplacements();
@@ -140,6 +148,7 @@ public static BoundStatement Rewrite(
             {
                 diagnostics.Add(ex.Diagnostic);
                 sawLambdas = sawLocalFunctions = sawAwaitInExceptionHandler = false;
+                codeCoverageSpans = ImmutableArray<SourceSpan>.Empty;
                 return new BoundBadStatement(statement.Syntax, ImmutableArray.Create<BoundNode>(statement), hasErrors: true);
             }
         }
@@ -147,6 +156,9 @@ public static BoundStatement Rewrite(
         internal SyntheticBoundNodeFactory Factory
             => _factory;
 
+        internal BoundBlock? CurrentLambdaBody
+            => _currentLambdaBody;
+
         internal BoundStatement CurrentMethodBody
             => _rootStatement;
 
@@ -268,8 +280,11 @@ public override BoundNode VisitLambda(BoundLambda node)
 
             var oldContainingSymbol = _factory.CurrentFunction;
             var oldInstrumenter = InstrumentationState.Instrumenter;
+            var oldLambdaBody = _currentLambdaBody;
             try
             {
+                _currentLambdaBody = node.Body;
+
                 _factory.CurrentFunction = lambda;
                 if (lambda.IsDirectlyExcludedFromCodeCoverage)
                 {
@@ -282,6 +297,7 @@ public override BoundNode VisitLambda(BoundLambda node)
             {
                 _factory.CurrentFunction = oldContainingSymbol;
                 InstrumentationState.Instrumenter = oldInstrumenter;
+                _currentLambdaBody = oldLambdaBody;
             }
         }
 
@@ -327,8 +343,10 @@ static bool hasReturnTypeOrParameter(LocalFunctionSymbol localFunction, Func<Typ
             var oldContainingSymbol = _factory.CurrentFunction;
             var oldInstrumenter = InstrumentationState.Instrumenter;
             var oldDynamicFactory = _dynamicFactory;
+            var oldLambdaBody = _currentLambdaBody;
             try
             {
+                _currentLambdaBody = node.Body;
                 _factory.CurrentFunction = localFunction;
 
                 if (localFunction.IsDirectlyExcludedFromCodeCoverage)
@@ -351,6 +369,7 @@ static bool hasReturnTypeOrParameter(LocalFunctionSymbol localFunction, Func<Typ
                 _factory.CurrentFunction = oldContainingSymbol;
                 InstrumentationState.Instrumenter = oldInstrumenter;
                 _dynamicFactory = oldDynamicFactory;
+                _currentLambdaBody = oldLambdaBody;
             }
         }
 
@@ -589,7 +608,7 @@ public override BoundNode VisitTypeOrInstanceInitializers(BoundTypeOrInstanceIni
 
                         var statement = RewriteExpressionStatement((BoundExpressionStatement)block.Statements.Single(), suppressInstrumentation: true);
                         Debug.Assert(statement is { });
-                        statements.Add(block.Update(block.Locals, block.LocalFunctions, block.HasUnsafeModifier, ImmutableArray.Create(statement)));
+                        statements.Add(block.Update(block.Locals, block.LocalFunctions, block.HasUnsafeModifier, block.Instrumentation, ImmutableArray.Create(statement)));
                     }
                     else
                     {
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_AssignmentOperator.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_AssignmentOperator.cs
index a475387e73dc6..785b34a087f2d 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_AssignmentOperator.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_AssignmentOperator.cs
@@ -223,12 +223,12 @@ private BoundExpression MakeStaticAssignmentOperator(
                 case BoundKind.FieldAccess:
                     {
                         Debug.Assert(!isRef || rewrittenLeft.GetRefKind() != RefKind.None);
-                        return new BoundAssignmentOperator(
+                        return _factory.AssignmentExpression(
                             syntax,
                             rewrittenLeft,
                             rewrittenRight,
-                            isRef,
-                            type);
+                            type,
+                            isRef);
                     }
 
                 case BoundKind.DiscardExpression:
@@ -261,7 +261,7 @@ private BoundExpression MakeStaticAssignmentOperator(
                 default:
                     {
                         Debug.Assert(!isRef);
-                        return new BoundAssignmentOperator(
+                        return _factory.AssignmentExpression(
                             syntax,
                             rewrittenLeft,
                             rewrittenRight,
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Block.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Block.cs
index 2236e6951ab7e..0e96c4d2fcaa0 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Block.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Block.cs
@@ -14,14 +14,20 @@ internal sealed partial class LocalRewriter
     {
         public override BoundNode VisitBlock(BoundBlock node)
         {
+            if (Instrument)
+            {
+                Instrumenter.PreInstrumentBlock(node, this);
+            }
+
             var builder = ArrayBuilder<BoundStatement>.GetInstance();
             VisitStatementSubList(builder, node.Statements);
 
             var additionalLocals = TemporaryArray<LocalSymbol>.Empty;
 
+            BoundBlockInstrumentation? instrumentation = null;
             if (Instrument)
             {
-                Instrumenter.InstrumentBlock(node, this, ref additionalLocals, out var prologue, out var epilogue);
+                Instrumenter.InstrumentBlock(node, this, ref additionalLocals, out var prologue, out var epilogue, out instrumentation);
                 if (prologue != null)
                 {
                     builder.Insert(0, prologue);
@@ -33,7 +39,7 @@ public override BoundNode VisitBlock(BoundBlock node)
                 }
             }
 
-            return new BoundBlock(node.Syntax, node.Locals.AddRange(additionalLocals), node.LocalFunctions, node.HasUnsafeModifier, builder.ToImmutableAndFree(), node.HasErrors);
+            return new BoundBlock(node.Syntax, node.Locals.AddRange(additionalLocals), node.LocalFunctions, node.HasUnsafeModifier, instrumentation, builder.ToImmutableAndFree(), node.HasErrors);
         }
 
         /// <summary>
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs
index bdabe974f18c4..de3261600f95c 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Call.cs
@@ -152,7 +152,7 @@ public override BoundNode VisitCall(BoundCall node)
                 storesOpt: null,
                 ref temps);
 
-            return MakeArgumentsAndCall(
+            var rewrittenCall = MakeArgumentsAndCall(
                 syntax: node.Syntax,
                 rewrittenReceiver: rewrittenReceiver,
                 method: node.Method,
@@ -165,6 +165,13 @@ public override BoundNode VisitCall(BoundCall node)
                 type: node.Type,
                 temps,
                 nodeOpt: node);
+
+            if (Instrument)
+            {
+                rewrittenCall = Instrumenter.InstrumentCall(node, rewrittenCall);
+            }
+
+            return rewrittenCall;
         }
 
         private BoundExpression MakeArgumentsAndCall(
@@ -497,7 +504,7 @@ private ImmutableArray<BoundExpression> VisitArgumentsAndCaptureReceiverIfNeeded
                         ref tempsOpt,
                         ref argumentsAssignedToTemp);
 
-                    visitedArgumentsBuilder.Add(VisitExpression(arguments[i]));
+                    visitedArgumentsBuilder.Add(VisitExpression(argument));
 
                     foreach (var placeholder in argumentPlaceholders)
                     {
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_FunctionPointerInvocation.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_FunctionPointerInvocation.cs
index 8f61e803990e0..8f5c8553a2c85 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_FunctionPointerInvocation.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_FunctionPointerInvocation.cs
@@ -14,6 +14,7 @@ internal sealed partial class LocalRewriter
         public override BoundNode? VisitFunctionPointerInvocation(BoundFunctionPointerInvocation node)
         {
             var rewrittenExpression = VisitExpression(node.InvokedExpression);
+            Debug.Assert(rewrittenExpression != null);
 
             // There are target types so we can have handler conversions, but there are no attributes so contexts cannot
             // be involved.
@@ -44,16 +45,23 @@ internal sealed partial class LocalRewriter
                 ref temps,
                 invokedAsExtensionMethod: false);
 
-            Debug.Assert(rewrittenExpression != null);
-            node = node.Update(rewrittenExpression, rewrittenArgs, argumentRefKindsOpt, node.ResultKind, node.Type);
+            BoundExpression rewrittenInvocation = node.Update(rewrittenExpression, rewrittenArgs, argumentRefKindsOpt, node.ResultKind, node.Type);
 
             if (temps.Count == 0)
             {
                 temps.Free();
-                return node;
+            }
+            else
+            {
+                rewrittenInvocation = new BoundSequence(rewrittenInvocation.Syntax, temps.ToImmutableAndFree(), sideEffects: ImmutableArray<BoundExpression>.Empty, rewrittenInvocation, node.Type);
+            }
+
+            if (Instrument)
+            {
+                rewrittenInvocation = Instrumenter.InstrumentFunctionPointerInvocation(node, rewrittenInvocation);
             }
 
-            return new BoundSequence(node.Syntax, temps.ToImmutableAndFree(), sideEffects: ImmutableArray<BoundExpression>.Empty, node, node.Type);
+            return rewrittenInvocation;
         }
     }
 }
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_LocalDeclaration.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_LocalDeclaration.cs
index 5d1347c2e72cc..b2d42a9a8597e 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_LocalDeclaration.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_LocalDeclaration.cs
@@ -54,7 +54,7 @@ internal sealed partial class LocalRewriter
 
             BoundStatement rewrittenLocalDeclaration = new BoundExpressionStatement(
                 syntax,
-                new BoundAssignmentOperator(
+                _factory.AssignmentExpression(
                     syntax,
                     new BoundLocal(
                         syntax,
@@ -78,7 +78,7 @@ private BoundStatement InstrumentLocalDeclarationIfNecessary(BoundLocalDeclarati
                     (originalOpt.Syntax.Kind() == SyntaxKind.LocalDeclarationStatement &&
                         ((LocalDeclarationStatementSyntax)originalOpt.Syntax).Declaration.Variables.Count == 1)))
             {
-                rewrittenLocalDeclaration = Instrumenter.InstrumentLocalInitialization(originalOpt, rewrittenLocalDeclaration);
+                rewrittenLocalDeclaration = Instrumenter.InstrumentUserDefinedLocalInitialization(originalOpt, rewrittenLocalDeclaration);
             }
 
             return rewrittenLocalDeclaration;
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_ObjectCreationExpression.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_ObjectCreationExpression.cs
index 9b0cbb9986dd2..b5632a1b8bd2e 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_ObjectCreationExpression.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_ObjectCreationExpression.cs
@@ -108,6 +108,11 @@ public override BoundNode VisitObjectCreationExpression(BoundObjectCreationExpre
                 rewrittenObjectCreation = MakeConversionNode(rewrittenObjectCreation, node.Type, false, false);
             }
 
+            if (Instrument)
+            {
+                rewrittenObjectCreation = Instrumenter.InstrumentObjectCreationExpression(node, rewrittenObjectCreation);
+            }
+
             if (node.InitializerExpressionOpt == null || node.InitializerExpressionOpt.HasErrors)
             {
                 return rewrittenObjectCreation;
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_TryStatement.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_TryStatement.cs
index b913eeae5e806..aa154b0b2b93d 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_TryStatement.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_TryStatement.cs
@@ -77,12 +77,7 @@ private static bool HasSideEffects([NotNullWhen(true)] BoundStatement? statement
 
         public override BoundNode? VisitCatchBlock(BoundCatchBlock node)
         {
-            if (node.ExceptionFilterOpt == null)
-            {
-                return base.VisitCatchBlock(node);
-            }
-
-            if (node.ExceptionFilterOpt.ConstantValueOpt?.BooleanValue == false)
+            if (node.ExceptionFilterOpt?.ConstantValueOpt?.BooleanValue == false)
             {
                 return null;
             }
@@ -94,11 +89,16 @@ private static bool HasSideEffects([NotNullWhen(true)] BoundStatement? statement
             Debug.Assert(rewrittenBody is { });
             TypeSymbol? rewrittenExceptionTypeOpt = this.VisitType(node.ExceptionTypeOpt);
 
-            // EnC: We need to insert a hidden sequence point to handle function remapping in case 
-            // the containing method is edited while methods invoked in the condition are being executed.
-            if (rewrittenFilter != null && !node.WasCompilerGenerated && this.Instrument)
+            if (Instrument)
             {
-                rewrittenFilter = Instrumenter.InstrumentCatchClauseFilter(node, rewrittenFilter, _factory);
+                Instrumenter.InstrumentCatchBlock(
+                    node,
+                    ref rewrittenExceptionSourceOpt,
+                    ref rewrittenFilterPrologue,
+                    ref rewrittenFilter,
+                    ref rewrittenBody,
+                    ref rewrittenExceptionTypeOpt,
+                    _factory);
             }
 
             return node.Update(
diff --git a/src/Compilers/CSharp/Portable/Lowering/MethodToClassRewriter.cs b/src/Compilers/CSharp/Portable/Lowering/MethodToClassRewriter.cs
index 0a5d8bcafa4e3..2228f9003d5bf 100644
--- a/src/Compilers/CSharp/Portable/Lowering/MethodToClassRewriter.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/MethodToClassRewriter.cs
@@ -6,6 +6,7 @@
 using System.Collections.Immutable;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
+using System.Diagnostics.Contracts;
 using Microsoft.CodeAnalysis.CodeGen;
 using Microsoft.CodeAnalysis.CSharp.Emit;
 using Microsoft.CodeAnalysis.PooledObjects;
@@ -49,11 +50,11 @@ internal abstract partial class MethodToClassRewriter : BoundTreeRewriterWithSta
         protected readonly TypeCompilationState CompilationState;
 
         protected readonly BindingDiagnosticBag Diagnostics;
-        protected readonly VariableSlotAllocator slotAllocatorOpt;
+        protected readonly VariableSlotAllocator? slotAllocatorOpt;
 
         private readonly Dictionary<BoundValuePlaceholderBase, BoundExpression> _placeholderMap;
 
-        protected MethodToClassRewriter(VariableSlotAllocator slotAllocatorOpt, TypeCompilationState compilationState, BindingDiagnosticBag diagnostics)
+        protected MethodToClassRewriter(VariableSlotAllocator? slotAllocatorOpt, TypeCompilationState compilationState, BindingDiagnosticBag diagnostics)
         {
             Debug.Assert(compilationState != null);
             Debug.Assert(diagnostics != null);
@@ -146,11 +147,17 @@ public override BoundNode VisitCatchBlock(BoundCatchBlock node)
         }
 
         public override BoundNode VisitBlock(BoundBlock node)
+            => VisitBlock(node, removeInstrumentation: false);
+
+        protected BoundBlock VisitBlock(BoundBlock node, bool removeInstrumentation)
         {
+            // Note: Instrumentation variable is intentionally not rewritten. It should never be lifted.
+
             var newLocals = RewriteLocals(node.Locals);
             var newLocalFunctions = node.LocalFunctions;
             var newStatements = VisitList(node.Statements);
-            return node.Update(newLocals, newLocalFunctions, node.HasUnsafeModifier, newStatements);
+            var newInstrumentation = removeInstrumentation ? null : (BoundBlockInstrumentation?)Visit(node.Instrumentation);
+            return node.Update(newLocals, newLocalFunctions, node.HasUnsafeModifier, newInstrumentation, newStatements);
         }
 
         public abstract override BoundNode VisitScope(BoundScope node);
@@ -399,6 +406,34 @@ public sealed override BoundNode VisitLocal(BoundLocal node)
             return VisitUnhoistedLocal(node);
         }
 
+        public override BoundNode? VisitLocalId(BoundLocalId node)
+            => TryGetHoistedField(node.Local, out var fieldSymbol) ?
+                node.Update(node.Local, fieldSymbol, node.Type) :
+                base.VisitLocalId(node);
+
+        public override BoundNode? VisitParameterId(BoundParameterId node)
+            => TryGetHoistedField(node.Parameter, out var fieldSymbol) ?
+                node.Update(node.Parameter, fieldSymbol, node.Type) :
+                base.VisitParameterId(node);
+
+        private bool TryGetHoistedField(Symbol variable, [NotNullWhen(true)] out FieldSymbol? field)
+        {
+            if (proxies.TryGetValue(variable, out CapturedSymbolReplacement? proxy))
+            {
+                field = proxy switch
+                {
+                    CapturedToStateMachineFieldReplacement stateMachineProxy => (FieldSymbol)stateMachineProxy.HoistedField,
+                    CapturedToFrameSymbolReplacement closureProxy => closureProxy.HoistedField,
+                    _ => throw ExceptionUtilities.UnexpectedValue(proxy)
+                };
+
+                return true;
+            }
+
+            field = null;
+            return false;
+        }
+
         private BoundNode VisitUnhoistedLocal(BoundLocal node)
         {
             if (this.localMap.TryGetValue(node.LocalSymbol, out LocalSymbol? replacementLocal))
diff --git a/src/Compilers/CSharp/Portable/Lowering/StateMachineRewriter/MethodToStateMachineRewriter.cs b/src/Compilers/CSharp/Portable/Lowering/StateMachineRewriter/MethodToStateMachineRewriter.cs
index 5fc63f49cd260..6c31af2d56938 100644
--- a/src/Compilers/CSharp/Portable/Lowering/StateMachineRewriter/MethodToStateMachineRewriter.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/StateMachineRewriter/MethodToStateMachineRewriter.cs
@@ -2,8 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-#nullable disable
-
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
@@ -49,7 +47,9 @@ internal abstract class MethodToStateMachineRewriter : MethodToClassRewriter
         ///       but such caching would not save as much indirection and could actually
         ///       be done at JIT level, possibly more efficiently)
         /// </summary>
-        protected readonly LocalSymbol cachedThis;
+        protected readonly LocalSymbol? cachedThis;
+
+        protected readonly FieldSymbol? instanceIdField;
 
         /// <summary>
         /// Allocates resumable states, i.e. states that resume execution of the state machine after await expression or yield return.
@@ -67,7 +67,7 @@ internal abstract class MethodToStateMachineRewriter : MethodToClassRewriter
         /// A pool of fields used to hoist locals. They appear in this set when not in scope,
         /// so that members of this set may be allocated to locals when the locals come into scope.
         /// </summary>
-        private Dictionary<TypeSymbol, ArrayBuilder<StateMachineFieldSymbol>> _lazyAvailableReusableHoistedFields;
+        private Dictionary<TypeSymbol, ArrayBuilder<StateMachineFieldSymbol>>? _lazyAvailableReusableHoistedFields;
 
         /// <summary>
         /// Fields allocated for temporary variables are given unique names distinguished by a number at the end.
@@ -93,16 +93,20 @@ internal abstract class MethodToStateMachineRewriter : MethodToClassRewriter
         /// </summary>
         private readonly ArrayBuilder<StateMachineStateDebugInfo> _stateDebugInfoBuilder;
 
+        // Instrumentation related bound nodes:
+        protected BoundBlockInstrumentation? _instrumentation;
+
         // new:
         public MethodToStateMachineRewriter(
             SyntheticBoundNodeFactory F,
             MethodSymbol originalMethod,
             FieldSymbol state,
+            FieldSymbol? instanceIdField,
             Roslyn.Utilities.IReadOnlySet<Symbol> hoistedVariables,
             IReadOnlyDictionary<Symbol, CapturedSymbolReplacement> nonReusableLocalProxies,
             SynthesizedLocalOrdinalsDispenser synthesizedLocalOrdinals,
             ArrayBuilder<StateMachineStateDebugInfo> stateMachineStateDebugInfoBuilder,
-            VariableSlotAllocator slotAllocatorOpt,
+            VariableSlotAllocator? slotAllocatorOpt,
             int nextFreeHoistedLocalSlot,
             BindingDiagnosticBag diagnostics)
             : base(slotAllocatorOpt, F.CompilationState, diagnostics)
@@ -117,6 +121,7 @@ public MethodToStateMachineRewriter(
 
             this.F = F;
             this.stateField = state;
+            this.instanceIdField = instanceIdField;
             this.cachedState = F.SynthesizedLocal(F.SpecialType(SpecialType.System_Int32), syntax: F.Syntax, kind: SynthesizedLocalKind.StateMachineCachedState);
             this.OriginalMethod = originalMethod;
             _hoistedVariables = hoistedVariables;
@@ -130,13 +135,14 @@ public MethodToStateMachineRewriter(
 
             // create cache local for reference type "this" in Release
             var thisParameter = originalMethod.ThisParameter;
-            CapturedSymbolReplacement thisProxy;
-            if ((object)thisParameter != null &&
+            CapturedSymbolReplacement? thisProxy;
+            if (thisParameter is not null &&
                 thisParameter.Type.IsReferenceType &&
                 proxies.TryGetValue(thisParameter, out thisProxy) &&
                 F.Compilation.Options.OptimizationLevel == OptimizationLevel.Release)
             {
                 BoundExpression thisProxyReplacement = thisProxy.Replacement(F.Syntax, frameType => F.This());
+                Debug.Assert(thisProxyReplacement.Type is not null);
                 this.cachedThis = F.SynthesizedLocal(thisProxyReplacement.Type, syntax: F.Syntax, kind: SynthesizedLocalKind.FrameCache);
             }
 
@@ -151,6 +157,7 @@ public MethodToStateMachineRewriter(
                 firstState: FirstIncreasingResumableState,
                 increasing: true);
         }
+#nullable disable
 
         protected abstract StateMachineState FirstIncreasingResumableState { get; }
         protected abstract string EncMissingStateMessage { get; }
@@ -328,7 +335,7 @@ private BoundStatement PossibleIteratorScope(ImmutableArray<LocalSymbol> locals,
             }
 
             var translatedStatement = wrapped();
-            var variableCleanup = ArrayBuilder<BoundAssignmentOperator>.GetInstance();
+            var variableCleanup = ArrayBuilder<BoundExpression>.GetInstance();
 
             // produce cleanup code for all fields of locals defined by this block
             // as well as all proxies allocated by VisitAssignmentOperator within this block:
@@ -414,7 +421,7 @@ internal static bool TryUnwrapBoundStateMachineScope(ref BoundStatement statemen
             return false;
         }
 
-        private void AddVariableCleanup(ArrayBuilder<BoundAssignmentOperator> cleanup, FieldSymbol field)
+        private void AddVariableCleanup(ArrayBuilder<BoundExpression> cleanup, FieldSymbol field)
         {
             if (MightContainReferences(field.Type))
             {
@@ -689,9 +696,18 @@ public override BoundNode Visit(BoundNode node)
 
         public override BoundNode VisitBlock(BoundBlock node)
         {
-            return PossibleIteratorScope(node.Locals, () => (BoundStatement)base.VisitBlock(node));
+            if (node.Instrumentation != null)
+            {
+                // Stash away the instrumentation node, it will be used when generating MoveNext method.
+                _instrumentation = (BoundBlockInstrumentation)Visit(node.Instrumentation);
+            }
+
+            return PossibleIteratorScope(node.Locals, () => VisitBlock(node, removeInstrumentation: true));
         }
 
+        public override BoundNode VisitStateMachineInstanceId(BoundStateMachineInstanceId node)
+            => F.Field(F.This(), instanceIdField);
+
         public override BoundNode VisitScope(BoundScope node)
         {
             Debug.Assert(!node.Locals.IsEmpty);
diff --git a/src/Compilers/CSharp/Portable/Lowering/StateMachineRewriter/StateMachineRewriter.cs b/src/Compilers/CSharp/Portable/Lowering/StateMachineRewriter/StateMachineRewriter.cs
index 9138deb880e85..e54c9781c2378 100644
--- a/src/Compilers/CSharp/Portable/Lowering/StateMachineRewriter/StateMachineRewriter.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/StateMachineRewriter/StateMachineRewriter.cs
@@ -2,8 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-#nullable disable
-
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
@@ -11,6 +9,7 @@
 using Microsoft.CodeAnalysis.CodeGen;
 using Microsoft.CodeAnalysis.Collections;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
+using Microsoft.CodeAnalysis.Emit;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Roslyn.Utilities;
 
@@ -23,29 +22,30 @@ internal abstract class StateMachineRewriter
         protected readonly BindingDiagnosticBag diagnostics;
         protected readonly SyntheticBoundNodeFactory F;
         protected readonly SynthesizedContainer stateMachineType;
-        protected readonly VariableSlotAllocator slotAllocatorOpt;
+        protected readonly VariableSlotAllocator? slotAllocatorOpt;
         protected readonly SynthesizedLocalOrdinalsDispenser synthesizedLocalOrdinals;
         protected readonly ArrayBuilder<StateMachineStateDebugInfo> stateMachineStateDebugInfoBuilder;
 
-        protected FieldSymbol stateField;
-        protected IReadOnlyDictionary<Symbol, CapturedSymbolReplacement> nonReusableLocalProxies;
+        protected FieldSymbol? stateField;
+        protected FieldSymbol? instanceIdField;
+        protected IReadOnlyDictionary<Symbol, CapturedSymbolReplacement>? nonReusableLocalProxies;
         protected int nextFreeHoistedLocalSlot;
-        protected IOrderedReadOnlySet<Symbol> hoistedVariables;
-        protected Dictionary<Symbol, CapturedSymbolReplacement> initialParameters;
-        protected FieldSymbol initialThreadIdField;
+        protected IOrderedReadOnlySet<Symbol>? hoistedVariables;
+        protected Dictionary<Symbol, CapturedSymbolReplacement>? initialParameters;
+        protected FieldSymbol? initialThreadIdField;
 
         protected StateMachineRewriter(
             BoundStatement body,
             MethodSymbol method,
             SynthesizedContainer stateMachineType,
             ArrayBuilder<StateMachineStateDebugInfo> stateMachineStateDebugInfoBuilder,
-            VariableSlotAllocator slotAllocatorOpt,
+            VariableSlotAllocator? slotAllocatorOpt,
             TypeCompilationState compilationState,
             BindingDiagnosticBag diagnostics)
         {
             Debug.Assert(body != null);
             Debug.Assert(method != null);
-            Debug.Assert((object)stateMachineType != null);
+            Debug.Assert(stateMachineType is not null);
             Debug.Assert(compilationState != null);
             Debug.Assert(diagnostics != null);
             Debug.Assert(diagnostics.DiagnosticBag != null);
@@ -64,6 +64,7 @@ protected StateMachineRewriter(
             Debug.Assert(F.Syntax == body.Syntax);
         }
 
+#nullable disable
         /// <summary>
         /// True if the initial values of locals in the rewritten method and the initial thread ID need to be preserved. (e.g. enumerable iterator methods and async-enumerable iterator methods)
         /// </summary>
diff --git a/src/Compilers/CSharp/Portable/Lowering/SyntheticBoundNodeFactory.cs b/src/Compilers/CSharp/Portable/Lowering/SyntheticBoundNodeFactory.cs
index 48f9f6f977085..58234ae99fb91 100644
--- a/src/Compilers/CSharp/Portable/Lowering/SyntheticBoundNodeFactory.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/SyntheticBoundNodeFactory.cs
@@ -428,14 +428,29 @@ public BoundExpressionStatement ExpressionStatement(BoundExpression expr)
             return new BoundExpressionStatement(Syntax, expr) { WasCompilerGenerated = true };
         }
 
-        public BoundAssignmentOperator AssignmentExpression(BoundExpression left, BoundExpression right, bool isRef = false)
+        /// <summary>
+        /// Creates a general assignment that might be instrumented.
+        /// </summary>
+        public BoundExpression AssignmentExpression(BoundExpression left, BoundExpression right, bool isRef = false)
         {
             Debug.Assert(left.Type is { } && right.Type is { } &&
                 (left.Type.Equals(right.Type, TypeCompareKind.AllIgnoreOptions) ||
                  StackOptimizerPass1.IsFixedBufferAssignmentToRefLocal(left, right, isRef) ||
                  right.Type.IsErrorType() || left.Type.IsErrorType()));
 
-            return new BoundAssignmentOperator(Syntax, left, right, left.Type, isRef: isRef) { WasCompilerGenerated = true };
+            return AssignmentExpression(Syntax, left, right, left.Type, isRef: isRef, wasCompilerGenerated: true);
+        }
+
+        /// <summary>
+        /// Creates a general assignment that might be instrumented.
+        /// </summary>
+        public BoundExpression AssignmentExpression(SyntaxNode syntax, BoundExpression left, BoundExpression right, TypeSymbol type, bool isRef = false, bool hasErrors = false, bool wasCompilerGenerated = false)
+        {
+            var assignment = new BoundAssignmentOperator(syntax, left, right, isRef, type, hasErrors) { WasCompilerGenerated = wasCompilerGenerated };
+
+            return (InstrumentationState?.IsSuppressed == false && left is BoundLocal { LocalSymbol.SynthesizedKind: SynthesizedLocalKind.UserDefined } or BoundParameter) ?
+                InstrumentationState.Instrumenter.InstrumentUserDefinedLocalAssignment(assignment) :
+                assignment;
         }
 
         public BoundBlock Block()
@@ -470,7 +485,7 @@ public BoundBlock Block(ImmutableArray<LocalSymbol> locals, ImmutableArray<Local
 
         public BoundBlock Block(ImmutableArray<LocalSymbol> locals, ImmutableArray<LocalFunctionSymbol> localFunctions, ImmutableArray<BoundStatement> statements)
         {
-            return new BoundBlock(Syntax, locals, localFunctions, hasUnsafeModifier: false, statements) { WasCompilerGenerated = true };
+            return new BoundBlock(Syntax, locals, localFunctions, hasUnsafeModifier: false, instrumentation: null, statements) { WasCompilerGenerated = true };
         }
 
         public BoundExtractedFinallyBlock ExtractedFinallyBlock(BoundBlock finallyBlock)
@@ -1217,6 +1232,35 @@ public BoundExpression MethodDefIndex(MethodSymbol method)
             { WasCompilerGenerated = true };
         }
 
+        public BoundExpression LocalId(LocalSymbol symbol)
+        {
+            return new BoundLocalId(
+                Syntax,
+                symbol,
+                hoistedField: null,
+                SpecialType(Microsoft.CodeAnalysis.SpecialType.System_Int32))
+            { WasCompilerGenerated = true };
+        }
+
+        public BoundExpression ParameterId(ParameterSymbol symbol)
+        {
+            return new BoundParameterId(
+                Syntax,
+                symbol,
+                hoistedField: null,
+                SpecialType(Microsoft.CodeAnalysis.SpecialType.System_Int32))
+            { WasCompilerGenerated = true };
+        }
+
+        public BoundExpression StateMachineInstanceId()
+        {
+            return new BoundStateMachineInstanceId(
+                Syntax,
+                field: null,
+                SpecialType(Microsoft.CodeAnalysis.SpecialType.System_UInt64))
+            { WasCompilerGenerated = true };
+        }
+
         /// <summary>
         /// Synthesizes an expression that evaluates to the current module's MVID.
         /// </summary>
@@ -1476,6 +1520,7 @@ public BoundLocal StoreToTemp(
             Debug.Assert(argument.Type is { });
             MethodSymbol? containingMethod = this.CurrentFunction;
             Debug.Assert(containingMethod is { });
+            Debug.Assert(kind != SynthesizedLocalKind.UserDefined);
 
             switch (refKind)
             {
@@ -1522,14 +1567,14 @@ public BoundLocal StoreToTemp(
                     isKnownToReferToTempIfReferenceType: isKnownToReferToTempIfReferenceType,
                     refKind: refKind),
                 null,
-                type);
+            type);
 
             store = new BoundAssignmentOperator(
                 syntax,
                 local,
                 argument,
-                refKind != RefKind.None,
-                type);
+                type,
+                isRef: refKind != RefKind.None);
 
             return local;
         }
diff --git a/src/Compilers/CSharp/Portable/Symbols/Synthesized/GeneratedNameKind.cs b/src/Compilers/CSharp/Portable/Symbols/Synthesized/GeneratedNameKind.cs
index 1404bc8a80496..29951480a3588 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Synthesized/GeneratedNameKind.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Synthesized/GeneratedNameKind.cs
@@ -34,6 +34,7 @@ internal enum GeneratedNameKind
         AnonymousType = 'f',
         TransparentIdentifier = 'h',
         AnonymousTypeField = 'i',
+        StateMachineStateIdField = 'I',
         AnonymousTypeTypeParameter = 'j',
         AutoPropertyBackingField = 'k',
         IteratorCurrentThreadIdField = 'l',
diff --git a/src/Compilers/CSharp/Portable/Symbols/Synthesized/GeneratedNames.cs b/src/Compilers/CSharp/Portable/Symbols/Synthesized/GeneratedNames.cs
index 3ae0159c5f0df..4ae9b7fc3326f 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Synthesized/GeneratedNames.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Synthesized/GeneratedNames.cs
@@ -319,6 +319,12 @@ internal static string MakeIteratorCurrentThreadIdFieldName()
             return "<>l__initialThreadId";
         }
 
+        internal static string MakeStateMachineStateIdFieldName()
+        {
+            Debug.Assert((char)GeneratedNameKind.StateMachineStateIdField == 'I');
+            return "<>I";
+        }
+
         internal static string ThisProxyFieldName()
         {
             Debug.Assert((char)GeneratedNameKind.ThisProxyField == '4');
diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenTests.cs
index 73b984de19750..60962a32b0414 100644
--- a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenTests.cs
@@ -13266,7 +13266,6 @@ static System.Action M()
                 compilation: compilation,
                 moduleBeingBuiltOpt: module,
                 emittingPdb: false,
-                emitTestCoverageData: false,
                 hasDeclarationErrors: false,
                 emitMethodBodies: true,
                 diagnostics: new BindingDiagnosticBag(diagnostics),
diff --git a/src/Compilers/CSharp/Test/Emit/Emit/DynamicAnalysis/DynamicInstrumentationTests.cs b/src/Compilers/CSharp/Test/Emit/Emit/DynamicAnalysis/DynamicInstrumentationTests.cs
index 1139098c63857..d1f62549e8b9b 100644
--- a/src/Compilers/CSharp/Test/Emit/Emit/DynamicAnalysis/DynamicInstrumentationTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/Emit/DynamicAnalysis/DynamicInstrumentationTests.cs
@@ -21,8 +21,6 @@ public class DynamicInstrumentationTests : CSharpTestBase
         public void HelpersInstrumentation()
         {
             string source = @"
-using System;
-
 public class Program
 {
     public static void Main(string[] args)
@@ -690,8 +688,6 @@ .locals init (bool[] V_0,
         public void NonStaticImplicitBlockMethodsCoverage()
         {
             string source = @"
-using System;
-
 public class Program
 {
     public int Prop { get; }
@@ -962,8 +958,6 @@ void L1()
         public void MultipleFilesCoverage()
         {
             string source = @"
-using System;
-
 public class Program
 {
 #line 10 ""File1.cs""
@@ -1142,7 +1136,6 @@ File 1
         public void UsingAndFixedCoverage()
         {
             string source = @"
-using System;
 using System.IO;
 
 public class Program
@@ -1426,8 +1419,6 @@ File 1
         public void PatternsCoverage()
         {
             string source = @"
-using System;
-
 public class C
 {
     public static void Main()
@@ -1461,7 +1452,7 @@ static string Operate(Person p)                         // Method 3
 }
 
 class Person { public string Name; }
-class Teacher : Person { public string Subject; }
+class Teacher : Person { public string Subject = string.Empty; }
 class Student : Person { public double GPA; }
 
     // Methods 7 and 9 are implicit constructors.
@@ -1513,7 +1504,7 @@ File 1
 ";
 
             CompilationVerifier verifier = CompileAndVerify(source + InstrumentationHelperSource, expectedOutput: expectedOutput);
-            verifier.VerifyDiagnostics(Diagnostic(ErrorCode.WRN_UnassignedInternalField, "Subject").WithArguments("Teacher.Subject", "null").WithLocation(37, 40));
+            verifier.VerifyDiagnostics();
         }
 
         /// <see cref="DynamicAnalysisResourceTests.TestPatternSpans_WithSharedWhenExpression"/>
@@ -2034,8 +2025,6 @@ File 1
         public void TestFieldInitializerCoverage()
         {
             string source = @"
-using System;
-
 public class C
 {
     public static void Main()                                   // Method 1
@@ -2214,8 +2203,6 @@ .locals init (bool[] V_0)
         public void TestImplicitConstructorCoverage()
         {
             string source = @"
-using System;
-
 public class C
 {
     public static void Main()                                   // Method 1
@@ -2946,7 +2933,6 @@ class C
         public void ExcludeFromCodeCoverageAttribute_CustomDefinition_Good()
         {
             string source = @"
-using System;
 using System.Diagnostics.CodeAnalysis;
 
 namespace System.Diagnostics.CodeAnalysis
@@ -2983,7 +2969,6 @@ void M() {}
         public void ExcludeFromCodeCoverageAttribute_CustomDefinition_Bad()
         {
             string source = @"
-using System;
 using System.Diagnostics.CodeAnalysis;
 
 namespace System.Diagnostics.CodeAnalysis
diff --git a/src/Compilers/CSharp/Test/Emit/Emit/LocalStateTracing/LocalStateTracingTests.cs b/src/Compilers/CSharp/Test/Emit/Emit/LocalStateTracing/LocalStateTracingTests.cs
new file mode 100644
index 0000000000000..96f3d0f9fa164
--- /dev/null
+++ b/src/Compilers/CSharp/Test/Emit/Emit/LocalStateTracing/LocalStateTracingTests.cs
@@ -0,0 +1,5898 @@
+// 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.
+#if NET
+using System;
+using System.Collections.Immutable;
+using System.IO;
+using System.Linq;
+using Microsoft.CodeAnalysis.CSharp.EditAndContinue.UnitTests;
+using Microsoft.CodeAnalysis.CSharp.Symbols;
+using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
+using Microsoft.CodeAnalysis.Emit;
+using Microsoft.CodeAnalysis.Test.Utilities;
+using Roslyn.Test.Utilities;
+using Xunit;
+
+namespace Microsoft.CodeAnalysis.CSharp.UnitTests
+{
+    public class LocalStateTracingTests : CSharpTestBase
+    {
+        // TODO:
+        // arrays (stloc, stelem),
+        // collections, anonymous types, tuples
+
+        private static readonly EmitOptions s_emitOptions = EmitOptions.Default
+            .WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.LocalStateTracing));
+
+        private const string TrackerTypeName = "Microsoft.CodeAnalysis.Runtime.LocalStoreTracker";
+
+        private static readonly string s_helpers = """
+namespace Microsoft.CodeAnalysis.Runtime
+{
+    using System.Linq;
+    using System.Reflection;
+    using System.Threading;
+    using static System.Console;
+
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+    public unsafe readonly ref struct LocalStoreTracker
+    {
+        private static int s_stateMachineId;
+
+        private readonly MethodBase M;
+        private readonly ParameterInfo[] Parameters;
+
+        private LocalStoreTracker(MethodBase m)
+        {
+            M = m;
+            Parameters = m.GetParameters();
+        }
+
+        public static LocalStoreTracker LogMethodEntry(int methodId)
+            => Entry(methodId, lambdaId: 0, stateMachineId: 0);
+
+        public static LocalStoreTracker LogLambdaEntry(int methodId, int lambdaId)
+            => Entry(methodId, lambdaId, stateMachineId: 0);
+
+        public static LocalStoreTracker LogStateMachineMethodEntry(int methodId, ulong stateMachineId)
+            => Entry(methodId, lambdaId: 0, stateMachineId);
+
+        public static LocalStoreTracker LogStateMachineLambdaEntry(int methodId, int lambdaId, ulong stateMachineId)
+            => Entry(methodId, lambdaId, stateMachineId);
+
+        public void LogReturn()
+            => WriteLine($"{M.Name}: Returned");
+
+        public static ulong GetNewStateMachineInstanceId()
+            => unchecked((ulong)Interlocked.Increment(ref s_stateMachineId));
+
+        private static LocalStoreTracker Entry(int methodId, int lambdaId, ulong stateMachineId)
+        {
+            var module = typeof(LocalStoreTracker).Assembly.Modules.Single();
+            var method = module.ResolveMethod(methodId + 0x06000000);
+            var message = $"{method.Name}: Entered";
+
+            if (lambdaId > 0)
+            {
+                var lambda = module.ResolveMethod(lambdaId + 0x06000000);
+                message += $" lambda '{lambda.Name}'";
+                method = lambda;
+            }
+
+            if (stateMachineId > 0)
+            {
+                message += $" state machine #{stateMachineId}";
+            }
+
+            WriteLine(message);
+            return new(method);
+        }
+
+        private void WL(object value, int index)
+            => WriteLine($"{M.Name}: {L(index)} = {value}");
+
+        private void WP(object value, int index)
+            => WriteLine($"{M.Name}: {P(index)} = {value}");
+
+        private string L(int index)
+            => (index >= 0x10000) ? $"L'{UnmangleFieldName(M.Module.ResolveField(index - 0x10000 + 0x04000000).Name)}'" : $"L{index}";
+
+        private string P(int index)
+            => (index >= 0x10000) ? $"P'{M.Module.ResolveField(index - 0x10000 + 0x04000000).Name}'" : $"P'{Parameters[index].Name}'[{index}]";
+
+        private static string UnmangleFieldName(string name)
+            => (name[0] == '<') ? name.Substring(1, name.IndexOf('>') - 1) : name;
+
+        public void LogLocalStore(bool value, int index) => WL(value, index);
+        public void LogLocalStore(byte value, int index) => WL(value, index);
+        public void LogLocalStore(ushort value, int index) => WL(value, index);
+        public void LogLocalStore(uint value, int index) => WL(value, index);
+        public void LogLocalStore(ulong value, int index) => WL(value, index);
+        public void LogLocalStore(string value, int index) => WL(value, index);
+        public void LogLocalStore(object value, int index) => WL(value, index);
+        public void LogLocalStore(void* value, int index) => WL("*ptr*", index);
+        public void LogLocalStoreUnmanaged<T>(ref T local, int index) => WL(local, index);
+        public void LogLocalStoreParameterAlias(int sourceParameterIndex, int targetLocalIndex) { WriteLine($"{M.Name}: {L(targetLocalIndex)} -> {P(sourceParameterIndex)}"); }
+
+        public void LogParameterStore(bool value, int index) => WP(value, index);
+        public void LogParameterStore(byte value, int index) => WP(value, index);
+        public void LogParameterStore(ushort value, int index) => WP(value, index);
+        public void LogParameterStore(uint value, int index) => WP(value, index);
+        public void LogParameterStore(ulong value, int index) => WP(value, index);
+        public void LogParameterStore(string value, int index) => WP(value, index);
+        public void LogParameterStore(object value, int index) => WP(value, index);
+        public void LogParameterStore(void* value, int index) => WP("*ptr*", index);
+        public void LogParameterStoreUnmanaged<T>(ref T parameter, int index) => WP(parameter, index);
+        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 WithHelpers(string source)
+            => source + s_helpers;
+
+        private static readonly TargetFramework s_targetFramework = TargetFramework.Net70;
+
+        private static readonly Verification s_verification = Verification.Fails with
+        {
+            ILVerifyMessage = """
+            [LogMethodEntry]: Return type is ByRef, TypedReference, ArgHandle, or ArgIterator. { Offset = 0x9 }
+            [LogLambdaEntry]: Return type is ByRef, TypedReference, ArgHandle, or ArgIterator. { Offset = 0x9 }
+            [LogStateMachineMethodEntry]: Return type is ByRef, TypedReference, ArgHandle, or ArgIterator. { Offset = 0x8 }
+            [LogStateMachineLambdaEntry]: Return type is ByRef, TypedReference, ArgHandle, or ArgIterator. { Offset = 0x8 }
+            [Entry]: Return type is ByRef, TypedReference, ArgHandle, or ArgIterator. { Offset = 0xbc }
+            """
+        };
+
+        private CompilationVerifier CompileAndVerify(string source, string? ilVerifyMessage = null, string? expectedOutput = null)
+            => CompileAndVerify(
+                source,
+                options: (expectedOutput != null) ? TestOptions.UnsafeDebugExe : TestOptions.UnsafeDebugDll,
+                emitOptions: s_emitOptions,
+                verify: s_verification with { ILVerifyMessage = ilVerifyMessage + Environment.NewLine + s_verification.ILVerifyMessage },
+                targetFramework: s_targetFramework,
+                expectedOutput: expectedOutput);
+
+        private static void AssertNotInstrumented(CompilationVerifier verifier, string qualifiedMethodName)
+            => AssertInstrumented(verifier, qualifiedMethodName, expected: false);
+
+        private static void AssertInstrumented(CompilationVerifier verifier, string qualifiedMethodName, bool expected = true)
+        {
+            var il = verifier.VisualizeIL(qualifiedMethodName);
+            var isInstrumented = il.Contains(TrackerTypeName);
+
+            AssertEx.AreEqual(expected, isInstrumented,
+                $"Method '{qualifiedMethodName}' should {(expected ? "be" : "not be")} instrumented. Actual IL:{Environment.NewLine}{il}");
+        }
+
+        [Fact]
+        public void Composition_LocalStateTracing_TestCoverage()
+        {
+            var source = WithHelpers(@"
+class C
+{
+    static void Main(string[] p)
+    {
+        string[] a = p = null;
+        Microsoft.CodeAnalysis.Runtime.Instrumentation.FlushPayload();
+    }
+}
+") + CSharpInstrumentationChecker.InstrumentationHelperSource;
+
+            var verifier = CompileAndVerify(
+                source,
+                options: TestOptions.UnsafeDebugExe,
+                emitOptions: EmitOptions.Default
+                    .WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.LocalStateTracing, InstrumentationKind.TestCoverage)),
+                verify: s_verification,
+                targetFramework: s_targetFramework);
+
+            verifier.VerifyMethodBody("C.Main", @"
+{
+  // Code size      128 (0x80)
+  .maxstack  5
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0,
+                string[] V_1, //a
+                bool[] V_2)
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""void C.Main(string[])""
+  IL_0005:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogMethodEntry(int)""
+  IL_000a:  stloc.0
+  .try
+  {
+    // sequence point: {
+    IL_000b:  ldsfld     ""bool[][] <PrivateImplementationDetails>.PayloadRoot0""
+    IL_0010:  ldtoken    ""void C.Main(string[])""
+    IL_0015:  ldelem.ref
+    IL_0016:  stloc.2
+    IL_0017:  ldloc.2
+    IL_0018:  brtrue.s   IL_003f
+    IL_001a:  ldsfld     ""System.Guid <PrivateImplementationDetails>.MVID""
+    IL_001f:  ldtoken    ""void C.Main(string[])""
+    IL_0024:  ldtoken    Source Document 0
+    IL_0029:  ldsfld     ""bool[][] <PrivateImplementationDetails>.PayloadRoot0""
+    IL_002e:  ldtoken    ""void C.Main(string[])""
+    IL_0033:  ldelema    ""bool[]""
+    IL_0038:  ldc.i4.3
+    IL_0039:  call       ""bool[] Microsoft.CodeAnalysis.Runtime.Instrumentation.CreatePayload(System.Guid, int, int, ref bool[], int)""
+    IL_003e:  stloc.2
+    IL_003f:  ldloc.2
+    IL_0040:  ldc.i4.0
+    IL_0041:  ldc.i4.1
+    IL_0042:  stelem.i1
+    IL_0043:  ldloca.s   V_0
+    IL_0045:  ldarg.0
+    IL_0046:  ldc.i4.0
+    IL_0047:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogParameterStore(object, int)""
+    IL_004c:  nop
+    // sequence point: string[] a = p = null;
+    IL_004d:  ldloc.2
+    IL_004e:  ldc.i4.1
+    IL_004f:  ldc.i4.1
+    IL_0050:  stelem.i1
+    IL_0051:  ldloca.s   V_0
+    IL_0053:  ldloca.s   V_0
+    IL_0055:  ldnull
+    IL_0056:  dup
+    IL_0057:  starg.s    V_0
+    IL_0059:  ldc.i4.0
+    IL_005a:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogParameterStore(object, int)""
+    IL_005f:  nop
+    IL_0060:  ldarg.0
+    IL_0061:  dup
+    IL_0062:  stloc.1
+    IL_0063:  ldc.i4.1
+    IL_0064:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(object, int)""
+    IL_0069:  nop
+    // sequence point: Microsoft.CodeAnalysis.Runtime.Instrumentation.FlushPayload();
+    IL_006a:  ldloc.2
+    IL_006b:  ldc.i4.2
+    IL_006c:  ldc.i4.1
+    IL_006d:  stelem.i1
+    IL_006e:  call       ""void Microsoft.CodeAnalysis.Runtime.Instrumentation.FlushPayload()""
+    IL_0073:  nop
+    // sequence point: }
+    IL_0074:  leave.s    IL_007f
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_0076:  ldloca.s   V_0
+    IL_0078:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_007d:  nop
+    IL_007e:  endfinally
+  }
+  // sequence point: }
+  IL_007f:  ret
+}
+");
+        }
+
+        [Fact]
+        public void Composition_LocalStateTracing_TestCoverage_LocallySuppressed()
+        {
+            var source = WithHelpers(@"
+class C
+{
+    static void Main()
+    {
+        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+        void F()
+        {
+            int a = 1;    
+        }
+
+        F();
+
+        Microsoft.CodeAnalysis.Runtime.Instrumentation.FlushPayload();
+    }
+}
+") + CSharpInstrumentationChecker.InstrumentationHelperSource;
+
+            var verifier = CompileAndVerify(
+                source,
+                options: TestOptions.UnsafeDebugExe,
+                emitOptions: EmitOptions.Default
+                    .WithInstrumentationKinds(ImmutableArray.Create(InstrumentationKind.LocalStateTracing, InstrumentationKind.TestCoverage)),
+                verify: s_verification,
+                targetFramework: s_targetFramework);
+
+            verifier.VerifyMethodBody("C.<Main>g__F|0_0", @"
+{
+  // Code size       41 (0x29)
+  .maxstack  3
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0,
+                int V_1) //a
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""void C.Main()""
+  IL_0005:  ldtoken    ""void C.<Main>g__F|0_0()""
+  IL_000a:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLambdaEntry(int, int)""
+  IL_000f:  stloc.0
+  .try
+  {
+    // sequence point: {
+    IL_0010:  nop
+    // sequence point: int a = 1;
+    IL_0011:  ldloca.s   V_0
+    IL_0013:  ldc.i4.1
+    IL_0014:  dup
+    IL_0015:  stloc.1
+    IL_0016:  ldc.i4.1
+    IL_0017:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_001c:  nop
+    // sequence point: }
+    IL_001d:  leave.s    IL_0028
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_001f:  ldloca.s   V_0
+    IL_0021:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_0026:  nop
+    IL_0027:  endfinally
+  }
+  // sequence point: }
+  IL_0028:  ret
+}
+");
+        }
+
+        [Fact]
+        public void EmitDifference()
+        {
+            var source = WithHelpers(@"
+class C
+{
+    static void F()
+    {
+        int a = 0xFFFF;
+
+        static void LF() { int b = 0xEEEE; }
+
+        LF();
+    }
+}
+");
+
+            var compilation0 = CreateCompilation(source, options: TestOptions.UnsafeDebugDll, targetFramework: s_targetFramework);
+            var compilation1 = compilation0.WithSource(source);
+
+            var f0 = compilation0.GetMember("C.F").GetPublicSymbol();
+            var f1 = compilation1.GetMember("C.F").GetPublicSymbol();
+
+            using var md0 = ModuleMetadata.CreateFromImage(compilation0.EmitToArray());
+            var generation0 = EmitBaseline.CreateInitialBaseline(md0, debugInformationProvider: _ => default);
+
+            var diff = compilation1.EmitDifference(
+                generation0,
+                edits: ImmutableArray.Create(
+                    new SemanticEdit(SemanticEditKind.Update, f0, f1, instrumentation: new MethodInstrumentation() { Kinds = ImmutableArray.Create(InstrumentationKind.LocalStateTracing) })));
+
+            diff.VerifyIL(@"
+{
+  // Code size       47 (0x2f)
+  .maxstack  3
+  IL_0000:  ldc.i4     0x3
+  IL_0005:  call       0x06000007
+  IL_000a:  stloc.0
+  IL_000b:  nop
+  IL_000c:  ldloca.s   V_0
+  IL_000e:  ldc.i4     0xffff
+  IL_0013:  dup
+  IL_0014:  stloc.1
+  IL_0015:  ldc.i4.1
+  IL_0016:  call       0x06000016
+  IL_001b:  nop
+  IL_001c:  nop
+  IL_001d:  call       0x06000028
+  IL_0022:  nop
+  IL_0023:  leave.s    IL_002e
+  IL_0025:  ldloca.s   V_0
+  IL_0027:  call       0x0600000B
+  IL_002c:  nop
+  IL_002d:  endfinally
+  IL_002e:  ret
+}
+{
+  // Code size       45 (0x2d)
+  .maxstack  3
+  IL_0000:  ldc.i4     0x3
+  IL_0005:  ldc.i4     0x28
+  IL_000a:  call       0x06000008
+  IL_000f:  stloc.0
+  IL_0010:  nop
+  IL_0011:  ldloca.s   V_0
+  IL_0013:  ldc.i4     0xeeee
+  IL_0018:  dup
+  IL_0019:  stloc.1
+  IL_001a:  ldc.i4.1
+  IL_001b:  call       0x06000016
+  IL_0020:  nop
+  IL_0021:  leave.s    IL_002c
+  IL_0023:  ldloca.s   V_0
+  IL_0025:  call       0x0600000B
+  IL_002a:  nop
+  IL_002b:  endfinally
+  IL_002c:  ret
+}
+");
+        }
+
+        [Fact]
+        public void HelpersNotInstrumented()
+        {
+            var source = WithHelpers("");
+            var verifier = CompileAndVerify(source);
+            foreach (var entry in verifier.TestData.Methods)
+            {
+                string actualIL = verifier.VisualizeIL(entry.Value);
+                Assert.False(actualIL.Contains(TrackerTypeName + ".Log"));
+            }
+        }
+
+        [Fact]
+        public void ObjectInitializers_NotInstrumented()
+        {
+            var source = WithHelpers(@"
+class C
+{
+    int X;
+
+    public C F() => new C() { X = 1 };
+}
+");
+            var verifier = CompileAndVerify(source);
+
+            verifier.VerifyMethodBody("C.F", @"
+{
+  // Code size       37 (0x25)
+  .maxstack  3
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0,
+                C V_1)
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""C C.F()""
+  IL_0005:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogMethodEntry(int)""
+  IL_000a:  stloc.0
+  .try
+  {
+    // sequence point: new C() { X = 1 }
+    IL_000b:  newobj     ""C..ctor()""
+    IL_0010:  dup
+    IL_0011:  ldc.i4.1
+    IL_0012:  stfld      ""int C.X""
+    IL_0017:  stloc.1
+    IL_0018:  leave.s    IL_0023
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_001a:  ldloca.s   V_0
+    IL_001c:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_0021:  nop
+    IL_0022:  endfinally
+  }
+  // sequence point: <hidden>
+  IL_0023:  ldloc.1
+  IL_0024:  ret
+}
+");
+        }
+
+        [Fact]
+        public void WithExpressions_NotInstrumented()
+        {
+            var source = WithHelpers(@"
+record class C(int X)
+{
+    public C F() => new C(0) with { X = 1 };
+}
+");
+            var verifier = CompileAndVerify(source);
+
+            verifier.VerifyMethodBody("C.F", @"
+{
+  // Code size       44 (0x2c)
+  .maxstack  3
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0,
+                C V_1)
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""C C.F()""
+  IL_0005:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogMethodEntry(int)""
+  IL_000a:  stloc.0
+  .try
+  {
+    // sequence point: new C(0) with { X = 1 }
+    IL_000b:  ldc.i4.0
+    IL_000c:  newobj     ""C..ctor(int)""
+    IL_0011:  callvirt   ""C C.<Clone>$()""
+    IL_0016:  dup
+    IL_0017:  ldc.i4.1
+    IL_0018:  callvirt   ""void C.X.init""
+    IL_001d:  nop
+    IL_001e:  stloc.1
+    IL_001f:  leave.s    IL_002a
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_0021:  ldloca.s   V_0
+    IL_0023:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_0028:  nop
+    IL_0029:  endfinally
+  }
+  // sequence point: <hidden>
+  IL_002a:  ldloc.1
+  IL_002b:  ret
+}
+");
+        }
+
+        [Fact]
+        public void MemberAssignment_NotInstrumented()
+        {
+            var source = WithHelpers(@"
+class C
+{
+    int X;
+    int P { get => 1; set { X = value; } }
+
+    public void F() { X = 1; P = 2; }
+}
+");
+            var verifier = CompileAndVerify(source);
+
+            verifier.VerifyMethodBody("C.F", @"
+{
+  // Code size       39 (0x27)
+  .maxstack  2
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0)
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""void C.F()""
+  IL_0005:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogMethodEntry(int)""
+  IL_000a:  stloc.0
+  .try
+  {
+    // sequence point: {
+    IL_000b:  nop
+    // sequence point: X = 1;
+    IL_000c:  ldarg.0
+    IL_000d:  ldc.i4.1
+    IL_000e:  stfld      ""int C.X""
+    // sequence point: P = 2;
+    IL_0013:  ldarg.0
+    IL_0014:  ldc.i4.2
+    IL_0015:  call       ""void C.P.set""
+    IL_001a:  nop
+    // sequence point: }
+    IL_001b:  leave.s    IL_0026
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_001d:  ldloca.s   V_0
+    IL_001f:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_0024:  nop
+    IL_0025:  endfinally
+  }
+  // sequence point: }
+  IL_0026:  ret
+}
+");
+        }
+
+        [Fact]
+        public void AutoPropertyAccessors_NotInstrumented()
+        {
+            var source = WithHelpers(@"
+class C
+{
+    int P { get; set; }
+}
+");
+            var verifier = CompileAndVerify(source);
+
+            AssertNotInstrumented(verifier, "C.P.get");
+            AssertNotInstrumented(verifier, "C.P.set");
+        }
+
+        [Fact]
+        public void EventAccessors_NotInstrumented()
+        {
+            var source = WithHelpers(@"
+using System;
+
+class C
+{
+    event Action E;
+}
+");
+
+            var verifier = CompileAndVerify(source);
+
+            AssertNotInstrumented(verifier, "C.E.add");
+            AssertNotInstrumented(verifier, "C.E.remove");
+        }
+
+        [Fact]
+        public void SimpleLocalsAndParameters()
+        {
+            var source = WithHelpers(@"
+class C
+{
+    public void F(int p, int q)
+    {
+        int x = 1;
+        p = x = 2;
+        for (int i = 0; i < 10; i++)
+        {
+            q = x += 2;
+        }
+    }
+}
+");
+            var verifier = CompileAndVerify(source);
+
+            verifier.VerifyMethodBody("C.F", @"
+{
+  // Code size      150 (0x96)
+  .maxstack  4
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0,
+                int V_1, //x
+                int V_2, //i
+                int V_3,
+                bool V_4)
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""void C.F(int, int)""
+  IL_0005:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogMethodEntry(int)""
+  IL_000a:  stloc.0
+  .try
+  {
+    // sequence point: {
+    IL_000b:  ldloca.s   V_0
+    IL_000d:  ldarg.1
+    IL_000e:  ldc.i4.0
+    IL_000f:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogParameterStore(uint, int)""
+    IL_0014:  nop
+    IL_0015:  ldloca.s   V_0
+    IL_0017:  ldarg.2
+    IL_0018:  ldc.i4.1
+    IL_0019:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogParameterStore(uint, int)""
+    IL_001e:  nop
+    // sequence point: int x = 1;
+    IL_001f:  ldloca.s   V_0
+    IL_0021:  ldc.i4.1
+    IL_0022:  dup
+    IL_0023:  stloc.1
+    IL_0024:  ldc.i4.1
+    IL_0025:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_002a:  nop
+    // sequence point: p = x = 2;
+    IL_002b:  ldloca.s   V_0
+    IL_002d:  ldloca.s   V_0
+    IL_002f:  ldc.i4.2
+    IL_0030:  dup
+    IL_0031:  stloc.1
+    IL_0032:  ldc.i4.1
+    IL_0033:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_0038:  nop
+    IL_0039:  ldloc.1
+    IL_003a:  dup
+    IL_003b:  starg.s    V_1
+    IL_003d:  ldc.i4.0
+    IL_003e:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogParameterStore(uint, int)""
+    IL_0043:  nop
+    // sequence point: int i = 0
+    IL_0044:  ldloca.s   V_0
+    IL_0046:  ldc.i4.0
+    IL_0047:  dup
+    IL_0048:  stloc.2
+    IL_0049:  ldc.i4.2
+    IL_004a:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_004f:  nop
+    // sequence point: <hidden>
+    IL_0050:  br.s       IL_007f
+    // sequence point: {
+    IL_0052:  nop
+    // sequence point: q = x += 2;
+    IL_0053:  ldloca.s   V_0
+    IL_0055:  ldloca.s   V_0
+    IL_0057:  ldloc.1
+    IL_0058:  ldc.i4.2
+    IL_0059:  add
+    IL_005a:  dup
+    IL_005b:  stloc.1
+    IL_005c:  ldc.i4.1
+    IL_005d:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_0062:  nop
+    IL_0063:  ldloc.1
+    IL_0064:  dup
+    IL_0065:  starg.s    V_2
+    IL_0067:  ldc.i4.1
+    IL_0068:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogParameterStore(uint, int)""
+    IL_006d:  nop
+    // sequence point: }
+    IL_006e:  nop
+    // sequence point: i++
+    IL_006f:  ldloc.2
+    IL_0070:  stloc.3
+    IL_0071:  ldloca.s   V_0
+    IL_0073:  ldloc.3
+    IL_0074:  ldc.i4.1
+    IL_0075:  add
+    IL_0076:  dup
+    IL_0077:  stloc.2
+    IL_0078:  ldc.i4.2
+    IL_0079:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_007e:  nop
+    // sequence point: i < 10
+    IL_007f:  ldloc.2
+    IL_0080:  ldc.i4.s   10
+    IL_0082:  clt
+    IL_0084:  stloc.s    V_4
+    // sequence point: <hidden>
+    IL_0086:  ldloc.s    V_4
+    IL_0088:  brtrue.s   IL_0052
+    // sequence point: }
+    IL_008a:  leave.s    IL_0095
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_008c:  ldloca.s   V_0
+    IL_008e:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_0093:  nop
+    IL_0094:  endfinally
+  }
+  // sequence point: }
+  IL_0095:  ret
+}
+");
+        }
+
+        [Theory]
+        [InlineData("I", "object")]
+        [InlineData("C", "object")]
+        [InlineData("object", "object")]
+        [InlineData("string", "string")]
+        [InlineData("bool", "bool")]
+        [InlineData("byte", "byte")]
+        [InlineData("ushort", "ushort")]
+        [InlineData("char", "ushort")]
+        [InlineData("int", "uint")]
+        [InlineData("uint", "uint")]
+        [InlineData("long", "ulong")]
+        [InlineData("ulong", "ulong")]
+        [InlineData("void*", "void*", false)]
+        [InlineData("byte*", "void*", false)]
+        [InlineData("delegate*<int>", "void*")]
+        public void SpecialTypes_NoConv(string typeName, string targetType, bool verificationPasses = true)
+        {
+            var source = WithHelpers($$"""
+interface I {}
+
+unsafe class C
+{
+    private static readonly {{typeName}} s;
+
+    public void F({{typeName}} p)
+    {
+        var x = p = s;
+    }
+}
+""");
+            var verifier = CompileAndVerify(source, ilVerifyMessage: verificationPasses ? "" : """
+                [F]: Unmanaged pointers are not a verifiable type. { Offset = 0xd }
+                [F]: Unmanaged pointers are not a verifiable type. { Offset = 0x28 }
+                """);
+
+            verifier.VerifyMethodBody("C.F", $@"
+{{
+  // Code size       62 (0x3e)
+  .maxstack  4
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0,
+                {typeName} V_1) //x
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""void C.F({typeName})""
+  IL_0005:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogMethodEntry(int)""
+  IL_000a:  stloc.0
+  .try
+  {{
+    // sequence point: {{
+    IL_000b:  ldloca.s   V_0
+    IL_000d:  ldarg.1
+    IL_000e:  ldc.i4.0
+    IL_000f:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogParameterStore({targetType}, int)""
+    IL_0014:  nop
+    // sequence point: var x = p = s;
+    IL_0015:  ldloca.s   V_0
+    IL_0017:  ldloca.s   V_0
+    IL_0019:  ldsfld     ""{typeName} C.s""
+    IL_001e:  dup
+    IL_001f:  starg.s    V_1
+    IL_0021:  ldc.i4.0
+    IL_0022:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogParameterStore({targetType}, int)""
+    IL_0027:  nop
+    IL_0028:  ldarg.1
+    IL_0029:  dup
+    IL_002a:  stloc.1
+    IL_002b:  ldc.i4.1
+    IL_002c:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore({targetType}, int)""
+    IL_0031:  nop
+    // sequence point: }}
+    IL_0032:  leave.s    IL_003d
+  }}
+  finally
+  {{
+    // sequence point: <hidden>
+    IL_0034:  ldloca.s   V_0
+    IL_0036:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_003b:  nop
+    IL_003c:  endfinally
+  }}
+  // sequence point: }}
+  IL_003d:  ret
+}}
+");
+        }
+
+        [Theory]
+        [InlineData("sbyte", "byte", "conv.u1")]
+        [InlineData("short", "ushort", "conv.u2")]
+        [InlineData("float", "uint", "conv.u4")]
+        [InlineData("double", "ulong", "conv.u8")]
+        public void SpecialTypes_ConvU(string typeName, string targetType, string conversion)
+        {
+            var source = WithHelpers($$"""
+class C
+{
+    private static readonly {{typeName}} s;
+
+    public void F({{typeName}} p)
+    {
+        var x = p = s;
+    }
+}
+""");
+            var verifier = CompileAndVerify(source);
+
+            verifier.VerifyMethodBody("C.F", $@"
+{{
+  // Code size       65 (0x41)
+  .maxstack  4
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0,
+                {typeName} V_1) //x
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""void C.F({typeName})""
+  IL_0005:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogMethodEntry(int)""
+  IL_000a:  stloc.0
+  .try
+  {{
+    // sequence point: {{
+    IL_000b:  ldloca.s   V_0
+    IL_000d:  ldarg.1
+    IL_000e:  {conversion}
+    IL_000f:  ldc.i4.0
+    IL_0010:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogParameterStore({targetType}, int)""
+    IL_0015:  nop
+    // sequence point: var x = p = s;
+    IL_0016:  ldloca.s   V_0
+    IL_0018:  ldloca.s   V_0
+    IL_001a:  ldsfld     ""{typeName} C.s""
+    IL_001f:  dup
+    IL_0020:  starg.s    V_1
+    IL_0022:  {conversion}
+    IL_0023:  ldc.i4.0
+    IL_0024:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogParameterStore({targetType}, int)""
+    IL_0029:  nop
+    IL_002a:  ldarg.1
+    IL_002b:  dup
+    IL_002c:  stloc.1
+    IL_002d:  {conversion}
+    IL_002e:  ldc.i4.1
+    IL_002f:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore({targetType}, int)""
+    IL_0034:  nop
+    // sequence point: }}
+    IL_0035:  leave.s    IL_0040
+  }}
+  finally
+  {{
+    // sequence point: <hidden>
+    IL_0037:  ldloca.s   V_0
+    IL_0039:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_003e:  nop
+    IL_003f:  endfinally
+  }}
+  // sequence point: }}
+  IL_0040:  ret
+}}
+");
+        }
+
+        [Theory]
+        [InlineData("byte", "byte")]
+        [InlineData("ushort", "ushort")]
+        [InlineData("int", "uint")]
+        [InlineData("uint", "uint")]
+        [InlineData("long", "ulong")]
+        [InlineData("ulong", "ulong")]
+        public void Enums_NoConv(string typeName, string targetType)
+        {
+            var source = WithHelpers($$"""
+enum E : {{typeName}}
+{
+}
+
+class C
+{
+    private static readonly E s;
+
+    public void F(E p)
+    {
+        var x = p = s;
+    }
+}
+""");
+            var verifier = CompileAndVerify(source);
+
+            verifier.VerifyMethodBody("C.F", $@"
+{{
+  // Code size       62 (0x3e)
+  .maxstack  4
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0,
+                E V_1) //x
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""void C.F(E)""
+  IL_0005:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogMethodEntry(int)""
+  IL_000a:  stloc.0
+  .try
+  {{
+    // sequence point: {{
+    IL_000b:  ldloca.s   V_0
+    IL_000d:  ldarg.1
+    IL_000e:  ldc.i4.0
+    IL_000f:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogParameterStore({targetType}, int)""
+    IL_0014:  nop
+    // sequence point: var x = p = s;
+    IL_0015:  ldloca.s   V_0
+    IL_0017:  ldloca.s   V_0
+    IL_0019:  ldsfld     ""E C.s""
+    IL_001e:  dup
+    IL_001f:  starg.s    V_1
+    IL_0021:  ldc.i4.0
+    IL_0022:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogParameterStore({targetType}, int)""
+    IL_0027:  nop
+    IL_0028:  ldarg.1
+    IL_0029:  dup
+    IL_002a:  stloc.1
+    IL_002b:  ldc.i4.1
+    IL_002c:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore({targetType}, int)""
+    IL_0031:  nop
+    // sequence point: }}
+    IL_0032:  leave.s    IL_003d
+  }}
+  finally
+  {{
+    // sequence point: <hidden>
+    IL_0034:  ldloca.s   V_0
+    IL_0036:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_003b:  nop
+    IL_003c:  endfinally
+  }}
+  // sequence point: }}
+  IL_003d:  ret
+}}
+");
+        }
+
+        [Theory]
+        [InlineData("sbyte", "byte", "conv.u1")]
+        [InlineData("short", "ushort", "conv.u2")]
+        public void Enums_ConvU(string typeName, string targetType, string conversion)
+        {
+            var source = WithHelpers($$"""
+enum E : {{typeName}}
+{
+}
+
+class C
+{
+    private static readonly E s;
+
+    public void F(E p)
+    {
+        var x = p = s;
+    }
+}
+""");
+            var verifier = CompileAndVerify(source);
+
+            verifier.VerifyMethodBody("C.F", $@"
+{{
+  // Code size       65 (0x41)
+  .maxstack  4
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0,
+                E V_1) //x
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""void C.F(E)""
+  IL_0005:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogMethodEntry(int)""
+  IL_000a:  stloc.0
+  .try
+  {{
+    // sequence point: {{
+    IL_000b:  ldloca.s   V_0
+    IL_000d:  ldarg.1
+    IL_000e:  {conversion}
+    IL_000f:  ldc.i4.0
+    IL_0010:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogParameterStore({targetType}, int)""
+    IL_0015:  nop
+    // sequence point: var x = p = s;
+    IL_0016:  ldloca.s   V_0
+    IL_0018:  ldloca.s   V_0
+    IL_001a:  ldsfld     ""E C.s""
+    IL_001f:  dup
+    IL_0020:  starg.s    V_1
+    IL_0022:  {conversion}
+    IL_0023:  ldc.i4.0
+    IL_0024:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogParameterStore({targetType}, int)""
+    IL_0029:  nop
+    IL_002a:  ldarg.1
+    IL_002b:  dup
+    IL_002c:  stloc.1
+    IL_002d:  {conversion}
+    IL_002e:  ldc.i4.1
+    IL_002f:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore({targetType}, int)""
+    IL_0034:  nop
+    // sequence point: }}
+    IL_0035:  leave.s    IL_0040
+  }}
+  finally
+  {{
+    // sequence point: <hidden>
+    IL_0037:  ldloca.s   V_0
+    IL_0039:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_003e:  nop
+    IL_003f:  endfinally
+  }}
+  // sequence point: }}
+  IL_0040:  ret
+}}
+");
+        }
+
+        [Theory]
+        [InlineData("", "decimal")]
+        [InlineData("", "nint")]
+        [InlineData("", "nuint")]
+        [InlineData("", "System.DateTime")]
+        [InlineData("", "System.Guid")]
+        [InlineData("", "System.ValueTuple<int, bool>")]
+        [InlineData("struct S { }", "S")]
+        [InlineData("struct S<T> where T : struct { T t; }", "S<int>")]
+        [InlineData("struct S { System.DateTime X; System.Guid Y; decimal Z; unsafe void* P; }", "S")]
+        [InlineData("", "System.ValueTuple<int?, bool?>")]
+        [InlineData("", "int?")]
+        public void UnmanagedStruct(string definition, string typeName)
+        {
+            var source = WithHelpers(definition + $$"""
+class C
+{
+    static readonly {{typeName}} s;
+
+    static void F({{typeName}} p)
+    {
+        var x = p = s;
+    }
+}
+""");
+
+            var verifier = CompileAndVerify(source);
+
+            verifier.VerifyMethodBody("C.F", $@"
+{{
+  // Code size       65 (0x41)
+  .maxstack  4
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0,
+                {typeName} V_1) //x
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""void C.F({typeName})""
+  IL_0005:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogMethodEntry(int)""
+  IL_000a:  stloc.0
+  .try
+  {{
+    // sequence point: {{
+    IL_000b:  ldloca.s   V_0
+    IL_000d:  ldarga.s   V_0
+    IL_000f:  ldc.i4.0
+    IL_0010:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogParameterStoreUnmanaged<{typeName}>(ref {typeName}, int)""
+    IL_0015:  nop
+    // sequence point: var x = p = s;
+    IL_0016:  ldloca.s   V_0
+    IL_0018:  ldloca.s   V_0
+    IL_001a:  ldsfld     ""{typeName} C.s""
+    IL_001f:  starg.s    V_0
+    IL_0021:  ldarga.s   V_0
+    IL_0023:  ldc.i4.0
+    IL_0024:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogParameterStoreUnmanaged<{typeName}>(ref {typeName}, int)""
+    IL_0029:  nop
+    IL_002a:  ldarg.0
+    IL_002b:  stloc.1
+    IL_002c:  ldloca.s   V_1
+    IL_002e:  ldc.i4.1
+    IL_002f:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStoreUnmanaged<{typeName}>(ref {typeName}, int)""
+    IL_0034:  nop
+    // sequence point: }}
+    IL_0035:  leave.s    IL_0040
+  }}
+  finally
+  {{
+    // sequence point: <hidden>
+    IL_0037:  ldloca.s   V_0
+    IL_0039:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_003e:  nop
+    IL_003f:  endfinally
+  }}
+  // sequence point: }}
+  IL_0040:  ret
+}}
+");
+        }
+
+        [Theory]
+        [InlineData("", "System.ValueTuple<int, string>")]
+        [InlineData("struct S { string A; }", "S")]
+        [InlineData("struct S { string A; }", "S?")]
+        public void ManagedStruct(string definition, string typeName)
+        {
+            var source = WithHelpers(definition + $$"""
+class C
+{
+    private static readonly {{typeName}} s;
+
+    public void F({{typeName}} p)
+    {
+        var x = p = s;
+    }
+}
+""");
+            var verifier = CompileAndVerify(source);
+
+            // TODO: why is the stloc+ldloc.a of V_2 emitted?
+            // IL_0045: stloc.2
+            // IL_0046: ldloca.s V_2
+
+            verifier.VerifyMethodBody("C.F", $@"
+{{
+  // Code size      102 (0x66)
+  .maxstack  4
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0,
+                {typeName} V_1, //x
+                {typeName} V_2)
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""void C.F({typeName})""
+  IL_0005:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogMethodEntry(int)""
+  IL_000a:  stloc.0
+  .try
+  {{
+    // sequence point: {{
+    IL_000b:  ldloca.s   V_0
+    IL_000d:  ldarga.s   V_1
+    IL_000f:  constrained. ""{typeName}""
+    IL_0015:  callvirt   ""string object.ToString()""
+    IL_001a:  ldc.i4.0
+    IL_001b:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogParameterStore(string, int)""
+    IL_0020:  nop
+    // sequence point: var x = p = s;
+    IL_0021:  ldloca.s   V_0
+    IL_0023:  ldloca.s   V_0
+    IL_0025:  ldsfld     ""{typeName} C.s""
+    IL_002a:  dup
+    IL_002b:  starg.s    V_1
+    IL_002d:  stloc.2
+    IL_002e:  ldloca.s   V_2
+    IL_0030:  constrained. ""{typeName}""
+    IL_0036:  callvirt   ""string object.ToString()""
+    IL_003b:  ldc.i4.0
+    IL_003c:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogParameterStore(string, int)""
+    IL_0041:  nop
+    IL_0042:  ldarg.1
+    IL_0043:  dup
+    IL_0044:  stloc.1
+    IL_0045:  stloc.2
+    IL_0046:  ldloca.s   V_2
+    IL_0048:  constrained. ""{typeName}""
+    IL_004e:  callvirt   ""string object.ToString()""
+    IL_0053:  ldc.i4.1
+    IL_0054:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(string, int)""
+    IL_0059:  nop
+    // sequence point: }}
+    IL_005a:  leave.s    IL_0065
+  }}
+  finally
+  {{
+    // sequence point: <hidden>
+    IL_005c:  ldloca.s   V_0
+    IL_005e:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_0063:  nop
+    IL_0064:  endfinally
+  }}
+  // sequence point: }}
+  IL_0065:  ret
+}}
+");
+        }
+
+        [Fact]
+        public void RefStructWithRefField()
+        {
+            var source = WithHelpers($$"""
+ref struct S { ref int X; }
+
+class C
+{
+    public void F(S p)
+    {
+        var x = p = new S();
+    }
+}
+""");
+            var verifier = CompileAndVerify(source);
+
+            verifier.VerifyMethodBody("C.F", @"
+ {
+  // Code size      103 (0x67)
+  .maxstack  4
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0,
+                S V_1, //x
+                S V_2)
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""void C.F(S)""
+  IL_0005:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogMethodEntry(int)""
+  IL_000a:  stloc.0
+  .try
+  {
+    // sequence point: {
+    IL_000b:  ldloca.s   V_0
+    IL_000d:  ldarga.s   V_1
+    IL_000f:  constrained. ""S""
+    IL_0015:  callvirt   ""string object.ToString()""
+    IL_001a:  ldc.i4.0
+    IL_001b:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogParameterStore(string, int)""
+    IL_0020:  nop
+    // sequence point: var x = p = new S();
+    IL_0021:  ldloca.s   V_0
+    IL_0023:  ldloca.s   V_0
+    IL_0025:  ldarga.s   V_1
+    IL_0027:  initobj    ""S""
+    IL_002d:  ldarg.1
+    IL_002e:  stloc.2
+    IL_002f:  ldloca.s   V_2
+    IL_0031:  constrained. ""S""
+    IL_0037:  callvirt   ""string object.ToString()""
+    IL_003c:  ldc.i4.0
+    IL_003d:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogParameterStore(string, int)""
+    IL_0042:  nop
+    IL_0043:  ldarg.1
+    IL_0044:  dup
+    IL_0045:  stloc.1
+    IL_0046:  stloc.2
+    IL_0047:  ldloca.s   V_2
+    IL_0049:  constrained. ""S""
+    IL_004f:  callvirt   ""string object.ToString()""
+    IL_0054:  ldc.i4.1
+    IL_0055:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(string, int)""
+    IL_005a:  nop
+    // sequence point: }
+    IL_005b:  leave.s    IL_0066
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_005d:  ldloca.s   V_0
+    IL_005f:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_0064:  nop
+    IL_0065:  endfinally
+  }
+  // sequence point: }
+  IL_0066:  ret
+}");
+        }
+
+        [Fact]
+        public void UnmanagedRefStruct()
+        {
+            var source = WithHelpers($$"""
+ref struct S { int X; }
+
+class C
+{
+    public void F(S p)
+    {
+        var x = p = new S();
+    }
+}
+""");
+            var verifier = CompileAndVerify(source);
+
+            verifier.VerifyMethodBody("C.F", $@"
+{{
+  // Code size       66 (0x42)
+  .maxstack  4
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0,
+                S V_1) //x
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""void C.F(S)""
+  IL_0005:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogMethodEntry(int)""
+  IL_000a:  stloc.0
+  .try
+  {{
+    // sequence point: {{
+    IL_000b:  ldloca.s   V_0
+    IL_000d:  ldarga.s   V_1
+    IL_000f:  ldc.i4.0
+    IL_0010:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogParameterStoreUnmanaged<S>(ref S, int)""
+    IL_0015:  nop
+    // sequence point: var x = p = new S();
+    IL_0016:  ldloca.s   V_0
+    IL_0018:  ldloca.s   V_0
+    IL_001a:  ldarga.s   V_1
+    IL_001c:  initobj    ""S""
+    IL_0022:  ldarga.s   V_1
+    IL_0024:  ldc.i4.0
+    IL_0025:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogParameterStoreUnmanaged<S>(ref S, int)""
+    IL_002a:  nop
+    IL_002b:  ldarg.1
+    IL_002c:  stloc.1
+    IL_002d:  ldloca.s   V_1
+    IL_002f:  ldc.i4.1
+    IL_0030:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStoreUnmanaged<S>(ref S, int)""
+    IL_0035:  nop
+    // sequence point: }}
+    IL_0036:  leave.s    IL_0041
+  }}
+  finally
+  {{
+    // sequence point: <hidden>
+    IL_0038:  ldloca.s   V_0
+    IL_003a:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_003f:  nop
+    IL_0040:  endfinally
+  }}
+  // sequence point: }}
+  IL_0041:  ret
+}}");
+        }
+
+        [Fact]
+        public void Dynamic()
+        {
+            var source = WithHelpers(@"
+class C
+{
+    static void Main()
+    {
+        dynamic x = 1;
+        x++;
+    }
+}
+");
+            var verifier = CompileAndVerify(source, expectedOutput: @"
+Main: Entered
+Main: L1 = 1
+Main: L1 = 2
+Main: Returned
+");
+
+            verifier.VerifyMethodBody("C.Main", @"
+{
+  // Code size      128 (0x80)
+  .maxstack  9
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0,
+                object V_1, //x
+                object V_2)
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""void C.Main()""
+  IL_0005:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogMethodEntry(int)""
+  IL_000a:  stloc.0
+  .try
+  {
+    // sequence point: {
+    IL_000b:  nop
+    // sequence point: dynamic x = 1;
+    IL_000c:  ldloca.s   V_0
+    IL_000e:  ldc.i4.1
+    IL_000f:  box        ""int""
+    IL_0014:  dup
+    IL_0015:  stloc.1
+    IL_0016:  ldc.i4.1
+    IL_0017:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(object, int)""
+    IL_001c:  nop
+    // sequence point: x++;
+    IL_001d:  ldloc.1
+    IL_001e:  stloc.2
+    IL_001f:  ldloca.s   V_0
+    IL_0021:  ldsfld     ""System.Runtime.CompilerServices.CallSite<System.Func<System.Runtime.CompilerServices.CallSite, dynamic, dynamic>> C.<>o__0.<>p__0""
+    IL_0026:  brfalse.s  IL_002a
+    IL_0028:  br.s       IL_0056
+    IL_002a:  ldc.i4.0
+    IL_002b:  ldc.i4.s   54
+    IL_002d:  ldtoken    ""C""
+    IL_0032:  call       ""System.Type System.Type.GetTypeFromHandle(System.RuntimeTypeHandle)""
+    IL_0037:  ldc.i4.1
+    IL_0038:  newarr     ""Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfo""
+    IL_003d:  dup
+    IL_003e:  ldc.i4.0
+    IL_003f:  ldc.i4.0
+    IL_0040:  ldnull
+    IL_0041:  call       ""Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfo Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfo.Create(Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfoFlags, string)""
+    IL_0046:  stelem.ref
+    IL_0047:  call       ""System.Runtime.CompilerServices.CallSiteBinder Microsoft.CSharp.RuntimeBinder.Binder.UnaryOperation(Microsoft.CSharp.RuntimeBinder.CSharpBinderFlags, System.Linq.Expressions.ExpressionType, System.Type, System.Collections.Generic.IEnumerable<Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfo>)""
+    IL_004c:  call       ""System.Runtime.CompilerServices.CallSite<System.Func<System.Runtime.CompilerServices.CallSite, dynamic, dynamic>> System.Runtime.CompilerServices.CallSite<System.Func<System.Runtime.CompilerServices.CallSite, dynamic, dynamic>>.Create(System.Runtime.CompilerServices.CallSiteBinder)""
+    IL_0051:  stsfld     ""System.Runtime.CompilerServices.CallSite<System.Func<System.Runtime.CompilerServices.CallSite, dynamic, dynamic>> C.<>o__0.<>p__0""
+    IL_0056:  ldsfld     ""System.Runtime.CompilerServices.CallSite<System.Func<System.Runtime.CompilerServices.CallSite, dynamic, dynamic>> C.<>o__0.<>p__0""
+    IL_005b:  ldfld      ""System.Func<System.Runtime.CompilerServices.CallSite, dynamic, dynamic> System.Runtime.CompilerServices.CallSite<System.Func<System.Runtime.CompilerServices.CallSite, dynamic, dynamic>>.Target""
+    IL_0060:  ldsfld     ""System.Runtime.CompilerServices.CallSite<System.Func<System.Runtime.CompilerServices.CallSite, dynamic, dynamic>> C.<>o__0.<>p__0""
+    IL_0065:  ldloc.2
+    IL_0066:  callvirt   ""dynamic System.Func<System.Runtime.CompilerServices.CallSite, dynamic, dynamic>.Invoke(System.Runtime.CompilerServices.CallSite, dynamic)""
+    IL_006b:  dup
+    IL_006c:  stloc.1
+    IL_006d:  ldc.i4.1
+    IL_006e:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(object, int)""
+    IL_0073:  nop
+    // sequence point: }
+    IL_0074:  leave.s    IL_007f
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_0076:  ldloca.s   V_0
+    IL_0078:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_007d:  nop
+    IL_007e:  endfinally
+  }
+  // sequence point: }
+  IL_007f:  ret
+}
+");
+        }
+
+        [Fact]
+        public void ThisAssignment_NotInstrumented()
+        {
+            var source = WithHelpers($$"""
+struct S
+{
+    void F()
+    {
+        this = new S();
+    }
+}
+""");
+            var verifier = CompileAndVerify(source);
+
+            verifier.VerifyMethodBody("S.F", @"
+{
+  // Code size       31 (0x1f)
+  .maxstack  1
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0)
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""void S.F()""
+  IL_0005:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogMethodEntry(int)""
+  IL_000a:  stloc.0
+  .try
+  {
+    // sequence point: {
+    IL_000b:  nop
+    // sequence point: this = new S();
+    IL_000c:  ldarg.0
+    IL_000d:  initobj    ""S""
+    // sequence point: }
+    IL_0013:  leave.s    IL_001e
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_0015:  ldloca.s   V_0
+    IL_0017:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_001c:  nop
+    IL_001d:  endfinally
+  }
+  // sequence point: }
+  IL_001e:  ret
+}
+");
+        }
+
+        [Fact]
+        public void RefAssignments()
+        {
+            var source = WithHelpers(@"
+class C
+{
+    static void G(int p1, ref int p2, out int p3, ref int p4)
+    {
+        int a = 1;
+        int b = 2;
+
+        p3 = 3;
+        p4 = ref p2;
+        
+        ref int r1 = ref a;
+        ref int r2 = ref p1;
+        ref int r3 = ref p2;
+        ref int r4 = ref p3;
+        ref int r5 = ref r1;
+
+        if (F(ref r1, ref r2, ref r3, ref r4, out r5))
+        {
+            r1 = r2;
+        }
+    }
+
+    static bool F(ref int a1, ref int a2, ref int a3, ref int a4, out int a5)
+    {
+        a5 = 0;
+        return true;
+    }
+
+    static void Main()
+    {
+        int a = 1;
+        G(1, ref a, out var b, ref a);
+    }
+}
+");
+            var verifier = CompileAndVerify(source, expectedOutput: @"
+Main: Entered
+Main: L1 = 1
+G: Entered
+G: P'p1'[0] = 1
+G: P'p2'[1] = 1
+G: P'p4'[3] = 1
+G: L1 = 1
+G: L2 = 2
+G: P'p3'[2] = 3
+G: P'p4'[3] -> P'p2'[1]
+G: L3 -> L1
+G: L4 -> P'p1'[0]
+G: L5 -> P'p2'[1]
+G: L6 -> P'p3'[2]
+G: L7 -> L3
+F: Entered
+F: P'a1'[0] = 1
+F: P'a2'[1] = 1
+F: P'a3'[2] = 1
+F: P'a4'[3] = 3
+F: P'a5'[4] = 0
+F: Returned
+G: L3 = 0
+G: L4 = 1
+G: L5 = 1
+G: L6 = 3
+G: L7 = 0
+G: L3 = 1
+G: Returned
+Main: L1 = 1
+Main: L2 = 3
+Main: L1 = 1
+Main: Returned
+");
+
+            // TODO: eliminate
+            // IL_007b:  ldloc.2
+            // IL_007c:  ldind.i4
+            // IL_007d:  pop
+
+            verifier.VerifyMethodBody("C.G", @"
+ {
+  // Code size      297 (0x129)
+  .maxstack  5
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0,
+                int V_1, //a
+                int V_2, //b
+                int& V_3, //r1
+                int& V_4, //r2
+                int& V_5, //r3
+                int& V_6, //r4
+                int& V_7, //r5
+                int V_8,
+                bool V_9)
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""void C.G(int, ref int, out int, ref int)""
+  IL_0005:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogMethodEntry(int)""
+  IL_000a:  stloc.0
+  .try
+  {
+    // sequence point: {
+    IL_000b:  ldloca.s   V_0
+    IL_000d:  ldarg.0
+    IL_000e:  ldc.i4.0
+    IL_000f:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogParameterStore(uint, int)""
+    IL_0014:  nop
+    IL_0015:  ldloca.s   V_0
+    IL_0017:  ldarg.1
+    IL_0018:  ldind.i4
+    IL_0019:  ldc.i4.1
+    IL_001a:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogParameterStore(uint, int)""
+    IL_001f:  nop
+    IL_0020:  ldloca.s   V_0
+    IL_0022:  ldarg.3
+    IL_0023:  ldind.i4
+    IL_0024:  ldc.i4.3
+    IL_0025:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogParameterStore(uint, int)""
+    IL_002a:  nop
+    // sequence point: int a = 1;
+    IL_002b:  ldloca.s   V_0
+    IL_002d:  ldc.i4.1
+    IL_002e:  dup
+    IL_002f:  stloc.1
+    IL_0030:  ldc.i4.1
+    IL_0031:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_0036:  nop
+    // sequence point: int b = 2;
+    IL_0037:  ldloca.s   V_0
+    IL_0039:  ldc.i4.2
+    IL_003a:  dup
+    IL_003b:  stloc.2
+    IL_003c:  ldc.i4.2
+    IL_003d:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_0042:  nop
+    // sequence point: p3 = 3;
+    IL_0043:  ldloca.s   V_0
+    IL_0045:  ldarg.2
+    IL_0046:  ldc.i4.3
+    IL_0047:  dup
+    IL_0048:  stloc.s    V_8
+    IL_004a:  stind.i4
+    IL_004b:  ldloc.s    V_8
+    IL_004d:  ldc.i4.2
+    IL_004e:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogParameterStore(uint, int)""
+    IL_0053:  nop
+    // sequence point: p4 = ref p2;
+    IL_0054:  ldloca.s   V_0
+    IL_0056:  ldarg.1
+    IL_0057:  starg.s    V_3
+    IL_0059:  ldc.i4.1
+    IL_005a:  ldc.i4.3
+    IL_005b:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogParameterStoreParameterAlias(int, int)""
+    IL_0060:  nop
+    // sequence point: ref int r1 = ref a;
+    IL_0061:  ldloca.s   V_0
+    IL_0063:  ldloca.s   V_1
+    IL_0065:  stloc.3
+    IL_0066:  ldc.i4.1
+    IL_0067:  ldc.i4.3
+    IL_0068:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStoreLocalAlias(int, int)""
+    IL_006d:  nop
+    IL_006e:  ldloc.3
+    IL_006f:  ldind.i4
+    IL_0070:  pop
+    // sequence point: ref int r2 = ref p1;
+    IL_0071:  ldloca.s   V_0
+    IL_0073:  ldarga.s   V_0
+    IL_0075:  stloc.s    V_4
+    IL_0077:  ldc.i4.0
+    IL_0078:  ldc.i4.4
+    IL_0079:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStoreParameterAlias(int, int)""
+    IL_007e:  nop
+    IL_007f:  ldloc.s    V_4
+    IL_0081:  ldind.i4
+    IL_0082:  pop
+    // sequence point: ref int r3 = ref p2;
+    IL_0083:  ldloca.s   V_0
+    IL_0085:  ldarg.1
+    IL_0086:  stloc.s    V_5
+    IL_0088:  ldc.i4.1
+    IL_0089:  ldc.i4.5
+    IL_008a:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStoreParameterAlias(int, int)""
+    IL_008f:  nop
+    IL_0090:  ldloc.s    V_5
+    IL_0092:  ldind.i4
+    IL_0093:  pop
+    // sequence point: ref int r4 = ref p3;
+    IL_0094:  ldloca.s   V_0
+    IL_0096:  ldarg.2
+    IL_0097:  stloc.s    V_6
+    IL_0099:  ldc.i4.2
+    IL_009a:  ldc.i4.6
+    IL_009b:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStoreParameterAlias(int, int)""
+    IL_00a0:  nop
+    IL_00a1:  ldloc.s    V_6
+    IL_00a3:  ldind.i4
+    IL_00a4:  pop
+    // sequence point: ref int r5 = ref r1;
+    IL_00a5:  ldloca.s   V_0
+    IL_00a7:  ldloc.3
+    IL_00a8:  stloc.s    V_7
+    IL_00aa:  ldc.i4.3
+    IL_00ab:  ldc.i4.7
+    IL_00ac:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStoreLocalAlias(int, int)""
+    IL_00b1:  nop
+    IL_00b2:  ldloc.s    V_7
+    IL_00b4:  ldind.i4
+    IL_00b5:  pop
+    // sequence point: if (F(ref r1, ref r2, ref r3, ref r4, out r5))
+    IL_00b6:  ldloc.3
+    IL_00b7:  ldloc.s    V_4
+    IL_00b9:  ldloc.s    V_5
+    IL_00bb:  ldloc.s    V_6
+    IL_00bd:  ldloc.s    V_7
+    IL_00bf:  call       ""bool C.F(ref int, ref int, ref int, ref int, out int)""
+    IL_00c4:  ldloca.s   V_0
+    IL_00c6:  ldloc.3
+    IL_00c7:  ldind.i4
+    IL_00c8:  ldc.i4.3
+    IL_00c9:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_00ce:  nop
+    IL_00cf:  ldloca.s   V_0
+    IL_00d1:  ldloc.s    V_4
+    IL_00d3:  ldind.i4
+    IL_00d4:  ldc.i4.4
+    IL_00d5:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_00da:  nop
+    IL_00db:  ldloca.s   V_0
+    IL_00dd:  ldloc.s    V_5
+    IL_00df:  ldind.i4
+    IL_00e0:  ldc.i4.5
+    IL_00e1:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_00e6:  nop
+    IL_00e7:  ldloca.s   V_0
+    IL_00e9:  ldloc.s    V_6
+    IL_00eb:  ldind.i4
+    IL_00ec:  ldc.i4.6
+    IL_00ed:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_00f2:  nop
+    IL_00f3:  ldloca.s   V_0
+    IL_00f5:  ldloc.s    V_7
+    IL_00f7:  ldind.i4
+    IL_00f8:  ldc.i4.7
+    IL_00f9:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_00fe:  nop
+    IL_00ff:  stloc.s    V_9
+    // sequence point: <hidden>
+    IL_0101:  ldloc.s    V_9
+    IL_0103:  brfalse.s  IL_011d
+    // sequence point: {
+    IL_0105:  nop
+    // sequence point: r1 = r2;
+    IL_0106:  ldloca.s   V_0
+    IL_0108:  ldloc.3
+    IL_0109:  ldloc.s    V_4
+    IL_010b:  ldind.i4
+    IL_010c:  dup
+    IL_010d:  stloc.s    V_8
+    IL_010f:  stind.i4
+    IL_0110:  ldloc.s    V_8
+    IL_0112:  ldc.i4.3
+    IL_0113:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_0118:  nop
+    IL_0119:  ldloc.3
+    IL_011a:  ldind.i4
+    IL_011b:  pop
+    // sequence point: }
+    IL_011c:  nop
+    // sequence point: }
+    IL_011d:  leave.s    IL_0128
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_011f:  ldloca.s   V_0
+    IL_0121:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_0126:  nop
+    IL_0127:  endfinally
+  }
+  // sequence point: }
+  IL_0128:  ret
+}");
+        }
+
+        /// <summary>
+        /// We don't currently track local aliases to ref fields.
+        /// </summary>
+        [Fact]
+        public void RefAssignments_RefFields_NotInstrumented()
+        {
+            var source = WithHelpers(@"
+ref struct S
+{
+    public ref int X;
+    public ref int Y;
+}
+
+class C
+{
+    public void F()
+    {
+        int a = 1;
+        scoped var s = new S();
+
+        s.X = ref a;                // ignored
+        s.X = 2;                    // not recognized as update of a
+
+        ref int x = ref s.X;        // ignored
+        x = 3;                      // not recognized as update of a
+
+        s.Y = ref s.X;              // ignored
+        s.Y = 4;                    // not recognized as update of a
+    }
+}
+");
+            var verifier = CompileAndVerify(source);
+
+            verifier.VerifyMethodBody("C.F", @"
+{
+  // Code size      136 (0x88)
+  .maxstack  4
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0,
+                int V_1, //a
+                S V_2, //s
+                int& V_3, //x
+                S V_4,
+                int V_5)
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""void C.F()""
+  IL_0005:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogMethodEntry(int)""
+  IL_000a:  stloc.0
+  .try
+  {
+    // sequence point: {
+    IL_000b:  nop
+    // sequence point: int a = 1;
+    IL_000c:  ldloca.s   V_0
+    IL_000e:  ldc.i4.1
+    IL_000f:  dup
+    IL_0010:  stloc.1
+    IL_0011:  ldc.i4.1
+    IL_0012:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_0017:  nop
+    // sequence point: scoped var s = new S();
+    IL_0018:  ldloca.s   V_0
+    IL_001a:  ldloca.s   V_2
+    IL_001c:  initobj    ""S""
+    IL_0022:  ldloc.2
+    IL_0023:  stloc.s    V_4
+    IL_0025:  ldloca.s   V_4
+    IL_0027:  constrained. ""S""
+    IL_002d:  callvirt   ""string object.ToString()""
+    IL_0032:  ldc.i4.2
+    IL_0033:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(string, int)""
+    IL_0038:  nop
+    // sequence point: s.X = ref a;
+    IL_0039:  ldloca.s   V_2
+    IL_003b:  ldloca.s   V_1
+    IL_003d:  stfld      ""ref int S.X""
+    // sequence point: s.X = 2;
+    IL_0042:  ldloc.2
+    IL_0043:  ldfld      ""ref int S.X""
+    IL_0048:  ldc.i4.2
+    IL_0049:  stind.i4
+    // sequence point: ref int x = ref s.X;
+    IL_004a:  ldloca.s   V_2
+    IL_004c:  ldfld      ""ref int S.X""
+    IL_0051:  stloc.3
+    // sequence point: x = 3;
+    IL_0052:  ldloca.s   V_0
+    IL_0054:  ldloc.3
+    IL_0055:  ldc.i4.3
+    IL_0056:  dup
+    IL_0057:  stloc.s    V_5
+    IL_0059:  stind.i4
+    IL_005a:  ldloc.s    V_5
+    IL_005c:  ldc.i4.3
+    IL_005d:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_0062:  nop
+    IL_0063:  ldloc.3
+    IL_0064:  ldind.i4
+    IL_0065:  pop
+    // sequence point: s.Y = ref s.X;
+    IL_0066:  ldloca.s   V_2
+    IL_0068:  ldloca.s   V_2
+    IL_006a:  ldfld      ""ref int S.X""
+    IL_006f:  stfld      ""ref int S.Y""
+    // sequence point: s.Y = 4;
+    IL_0074:  ldloc.2
+    IL_0075:  ldfld      ""ref int S.Y""
+    IL_007a:  ldc.i4.4
+    IL_007b:  stind.i4
+    // sequence point: }
+    IL_007c:  leave.s    IL_0087
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_007e:  ldloca.s   V_0
+    IL_0080:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_0085:  nop
+    IL_0086:  endfinally
+  }
+  // sequence point: }
+  IL_0087:  ret
+}
+");
+        }
+
+        [Fact]
+        public void RefArguments_Call()
+        {
+            var source = WithHelpers(@"
+class C
+{
+    public int G(ref int x, ref long y) => 1;
+    
+    public void F()
+    {
+        int a = 1;
+        long b = 2;
+        int c = G(y: ref b, x: ref a) + 1;
+    }
+}
+");
+            var verifier = CompileAndVerify(source);
+
+            verifier.VerifyMethodBody("C.F", @"
+{
+  // Code size       92 (0x5c)
+  .maxstack  5
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0,
+                int V_1, //a
+                long V_2, //b
+                int V_3) //c
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""void C.F()""
+  IL_0005:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogMethodEntry(int)""
+  IL_000a:  stloc.0
+  .try
+  {
+    // sequence point: {
+    IL_000b:  nop
+    // sequence point: int a = 1;
+    IL_000c:  ldloca.s   V_0
+    IL_000e:  ldc.i4.1
+    IL_000f:  dup
+    IL_0010:  stloc.1
+    IL_0011:  ldc.i4.1
+    IL_0012:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_0017:  nop
+    // sequence point: long b = 2;
+    IL_0018:  ldloca.s   V_0
+    IL_001a:  ldc.i4.2
+    IL_001b:  conv.i8
+    IL_001c:  dup
+    IL_001d:  stloc.2
+    IL_001e:  ldc.i4.2
+    IL_001f:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(ulong, int)""
+    IL_0024:  nop
+    // sequence point: int c = G(y: ref b, x: ref a) + 1;
+    IL_0025:  ldloca.s   V_0
+    IL_0027:  ldarg.0
+    IL_0028:  ldloca.s   V_1
+    IL_002a:  ldloca.s   V_2
+    IL_002c:  call       ""int C.G(ref int, ref long)""
+    IL_0031:  ldloca.s   V_0
+    IL_0033:  ldloc.2
+    IL_0034:  ldc.i4.2
+    IL_0035:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(ulong, int)""
+    IL_003a:  nop
+    IL_003b:  ldloca.s   V_0
+    IL_003d:  ldloc.1
+    IL_003e:  ldc.i4.1
+    IL_003f:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_0044:  nop
+    IL_0045:  ldc.i4.1
+    IL_0046:  add
+    IL_0047:  dup
+    IL_0048:  stloc.3
+    IL_0049:  ldc.i4.3
+    IL_004a:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_004f:  nop
+    // sequence point: }
+    IL_0050:  leave.s    IL_005b
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_0052:  ldloca.s   V_0
+    IL_0054:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_0059:  nop
+    IL_005a:  endfinally
+  }
+  // sequence point: }
+  IL_005b:  ret
+}
+");
+        }
+
+        [Fact]
+        public void RefArguments_Call_Void()
+        {
+            var source = WithHelpers(@"
+class C
+{
+    public void G(ref int x, ref long y)
+    {        
+    }
+    
+    public void F()
+    {
+        int a = 1;
+        long b = 2;
+        G(y: ref b, x: ref a);
+    }
+}
+");
+            var verifier = CompileAndVerify(source);
+
+            verifier.VerifyMethodBody("C.F", @"
+{
+  // Code size       80 (0x50)
+  .maxstack  3
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0,
+                int V_1, //a
+                long V_2) //b
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""void C.F()""
+  IL_0005:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogMethodEntry(int)""
+  IL_000a:  stloc.0
+  .try
+  {
+    // sequence point: {
+    IL_000b:  nop
+    // sequence point: int a = 1;
+    IL_000c:  ldloca.s   V_0
+    IL_000e:  ldc.i4.1
+    IL_000f:  dup
+    IL_0010:  stloc.1
+    IL_0011:  ldc.i4.1
+    IL_0012:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_0017:  nop
+    // sequence point: long b = 2;
+    IL_0018:  ldloca.s   V_0
+    IL_001a:  ldc.i4.2
+    IL_001b:  conv.i8
+    IL_001c:  dup
+    IL_001d:  stloc.2
+    IL_001e:  ldc.i4.2
+    IL_001f:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(ulong, int)""
+    IL_0024:  nop
+    // sequence point: G(y: ref b, x: ref a);
+    IL_0025:  ldarg.0
+    IL_0026:  ldloca.s   V_1
+    IL_0028:  ldloca.s   V_2
+    IL_002a:  call       ""void C.G(ref int, ref long)""
+    IL_002f:  nop
+    IL_0030:  ldloca.s   V_0
+    IL_0032:  ldloc.2
+    IL_0033:  ldc.i4.2
+    IL_0034:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(ulong, int)""
+    IL_0039:  nop
+    IL_003a:  ldloca.s   V_0
+    IL_003c:  ldloc.1
+    IL_003d:  ldc.i4.1
+    IL_003e:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_0043:  nop
+    // sequence point: }
+    IL_0044:  leave.s    IL_004f
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_0046:  ldloca.s   V_0
+    IL_0048:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_004d:  nop
+    IL_004e:  endfinally
+  }
+  // sequence point: }
+  IL_004f:  ret
+}
+");
+        }
+
+        [Fact]
+        public void RefArguments_Call_IgnoreNonLocalRefs()
+        {
+            var source = WithHelpers(@"
+class C
+{
+    int A;
+    long[] B;
+
+    public void G(ref int x, ref long y)
+    {        
+    }
+    
+    public void F()
+    {
+        var c = new C();
+
+        G(y: ref c.B[1], x: ref c.A);
+    }
+}
+");
+            var verifier = CompileAndVerify(source);
+
+            verifier.VerifyMethodBody("C.F", @"
+{
+  // Code size       67 (0x43)
+  .maxstack  3
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0,
+                C V_1, //c
+                long& V_2)
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""void C.F()""
+  IL_0005:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogMethodEntry(int)""
+  IL_000a:  stloc.0
+  .try
+  {
+    // sequence point: {
+    IL_000b:  nop
+    // sequence point: var c = new C();
+    IL_000c:  ldloca.s   V_0
+    IL_000e:  newobj     ""C..ctor()""
+    IL_0013:  dup
+    IL_0014:  stloc.1
+    IL_0015:  ldc.i4.1
+    IL_0016:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(object, int)""
+    IL_001b:  nop
+    // sequence point: G(y: ref c.B[1], x: ref c.A);
+    IL_001c:  ldarg.0
+    IL_001d:  ldloc.1
+    IL_001e:  ldfld      ""long[] C.B""
+    IL_0023:  ldc.i4.1
+    IL_0024:  ldelema    ""long""
+    IL_0029:  stloc.2
+    IL_002a:  ldloc.1
+    IL_002b:  ldflda     ""int C.A""
+    IL_0030:  ldloc.2
+    IL_0031:  call       ""void C.G(ref int, ref long)""
+    IL_0036:  nop
+    // sequence point: }
+    IL_0037:  leave.s    IL_0042
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_0039:  ldloca.s   V_0
+    IL_003b:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_0040:  nop
+    IL_0041:  endfinally
+  }
+  // sequence point: }
+  IL_0042:  ret
+}
+");
+        }
+
+        [Fact]
+        public void RefArguments_ObjectCreation()
+        {
+            var source = WithHelpers(@"
+class C
+{
+    public C(ref int x, ref long y)
+    {        
+    }
+    
+    public void F()
+    {
+        int a = 1;
+        long b = 2;
+        var c = new C(y: ref b, x: ref a);
+    }
+}
+");
+            var verifier = CompileAndVerify(source);
+
+            verifier.VerifyMethodBody("C.F", @"
+ {
+  // Code size       89 (0x59)
+  .maxstack  5
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0,
+                int V_1, //a
+                long V_2, //b
+                C V_3) //c
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""void C.F()""
+  IL_0005:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogMethodEntry(int)""
+  IL_000a:  stloc.0
+  .try
+  {
+    // sequence point: {
+    IL_000b:  nop
+    // sequence point: int a = 1;
+    IL_000c:  ldloca.s   V_0
+    IL_000e:  ldc.i4.1
+    IL_000f:  dup
+    IL_0010:  stloc.1
+    IL_0011:  ldc.i4.1
+    IL_0012:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_0017:  nop
+    // sequence point: long b = 2;
+    IL_0018:  ldloca.s   V_0
+    IL_001a:  ldc.i4.2
+    IL_001b:  conv.i8
+    IL_001c:  dup
+    IL_001d:  stloc.2
+    IL_001e:  ldc.i4.2
+    IL_001f:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(ulong, int)""
+    IL_0024:  nop
+    // sequence point: var c = new C(y: ref b, x: ref a);
+    IL_0025:  ldloca.s   V_0
+    IL_0027:  ldloca.s   V_1
+    IL_0029:  ldloca.s   V_2
+    IL_002b:  newobj     ""C..ctor(ref int, ref long)""
+    IL_0030:  ldloca.s   V_0
+    IL_0032:  ldloc.2
+    IL_0033:  ldc.i4.2
+    IL_0034:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(ulong, int)""
+    IL_0039:  nop
+    IL_003a:  ldloca.s   V_0
+    IL_003c:  ldloc.1
+    IL_003d:  ldc.i4.1
+    IL_003e:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_0043:  nop
+    IL_0044:  dup
+    IL_0045:  stloc.3
+    IL_0046:  ldc.i4.3
+    IL_0047:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(object, int)""
+    IL_004c:  nop
+    // sequence point: }
+    IL_004d:  leave.s    IL_0058
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_004f:  ldloca.s   V_0
+    IL_0051:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_0056:  nop
+    IL_0057:  endfinally
+  }
+  // sequence point: }
+  IL_0058:  ret
+}
+");
+        }
+
+        [Fact]
+        public void RefArguments_RefSelf()
+        {
+            var source = WithHelpers(@"
+static class C
+{
+    static void F()
+    {
+        int a = 1;
+        long b = 2;
+        a.G(y: ref b, x: ref a);
+    }
+
+    static void G(this ref int self, ref int x, ref long y) { }
+}
+");
+            var verifier = CompileAndVerify(source);
+
+            verifier.VerifyMethodBody("C.F", @"
+ {
+  // Code size       91 (0x5b)
+  .maxstack  3
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0,
+                int V_1, //a
+                long V_2) //b
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""void C.F()""
+  IL_0005:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogMethodEntry(int)""
+  IL_000a:  stloc.0
+  .try
+  {
+    // sequence point: {
+    IL_000b:  nop
+    // sequence point: int a = 1;
+    IL_000c:  ldloca.s   V_0
+    IL_000e:  ldc.i4.1
+    IL_000f:  dup
+    IL_0010:  stloc.1
+    IL_0011:  ldc.i4.1
+    IL_0012:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_0017:  nop
+    // sequence point: long b = 2;
+    IL_0018:  ldloca.s   V_0
+    IL_001a:  ldc.i4.2
+    IL_001b:  conv.i8
+    IL_001c:  dup
+    IL_001d:  stloc.2
+    IL_001e:  ldc.i4.2
+    IL_001f:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(ulong, int)""
+    IL_0024:  nop
+    // sequence point: a.G(y: ref b, x: ref a);
+    IL_0025:  ldloca.s   V_1
+    IL_0027:  ldloca.s   V_1
+    IL_0029:  ldloca.s   V_2
+    IL_002b:  call       ""void C.G(ref int, ref int, ref long)""
+    IL_0030:  nop
+    IL_0031:  ldloca.s   V_0
+    IL_0033:  ldloc.1
+    IL_0034:  ldc.i4.1
+    IL_0035:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_003a:  nop
+    IL_003b:  ldloca.s   V_0
+    IL_003d:  ldloc.2
+    IL_003e:  ldc.i4.2
+    IL_003f:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(ulong, int)""
+    IL_0044:  nop
+    IL_0045:  ldloca.s   V_0
+    IL_0047:  ldloc.1
+    IL_0048:  ldc.i4.1
+    IL_0049:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_004e:  nop
+    // sequence point: }
+    IL_004f:  leave.s    IL_005a
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_0051:  ldloca.s   V_0
+    IL_0053:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_0058:  nop
+    IL_0059:  endfinally
+  }
+  // sequence point: }
+  IL_005a:  ret
+}");
+        }
+
+        [Fact]
+        public void RefArguments_CollectionInitializer()
+        {
+            var source = WithHelpers(@"
+using System.Collections;
+using System.Collections.Generic;
+
+struct C : IEnumerable<int>
+{
+    public void F()
+    {
+        var c = new C() { {1} };
+    }
+
+    public IEnumerator<int> GetEnumerator() => null;
+    IEnumerator IEnumerable.GetEnumerator() => null;
+}
+
+static class Extensions
+{
+    public static void Add(this ref C self, int item) { }
+}
+");
+            var verifier = CompileAndVerify(source);
+
+            verifier.VerifyMethodBody("C.F", @"
+{
+  // Code size       54 (0x36)
+  .maxstack  3
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0,
+                C V_1, //c
+                C V_2)
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""void C.F()""
+  IL_0005:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogMethodEntry(int)""
+  IL_000a:  stloc.0
+  .try
+  {
+    // sequence point: {
+    IL_000b:  nop
+    // sequence point: var c = new C() { {1} };
+    IL_000c:  ldloca.s   V_0
+    IL_000e:  ldloca.s   V_2
+    IL_0010:  initobj    ""C""
+    IL_0016:  ldloca.s   V_2
+    IL_0018:  ldc.i4.1
+    IL_0019:  call       ""void Extensions.Add(ref C, int)""
+    IL_001e:  nop
+    IL_001f:  ldloc.2
+    IL_0020:  stloc.1
+    IL_0021:  ldloca.s   V_1
+    IL_0023:  ldc.i4.1
+    IL_0024:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStoreUnmanaged<C>(ref C, int)""
+    IL_0029:  nop
+    // sequence point: }
+    IL_002a:  leave.s    IL_0035
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_002c:  ldloca.s   V_0
+    IL_002e:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_0033:  nop
+    IL_0034:  endfinally
+  }
+  // sequence point: }
+  IL_0035:  ret
+}
+");
+        }
+
+        [Fact]
+        public void RefArguments_FunctionPointerInvocation()
+        {
+            var source = WithHelpers(@"
+unsafe class C
+{
+    void F(delegate*<ref int, ref long, void> f)
+    {
+        int a = 1;
+        long b = 2;
+        f(ref a, ref b);
+    }
+}
+");
+            var verifier = CompileAndVerify(source, ilVerifyMessage: """
+                [F]: ImportCalli not implemented
+                """);
+
+            verifier.VerifyMethodBody("C.F", @"
+ {
+  // Code size       91 (0x5b)
+  .maxstack  3
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0,
+                int V_1, //a
+                long V_2, //b
+                delegate*<ref int, ref long, void> V_3)
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""void C.F(delegate*<ref int, ref long, void>)""
+  IL_0005:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogMethodEntry(int)""
+  IL_000a:  stloc.0
+  .try
+  {
+    // sequence point: {
+    IL_000b:  ldloca.s   V_0
+    IL_000d:  ldarg.1
+    IL_000e:  ldc.i4.0
+    IL_000f:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogParameterStore(void*, int)""
+    IL_0014:  nop
+    // sequence point: int a = 1;
+    IL_0015:  ldloca.s   V_0
+    IL_0017:  ldc.i4.1
+    IL_0018:  dup
+    IL_0019:  stloc.1
+    IL_001a:  ldc.i4.1
+    IL_001b:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_0020:  nop
+    // sequence point: long b = 2;
+    IL_0021:  ldloca.s   V_0
+    IL_0023:  ldc.i4.2
+    IL_0024:  conv.i8
+    IL_0025:  dup
+    IL_0026:  stloc.2
+    IL_0027:  ldc.i4.2
+    IL_0028:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(ulong, int)""
+    IL_002d:  nop
+    // sequence point: f(ref a, ref b);
+    IL_002e:  ldarg.1
+    IL_002f:  stloc.3
+    IL_0030:  ldloca.s   V_1
+    IL_0032:  ldloca.s   V_2
+    IL_0034:  ldloc.3
+    IL_0035:  calli      ""delegate*<ref int, ref long, void>""
+    IL_003a:  nop
+    IL_003b:  ldloca.s   V_0
+    IL_003d:  ldloc.1
+    IL_003e:  ldc.i4.1
+    IL_003f:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_0044:  nop
+    IL_0045:  ldloca.s   V_0
+    IL_0047:  ldloc.2
+    IL_0048:  ldc.i4.2
+    IL_0049:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(ulong, int)""
+    IL_004e:  nop
+    // sequence point: }
+    IL_004f:  leave.s    IL_005a
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_0051:  ldloca.s   V_0
+    IL_0053:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_0058:  nop
+    IL_0059:  endfinally
+  }
+  // sequence point: }
+  IL_005a:  ret
+}
+");
+        }
+
+        [Fact]
+        public void Initializers()
+        {
+            var source = WithHelpers(@"
+class C
+{
+    static int A = F(out var x) + (x = 1);
+    static int B = F(out var x) + (x = 2);
+
+    static int F(out int a) => a = 1;
+}
+");
+            var verifier = CompileAndVerify(source);
+            verifier.VerifyMethodBody("C..cctor", @"
+{
+  // Code size       95 (0x5f)
+  .maxstack  4
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0,
+                int V_1, //x
+                int V_2) //x
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""C..cctor()""
+  IL_0005:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogMethodEntry(int)""
+  IL_000a:  stloc.0
+  .try
+  {
+    // sequence point: static int A = F(out var x) + (x = 1);
+    IL_000b:  ldloca.s   V_1
+    IL_000d:  call       ""int C.F(out int)""
+    IL_0012:  ldloca.s   V_0
+    IL_0014:  ldloc.1
+    IL_0015:  ldc.i4.1
+    IL_0016:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_001b:  nop
+    IL_001c:  ldloca.s   V_0
+    IL_001e:  ldc.i4.1
+    IL_001f:  dup
+    IL_0020:  stloc.1
+    IL_0021:  ldc.i4.1
+    IL_0022:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_0027:  nop
+    IL_0028:  ldloc.1
+    IL_0029:  add
+    IL_002a:  stsfld     ""int C.A""
+    // sequence point: static int B = F(out var x) + (x = 2);
+    IL_002f:  ldloca.s   V_2
+    IL_0031:  call       ""int C.F(out int)""
+    IL_0036:  ldloca.s   V_0
+    IL_0038:  ldloc.2
+    IL_0039:  ldc.i4.2
+    IL_003a:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_003f:  nop
+    IL_0040:  ldloca.s   V_0
+    IL_0042:  ldc.i4.2
+    IL_0043:  dup
+    IL_0044:  stloc.2
+    IL_0045:  ldc.i4.2
+    IL_0046:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_004b:  nop
+    IL_004c:  ldloc.2
+    IL_004d:  add
+    IL_004e:  stsfld     ""int C.B""
+    IL_0053:  leave.s    IL_005e
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_0055:  ldloca.s   V_0
+    IL_0057:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_005c:  nop
+    IL_005d:  endfinally
+  }
+  // sequence point: <hidden>
+  IL_005e:  ret
+}");
+        }
+
+        [Fact]
+        public void Initializers_Lambda()
+        {
+            var source = WithHelpers(@"
+using System;
+
+class C
+{
+    static Action A = new Action(() => { int x = 1; });
+
+    static void Main() { A(); }
+}
+");
+
+            // cctor invocation timing is different between .NET Core and .NET FX
+#if NET
+            var expectedOutput = @"
+Main: Entered
+.cctor: Entered
+.cctor: Returned
+.cctor: Entered lambda '<.cctor>b__3_0'
+<.cctor>b__3_0: L1 = 1
+<.cctor>b__3_0: Returned
+Main: Returned
+";
+#else
+            var expectedOutput = @"
+.cctor: Entered
+.cctor: Returned
+Main: Entered
+.cctor: Entered lambda '<.cctor>b__3_0'
+<.cctor>b__3_0: L1 = 1
+<.cctor>b__3_0: Returned
+Main: Returned
+";
+#endif
+
+            var verifier = CompileAndVerify(source, expectedOutput: expectedOutput);
+
+            verifier.VerifyMethodBody("C..cctor", @"
+{
+  // Code size       44 (0x2c)
+  .maxstack  2
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0)
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""C..cctor()""
+  IL_0005:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogMethodEntry(int)""
+  IL_000a:  stloc.0
+  .try
+  {
+    // sequence point: static Action A = new Action(() => { int x = 1; });
+    IL_000b:  ldsfld     ""C.<>c C.<>c.<>9""
+    IL_0010:  ldftn      ""void C.<>c.<.cctor>b__3_0()""
+    IL_0016:  newobj     ""System.Action..ctor(object, nint)""
+    IL_001b:  stsfld     ""System.Action C.A""
+    IL_0020:  leave.s    IL_002b
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_0022:  ldloca.s   V_0
+    IL_0024:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_0029:  nop
+    IL_002a:  endfinally
+  }
+  // sequence point: <hidden>
+  IL_002b:  ret
+}
+");
+
+            // TODO: is this sequence point correct?
+            // sequence point: }
+            // IL_001d:  leave.s    IL_0028
+
+            verifier.VerifyMethodBody("C.<>c.<.cctor>b__3_0", @"
+{
+  // Code size       41 (0x29)
+  .maxstack  3
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0,
+                int V_1) //x
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""C..cctor()""
+  IL_0005:  ldtoken    ""void C.<>c.<.cctor>b__3_0()""
+  IL_000a:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLambdaEntry(int, int)""
+  IL_000f:  stloc.0
+  .try
+  {
+    // sequence point: {
+    IL_0010:  nop
+    // sequence point: int x = 1;
+    IL_0011:  ldloca.s   V_0
+    IL_0013:  ldc.i4.1
+    IL_0014:  dup
+    IL_0015:  stloc.1
+    IL_0016:  ldc.i4.1
+    IL_0017:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_001c:  nop
+    // sequence point: }
+    IL_001d:  leave.s    IL_0028
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_001f:  ldloca.s   V_0
+    IL_0021:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_0026:  nop
+    IL_0027:  endfinally
+  }
+  // sequence point: }
+  IL_0028:  ret
+}
+");
+        }
+
+        [Fact]
+        public void Constructors()
+        {
+            var source = WithHelpers(@"
+class B
+{
+    public B(int p) {}
+}
+
+class C : B
+{
+    int A = F(out var x) + (x = 1);
+
+    C() : base(F(out var y) + (y = 2))
+    {
+        int z = 3;
+    }
+
+    static int F(out int a) => a = 4;
+    static void Main() => new C();
+}
+");
+            var verifier = CompileAndVerify(source, expectedOutput: @"
+Main: Entered
+.ctor: Entered
+F: Entered
+F: P'a'[0] = 4
+F: Returned
+.ctor: L2 = 4
+.ctor: L2 = 1
+F: Entered
+F: P'a'[0] = 4
+F: Returned
+.ctor: L1 = 4
+.ctor: L1 = 2
+.ctor: Entered
+.ctor: P'p'[0] = 6
+.ctor: Returned
+.ctor: L3 = 3
+.ctor: Returned
+Main: Returned
+");
+            verifier.VerifyMethodBody("B..ctor", @"
+{
+  // Code size       41 (0x29)
+  .maxstack  3
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0)
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""B..ctor(int)""
+  IL_0005:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogMethodEntry(int)""
+  IL_000a:  stloc.0
+  .try
+  {
+    // sequence point: <hidden>
+    IL_000b:  ldloca.s   V_0
+    IL_000d:  ldarg.1
+    IL_000e:  ldc.i4.0
+    IL_000f:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogParameterStore(uint, int)""
+    IL_0014:  nop
+    // sequence point: public B(int p)
+    IL_0015:  ldarg.0
+    IL_0016:  call       ""object..ctor()""
+    IL_001b:  nop
+    // sequence point: {
+    IL_001c:  nop
+    // sequence point: }
+    IL_001d:  leave.s    IL_0028
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_001f:  ldloca.s   V_0
+    IL_0021:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_0026:  nop
+    IL_0027:  endfinally
+  }
+  // sequence point: }
+  IL_0028:  ret
+}
+");
+            verifier.VerifyMethodBody("C..ctor", @"
+ {
+  // Code size      111 (0x6f)
+  .maxstack  5
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0,
+                int V_1, //y
+                int V_2, //x
+                int V_3) //z
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""C..ctor()""
+  IL_0005:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogMethodEntry(int)""
+  IL_000a:  stloc.0
+  .try
+  {
+    // sequence point: int A = F(out var x) + (x = 1);
+    IL_000b:  ldarg.0
+    IL_000c:  ldloca.s   V_2
+    IL_000e:  call       ""int C.F(out int)""
+    IL_0013:  ldloca.s   V_0
+    IL_0015:  ldloc.2
+    IL_0016:  ldc.i4.2
+    IL_0017:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_001c:  nop
+    IL_001d:  ldloca.s   V_0
+    IL_001f:  ldc.i4.1
+    IL_0020:  dup
+    IL_0021:  stloc.2
+    IL_0022:  ldc.i4.2
+    IL_0023:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_0028:  nop
+    IL_0029:  ldloc.2
+    IL_002a:  add
+    IL_002b:  stfld      ""int C.A""
+    // sequence point: base(F(out var y) + (y = 2))
+    IL_0030:  ldarg.0
+    IL_0031:  ldloca.s   V_1
+    IL_0033:  call       ""int C.F(out int)""
+    IL_0038:  ldloca.s   V_0
+    IL_003a:  ldloc.1
+    IL_003b:  ldc.i4.1
+    IL_003c:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_0041:  nop
+    IL_0042:  ldloca.s   V_0
+    IL_0044:  ldc.i4.2
+    IL_0045:  dup
+    IL_0046:  stloc.1
+    IL_0047:  ldc.i4.1
+    IL_0048:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_004d:  nop
+    IL_004e:  ldloc.1
+    IL_004f:  add
+    IL_0050:  call       ""B..ctor(int)""
+    IL_0055:  nop
+    // sequence point: {
+    IL_0056:  nop
+    // sequence point: int z = 3;
+    IL_0057:  ldloca.s   V_0
+    IL_0059:  ldc.i4.3
+    IL_005a:  dup
+    IL_005b:  stloc.3
+    IL_005c:  ldc.i4.3
+    IL_005d:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_0062:  nop
+    // sequence point: }
+    IL_0063:  leave.s    IL_006e
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_0065:  ldloca.s   V_0
+    IL_0067:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_006c:  nop
+    IL_006d:  endfinally
+  }
+  // sequence point: }
+  IL_006e:  ret
+}
+");
+        }
+
+        [Fact]
+        public void EmbeddedStatement()
+        {
+            var source = WithHelpers(@"
+class C
+{
+    void M()
+    {
+        while(true)
+            G(F(out var x), x = 1);
+    }
+
+    int F(out int a) => a = 1;
+    void G(int a, int b) {}
+}
+");
+
+            var verifier = CompileAndVerify(source);
+            verifier.VerifyMethodBody("C.M", @"
+{
+  // Code size       65 (0x41)
+  .maxstack  5
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0,
+                int V_1, //x
+                bool V_2)
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""void C.M()""
+  IL_0005:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogMethodEntry(int)""
+  IL_000a:  stloc.0
+  .try
+  {
+    // sequence point: {
+    IL_000b:  nop
+    // sequence point: <hidden>
+    IL_000c:  br.s       IL_0034
+    // sequence point: G(F(out var x), x = 1);
+    IL_000e:  ldarg.0
+    IL_000f:  ldarg.0
+    IL_0010:  ldloca.s   V_1
+    IL_0012:  call       ""int C.F(out int)""
+    IL_0017:  ldloca.s   V_0
+    IL_0019:  ldloc.1
+    IL_001a:  ldc.i4.1
+    IL_001b:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_0020:  nop
+    IL_0021:  ldloca.s   V_0
+    IL_0023:  ldc.i4.1
+    IL_0024:  dup
+    IL_0025:  stloc.1
+    IL_0026:  ldc.i4.1
+    IL_0027:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_002c:  nop
+    IL_002d:  ldloc.1
+    IL_002e:  call       ""void C.G(int, int)""
+    IL_0033:  nop
+    // sequence point: while(true)
+    IL_0034:  ldc.i4.1
+    IL_0035:  stloc.2
+    IL_0036:  br.s       IL_000e
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_0038:  ldloca.s   V_0
+    IL_003a:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_003f:  nop
+    IL_0040:  endfinally
+  }
+}
+");
+        }
+
+        [Fact]
+        public void Lambdas()
+        {
+            var source = WithHelpers(@"
+using System;
+
+class C
+{
+    static void Main()
+    {
+        int a = 1;
+        {
+            int b = 2;
+            {
+                int c = 3;
+                
+                F(() => c += 1);
+            }
+
+            F(() => a += b);
+        }
+    }
+
+    static void F(Func<int> f) { f(); }
+}
+");
+
+            var verifier = CompileAndVerify(source, expectedOutput: @"
+Main: Entered
+Main: L'a' = 1
+Main: L'b' = 2
+Main: L'c' = 3
+F: Entered
+F: P'f'[0] = System.Func`1[System.Int32]
+Main: Entered lambda '<Main>b__1'
+<Main>b__1: L'c' = 4
+<Main>b__1: Returned
+F: Returned
+F: Entered
+F: P'f'[0] = System.Func`1[System.Int32]
+Main: Entered lambda '<Main>b__0'
+<Main>b__0: L'a' = 3
+<Main>b__0: Returned
+F: Returned
+Main: Returned
+");
+
+            verifier.VerifyMethodBody("C.<>c__DisplayClass0_1.<Main>b__0()", @"
+{
+  // Code size       86 (0x56)
+  .maxstack  4
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0,
+                int V_1,
+                int V_2)
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""void C.Main()""
+  IL_0005:  ldtoken    ""int C.<>c__DisplayClass0_1.<Main>b__0()""
+  IL_000a:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLambdaEntry(int, int)""
+  IL_000f:  stloc.0
+  .try
+  {
+    // sequence point: a += b
+    IL_0010:  ldloca.s   V_0
+    IL_0012:  ldarg.0
+    IL_0013:  ldfld      ""C.<>c__DisplayClass0_0 C.<>c__DisplayClass0_1.CS$<>8__locals1""
+    IL_0018:  ldarg.0
+    IL_0019:  ldfld      ""C.<>c__DisplayClass0_0 C.<>c__DisplayClass0_1.CS$<>8__locals1""
+    IL_001e:  ldfld      ""int C.<>c__DisplayClass0_0.a""
+    IL_0023:  ldarg.0
+    IL_0024:  ldfld      ""int C.<>c__DisplayClass0_1.b""
+    IL_0029:  add
+    IL_002a:  dup
+    IL_002b:  stloc.1
+    IL_002c:  stfld      ""int C.<>c__DisplayClass0_0.a""
+    IL_0031:  ldloc.1
+    IL_0032:  ldtoken    ""int C.<>c__DisplayClass0_0.a""
+    IL_0037:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_003c:  nop
+    IL_003d:  ldarg.0
+    IL_003e:  ldfld      ""C.<>c__DisplayClass0_0 C.<>c__DisplayClass0_1.CS$<>8__locals1""
+    IL_0043:  ldfld      ""int C.<>c__DisplayClass0_0.a""
+    IL_0048:  stloc.2
+    IL_0049:  leave.s    IL_0054
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_004b:  ldloca.s   V_0
+    IL_004d:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_0052:  nop
+    IL_0053:  endfinally
+  }
+  // sequence point: <hidden>
+  IL_0054:  ldloc.2
+  IL_0055:  ret
+}
+");
+
+            verifier.VerifyMethodBody("C.<>c__DisplayClass0_2.<Main>b__1()", @"
+{
+  // Code size       66 (0x42)
+  .maxstack  4
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0,
+                int V_1,
+                int V_2)
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""void C.Main()""
+  IL_0005:  ldtoken    ""int C.<>c__DisplayClass0_2.<Main>b__1()""
+  IL_000a:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLambdaEntry(int, int)""
+  IL_000f:  stloc.0
+  .try
+  {
+    // sequence point: c += 1
+    IL_0010:  ldloca.s   V_0
+    IL_0012:  ldarg.0
+    IL_0013:  ldarg.0
+    IL_0014:  ldfld      ""int C.<>c__DisplayClass0_2.c""
+    IL_0019:  ldc.i4.1
+    IL_001a:  add
+    IL_001b:  dup
+    IL_001c:  stloc.1
+    IL_001d:  stfld      ""int C.<>c__DisplayClass0_2.c""
+    IL_0022:  ldloc.1
+    IL_0023:  ldtoken    ""int C.<>c__DisplayClass0_2.c""
+    IL_0028:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_002d:  nop
+    IL_002e:  ldarg.0
+    IL_002f:  ldfld      ""int C.<>c__DisplayClass0_2.c""
+    IL_0034:  stloc.2
+    IL_0035:  leave.s    IL_0040
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_0037:  ldloca.s   V_0
+    IL_0039:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_003e:  nop
+    IL_003f:  endfinally
+  }
+  // sequence point: <hidden>
+  IL_0040:  ldloc.2
+  IL_0041:  ret
+}
+");
+
+            verifier.VerifyMethodBody("C.Main", @"
+{
+  // Code size      183 (0xb7)
+  .maxstack  4
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0,
+                C.<>c__DisplayClass0_0 V_1, //CS$<>8__locals0
+                int V_2,
+                C.<>c__DisplayClass0_1 V_3, //CS$<>8__locals1
+                C.<>c__DisplayClass0_2 V_4) //CS$<>8__locals2
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""void C.Main()""
+  IL_0005:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogMethodEntry(int)""
+  IL_000a:  stloc.0
+  .try
+  {
+    // sequence point: <hidden>
+    IL_000b:  newobj     ""C.<>c__DisplayClass0_0..ctor()""
+    IL_0010:  stloc.1
+    // sequence point: {
+    IL_0011:  nop
+    // sequence point: int a = 1;
+    IL_0012:  ldloca.s   V_0
+    IL_0014:  ldloc.1
+    IL_0015:  ldc.i4.1
+    IL_0016:  dup
+    IL_0017:  stloc.2
+    IL_0018:  stfld      ""int C.<>c__DisplayClass0_0.a""
+    IL_001d:  ldloc.2
+    IL_001e:  ldtoken    ""int C.<>c__DisplayClass0_0.a""
+    IL_0023:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_0028:  nop
+    IL_0029:  ldloc.1
+    IL_002a:  ldfld      ""int C.<>c__DisplayClass0_0.a""
+    IL_002f:  pop
+    // sequence point: <hidden>
+    IL_0030:  newobj     ""C.<>c__DisplayClass0_1..ctor()""
+    IL_0035:  stloc.3
+    IL_0036:  ldloc.3
+    IL_0037:  ldloc.1
+    IL_0038:  stfld      ""C.<>c__DisplayClass0_0 C.<>c__DisplayClass0_1.CS$<>8__locals1""
+    // sequence point: {
+    IL_003d:  nop
+    // sequence point: int b = 2;
+    IL_003e:  ldloca.s   V_0
+    IL_0040:  ldloc.3
+    IL_0041:  ldc.i4.2
+    IL_0042:  dup
+    IL_0043:  stloc.2
+    IL_0044:  stfld      ""int C.<>c__DisplayClass0_1.b""
+    IL_0049:  ldloc.2
+    IL_004a:  ldtoken    ""int C.<>c__DisplayClass0_1.b""
+    IL_004f:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_0054:  nop
+    IL_0055:  ldloc.3
+    IL_0056:  ldfld      ""int C.<>c__DisplayClass0_1.b""
+    IL_005b:  pop
+    // sequence point: <hidden>
+    IL_005c:  newobj     ""C.<>c__DisplayClass0_2..ctor()""
+    IL_0061:  stloc.s    V_4
+    // sequence point: {
+    IL_0063:  nop
+    // sequence point: int c = 3;
+    IL_0064:  ldloca.s   V_0
+    IL_0066:  ldloc.s    V_4
+    IL_0068:  ldc.i4.3
+    IL_0069:  dup
+    IL_006a:  stloc.2
+    IL_006b:  stfld      ""int C.<>c__DisplayClass0_2.c""
+    IL_0070:  ldloc.2
+    IL_0071:  ldtoken    ""int C.<>c__DisplayClass0_2.c""
+    IL_0076:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_007b:  nop
+    IL_007c:  ldloc.s    V_4
+    IL_007e:  ldfld      ""int C.<>c__DisplayClass0_2.c""
+    IL_0083:  pop
+    // sequence point: F(() => c += 1);
+    IL_0084:  ldloc.s    V_4
+    IL_0086:  ldftn      ""int C.<>c__DisplayClass0_2.<Main>b__1()""
+    IL_008c:  newobj     ""System.Func<int>..ctor(object, nint)""
+    IL_0091:  call       ""void C.F(System.Func<int>)""
+    IL_0096:  nop
+    // sequence point: }
+    IL_0097:  nop
+    // sequence point: F(() => a += b);
+    IL_0098:  ldloc.3
+    IL_0099:  ldftn      ""int C.<>c__DisplayClass0_1.<Main>b__0()""
+    IL_009f:  newobj     ""System.Func<int>..ctor(object, nint)""
+    IL_00a4:  call       ""void C.F(System.Func<int>)""
+    IL_00a9:  nop
+    // sequence point: }
+    IL_00aa:  nop
+    // sequence point: }
+    IL_00ab:  leave.s    IL_00b6
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_00ad:  ldloca.s   V_0
+    IL_00af:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_00b4:  nop
+    IL_00b5:  endfinally
+  }
+  // sequence point: }
+  IL_00b6:  ret
+}
+");
+        }
+
+        [Fact]
+        public void Lambdas_Parameters()
+        {
+            var source = WithHelpers(@"
+using System;
+
+class C
+{
+    static void Main()
+    {
+        F(b =>
+        {
+            int a = 1;
+            b = 2;
+            ref int c = ref a;
+            ref int d = ref b;
+        });
+    }
+
+    static void F(Action<int> f) => f(2);
+}
+");
+
+            var verifier = CompileAndVerify(source, expectedOutput: @"
+Main: Entered
+F: Entered
+F: P'f'[0] = System.Action`1[System.Int32]
+Main: Entered lambda '<Main>b__0_0'
+<Main>b__0_0: P'b'[0] = 2
+<Main>b__0_0: L1 = 1
+<Main>b__0_0: P'b'[0] = 2
+<Main>b__0_0: L2 -> L1
+<Main>b__0_0: L3 -> P'b'[0]
+<Main>b__0_0: Returned
+F: Returned
+Main: Returned
+");
+
+            verifier.VerifyMethodBody("C.<>c.<Main>b__0_0", @"
+{
+  // Code size       95 (0x5f)
+  .maxstack  3
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0,
+                int V_1, //a
+                int& V_2, //c
+                int& V_3) //d
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""void C.Main()""
+  IL_0005:  ldtoken    ""void C.<>c.<Main>b__0_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: int a = 1;
+    IL_001a:  ldloca.s   V_0
+    IL_001c:  ldc.i4.1
+    IL_001d:  dup
+    IL_001e:  stloc.1
+    IL_001f:  ldc.i4.1
+    IL_0020:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_0025:  nop
+    // sequence point: b = 2;
+    IL_0026:  ldloca.s   V_0
+    IL_0028:  ldc.i4.2
+    IL_0029:  dup
+    IL_002a:  starg.s    V_1
+    IL_002c:  ldc.i4.0
+    IL_002d:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogParameterStore(uint, int)""
+    IL_0032:  nop
+    // sequence point: ref int c = ref a;
+    IL_0033:  ldloca.s   V_0
+    IL_0035:  ldloca.s   V_1
+    IL_0037:  stloc.2
+    IL_0038:  ldc.i4.1
+    IL_0039:  ldc.i4.2
+    IL_003a:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStoreLocalAlias(int, int)""
+    IL_003f:  nop
+    IL_0040:  ldloc.2
+    IL_0041:  ldind.i4
+    IL_0042:  pop
+    // sequence point: ref int d = ref b;
+    IL_0043:  ldloca.s   V_0
+    IL_0045:  ldarga.s   V_1
+    IL_0047:  stloc.3
+    IL_0048:  ldc.i4.0
+    IL_0049:  ldc.i4.3
+    IL_004a:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStoreParameterAlias(int, int)""
+    IL_004f:  nop
+    IL_0050:  ldloc.3
+    IL_0051:  ldind.i4
+    IL_0052:  pop
+    // sequence point: }
+    IL_0053:  leave.s    IL_005e
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_0055:  ldloca.s   V_0
+    IL_0057:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_005c:  nop
+    IL_005d:  endfinally
+  }
+  // sequence point: }
+  IL_005e:  ret
+}
+");
+        }
+
+        [Fact]
+        public void Lambdas_LiftedParameters()
+        {
+            var source = WithHelpers(@"
+using System;
+
+class C
+{
+    static void Main()
+    {
+        G(1);
+    }
+    
+    static void G(int a)
+    {
+        F(b => 
+        {
+            a = b;
+            return F(c => ++b);
+        });
+    }
+
+    static int F(Func<int, int> f) => f(2);
+}
+");
+
+            var verifier = CompileAndVerify(source, expectedOutput: @"
+Main: Entered
+G: Entered
+G: P'a'[0] = 1
+F: Entered
+F: P'f'[0] = System.Func`2[System.Int32,System.Int32]
+G: Entered lambda '<G>b__0'
+<G>b__0: P'b'[0] = 2
+<G>b__0: P'a' = 2
+F: Entered
+F: P'f'[0] = System.Func`2[System.Int32,System.Int32]
+G: Entered lambda '<G>b__1'
+<G>b__1: P'c'[0] = 2
+<G>b__1: P'b' = 3
+<G>b__1: Returned
+F: Returned
+<G>b__0: Returned
+F: Returned
+G: Returned
+Main: Returned
+");
+
+            verifier.VerifyMethodBody("C.G", @"
+{
+  // Code size       69 (0x45)
+  .maxstack  3
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0,
+                C.<>c__DisplayClass1_0 V_1) //CS$<>8__locals0
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""void C.G(int)""
+  IL_0005:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogMethodEntry(int)""
+  IL_000a:  stloc.0
+  .try
+  {
+    // sequence point: <hidden>
+    IL_000b:  newobj     ""C.<>c__DisplayClass1_0..ctor()""
+    IL_0010:  stloc.1
+    IL_0011:  ldloc.1
+    IL_0012:  ldarg.0
+    IL_0013:  stfld      ""int C.<>c__DisplayClass1_0.a""
+    // sequence point: {
+    IL_0018:  ldloca.s   V_0
+    IL_001a:  ldloc.1
+    IL_001b:  ldfld      ""int C.<>c__DisplayClass1_0.a""
+    IL_0020:  ldc.i4.0
+    IL_0021:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogParameterStore(uint, int)""
+    IL_0026:  nop
+    // sequence point: F(b =>  ...         });
+    IL_0027:  ldloc.1
+    IL_0028:  ldftn      ""int C.<>c__DisplayClass1_0.<G>b__0(int)""
+    IL_002e:  newobj     ""System.Func<int, int>..ctor(object, nint)""
+    IL_0033:  call       ""int C.F(System.Func<int, int>)""
+    IL_0038:  pop
+    // sequence point: }
+    IL_0039:  leave.s    IL_0044
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_003b:  ldloca.s   V_0
+    IL_003d:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_0042:  nop
+    IL_0043:  endfinally
+  }
+  // sequence point: }
+  IL_0044:  ret
+}
+");
+            verifier.VerifyMethodBody("C.<>c__DisplayClass1_0.<G>b__0", @"
+{
+  // Code size      110 (0x6e)
+  .maxstack  4
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0,
+                C.<>c__DisplayClass1_1 V_1, //CS$<>8__locals0
+                int V_2,
+                int V_3)
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""void C.G(int)""
+  IL_0005:  ldtoken    ""int C.<>c__DisplayClass1_0.<G>b__0(int)""
+  IL_000a:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLambdaEntry(int, int)""
+  IL_000f:  stloc.0
+  .try
+  {
+    // sequence point: <hidden>
+    IL_0010:  newobj     ""C.<>c__DisplayClass1_1..ctor()""
+    IL_0015:  stloc.1
+    IL_0016:  ldloc.1
+    IL_0017:  ldarg.1
+    IL_0018:  stfld      ""int C.<>c__DisplayClass1_1.b""
+    // sequence point: {
+    IL_001d:  ldloca.s   V_0
+    IL_001f:  ldloc.1
+    IL_0020:  ldfld      ""int C.<>c__DisplayClass1_1.b""
+    IL_0025:  ldc.i4.0
+    IL_0026:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogParameterStore(uint, int)""
+    IL_002b:  nop
+    // sequence point: a = b;
+    IL_002c:  ldloca.s   V_0
+    IL_002e:  ldarg.0
+    IL_002f:  ldloc.1
+    IL_0030:  ldfld      ""int C.<>c__DisplayClass1_1.b""
+    IL_0035:  dup
+    IL_0036:  stloc.2
+    IL_0037:  stfld      ""int C.<>c__DisplayClass1_0.a""
+    IL_003c:  ldloc.2
+    IL_003d:  ldtoken    ""int C.<>c__DisplayClass1_0.a""
+    IL_0042:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogParameterStore(uint, int)""
+    IL_0047:  nop
+    IL_0048:  ldarg.0
+    IL_0049:  ldfld      ""int C.<>c__DisplayClass1_0.a""
+    IL_004e:  pop
+    // sequence point: return F(c => ++b);
+    IL_004f:  ldloc.1
+    IL_0050:  ldftn      ""int C.<>c__DisplayClass1_1.<G>b__1(int)""
+    IL_0056:  newobj     ""System.Func<int, int>..ctor(object, nint)""
+    IL_005b:  call       ""int C.F(System.Func<int, int>)""
+    IL_0060:  stloc.3
+    IL_0061:  leave.s    IL_006c
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_0063:  ldloca.s   V_0
+    IL_0065:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_006a:  nop
+    IL_006b:  endfinally
+  }
+  // sequence point: }
+  IL_006c:  ldloc.3
+  IL_006d:  ret
+}");
+            verifier.VerifyMethodBody("C.<>c__DisplayClass1_1.<G>b__1", @"
+{
+  // Code size       80 (0x50)
+  .maxstack  4
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0,
+                int V_1,
+                int V_2,
+                int V_3)
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""void C.G(int)""
+  IL_0005:  ldtoken    ""int C.<>c__DisplayClass1_1.<G>b__1(int)""
+  IL_000a:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLambdaEntry(int, int)""
+  IL_000f:  stloc.0
+  .try
+  {
+    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: ++b
+    IL_001a:  ldarg.0
+    IL_001b:  ldfld      ""int C.<>c__DisplayClass1_1.b""
+    IL_0020:  ldc.i4.1
+    IL_0021:  add
+    IL_0022:  stloc.1
+    IL_0023:  ldloca.s   V_0
+    IL_0025:  ldarg.0
+    IL_0026:  ldloc.1
+    IL_0027:  dup
+    IL_0028:  stloc.2
+    IL_0029:  stfld      ""int C.<>c__DisplayClass1_1.b""
+    IL_002e:  ldloc.2
+    IL_002f:  ldtoken    ""int C.<>c__DisplayClass1_1.b""
+    IL_0034:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogParameterStore(uint, int)""
+    IL_0039:  nop
+    IL_003a:  ldarg.0
+    IL_003b:  ldfld      ""int C.<>c__DisplayClass1_1.b""
+    IL_0040:  pop
+    IL_0041:  ldloc.1
+    IL_0042:  stloc.3
+    IL_0043:  leave.s    IL_004e
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_0045:  ldloca.s   V_0
+    IL_0047:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_004c:  nop
+    IL_004d:  endfinally
+  }
+  // sequence point: <hidden>
+  IL_004e:  ldloc.3
+  IL_004f:  ret
+}
+");
+        }
+
+        [Fact]
+        public void StateMachine_Async()
+        {
+            var source = WithHelpers(@"
+using System.Threading.Tasks;
+
+class C
+{
+    static async Task M(int p)
+    {
+        int a = p;
+        F(out var b);
+        await Task.FromResult(1);
+        int c = b;
+    }
+
+    static int F(out int a) => a = 1;
+    static async Task Main() => await M(2);
+}
+");
+
+            var verifier = CompileAndVerify(source, expectedOutput: @"
+Main: Entered state machine #1
+M: Entered state machine #2
+M: P'p'[0] = 2
+M: L'a' = 2
+F: Entered
+F: P'a'[0] = 1
+F: Returned
+M: L'b' = 1
+M: L'c' = 1
+M: Returned
+Main: Returned
+");
+
+            verifier.VerifyMethodBody("C.M", @"
+{
+  // Code size       67 (0x43)
+  .maxstack  2
+  .locals init (C.<M>d__0 V_0)
+  IL_0000:  newobj     ""C.<M>d__0..ctor()""
+  IL_0005:  stloc.0
+  IL_0006:  ldloc.0
+  IL_0007:  call       ""System.Runtime.CompilerServices.AsyncTaskMethodBuilder System.Runtime.CompilerServices.AsyncTaskMethodBuilder.Create()""
+  IL_000c:  stfld      ""System.Runtime.CompilerServices.AsyncTaskMethodBuilder C.<M>d__0.<>t__builder""
+  IL_0011:  ldloc.0
+  IL_0012:  ldarg.0
+  IL_0013:  stfld      ""int C.<M>d__0.p""
+  IL_0018:  ldloc.0
+  IL_0019:  ldc.i4.m1
+  IL_001a:  stfld      ""int C.<M>d__0.<>1__state""
+  IL_001f:  ldloc.0
+  IL_0020:  call       ""ulong Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.GetNewStateMachineInstanceId()""
+  IL_0025:  stfld      ""ulong C.<M>d__0.<>I""
+  IL_002a:  ldloc.0
+  IL_002b:  ldflda     ""System.Runtime.CompilerServices.AsyncTaskMethodBuilder C.<M>d__0.<>t__builder""
+  IL_0030:  ldloca.s   V_0
+  IL_0032:  call       ""void System.Runtime.CompilerServices.AsyncTaskMethodBuilder.Start<C.<M>d__0>(ref C.<M>d__0)""
+  IL_0037:  ldloc.0
+  IL_0038:  ldflda     ""System.Runtime.CompilerServices.AsyncTaskMethodBuilder C.<M>d__0.<>t__builder""
+  IL_003d:  call       ""System.Threading.Tasks.Task System.Runtime.CompilerServices.AsyncTaskMethodBuilder.Task.get""
+  IL_0042:  ret
+}
+");
+
+            verifier.VerifyMethodBody("C.<M>d__0..ctor", @"
+{
+  // Code size        8 (0x8)
+  .maxstack  1
+  IL_0000:  ldarg.0
+  IL_0001:  call       ""object..ctor()""
+  IL_0006:  nop
+  IL_0007:  ret
+}
+");
+            // TODO: remove unnecessary IL:
+            // IL_0038: ldarg.0
+            // IL_0039: ldfld      ""int C.<Main>d__0.<a>5__1""
+            // IL_003e: pop
+
+            verifier.VerifyMethodBody("C.<M>d__0.System.Runtime.CompilerServices.IAsyncStateMachine.MoveNext()", @"
+{
+  // Code size      304 (0x130)
+  .maxstack  4
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0,
+                int V_1,
+                int V_2,
+                System.Runtime.CompilerServices.TaskAwaiter<int> V_3,
+                C.<M>d__0 V_4,
+                System.Exception V_5)
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""System.Threading.Tasks.Task C.M(int)""
+  IL_0005:  ldarg.0
+  IL_0006:  ldfld      ""ulong C.<M>d__0.<>I""
+  IL_000b:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogStateMachineMethodEntry(int, ulong)""
+  IL_0010:  stloc.0
+  .try
+  {
+    // sequence point: <hidden>
+    IL_0011:  ldarg.0
+    IL_0012:  ldfld      ""int C.<M>d__0.<>1__state""
+    IL_0017:  stloc.1
+    .try
+    {
+      // sequence point: <hidden>
+      IL_0018:  ldloc.1
+      IL_0019:  brfalse.s  IL_001d
+      IL_001b:  br.s       IL_0022
+      IL_001d:  br         IL_00ad
+      // sequence point: {
+      IL_0022:  ldloca.s   V_0
+      IL_0024:  ldarg.0
+      IL_0025:  ldfld      ""int C.<M>d__0.p""
+      IL_002a:  ldc.i4.0
+      IL_002b:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogParameterStore(uint, int)""
+      IL_0030:  nop
+      // sequence point: int a = p;
+      IL_0031:  ldloca.s   V_0
+      IL_0033:  ldarg.0
+      IL_0034:  ldarg.0
+      IL_0035:  ldfld      ""int C.<M>d__0.p""
+      IL_003a:  dup
+      IL_003b:  stloc.2
+      IL_003c:  stfld      ""int C.<M>d__0.<a>5__1""
+      IL_0041:  ldloc.2
+      IL_0042:  ldtoken    ""int C.<M>d__0.<a>5__1""
+      IL_0047:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+      IL_004c:  nop
+      IL_004d:  ldarg.0
+      IL_004e:  ldfld      ""int C.<M>d__0.<a>5__1""
+      IL_0053:  pop
+      // sequence point: F(out var b);
+      IL_0054:  ldarg.0
+      IL_0055:  ldflda     ""int C.<M>d__0.<b>5__2""
+      IL_005a:  call       ""int C.F(out int)""
+      IL_005f:  pop
+      IL_0060:  ldloca.s   V_0
+      IL_0062:  ldarg.0
+      IL_0063:  ldfld      ""int C.<M>d__0.<b>5__2""
+      IL_0068:  ldtoken    ""int C.<M>d__0.<b>5__2""
+      IL_006d:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+      IL_0072:  nop
+      // sequence point: await Task.FromResult(1);
+      IL_0073:  ldc.i4.1
+      IL_0074:  call       ""System.Threading.Tasks.Task<int> System.Threading.Tasks.Task.FromResult<int>(int)""
+      IL_0079:  callvirt   ""System.Runtime.CompilerServices.TaskAwaiter<int> System.Threading.Tasks.Task<int>.GetAwaiter()""
+      IL_007e:  stloc.3
+      // sequence point: <hidden>
+      IL_007f:  ldloca.s   V_3
+      IL_0081:  call       ""bool System.Runtime.CompilerServices.TaskAwaiter<int>.IsCompleted.get""
+      IL_0086:  brtrue.s   IL_00c9
+      IL_0088:  ldarg.0
+      IL_0089:  ldc.i4.0
+      IL_008a:  dup
+      IL_008b:  stloc.1
+      IL_008c:  stfld      ""int C.<M>d__0.<>1__state""
+      // async: yield
+      IL_0091:  ldarg.0
+      IL_0092:  ldloc.3
+      IL_0093:  stfld      ""System.Runtime.CompilerServices.TaskAwaiter<int> C.<M>d__0.<>u__1""
+      IL_0098:  ldarg.0
+      IL_0099:  stloc.s    V_4
+      IL_009b:  ldarg.0
+      IL_009c:  ldflda     ""System.Runtime.CompilerServices.AsyncTaskMethodBuilder C.<M>d__0.<>t__builder""
+      IL_00a1:  ldloca.s   V_3
+      IL_00a3:  ldloca.s   V_4
+      IL_00a5:  call       ""void System.Runtime.CompilerServices.AsyncTaskMethodBuilder.AwaitUnsafeOnCompleted<System.Runtime.CompilerServices.TaskAwaiter<int>, C.<M>d__0>(ref System.Runtime.CompilerServices.TaskAwaiter<int>, ref C.<M>d__0)""
+      IL_00aa:  nop
+      IL_00ab:  leave.s    IL_0124
+      // async: resume
+      IL_00ad:  ldarg.0
+      IL_00ae:  ldfld      ""System.Runtime.CompilerServices.TaskAwaiter<int> C.<M>d__0.<>u__1""
+      IL_00b3:  stloc.3
+      IL_00b4:  ldarg.0
+      IL_00b5:  ldflda     ""System.Runtime.CompilerServices.TaskAwaiter<int> C.<M>d__0.<>u__1""
+      IL_00ba:  initobj    ""System.Runtime.CompilerServices.TaskAwaiter<int>""
+      IL_00c0:  ldarg.0
+      IL_00c1:  ldc.i4.m1
+      IL_00c2:  dup
+      IL_00c3:  stloc.1
+      IL_00c4:  stfld      ""int C.<M>d__0.<>1__state""
+      IL_00c9:  ldloca.s   V_3
+      IL_00cb:  call       ""int System.Runtime.CompilerServices.TaskAwaiter<int>.GetResult()""
+      IL_00d0:  pop
+      // sequence point: int c = b;
+      IL_00d1:  ldloca.s   V_0
+      IL_00d3:  ldarg.0
+      IL_00d4:  ldarg.0
+      IL_00d5:  ldfld      ""int C.<M>d__0.<b>5__2""
+      IL_00da:  dup
+      IL_00db:  stloc.2
+      IL_00dc:  stfld      ""int C.<M>d__0.<c>5__3""
+      IL_00e1:  ldloc.2
+      IL_00e2:  ldtoken    ""int C.<M>d__0.<c>5__3""
+      IL_00e7:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+      IL_00ec:  nop
+      IL_00ed:  ldarg.0
+      IL_00ee:  ldfld      ""int C.<M>d__0.<c>5__3""
+      IL_00f3:  pop
+      IL_00f4:  leave.s    IL_0110
+    }
+    catch System.Exception
+    {
+      // sequence point: <hidden>
+      IL_00f6:  stloc.s    V_5
+      IL_00f8:  ldarg.0
+      IL_00f9:  ldc.i4.s   -2
+      IL_00fb:  stfld      ""int C.<M>d__0.<>1__state""
+      IL_0100:  ldarg.0
+      IL_0101:  ldflda     ""System.Runtime.CompilerServices.AsyncTaskMethodBuilder C.<M>d__0.<>t__builder""
+      IL_0106:  ldloc.s    V_5
+      IL_0108:  call       ""void System.Runtime.CompilerServices.AsyncTaskMethodBuilder.SetException(System.Exception)""
+      IL_010d:  nop
+      IL_010e:  leave.s    IL_0124
+    }
+    // sequence point: }
+    IL_0110:  ldarg.0
+    IL_0111:  ldc.i4.s   -2
+    IL_0113:  stfld      ""int C.<M>d__0.<>1__state""
+    // sequence point: <hidden>
+    IL_0118:  ldarg.0
+    IL_0119:  ldflda     ""System.Runtime.CompilerServices.AsyncTaskMethodBuilder C.<M>d__0.<>t__builder""
+    IL_011e:  call       ""void System.Runtime.CompilerServices.AsyncTaskMethodBuilder.SetResult()""
+    IL_0123:  nop
+    IL_0124:  leave.s    IL_012f
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_0126:  ldloca.s   V_0
+    IL_0128:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_012d:  nop
+    IL_012e:  endfinally
+  }
+  // sequence point: <hidden>
+  IL_012f:  ret
+}
+");
+        }
+
+        [Fact]
+        public void StateMachine_Iterator()
+        {
+            var source = WithHelpers(@"
+using System.Linq;
+using System.Collections.Generic;
+
+class C
+{
+    static IEnumerable<int> M(int p)
+    {
+        int a = p;
+        F(out var b);
+        yield return 1;
+        int c = b;
+    }
+
+    static int F(out int a) => a = 1;
+
+    static void Main() => M(2).ToArray();
+}
+");
+
+            var verifier = CompileAndVerify(source, expectedOutput: @"
+Main: Entered
+M: Entered state machine #1
+M: P'p'[0] = 2
+M: L'a' = 2
+F: Entered
+F: P'a'[0] = 1
+F: Returned
+M: L'b' = 1
+M: Returned
+M: Entered state machine #1
+M: L'c' = 1
+M: Returned
+Main: Returned
+");
+
+            verifier.VerifyMethodBody("C.M", @"
+{
+  // Code size       15 (0xf)
+  .maxstack  3
+  IL_0000:  ldc.i4.s   -2
+  IL_0002:  newobj     ""C.<M>d__0..ctor(int)""
+  IL_0007:  dup
+  IL_0008:  ldarg.0
+  IL_0009:  stfld      ""int C.<M>d__0.<>3__p""
+  IL_000e:  ret
+}
+");
+            verifier.VerifyMethodBody("C.<M>d__0..ctor", @"
+{
+  // Code size       37 (0x25)
+  .maxstack  2
+  IL_0000:  ldarg.0
+  IL_0001:  call       ""object..ctor()""
+  IL_0006:  nop
+  IL_0007:  ldarg.0
+  IL_0008:  ldarg.1
+  IL_0009:  stfld      ""int C.<M>d__0.<>1__state""
+  IL_000e:  ldarg.0
+  IL_000f:  call       ""int System.Environment.CurrentManagedThreadId.get""
+  IL_0014:  stfld      ""int C.<M>d__0.<>l__initialThreadId""
+  IL_0019:  ldarg.0
+  IL_001a:  call       ""ulong Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.GetNewStateMachineInstanceId()""
+  IL_001f:  stfld      ""ulong C.<M>d__0.<>I""
+  IL_0024:  ret
+}
+");
+
+            // TODO: remove unnecessary IL:
+            // ldarg.0
+            // ldfld      ""int C.<M>d__0.<a>5__1""
+            // pop
+
+            verifier.VerifyMethodBody("C.<M>d__0.System.Collections.IEnumerator.MoveNext()", @"
+{
+  // Code size      209 (0xd1)
+  .maxstack  4
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0,
+                int V_1,
+                bool V_2,
+                int V_3)
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""System.Collections.Generic.IEnumerable<int> C.M(int)""
+  IL_0005:  ldarg.0
+  IL_0006:  ldfld      ""ulong C.<M>d__0.<>I""
+  IL_000b:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogStateMachineMethodEntry(int, ulong)""
+  IL_0010:  stloc.0
+  .try
+  {
+    // sequence point: <hidden>
+    IL_0011:  ldarg.0
+    IL_0012:  ldfld      ""int C.<M>d__0.<>1__state""
+    IL_0017:  stloc.1
+    IL_0018:  ldloc.1
+    IL_0019:  brfalse.s  IL_0023
+    IL_001b:  br.s       IL_001d
+    IL_001d:  ldloc.1
+    IL_001e:  ldc.i4.1
+    IL_001f:  beq.s      IL_0025
+    IL_0021:  br.s       IL_0027
+    IL_0023:  br.s       IL_002e
+    IL_0025:  br.s       IL_0098
+    IL_0027:  ldc.i4.0
+    IL_0028:  stloc.2
+    IL_0029:  leave      IL_00cf
+    IL_002e:  ldarg.0
+    IL_002f:  ldc.i4.m1
+    IL_0030:  stfld      ""int C.<M>d__0.<>1__state""
+    // sequence point: {
+    IL_0035:  ldloca.s   V_0
+    IL_0037:  ldarg.0
+    IL_0038:  ldfld      ""int C.<M>d__0.p""
+    IL_003d:  ldc.i4.0
+    IL_003e:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogParameterStore(uint, int)""
+    IL_0043:  nop
+    // sequence point: int a = p;
+    IL_0044:  ldloca.s   V_0
+    IL_0046:  ldarg.0
+    IL_0047:  ldarg.0
+    IL_0048:  ldfld      ""int C.<M>d__0.p""
+    IL_004d:  dup
+    IL_004e:  stloc.3
+    IL_004f:  stfld      ""int C.<M>d__0.<a>5__1""
+    IL_0054:  ldloc.3
+    IL_0055:  ldtoken    ""int C.<M>d__0.<a>5__1""
+    IL_005a:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_005f:  nop
+    IL_0060:  ldarg.0
+    IL_0061:  ldfld      ""int C.<M>d__0.<a>5__1""
+    IL_0066:  pop
+    // sequence point: F(out var b);
+    IL_0067:  ldarg.0
+    IL_0068:  ldflda     ""int C.<M>d__0.<b>5__2""
+    IL_006d:  call       ""int C.F(out int)""
+    IL_0072:  pop
+    IL_0073:  ldloca.s   V_0
+    IL_0075:  ldarg.0
+    IL_0076:  ldfld      ""int C.<M>d__0.<b>5__2""
+    IL_007b:  ldtoken    ""int C.<M>d__0.<b>5__2""
+    IL_0080:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_0085:  nop
+    // sequence point: yield return 1;
+    IL_0086:  ldarg.0
+    IL_0087:  ldc.i4.1
+    IL_0088:  stfld      ""int C.<M>d__0.<>2__current""
+    IL_008d:  ldarg.0
+    IL_008e:  ldc.i4.1
+    IL_008f:  stfld      ""int C.<M>d__0.<>1__state""
+    IL_0094:  ldc.i4.1
+    IL_0095:  stloc.2
+    IL_0096:  leave.s    IL_00cf
+    // sequence point: <hidden>
+    IL_0098:  ldarg.0
+    IL_0099:  ldc.i4.m1
+    IL_009a:  stfld      ""int C.<M>d__0.<>1__state""
+    // sequence point: int c = b;
+    IL_009f:  ldloca.s   V_0
+    IL_00a1:  ldarg.0
+    IL_00a2:  ldarg.0
+    IL_00a3:  ldfld      ""int C.<M>d__0.<b>5__2""
+    IL_00a8:  dup
+    IL_00a9:  stloc.3
+    IL_00aa:  stfld      ""int C.<M>d__0.<c>5__3""
+    IL_00af:  ldloc.3
+    IL_00b0:  ldtoken    ""int C.<M>d__0.<c>5__3""
+    IL_00b5:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_00ba:  nop
+    IL_00bb:  ldarg.0
+    IL_00bc:  ldfld      ""int C.<M>d__0.<c>5__3""
+    IL_00c1:  pop
+    // sequence point: }
+    IL_00c2:  ldc.i4.0
+    IL_00c3:  stloc.2
+    IL_00c4:  leave.s    IL_00cf
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_00c6:  ldloca.s   V_0
+    IL_00c8:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_00cd:  nop
+    IL_00ce:  endfinally
+  }
+  // sequence point: <hidden>
+  IL_00cf:  ldloc.2
+  IL_00d0:  ret
+}");
+        }
+
+        [Fact]
+        public void StateMachine_AsyncIterator()
+        {
+            var source = WithHelpers(@"
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+class C
+{
+    static async IAsyncEnumerable<int> M(int p)
+    {
+        await Task.FromResult(1);
+        int a = p;
+        F(out var b);
+        yield return 1;
+        int c = b;
+    }
+
+    static int F(out int a) => a = 1;
+
+    static async Task Main()
+    {
+        await foreach (var n in M(2)) {}
+    }
+}
+");
+
+            var verifier = CompileAndVerify(source, expectedOutput: @"
+Main: Entered state machine #1
+M: Entered state machine #2
+M: P'p'[0] = 2
+M: L'a' = 2
+F: Entered
+F: P'a'[0] = 1
+F: Returned
+M: L'b' = 1
+M: Returned
+Main: L'n' = 1
+M: Entered state machine #2
+M: L'c' = 1
+M: Returned
+Main: Returned
+");
+
+            verifier.VerifyMethodBody("C.M", @"
+ {
+  // Code size       15 (0xf)
+  .maxstack  3
+  IL_0000:  ldc.i4.s   -2
+  IL_0002:  newobj     ""C.<M>d__0..ctor(int)""
+  IL_0007:  dup
+  IL_0008:  ldarg.0
+  IL_0009:  stfld      ""int C.<M>d__0.<>3__p""
+  IL_000e:  ret
+}
+");
+
+            // TODO: remove unnecessary IL:
+            // IL_0038: ldarg.0
+            // IL_0039: ldfld      ""int C.<M>d__0.<a>5__1""
+            // IL_003e: pop
+
+            verifier.VerifyMethodBody("C.<M>d__0.System.Runtime.CompilerServices.IAsyncStateMachine.MoveNext()", @"
+{
+  // Code size      457 (0x1c9)
+  .maxstack  4
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0,
+                int V_1,
+                System.Runtime.CompilerServices.TaskAwaiter<int> V_2,
+                C.<M>d__0 V_3,
+                int V_4,
+                System.Exception V_5)
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""System.Collections.Generic.IAsyncEnumerable<int> C.M(int)""
+  IL_0005:  ldarg.0
+  IL_0006:  ldfld      ""ulong C.<M>d__0.<>I""
+  IL_000b:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogStateMachineMethodEntry(int, ulong)""
+  IL_0010:  stloc.0
+  .try
+  {
+    // sequence point: <hidden>
+    IL_0011:  ldarg.0
+    IL_0012:  ldfld      ""int C.<M>d__0.<>1__state""
+    IL_0017:  stloc.1
+    .try
+    {
+      // sequence point: <hidden>
+      IL_0018:  ldloc.1
+      IL_0019:  ldc.i4.s   -4
+      IL_001b:  sub
+      IL_001c:  switch    (
+        IL_0037,
+        IL_003c,
+        IL_0040,
+        IL_0040,
+        IL_003e)
+      IL_0035:  br.s       IL_0040
+      IL_0037:  br         IL_011f
+      IL_003c:  br.s       IL_0040
+      IL_003e:  br.s       IL_00a1
+      IL_0040:  ldarg.0
+      IL_0041:  ldfld      ""bool C.<M>d__0.<>w__disposeMode""
+      IL_0046:  brfalse.s  IL_004d
+      IL_0048:  leave      IL_0186
+      IL_004d:  ldarg.0
+      IL_004e:  ldc.i4.m1
+      IL_004f:  dup
+      IL_0050:  stloc.1
+      IL_0051:  stfld      ""int C.<M>d__0.<>1__state""
+      // sequence point: {
+      IL_0056:  ldloca.s   V_0
+      IL_0058:  ldarg.0
+      IL_0059:  ldfld      ""int C.<M>d__0.p""
+      IL_005e:  ldc.i4.0
+      IL_005f:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogParameterStore(uint, int)""
+      IL_0064:  nop
+      // sequence point: await Task.FromResult(1);
+      IL_0065:  ldc.i4.1
+      IL_0066:  call       ""System.Threading.Tasks.Task<int> System.Threading.Tasks.Task.FromResult<int>(int)""
+      IL_006b:  callvirt   ""System.Runtime.CompilerServices.TaskAwaiter<int> System.Threading.Tasks.Task<int>.GetAwaiter()""
+      IL_0070:  stloc.2
+      // sequence point: <hidden>
+      IL_0071:  ldloca.s   V_2
+      IL_0073:  call       ""bool System.Runtime.CompilerServices.TaskAwaiter<int>.IsCompleted.get""
+      IL_0078:  brtrue.s   IL_00bd
+      IL_007a:  ldarg.0
+      IL_007b:  ldc.i4.0
+      IL_007c:  dup
+      IL_007d:  stloc.1
+      IL_007e:  stfld      ""int C.<M>d__0.<>1__state""
+      // async: yield
+      IL_0083:  ldarg.0
+      IL_0084:  ldloc.2
+      IL_0085:  stfld      ""System.Runtime.CompilerServices.TaskAwaiter<int> C.<M>d__0.<>u__1""
+      IL_008a:  ldarg.0
+      IL_008b:  stloc.3
+      IL_008c:  ldarg.0
+      IL_008d:  ldflda     ""System.Runtime.CompilerServices.AsyncIteratorMethodBuilder C.<M>d__0.<>t__builder""
+      IL_0092:  ldloca.s   V_2
+      IL_0094:  ldloca.s   V_3
+      IL_0096:  call       ""void System.Runtime.CompilerServices.AsyncIteratorMethodBuilder.AwaitUnsafeOnCompleted<System.Runtime.CompilerServices.TaskAwaiter<int>, C.<M>d__0>(ref System.Runtime.CompilerServices.TaskAwaiter<int>, ref C.<M>d__0)""
+      IL_009b:  nop
+      IL_009c:  leave      IL_01bd
+      // async: resume
+      IL_00a1:  ldarg.0
+      IL_00a2:  ldfld      ""System.Runtime.CompilerServices.TaskAwaiter<int> C.<M>d__0.<>u__1""
+      IL_00a7:  stloc.2
+      IL_00a8:  ldarg.0
+      IL_00a9:  ldflda     ""System.Runtime.CompilerServices.TaskAwaiter<int> C.<M>d__0.<>u__1""
+      IL_00ae:  initobj    ""System.Runtime.CompilerServices.TaskAwaiter<int>""
+      IL_00b4:  ldarg.0
+      IL_00b5:  ldc.i4.m1
+      IL_00b6:  dup
+      IL_00b7:  stloc.1
+      IL_00b8:  stfld      ""int C.<M>d__0.<>1__state""
+      IL_00bd:  ldloca.s   V_2
+      IL_00bf:  call       ""int System.Runtime.CompilerServices.TaskAwaiter<int>.GetResult()""
+      IL_00c4:  pop
+      // sequence point: int a = p;
+      IL_00c5:  ldloca.s   V_0
+      IL_00c7:  ldarg.0
+      IL_00c8:  ldarg.0
+      IL_00c9:  ldfld      ""int C.<M>d__0.p""
+      IL_00ce:  dup
+      IL_00cf:  stloc.s    V_4
+      IL_00d1:  stfld      ""int C.<M>d__0.<a>5__1""
+      IL_00d6:  ldloc.s    V_4
+      IL_00d8:  ldtoken    ""int C.<M>d__0.<a>5__1""
+      IL_00dd:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+      IL_00e2:  nop
+      IL_00e3:  ldarg.0
+      IL_00e4:  ldfld      ""int C.<M>d__0.<a>5__1""
+      IL_00e9:  pop
+      // sequence point: F(out var b);
+      IL_00ea:  ldarg.0
+      IL_00eb:  ldflda     ""int C.<M>d__0.<b>5__2""
+      IL_00f0:  call       ""int C.F(out int)""
+      IL_00f5:  pop
+      IL_00f6:  ldloca.s   V_0
+      IL_00f8:  ldarg.0
+      IL_00f9:  ldfld      ""int C.<M>d__0.<b>5__2""
+      IL_00fe:  ldtoken    ""int C.<M>d__0.<b>5__2""
+      IL_0103:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+      IL_0108:  nop
+      // sequence point: yield return 1;
+      IL_0109:  ldarg.0
+      IL_010a:  ldc.i4.1
+      IL_010b:  stfld      ""int C.<M>d__0.<>2__current""
+      IL_0110:  ldarg.0
+      IL_0111:  ldc.i4.s   -4
+      IL_0113:  dup
+      IL_0114:  stloc.1
+      IL_0115:  stfld      ""int C.<M>d__0.<>1__state""
+      IL_011a:  leave      IL_01b0
+      // sequence point: <hidden>
+      IL_011f:  ldarg.0
+      IL_0120:  ldc.i4.m1
+      IL_0121:  dup
+      IL_0122:  stloc.1
+      IL_0123:  stfld      ""int C.<M>d__0.<>1__state""
+      IL_0128:  ldarg.0
+      IL_0129:  ldfld      ""bool C.<M>d__0.<>w__disposeMode""
+      IL_012e:  brfalse.s  IL_0132
+      IL_0130:  leave.s    IL_0186
+      // sequence point: int c = b;
+      IL_0132:  ldloca.s   V_0
+      IL_0134:  ldarg.0
+      IL_0135:  ldarg.0
+      IL_0136:  ldfld      ""int C.<M>d__0.<b>5__2""
+      IL_013b:  dup
+      IL_013c:  stloc.s    V_4
+      IL_013e:  stfld      ""int C.<M>d__0.<c>5__3""
+      IL_0143:  ldloc.s    V_4
+      IL_0145:  ldtoken    ""int C.<M>d__0.<c>5__3""
+      IL_014a:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+      IL_014f:  nop
+      IL_0150:  ldarg.0
+      IL_0151:  ldfld      ""int C.<M>d__0.<c>5__3""
+      IL_0156:  pop
+      IL_0157:  leave.s    IL_0186
+    }
+    catch System.Exception
+    {
+      // sequence point: <hidden>
+      IL_0159:  stloc.s    V_5
+      IL_015b:  ldarg.0
+      IL_015c:  ldc.i4.s   -2
+      IL_015e:  stfld      ""int C.<M>d__0.<>1__state""
+      IL_0163:  ldarg.0
+      IL_0164:  ldc.i4.0
+      IL_0165:  stfld      ""int C.<M>d__0.<>2__current""
+      IL_016a:  ldarg.0
+      IL_016b:  ldflda     ""System.Runtime.CompilerServices.AsyncIteratorMethodBuilder C.<M>d__0.<>t__builder""
+      IL_0170:  call       ""void System.Runtime.CompilerServices.AsyncIteratorMethodBuilder.Complete()""
+      IL_0175:  nop
+      IL_0176:  ldarg.0
+      IL_0177:  ldflda     ""System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore<bool> C.<M>d__0.<>v__promiseOfValueOrEnd""
+      IL_017c:  ldloc.s    V_5
+      IL_017e:  call       ""void System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore<bool>.SetException(System.Exception)""
+      IL_0183:  nop
+      IL_0184:  leave.s    IL_01bd
+    }
+    // sequence point: }
+    IL_0186:  ldarg.0
+    IL_0187:  ldc.i4.s   -2
+    IL_0189:  stfld      ""int C.<M>d__0.<>1__state""
+    // sequence point: <hidden>
+    IL_018e:  ldarg.0
+    IL_018f:  ldc.i4.0
+    IL_0190:  stfld      ""int C.<M>d__0.<>2__current""
+    IL_0195:  ldarg.0
+    IL_0196:  ldflda     ""System.Runtime.CompilerServices.AsyncIteratorMethodBuilder C.<M>d__0.<>t__builder""
+    IL_019b:  call       ""void System.Runtime.CompilerServices.AsyncIteratorMethodBuilder.Complete()""
+    IL_01a0:  nop
+    IL_01a1:  ldarg.0
+    IL_01a2:  ldflda     ""System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore<bool> C.<M>d__0.<>v__promiseOfValueOrEnd""
+    IL_01a7:  ldc.i4.0
+    IL_01a8:  call       ""void System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore<bool>.SetResult(bool)""
+    IL_01ad:  nop
+    IL_01ae:  leave.s    IL_01c8
+    IL_01b0:  ldarg.0
+    IL_01b1:  ldflda     ""System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore<bool> C.<M>d__0.<>v__promiseOfValueOrEnd""
+    IL_01b6:  ldc.i4.1
+    IL_01b7:  call       ""void System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore<bool>.SetResult(bool)""
+    IL_01bc:  nop
+    IL_01bd:  leave.s    IL_01c8
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_01bf:  ldloca.s   V_0
+    IL_01c1:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_01c6:  nop
+    IL_01c7:  endfinally
+  }
+  // sequence point: <hidden>
+  IL_01c8:  ret
+}");
+        }
+
+        [Fact]
+        public void StateMachine_Lambda_Async()
+        {
+            var source = WithHelpers(@"
+using System;
+using System.Threading.Tasks;
+
+class C
+{
+    static async Task Main() 
+    {
+        await F(async p =>
+        {
+            int a = p;
+            return await Task.FromResult(1);
+        });
+    }
+
+    static async Task F(Func<int, Task<int>> t) => await t(2);
+}
+");
+            var verifier = CompileAndVerify(source, expectedOutput: @"
+Main: Entered state machine #1
+F: Entered state machine #2
+F: P't'[0] = System.Func`2[System.Int32,System.Threading.Tasks.Task`1[System.Int32]]
+Main: Entered lambda '<Main>b__0_0' state machine #3
+<Main>b__0_0: P'p'[0] = 2
+<Main>b__0_0: L'a' = 2
+<Main>b__0_0: Returned
+F: Returned
+Main: Returned
+");
+            verifier.VerifyMethodBody("C.<>c.<<Main>b__0_0>d.System.Runtime.CompilerServices.IAsyncStateMachine.MoveNext()", @"
+{
+  // Code size      256 (0x100)
+  .maxstack  4
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0,
+                int V_1,
+                int V_2,
+                int V_3,
+                System.Runtime.CompilerServices.TaskAwaiter<int> V_4,
+                C.<>c.<<Main>b__0_0>d V_5,
+                System.Exception V_6)
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""System.Threading.Tasks.Task C.Main()""
+  IL_0005:  ldtoken    ""System.Threading.Tasks.Task<int> C.<>c.<Main>b__0_0(int)""
+  IL_000a:  ldarg.0
+  IL_000b:  ldfld      ""ulong C.<>c.<<Main>b__0_0>d.<>I""
+  IL_0010:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogStateMachineLambdaEntry(int, int, ulong)""
+  IL_0015:  stloc.0
+  .try
+  {
+    // sequence point: <hidden>
+    IL_0016:  ldarg.0
+    IL_0017:  ldfld      ""int C.<>c.<<Main>b__0_0>d.<>1__state""
+    IL_001c:  stloc.1
+    .try
+    {
+      // sequence point: <hidden>
+      IL_001d:  ldloc.1
+      IL_001e:  brfalse.s  IL_0022
+      IL_0020:  br.s       IL_0024
+      IL_0022:  br.s       IL_0092
+      // sequence point: {
+      IL_0024:  ldloca.s   V_0
+      IL_0026:  ldarg.0
+      IL_0027:  ldfld      ""int C.<>c.<<Main>b__0_0>d.p""
+      IL_002c:  ldc.i4.0
+      IL_002d:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogParameterStore(uint, int)""
+      IL_0032:  nop
+      // sequence point: int a = p;
+      IL_0033:  ldloca.s   V_0
+      IL_0035:  ldarg.0
+      IL_0036:  ldarg.0
+      IL_0037:  ldfld      ""int C.<>c.<<Main>b__0_0>d.p""
+      IL_003c:  dup
+      IL_003d:  stloc.3
+      IL_003e:  stfld      ""int C.<>c.<<Main>b__0_0>d.<a>5__1""
+      IL_0043:  ldloc.3
+      IL_0044:  ldtoken    ""int C.<>c.<<Main>b__0_0>d.<a>5__1""
+      IL_0049:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+      IL_004e:  nop
+      IL_004f:  ldarg.0
+      IL_0050:  ldfld      ""int C.<>c.<<Main>b__0_0>d.<a>5__1""
+      IL_0055:  pop
+      // sequence point: return await Task.FromResult(1);
+      IL_0056:  ldc.i4.1
+      IL_0057:  call       ""System.Threading.Tasks.Task<int> System.Threading.Tasks.Task.FromResult<int>(int)""
+      IL_005c:  callvirt   ""System.Runtime.CompilerServices.TaskAwaiter<int> System.Threading.Tasks.Task<int>.GetAwaiter()""
+      IL_0061:  stloc.s    V_4
+      // sequence point: <hidden>
+      IL_0063:  ldloca.s   V_4
+      IL_0065:  call       ""bool System.Runtime.CompilerServices.TaskAwaiter<int>.IsCompleted.get""
+      IL_006a:  brtrue.s   IL_00af
+      IL_006c:  ldarg.0
+      IL_006d:  ldc.i4.0
+      IL_006e:  dup
+      IL_006f:  stloc.1
+      IL_0070:  stfld      ""int C.<>c.<<Main>b__0_0>d.<>1__state""
+      // async: yield
+      IL_0075:  ldarg.0
+      IL_0076:  ldloc.s    V_4
+      IL_0078:  stfld      ""System.Runtime.CompilerServices.TaskAwaiter<int> C.<>c.<<Main>b__0_0>d.<>u__1""
+      IL_007d:  ldarg.0
+      IL_007e:  stloc.s    V_5
+      IL_0080:  ldarg.0
+      IL_0081:  ldflda     ""System.Runtime.CompilerServices.AsyncTaskMethodBuilder<int> C.<>c.<<Main>b__0_0>d.<>t__builder""
+      IL_0086:  ldloca.s   V_4
+      IL_0088:  ldloca.s   V_5
+      IL_008a:  call       ""void System.Runtime.CompilerServices.AsyncTaskMethodBuilder<int>.AwaitUnsafeOnCompleted<System.Runtime.CompilerServices.TaskAwaiter<int>, C.<>c.<<Main>b__0_0>d>(ref System.Runtime.CompilerServices.TaskAwaiter<int>, ref C.<>c.<<Main>b__0_0>d)""
+      IL_008f:  nop
+      IL_0090:  leave.s    IL_00f4
+      // async: resume
+      IL_0092:  ldarg.0
+      IL_0093:  ldfld      ""System.Runtime.CompilerServices.TaskAwaiter<int> C.<>c.<<Main>b__0_0>d.<>u__1""
+      IL_0098:  stloc.s    V_4
+      IL_009a:  ldarg.0
+      IL_009b:  ldflda     ""System.Runtime.CompilerServices.TaskAwaiter<int> C.<>c.<<Main>b__0_0>d.<>u__1""
+      IL_00a0:  initobj    ""System.Runtime.CompilerServices.TaskAwaiter<int>""
+      IL_00a6:  ldarg.0
+      IL_00a7:  ldc.i4.m1
+      IL_00a8:  dup
+      IL_00a9:  stloc.1
+      IL_00aa:  stfld      ""int C.<>c.<<Main>b__0_0>d.<>1__state""
+      IL_00af:  ldarg.0
+      IL_00b0:  ldloca.s   V_4
+      IL_00b2:  call       ""int System.Runtime.CompilerServices.TaskAwaiter<int>.GetResult()""
+      IL_00b7:  stfld      ""int C.<>c.<<Main>b__0_0>d.<>s__2""
+      IL_00bc:  ldarg.0
+      IL_00bd:  ldfld      ""int C.<>c.<<Main>b__0_0>d.<>s__2""
+      IL_00c2:  stloc.2
+      IL_00c3:  leave.s    IL_00df
+    }
+    catch System.Exception
+    {
+      // sequence point: <hidden>
+      IL_00c5:  stloc.s    V_6
+      IL_00c7:  ldarg.0
+      IL_00c8:  ldc.i4.s   -2
+      IL_00ca:  stfld      ""int C.<>c.<<Main>b__0_0>d.<>1__state""
+      IL_00cf:  ldarg.0
+      IL_00d0:  ldflda     ""System.Runtime.CompilerServices.AsyncTaskMethodBuilder<int> C.<>c.<<Main>b__0_0>d.<>t__builder""
+      IL_00d5:  ldloc.s    V_6
+      IL_00d7:  call       ""void System.Runtime.CompilerServices.AsyncTaskMethodBuilder<int>.SetException(System.Exception)""
+      IL_00dc:  nop
+      IL_00dd:  leave.s    IL_00f4
+    }
+    // sequence point: }
+    IL_00df:  ldarg.0
+    IL_00e0:  ldc.i4.s   -2
+    IL_00e2:  stfld      ""int C.<>c.<<Main>b__0_0>d.<>1__state""
+    // sequence point: <hidden>
+    IL_00e7:  ldarg.0
+    IL_00e8:  ldflda     ""System.Runtime.CompilerServices.AsyncTaskMethodBuilder<int> C.<>c.<<Main>b__0_0>d.<>t__builder""
+    IL_00ed:  ldloc.2
+    IL_00ee:  call       ""void System.Runtime.CompilerServices.AsyncTaskMethodBuilder<int>.SetResult(int)""
+    IL_00f3:  nop
+    IL_00f4:  leave.s    IL_00ff
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_00f6:  ldloca.s   V_0
+    IL_00f8:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_00fd:  nop
+    IL_00fe:  endfinally
+  }
+  // sequence point: <hidden>
+  IL_00ff:  ret
+}
+");
+        }
+
+        [Fact]
+        public void StateMachine_LocalFunction_Iterator()
+        {
+            var source = WithHelpers(@"
+using System;
+using System.Collections.Generic;
+
+class C
+{
+    static void Main()
+    {
+        IEnumerable<int> f(int p)
+        {
+            int a = p;
+            yield return 1;       
+        }
+        
+        foreach (var n in M(f))
+        {
+        }
+    }
+
+    static IEnumerable<int> M(Func<int, IEnumerable<int>> p)
+        => p(2);
+}
+");
+
+            var verifier = CompileAndVerify(source, expectedOutput: @"
+Main: Entered
+M: Entered
+M: P'p'[0] = System.Func`2[System.Int32,System.Collections.Generic.IEnumerable`1[System.Int32]]
+M: Returned
+Main: Entered lambda '<Main>g__f|0_0' state machine #1
+<Main>g__f|0_0: P'p'[0] = 2
+<Main>g__f|0_0: L'a' = 2
+<Main>g__f|0_0: Returned
+Main: L2 = 1
+Main: Entered lambda '<Main>g__f|0_0' state machine #1
+<Main>g__f|0_0: Returned
+Main: Returned
+");
+
+            verifier.VerifyMethodBody("C.<<Main>g__f|0_0>d.System.Collections.IEnumerator.MoveNext()", @"
+{
+  // Code size      145 (0x91)
+  .maxstack  4
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0,
+                int V_1,
+                bool V_2,
+                int V_3)
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""void C.Main()""
+  IL_0005:  ldtoken    ""System.Collections.Generic.IEnumerable<int> C.<Main>g__f|0_0(int)""
+  IL_000a:  ldarg.0
+  IL_000b:  ldfld      ""ulong C.<<Main>g__f|0_0>d.<>I""
+  IL_0010:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogStateMachineLambdaEntry(int, int, ulong)""
+  IL_0015:  stloc.0
+  .try
+  {
+    // sequence point: <hidden>
+    IL_0016:  ldarg.0
+    IL_0017:  ldfld      ""int C.<<Main>g__f|0_0>d.<>1__state""
+    IL_001c:  stloc.1
+    IL_001d:  ldloc.1
+    IL_001e:  brfalse.s  IL_0028
+    IL_0020:  br.s       IL_0022
+    IL_0022:  ldloc.1
+    IL_0023:  ldc.i4.1
+    IL_0024:  beq.s      IL_002a
+    IL_0026:  br.s       IL_002c
+    IL_0028:  br.s       IL_0030
+    IL_002a:  br.s       IL_007b
+    IL_002c:  ldc.i4.0
+    IL_002d:  stloc.2
+    IL_002e:  leave.s    IL_008f
+    IL_0030:  ldarg.0
+    IL_0031:  ldc.i4.m1
+    IL_0032:  stfld      ""int C.<<Main>g__f|0_0>d.<>1__state""
+    // sequence point: {
+    IL_0037:  ldloca.s   V_0
+    IL_0039:  ldarg.0
+    IL_003a:  ldfld      ""int C.<<Main>g__f|0_0>d.p""
+    IL_003f:  ldc.i4.0
+    IL_0040:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogParameterStore(uint, int)""
+    IL_0045:  nop
+    // sequence point: int a = p;
+    IL_0046:  ldloca.s   V_0
+    IL_0048:  ldarg.0
+    IL_0049:  ldarg.0
+    IL_004a:  ldfld      ""int C.<<Main>g__f|0_0>d.p""
+    IL_004f:  dup
+    IL_0050:  stloc.3
+    IL_0051:  stfld      ""int C.<<Main>g__f|0_0>d.<a>5__1""
+    IL_0056:  ldloc.3
+    IL_0057:  ldtoken    ""int C.<<Main>g__f|0_0>d.<a>5__1""
+    IL_005c:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_0061:  nop
+    IL_0062:  ldarg.0
+    IL_0063:  ldfld      ""int C.<<Main>g__f|0_0>d.<a>5__1""
+    IL_0068:  pop
+    // sequence point: yield return 1;
+    IL_0069:  ldarg.0
+    IL_006a:  ldc.i4.1
+    IL_006b:  stfld      ""int C.<<Main>g__f|0_0>d.<>2__current""
+    IL_0070:  ldarg.0
+    IL_0071:  ldc.i4.1
+    IL_0072:  stfld      ""int C.<<Main>g__f|0_0>d.<>1__state""
+    IL_0077:  ldc.i4.1
+    IL_0078:  stloc.2
+    IL_0079:  leave.s    IL_008f
+    // sequence point: <hidden>
+    IL_007b:  ldarg.0
+    IL_007c:  ldc.i4.m1
+    IL_007d:  stfld      ""int C.<<Main>g__f|0_0>d.<>1__state""
+    // sequence point: }
+    IL_0082:  ldc.i4.0
+    IL_0083:  stloc.2
+    IL_0084:  leave.s    IL_008f
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_0086:  ldloca.s   V_0
+    IL_0088:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_008d:  nop
+    IL_008e:  endfinally
+  }
+  // sequence point: <hidden>
+  IL_008f:  ldloc.2
+  IL_0090:  ret
+}");
+        }
+
+        [Fact]
+        public void StateMachine_LocalFunction_AsyncIterator()
+        {
+            var source = WithHelpers(@"
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+class C
+{
+    static async Task Main()
+    {
+        async IAsyncEnumerable<int> f(int p)
+        {
+            await Task.FromResult(1);
+            int a = p;
+            yield return 1;       
+        }
+        
+        await foreach (var n in M(f))
+        {
+        }
+    }
+
+    static IAsyncEnumerable<int> M(Func<int, IAsyncEnumerable<int>> p)
+        => p(2);
+}
+");
+
+            var verifier = CompileAndVerify(source, expectedOutput: @"
+Main: Entered state machine #1
+M: Entered
+M: P'p'[0] = System.Func`2[System.Int32,System.Collections.Generic.IAsyncEnumerable`1[System.Int32]]
+M: Returned
+Main: Entered lambda '<Main>g__f|0_0' state machine #2
+<Main>g__f|0_0: P'p'[0] = 2
+<Main>g__f|0_0: L'a' = 2
+<Main>g__f|0_0: Returned
+Main: L'n' = 1
+Main: Entered lambda '<Main>g__f|0_0' state machine #2
+<Main>g__f|0_0: Returned
+Main: Returned
+");
+
+            verifier.VerifyMethodBody("C.<<Main>g__f|0_0>d.System.Runtime.CompilerServices.IAsyncStateMachine.MoveNext()", @"
+{
+  // Code size      391 (0x187)
+  .maxstack  4
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0,
+                int V_1,
+                System.Runtime.CompilerServices.TaskAwaiter<int> V_2,
+                C.<<Main>g__f|0_0>d V_3,
+                int V_4,
+                System.Exception V_5)
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""System.Threading.Tasks.Task C.Main()""
+  IL_0005:  ldtoken    ""System.Collections.Generic.IAsyncEnumerable<int> C.<Main>g__f|0_0(int)""
+  IL_000a:  ldarg.0
+  IL_000b:  ldfld      ""ulong C.<<Main>g__f|0_0>d.<>I""
+  IL_0010:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogStateMachineLambdaEntry(int, int, ulong)""
+  IL_0015:  stloc.0
+  .try
+  {
+    // sequence point: <hidden>
+    IL_0016:  ldarg.0
+    IL_0017:  ldfld      ""int C.<<Main>g__f|0_0>d.<>1__state""
+    IL_001c:  stloc.1
+    .try
+    {
+      // sequence point: <hidden>
+      IL_001d:  ldloc.1
+      IL_001e:  ldc.i4.s   -4
+      IL_0020:  sub
+      IL_0021:  switch    (
+        IL_003c,
+        IL_0041,
+        IL_0045,
+        IL_0045,
+        IL_0043)
+      IL_003a:  br.s       IL_0045
+      IL_003c:  br         IL_0102
+      IL_0041:  br.s       IL_0045
+      IL_0043:  br.s       IL_00a6
+      IL_0045:  ldarg.0
+      IL_0046:  ldfld      ""bool C.<<Main>g__f|0_0>d.<>w__disposeMode""
+      IL_004b:  brfalse.s  IL_0052
+      IL_004d:  leave      IL_0144
+      IL_0052:  ldarg.0
+      IL_0053:  ldc.i4.m1
+      IL_0054:  dup
+      IL_0055:  stloc.1
+      IL_0056:  stfld      ""int C.<<Main>g__f|0_0>d.<>1__state""
+      // sequence point: {
+      IL_005b:  ldloca.s   V_0
+      IL_005d:  ldarg.0
+      IL_005e:  ldfld      ""int C.<<Main>g__f|0_0>d.p""
+      IL_0063:  ldc.i4.0
+      IL_0064:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogParameterStore(uint, int)""
+      IL_0069:  nop
+      // sequence point: await Task.FromResult(1);
+      IL_006a:  ldc.i4.1
+      IL_006b:  call       ""System.Threading.Tasks.Task<int> System.Threading.Tasks.Task.FromResult<int>(int)""
+      IL_0070:  callvirt   ""System.Runtime.CompilerServices.TaskAwaiter<int> System.Threading.Tasks.Task<int>.GetAwaiter()""
+      IL_0075:  stloc.2
+      // sequence point: <hidden>
+      IL_0076:  ldloca.s   V_2
+      IL_0078:  call       ""bool System.Runtime.CompilerServices.TaskAwaiter<int>.IsCompleted.get""
+      IL_007d:  brtrue.s   IL_00c2
+      IL_007f:  ldarg.0
+      IL_0080:  ldc.i4.0
+      IL_0081:  dup
+      IL_0082:  stloc.1
+      IL_0083:  stfld      ""int C.<<Main>g__f|0_0>d.<>1__state""
+      // async: yield
+      IL_0088:  ldarg.0
+      IL_0089:  ldloc.2
+      IL_008a:  stfld      ""System.Runtime.CompilerServices.TaskAwaiter<int> C.<<Main>g__f|0_0>d.<>u__1""
+      IL_008f:  ldarg.0
+      IL_0090:  stloc.3
+      IL_0091:  ldarg.0
+      IL_0092:  ldflda     ""System.Runtime.CompilerServices.AsyncIteratorMethodBuilder C.<<Main>g__f|0_0>d.<>t__builder""
+      IL_0097:  ldloca.s   V_2
+      IL_0099:  ldloca.s   V_3
+      IL_009b:  call       ""void System.Runtime.CompilerServices.AsyncIteratorMethodBuilder.AwaitUnsafeOnCompleted<System.Runtime.CompilerServices.TaskAwaiter<int>, C.<<Main>g__f|0_0>d>(ref System.Runtime.CompilerServices.TaskAwaiter<int>, ref C.<<Main>g__f|0_0>d)""
+      IL_00a0:  nop
+      IL_00a1:  leave      IL_017b
+      // async: resume
+      IL_00a6:  ldarg.0
+      IL_00a7:  ldfld      ""System.Runtime.CompilerServices.TaskAwaiter<int> C.<<Main>g__f|0_0>d.<>u__1""
+      IL_00ac:  stloc.2
+      IL_00ad:  ldarg.0
+      IL_00ae:  ldflda     ""System.Runtime.CompilerServices.TaskAwaiter<int> C.<<Main>g__f|0_0>d.<>u__1""
+      IL_00b3:  initobj    ""System.Runtime.CompilerServices.TaskAwaiter<int>""
+      IL_00b9:  ldarg.0
+      IL_00ba:  ldc.i4.m1
+      IL_00bb:  dup
+      IL_00bc:  stloc.1
+      IL_00bd:  stfld      ""int C.<<Main>g__f|0_0>d.<>1__state""
+      IL_00c2:  ldloca.s   V_2
+      IL_00c4:  call       ""int System.Runtime.CompilerServices.TaskAwaiter<int>.GetResult()""
+      IL_00c9:  pop
+      // sequence point: int a = p;
+      IL_00ca:  ldloca.s   V_0
+      IL_00cc:  ldarg.0
+      IL_00cd:  ldarg.0
+      IL_00ce:  ldfld      ""int C.<<Main>g__f|0_0>d.p""
+      IL_00d3:  dup
+      IL_00d4:  stloc.s    V_4
+      IL_00d6:  stfld      ""int C.<<Main>g__f|0_0>d.<a>5__1""
+      IL_00db:  ldloc.s    V_4
+      IL_00dd:  ldtoken    ""int C.<<Main>g__f|0_0>d.<a>5__1""
+      IL_00e2:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+      IL_00e7:  nop
+      IL_00e8:  ldarg.0
+      IL_00e9:  ldfld      ""int C.<<Main>g__f|0_0>d.<a>5__1""
+      IL_00ee:  pop
+      // sequence point: yield return 1;
+      IL_00ef:  ldarg.0
+      IL_00f0:  ldc.i4.1
+      IL_00f1:  stfld      ""int C.<<Main>g__f|0_0>d.<>2__current""
+      IL_00f6:  ldarg.0
+      IL_00f7:  ldc.i4.s   -4
+      IL_00f9:  dup
+      IL_00fa:  stloc.1
+      IL_00fb:  stfld      ""int C.<<Main>g__f|0_0>d.<>1__state""
+      IL_0100:  leave.s    IL_016e
+      // sequence point: <hidden>
+      IL_0102:  ldarg.0
+      IL_0103:  ldc.i4.m1
+      IL_0104:  dup
+      IL_0105:  stloc.1
+      IL_0106:  stfld      ""int C.<<Main>g__f|0_0>d.<>1__state""
+      IL_010b:  ldarg.0
+      IL_010c:  ldfld      ""bool C.<<Main>g__f|0_0>d.<>w__disposeMode""
+      IL_0111:  brfalse.s  IL_0115
+      IL_0113:  leave.s    IL_0144
+      // sequence point: <hidden>
+      IL_0115:  leave.s    IL_0144
+    }
+    catch System.Exception
+    {
+      // sequence point: <hidden>
+      IL_0117:  stloc.s    V_5
+      IL_0119:  ldarg.0
+      IL_011a:  ldc.i4.s   -2
+      IL_011c:  stfld      ""int C.<<Main>g__f|0_0>d.<>1__state""
+      IL_0121:  ldarg.0
+      IL_0122:  ldc.i4.0
+      IL_0123:  stfld      ""int C.<<Main>g__f|0_0>d.<>2__current""
+      IL_0128:  ldarg.0
+      IL_0129:  ldflda     ""System.Runtime.CompilerServices.AsyncIteratorMethodBuilder C.<<Main>g__f|0_0>d.<>t__builder""
+      IL_012e:  call       ""void System.Runtime.CompilerServices.AsyncIteratorMethodBuilder.Complete()""
+      IL_0133:  nop
+      IL_0134:  ldarg.0
+      IL_0135:  ldflda     ""System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore<bool> C.<<Main>g__f|0_0>d.<>v__promiseOfValueOrEnd""
+      IL_013a:  ldloc.s    V_5
+      IL_013c:  call       ""void System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore<bool>.SetException(System.Exception)""
+      IL_0141:  nop
+      IL_0142:  leave.s    IL_017b
+    }
+    // sequence point: }
+    IL_0144:  ldarg.0
+    IL_0145:  ldc.i4.s   -2
+    IL_0147:  stfld      ""int C.<<Main>g__f|0_0>d.<>1__state""
+    // sequence point: <hidden>
+    IL_014c:  ldarg.0
+    IL_014d:  ldc.i4.0
+    IL_014e:  stfld      ""int C.<<Main>g__f|0_0>d.<>2__current""
+    IL_0153:  ldarg.0
+    IL_0154:  ldflda     ""System.Runtime.CompilerServices.AsyncIteratorMethodBuilder C.<<Main>g__f|0_0>d.<>t__builder""
+    IL_0159:  call       ""void System.Runtime.CompilerServices.AsyncIteratorMethodBuilder.Complete()""
+    IL_015e:  nop
+    IL_015f:  ldarg.0
+    IL_0160:  ldflda     ""System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore<bool> C.<<Main>g__f|0_0>d.<>v__promiseOfValueOrEnd""
+    IL_0165:  ldc.i4.0
+    IL_0166:  call       ""void System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore<bool>.SetResult(bool)""
+    IL_016b:  nop
+    IL_016c:  leave.s    IL_0186
+    IL_016e:  ldarg.0
+    IL_016f:  ldflda     ""System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore<bool> C.<<Main>g__f|0_0>d.<>v__promiseOfValueOrEnd""
+    IL_0174:  ldc.i4.1
+    IL_0175:  call       ""void System.Threading.Tasks.Sources.ManualResetValueTaskSourceCore<bool>.SetResult(bool)""
+    IL_017a:  nop
+    IL_017b:  leave.s    IL_0186
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_017d:  ldloca.s   V_0
+    IL_017f:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_0184:  nop
+    IL_0185:  endfinally
+  }
+  // sequence point: <hidden>
+  IL_0186:  ret
+}");
+        }
+
+        [Fact]
+        public void LocalFunctions()
+        {
+            var source = WithHelpers(@"
+using System;
+
+class C
+{
+    static void Main()
+    {
+        int a = 1;
+        {
+            int b = 2;
+            {
+                int c = 3;
+                int f() => c += 1;
+                f();
+            }
+
+            int g() => a += b;
+            g();
+        }
+    }
+}
+");
+
+            var verifier = CompileAndVerify(source, expectedOutput: @"
+Main: Entered
+Main: L'a' = 1
+Main: L'b' = 2
+Main: L'c' = 3
+Main: Entered lambda '<Main>g__f|0_1'
+<Main>g__f|0_1: L'c' = 4
+<Main>g__f|0_1: Returned
+Main: Entered lambda '<Main>g__g|0_0'
+<Main>g__g|0_0: L'a' = 3
+<Main>g__g|0_0: Returned
+Main: Returned
+");
+
+            verifier.VerifyMethodBody("C.<Main>g__f|0_1", @"
+{
+  // Code size       66 (0x42)
+  .maxstack  4
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0,
+                int V_1,
+                int V_2)
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""void C.Main()""
+  IL_0005:  ldtoken    ""int C.<Main>g__f|0_1(ref C.<>c__DisplayClass0_2)""
+  IL_000a:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLambdaEntry(int, int)""
+  IL_000f:  stloc.0
+  .try
+  {
+    // sequence point: c += 1
+    IL_0010:  ldloca.s   V_0
+    IL_0012:  ldarg.0
+    IL_0013:  ldarg.0
+    IL_0014:  ldfld      ""int C.<>c__DisplayClass0_2.c""
+    IL_0019:  ldc.i4.1
+    IL_001a:  add
+    IL_001b:  dup
+    IL_001c:  stloc.1
+    IL_001d:  stfld      ""int C.<>c__DisplayClass0_2.c""
+    IL_0022:  ldloc.1
+    IL_0023:  ldtoken    ""int C.<>c__DisplayClass0_2.c""
+    IL_0028:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_002d:  nop
+    IL_002e:  ldarg.0
+    IL_002f:  ldfld      ""int C.<>c__DisplayClass0_2.c""
+    IL_0034:  stloc.2
+    IL_0035:  leave.s    IL_0040
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_0037:  ldloca.s   V_0
+    IL_0039:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_003e:  nop
+    IL_003f:  endfinally
+  }
+  // sequence point: <hidden>
+  IL_0040:  ldloc.2
+  IL_0041:  ret
+}
+");
+            verifier.VerifyMethodBody("C.<Main>g__g|0_0", @"
+{
+  // Code size       71 (0x47)
+  .maxstack  4
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0,
+                int V_1,
+                int V_2)
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""void C.Main()""
+  IL_0005:  ldtoken    ""int C.<Main>g__g|0_0(ref C.<>c__DisplayClass0_0, ref C.<>c__DisplayClass0_1)""
+  IL_000a:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLambdaEntry(int, int)""
+  IL_000f:  stloc.0
+  .try
+  {
+    // sequence point: a += b
+    IL_0010:  ldloca.s   V_0
+    IL_0012:  ldarg.0
+    IL_0013:  ldarg.0
+    IL_0014:  ldfld      ""int C.<>c__DisplayClass0_0.a""
+    IL_0019:  ldarg.1
+    IL_001a:  ldfld      ""int C.<>c__DisplayClass0_1.b""
+    IL_001f:  add
+    IL_0020:  dup
+    IL_0021:  stloc.1
+    IL_0022:  stfld      ""int C.<>c__DisplayClass0_0.a""
+    IL_0027:  ldloc.1
+    IL_0028:  ldtoken    ""int C.<>c__DisplayClass0_0.a""
+    IL_002d:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_0032:  nop
+    IL_0033:  ldarg.0
+    IL_0034:  ldfld      ""int C.<>c__DisplayClass0_0.a""
+    IL_0039:  stloc.2
+    IL_003a:  leave.s    IL_0045
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_003c:  ldloca.s   V_0
+    IL_003e:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_0043:  nop
+    IL_0044:  endfinally
+  }
+  // sequence point: <hidden>
+  IL_0045:  ldloc.2
+  IL_0046:  ret
+}");
+            verifier.VerifyMethodBody("C.Main", @"
+{
+  // Code size      120 (0x78)
+  .maxstack  4
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0,
+                C.<>c__DisplayClass0_0 V_1, //CS$<>8__locals0
+                int V_2,
+                C.<>c__DisplayClass0_1 V_3, //CS$<>8__locals1
+                C.<>c__DisplayClass0_2 V_4) //CS$<>8__locals2
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""void C.Main()""
+  IL_0005:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogMethodEntry(int)""
+  IL_000a:  stloc.0
+  .try
+  {
+    // sequence point: {
+    IL_000b:  nop
+    // sequence point: int a = 1;
+    IL_000c:  ldloca.s   V_0
+    IL_000e:  ldloca.s   V_1
+    IL_0010:  ldc.i4.1
+    IL_0011:  dup
+    IL_0012:  stloc.2
+    IL_0013:  stfld      ""int C.<>c__DisplayClass0_0.a""
+    IL_0018:  ldloc.2
+    IL_0019:  ldtoken    ""int C.<>c__DisplayClass0_0.a""
+    IL_001e:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_0023:  nop
+    // sequence point: {
+    IL_0024:  nop
+    // sequence point: int b = 2;
+    IL_0025:  ldloca.s   V_0
+    IL_0027:  ldloca.s   V_3
+    IL_0029:  ldc.i4.2
+    IL_002a:  dup
+    IL_002b:  stloc.2
+    IL_002c:  stfld      ""int C.<>c__DisplayClass0_1.b""
+    IL_0031:  ldloc.2
+    IL_0032:  ldtoken    ""int C.<>c__DisplayClass0_1.b""
+    IL_0037:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_003c:  nop
+    // sequence point: {
+    IL_003d:  nop
+    // sequence point: int c = 3;
+    IL_003e:  ldloca.s   V_0
+    IL_0040:  ldloca.s   V_4
+    IL_0042:  ldc.i4.3
+    IL_0043:  dup
+    IL_0044:  stloc.2
+    IL_0045:  stfld      ""int C.<>c__DisplayClass0_2.c""
+    IL_004a:  ldloc.2
+    IL_004b:  ldtoken    ""int C.<>c__DisplayClass0_2.c""
+    IL_0050:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_0055:  nop
+    IL_0056:  nop
+    // sequence point: f();
+    IL_0057:  ldloca.s   V_4
+    IL_0059:  call       ""int C.<Main>g__f|0_1(ref C.<>c__DisplayClass0_2)""
+    IL_005e:  pop
+    // sequence point: }
+    IL_005f:  nop
+    IL_0060:  nop
+    // sequence point: g();
+    IL_0061:  ldloca.s   V_1
+    IL_0063:  ldloca.s   V_3
+    IL_0065:  call       ""int C.<Main>g__g|0_0(ref C.<>c__DisplayClass0_0, ref C.<>c__DisplayClass0_1)""
+    IL_006a:  pop
+    // sequence point: }
+    IL_006b:  nop
+    // sequence point: }
+    IL_006c:  leave.s    IL_0077
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_006e:  ldloca.s   V_0
+    IL_0070:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_0075:  nop
+    IL_0076:  endfinally
+  }
+  // sequence point: }
+  IL_0077:  ret
+}
+");
+        }
+
+        [Fact]
+        public void Queries()
+        {
+            var source = WithHelpers(@"
+using System;
+using System.Linq;
+
+class C
+{
+    static void Main()
+    {
+        int a = 1;
+        {
+            int b = 2;
+            var x = from item in new[] { 10, 20 }
+                    let c = a + b
+                    select item + (a = b);
+            x.ToArray();
+        }
+    }
+}
+");
+
+            var verifier = CompileAndVerify(source, expectedOutput: @"
+Main: Entered
+Main: L'a' = 1
+Main: L'b' = 2
+Main: L4 = System.Linq.Enumerable+SelectArrayIterator`2[System.Int32,System.Int32]
+Main: Entered lambda '<Main>b__0'
+<Main>b__0: P'item'[0] = 10
+<Main>b__0: Returned
+Main: Entered lambda '<Main>b__1'
+<Main>b__1: P'<>h__TransparentIdentifier0'[0] = { item = 10, c = 3 }
+<Main>b__1: L'a' = 2
+<Main>b__1: Returned
+Main: Entered lambda '<Main>b__0'
+<Main>b__0: P'item'[0] = 20
+<Main>b__0: Returned
+Main: Entered lambda '<Main>b__1'
+<Main>b__1: P'<>h__TransparentIdentifier0'[0] = { item = 20, c = 4 }
+<Main>b__1: L'a' = 2
+<Main>b__1: Returned
+Main: Returned
+");
+
+            verifier.VerifyMethodBody("C.<>c__DisplayClass0_1.<Main>b__1", @"
+ {
+  // Code size       91 (0x5b)
+  .maxstack  5
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0,
+                int V_1,
+                int V_2)
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""void C.Main()""
+  IL_0005:  ldtoken    ""int C.<>c__DisplayClass0_1.<Main>b__1(<anonymous type: int item, int c>)""
+  IL_000a:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLambdaEntry(int, int)""
+  IL_000f:  stloc.0
+  .try
+  {
+    IL_0010:  ldloca.s   V_0
+    IL_0012:  ldarg.1
+    IL_0013:  ldc.i4.0
+    IL_0014:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogParameterStore(object, int)""
+    IL_0019:  nop
+    // sequence point: item + (a = b)
+    IL_001a:  ldarg.1
+    IL_001b:  callvirt   ""int <>f__AnonymousType0<int, int>.item.get""
+    IL_0020:  ldloca.s   V_0
+    IL_0022:  ldarg.0
+    IL_0023:  ldfld      ""C.<>c__DisplayClass0_0 C.<>c__DisplayClass0_1.CS$<>8__locals1""
+    IL_0028:  ldarg.0
+    IL_0029:  ldfld      ""int C.<>c__DisplayClass0_1.b""
+    IL_002e:  dup
+    IL_002f:  stloc.1
+    IL_0030:  stfld      ""int C.<>c__DisplayClass0_0.a""
+    IL_0035:  ldloc.1
+    IL_0036:  ldtoken    ""int C.<>c__DisplayClass0_0.a""
+    IL_003b:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_0040:  nop
+    IL_0041:  ldarg.0
+    IL_0042:  ldfld      ""C.<>c__DisplayClass0_0 C.<>c__DisplayClass0_1.CS$<>8__locals1""
+    IL_0047:  ldfld      ""int C.<>c__DisplayClass0_0.a""
+    IL_004c:  add
+    IL_004d:  stloc.2
+    IL_004e:  leave.s    IL_0059
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_0050:  ldloca.s   V_0
+    IL_0052:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_0057:  nop
+    IL_0058:  endfinally
+  }
+  // sequence point: <hidden>
+  IL_0059:  ldloc.2
+  IL_005a:  ret
+}");
+
+            verifier.VerifyMethodBody("C.<>c__DisplayClass0_1.<Main>b__0", @"
+{
+  // Code size       64 (0x40)
+  .maxstack  3
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0,
+                <>f__AnonymousType0<int, int> V_1)
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""void C.Main()""
+  IL_0005:  ldtoken    ""<anonymous type: int item, int c> C.<>c__DisplayClass0_1.<Main>b__0(int)""
+  IL_000a:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLambdaEntry(int, int)""
+  IL_000f:  stloc.0
+  .try
+  {
+    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: a + b
+    IL_001a:  ldarg.1
+    IL_001b:  ldarg.0
+    IL_001c:  ldfld      ""C.<>c__DisplayClass0_0 C.<>c__DisplayClass0_1.CS$<>8__locals1""
+    IL_0021:  ldfld      ""int C.<>c__DisplayClass0_0.a""
+    IL_0026:  ldarg.0
+    IL_0027:  ldfld      ""int C.<>c__DisplayClass0_1.b""
+    IL_002c:  add
+    IL_002d:  newobj     ""<>f__AnonymousType0<int, int>..ctor(int, int)""
+    IL_0032:  stloc.1
+    IL_0033:  leave.s    IL_003e
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_0035:  ldloca.s   V_0
+    IL_0037:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_003c:  nop
+    IL_003d:  endfinally
+  }
+  // sequence point: <hidden>
+  IL_003e:  ldloc.1
+  IL_003f:  ret
+}");
+        }
+
+        [Fact]
+        public void ExpressionLambdas()
+        {
+            var source = WithHelpers(@"
+using System;
+using System.Linq.Expressions;
+
+Expression<Func<int, int>> expression = a => a + 1;
+");
+            var verifier = CompileAndVerify(source, expectedOutput: @"
+<Main>$: Entered
+<Main>$: P'args'[0] = System.String[]
+<Main>$: L1 = a => (a + 1)
+<Main>$: Returned
+");
+            verifier.VerifyMethodBody("<top-level-statements-entry-point>", @"
+{
+  // Code size      107 (0x6b)
+  .maxstack  6
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0,
+                System.Linq.Expressions.Expression<System.Func<int, int>> V_1, //expression
+                System.Linq.Expressions.ParameterExpression V_2)
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""<top-level-statements-entry-point>""
+  IL_0005:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogMethodEntry(int)""
+  IL_000a:  stloc.0
+  .try
+  {
+    // sequence point: <hidden>
+    IL_000b:  ldloca.s   V_0
+    IL_000d:  ldarg.0
+    IL_000e:  ldc.i4.0
+    IL_000f:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogParameterStore(object, int)""
+    IL_0014:  nop
+    // sequence point: Expression<Func<int, int>> expression = a => a + 1;
+    IL_0015:  ldloca.s   V_0
+    IL_0017:  ldtoken    ""int""
+    IL_001c:  call       ""System.Type System.Type.GetTypeFromHandle(System.RuntimeTypeHandle)""
+    IL_0021:  ldstr      ""a""
+    IL_0026:  call       ""System.Linq.Expressions.ParameterExpression System.Linq.Expressions.Expression.Parameter(System.Type, string)""
+    IL_002b:  stloc.2
+    IL_002c:  ldloc.2
+    IL_002d:  ldc.i4.1
+    IL_002e:  box        ""int""
+    IL_0033:  ldtoken    ""int""
+    IL_0038:  call       ""System.Type System.Type.GetTypeFromHandle(System.RuntimeTypeHandle)""
+    IL_003d:  call       ""System.Linq.Expressions.ConstantExpression System.Linq.Expressions.Expression.Constant(object, System.Type)""
+    IL_0042:  call       ""System.Linq.Expressions.BinaryExpression System.Linq.Expressions.Expression.Add(System.Linq.Expressions.Expression, System.Linq.Expressions.Expression)""
+    IL_0047:  ldc.i4.1
+    IL_0048:  newarr     ""System.Linq.Expressions.ParameterExpression""
+    IL_004d:  dup
+    IL_004e:  ldc.i4.0
+    IL_004f:  ldloc.2
+    IL_0050:  stelem.ref
+    IL_0051:  call       ""System.Linq.Expressions.Expression<System.Func<int, int>> System.Linq.Expressions.Expression.Lambda<System.Func<int, int>>(System.Linq.Expressions.Expression, params System.Linq.Expressions.ParameterExpression[])""
+    IL_0056:  dup
+    IL_0057:  stloc.1
+    IL_0058:  ldc.i4.1
+    IL_0059:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(object, int)""
+    IL_005e:  nop
+    IL_005f:  leave.s    IL_006a
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_0061:  ldloca.s   V_0
+    IL_0063:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_0068:  nop
+    IL_0069:  endfinally
+  }
+  // sequence point: <hidden>
+  IL_006a:  ret
+}
+");
+        }
+
+        [Fact]
+        public void TopLevelCode()
+        {
+            var source = WithHelpers(@"
+int a = 1;
+int b = 2;
+");
+            var verifier = CompileAndVerify(source, expectedOutput: @"
+<Main>$: Entered
+<Main>$: P'args'[0] = System.String[]
+<Main>$: L1 = 1
+<Main>$: L2 = 2
+<Main>$: Returned
+");
+            verifier.VerifyMethodBody("<top-level-statements-entry-point>", @"
+{
+  // Code size       57 (0x39)
+  .maxstack  3
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0,
+                int V_1, //a
+                int V_2) //b
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""<top-level-statements-entry-point>""
+  IL_0005:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogMethodEntry(int)""
+  IL_000a:  stloc.0
+  .try
+  {
+    // sequence point: <hidden>
+    IL_000b:  ldloca.s   V_0
+    IL_000d:  ldarg.0
+    IL_000e:  ldc.i4.0
+    IL_000f:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogParameterStore(object, int)""
+    IL_0014:  nop
+    // sequence point: int a = 1;
+    IL_0015:  ldloca.s   V_0
+    IL_0017:  ldc.i4.1
+    IL_0018:  dup
+    IL_0019:  stloc.1
+    IL_001a:  ldc.i4.1
+    IL_001b:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_0020:  nop
+    // sequence point: int b = 2;
+    IL_0021:  ldloca.s   V_0
+    IL_0023:  ldc.i4.2
+    IL_0024:  dup
+    IL_0025:  stloc.2
+    IL_0026:  ldc.i4.2
+    IL_0027:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(uint, int)""
+    IL_002c:  nop
+    IL_002d:  leave.s    IL_0038
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_002f:  ldloca.s   V_0
+    IL_0031:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_0036:  nop
+    IL_0037:  endfinally
+  }
+  // sequence point: <hidden>
+  IL_0038:  ret
+}
+");
+        }
+
+        [Fact]
+        public void ExceptionHandler_CatchAll()
+        {
+            var source = WithHelpers(@"
+class C
+{
+    static void Main(string[] args)
+    {
+        string s;
+        try
+        {
+            s = args[0];
+        }
+        catch
+        {
+            s = ""error"";
+        }
+    }
+}
+");
+            var verifier = CompileAndVerify(source, expectedOutput: @"
+Main: Entered
+Main: P'args'[0] = System.String[]
+Main: L1 = error
+Main: Returned
+");
+
+            verifier.VerifyMethodBody("C.Main", @"
+ {
+  // Code size       72 (0x48)
+  .maxstack  3
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0,
+                string V_1) //s
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""void C.Main(string[])""
+  IL_0005:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogMethodEntry(int)""
+  IL_000a:  stloc.0
+  .try
+  {
+    // sequence point: {
+    IL_000b:  ldloca.s   V_0
+    IL_000d:  ldarg.0
+    IL_000e:  ldc.i4.0
+    IL_000f:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogParameterStore(object, int)""
+    IL_0014:  nop
+    .try
+    {
+      // sequence point: {
+      IL_0015:  nop
+      // sequence point: s = args[0];
+      IL_0016:  ldloca.s   V_0
+      IL_0018:  ldarg.0
+      IL_0019:  ldc.i4.0
+      IL_001a:  ldelem.ref
+      IL_001b:  dup
+      IL_001c:  stloc.1
+      IL_001d:  ldc.i4.1
+      IL_001e:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(string, int)""
+      IL_0023:  nop
+      // sequence point: }
+      IL_0024:  nop
+      IL_0025:  leave.s    IL_003c
+    }
+    catch object
+    {
+      // sequence point: catch
+      IL_0027:  pop
+      // sequence point: {
+      IL_0028:  nop
+      // sequence point: s = ""error"";
+      IL_0029:  ldloca.s   V_0
+      IL_002b:  ldstr      ""error""
+      IL_0030:  dup
+      IL_0031:  stloc.1
+      IL_0032:  ldc.i4.1
+      IL_0033:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(string, int)""
+      IL_0038:  nop
+      // sequence point: }
+      IL_0039:  nop
+      IL_003a:  leave.s    IL_003c
+    }
+    // sequence point: }
+    IL_003c:  leave.s    IL_0047
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_003e:  ldloca.s   V_0
+    IL_0040:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_0045:  nop
+    IL_0046:  endfinally
+  }
+  // sequence point: }
+  IL_0047:  ret
+}");
+        }
+
+        [Fact]
+        public void ExceptionHandler_CatchType()
+        {
+            var source = WithHelpers(@"
+class C
+{
+    static void Main(string[] args)
+    {
+        string s;
+        try
+        {
+            s = args[0];
+        }
+        catch (System.Exception)
+        {
+            s = ""error"";
+        }
+    }
+}
+");
+            var verifier = CompileAndVerify(source);
+
+            verifier.VerifyMethodBody("C.Main", @"
+{
+  // Code size       72 (0x48)
+  .maxstack  3
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0,
+                string V_1) //s
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""void C.Main(string[])""
+  IL_0005:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogMethodEntry(int)""
+  IL_000a:  stloc.0
+  .try
+  {
+    // sequence point: {
+    IL_000b:  ldloca.s   V_0
+    IL_000d:  ldarg.0
+    IL_000e:  ldc.i4.0
+    IL_000f:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogParameterStore(object, int)""
+    IL_0014:  nop
+    .try
+    {
+      // sequence point: {
+      IL_0015:  nop
+      // sequence point: s = args[0];
+      IL_0016:  ldloca.s   V_0
+      IL_0018:  ldarg.0
+      IL_0019:  ldc.i4.0
+      IL_001a:  ldelem.ref
+      IL_001b:  dup
+      IL_001c:  stloc.1
+      IL_001d:  ldc.i4.1
+      IL_001e:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(string, int)""
+      IL_0023:  nop
+      // sequence point: }
+      IL_0024:  nop
+      IL_0025:  leave.s    IL_003c
+    }
+    catch System.Exception
+    {
+      // sequence point: catch (System.Exception)
+      IL_0027:  pop
+      // sequence point: {
+      IL_0028:  nop
+      // sequence point: s = ""error"";
+      IL_0029:  ldloca.s   V_0
+      IL_002b:  ldstr      ""error""
+      IL_0030:  dup
+      IL_0031:  stloc.1
+      IL_0032:  ldc.i4.1
+      IL_0033:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(string, int)""
+      IL_0038:  nop
+      // sequence point: }
+      IL_0039:  nop
+      IL_003a:  leave.s    IL_003c
+    }
+    // sequence point: }
+    IL_003c:  leave.s    IL_0047
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_003e:  ldloca.s   V_0
+    IL_0040:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_0045:  nop
+    IL_0046:  endfinally
+  }
+  // sequence point: }
+  IL_0047:  ret
+}");
+        }
+
+        [Fact]
+        public void ExceptionHandler_CatchTypeWithVariable()
+        {
+            var source = WithHelpers(@"
+class C
+{
+    static void Main(string[] args)
+    {
+        string s;
+        try
+        {
+            s = args[0];
+        }
+        catch (System.Exception e)
+        {
+            s = ""error"";
+        }
+    }
+}
+");
+            var verifier = CompileAndVerify(source, expectedOutput: @"
+Main: Entered
+Main: P'args'[0] = System.String[]
+Main: L2 = System.IndexOutOfRangeException: Index was outside the bounds of the array.
+   at C.Main(String[] args)
+Main: L1 = error
+Main: Returned
+");
+
+            verifier.VerifyMethodBody("C.Main", @"
+{
+  // Code size       82 (0x52)
+  .maxstack  3
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0,
+                string V_1, //s
+                System.Exception V_2) //e
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""void C.Main(string[])""
+  IL_0005:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogMethodEntry(int)""
+  IL_000a:  stloc.0
+  .try
+  {
+    // sequence point: {
+    IL_000b:  ldloca.s   V_0
+    IL_000d:  ldarg.0
+    IL_000e:  ldc.i4.0
+    IL_000f:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogParameterStore(object, int)""
+    IL_0014:  nop
+    .try
+    {
+      // sequence point: {
+      IL_0015:  nop
+      // sequence point: s = args[0];
+      IL_0016:  ldloca.s   V_0
+      IL_0018:  ldarg.0
+      IL_0019:  ldc.i4.0
+      IL_001a:  ldelem.ref
+      IL_001b:  dup
+      IL_001c:  stloc.1
+      IL_001d:  ldc.i4.1
+      IL_001e:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(string, int)""
+      IL_0023:  nop
+      // sequence point: }
+      IL_0024:  nop
+      IL_0025:  leave.s    IL_0046
+    }
+    catch System.Exception
+    {
+      // sequence point: catch (System.Exception e)
+      IL_0027:  stloc.2
+      IL_0028:  ldloca.s   V_0
+      IL_002a:  ldloc.2
+      IL_002b:  ldc.i4.2
+      IL_002c:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(object, int)""
+      IL_0031:  nop
+      // sequence point: {
+      IL_0032:  nop
+      // sequence point: s = ""error"";
+      IL_0033:  ldloca.s   V_0
+      IL_0035:  ldstr      ""error""
+      IL_003a:  dup
+      IL_003b:  stloc.1
+      IL_003c:  ldc.i4.1
+      IL_003d:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(string, int)""
+      IL_0042:  nop
+      // sequence point: }
+      IL_0043:  nop
+      IL_0044:  leave.s    IL_0046
+    }
+    // sequence point: }
+    IL_0046:  leave.s    IL_0051
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_0048:  ldloca.s   V_0
+    IL_004a:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_004f:  nop
+    IL_0050:  endfinally
+  }
+  // sequence point: }
+  IL_0051:  ret
+}
+");
+        }
+
+        [Fact]
+        public void ExceptionHandler_CatchTypeWithFilter()
+        {
+            var source = WithHelpers(@"
+class C
+{
+    static void Main(string[] args)
+    {
+        bool b = false;
+        string s;
+        try
+        {
+            s = args[0];
+        }
+        catch (System.Exception e) when (b = true)
+        {
+            s = ""error"";
+        }
+    }
+}
+");
+            var verifier = CompileAndVerify(source, expectedOutput: @"
+Main: Entered
+Main: P'args'[0] = System.String[]
+Main: L1 = False
+Main: L3 = System.IndexOutOfRangeException: Index was outside the bounds of the array.
+   at C.Main(String[] args)
+Main: L1 = True
+Main: L2 = error
+Main: Returned
+");
+
+            verifier.VerifyMethodBody("C.Main", @"
+{
+  // Code size      129 (0x81)
+  .maxstack  3
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0,
+                bool V_1, //b
+                string V_2, //s
+                System.Exception V_3, //e
+                bool V_4)
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""void C.Main(string[])""
+  IL_0005:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogMethodEntry(int)""
+  IL_000a:  stloc.0
+  .try
+  {
+    // sequence point: {
+    IL_000b:  ldloca.s   V_0
+    IL_000d:  ldarg.0
+    IL_000e:  ldc.i4.0
+    IL_000f:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogParameterStore(object, int)""
+    IL_0014:  nop
+    // sequence point: bool b = false;
+    IL_0015:  ldloca.s   V_0
+    IL_0017:  ldc.i4.0
+    IL_0018:  dup
+    IL_0019:  stloc.1
+    IL_001a:  ldc.i4.1
+    IL_001b:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(bool, int)""
+    IL_0020:  nop
+    .try
+    {
+      // sequence point: {
+      IL_0021:  nop
+      // sequence point: s = args[0];
+      IL_0022:  ldloca.s   V_0
+      IL_0024:  ldarg.0
+      IL_0025:  ldc.i4.0
+      IL_0026:  ldelem.ref
+      IL_0027:  dup
+      IL_0028:  stloc.2
+      IL_0029:  ldc.i4.2
+      IL_002a:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(string, int)""
+      IL_002f:  nop
+      // sequence point: }
+      IL_0030:  nop
+      IL_0031:  leave.s    IL_0075
+    }
+    filter
+    {
+      // sequence point: <hidden>
+      IL_0033:  isinst     ""System.Exception""
+      IL_0038:  dup
+      IL_0039:  brtrue.s   IL_003f
+      IL_003b:  pop
+      IL_003c:  ldc.i4.0
+      IL_003d:  br.s       IL_005e
+      IL_003f:  stloc.3
+      IL_0040:  ldloca.s   V_0
+      IL_0042:  ldloc.3
+      IL_0043:  ldc.i4.3
+      IL_0044:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(object, int)""
+      IL_0049:  nop
+      // sequence point: when (b = true)
+      IL_004a:  ldloca.s   V_0
+      IL_004c:  ldc.i4.1
+      IL_004d:  dup
+      IL_004e:  stloc.1
+      IL_004f:  ldc.i4.1
+      IL_0050:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(bool, int)""
+      IL_0055:  nop
+      IL_0056:  ldloc.1
+      IL_0057:  stloc.s    V_4
+      // sequence point: <hidden>
+      IL_0059:  ldloc.s    V_4
+      IL_005b:  ldc.i4.0
+      IL_005c:  cgt.un
+      IL_005e:  endfilter
+    }  // end filter
+    {  // handler
+      // sequence point: <hidden>
+      IL_0060:  pop
+      // sequence point: {
+      IL_0061:  nop
+      // sequence point: s = ""error"";
+      IL_0062:  ldloca.s   V_0
+      IL_0064:  ldstr      ""error""
+      IL_0069:  dup
+      IL_006a:  stloc.2
+      IL_006b:  ldc.i4.2
+      IL_006c:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(string, int)""
+      IL_0071:  nop
+      // sequence point: }
+      IL_0072:  nop
+      IL_0073:  leave.s    IL_0075
+    }
+    // sequence point: }
+    IL_0075:  leave.s    IL_0080
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_0077:  ldloca.s   V_0
+    IL_0079:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_007e:  nop
+    IL_007f:  endfinally
+  }
+  // sequence point: }
+  IL_0080:  ret
+}
+");
+        }
+
+        [Fact]
+        public void ExceptionHandler_CatchAllWithFilter()
+        {
+            var source = WithHelpers(@"
+class C
+{
+    static void Main(string[] args)
+    {
+        bool b = false;
+        string s;
+        try
+        {
+            s = args[0];
+        }
+        catch when (b = true)
+        {
+            s = ""error"";
+        }
+    }
+}
+");
+            var verifier = CompileAndVerify(source, expectedOutput: @"
+Main: Entered
+Main: P'args'[0] = System.String[]
+Main: L1 = False
+Main: L1 = True
+Main: L2 = error
+Main: Returned
+");
+
+            verifier.VerifyMethodBody("C.Main", @"
+{
+  // Code size      105 (0x69)
+  .maxstack  3
+  .locals init (Microsoft.CodeAnalysis.Runtime.LocalStoreTracker V_0,
+                bool V_1, //b
+                string V_2, //s
+                bool V_3)
+  // sequence point: <hidden>
+  IL_0000:  ldtoken    ""void C.Main(string[])""
+  IL_0005:  call       ""Microsoft.CodeAnalysis.Runtime.LocalStoreTracker Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogMethodEntry(int)""
+  IL_000a:  stloc.0
+  .try
+  {
+    // sequence point: {
+    IL_000b:  ldloca.s   V_0
+    IL_000d:  ldarg.0
+    IL_000e:  ldc.i4.0
+    IL_000f:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogParameterStore(object, int)""
+    IL_0014:  nop
+    // sequence point: bool b = false;
+    IL_0015:  ldloca.s   V_0
+    IL_0017:  ldc.i4.0
+    IL_0018:  dup
+    IL_0019:  stloc.1
+    IL_001a:  ldc.i4.1
+    IL_001b:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(bool, int)""
+    IL_0020:  nop
+    .try
+    {
+      // sequence point: {
+      IL_0021:  nop
+      // sequence point: s = args[0];
+      IL_0022:  ldloca.s   V_0
+      IL_0024:  ldarg.0
+      IL_0025:  ldc.i4.0
+      IL_0026:  ldelem.ref
+      IL_0027:  dup
+      IL_0028:  stloc.2
+      IL_0029:  ldc.i4.2
+      IL_002a:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(string, int)""
+      IL_002f:  nop
+      // sequence point: }
+      IL_0030:  nop
+      IL_0031:  leave.s    IL_005d
+    }
+    filter
+    {
+      // sequence point: <hidden>
+      IL_0033:  pop
+      // sequence point: when (b = true)
+      IL_0034:  ldloca.s   V_0
+      IL_0036:  ldc.i4.1
+      IL_0037:  dup
+      IL_0038:  stloc.1
+      IL_0039:  ldc.i4.1
+      IL_003a:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(bool, int)""
+      IL_003f:  nop
+      IL_0040:  ldloc.1
+      IL_0041:  stloc.3
+      // sequence point: <hidden>
+      IL_0042:  ldloc.3
+      IL_0043:  ldc.i4.0
+      IL_0044:  cgt.un
+      IL_0046:  endfilter
+    }  // end filter
+    {  // handler
+      // sequence point: <hidden>
+      IL_0048:  pop
+      // sequence point: {
+      IL_0049:  nop
+      // sequence point: s = ""error"";
+      IL_004a:  ldloca.s   V_0
+      IL_004c:  ldstr      ""error""
+      IL_0051:  dup
+      IL_0052:  stloc.2
+      IL_0053:  ldc.i4.2
+      IL_0054:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogLocalStore(string, int)""
+      IL_0059:  nop
+      // sequence point: }
+      IL_005a:  nop
+      IL_005b:  leave.s    IL_005d
+    }
+    // sequence point: }
+    IL_005d:  leave.s    IL_0068
+  }
+  finally
+  {
+    // sequence point: <hidden>
+    IL_005f:  ldloca.s   V_0
+    IL_0061:  call       ""void Microsoft.CodeAnalysis.Runtime.LocalStoreTracker.LogReturn()""
+    IL_0066:  nop
+    IL_0067:  endfinally
+  }
+  // sequence point: }
+  IL_0068:  ret
+}");
+        }
+
+        [Fact]
+        public void Recursion()
+        {
+            var source = WithHelpers(@"
+class C
+{
+    static void M(int depth)
+    {
+        if (depth == 4)
+        {
+            return;
+        }
+
+        int a = depth;
+        int b = depth;
+
+        M(depth + 1);
+
+        a += 10;
+        if (depth % 2 == 0) b += 10;
+    }
+
+    static void Main() => M(0);
+}
+");
+            CompileAndVerify(source, expectedOutput: @"
+Main: Entered
+M: Entered
+M: P'depth'[0] = 0
+M: L1 = 0
+M: L2 = 0
+M: Entered
+M: P'depth'[0] = 1
+M: L1 = 1
+M: L2 = 1
+M: Entered
+M: P'depth'[0] = 2
+M: L1 = 2
+M: L2 = 2
+M: Entered
+M: P'depth'[0] = 3
+M: L1 = 3
+M: L2 = 3
+M: Entered
+M: P'depth'[0] = 4
+M: Returned
+M: L1 = 13
+M: Returned
+M: L1 = 12
+M: L2 = 12
+M: Returned
+M: L1 = 11
+M: Returned
+M: L1 = 10
+M: L2 = 10
+M: Returned
+Main: Returned
+");
+        }
+    }
+}
+#endif
diff --git a/src/Compilers/CSharp/Test/Emit2/FlowAnalysis/FlowTestBase.cs b/src/Compilers/CSharp/Test/Emit2/FlowAnalysis/FlowTestBase.cs
index 36de006b6e532..8c903259ebb6b 100644
--- a/src/Compilers/CSharp/Test/Emit2/FlowAnalysis/FlowTestBase.cs
+++ b/src/Compilers/CSharp/Test/Emit2/FlowAnalysis/FlowTestBase.cs
@@ -29,7 +29,7 @@ internal ImmutableArray<Diagnostic> FlowDiagnostics(CSharpCompilation compilatio
                 }
 
                 var compilationState = new TypeCompilationState(sourceSymbol.ContainingType, compilation, null);
-                var boundBody = MethodCompiler.BindMethodBody(sourceSymbol, compilationState, new BindingDiagnosticBag(new DiagnosticBag()));
+                var boundBody = MethodCompiler.BindSynthesizedMethodBody(sourceSymbol, compilationState, new BindingDiagnosticBag(new DiagnosticBag()));
                 if (boundBody != null)
                 {
                     FlowAnalysisPass.Rewrite(sourceSymbol, boundBody, compilationState, flowDiagnostics, hasTrailingExpression: false, originalBodyNested: false);
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/ImplicitlyTypeArraysTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/ImplicitlyTypeArraysTests.cs
index 10f1cf5377abb..c4dbf665bf6ea 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/ImplicitlyTypeArraysTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/ImplicitlyTypeArraysTests.cs
@@ -37,7 +37,7 @@ public void F()
 
             var method = (SourceMemberMethodSymbol)compilation.GlobalNamespace.GetTypeMembers("C").Single().GetMembers("F").Single();
             var diagnostics = new DiagnosticBag();
-            var block = MethodCompiler.BindMethodBody(method, new TypeCompilationState(method.ContainingType, compilation, null), new BindingDiagnosticBag(diagnostics));
+            var block = MethodCompiler.BindSynthesizedMethodBody(method, new TypeCompilationState(method.ContainingType, compilation, null), new BindingDiagnosticBag(diagnostics));
 
             var locDecl = (BoundLocalDeclaration)block.Statements.Single();
             var localA = (ArrayTypeSymbol)locDecl.DeclaredTypeOpt.Display;
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/OperatorTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/OperatorTests.cs
index a2a9327542fb1..0d75642b14dae 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/OperatorTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/OperatorTests.cs
@@ -3201,7 +3201,7 @@ private void TestBoundTree(string source, System.Func<IEnumerable<KeyValuePair<T
             var compilation = CreateCompilation(source, options: TestOptions.ReleaseDll);
             var method = (SourceMemberMethodSymbol)compilation.GlobalNamespace.GetTypeMembers("C").Single().GetMembers("M").Single();
             var diagnostics = new DiagnosticBag();
-            var block = MethodCompiler.BindMethodBody(method, new TypeCompilationState(method.ContainingType, compilation, null), new BindingDiagnosticBag(diagnostics));
+            var block = MethodCompiler.BindSynthesizedMethodBody(method, new TypeCompilationState(method.ContainingType, compilation, null), new BindingDiagnosticBag(diagnostics));
             var tree = BoundTreeDumperNodeProducer.MakeTree(block);
             var results = string.Join("\n",
                 query(tree.PreorderTraversal())
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/OverloadResolutionTestBase.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/OverloadResolutionTestBase.cs
index 1e10ff7a1c44f..6f5bbf22e4516 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/OverloadResolutionTestBase.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/OverloadResolutionTestBase.cs
@@ -33,7 +33,7 @@ internal void TestOverloadResolutionWithDiff(string source, MetadataReference[]
 
             var method = (SourceMemberMethodSymbol)compilation.GlobalNamespace.GetTypeMembers("C").Single().GetMembers("M").Single();
             var diagnostics = new DiagnosticBag();
-            var block = MethodCompiler.BindMethodBody(method, new TypeCompilationState(method.ContainingType, compilation, null), new BindingDiagnosticBag(diagnostics));
+            var block = MethodCompiler.BindSynthesizedMethodBody(method, new TypeCompilationState(method.ContainingType, compilation, null), new BindingDiagnosticBag(diagnostics));
             var tree = BoundTreeDumperNodeProducer.MakeTree(block);
             var results = string.Join("\n", tree.PreorderTraversal().Select(edge => edge.Value)
                 .Where(x => x.Text == "method" && x.Value != null)
diff --git a/src/Compilers/CSharp/Test/Symbol/Symbols/MissingSpecialMember.cs b/src/Compilers/CSharp/Test/Symbol/Symbols/MissingSpecialMember.cs
index a95d49a0311b5..b20bcbddb1781 100644
--- a/src/Compilers/CSharp/Test/Symbol/Symbols/MissingSpecialMember.cs
+++ b/src/Compilers/CSharp/Test/Symbol/Symbols/MissingSpecialMember.cs
@@ -636,6 +636,7 @@ public void AllWellKnownTypes()
                         // Not yet in the platform.
                         continue;
                     case WellKnownType.Microsoft_CodeAnalysis_Runtime_Instrumentation:
+                    case WellKnownType.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker:
                     case WellKnownType.System_Runtime_CompilerServices_ITuple:
                     case WellKnownType.System_Runtime_CompilerServices_NonNullTypesAttribute:
                     case WellKnownType.Microsoft_CodeAnalysis_EmbeddedAttribute:
@@ -1005,6 +1006,33 @@ public void AllWellKnownTypeMembers()
                         continue;
                     case WellKnownMember.Microsoft_CodeAnalysis_Runtime_Instrumentation__CreatePayloadForMethodsSpanningSingleFile:
                     case WellKnownMember.Microsoft_CodeAnalysis_Runtime_Instrumentation__CreatePayloadForMethodsSpanningMultipleFiles:
+                    case WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogMethodEntry:
+                    case WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLambdaEntry:
+                    case WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogStateMachineMethodEntry:
+                    case WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogStateMachineLambdaEntry:
+                    case WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogReturn:
+                    case WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__GetNewStateMachineInstanceId:
+                    case WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreBoolean:
+                    case WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreByte:
+                    case WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreUInt16:
+                    case WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreUInt32:
+                    case WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreUInt64:
+                    case WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreString:
+                    case WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreObject:
+                    case WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStorePointer:
+                    case WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreUnmanaged:
+                    case WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreParameterAlias:
+                    case WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreBoolean:
+                    case WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreByte:
+                    case WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreUInt16:
+                    case WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreUInt32:
+                    case WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreUInt64:
+                    case WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreString:
+                    case WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreObject:
+                    case WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStorePointer:
+                    case WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreUnmanaged:
+                    case WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreParameterAlias:
+                    case WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreLocalAlias:
                     case WellKnownMember.System_Runtime_CompilerServices_IsReadOnlyAttribute__ctor:
                     case WellKnownMember.System_Runtime_CompilerServices_IsByRefLikeAttribute__ctor:
                     case WellKnownMember.System_Runtime_CompilerServices_IsUnmanagedAttribute__ctor:
diff --git a/src/Compilers/Core/CodeAnalysisTest/Emit/EmitOptionsTests.cs b/src/Compilers/Core/CodeAnalysisTest/Emit/EmitOptionsTests.cs
index 5c9a24b32df5a..dacb90e7c1564 100644
--- a/src/Compilers/Core/CodeAnalysisTest/Emit/EmitOptionsTests.cs
+++ b/src/Compilers/Core/CodeAnalysisTest/Emit/EmitOptionsTests.cs
@@ -78,7 +78,6 @@ public void TestFieldsForEqualsAndGetHashCode()
         {
             ReflectionAssert.AssertPublicAndInternalFieldsAndProperties(
                 typeof(EmitOptions),
-                nameof(EmitOptions.EmitTestCoverageData),
                 nameof(EmitOptions.EmitMetadataOnly),
                 nameof(EmitOptions.SubsystemVersion),
                 nameof(EmitOptions.FileAlignment),
diff --git a/src/Compilers/Core/Portable/CodeAnalysisResources.resx b/src/Compilers/Core/Portable/CodeAnalysisResources.resx
index 524571c711d43..047409511ef1b 100644
--- a/src/Compilers/Core/Portable/CodeAnalysisResources.resx
+++ b/src/Compilers/Core/Portable/CodeAnalysisResources.resx
@@ -750,4 +750,7 @@
   <data name="HintNameNotWithinCurrentDirectory" xml:space="preserve">
     <value>The hintName '{0}' is not within the current directory.</value>
   </data>
+  <data name="MethodSymbolExpected" xml:space="preserve">
+    <value>Method symbol expected</value>
+  </data>
 </root>
\ No newline at end of file
diff --git a/src/Compilers/Core/Portable/CodeGen/DynamicAnalysisMethodBodyData.cs b/src/Compilers/Core/Portable/CodeGen/DynamicAnalysisMethodBodyData.cs
deleted file mode 100644
index 2ab9bac1a7873..0000000000000
--- a/src/Compilers/Core/Portable/CodeGen/DynamicAnalysisMethodBodyData.cs
+++ /dev/null
@@ -1,20 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-using System.Collections.Immutable;
-using System.Diagnostics;
-
-namespace Microsoft.CodeAnalysis.CodeGen
-{
-    internal sealed class DynamicAnalysisMethodBodyData
-    {
-        public readonly ImmutableArray<SourceSpan> Spans;
-
-        public DynamicAnalysisMethodBodyData(ImmutableArray<SourceSpan> spans)
-        {
-            Debug.Assert(!spans.IsDefault);
-            Spans = spans;
-        }
-    }
-}
diff --git a/src/Compilers/Core/Portable/CodeGen/ILBuilderEmit.cs b/src/Compilers/Core/Portable/CodeGen/ILBuilderEmit.cs
index 0adab363b480a..815b077f70700 100644
--- a/src/Compilers/Core/Portable/CodeGen/ILBuilderEmit.cs
+++ b/src/Compilers/Core/Portable/CodeGen/ILBuilderEmit.cs
@@ -46,13 +46,12 @@ internal void EmitToken(string value)
             this.GetCurrentWriter().WriteUInt32(token);
         }
 
-        internal void EmitToken(Cci.IReference value, SyntaxNode? syntaxNode, DiagnosticBag diagnostics, bool encodeAsRawToken = false)
+        internal void EmitToken(Cci.IReference value, SyntaxNode? syntaxNode, DiagnosticBag diagnostics, Cci.MetadataWriter.RawTokenEncoding encoding = 0)
         {
             uint token = module?.GetFakeSymbolTokenForIL(value, syntaxNode, diagnostics) ?? 0xFFFF;
-            // Setting the high bit indicates that the token value is to be interpreted literally rather than as a handle.
-            if (encodeAsRawToken)
+            if (encoding != Cci.MetadataWriter.RawTokenEncoding.None)
             {
-                token |= Cci.MetadataWriter.LiteralMethodDefinitionToken;
+                token = Cci.MetadataWriter.GetRawToken(encoding, token);
             }
             this.GetCurrentWriter().WriteUInt32(token);
         }
@@ -65,8 +64,8 @@ internal void EmitToken(Cci.ISignature value, SyntaxNode? syntaxNode, Diagnostic
 
         internal void EmitGreatestMethodToken()
         {
-            // A magic value indicates that the token value is to be the literal value of the greatest method definition token.
-            this.GetCurrentWriter().WriteUInt32(Cci.MetadataWriter.LiteralGreatestMethodDefinitionToken);
+            var token = Cci.MetadataWriter.GetRawToken(Cci.MetadataWriter.RawTokenEncoding.GreatestMethodDefinitionRowId, 0);
+            this.GetCurrentWriter().WriteUInt32(token);
         }
 
         internal void EmitModuleVersionIdStringToken()
@@ -77,7 +76,8 @@ internal void EmitModuleVersionIdStringToken()
 
         internal void EmitSourceDocumentIndexToken(Cci.DebugSourceDocument document)
         {
-            this.GetCurrentWriter().WriteUInt32((module?.GetSourceDocumentIndexForIL(document) ?? 0xFFFF) | Cci.MetadataWriter.SourceDocumentIndex);
+            var token = Cci.MetadataWriter.GetRawToken(Cci.MetadataWriter.RawTokenEncoding.DocumentRowId, module?.GetSourceDocumentIndexForIL(document) ?? 0xFFFF);
+            this.GetCurrentWriter().WriteUInt32(token);
         }
 
         internal void EmitArrayBlockInitializer(ImmutableArray<byte> data, SyntaxNode syntaxNode, DiagnosticBag diagnostics)
diff --git a/src/Compilers/Core/Portable/CodeGen/MethodBody.cs b/src/Compilers/Core/Portable/CodeGen/MethodBody.cs
index 9e5230a5b95e2..8c8e20a87f1f5 100644
--- a/src/Compilers/Core/Portable/CodeGen/MethodBody.cs
+++ b/src/Compilers/Core/Portable/CodeGen/MethodBody.cs
@@ -42,8 +42,8 @@ internal sealed class MethodBody : Cci.IMethodBody
         // Data used when emitting EnC delta:
         private readonly ImmutableArray<Cci.ITypeReference?> _stateMachineAwaiterSlots;
 
-        // Data used when emitting Dynamic Analysis resource:
-        private readonly DynamicAnalysisMethodBodyData _dynamicAnalysisDataOpt;
+        // Data used when emitting Dynamic Analysis resource generated by code coverage instrumentation. Empty if not applicable.
+        private readonly ImmutableArray<SourceSpan> _codeCoverageSpans;
 
         public MethodBody(
             ImmutableArray<byte> ilBits,
@@ -67,7 +67,7 @@ public MethodBody(
             ImmutableArray<Cci.ITypeReference?> stateMachineAwaiterSlots,
             StateMachineStatesDebugInfo stateMachineStatesDebugInfo,
             StateMachineMoveNextBodyDebugInfo stateMachineMoveNextDebugInfoOpt,
-            DynamicAnalysisMethodBodyData dynamicAnalysisDataOpt)
+            ImmutableArray<SourceSpan> codeCoverageSpans)
         {
             Debug.Assert(!locals.IsDefault);
             Debug.Assert(!exceptionHandlers.IsDefault);
@@ -92,7 +92,7 @@ public MethodBody(
             _stateMachineAwaiterSlots = stateMachineAwaiterSlots;
             _stateMachineStatesDebugInfo = stateMachineStatesDebugInfo;
             _stateMachineMoveNextDebugInfoOpt = stateMachineMoveNextDebugInfoOpt;
-            _dynamicAnalysisDataOpt = dynamicAnalysisDataOpt;
+            _codeCoverageSpans = codeCoverageSpans;
             _sequencePoints = GetSequencePoints(sequencePoints, debugDocumentProvider);
         }
 
@@ -108,7 +108,7 @@ public MethodBody(
             return sequencePointsBuilder.ToImmutableAndFree();
         }
 
-        DynamicAnalysisMethodBodyData Cci.IMethodBody.DynamicAnalysisData => _dynamicAnalysisDataOpt;
+        ImmutableArray<SourceSpan> Cci.IMethodBody.CodeCoverageSpans => _codeCoverageSpans;
 
         ImmutableArray<Cci.ExceptionHandlerRegion> Cci.IMethodBody.ExceptionRegions => _exceptionHandlers;
 
diff --git a/src/Compilers/Core/Portable/CommandLine/CommonCompiler.cs b/src/Compilers/Core/Portable/CommandLine/CommonCompiler.cs
index 15a6fedb65cb3..0ab3a57861312 100644
--- a/src/Compilers/Core/Portable/CommandLine/CommonCompiler.cs
+++ b/src/Compilers/Core/Portable/CommandLine/CommonCompiler.cs
@@ -1202,8 +1202,6 @@ private void CompileAndEmit(
                         success = compilation.CompileMethods(
                             moduleBeingBuilt,
                             Arguments.EmitPdb,
-                            emitOptions.EmitMetadataOnly,
-                            emitOptions.EmitTestCoverageData,
                             diagnostics,
                             filterOpt: null,
                             cancellationToken: cancellationToken);
diff --git a/src/Compilers/Core/Portable/Compilation/Compilation.cs b/src/Compilers/Core/Portable/Compilation/Compilation.cs
index 6aa2638065b8b..543cf7845ea6e 100644
--- a/src/Compilers/Core/Portable/Compilation/Compilation.cs
+++ b/src/Compilers/Core/Portable/Compilation/Compilation.cs
@@ -2432,8 +2432,6 @@ internal bool IsRealSigned
         internal abstract bool CompileMethods(
             CommonPEModuleBuilder moduleBuilder,
             bool emittingPdb,
-            bool emitMetadataOnly,
-            bool emitTestCoverageData,
             DiagnosticBag diagnostics,
             Predicate<ISymbolInternal>? filterOpt,
             CancellationToken cancellationToken);
@@ -2568,8 +2566,6 @@ internal bool Compile(
                 return CompileMethods(
                     moduleBuilder,
                     emittingPdb,
-                    emitMetadataOnly: false,
-                    emitTestCoverageData: false,
                     diagnostics: diagnostics,
                     filterOpt: filterOpt,
                     cancellationToken: cancellationToken);
@@ -2919,8 +2915,6 @@ internal EmitResult Emit(
                     success = CompileMethods(
                         moduleBeingBuilt,
                         emittingPdb: pdbStream != null || embedPdb,
-                        emitMetadataOnly: options.EmitMetadataOnly,
-                        emitTestCoverageData: options.EmitTestCoverageData,
                         diagnostics: diagnostics,
                         filterOpt: null,
                         cancellationToken: cancellationToken);
@@ -3239,7 +3233,7 @@ internal bool SerializeToPeStream(
                         emitOptions.EmitMetadataOnly,
                         emitOptions.IncludePrivateMembers,
                         deterministic,
-                        emitOptions.EmitTestCoverageData,
+                        emitOptions.InstrumentationKinds.Contains(InstrumentationKind.TestCoverage),
                         privateKeyOpt,
                         cancellationToken))
                     {
diff --git a/src/Compilers/Core/Portable/Emit/EditAndContinue/DefinitionMap.cs b/src/Compilers/Core/Portable/Emit/EditAndContinue/DefinitionMap.cs
index f6a2c304bc5ca..82c2f1cff96ca 100644
--- a/src/Compilers/Core/Portable/Emit/EditAndContinue/DefinitionMap.cs
+++ b/src/Compilers/Core/Portable/Emit/EditAndContinue/DefinitionMap.cs
@@ -30,6 +30,7 @@ public MappedMethod(IMethodSymbolInternal previousMethod, Func<SyntaxNode, Synta
             }
         }
 
+        private readonly ImmutableDictionary<IMethodSymbolInternal, MethodInstrumentation> _methodInstrumentations;
         protected readonly IReadOnlyDictionary<IMethodSymbolInternal, MappedMethod> mappedMethods;
         protected abstract SymbolMatcher MapToMetadataSymbolMatcher { get; }
         protected abstract SymbolMatcher MapToPreviousSymbolMatcher { get; }
@@ -38,7 +39,11 @@ protected DefinitionMap(IEnumerable<SemanticEdit> edits)
         {
             Debug.Assert(edits != null);
 
-            this.mappedMethods = GetMappedMethods(edits);
+            mappedMethods = GetMappedMethods(edits);
+
+            _methodInstrumentations = edits
+                .Where(edit => !edit.Instrumentation.IsDefaultOrEmpty)
+                .ToImmutableDictionary(edit => (IMethodSymbolInternal)GetISymbolInternalOrNull(edit.NewSymbol!)!, edit => edit.Instrumentation);
         }
 
         private IReadOnlyDictionary<IMethodSymbolInternal, MappedMethod> GetMappedMethods(IEnumerable<SemanticEdit> edits)
@@ -342,6 +347,9 @@ protected abstract void GetStateMachineFieldMapFromMetadata(
                 GetLambdaSyntaxFacts());
         }
 
+        internal MethodInstrumentation GetMethodBodyInstrumentations(IMethodSymbolInternal method)
+            => _methodInstrumentations.TryGetValue(method, out var instrumentation) ? instrumentation : MethodInstrumentation.Empty;
+
         protected abstract LambdaSyntaxFacts GetLambdaSyntaxFacts();
 
         private void ReportMissingStateMachineAttribute(DiagnosticBag diagnostics, IMethodSymbolInternal method, string stateMachineAttributeFullName)
diff --git a/src/Compilers/Core/Portable/Emit/EditAndContinue/DeletedMethodBody.cs b/src/Compilers/Core/Portable/Emit/EditAndContinue/DeletedMethodBody.cs
index 7edd6c109d5df..ec4adf0b0593d 100644
--- a/src/Compilers/Core/Portable/Emit/EditAndContinue/DeletedMethodBody.cs
+++ b/src/Compilers/Core/Portable/Emit/EditAndContinue/DeletedMethodBody.cs
@@ -64,7 +64,7 @@ public DeletedMethodBody(DeletedMethodDefinition methodDef, EmitContext context)
 
         public ImmutableArray<LambdaDebugInfo> LambdaDebugInfo => ImmutableArray<LambdaDebugInfo>.Empty;
 
-        public DynamicAnalysisMethodBodyData DynamicAnalysisData => null;
+        public ImmutableArray<SourceSpan> CodeCoverageSpans => ImmutableArray<SourceSpan>.Empty;
 
         public StateMachineStatesDebugInfo StateMachineStatesDebugInfo => default;
 
diff --git a/src/Compilers/Core/Portable/Emit/EmitOptions.cs b/src/Compilers/Core/Portable/Emit/EmitOptions.cs
index 70f7aa9332ae3..ac902d0cc2551 100644
--- a/src/Compilers/Core/Portable/Emit/EmitOptions.cs
+++ b/src/Compilers/Core/Portable/Emit/EmitOptions.cs
@@ -7,6 +7,7 @@
 using System.Linq;
 using System.Security.Cryptography;
 using System.Text;
+using Microsoft.CodeAnalysis.CodeGen;
 using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.Emit
@@ -368,8 +369,6 @@ internal void ValidateOptions(DiagnosticBag diagnostics, CommonMessageProvider m
             }
         }
 
-        internal bool EmitTestCoverageData => InstrumentationKinds.Contains(InstrumentationKind.TestCoverage);
-
         internal static bool IsValidFileAlignment(int value)
         {
             switch (value)
diff --git a/src/Compilers/Core/Portable/Emit/InstrumentationKind.cs b/src/Compilers/Core/Portable/Emit/InstrumentationKind.cs
index 21d3418330216..4c6741f2e7024 100644
--- a/src/Compilers/Core/Portable/Emit/InstrumentationKind.cs
+++ b/src/Compilers/Core/Portable/Emit/InstrumentationKind.cs
@@ -15,16 +15,21 @@ public enum InstrumentationKind
         None = 0,
 
         /// <summary>
-        /// Instruments the binary to add test coverage.
+        /// Instruments the code to add test coverage.
         /// </summary>
         TestCoverage = 1,
+
+        /// <summary>
+        /// Instruments the code to trace local variable writes.
+        /// </summary>
+        LocalStateTracing = 2,
     }
 
     internal static class InstrumentationKindExtensions
     {
         internal static bool IsValid(this InstrumentationKind value)
         {
-            return value >= InstrumentationKind.None && value <= InstrumentationKind.TestCoverage;
+            return value >= InstrumentationKind.None && value <= InstrumentationKind.LocalStateTracing;
         }
     }
 }
diff --git a/src/Compilers/Core/Portable/Emit/MethodInstrumentation.cs b/src/Compilers/Core/Portable/Emit/MethodInstrumentation.cs
new file mode 100644
index 0000000000000..08318df6066ed
--- /dev/null
+++ b/src/Compilers/Core/Portable/Emit/MethodInstrumentation.cs
@@ -0,0 +1,26 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Immutable;
+
+namespace Microsoft.CodeAnalysis.Emit;
+
+/// <summary>
+/// Represents instrumentation of a method.
+/// </summary>
+public readonly struct MethodInstrumentation
+{
+    internal static readonly MethodInstrumentation Empty = new()
+    {
+        Kinds = ImmutableArray<InstrumentationKind>.Empty,
+    };
+
+    /// <summary>
+    /// Kinds of instrumentation to apply to the entire method body.
+    /// </summary>
+    public ImmutableArray<InstrumentationKind> Kinds { get; init; }
+
+    internal bool IsDefaultOrEmpty
+        => Kinds.IsDefaultOrEmpty;
+}
diff --git a/src/Compilers/Core/Portable/Emit/NoPia/CommonEmbeddedMethod.cs b/src/Compilers/Core/Portable/Emit/NoPia/CommonEmbeddedMethod.cs
index 6d8771f789e6f..92b311fb6bd57 100644
--- a/src/Compilers/Core/Portable/Emit/NoPia/CommonEmbeddedMethod.cs
+++ b/src/Compilers/Core/Portable/Emit/NoPia/CommonEmbeddedMethod.cs
@@ -137,7 +137,7 @@ public EmptyBody(CommonEmbeddedMethod method)
 
                 StateMachineMoveNextBodyDebugInfo Cci.IMethodBody.MoveNextBodyInfo => null;
 
-                DynamicAnalysisMethodBodyData Cci.IMethodBody.DynamicAnalysisData => null;
+                ImmutableArray<SourceSpan> Cci.IMethodBody.CodeCoverageSpans => ImmutableArray<SourceSpan>.Empty;
 
                 ImmutableArray<Cci.LocalScope> Cci.IMethodBody.LocalScopes =>
                     ImmutableArray<Cci.LocalScope>.Empty;
diff --git a/src/Compilers/Core/Portable/Emit/SemanticEdit.cs b/src/Compilers/Core/Portable/Emit/SemanticEdit.cs
index cf23930ffb2bb..87ff8ac06afa2 100644
--- a/src/Compilers/Core/Portable/Emit/SemanticEdit.cs
+++ b/src/Compilers/Core/Portable/Emit/SemanticEdit.cs
@@ -2,9 +2,10 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System;
+using System.ComponentModel;
 using Microsoft.CodeAnalysis.Symbols;
 using Roslyn.Utilities;
-using System;
 
 namespace Microsoft.CodeAnalysis.Emit
 {
@@ -48,6 +49,20 @@ namespace Microsoft.CodeAnalysis.Emit
         /// </summary>
         public bool PreserveLocalVariables { get; }
 
+        /// <summary>
+        /// Instrumentation update to be applied to a method.
+        /// <see cref="OldSymbol"/> and <see cref="NewSymbol"/> must be non-null <see cref="IMethodSymbol"/>s.
+        /// <see cref="Kind"/> must be <see cref="SemanticEditKind.Update"/>.
+        /// </summary>
+        public MethodInstrumentation Instrumentation { get; }
+
+        // 4.6 BACKCOMPAT OVERLOAD -- DO NOT TOUCH
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public SemanticEdit(SemanticEditKind kind, ISymbol? oldSymbol, ISymbol? newSymbol, Func<SyntaxNode, SyntaxNode?>? syntaxMap, bool preserveLocalVariables)
+            : this(kind, oldSymbol, newSymbol, syntaxMap, preserveLocalVariables, MethodInstrumentation.Empty)
+        {
+        }
+
         /// <summary>
         /// Initializes an instance of <see cref="SemanticEdit"/>.
         /// </summary>
@@ -66,13 +81,16 @@ namespace Microsoft.CodeAnalysis.Emit
         /// <param name="preserveLocalVariables">
         /// True if the edit is an update of an active method and local values should be preserved; false otherwise.
         /// </param>
+        /// <param name="instrumentation">
+        /// Instrumentation update to be applied to a method.
+        /// </param>
         /// <exception cref="ArgumentNullException">
         /// <paramref name="oldSymbol"/> or <paramref name="newSymbol"/> is null and the edit isn't a <see cref="SemanticEditKind.Insert"/> or <see cref="SemanticEditKind.Delete"/>, respectively.
         /// </exception>
         /// <exception cref="ArgumentOutOfRangeException">
         /// <paramref name="kind"/> is not a valid kind.
         /// </exception>
-        public SemanticEdit(SemanticEditKind kind, ISymbol? oldSymbol, ISymbol? newSymbol, Func<SyntaxNode, SyntaxNode?>? syntaxMap = null, bool preserveLocalVariables = false)
+        public SemanticEdit(SemanticEditKind kind, ISymbol? oldSymbol, ISymbol? newSymbol, Func<SyntaxNode, SyntaxNode?>? syntaxMap = null, bool preserveLocalVariables = false, MethodInstrumentation instrumentation = default)
         {
             if (oldSymbol == null && kind is not (SemanticEditKind.Insert or SemanticEditKind.Replace))
             {
@@ -89,15 +107,34 @@ public SemanticEdit(SemanticEditKind kind, ISymbol? oldSymbol, ISymbol? newSymbo
                 throw new ArgumentOutOfRangeException(nameof(kind));
             }
 
+            if (!instrumentation.IsDefaultOrEmpty)
+            {
+                if (kind != SemanticEditKind.Update)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(kind));
+                }
+
+                if (oldSymbol is not IMethodSymbol)
+                {
+                    throw new ArgumentException(CodeAnalysisResources.MethodSymbolExpected, nameof(oldSymbol));
+                }
+
+                if (newSymbol is not IMethodSymbol)
+                {
+                    throw new ArgumentException(CodeAnalysisResources.MethodSymbolExpected, nameof(newSymbol));
+                }
+            }
+
             Kind = kind;
             OldSymbol = oldSymbol;
             NewSymbol = newSymbol;
             PreserveLocalVariables = preserveLocalVariables;
             SyntaxMap = syntaxMap;
+            Instrumentation = instrumentation;
         }
 
         internal static SemanticEdit Create(SemanticEditKind kind, ISymbolInternal oldSymbol, ISymbolInternal newSymbol, Func<SyntaxNode, SyntaxNode>? syntaxMap = null, bool preserveLocalVariables = false)
-            => new SemanticEdit(kind, oldSymbol?.GetISymbol(), newSymbol?.GetISymbol(), syntaxMap, preserveLocalVariables);
+            => new SemanticEdit(kind, oldSymbol?.GetISymbol(), newSymbol?.GetISymbol(), syntaxMap, preserveLocalVariables, instrumentation: default);
 
         public override int GetHashCode()
             => Hash.Combine(OldSymbol, Hash.Combine(NewSymbol, (int)Kind));
@@ -105,6 +142,10 @@ public override int GetHashCode()
         public override bool Equals(object? obj)
             => obj is SemanticEdit other && Equals(other);
 
+        /// <summary>
+        /// <see cref="SemanticEdit"/>s are considered equal if they are of the same <see cref="Kind"/> and symbols (<see cref="OldSymbol"/> and <see cref="NewSymbol"/>).
+        /// The effects of edits that compare equal on the emitted metadata/IL are not necessarily the same.
+        /// </summary>
         public bool Equals(SemanticEdit other)
             => Kind == other.Kind
                 && (OldSymbol == null ? other.OldSymbol == null : OldSymbol.Equals(other.OldSymbol))
diff --git a/src/Compilers/Core/Portable/InternalUtilities/EnumerableExtensions.cs b/src/Compilers/Core/Portable/InternalUtilities/EnumerableExtensions.cs
index f293e368f7dc0..7e2359d2ff875 100644
--- a/src/Compilers/Core/Portable/InternalUtilities/EnumerableExtensions.cs
+++ b/src/Compilers/Core/Portable/InternalUtilities/EnumerableExtensions.cs
@@ -662,7 +662,7 @@ private static IEnumerable<IList<T>> TransposeInternal<T>(this IEnumerable<IEnum
         }
 #nullable enable
 
-        internal static Dictionary<K, ImmutableArray<T>> ToDictionary<K, T>(this IEnumerable<T> data, Func<T, K> keySelector, IEqualityComparer<K>? comparer = null)
+        internal static Dictionary<K, ImmutableArray<T>> ToMultiDictionary<K, T>(this IEnumerable<T> data, Func<T, K> keySelector, IEqualityComparer<K>? comparer = null)
             where K : notnull
         {
             var dictionary = new Dictionary<K, ImmutableArray<T>>(comparer);
diff --git a/src/Compilers/Core/Portable/PEWriter/Members.cs b/src/Compilers/Core/Portable/PEWriter/Members.cs
index 61ee5c0785f56..ca39d4032b994 100644
--- a/src/Compilers/Core/Portable/PEWriter/Members.cs
+++ b/src/Compilers/Core/Portable/PEWriter/Members.cs
@@ -488,7 +488,11 @@ ImmutableArray<ExceptionHandlerRegion> ExceptionRegions
         ImmutableArray<LambdaDebugInfo> LambdaDebugInfo { get; }
         StateMachineStatesDebugInfo StateMachineStatesDebugInfo { get; }
 
-        DynamicAnalysisMethodBodyData DynamicAnalysisData { get; }
+        /// <summary>
+        /// Code coverage spans produced by <see cref="InstrumentationKind.TestCoverage"/> instrumentation.
+        /// <see cref="ImmutableArray{SourceSpan}.Empty"/> if not applicable.
+        /// </summary>
+        ImmutableArray<SourceSpan> CodeCoverageSpans { get; }
     }
 
     /// <summary>
diff --git a/src/Compilers/Core/Portable/PEWriter/MetadataWriter.DynamicAnalysis.cs b/src/Compilers/Core/Portable/PEWriter/MetadataWriter.DynamicAnalysis.cs
index 3da30c41aed76..98c778a445b78 100644
--- a/src/Compilers/Core/Portable/PEWriter/MetadataWriter.DynamicAnalysis.cs
+++ b/src/Compilers/Core/Portable/PEWriter/MetadataWriter.DynamicAnalysis.cs
@@ -62,19 +62,14 @@ public DynamicAnalysisDataWriter(int documentCountEstimate, int methodCountEstim
             _blobHeapSize = 1;
         }
 
-        internal void SerializeMethodDynamicAnalysisData(IMethodBody bodyOpt)
+#nullable enable
+        internal void SerializeMethodCodeCoverageData(IMethodBody? body)
         {
-            var data = bodyOpt?.DynamicAnalysisData;
-
-            if (data == null)
-            {
-                _methodTable.Add(default(MethodRow));
-                return;
-            }
-
-            BlobHandle spanBlob = SerializeSpans(data.Spans, _documentIndex);
+            var spans = body?.CodeCoverageSpans ?? ImmutableArray<SourceSpan>.Empty;
+            BlobHandle spanBlob = SerializeSpans(spans, _documentIndex);
             _methodTable.Add(new MethodRow { Spans = spanBlob });
         }
+#nullable disable
 
         #region Heaps
 
diff --git a/src/Compilers/Core/Portable/PEWriter/MetadataWriter.cs b/src/Compilers/Core/Portable/PEWriter/MetadataWriter.cs
index 767955d6eebb5..e8fd0fef9dbc4 100644
--- a/src/Compilers/Core/Portable/PEWriter/MetadataWriter.cs
+++ b/src/Compilers/Core/Portable/PEWriter/MetadataWriter.cs
@@ -2933,7 +2933,7 @@ private int[] SerializeMethodBodies(BlobBuilder ilBuilder, PdbWriter nativePdbWr
                     SerializeMethodDebugInfo(body, methodRid, aggregateMethodRid, localSignatureHandleOpt, ref lastLocalVariableHandle, ref lastLocalConstantHandle);
                 }
 
-                _dynamicAnalysisDataWriterOpt?.SerializeMethodDynamicAnalysisData(body);
+                _dynamicAnalysisDataWriterOpt?.SerializeMethodCodeCoverageData(body);
 
                 bodyOffsets[methodRid - 1] = bodyOffset;
 
@@ -3142,10 +3142,40 @@ private ReservedBlob<UserStringHandle> ReserveUserString(int length)
             return default(ReservedBlob<UserStringHandle>);
         }
 
-        internal const uint LiteralMethodDefinitionToken = 0x80000000;
-        internal const uint LiteralGreatestMethodDefinitionToken = 0x40000000;
-        internal const uint SourceDocumentIndex = 0x20000000;
+        public enum RawTokenEncoding : byte
+        {
+            None = 0,
+
+            /// <summary>
+            /// Emit ldc.i4 of row id of an entity represented by the pseudo-token.
+            /// </summary>
+            RowId,
+
+            /// <summary>
+            /// Emit ldc.i4 of the greatest row id assigned to a method definition in the module being built.
+            /// </summary>
+            GreatestMethodDefinitionRowId,
+
+            /// <summary>
+            /// Emit ldc.i4 of row id of a source document represented by the pseudo-token.
+            /// </summary>
+            DocumentRowId,
+
+            /// <summary>
+            /// Emit ldc.i4 of row id of the hoisted local variable or parameter field that the pseudo-token represents, 
+            /// increased by <see cref="LiftedVariableBaseIndex"/>.
+            /// </summary>
+            LiftedVariableId,
+        }
+
+        public static uint GetRawToken(RawTokenEncoding encoding, uint pseudoToken)
+        {
+            Debug.Assert(pseudoToken <= 0xffffff);
+            return unchecked((uint)encoding << 24 | pseudoToken);
+        }
+
         internal const uint ModuleVersionIdStringToken = 0x80000000;
+        internal const int LiftedVariableBaseIndex = 0x10000;
 
         private void WriteInstructions(Blob finalIL, ImmutableArray<byte> generatedIL, ref UserStringHandle mvidStringHandle, ref Blob mvidStringFixup)
         {
@@ -3174,27 +3204,40 @@ private void WriteInstructions(Blob finalIL, ImmutableArray<byte> generatedIL, r
                             // This is a trick to enable loading raw metadata token indices as integers.
                             if (operandType == OperandType.InlineTok)
                             {
-                                int tokenMask = pseudoToken & unchecked((int)0xff000000);
-                                if (tokenMask != 0 && (uint)pseudoToken != 0xffffffff)
+                                var rawTokenEncoding = (RawTokenEncoding)(pseudoToken >> 24);
+                                if (rawTokenEncoding != RawTokenEncoding.None && (uint)pseudoToken != 0xffffffff)
                                 {
                                     Debug.Assert(ReadByte(generatedIL, offset - 1) == (byte)ILOpCode.Ldtoken);
                                     writer.Offset = offset - 1;
                                     writer.WriteByte((byte)ILOpCode.Ldc_i4);
-                                    switch ((uint)tokenMask)
+                                    switch (rawTokenEncoding)
                                     {
-                                        case LiteralMethodDefinitionToken:
-                                            // Crash the compiler if pseudo token fails to resolve to a MethodDefinitionHandle.
-                                            var handle = (MethodDefinitionHandle)ResolveEntityHandleFromPseudoToken(pseudoToken & 0x00ffffff);
-                                            token = MetadataTokens.GetToken(handle) & 0x00ffffff;
+                                        case RawTokenEncoding.RowId:
+                                            {
+                                                var handle = ResolveEntityHandleFromPseudoToken(pseudoToken & 0x00ffffff);
+                                                Debug.Assert(handle.Kind is HandleKind.MethodDefinition);
+                                                token = MetadataTokens.GetRowNumber(handle);
+                                            }
+                                            break;
+
+                                        case RawTokenEncoding.LiftedVariableId:
+                                            {
+                                                var handle = ResolveEntityHandleFromPseudoToken(pseudoToken & 0x00ffffff);
+                                                Debug.Assert(handle.Kind is HandleKind.FieldDefinition);
+                                                token = MetadataTokens.GetRowNumber(handle) + LiftedVariableBaseIndex;
+                                            }
                                             break;
-                                        case LiteralGreatestMethodDefinitionToken:
+
+                                        case RawTokenEncoding.GreatestMethodDefinitionRowId:
                                             token = GreatestMethodDefIndex;
                                             break;
-                                        case SourceDocumentIndex:
-                                            token = _dynamicAnalysisDataWriterOpt.GetOrAddDocument(((CommonPEModuleBuilder)module).GetSourceDocumentFromIndex((uint)(pseudoToken & 0x00ffffff)));
+
+                                        case RawTokenEncoding.DocumentRowId:
+                                            token = _dynamicAnalysisDataWriterOpt.GetOrAddDocument(module.GetSourceDocumentFromIndex((uint)(pseudoToken & 0x00ffffff)));
                                             break;
+
                                         default:
-                                            throw ExceptionUtilities.UnexpectedValue(tokenMask);
+                                            throw ExceptionUtilities.UnexpectedValue(rawTokenEncoding);
                                     }
                                 }
                             }
diff --git a/src/Compilers/Core/Portable/PEWriter/RootModuleStaticConstructor.cs b/src/Compilers/Core/Portable/PEWriter/RootModuleStaticConstructor.cs
index fcfcabeb35693..20325811506ca 100644
--- a/src/Compilers/Core/Portable/PEWriter/RootModuleStaticConstructor.cs
+++ b/src/Compilers/Core/Portable/PEWriter/RootModuleStaticConstructor.cs
@@ -163,7 +163,7 @@ public RootModuleStaticConstructor(ITypeDefinition containingTypeDefinition, Imm
 
         public StateMachineStatesDebugInfo StateMachineStatesDebugInfo => default;
 
-        public DynamicAnalysisMethodBodyData DynamicAnalysisData => null;
+        public ImmutableArray<SourceSpan> CodeCoverageSpans => ImmutableArray<SourceSpan>.Empty;
 
         public sealed override bool Equals(object obj)
         {
diff --git a/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt b/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt
index 8af4988ef07e1..3bc18703d6afa 100644
--- a/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt
+++ b/src/Compilers/Core/Portable/PublicAPI.Unshipped.txt
@@ -1,4 +1,13 @@
 Microsoft.CodeAnalysis.Compilation.SupportsRuntimeCapability(Microsoft.CodeAnalysis.RuntimeCapability capability) -> bool
+Microsoft.CodeAnalysis.Emit.InstrumentationKind.LocalStateTracing = 2 -> Microsoft.CodeAnalysis.Emit.InstrumentationKind
+Microsoft.CodeAnalysis.Emit.MethodInstrumentation
+Microsoft.CodeAnalysis.Emit.MethodInstrumentation.Kinds.get -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.Emit.InstrumentationKind>
+Microsoft.CodeAnalysis.Emit.MethodInstrumentation.Kinds.init -> void
+Microsoft.CodeAnalysis.Emit.MethodInstrumentation.MethodInstrumentation() -> void
+Microsoft.CodeAnalysis.Emit.SemanticEdit.Instrumentation.get -> Microsoft.CodeAnalysis.Emit.MethodInstrumentation
+Microsoft.CodeAnalysis.Emit.SemanticEdit.SemanticEdit(Microsoft.CodeAnalysis.Emit.SemanticEditKind kind, Microsoft.CodeAnalysis.ISymbol? oldSymbol, Microsoft.CodeAnalysis.ISymbol? newSymbol, System.Func<Microsoft.CodeAnalysis.SyntaxNode!, Microsoft.CodeAnalysis.SyntaxNode?>? syntaxMap = null, bool preserveLocalVariables = false, Microsoft.CodeAnalysis.Emit.MethodInstrumentation instrumentation = default(Microsoft.CodeAnalysis.Emit.MethodInstrumentation)) -> void
+Microsoft.CodeAnalysis.Emit.SemanticEdit.SemanticEdit(Microsoft.CodeAnalysis.Emit.SemanticEditKind kind, Microsoft.CodeAnalysis.ISymbol? oldSymbol, Microsoft.CodeAnalysis.ISymbol? newSymbol, System.Func<Microsoft.CodeAnalysis.SyntaxNode!, Microsoft.CodeAnalysis.SyntaxNode?>? syntaxMap, bool preserveLocalVariables) -> void
+*REMOVED*Microsoft.CodeAnalysis.Emit.SemanticEdit.SemanticEdit(Microsoft.CodeAnalysis.Emit.SemanticEditKind kind, Microsoft.CodeAnalysis.ISymbol? oldSymbol, Microsoft.CodeAnalysis.ISymbol? newSymbol, System.Func<Microsoft.CodeAnalysis.SyntaxNode!, Microsoft.CodeAnalysis.SyntaxNode?>? syntaxMap = null, bool preserveLocalVariables = false) -> void
 Microsoft.CodeAnalysis.OperationKind.Attribute = 125 -> Microsoft.CodeAnalysis.OperationKind
 Microsoft.CodeAnalysis.Operations.IAttributeOperation
 Microsoft.CodeAnalysis.Operations.IAttributeOperation.Operation.get -> Microsoft.CodeAnalysis.IOperation!
diff --git a/src/Compilers/Core/Portable/SynthesizedLocalKind.cs b/src/Compilers/Core/Portable/SynthesizedLocalKind.cs
index 203b7824c681c..8eef47c35268e 100644
--- a/src/Compilers/Core/Portable/SynthesizedLocalKind.cs
+++ b/src/Compilers/Core/Portable/SynthesizedLocalKind.cs
@@ -213,6 +213,12 @@ internal enum SynthesizedLocalKind
         /// </summary>
         SwitchCasePatternMatching = 35,
 
+        /// <summary>
+        /// Variable that stores the context object used to track local variable and parameter stores in method bodies instrumented with <see cref="InstrumentationKind.LocalStateTracing"/>.
+        /// Associated with the method body syntax.
+        /// </summary>
+        LocalStoreTracker = 36,
+
         /// <summary>
         /// All values have to be less than or equal to <see cref="MaxValidValueForLocalVariableSerializedToDebugInformation"/> 
         /// (<see cref="EditAndContinueMethodDebugInformation"/>)
diff --git a/src/Compilers/Core/Portable/WellKnownMember.cs b/src/Compilers/Core/Portable/WellKnownMember.cs
index 6bdd52e00f151..cbae3c69b8913 100644
--- a/src/Compilers/Core/Portable/WellKnownMember.cs
+++ b/src/Compilers/Core/Portable/WellKnownMember.cs
@@ -7,6 +7,8 @@ namespace Microsoft.CodeAnalysis
     // Members of well known types
     internal enum WellKnownMember
     {
+        System_Object__ToString,
+
         System_Math__RoundDouble,
         System_Math__PowDoubleDouble,
 
@@ -426,6 +428,40 @@ internal enum WellKnownMember
         Microsoft_CodeAnalysis_Runtime_Instrumentation__CreatePayloadForMethodsSpanningSingleFile,
         Microsoft_CodeAnalysis_Runtime_Instrumentation__CreatePayloadForMethodsSpanningMultipleFiles,
 
+        Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogMethodEntry,
+        Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLambdaEntry,
+        Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogStateMachineMethodEntry,
+        Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogStateMachineLambdaEntry,
+        Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogReturn,
+        Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__GetNewStateMachineInstanceId,
+
+        // Each of the following LogLocalStore helpers have a matching LogParameterStore helper below.
+        // The corresponding helpers must be listed in the same order.
+        Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreBoolean,
+        Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreByte,
+        Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreUInt16,
+        Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreUInt32,
+        Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreUInt64,
+        Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreString,
+        Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreObject,
+        Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStorePointer,
+        Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreUnmanaged,
+        Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreParameterAlias,
+
+        Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreBoolean,
+        Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreByte,
+        Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreUInt16,
+        Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreUInt32,
+        Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreUInt64,
+        Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreString,
+        Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreObject,
+        Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStorePointer,
+        Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreUnmanaged,
+        Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreParameterAlias,
+
+        // No LogParameterStoreLocalAlias since address of a local can't be assigned to a parameter
+        Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreLocalAlias,
+
         System_Runtime_CompilerServices_NullableAttribute__ctorByte,
         System_Runtime_CompilerServices_NullableAttribute__ctorTransformFlags,
         System_Runtime_CompilerServices_NullableContextAttribute__ctor,
diff --git a/src/Compilers/Core/Portable/WellKnownMembers.cs b/src/Compilers/Core/Portable/WellKnownMembers.cs
index 3e354d75e2ed9..955f1ba80c573 100644
--- a/src/Compilers/Core/Portable/WellKnownMembers.cs
+++ b/src/Compilers/Core/Portable/WellKnownMembers.cs
@@ -16,6 +16,13 @@ static WellKnownMembers()
         {
             byte[] initializationBytes = new byte[]
             {
+                // System_Object__ToString
+                (byte)(MemberFlags.Method | MemberFlags.Virtual),                                                                                   // Flags
+                (byte)SpecialType.System_Object,                                                                            // DeclaringTypeId
+                0,                                                                                                          // Arity
+                    0,                                                                                                      // Method Signature
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_String, // Return Type
+
                 // System_Math__RoundDouble
                 (byte)(MemberFlags.Method | MemberFlags.Static),                                                            // Flags
                 (byte)WellKnownType.System_Math,                                                                            // DeclaringTypeId
@@ -2947,6 +2954,245 @@ static WellKnownMembers()
                     (byte)SignatureTypeCode.ByReference, (byte)SignatureTypeCode.SZArray, (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Boolean,
                     (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Int32,
 
+                // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogMethodEntry
+                (byte)(MemberFlags.Method | MemberFlags.Static),                                                                                         // Flags
+                (byte)WellKnownType.ExtSentinel, (byte)(WellKnownType.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker - WellKnownType.ExtSentinel),     // DeclaringTypeId
+                0,                                                                                                                                       // Arity
+                    1,                                                                                                                                   // Method Signature
+                    (byte)SignatureTypeCode.TypeHandle, (byte)WellKnownType.ExtSentinel, (byte)(WellKnownType.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker - WellKnownType.ExtSentinel),    // Return Type
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Int32,      // Method id
+
+                // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLambdaEntry
+                (byte)(MemberFlags.Method | MemberFlags.Static),                                                                                         // Flags
+                (byte)WellKnownType.ExtSentinel, (byte)(WellKnownType.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker - WellKnownType.ExtSentinel),     // DeclaringTypeId
+                0,                                                                                                                                       // Arity
+                    2,                                                                                                                                   // Method Signature
+                    (byte)SignatureTypeCode.TypeHandle, (byte)WellKnownType.ExtSentinel, (byte)(WellKnownType.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker - WellKnownType.ExtSentinel),    // Return Type
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Int32,      // Method id
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Int32,      // Lambda id
+
+                // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogStateMachineMethodEntry
+                (byte)(MemberFlags.Method | MemberFlags.Static),                                                                                         // Flags
+                (byte)WellKnownType.ExtSentinel, (byte)(WellKnownType.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker - WellKnownType.ExtSentinel),     // DeclaringTypeId
+                0,                                                                                                                                       // Arity
+                    2,                                                                                                                                   // Method Signature
+                    (byte)SignatureTypeCode.TypeHandle, (byte)WellKnownType.ExtSentinel, (byte)(WellKnownType.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker - WellKnownType.ExtSentinel),    // Return Type
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Int32,      // Method id
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_UInt64,     // State machine instance id
+
+                // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogStateMachineLambdaEntry
+                (byte)(MemberFlags.Method | MemberFlags.Static),                                                                                         // Flags
+                (byte)WellKnownType.ExtSentinel, (byte)(WellKnownType.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker - WellKnownType.ExtSentinel),     // DeclaringTypeId
+                0,                                                                                                                                       // Arity
+                    3,                                                                                                                                   // Method Signature
+                    (byte)SignatureTypeCode.TypeHandle, (byte)WellKnownType.ExtSentinel, (byte)(WellKnownType.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker - WellKnownType.ExtSentinel),    // Return Type
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Int32,      // Method id
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Int32,      // Lambda id
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_UInt64,     // State machine instance id
+
+                // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogReturn
+                (byte)MemberFlags.Method,                                                                                         // Flags
+                (byte)WellKnownType.ExtSentinel, (byte)(WellKnownType.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker - WellKnownType.ExtSentinel),     // DeclaringTypeId
+                0,                                                                                                                                       // Arity
+                    0,                                                                                                                                   // Method Signature
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Void,    // Return Type
+
+                // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__GetNewStateMachineInstanceId
+                (byte)(MemberFlags.Method | MemberFlags.Static),                                                                                         // Flags
+                (byte)WellKnownType.ExtSentinel, (byte)(WellKnownType.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker - WellKnownType.ExtSentinel),     // DeclaringTypeId
+                0,                                                                                                                                       // Arity
+                    0,                                                                                                                                   // Method Signature
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_UInt64,    // Return Type
+
+                // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreBoolean
+                (byte)MemberFlags.Method,                                                                                                             // Flags
+                (byte)WellKnownType.ExtSentinel, (byte)(WellKnownType.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker - WellKnownType.ExtSentinel),  // DeclaringTypeId
+                0,                                                                                                                                    // Arity
+                    2,                                                                                                                                // Method Signature
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Void,    // Return Type
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Boolean, // Value
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Int32,  // Local index
+
+                // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreByte
+                (byte)MemberFlags.Method,                                                                                                             // Flags
+                (byte)WellKnownType.ExtSentinel, (byte)(WellKnownType.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker - WellKnownType.ExtSentinel),  // DeclaringTypeId
+                0,                                                                                                                                    // Arity
+                    2,                                                                                                                                // Method Signature
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Void,  // Return Type
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Byte,  // Value
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Int32, // Local index
+
+                // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreUInt16
+                (byte)MemberFlags.Method,                                                                                                             // Flags
+                (byte)WellKnownType.ExtSentinel, (byte)(WellKnownType.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker - WellKnownType.ExtSentinel),  // DeclaringTypeId
+                0,                                                                                                                                    // Arity
+                    2,                                                                                                                                // Method Signature
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Void,   // Return Type
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_UInt16, // Value
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Int32,  // Local index
+
+                // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreUInt32
+                (byte)MemberFlags.Method,                                                                                                             // Flags
+                (byte)WellKnownType.ExtSentinel, (byte)(WellKnownType.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker - WellKnownType.ExtSentinel),  // DeclaringTypeId
+                0,                                                                                                                                    // Arity
+                    2,                                                                                                                                // Method Signature
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Void,   // Return Type
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_UInt32, // Value
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Int32,  // Local index
+
+                // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreUInt64
+                (byte)MemberFlags.Method,                                                                                                             // Flags
+                (byte)WellKnownType.ExtSentinel, (byte)(WellKnownType.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker - WellKnownType.ExtSentinel),  // DeclaringTypeId
+                0,                                                                                                                                    // Arity
+                    2,                                                                                                                                // Method Signature
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Void,   // Return Type
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_UInt64, // Value
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Int32,  // Local index
+
+                // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreString
+                (byte)MemberFlags.Method,                                                                                                             // Flags
+                (byte)WellKnownType.ExtSentinel, (byte)(WellKnownType.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker - WellKnownType.ExtSentinel),  // DeclaringTypeId
+                0,                                                                                                                                    // Arity
+                    2,                                                                                                                                // Method Signature
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Void,   // Return Type
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_String, // Value
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Int32,  // Local index
+
+                // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreObject
+                (byte)MemberFlags.Method,                                                                                                             // Flags
+                (byte)WellKnownType.ExtSentinel, (byte)(WellKnownType.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker - WellKnownType.ExtSentinel),  // DeclaringTypeId
+                0,                                                                                                                                    // Arity
+                    2,                                                                                                                                // Method Signature
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Void,   // Return Type
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Object, // Value
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Int32,  // Local index
+
+                // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStorePointer
+                (byte)MemberFlags.Method,                                                                                                             // Flags
+                (byte)WellKnownType.ExtSentinel, (byte)(WellKnownType.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker - WellKnownType.ExtSentinel),  // DeclaringTypeId
+                0,                                                                                                                                    // Arity
+                    2,                                                                                                                                // Method Signature
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Void,   // Return Type
+                    (byte)SignatureTypeCode.Pointer, (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Void, // Value
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Int32,  // Local index
+
+                // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreUnmanaged
+                (byte)MemberFlags.Method,                                                                                                             // Flags
+                (byte)WellKnownType.ExtSentinel, (byte)(WellKnownType.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker - WellKnownType.ExtSentinel),  // DeclaringTypeId
+                1,                                                                                                                                    // Arity
+                    2,                                                                                                                                // Method Signature
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Void,                      // Return Type
+                    (byte)SignatureTypeCode.ByReference, (byte)SignatureTypeCode.GenericMethodParameter, 0, // Address
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Int32,                     // Local index
+
+                // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreParameterAlias
+                (byte)MemberFlags.Method,                                                                                                             // Flags
+                (byte)WellKnownType.ExtSentinel, (byte)(WellKnownType.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker - WellKnownType.ExtSentinel),  // DeclaringTypeId
+                0,                                                                                                                                    // Arity
+                    2,                                                                                                                                // Method Signature
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Void,   // Return Type
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Int32,                    // Source parameter index
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Int32,                     // Target local index
+
+                // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreBoolean
+                (byte)MemberFlags.Method,                                                                                                             // Flags
+                (byte)WellKnownType.ExtSentinel, (byte)(WellKnownType.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker - WellKnownType.ExtSentinel),  // DeclaringTypeId
+                0,                                                                                                                                    // Arity
+                    2,                                                                                                                                // Method Signature
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Void,   // Return Type
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Boolean,// Value
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Int32,  // Parameter index
+
+                // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreByte
+                (byte)MemberFlags.Method,                                                                                                             // Flags
+                (byte)WellKnownType.ExtSentinel, (byte)(WellKnownType.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker - WellKnownType.ExtSentinel),  // DeclaringTypeId
+                0,                                                                                                                                    // Arity
+                    2,                                                                                                                                // Method Signature
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Void,  // Return Type
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Byte,  // Value
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Int32, // Parameter index
+
+                // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreUInt16
+                (byte)MemberFlags.Method,                                                                                                             // Flags
+                (byte)WellKnownType.ExtSentinel, (byte)(WellKnownType.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker - WellKnownType.ExtSentinel),  // DeclaringTypeId
+                0,                                                                                                                                    // Arity
+                    2,                                                                                                                                // Method Signature
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Void,    // Return Type
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_UInt16,  // Value
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Int32,   // Parameter index
+
+                // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreUInt32
+                (byte)MemberFlags.Method,                                                                                                             // Flags
+                (byte)WellKnownType.ExtSentinel, (byte)(WellKnownType.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker - WellKnownType.ExtSentinel),  // DeclaringTypeId
+                0,                                                                                                                                    // Arity
+                    2,                                                                                                                                // Method Signature
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Void,    // Return Type
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_UInt32,  // Value
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Int32,   // Parameter index
+
+                // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreUInt64
+                (byte)MemberFlags.Method,                                                                                                             // Flags
+                (byte)WellKnownType.ExtSentinel, (byte)(WellKnownType.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker - WellKnownType.ExtSentinel),  // DeclaringTypeId
+                0,                                                                                                                                    // Arity
+                    2,                                                                                                                                // Method Signature
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Void,   // Return Type
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_UInt64, // Value
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Int32,  // Parameter index
+
+                // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreString
+                (byte)MemberFlags.Method,                                                                                                             // Flags
+                (byte)WellKnownType.ExtSentinel, (byte)(WellKnownType.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker - WellKnownType.ExtSentinel),  // DeclaringTypeId
+                0,                                                                                                                                    // Arity
+                    2,                                                                                                                                // Method Signature
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Void,   // Return Type
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_String, // Value
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Int32,  // Parameter index
+
+                // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreObject
+                (byte)MemberFlags.Method,                                                                                                             // Flags
+                (byte)WellKnownType.ExtSentinel, (byte)(WellKnownType.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker - WellKnownType.ExtSentinel),  // DeclaringTypeId
+                0,                                                                                                                                    // Arity
+                    2,                                                                                                                                // Method Signature
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Void,   // Return Type
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Object, // Value
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Int32,  // Parameter index
+
+                // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStorePointer
+                (byte)MemberFlags.Method,                                                                                                             // Flags
+                (byte)WellKnownType.ExtSentinel, (byte)(WellKnownType.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker - WellKnownType.ExtSentinel),  // DeclaringTypeId
+                0,                                                                                                                                    // Arity
+                    2,                                                                                                                                // Method Signature
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Void,   // Return Type
+                    (byte)SignatureTypeCode.Pointer, (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Void, // Value
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Int32, // Local index
+
+                // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreUnmanaged
+                (byte)MemberFlags.Method,                                                                                                             // Flags
+                (byte)WellKnownType.ExtSentinel, (byte)(WellKnownType.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker - WellKnownType.ExtSentinel),  // DeclaringTypeId
+                1,                                                                                                                                    // Arity
+                    2,                                                                                                                                // Method Signature
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Void,                       // Return Type
+                    (byte)SignatureTypeCode.ByReference, (byte)SignatureTypeCode.GenericMethodParameter, 0,  // Address
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Int32,                     // Parameter index
+
+                // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreParameterAlias
+                (byte)MemberFlags.Method,                                                                                                             // Flags
+                (byte)WellKnownType.ExtSentinel, (byte)(WellKnownType.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker - WellKnownType.ExtSentinel),  // DeclaringTypeId
+                0,                                                                                                                                    // Arity
+                    2,                                                                                                                                // Method Signature
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Void,   // Return Type
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Int32,  // Source parameter index
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Int32,  // Target parameter index
+
+                // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreLocalAlias
+                (byte)MemberFlags.Method,                                                                                                             // Flags
+                (byte)WellKnownType.ExtSentinel, (byte)(WellKnownType.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker - WellKnownType.ExtSentinel),  // DeclaringTypeId
+                0,                                                                                                                                    // Arity
+                    2,                                                                                                                                // Method Signature
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Void,   // Return Type
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Int32,                     // Source local index
+                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Int32,                     // Target local index
+
                 // System_Runtime_CompilerServices_NullableAttribute__ctorByte
                 (byte)MemberFlags.Constructor,                                                                              // Flags
                 (byte)WellKnownType.ExtSentinel, (byte)(WellKnownType.System_Runtime_CompilerServices_NullableAttribute - WellKnownType.ExtSentinel),                                       // DeclaringTypeId
@@ -3683,6 +3929,7 @@ static WellKnownMembers()
 
             string[] allNames = new string[(int)WellKnownMember.Count]
             {
+                "ToString",                                 // System_Object__ToString
                 "Round",                                    // System_Math__RoundDouble
                 "Pow",                                      // System_Math__PowDoubleDouble
                 "get_Length",                               // System_Array__get_Length
@@ -4046,6 +4293,34 @@ static WellKnownMembers()
                 "CreatePayload",                            // Microsoft_CodeAnalysis_Runtime_Instrumentation__CreatePayloadForMethodsSpanningSingleFile
                 "CreatePayload",                            // Microsoft_CodeAnalysis_Runtime_Instrumentation__CreatePayloadForMethodsSpanningMultipleFiles
 
+                "LogMethodEntry",                           // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogMethodEntry
+                "LogLambdaEntry",                           // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLambdaEntry
+                "LogStateMachineMethodEntry",               // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogStateMachineMethodEntry
+                "LogStateMachineLambdaEntry",               // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogStateMachineLambdaEntry
+                "LogReturn",                                // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogReturn
+                "GetNewStateMachineInstanceId",             // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__GetNewStateMachineInstanceId
+                "LogLocalStore",                            // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreBoolean
+                "LogLocalStore",                            // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreByte
+                "LogLocalStore",                            // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreUInt16
+                "LogLocalStore",                            // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreUInt32
+                "LogLocalStore",                            // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreUInt64
+                "LogLocalStore",                            // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreString
+                "LogLocalStore",                            // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreObject
+                "LogLocalStore",                            // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStorePointer
+                "LogLocalStoreUnmanaged",                   // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreUnmanaged
+                "LogLocalStoreParameterAlias",              // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreParameterAlias
+                "LogParameterStore",                        // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreBoolean
+                "LogParameterStore",                        // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreByte
+                "LogParameterStore",                        // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreUInt16
+                "LogParameterStore",                        // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreUInt32
+                "LogParameterStore",                        // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreUInt64
+                "LogParameterStore",                        // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreString
+                "LogParameterStore",                        // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreObject
+                "LogParameterStore",                        // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStorePointer
+                "LogParameterStoreUnmanaged",               // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreUnmanaged
+                "LogParameterStoreParameterAlias",          // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreParameterAlias
+                "LogLocalStoreLocalAlias",                  // Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreLocalAlias
+
                 ".ctor",                                    // System_Runtime_CompilerServices_NullableAttribute__ctorByte
                 ".ctor",                                    // System_Runtime_CompilerServices_NullableAttribute__ctorTransformFlags
                 ".ctor",                                    // System_Runtime_CompilerServices_NullableContextAttribute__ctor
diff --git a/src/Compilers/Core/Portable/WellKnownTypes.cs b/src/Compilers/Core/Portable/WellKnownTypes.cs
index 6b16d7b96fec6..25eaebfc06e49 100644
--- a/src/Compilers/Core/Portable/WellKnownTypes.cs
+++ b/src/Compilers/Core/Portable/WellKnownTypes.cs
@@ -265,6 +265,7 @@ internal enum WellKnownType
         System_Runtime_CompilerServices_TupleElementNamesAttribute,
 
         Microsoft_CodeAnalysis_Runtime_Instrumentation,
+        Microsoft_CodeAnalysis_Runtime_LocalStoreTracker,
         System_Runtime_CompilerServices_NullableAttribute,
         System_Runtime_CompilerServices_NullableContextAttribute,
         System_Runtime_CompilerServices_NullablePublicOnlyAttribute,
@@ -587,6 +588,7 @@ internal static class WellKnownTypes
             "System.Runtime.CompilerServices.TupleElementNamesAttribute",
 
             "Microsoft.CodeAnalysis.Runtime.Instrumentation",
+            "Microsoft.CodeAnalysis.Runtime.LocalStoreTracker",
 
             "System.Runtime.CompilerServices.NullableAttribute",
             "System.Runtime.CompilerServices.NullableContextAttribute",
diff --git a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.cs.xlf b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.cs.xlf
index 3767523584f70..8b3f53905a164 100644
--- a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.cs.xlf
+++ b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.cs.xlf
@@ -119,6 +119,11 @@
         <target state="translated">Parametr {0} musí být symbol z této kompilace nebo některé odkazované sestavení.</target>
         <note />
       </trans-unit>
+      <trans-unit id="MethodSymbolExpected">
+        <source>Method symbol expected</source>
+        <target state="new">Method symbol expected</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ModuleHasInvalidAttributes">
         <source>Module has invalid attributes.</source>
         <target state="translated">Modul zahrnuje neplatné atributy.</target>
diff --git a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.de.xlf b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.de.xlf
index a6f45e4b3a9b9..7e1b521cbcb4c 100644
--- a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.de.xlf
+++ b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.de.xlf
@@ -119,6 +119,11 @@
         <target state="translated">Der Parameter "{0}" muss ein Symbol aus dieser Zusammenstellung oder eine referenzierte Assembly sein.</target>
         <note />
       </trans-unit>
+      <trans-unit id="MethodSymbolExpected">
+        <source>Method symbol expected</source>
+        <target state="new">Method symbol expected</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ModuleHasInvalidAttributes">
         <source>Module has invalid attributes.</source>
         <target state="translated">Das Modul weist ungültige Attribute auf.</target>
diff --git a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.es.xlf b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.es.xlf
index f36c6a138e81c..74468fe5f6e3c 100644
--- a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.es.xlf
+++ b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.es.xlf
@@ -119,6 +119,11 @@
         <target state="translated">El parámetro "{0}" debe ser un símbolo de esta compilación o algún ensamble al que se hace referencia.</target>
         <note />
       </trans-unit>
+      <trans-unit id="MethodSymbolExpected">
+        <source>Method symbol expected</source>
+        <target state="new">Method symbol expected</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ModuleHasInvalidAttributes">
         <source>Module has invalid attributes.</source>
         <target state="translated">El módulo tiene atributos no válidos.</target>
diff --git a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.fr.xlf b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.fr.xlf
index e0cbab3616e8d..0a54f9d95db4a 100644
--- a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.fr.xlf
+++ b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.fr.xlf
@@ -119,6 +119,11 @@
         <target state="translated">Le paramètre '{0}' doit être un symbole de cette compilation ou un assembly référencé.</target>
         <note />
       </trans-unit>
+      <trans-unit id="MethodSymbolExpected">
+        <source>Method symbol expected</source>
+        <target state="new">Method symbol expected</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ModuleHasInvalidAttributes">
         <source>Module has invalid attributes.</source>
         <target state="translated">Le module a des attributs non valides.</target>
diff --git a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.it.xlf b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.it.xlf
index ed0062307a326..e5d049106ec2d 100644
--- a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.it.xlf
+++ b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.it.xlf
@@ -119,6 +119,11 @@
         <target state="translated">Il parametro '{0}' deve essere un simbolo di questa compilazione oppure un qualsiasi assembly cui viene fatto riferimento.</target>
         <note />
       </trans-unit>
+      <trans-unit id="MethodSymbolExpected">
+        <source>Method symbol expected</source>
+        <target state="new">Method symbol expected</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ModuleHasInvalidAttributes">
         <source>Module has invalid attributes.</source>
         <target state="translated">Il modulo contiene attributi non validi.</target>
diff --git a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.ja.xlf b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.ja.xlf
index f6a5be23fe863..073ce97d97862 100644
--- a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.ja.xlf
+++ b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.ja.xlf
@@ -119,6 +119,11 @@
         <target state="translated">パラメーター '{0}' は、このコンパイルまたはいくつかの参照アセンブリのシンボルにする必要があります。</target>
         <note />
       </trans-unit>
+      <trans-unit id="MethodSymbolExpected">
+        <source>Method symbol expected</source>
+        <target state="new">Method symbol expected</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ModuleHasInvalidAttributes">
         <source>Module has invalid attributes.</source>
         <target state="translated">モジュールに無効な属性があります。</target>
diff --git a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.ko.xlf b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.ko.xlf
index 2cf0f6ab726dd..c42e09e90e326 100644
--- a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.ko.xlf
+++ b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.ko.xlf
@@ -119,6 +119,11 @@
         <target state="translated">'{0}' 매개 변수는 이 컴파일 또는 일부 참조된 어셈블리의 기호여야 합니다.</target>
         <note />
       </trans-unit>
+      <trans-unit id="MethodSymbolExpected">
+        <source>Method symbol expected</source>
+        <target state="new">Method symbol expected</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ModuleHasInvalidAttributes">
         <source>Module has invalid attributes.</source>
         <target state="translated">모듈에 잘못된 특성이 있습니다.</target>
diff --git a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.pl.xlf b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.pl.xlf
index 1479db7bf502b..f562bfb32d8b8 100644
--- a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.pl.xlf
+++ b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.pl.xlf
@@ -119,6 +119,11 @@
         <target state="translated">Parametr „{0}” musi być symbolem z tej kompilacji lub przywoływanym zestawem.</target>
         <note />
       </trans-unit>
+      <trans-unit id="MethodSymbolExpected">
+        <source>Method symbol expected</source>
+        <target state="new">Method symbol expected</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ModuleHasInvalidAttributes">
         <source>Module has invalid attributes.</source>
         <target state="translated">Moduł ma nieprawidłowe atrybuty.</target>
diff --git a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.pt-BR.xlf b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.pt-BR.xlf
index 6ac3153012b83..f7e098bc8bd74 100644
--- a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.pt-BR.xlf
+++ b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.pt-BR.xlf
@@ -119,6 +119,11 @@
         <target state="translated">O parâmetro '{0}' deve ser um símbolo desta compilação ou um assembly referenciado.</target>
         <note />
       </trans-unit>
+      <trans-unit id="MethodSymbolExpected">
+        <source>Method symbol expected</source>
+        <target state="new">Method symbol expected</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ModuleHasInvalidAttributes">
         <source>Module has invalid attributes.</source>
         <target state="translated">O módulo tem atributos inválidos.</target>
diff --git a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.ru.xlf b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.ru.xlf
index bec0b4660f049..dfc55d203afcf 100644
--- a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.ru.xlf
+++ b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.ru.xlf
@@ -119,6 +119,11 @@
         <target state="translated">Параметр "{0}" должен быть символом из этой компиляции или из другой сборки, на которую она ссылается.</target>
         <note />
       </trans-unit>
+      <trans-unit id="MethodSymbolExpected">
+        <source>Method symbol expected</source>
+        <target state="new">Method symbol expected</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ModuleHasInvalidAttributes">
         <source>Module has invalid attributes.</source>
         <target state="translated">Модуль содержит недопустимые атрибуты.</target>
diff --git a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.tr.xlf b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.tr.xlf
index 241554052476c..dde2ba92834bd 100644
--- a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.tr.xlf
+++ b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.tr.xlf
@@ -119,6 +119,11 @@
         <target state="translated">'{0}' parametresi bu derleme veya bazı başvurulan derleme bir sembol olması gerekir.</target>
         <note />
       </trans-unit>
+      <trans-unit id="MethodSymbolExpected">
+        <source>Method symbol expected</source>
+        <target state="new">Method symbol expected</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ModuleHasInvalidAttributes">
         <source>Module has invalid attributes.</source>
         <target state="translated">Modülde geçersiz öznitelikler var.</target>
diff --git a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.zh-Hans.xlf b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.zh-Hans.xlf
index 2df9d936e3854..fde2b9b702f36 100644
--- a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.zh-Hans.xlf
+++ b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.zh-Hans.xlf
@@ -119,6 +119,11 @@
         <target state="translated">参数“{0}”必须是此编译或某些引用程序集的符号。</target>
         <note />
       </trans-unit>
+      <trans-unit id="MethodSymbolExpected">
+        <source>Method symbol expected</source>
+        <target state="new">Method symbol expected</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ModuleHasInvalidAttributes">
         <source>Module has invalid attributes.</source>
         <target state="translated">模块具有无效属性。</target>
diff --git a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.zh-Hant.xlf b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.zh-Hant.xlf
index d78145dd65aef..8d5a10f189faf 100644
--- a/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.zh-Hant.xlf
+++ b/src/Compilers/Core/Portable/xlf/CodeAnalysisResources.zh-Hant.xlf
@@ -119,6 +119,11 @@
         <target state="translated">參數 '{0}' 必須是此編譯或某些參考組件中的符號。</target>
         <note />
       </trans-unit>
+      <trans-unit id="MethodSymbolExpected">
+        <source>Method symbol expected</source>
+        <target state="new">Method symbol expected</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ModuleHasInvalidAttributes">
         <source>Module has invalid attributes.</source>
         <target state="translated">模組有無效的屬性。</target>
diff --git a/src/Compilers/Test/Core/CommonTestBase.cs b/src/Compilers/Test/Core/CommonTestBase.cs
index 700035338d9ec..8f104ed92ad31 100644
--- a/src/Compilers/Test/Core/CommonTestBase.cs
+++ b/src/Compilers/Test/Core/CommonTestBase.cs
@@ -46,9 +46,9 @@ public readonly struct Verification
         public string? PEVerifyMessage { get; init; }
 
         /// <summary>
-        /// True if the expected messages include member tokens.
+        /// True if the expected messages include member tokens and MVIDs.
         /// </summary>
-        public bool IncludeTokens { get; init; }
+        public bool IncludeTokensAndModuleIds { get; init; }
 
         public static readonly Verification Skipped = new() { Status = VerificationStatus.Skipped };
         public static readonly Verification Passes = new() { Status = VerificationStatus.Passes };
diff --git a/src/Compilers/Test/Core/CompilationVerifier.cs b/src/Compilers/Test/Core/CompilationVerifier.cs
index 7e6396980acbc..97fe22d0c9ac4 100644
--- a/src/Compilers/Test/Core/CompilationVerifier.cs
+++ b/src/Compilers/Test/Core/CompilationVerifier.cs
@@ -15,6 +15,7 @@
 using System.Reflection.PortableExecutable;
 using System.Runtime.CompilerServices;
 using System.Text;
+using System.Text.RegularExpressions;
 using System.Xml.Linq;
 using ICSharpCode.Decompiler.Metadata;
 using Microsoft.CodeAnalysis;
@@ -345,6 +346,11 @@ private void ILVerify(Verification verification)
 
             if (!actualSuccess && verification.ILVerifyMessage != null && !IsEnglishLocal.Instance.ShouldSkip)
             {
+                if (!verification.IncludeTokensAndModuleIds)
+                {
+                    actualMessage = Regex.Replace(actualMessage, @"\[[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}\]", "");
+                }
+
                 AssertEx.AssertEqualToleratingWhitespaceDifferences(verification.ILVerifyMessage, actualMessage);
             }
 
@@ -560,9 +566,10 @@ private CompilationVerifier VerifyILImpl(
         }
 
         public string VisualizeIL(string qualifiedMethodName, bool realIL = false, bool sequencePoints = false, bool sequencePointsSource = true)
-        {
-            var methodData = _testData.GetMethodData(qualifiedMethodName);
+            => VisualizeIL(_testData.GetMethodData(qualifiedMethodName), realIL, sequencePoints, sequencePointsSource);
 
+        internal string VisualizeIL(CompilationTestData.MethodData methodData, bool realIL = false, bool sequencePoints = false, bool sequencePointsSource = true)
+        {
             Dictionary<int, string> markers = null;
 
             if (sequencePoints)
diff --git a/src/Compilers/Test/Core/InstrumentationChecker.cs b/src/Compilers/Test/Core/InstrumentationChecker.cs
index d6f216daf0590..af481314a1fb4 100644
--- a/src/Compilers/Test/Core/InstrumentationChecker.cs
+++ b/src/Compilers/Test/Core/InstrumentationChecker.cs
@@ -111,7 +111,7 @@ public static bool[] CreatePayload(System.Guid mvid, int methodIndex, int[] file
 
         public static void FlushPayload()
         {
-            Console.WriteLine(""Flushing"");
+            System.Console.WriteLine(""Flushing"");
             if (_payloads == null)
             {
                 return;
@@ -121,14 +121,14 @@ public static void FlushPayload()
                 bool[] payload = _payloads[i];
                 if (payload != null)
                 {
-                    Console.WriteLine(""Method "" + i.ToString());
+                    System.Console.WriteLine(""Method "" + i.ToString());
                     for (int j = 0; j < _fileIndices[i].Length; j++)
                     {
-                        Console.WriteLine(""File "" + _fileIndices[i][j].ToString());
+                        System.Console.WriteLine(""File "" + _fileIndices[i][j].ToString());
                     }
                     for (int j = 0; j < payload.Length; j++)
                     {
-                        Console.WriteLine(payload[j]);
+                        System.Console.WriteLine(payload[j]);
                         payload[j] = false;
                     }
                 }
diff --git a/src/Compilers/Test/Core/Metadata/ILBuilderVisualizer.cs b/src/Compilers/Test/Core/Metadata/ILBuilderVisualizer.cs
index a2d81f82a773f..845c29432a88f 100644
--- a/src/Compilers/Test/Core/Metadata/ILBuilderVisualizer.cs
+++ b/src/Compilers/Test/Core/Metadata/ILBuilderVisualizer.cs
@@ -18,6 +18,7 @@
 using Cci = Microsoft.Cci;
 using Microsoft.CodeAnalysis.Symbols;
 using System.Diagnostics;
+using System.Reflection.Metadata.Ecma335;
 
 namespace Roslyn.Test.Utilities
 {
@@ -45,23 +46,16 @@ public override string VisualizeSymbol(uint token, OperandType operandType)
         {
             if (operandType == OperandType.InlineTok)
             {
-                // Check for an encoding of the maximum method token index value.
-                if ((token & 0xff000000) == 0x40000000)
+                switch ((Cci.MetadataWriter.RawTokenEncoding)(token >> 24))
                 {
-                    return "Max Method Token Index";
-                }
+                    case Cci.MetadataWriter.RawTokenEncoding.GreatestMethodDefinitionRowId:
+                        return "Max Method Token Index";
 
-                // Check for an encoding of a source document index.
-                if ((token & 0xff000000) == 0x20000000)
-                {
-                    return "Source Document " + (token & 0x00ffffff).ToString();
+                    case Cci.MetadataWriter.RawTokenEncoding.DocumentRowId:
+                        return "Source Document " + (token & 0x00ffffff).ToString();
                 }
 
-                // Check for a raw token value, encoded with a 1 high-order bit.
-                if ((token & 0x80000000) != 0 && token != 0xffffffff)
-                {
-                    token &= 0x7fffffff;
-                }
+                token &= 0xffffff;
             }
 
             object reference = _tokenDeferral.GetReferenceFromToken(token);
diff --git a/src/Compilers/Test/Core/Platform/Desktop/DesktopRuntimeEnvironment.cs b/src/Compilers/Test/Core/Platform/Desktop/DesktopRuntimeEnvironment.cs
index 377bc2860014f..4bcb04e464bc9 100644
--- a/src/Compilers/Test/Core/Platform/Desktop/DesktopRuntimeEnvironment.cs
+++ b/src/Compilers/Test/Core/Platform/Desktop/DesktopRuntimeEnvironment.cs
@@ -342,7 +342,7 @@ public void Verify(Verification verification)
                 {
                     var actualMessage = ex.Output;
                     
-                    if (!verification.IncludeTokens)
+                    if (!verification.IncludeTokensAndModuleIds)
                     {
                         actualMessage = Regex.Replace(ex.Output, @"\[mdToken=0x[0-9a-fA-F]+\]", "");
                     }
diff --git a/src/Compilers/Test/Utilities/CSharp/CompilingTestBase.cs b/src/Compilers/Test/Utilities/CSharp/CompilingTestBase.cs
index d9896abd7721c..194fb9cae249e 100644
--- a/src/Compilers/Test/Utilities/CSharp/CompilingTestBase.cs
+++ b/src/Compilers/Test/Utilities/CSharp/CompilingTestBase.cs
@@ -36,7 +36,7 @@ internal static BoundBlock ParseAndBindMethodBody(string program, string typeNam
             TypeCompilationState compilationState = new TypeCompilationState(method.ContainingType, compilation, module);
 
             var diagnostics = DiagnosticBag.GetInstance();
-            var block = MethodCompiler.BindMethodBody(method, compilationState, new BindingDiagnosticBag(diagnostics));
+            var block = MethodCompiler.BindSynthesizedMethodBody(method, compilationState, new BindingDiagnosticBag(diagnostics));
             diagnostics.Free();
             return block;
         }
diff --git a/src/Compilers/VisualBasic/Portable/CodeGen/CodeGenerator.vb b/src/Compilers/VisualBasic/Portable/CodeGen/CodeGenerator.vb
index df115b9bc3d23..479e808325b56 100644
--- a/src/Compilers/VisualBasic/Portable/CodeGen/CodeGenerator.vb
+++ b/src/Compilers/VisualBasic/Portable/CodeGen/CodeGenerator.vb
@@ -194,7 +194,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGen
         End Sub
 
         Private Sub EmitSymbolToken(symbol As MethodSymbol, syntaxNode As SyntaxNode, Optional encodeAsRawDefinitionToken As Boolean = False)
-            _builder.EmitToken(_module.Translate(symbol, syntaxNode, _diagnostics, needDeclaration:=encodeAsRawDefinitionToken), syntaxNode, _diagnostics, encodeAsRawDefinitionToken)
+            Dim methodRef = _module.Translate(symbol, syntaxNode, _diagnostics, needDeclaration:=encodeAsRawDefinitionToken)
+            _builder.EmitToken(methodRef, syntaxNode, _diagnostics, If(encodeAsRawDefinitionToken, Cci.MetadataWriter.RawTokenEncoding.RowId, Cci.MetadataWriter.RawTokenEncoding.None))
         End Sub
 
         Private Sub EmitSymbolToken(symbol As TypeSymbol, syntaxNode As SyntaxNode)
diff --git a/src/Compilers/VisualBasic/Portable/Compilation/MethodCompiler.vb b/src/Compilers/VisualBasic/Portable/Compilation/MethodCompiler.vb
index ae5e4cb03e4b2..c06a48bfe6b95 100644
--- a/src/Compilers/VisualBasic/Portable/Compilation/MethodCompiler.vb
+++ b/src/Compilers/VisualBasic/Portable/Compilation/MethodCompiler.vb
@@ -26,12 +26,10 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
         Private ReadOnly _compilation As VisualBasicCompilation
         Private ReadOnly _cancellationToken As CancellationToken
         Private ReadOnly _emittingPdb As Boolean
-        Private ReadOnly _emitTestCoverageData As Boolean
         Private ReadOnly _diagnostics As BindingDiagnosticBag
         Private ReadOnly _hasDeclarationErrors As Boolean
         Private ReadOnly _moduleBeingBuiltOpt As PEModuleBuilder ' Nothing if compiling for diagnostics
         Private ReadOnly _filterOpt As Predicate(Of Symbol)      ' If not Nothing, limit analysis to specific symbols
-        Private ReadOnly _debugDocumentProvider As DebugDocumentProvider
 
         ' GetDiagnostics only needs to Bind. If we need to go further, _doEmitPhase needs to be set.
         ' It normally happens during actual compile, but also happens when getting emit diagnostics for
@@ -55,6 +53,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
         ' more chances to do inlined execution.
         Private ReadOnly _compilerTasks As ConcurrentStack(Of Task)
 
+        Private _lazyDebugDocumentProvider As DebugDocumentProvider
+
         ' Tracks whether any method body has hasErrors set, and used to avoid
         ' emitting if there are errors without corresponding diagnostics.
         ' NOTE: once the flag is set to true, it should never go back to false!!!
@@ -84,7 +84,6 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
         Private Sub New(compilation As VisualBasicCompilation,
                        moduleBeingBuiltOpt As PEModuleBuilder,
                        emittingPdb As Boolean,
-                       emitTestCoverageData As Boolean,
                        doLoweringPhase As Boolean,
                        doEmitPhase As Boolean,
                        hasDeclarationErrors As Boolean,
@@ -104,18 +103,22 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             _doLoweringPhase = doEmitPhase OrElse doLoweringPhase
             _doEmitPhase = doEmitPhase
             _emittingPdb = emittingPdb
-            _emitTestCoverageData = emitTestCoverageData
             _filterOpt = filter
 
-            If emittingPdb OrElse emitTestCoverageData Then
-                _debugDocumentProvider = Function(path As String, basePath As String) moduleBeingBuiltOpt.DebugDocumentsBuilder.GetOrAddDebugDocument(path, basePath, AddressOf CreateDebugDocumentForFile)
-            End If
-
             If compilation.Options.ConcurrentBuild Then
                 _compilerTasks = New ConcurrentStack(Of Task)()
             End If
         End Sub
 
+        Private Function GetDebugDocumentProvider(instrumentations As MethodInstrumentation) As DebugDocumentProvider
+            If _emittingPdb OrElse instrumentations.Kinds.Contains(InstrumentationKind.TestCoverage) Then
+                Debug.Assert(_moduleBeingBuiltOpt IsNot Nothing)
+                _lazyDebugDocumentProvider = Function(path As String, basePath As String) _moduleBeingBuiltOpt.DebugDocumentsBuilder.GetOrAddDebugDocument(path, basePath, AddressOf CreateDebugDocumentForFile)
+            End If
+
+            Return _lazyDebugDocumentProvider
+        End Function
+
         Private Shared Function IsDefinedOrImplementedInSourceTree(symbol As Symbol, tree As SyntaxTree, span As TextSpan?) As Boolean
             If symbol.IsDefinedInSourceTree(tree, span) Then
                 Return True
@@ -179,7 +182,6 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                                                                                      cancellationToken:=cancellationToken), PEModuleBuilder),
                                                                       Nothing),
                                               emittingPdb:=False,
-                                              emitTestCoverageData:=False,
                                               doLoweringPhase:=doLoweringPhase,
                                               doEmitPhase:=False,
                                               hasDeclarationErrors:=hasDeclarationErrors,
@@ -213,7 +215,6 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
         Friend Shared Sub CompileMethodBodies(compilation As VisualBasicCompilation,
                                               moduleBeingBuiltOpt As PEModuleBuilder,
                                               emittingPdb As Boolean,
-                                              emitTestCoverageData As Boolean,
                                               hasDeclarationErrors As Boolean,
                                               filter As Predicate(Of Symbol),
                                               diagnostics As BindingDiagnosticBag,
@@ -238,7 +239,6 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             Dim compiler = New MethodCompiler(compilation,
                                               moduleBeingBuiltOpt,
                                               emittingPdb,
-                                              emitTestCoverageData,
                                               doLoweringPhase:=True,
                                               doEmitPhase:=True,
                                               hasDeclarationErrors:=hasDeclarationErrors,
@@ -318,11 +318,10 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                                              stateMachineStateDebugInfos:=ImmutableArray(Of StateMachineStateDebugInfo).Empty,
                                              stateMachineTypeOpt:=Nothing,
                                              variableSlotAllocatorOpt:=Nothing,
-                                             debugDocumentProvider:=Nothing,
                                              diagnostics:=diagnostics,
+                                             debugDocumentProvider:=Nothing,
                                              emittingPdb:=False,
-                                             emitTestCoverageData:=False,
-                                             dynamicAnalysisSpans:=ImmutableArray(Of SourceSpan).Empty)
+                                             codeCoverageSpans:=ImmutableArray(Of SourceSpan).Empty)
                 moduleBeingBuilt.SetMethodBody(synthesizedEntryPoint, emittedBody)
             End If
 
@@ -889,11 +888,10 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                                                          stateMachineStateDebugInfos:=ImmutableArray(Of StateMachineStateDebugInfo).Empty,
                                                          stateMachineTypeOpt:=Nothing,
                                                          variableSlotAllocatorOpt:=Nothing,
-                                                         debugDocumentProvider:=If(_emitTestCoverageData, _debugDocumentProvider, Nothing),
+                                                         debugDocumentProvider:=GetDebugDocumentProvider(MethodInstrumentation.Empty),
                                                          diagnostics:=diagnosticsThisMethod,
                                                          emittingPdb:=False,
-                                                         emitTestCoverageData:=_emitTestCoverageData,
-                                                         dynamicAnalysisSpans:=ImmutableArray(Of SourceSpan).Empty)
+                                                         codeCoverageSpans:=ImmutableArray(Of SourceSpan).Empty)
 
                     ' error while generating IL
                     If emittedBody Is Nothing Then
@@ -936,7 +934,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                         Dim statemachineTypeOpt As StateMachineTypeSymbol = Nothing
 
                         Dim delegateRelaxationIdDispenser = 0
-                        Dim dynamicAnalysisSpans As ImmutableArray(Of SourceSpan) = ImmutableArray(Of SourceSpan).Empty
+                        Dim codeCoverageSpans As ImmutableArray(Of SourceSpan) = ImmutableArray(Of SourceSpan).Empty
+                        Dim instrumentation = _moduleBeingBuiltOpt.GetMethodBodyInstrumentations(method)
 
                         Dim rewrittenBody = Rewriter.LowerBodyOrInitializer(
                             method,
@@ -944,9 +943,9 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                             boundBody,
                             previousSubmissionFields:=Nothing,
                             compilationState:=compilationState,
-                            instrumentForDynamicAnalysis:=False,
-                            dynamicAnalysisSpans:=dynamicAnalysisSpans,
-                            debugDocumentProvider:=_debugDocumentProvider,
+                            instrumentations:=instrumentation,
+                            codeCoverageSpans:=codeCoverageSpans,
+                            debugDocumentProvider:=GetDebugDocumentProvider(instrumentation),
                             diagnostics:=diagnosticsThisMethod,
                             lazyVariableSlotAllocator:=lazyVariableSlotAllocator,
                             lambdaDebugInfoBuilder:=lambdaDebugInfoBuilder,
@@ -972,8 +971,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                                                              debugDocumentProvider:=Nothing,
                                                              diagnostics:=diagnosticsThisMethod,
                                                              emittingPdb:=False,
-                                                             emitTestCoverageData:=False,
-                                                             dynamicAnalysisSpans:=dynamicAnalysisSpans)
+                                                             codeCoverageSpans:=codeCoverageSpans)
                         End If
                     End If
 
@@ -1028,11 +1026,10 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                                                          stateMachineStateDebugInfos:=methodWithBody.StateMachineStatesDebugInfo,
                                                          stateMachineTypeOpt:=methodWithBody.StateMachineType,
                                                          variableSlotAllocatorOpt:=Nothing,
-                                                         debugDocumentProvider:=_debugDocumentProvider,
+                                                         debugDocumentProvider:=GetDebugDocumentProvider(MethodInstrumentation.Empty),
                                                          diagnostics:=diagnosticsThisMethod,
                                                          emittingPdb:=_emittingPdb,
-                                                         emitTestCoverageData:=_emitTestCoverageData,
-                                                         dynamicAnalysisSpans:=ImmutableArray(Of SourceSpan).Empty)
+                                                         codeCoverageSpans:=ImmutableArray(Of SourceSpan).Empty)
 
                     _diagnostics.AddRange(diagnosticsThisMethod)
                     diagnosticsThisMethod.Free()
@@ -1261,7 +1258,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
 
                 Try
                     If sourceMethod.SetDiagnostics(diagsForCurrentMethod.DiagnosticBag.ToReadOnly()) Then
-                        If Compilation.ShouldAddEvent(method) Then
+                        If compilation.ShouldAddEvent(method) Then
                             If block Is Nothing Then
                                 compilation.SymbolDeclaredEvent(sourceMethod)
                             Else
@@ -1370,15 +1367,16 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                 Dim lambdaDebugInfoBuilder = ArrayBuilder(Of LambdaDebugInfo).GetInstance()
                 Dim closureDebugInfoBuilder = ArrayBuilder(Of ClosureDebugInfo).GetInstance()
                 Dim stateMachineStateDebugInfoBuilder = ArrayBuilder(Of StateMachineStateDebugInfo).GetInstance()
+                Dim methodInstrumentations = _moduleBeingBuiltOpt.GetMethodBodyInstrumentations(setter)
 
                 setterBody = Rewriter.LowerBodyOrInitializer(setter,
                                                              withEventPropertyIdDispenser,
                                                              setterBody,
                                                              previousSubmissionFields,
                                                              compilationState,
-                                                             instrumentForDynamicAnalysis:=False,
-                                                             dynamicAnalysisSpans:=ImmutableArray(Of SourceSpan).Empty,
-                                                             debugDocumentProvider:=_debugDocumentProvider,
+                                                             instrumentations:=methodInstrumentations,
+                                                             codeCoverageSpans:=ImmutableArray(Of SourceSpan).Empty,
+                                                             debugDocumentProvider:=GetDebugDocumentProvider(methodInstrumentations),
                                                              diagnostics:=diagnostics,
                                                              lazyVariableSlotAllocator:=Nothing,
                                                              lambdaDebugInfoBuilder:=lambdaDebugInfoBuilder,
@@ -1482,16 +1480,17 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             Dim lambdaDebugInfoBuilder = ArrayBuilder(Of LambdaDebugInfo).GetInstance()
             Dim closureDebugInfoBuilder = ArrayBuilder(Of ClosureDebugInfo).GetInstance()
             Dim stateMachineStateDebugInfoBuilder = ArrayBuilder(Of StateMachineStateDebugInfo).GetInstance()
-            Dim dynamicAnalysisSpans As ImmutableArray(Of SourceSpan) = ImmutableArray(Of SourceSpan).Empty
+            Dim codeCoverageSpans As ImmutableArray(Of SourceSpan) = ImmutableArray(Of SourceSpan).Empty
+            Dim instrumentation = If(_moduleBeingBuiltOpt IsNot Nothing, _moduleBeingBuiltOpt.GetMethodBodyInstrumentations(method), Nothing)
 
             body = Rewriter.LowerBodyOrInitializer(method,
                                                    methodOrdinal,
                                                    body,
                                                    previousSubmissionFields,
                                                    compilationState,
-                                                   _emitTestCoverageData,
-                                                   dynamicAnalysisSpans,
-                                                   _debugDocumentProvider,
+                                                   instrumentation,
+                                                   codeCoverageSpans,
+                                                   GetDebugDocumentProvider(instrumentation),
                                                    diagnostics,
                                                    lazyVariableSlotAllocator,
                                                    lambdaDebugInfoBuilder,
@@ -1540,11 +1539,10 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                                                               stateMachineStateDebugInfoBuilder.ToImmutable(),
                                                               stateMachineTypeOpt,
                                                               lazyVariableSlotAllocator,
-                                                              _debugDocumentProvider,
+                                                              GetDebugDocumentProvider(instrumentation),
                                                               diagnostics,
                                                               emittingPdb:=_emittingPdb,
-                                                              emitTestCoverageData:=_emitTestCoverageData,
-                                                              dynamicAnalysisSpans:=dynamicAnalysisSpans)
+                                                              codeCoverageSpans:=codeCoverageSpans)
 
                 _moduleBeingBuiltOpt.SetMethodBody(If(method.PartialDefinitionPart, method), methodBody)
             End If
@@ -1571,8 +1569,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                                                   debugDocumentProvider As DebugDocumentProvider,
                                                   diagnostics As BindingDiagnosticBag,
                                                   emittingPdb As Boolean,
-                                                  emitTestCoverageData As Boolean,
-                                                  dynamicAnalysisSpans As ImmutableArray(Of SourceSpan)) As MethodBody
+                                                  codeCoverageSpans As ImmutableArray(Of SourceSpan)) As MethodBody
             Debug.Assert(diagnostics.AccumulatesDiagnostics)
 
             Dim compilation = moduleBuilder.Compilation
@@ -1670,12 +1667,6 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
 
                 Dim localScopes = builder.GetAllScopes()
 
-                Dim dynamicAnalysisDataOpt As DynamicAnalysisMethodBodyData = Nothing
-                If emitTestCoverageData Then
-                    Debug.Assert(debugDocumentProvider IsNot Nothing)
-                    dynamicAnalysisDataOpt = New DynamicAnalysisMethodBodyData(dynamicAnalysisSpans)
-                End If
-
                 Return New MethodBody(builder.RealizedIL,
                                       builder.MaxStack,
                                       If(method.PartialDefinitionPart, method).GetCciAdapter(),
@@ -1697,7 +1688,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                                       stateMachineAwaiterSlots:=stateMachineAwaiterSlots,
                                       stateMachineStatesDebugInfo:=StateMachineStatesDebugInfo.Create(variableSlotAllocatorOpt, stateMachineStateDebugInfos),
                                       stateMachineMoveNextDebugInfoOpt:=moveNextBodyDebugInfoOpt,
-                                      dynamicAnalysisDataOpt:=dynamicAnalysisDataOpt)
+                                      codeCoverageSpans:=codeCoverageSpans)
             Finally
                 ' Free resources used by the basic blocks in the builder.
                 builder.FreeBasicBlocks()
diff --git a/src/Compilers/VisualBasic/Portable/Compilation/VisualBasicCompilation.vb b/src/Compilers/VisualBasic/Portable/Compilation/VisualBasicCompilation.vb
index 04ee97c212748..22c98b229a32e 100644
--- a/src/Compilers/VisualBasic/Portable/Compilation/VisualBasicCompilation.vb
+++ b/src/Compilers/VisualBasic/Portable/Compilation/VisualBasicCompilation.vb
@@ -2439,15 +2439,15 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
         Friend Overrides Function CompileMethods(
             moduleBuilder As CommonPEModuleBuilder,
             emittingPdb As Boolean,
-            emitMetadataOnly As Boolean,
-            emitTestCoverageData As Boolean,
-            diagnostics As DiagnosticBag,
+            Diagnostics As DiagnosticBag,
             filterOpt As Predicate(Of ISymbolInternal),
             cancellationToken As CancellationToken) As Boolean
 
+            Dim emitMetadataOnly = moduleBuilder.EmitOptions.EmitMetadataOnly
+
             ' The diagnostics should include syntax and declaration errors. We insert these before calling Emitter.Emit, so that we don't emit
             ' metadata if there are declaration errors or method body errors (but we do insert all errors from method body binding...)
-            Dim hasDeclarationErrors = Not FilterAndAppendDiagnostics(diagnostics, GetDiagnostics(CompilationStage.Declare, True, cancellationToken), exclude:=Nothing, cancellationToken)
+            Dim hasDeclarationErrors = Not FilterAndAppendDiagnostics(Diagnostics, GetDiagnostics(CompilationStage.Declare, True, cancellationToken), exclude:=Nothing, cancellationToken)
 
             Dim moduleBeingBuilt = DirectCast(moduleBuilder, PEModuleBuilder)
 
@@ -2457,7 +2457,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             ' We don't need to translate them if there are any declaration errors since 
             ' we are not going to emit the metadata.
             If Not hasDeclarationErrors Then
-                moduleBeingBuilt.TranslateImports(diagnostics)
+                moduleBeingBuilt.TranslateImports(Diagnostics)
             End If
 
             If emitMetadataOnly Then
@@ -2467,7 +2467,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
 
                 If moduleBeingBuilt.SourceModule.HasBadAttributes Then
                     ' If there were errors but no declaration diagnostics, explicitly add a "Failed to emit module" error.
-                    diagnostics.Add(ERRID.ERR_ModuleEmitFailure, NoLocation.Singleton, moduleBeingBuilt.SourceModule.Name,
+                    Diagnostics.Add(ERRID.ERR_ModuleEmitFailure, NoLocation.Singleton, moduleBeingBuilt.SourceModule.Name,
                         New LocalizableResourceString(NameOf(CodeAnalysisResources.ModuleHasInvalidAttributes), CodeAnalysisResources.ResourceManager, GetType(CodeAnalysisResources)))
                     Return False
                 End If
@@ -2475,8 +2475,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                 SynthesizedMetadataCompiler.ProcessSynthesizedMembers(Me, moduleBeingBuilt, cancellationToken)
             Else
                 ' start generating PDB checksums if we need to emit PDBs
-                If (emittingPdb OrElse emitTestCoverageData) AndAlso
-                   Not CreateDebugDocuments(moduleBeingBuilt.DebugDocumentsBuilder, moduleBeingBuilt.EmbeddedTexts, diagnostics) Then
+                If (emittingPdb OrElse moduleBuilder.EmitOptions.InstrumentationKinds.Contains(InstrumentationKind.TestCoverage)) AndAlso
+                   Not CreateDebugDocuments(moduleBeingBuilt.DebugDocumentsBuilder, moduleBeingBuilt.EmbeddedTexts, Diagnostics) Then
                     Return False
                 End If
 
@@ -2490,13 +2490,12 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                     Me,
                     moduleBeingBuilt,
                     emittingPdb,
-                    emitTestCoverageData,
                     hasDeclarationErrors,
                     filterOpt,
                     New BindingDiagnosticBag(methodBodyDiagnosticBag),
                     cancellationToken)
 
-                Dim hasMethodBodyErrors As Boolean = Not FilterAndAppendAndFreeDiagnostics(diagnostics, methodBodyDiagnosticBag, cancellationToken)
+                Dim hasMethodBodyErrors As Boolean = Not FilterAndAppendAndFreeDiagnostics(Diagnostics, methodBodyDiagnosticBag, cancellationToken)
                 If hasDeclarationErrors OrElse hasMethodBodyErrors Then
                     Return False
                 End If
diff --git a/src/Compilers/VisualBasic/Portable/Emit/EditAndContinue/PEDeltaAssemblyBuilder.vb b/src/Compilers/VisualBasic/Portable/Emit/EditAndContinue/PEDeltaAssemblyBuilder.vb
index 93ae067450663..3be20bcb0d51d 100644
--- a/src/Compilers/VisualBasic/Portable/Emit/EditAndContinue/PEDeltaAssemblyBuilder.vb
+++ b/src/Compilers/VisualBasic/Portable/Emit/EditAndContinue/PEDeltaAssemblyBuilder.vb
@@ -251,6 +251,10 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Emit
             Return _previousDefinitions.TryCreateVariableSlotAllocator(_previousGeneration, Compilation, method, topLevelMethod, diagnostics)
         End Function
 
+        Friend Overrides Function GetMethodBodyInstrumentations(method As MethodSymbol) As MethodInstrumentation
+            Return _previousDefinitions.GetMethodBodyInstrumentations(method)
+        End Function
+
         Friend Overrides Function GetPreviousAnonymousTypes() As ImmutableArray(Of AnonymousTypeKey)
             Return ImmutableArray.CreateRange(_previousGeneration.AnonymousTypeMap.Keys)
         End Function
diff --git a/src/Compilers/VisualBasic/Portable/Emit/PEModuleBuilder.vb b/src/Compilers/VisualBasic/Portable/Emit/PEModuleBuilder.vb
index 0d5211f7c9038..e73322bffec5d 100644
--- a/src/Compilers/VisualBasic/Portable/Emit/PEModuleBuilder.vb
+++ b/src/Compilers/VisualBasic/Portable/Emit/PEModuleBuilder.vb
@@ -321,6 +321,10 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Emit
             Return Nothing
         End Function
 
+        Friend Overridable Function GetMethodBodyInstrumentations(method As MethodSymbol) As MethodInstrumentation
+            Return New MethodInstrumentation() With {.Kinds = EmitOptions.InstrumentationKinds}
+        End Function
+
         Friend Overridable Function GetPreviousAnonymousTypes() As ImmutableArray(Of AnonymousTypeKey)
             Return ImmutableArray(Of AnonymousTypeKey).Empty
         End Function
diff --git a/src/Compilers/VisualBasic/Portable/Lowering/Rewriter.vb b/src/Compilers/VisualBasic/Portable/Lowering/Rewriter.vb
index d72d7dee8292a..107774e9f2bfd 100644
--- a/src/Compilers/VisualBasic/Portable/Lowering/Rewriter.vb
+++ b/src/Compilers/VisualBasic/Portable/Lowering/Rewriter.vb
@@ -6,6 +6,7 @@ Imports System.Collections.Immutable
 Imports System.Diagnostics.CodeAnalysis
 Imports System.Runtime.InteropServices
 Imports Microsoft.CodeAnalysis.CodeGen
+Imports Microsoft.CodeAnalysis.Emit
 Imports Microsoft.CodeAnalysis.PooledObjects
 Imports Microsoft.CodeAnalysis.VisualBasic.Symbols
 
@@ -19,8 +20,8 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             body As BoundBlock,
             previousSubmissionFields As SynthesizedSubmissionFields,
             compilationState As TypeCompilationState,
-            instrumentForDynamicAnalysis As Boolean,
-            <Out> ByRef dynamicAnalysisSpans As ImmutableArray(Of SourceSpan),
+            instrumentations As MethodInstrumentation,
+            <Out> ByRef codeCoverageSpans As ImmutableArray(Of SourceSpan),
             debugDocumentProvider As DebugDocumentProvider,
             diagnostics As BindingDiagnosticBag,
             ByRef lazyVariableSlotAllocator As VariableSlotAllocator,
@@ -43,11 +44,10 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             Dim flags = If(allowOmissionOfConditionalCalls, LocalRewriter.RewritingFlags.AllowOmissionOfConditionalCalls, LocalRewriter.RewritingFlags.Default)
             Dim localDiagnostics = BindingDiagnosticBag.GetInstance(diagnostics)
             Debug.Assert(localDiagnostics.AccumulatesDiagnostics)
-            dynamicAnalysisSpans = ImmutableArray(Of SourceSpan).Empty
 
             Try
-                Dim dynamicInstrumenter As CodeCoverageInstrumenter =
-                    If(instrumentForDynamicAnalysis,
+                Dim codeCoverageInstrumenter As CodeCoverageInstrumenter =
+                    If(Not isBodySynthesized AndAlso instrumentations.Kinds.Contains(InstrumentationKind.TestCoverage),
                         CodeCoverageInstrumenter.TryCreate(method, body, New SyntheticBoundNodeFactory(method, method, body.Syntax, compilationState, diagnostics), diagnostics, debugDocumentProvider, Instrumenter.NoOp),
                         Nothing)
 
@@ -62,12 +62,10 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
                                                     sawLambdas,
                                                     symbolsCapturedWithoutCopyCtor,
                                                     flags,
-                                                    If(dynamicInstrumenter IsNot Nothing, New DebugInfoInjector(dynamicInstrumenter), DebugInfoInjector.Singleton),
+                                                    If(codeCoverageInstrumenter IsNot Nothing, New DebugInfoInjector(codeCoverageInstrumenter), DebugInfoInjector.Singleton),
                                                     currentMethod:=Nothing)
 
-                If dynamicInstrumenter IsNot Nothing Then
-                    dynamicAnalysisSpans = dynamicInstrumenter.DynamicAnalysisSpans
-                End If
+                codeCoverageSpans = If(codeCoverageInstrumenter IsNot Nothing, codeCoverageInstrumenter.DynamicAnalysisSpans, ImmutableArray(Of SourceSpan).Empty)
 
                 If loweredBody.HasErrors OrElse localDiagnostics.HasAnyErrors Then
                     diagnostics.AddRangeAndFree(localDiagnostics)
diff --git a/src/Compilers/VisualBasic/Portable/Symbols/Source/SourceMemberContainerTypeSymbol.vb b/src/Compilers/VisualBasic/Portable/Symbols/Source/SourceMemberContainerTypeSymbol.vb
index e618258329341..3cef4c4b7eef5 100644
--- a/src/Compilers/VisualBasic/Portable/Symbols/Source/SourceMemberContainerTypeSymbol.vb
+++ b/src/Compilers/VisualBasic/Portable/Symbols/Source/SourceMemberContainerTypeSymbol.vb
@@ -1624,7 +1624,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols
                 Return s_emptyTypeMembers
             End If
 
-            Return children.Select(Function(decl) CreateNestedType(decl)).ToDictionary(
+            Return children.Select(Function(decl) CreateNestedType(decl)).ToMultiDictionary(
                 Function(decl) decl.Name,
                 IdentifierComparison.Comparer)
         End Function
diff --git a/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/WellKnownTypeValidationTests.vb b/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/WellKnownTypeValidationTests.vb
index 9e59bae6a852e..ad5585058313e 100644
--- a/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/WellKnownTypeValidationTests.vb
+++ b/src/Compilers/VisualBasic/Test/Symbol/SymbolsTests/WellKnownTypeValidationTests.vb
@@ -562,6 +562,7 @@ End Namespace
                         ' Not a real type
                         Continue For
                     Case WellKnownType.Microsoft_CodeAnalysis_Runtime_Instrumentation,
+                         WellKnownType.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker,
                          WellKnownType.System_Runtime_CompilerServices_IsReadOnlyAttribute,
                          WellKnownType.System_Runtime_CompilerServices_IsByRefLikeAttribute,
                          WellKnownType.System_Runtime_CompilerServices_IsUnmanagedAttribute,
@@ -636,6 +637,7 @@ End Namespace
                         ' Not a real type
                         Continue For
                     Case WellKnownType.Microsoft_CodeAnalysis_Runtime_Instrumentation,
+                         WellKnownType.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker,
                          WellKnownType.System_Runtime_CompilerServices_IsReadOnlyAttribute,
                          WellKnownType.System_Runtime_CompilerServices_IsByRefLikeAttribute,
                          WellKnownType.System_Runtime_CompilerServices_IsUnmanagedAttribute,
@@ -734,6 +736,33 @@ End Namespace
                         Continue For
                     Case WellKnownMember.Microsoft_CodeAnalysis_Runtime_Instrumentation__CreatePayloadForMethodsSpanningSingleFile,
                          WellKnownMember.Microsoft_CodeAnalysis_Runtime_Instrumentation__CreatePayloadForMethodsSpanningMultipleFiles,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogMethodEntry,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLambdaEntry,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogStateMachineMethodEntry,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogStateMachineLambdaEntry,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogReturn,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__GetNewStateMachineInstanceId,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreBoolean,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreByte,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreUInt16,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreUInt32,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreUInt64,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreString,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreObject,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStorePointer,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreUnmanaged,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreParameterAlias,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreBoolean,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreByte,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreUInt16,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreUInt32,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreUInt64,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreString,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreObject,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStorePointer,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreUnmanaged,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreParameterAlias,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreLocalAlias,
                          WellKnownMember.System_Runtime_CompilerServices_IsReadOnlyAttribute__ctor,
                          WellKnownMember.System_Runtime_CompilerServices_IsByRefLikeAttribute__ctor,
                          WellKnownMember.System_Runtime_CompilerServices_IsUnmanagedAttribute__ctor,
@@ -890,6 +919,33 @@ End Namespace
                         Continue For
                     Case WellKnownMember.Microsoft_CodeAnalysis_Runtime_Instrumentation__CreatePayloadForMethodsSpanningSingleFile,
                          WellKnownMember.Microsoft_CodeAnalysis_Runtime_Instrumentation__CreatePayloadForMethodsSpanningMultipleFiles,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogMethodEntry,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLambdaEntry,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogStateMachineMethodEntry,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogStateMachineLambdaEntry,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogReturn,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__GetNewStateMachineInstanceId,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreBoolean,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreByte,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreUInt16,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreUInt32,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreUInt64,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreString,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreObject,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStorePointer,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreUnmanaged,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreParameterAlias,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreBoolean,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreByte,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreUInt16,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreUInt32,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreUInt64,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreString,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreObject,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStorePointer,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreUnmanaged,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogParameterStoreParameterAlias,
+                         WellKnownMember.Microsoft_CodeAnalysis_Runtime_LocalStoreTracker__LogLocalStoreLocalAlias,
                          WellKnownMember.System_Runtime_CompilerServices_IsReadOnlyAttribute__ctor,
                          WellKnownMember.System_Runtime_CompilerServices_IsByRefLikeAttribute__ctor,
                          WellKnownMember.System_Runtime_CompilerServices_IsUnmanagedAttribute__ctor,
diff --git a/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/Rewriters/CapturedVariableRewriter.cs b/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/Rewriters/CapturedVariableRewriter.cs
index 0bcaadd943ada..f0abcca81aec7 100644
--- a/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/Rewriters/CapturedVariableRewriter.cs
+++ b/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/Rewriters/CapturedVariableRewriter.cs
@@ -48,7 +48,7 @@ public override BoundNode VisitBlock(BoundBlock node)
             var rewrittenLocals = node.Locals.WhereAsArray((local, rewriter) => local.IsCompilerGenerated || local.Name == null || rewriter.GetVariable(local.Name) == null, this);
             var rewrittenLocalFunctions = node.LocalFunctions;
             var rewrittenStatements = VisitList(node.Statements);
-            return node.Update(rewrittenLocals, rewrittenLocalFunctions, node.HasUnsafeModifier, rewrittenStatements);
+            return node.Update(rewrittenLocals, rewrittenLocalFunctions, node.HasUnsafeModifier, instrumentation: null, rewrittenStatements);
         }
 
         public override BoundNode VisitLocal(BoundLocal node)
diff --git a/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/Symbols/EEMethodSymbol.cs b/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/Symbols/EEMethodSymbol.cs
index d542811a49c76..7ce61917ed722 100644
--- a/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/Symbols/EEMethodSymbol.cs
+++ b/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/Symbols/EEMethodSymbol.cs
@@ -11,6 +11,7 @@
 using System.Linq;
 using Microsoft.CodeAnalysis.CodeGen;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
+using Microsoft.CodeAnalysis.Emit;
 using Microsoft.CodeAnalysis.ExpressionEvaluator;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Roslyn.Utilities;
@@ -544,10 +545,6 @@ internal override void GenerateMethodBody(TypeCompilationState compilationState,
                     Debug.Assert(!diagnostics.HasAnyErrors());
                     Debug.Assert(!body.HasErrors);
 
-                    bool sawLambdas;
-                    bool sawLocalFunctions;
-                    bool sawAwaitInExceptionHandler;
-                    ImmutableArray<SourceSpan> dynamicAnalysisSpans = ImmutableArray<SourceSpan>.Empty;
                     body = LocalRewriter.Rewrite(
                         compilation: this.DeclaringCompilation,
                         method: this,
@@ -557,16 +554,16 @@ internal override void GenerateMethodBody(TypeCompilationState compilationState,
                         compilationState: compilationState,
                         previousSubmissionFields: null,
                         allowOmissionOfConditionalCalls: false,
-                        instrumentForDynamicAnalysis: false,
+                        instrumentation: MethodInstrumentation.Empty,
                         debugDocumentProvider: null,
-                        dynamicAnalysisSpans: ref dynamicAnalysisSpans,
                         diagnostics: diagnostics,
-                        sawLambdas: out sawLambdas,
-                        sawLocalFunctions: out sawLocalFunctions,
-                        sawAwaitInExceptionHandler: out sawAwaitInExceptionHandler);
+                        codeCoverageSpans: out ImmutableArray<SourceSpan> codeCoverageSpans,
+                        sawLambdas: out bool sawLambdas,
+                        sawLocalFunctions: out bool sawLocalFunctions,
+                        sawAwaitInExceptionHandler: out bool sawAwaitInExceptionHandler);
 
                     Debug.Assert(!sawAwaitInExceptionHandler);
-                    Debug.Assert(dynamicAnalysisSpans.Length == 0);
+                    Debug.Assert(codeCoverageSpans.IsEmpty);
 
                     if (body.HasErrors)
                     {
@@ -666,7 +663,7 @@ internal override void GenerateMethodBody(TypeCompilationState compilationState,
                     localBuilder.Add(local);
                 }
 
-                body = block.Update(localBuilder.ToImmutableAndFree(), block.LocalFunctions, block.HasUnsafeModifier, block.Statements);
+                body = block.Update(localBuilder.ToImmutableAndFree(), block.LocalFunctions, block.HasUnsafeModifier, instrumentation: null, block.Statements);
                 TypeParameterChecker.Check(body, _allTypeParameters);
                 compilationState.AddSynthesizedMethod(this, body);
             }