diff --git a/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml b/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml
index 5b25a9bbc350ddfc5ab6874be85cb2834ee38b6f..01889dac57b6250590642f55d4fade1b8556ae49 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml
+++ b/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml
@@ -671,6 +671,18 @@
     <Field Name="LocalFunctions" Type="ImmutableArray&lt;LocalFunctionSymbol&gt;"/>
   </Node>
 
+  <!--
+  This node is used to represent a visibility scope for locals, 
+  for which lifetime is extended beyond the visibility scope. 
+  At the moment, only locals declared within CasePatternSwitchLabelSyntax 
+  have their lifetime expanded to the entire switch body, whereas their 
+  visibility scope is the declaring switch section. The node is added into 
+  the tree during lowering phase.
+  -->
+  <Node Name="BoundScope" Base="BoundStatementList">
+    <Field Name="Locals" Type="ImmutableArray&lt;LocalSymbol&gt;"/>
+  </Node>
+
   <!--
   BoundStateMachineScope represents a scope within a translated iterator/async method.
   It is used to emit debugging information that allows the EE to map 
diff --git a/src/Compilers/CSharp/Portable/CodeGen/EmitStatement.cs b/src/Compilers/CSharp/Portable/CodeGen/EmitStatement.cs
index 930f591e857dd8f86d09eab0772eec93e38c0983..332d3eea47de6444cf2601901935b2d77dc38b9e 100644
--- a/src/Compilers/CSharp/Portable/CodeGen/EmitStatement.cs
+++ b/src/Compilers/CSharp/Portable/CodeGen/EmitStatement.cs
@@ -24,6 +24,10 @@ private void EmitStatement(BoundStatement statement)
                     EmitBlock((BoundBlock)statement);
                     break;
 
+                case BoundKind.Scope:
+                    EmitScope((BoundScope)statement);
+                    break;
+
                 case BoundKind.SequencePoint:
                     this.EmitSequencePointStatement((BoundSequencePoint)statement);
                     break;
@@ -609,10 +613,7 @@ private void EmitBlock(BoundBlock block)
                 }
             }
 
-            foreach (var statement in block.Statements)
-            {
-                EmitStatement(statement);
-            }
+            EmitStatements(block.Statements);
 
             if (_indirectReturnState == IndirectReturnState.Needed &&
                 IsLastBlockInMethod(block))
@@ -631,6 +632,36 @@ private void EmitBlock(BoundBlock block)
             }
         }
 
+        private void EmitStatements(ImmutableArray<BoundStatement> statements)
+        {
+            foreach (var statement in statements)
+            {
+                EmitStatement(statement);
+            }
+        }
+
+        private void EmitScope(BoundScope block)
+        {
+            Debug.Assert(!block.Locals.IsEmpty);
+
+            _builder.OpenLocalScope();
+
+            foreach (var local in block.Locals)
+            {
+                Debug.Assert(local.Name != null);
+                Debug.Assert(local.SynthesizedKind == SynthesizedLocalKind.UserDefined &&
+                    local.ScopeDesignatorOpt?.Kind() == SyntaxKind.SwitchSection);
+                if (!local.IsConst && !IsStackLocal(local))
+                {
+                    _builder.AddLocalToScope(_builder.LocalSlotManager.GetLocal(local));
+                }
+            }
+
+            EmitStatements(block.Statements);
+
+            _builder.CloseLocalScope();
+        }
+
         private void EmitStateMachineScope(BoundStateMachineScope scope)
         {
             _builder.OpenStateMachineScope();
@@ -1464,7 +1495,9 @@ private LocalDefinition DefineLocal(LocalSymbol local, SyntaxNode syntaxNode)
                 isSlotReusable: local.SynthesizedKind.IsSlotReusable(_ilEmitStyle != ILEmitStyle.Release));
 
             // If named, add it to the local debug scope.
-            if (localDef.Name != null)
+            if (localDef.Name != null &&
+                !(local.SynthesizedKind == SynthesizedLocalKind.UserDefined &&
+                    local.ScopeDesignatorOpt?.Kind() == SyntaxKind.SwitchSection)) // Visibility scope of such locals is represented by BoundScope node.
             {
                 _builder.AddLocalToScope(localDef);
             }
diff --git a/src/Compilers/CSharp/Portable/CodeGen/Optimizer.cs b/src/Compilers/CSharp/Portable/CodeGen/Optimizer.cs
index 2b4e8e4f13643d18b636c103067866eaad06c49c..9ebf246212b58ad2e92b4a89f3252a6bafcb3a23 100644
--- a/src/Compilers/CSharp/Portable/CodeGen/Optimizer.cs
+++ b/src/Compilers/CSharp/Portable/CodeGen/Optimizer.cs
@@ -2082,6 +2082,11 @@ internal override SynthesizedLocalKind SynthesizedKind
             get { return SynthesizedLocalKind.OptimizerTemp; }
         }
 
+        internal override SyntaxNode ScopeDesignatorOpt
+        {
+            get { return null; }
+        }
+
         internal override LocalSymbol WithSynthesizedLocalKindAndSyntax(SynthesizedLocalKind kind, SyntaxNode syntax)
         {
             throw new NotImplementedException();
diff --git a/src/Compilers/CSharp/Portable/FlowAnalysis/PreciseAbstractFlowPass.cs b/src/Compilers/CSharp/Portable/FlowAnalysis/PreciseAbstractFlowPass.cs
index 53017d3625313c920bcfa34e3961db4e79da3736..40cd4b799b4a4644bc3a75e8617ceba5d7bead61 100644
--- a/src/Compilers/CSharp/Portable/FlowAnalysis/PreciseAbstractFlowPass.cs
+++ b/src/Compilers/CSharp/Portable/FlowAnalysis/PreciseAbstractFlowPass.cs
@@ -1144,10 +1144,21 @@ public override BoundNode VisitLocalDeclaration(BoundLocalDeclaration node)
 
         public override BoundNode VisitBlock(BoundBlock node)
         {
-            foreach (var statement in node.Statements)
+            VisitStatements(node.Statements);
+            return null;
+        }
+
+        private void VisitStatements(ImmutableArray<BoundStatement> statements)
+        {
+            foreach (var statement in statements)
             {
                 VisitStatement(statement);
             }
+        }
+
+        public override BoundNode VisitScope(BoundScope node)
+        {
+            VisitStatements(node.Statements);
             return null;
         }
 
diff --git a/src/Compilers/CSharp/Portable/Lowering/LambdaRewriter/LambdaCapturedVariable.cs b/src/Compilers/CSharp/Portable/Lowering/LambdaRewriter/LambdaCapturedVariable.cs
index 51d996a804ae78e0313c45d59b27019ffb84ca9b..80f126174377651e0b151879fe002b1c8ee84667 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LambdaRewriter/LambdaCapturedVariable.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LambdaRewriter/LambdaCapturedVariable.cs
@@ -70,6 +70,11 @@ private static string GetCapturedVariableFieldName(Symbol variable, ref int uniq
                 {
                     return GeneratedNames.MakeSynthesizedInstrumentationPayloadLocalFieldName(uniqueId++);
                 }
+
+                if (local.SynthesizedKind == SynthesizedLocalKind.UserDefined && local.ScopeDesignatorOpt?.Kind() == SyntaxKind.SwitchSection)
+                {
+                    return GeneratedNames.MakeHoistedLocalFieldName(local.SynthesizedKind, uniqueId++, local.Name);
+                }
             }
 
             Debug.Assert(variable.Name != null);
diff --git a/src/Compilers/CSharp/Portable/Lowering/LambdaRewriter/LambdaRewriter.cs b/src/Compilers/CSharp/Portable/Lowering/LambdaRewriter/LambdaRewriter.cs
index e9dd67b44ee28e9360223fff506eb218cc801c20..81c2d7be3519c65e53e7eb2a3c9505decc030b93 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LambdaRewriter/LambdaRewriter.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LambdaRewriter/LambdaRewriter.cs
@@ -1002,6 +1002,22 @@ private BoundBlock RewriteBlock(BoundBlock node, ArrayBuilder<BoundExpression> p
             return node.Update(newLocals.ToImmutableAndFree(), node.LocalFunctions, newStatements.ToImmutableAndFree());
         }
 
+        public override BoundNode VisitScope(BoundScope node)
+        {
+            Debug.Assert(!node.Locals.IsEmpty);
+            var newLocals = ArrayBuilder<LocalSymbol>.GetInstance();
+            RewriteLocals(node.Locals, newLocals);
+
+            var statements = VisitList(node.Statements);
+            if (newLocals.Count == 0)
+            {
+                newLocals.Free();
+                return new BoundStatementList(node.Syntax, statements);
+            }
+
+            return node.Update(newLocals.ToImmutableAndFree(), statements);
+        }
+
         public override BoundNode VisitCatchBlock(BoundCatchBlock node)
         {
             // Test if this frame has captured variables and requires the introduction of a closure class.
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_PatternSwitchStatement.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_PatternSwitchStatement.cs
index 7bc8beebf78d62e0a1361f8c0c034740a54bf1f6..c5bbae04f391d30c4837ed213f36c950c3551708 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_PatternSwitchStatement.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_PatternSwitchStatement.cs
@@ -82,9 +82,15 @@ private BoundStatement MakeLoweredForm(BoundPatternSwitchStatement node)
                 }
                 // at this point the end of result is unreachable.
 
+                _declaredTemps.AddOptional(initialTemp);
+                _declaredTemps.AddRange(node.InnerLocals);
+
                 // output the sections of code
                 foreach (var section in node.SwitchSections)
                 {
+                    // Lifetime of these locals is expanded to the entire switch body.
+                    _declaredTemps.AddRange(section.Locals);
+
                     // Start with the part of the decision tree that is in scope of the section variables.
                     // Its endpoint is not reachable (it jumps back into the decision tree code).
                     var sectionSyntax = (SyntaxNode)section.Syntax;
@@ -98,14 +104,23 @@ private BoundStatement MakeLoweredForm(BoundPatternSwitchStatement node)
 
                     // Add the translated body of the switch section
                     sectionBuilder.AddRange(_localRewriter.VisitList(section.Statements));
+
                     sectionBuilder.Add(_factory.Goto(node.BreakLabel));
-                    result.Add(_factory.Block(section.Locals, sectionBuilder.ToImmutableAndFree()));
+
+                    ImmutableArray<BoundStatement> statements = sectionBuilder.ToImmutableAndFree();
+                    if (section.Locals.IsEmpty)
+                    {
+                        result.Add(_factory.StatementList(statements));
+                    }
+                    else
+                    {
+                        result.Add(new BoundScope(section.Syntax, section.Locals, statements));
+                    }
                     // at this point the end of result is unreachable.
                 }
 
                 result.Add(_factory.Label(node.BreakLabel));
-                _declaredTemps.AddOptional(initialTemp);
-                _declaredTemps.AddRange(node.InnerLocals);
+
                 BoundStatement translatedSwitch = _factory.Block(_declaredTemps.ToImmutableArray(), node.InnerLocalFunctions, result.ToImmutableAndFree());
 
                 // Only add instrumentation (such as a sequence point) if the node is not compiler-generated.
diff --git a/src/Compilers/CSharp/Portable/Lowering/MethodToClassRewriter.cs b/src/Compilers/CSharp/Portable/Lowering/MethodToClassRewriter.cs
index 4a54903b455de58b97dc8e3b69f25821e3ad58e3..5e5a8dd3508afbd4de0616a317ad4ae0aa5283ba 100644
--- a/src/Compilers/CSharp/Portable/Lowering/MethodToClassRewriter.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/MethodToClassRewriter.cs
@@ -138,6 +138,8 @@ public override BoundNode VisitBlock(BoundBlock node)
             return node.Update(newLocals, newLocalFunctions, newStatements);
         }
 
+        public override abstract BoundNode VisitScope(BoundScope node);
+
         public override BoundNode VisitSequence(BoundSequence node)
         {
             var newLocals = RewriteLocals(node.Locals);
diff --git a/src/Compilers/CSharp/Portable/Lowering/StateMachineRewriter/MethodToStateMachineRewriter.cs b/src/Compilers/CSharp/Portable/Lowering/StateMachineRewriter/MethodToStateMachineRewriter.cs
index e0b2e57f3d4d01b97bc93d20fb041b7f03da9ddb..92cf2f13e43e4bb17e5bbc9286964cf06d035ec9 100644
--- a/src/Compilers/CSharp/Portable/Lowering/StateMachineRewriter/MethodToStateMachineRewriter.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/StateMachineRewriter/MethodToStateMachineRewriter.cs
@@ -292,7 +292,8 @@ private BoundStatement PossibleIteratorScope(ImmutableArray<LocalSymbol> locals,
                 // We need to produce hoisted local scope debug information for user locals as well as 
                 // lambda display classes, since Dev12 EE uses them to determine which variables are displayed 
                 // in Locals window.
-                if (local.SynthesizedKind == SynthesizedLocalKind.UserDefined ||
+                if ((local.SynthesizedKind == SynthesizedLocalKind.UserDefined && 
+                        local.ScopeDesignatorOpt?.Kind() != SyntaxKind.SwitchSection) ||
                     local.SynthesizedKind == SynthesizedLocalKind.LambdaDisplayClass)
                 {
                     hoistedLocalsWithDebugScopes.Add(((CapturedToStateMachineFieldReplacement)proxy).HoistedField);
@@ -621,6 +622,52 @@ public override BoundNode VisitBlock(BoundBlock node)
             return PossibleIteratorScope(node.Locals, () => (BoundStatement)base.VisitBlock(node));
         }
 
+        public override BoundNode VisitScope(BoundScope node)
+        {
+            Debug.Assert(!node.Locals.IsEmpty);
+            var newLocals = ArrayBuilder<LocalSymbol>.GetInstance();
+            var hoistedLocalsWithDebugScopes = ArrayBuilder<StateMachineFieldSymbol>.GetInstance();
+            foreach (var local in node.Locals)
+            {
+                Debug.Assert(local.SynthesizedKind == SynthesizedLocalKind.UserDefined &&
+                    local.ScopeDesignatorOpt?.Kind() == SyntaxKind.SwitchSection);
+
+                if (!NeedsProxy(local))
+                {
+                    newLocals.Add(local);
+                    continue;
+                }
+
+                hoistedLocalsWithDebugScopes.Add(((CapturedToStateMachineFieldReplacement)proxies[local]).HoistedField);
+            }
+
+            var statements = VisitList(node.Statements);
+
+            // wrap the node in an iterator scope for debugging
+            if (hoistedLocalsWithDebugScopes.Count != 0)
+            {
+                BoundStatement translated;
+
+                if (newLocals.Count == 0)
+                {
+                    newLocals.Free();
+                    translated = new BoundStatementList(node.Syntax, statements);
+                }
+                else
+                {
+                    translated = node.Update(newLocals.ToImmutableAndFree(), statements);
+                }
+
+                return MakeStateMachineScope(hoistedLocalsWithDebugScopes.ToImmutable(), translated);
+            }
+            else
+            {
+                hoistedLocalsWithDebugScopes.Free();
+                newLocals.Free();
+                return node.Update(node.Locals, statements);
+            }
+        }
+
         public override BoundNode VisitSwitchStatement(BoundSwitchStatement node)
         {
             return PossibleIteratorScope(node.InnerLocals, () => (BoundStatement)base.VisitSwitchStatement(node));
diff --git a/src/Compilers/CSharp/Portable/Symbols/LocalSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/LocalSymbol.cs
index f43469018f6019b46459f766146fcaa65f911e67..b8481066244bf89c0c0b21f55079b559eaff8b90 100644
--- a/src/Compilers/CSharp/Portable/Symbols/LocalSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/LocalSymbol.cs
@@ -25,6 +25,11 @@ protected LocalSymbol()
             get;
         }
 
+        /// <summary>
+        /// Syntax node that is used as the scope designator. Otherwise, null.
+        /// </summary>
+        internal abstract SyntaxNode ScopeDesignatorOpt { get; }
+
         internal abstract LocalSymbol WithSynthesizedLocalKindAndSyntax(SynthesizedLocalKind kind, SyntaxNode syntax);
 
         internal abstract bool IsImportedFromMetadata
diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/SourceLocalSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Source/SourceLocalSymbol.cs
index 1f488088e6baa95f92c67b3d760faf365d5eaad0..a69903304764643c45779dbd7e7d458bbae16a23 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Source/SourceLocalSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Source/SourceLocalSymbol.cs
@@ -76,6 +76,11 @@ internal Binder ScopeBinder
             get { return _scopeBinder; }
         }
 
+        internal override SyntaxNode ScopeDesignatorOpt
+        {
+            get { return _scopeBinder.ScopeDesignator; }
+        }
+
         /// <summary>
         /// Binder that should be used to bind type syntax for the local.
         /// </summary>
diff --git a/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedLocal.cs b/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedLocal.cs
index 5e15547769383c2c86e8f9cf6fb4e23a46d4784b..5a9bf37a7365aa8dfc6664f8acdf03acbe4b52f6 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedLocal.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedLocal.cs
@@ -102,6 +102,11 @@ internal override SynthesizedLocalKind SynthesizedKind
             get { return _kind; }
         }
 
+        internal override SyntaxNode ScopeDesignatorOpt
+        {
+            get { return null; }
+        }
+
         internal override SyntaxToken IdentifierToken
         {
             get { return default(SyntaxToken); }
diff --git a/src/Compilers/CSharp/Portable/Symbols/Synthesized/TypeSubstitutedLocalSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/Synthesized/TypeSubstitutedLocalSymbol.cs
index bc12f8d0d738a5903111d2f3e4abeceb6788ce91..4d1bd0499e07b97b77ea378f9f7e159454cf0f6c 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Synthesized/TypeSubstitutedLocalSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Synthesized/TypeSubstitutedLocalSymbol.cs
@@ -38,6 +38,11 @@ internal override SynthesizedLocalKind SynthesizedKind
             get { return _originalVariable.SynthesizedKind; }
         }
 
+        internal override SyntaxNode ScopeDesignatorOpt
+        {
+            get { return _originalVariable.ScopeDesignatorOpt; }
+        }
+
         public override string Name
         {
             get { return _originalVariable.Name; }
diff --git a/src/Compilers/CSharp/Test/Emit/PDB/PDBTests.cs b/src/Compilers/CSharp/Test/Emit/PDB/PDBTests.cs
index c3ada8ce659c80f52b6b560f162e251213346aab..a66ee50dd5049fea0c482d7ef4165b57f2ddca69 100644
--- a/src/Compilers/CSharp/Test/Emit/PDB/PDBTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/PDB/PDBTests.cs
@@ -2150,7 +2150,7 @@ static void Main(string[] args)
         }
 
         [Fact]
-        public void SwitchWithPattern()
+        public void SwitchWithPattern_01()
         {
             string source = @"
 using System;
@@ -2203,11 +2203,11 @@ class Student : Person { public double GPA; }
           <slot kind=""temp"" />
           <slot kind=""temp"" />
           <slot kind=""temp"" />
-          <slot kind=""1"" offset=""11"" />
           <slot kind=""0"" offset=""59"" />
-          <slot kind=""21"" offset=""0"" />
           <slot kind=""0"" offset=""163"" />
           <slot kind=""0"" offset=""250"" />
+          <slot kind=""1"" offset=""11"" />
+          <slot kind=""21"" offset=""0"" />
         </encLocalSlotMap>
       </customDebugInfo>
       <sequencePoints>
@@ -2226,13 +2226,109 @@ class Student : Person { public double GPA; }
       </sequencePoints>
       <scope startOffset=""0x0"" endOffset=""0xcc"">
         <scope startOffset=""0x36"" endOffset=""0x6e"">
-          <local name=""s"" il_index=""6"" il_start=""0x36"" il_end=""0x6e"" attributes=""0"" />
+          <local name=""s"" il_index=""5"" il_start=""0x36"" il_end=""0x6e"" attributes=""0"" />
         </scope>
         <scope startOffset=""0x6e"" endOffset=""0x94"">
-          <local name=""s"" il_index=""8"" il_start=""0x6e"" il_end=""0x94"" attributes=""0"" />
+          <local name=""s"" il_index=""6"" il_start=""0x6e"" il_end=""0x94"" attributes=""0"" />
         </scope>
         <scope startOffset=""0x94"" endOffset=""0xb5"">
-          <local name=""t"" il_index=""9"" il_start=""0x94"" il_end=""0xb5"" attributes=""0"" />
+          <local name=""t"" il_index=""7"" il_start=""0x94"" il_end=""0xb5"" attributes=""0"" />
+        </scope>
+      </scope>
+    </method>
+  </methods>
+</symbols>"
+);
+        }
+
+        [Fact]
+        public void SwitchWithPattern_02()
+        {
+            string source = @"
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+class Program
+{
+    private static List<List<int>> l = new List<List<int>>();
+
+    static void Main(string[] args)
+    {
+        Student s = new Student();
+        s.Name = ""Bozo"";
+        s.GPA = 2.3;
+        Operate(s);  
+    }
+
+    static System.Func<string> Operate(Person p)
+    {
+        switch (p)
+        {
+            case Student s when s.GPA > 3.5:
+                return () => $""Student {s.Name} ({s.GPA:N1})"";
+            case Student s:
+                return () => $""Student {s.Name} ({s.GPA:N1})"";
+            case Teacher t:
+                return () => $""Teacher {t.Name} of {t.Subject}"";
+            default:
+                return () => $""Person {p.Name}"";
+        }
+    }
+}
+
+class Person { public string Name; }
+class Teacher : Person { public string Subject; }
+class Student : Person { public double GPA; }
+";
+            // we just want this to compile without crashing/asserting
+            var c = CreateCompilationWithMscorlibAndSystemCore(source, options: TestOptions.DebugDll);
+            c.VerifyPdb("Program.Operate",
+@"<symbols>
+  <methods>
+    <method containingType=""Program"" name=""Operate"" parameterNames=""p"">
+      <customDebugInfo>
+        <forward declaringType=""Program"" methodName=""Main"" parameterNames=""args"" />
+        <encLocalSlotMap>
+          <slot kind=""30"" offset=""0"" />
+          <slot kind=""30"" offset=""383"" />
+          <slot kind=""temp"" />
+          <slot kind=""temp"" />
+          <slot kind=""temp"" />
+          <slot kind=""temp"" />
+          <slot kind=""temp"" />
+          <slot kind=""1"" offset=""11"" />
+          <slot kind=""21"" offset=""0"" />
+        </encLocalSlotMap>
+        <encLambdaMap>
+          <methodOrdinal>2</methodOrdinal>
+          <closure offset=""383"" />
+          <closure offset=""0"" />
+          <lambda offset=""109"" closure=""0"" />
+          <lambda offset=""202"" closure=""0"" />
+          <lambda offset=""295"" closure=""0"" />
+          <lambda offset=""383"" closure=""1"" />
+        </encLambdaMap>
+      </customDebugInfo>
+      <sequencePoints>
+        <entry offset=""0x0"" hidden=""true"" />
+        <entry offset=""0xd"" startLine=""19"" startColumn=""5"" endLine=""19"" endColumn=""6"" />
+        <entry offset=""0xe"" hidden=""true"" />
+        <entry offset=""0x20"" hidden=""true"" />
+        <entry offset=""0x50"" hidden=""true"" />
+        <entry offset=""0x57"" startLine=""22"" startColumn=""28"" endLine=""22"" endColumn=""44"" />
+        <entry offset=""0x6f"" startLine=""23"" startColumn=""17"" endLine=""23"" endColumn=""63"" />
+        <entry offset=""0x7f"" hidden=""true"" />
+        <entry offset=""0x89"" startLine=""25"" startColumn=""17"" endLine=""25"" endColumn=""63"" />
+        <entry offset=""0x99"" hidden=""true"" />
+        <entry offset=""0xa3"" startLine=""27"" startColumn=""17"" endLine=""27"" endColumn=""65"" />
+        <entry offset=""0xb3"" startLine=""29"" startColumn=""17"" endLine=""29"" endColumn=""49"" />
+        <entry offset=""0xc3"" startLine=""31"" startColumn=""5"" endLine=""31"" endColumn=""6"" />
+      </sequencePoints>
+      <scope startOffset=""0x0"" endOffset=""0xc6"">
+        <local name=""CS$&lt;&gt;8__locals0"" il_index=""0"" il_start=""0x0"" il_end=""0xc6"" attributes=""0"" />
+        <scope startOffset=""0xe"" endOffset=""0xc3"">
+          <local name=""CS$&lt;&gt;8__locals1"" il_index=""1"" il_start=""0xe"" il_end=""0xc3"" attributes=""0"" />
         </scope>
       </scope>
     </method>
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/LocalFunctionTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/LocalFunctionTests.cs
index e335630e8ebea0c483efb1da48c3894291bbd42d..83a6d40748937c39d5d1e42d9cc288d6ef31fb3b 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/LocalFunctionTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/LocalFunctionTests.cs
@@ -2375,5 +2375,174 @@ public static void Main(string[] args)
                 Assert.Equal(symbol, model.GetSymbolInfo(refs[0]).Symbol);
             });
         }
+
+        [Fact]
+        [WorkItem(15536, "https://github.com/dotnet/roslyn/issues/15536")]
+        public void CallFromDifferentSwitchSection_01()
+        {
+            var source = @"
+class Program
+{
+    static void Main()
+    {
+        Test(string.Empty);
+    }
+
+    static void Test(object o)
+    {
+        switch (o)
+        {
+            case string x:
+                Assign();
+                Print();
+                break;
+            case int x:
+                void Assign() { x = 5; }
+                void Print() => System.Console.WriteLine(x);
+                break;
+        }
+    }
+}";
+
+            var comp = CreateCompilationWithMscorlib46(source, parseOptions: DefaultParseOptions, options: TestOptions.DebugExe);
+            CompileAndVerify(comp, expectedOutput: "5");
+        }
+
+        [Fact]
+        [WorkItem(15536, "https://github.com/dotnet/roslyn/issues/15536")]
+        public void CallFromDifferentSwitchSection_02()
+        {
+            var source = @"
+class Program
+{
+    static void Main()
+    {
+        Test(string.Empty);
+    }
+
+    static void Test(object o)
+    {
+        switch (o)
+        {
+            case int x:
+                void Assign() { x = 5; }
+                void Print() => System.Console.WriteLine(x);
+                break;
+            case string x:
+                Assign();
+                Print();
+                break;
+        }
+    }
+}";
+
+            var comp = CreateCompilationWithMscorlib46(source, parseOptions: DefaultParseOptions, options: TestOptions.DebugExe);
+            CompileAndVerify(comp, expectedOutput: "5");
+        }
+
+        [Fact]
+        [WorkItem(15536, "https://github.com/dotnet/roslyn/issues/15536")]
+        public void CallFromDifferentSwitchSection_03()
+        {
+            var source = @"
+class Program
+{
+    static void Main()
+    {
+        Test(string.Empty);
+    }
+
+    static void Test(object o)
+    {
+        switch (o)
+        {
+            case string x:
+                Assign();
+                System.Action p = Print;
+                p();
+                break;
+            case int x:
+                void Assign() { x = 5; }
+                void Print() => System.Console.WriteLine(x);
+                break;
+        }
+    }
+}";
+
+            var comp = CreateCompilationWithMscorlib46(source, parseOptions: DefaultParseOptions, options: TestOptions.DebugExe);
+            CompileAndVerify(comp, expectedOutput: "5");
+        }
+
+        [Fact]
+        [WorkItem(15536, "https://github.com/dotnet/roslyn/issues/15536")]
+        public void CallFromDifferentSwitchSection_04()
+        {
+            var source = @"
+class Program
+{
+    static void Main()
+    {
+        Test(string.Empty);
+    }
+
+    static void Test(object o)
+    {
+        switch (o)
+        {
+            case int x:
+                void Assign() { x = 5; }
+                void Print() => System.Console.WriteLine(x);
+                break;
+            case string x:
+                Assign();
+                System.Action p = Print;
+                p();
+                break;
+        }
+    }
+}";
+
+            var comp = CreateCompilationWithMscorlib46(source, parseOptions: DefaultParseOptions, options: TestOptions.DebugExe);
+            CompileAndVerify(comp, expectedOutput: "5");
+        }
+
+        [Fact]
+        [WorkItem(15536, "https://github.com/dotnet/roslyn/issues/15536")]
+        public void CallFromDifferentSwitchSection_05()
+        {
+            var source = @"
+class Program
+{
+    static void Main()
+    {
+        Test(string.Empty);
+    }
+
+    static void Test(object o)
+    {
+        switch (o)
+        {
+            case string x:
+                Local1();
+                break;
+             case int x:
+                void Local1() => Local2(x = 5);
+                break;
+             case char x:
+                void Local2(int y)
+                {
+                    System.Console.WriteLine(x = 'a');
+                    System.Console.WriteLine(y);
+                }
+                break;
+        }
+    }
+}";
+
+            var comp = CreateCompilationWithMscorlib46(source, parseOptions: DefaultParseOptions, options: TestOptions.DebugExe);
+            CompileAndVerify(comp, expectedOutput: 
+@"a
+5");
+        }
     }
 }
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/PatternSwitchTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/PatternSwitchTests.cs
index 11f00a9c965620f8fb35b35197e3341853654092..cbc124ecbcb9ec0836c612ae86cc43bf3085353d 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/PatternSwitchTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/PatternSwitchTests.cs
@@ -1997,5 +1997,547 @@ static void Main()
 @"not null
 null");
         }
+
+        [Fact]
+        [WorkItem(16066, "https://github.com/dotnet/roslyn/issues/16066")]
+        public void SwitchSectionWithLambda_01()
+        {
+            var source =
+@"
+class Program
+{
+    static void Main(string[] args)
+    {                           
+        switch((object)new A())
+        {
+            case A a:
+                System.Action print = () => System.Console.WriteLine(a);
+                print();
+                break;
+        }
+    }
+}
+
+class A{}
+";
+            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe);
+            compilation.VerifyDiagnostics();
+            var expectedOutput = "A";
+            var comp = CompileAndVerify(compilation, expectedOutput: expectedOutput);
+        }
+
+        [Fact]
+        [WorkItem(16066, "https://github.com/dotnet/roslyn/issues/16066")]
+        public void SwitchSectionWithLambda_02()
+        {
+            var source =
+@"
+class Program
+{
+    static void Main(string[] args)
+    {
+        int val = 3; 
+        var l = new System.Collections.Generic.List<System.Action>();
+        int i = 1;                          
+        switch(val)
+        {
+            case int a when a == 3:
+            case 1:
+                System.Console.WriteLine(""case 1: {0}"", i);
+                a = i++;
+                l.Add(() => System.Console.WriteLine(a));
+                goto case 2;
+            case int a when a == 4:
+            case 2:
+                System.Console.WriteLine(""case 2: {0}"", i);
+                a = i++;
+                l.Add(() => System.Console.WriteLine(a));
+
+                if (i < 4)
+                {
+                    goto case 1;
+                }
+                break;
+        }
+
+        foreach (var a in l)
+        {
+            a();
+        }
+    }
+}
+";
+            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe);
+            compilation.VerifyDiagnostics();
+            var comp = CompileAndVerify(compilation, expectedOutput:
+@"case 1: 1
+case 2: 2
+case 1: 3
+case 2: 4
+3
+4
+3
+4");
+        }
+
+        [Fact]
+        [WorkItem(16066, "https://github.com/dotnet/roslyn/issues/16066")]
+        public void SwitchSectionWithYield_01()
+        {
+            var source =
+@"
+class Program
+{
+    static void Main()
+    {
+        foreach (var a in Test())
+        {
+            System.Console.WriteLine(a);
+        }
+    }
+
+    static System.Collections.Generic.IEnumerable<string> Test()
+    {
+        int val = 3; 
+        var l = new System.Collections.Generic.List<System.Action>();
+        int i = 1;                          
+        switch(val)
+        {
+            case int a when a == 3:
+            case 1:
+                yield return string.Format(""case 1: {0}"", i);
+                a = i++;
+                l.Add(() => System.Console.WriteLine(a));
+                goto case 2;
+            case int a when a == 4:
+            case 2:
+                yield return string.Format(""case 2: {0}"", i);
+                a = i++;
+                l.Add(() => System.Console.WriteLine(a));
+
+                if (i < 4)
+                {
+                    goto case 1;
+                }
+                break;
+        }
+
+        foreach (var a in l)
+        {
+            a();
+        }
+    }
+}
+";
+            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe);
+            compilation.VerifyDiagnostics();
+            var comp = CompileAndVerify(compilation, expectedOutput:
+@"case 1: 1
+case 2: 2
+case 1: 3
+case 2: 4
+3
+4
+3
+4");
+        }
+
+        [Fact]
+        [WorkItem(16066, "https://github.com/dotnet/roslyn/issues/16066")]
+        public void SwitchSectionWithYield_02()
+        {
+            var source =
+@"
+class Program
+{
+    static void Main()
+    {
+        foreach (var a in Test())
+        {
+            System.Console.WriteLine(a);
+        }
+    }
+
+    static System.Collections.Generic.IEnumerable<string> Test()
+    {
+        int val = 3; 
+        int i = 1;                          
+        switch(val)
+        {
+            case int a when a == 3:
+            case 1:
+                yield return string.Format(""case 1: {0}"", i);
+                a = i++;
+                System.Console.WriteLine(a);
+                goto case 2;
+            case int a when a == 4:
+            case 2:
+                yield return string.Format(""case 2: {0}"", i);
+                a = i++;
+                System.Console.WriteLine(a);
+
+                if (i < 4)
+                {
+                    goto case 1;
+                }
+                break;
+        }
+    }
+}
+";
+            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe);
+            compilation.VerifyDiagnostics();
+            var comp = CompileAndVerify(compilation, expectedOutput:
+@"case 1: 1
+1
+case 2: 2
+2
+case 1: 3
+3
+case 2: 4
+4");
+        }
+
+        [Fact]
+        [WorkItem(16066, "https://github.com/dotnet/roslyn/issues/16066")]
+        public void SwitchSectionWithYield_03()
+        {
+            var source =
+@"
+class Program
+{
+    static void Main()
+    {
+        foreach (var a in Test())
+        {
+            System.Console.WriteLine(a);
+        }
+    }
+
+    static System.Collections.Generic.IEnumerable<int> Test()
+    {
+        int val = 3; 
+        int i = 1;                          
+        switch(val)
+        {
+            case int a when a == 3:
+            case 1:
+                System.Console.WriteLine(""case 1: {0}"", i);
+                a = i++;
+                System.Console.WriteLine(a);
+                goto case 2;
+            case int a when a == 4:
+            case 2:
+                System.Console.WriteLine(""case 2: {0}"", i);
+                a = i++;
+                System.Console.WriteLine(a);
+
+                if (i < 4)
+                {
+                    goto case 1;
+                }
+                break;
+        }
+
+        yield return i;
+    }
+}
+";
+            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.ReleaseExe);
+            compilation.VerifyDiagnostics();
+            var comp = CompileAndVerify(compilation, expectedOutput:
+@"case 1: 1
+1
+case 2: 2
+2
+case 1: 3
+3
+case 2: 4
+4
+5");
+        }
+
+        [Fact]
+        [WorkItem(16066, "https://github.com/dotnet/roslyn/issues/16066")]
+        public void SwitchSectionWithYield_04()
+        {
+            var source =
+@"
+class Program
+{
+    static void Main()
+    {
+        foreach (var a in Test())
+        {
+            System.Console.WriteLine(a);
+        }
+    }
+
+    static System.Collections.Generic.IEnumerable<string> Test()
+    {
+        int val = 3; 
+        switch(val)
+        {
+            case int a when TakeOutVar(out var b) && a == b:
+                yield return string.Format(""case: {0}"", val);
+                System.Console.WriteLine(a);
+                break;
+        }
+    }
+
+    static bool TakeOutVar(out int x)
+    {
+        x = 3;
+        return true;
+    }
+}
+";
+            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.ReleaseExe);
+            compilation.VerifyDiagnostics();
+            var comp = CompileAndVerify(compilation, expectedOutput:
+@"case: 3
+3");
+        }
+
+        [Fact]
+        [WorkItem(16066, "https://github.com/dotnet/roslyn/issues/16066")]
+        public void SwitchSectionWithAwait_01()
+        {
+            var source =
+@"
+using System.Threading.Tasks;
+
+class Program
+{
+    static void Main()
+    {
+        System.Console.WriteLine(Test().Result);
+    }
+
+    static async Task<int> Test()
+    {
+        int val = 3; 
+        var l = new System.Collections.Generic.List<System.Action>();
+        int i = 1;                          
+        switch(val)
+        {
+            case int a when a == 3:
+            case 1:
+                System.Console.WriteLine(await GetTask(string.Format(""case 1: {0}"", i)));
+                a = i++;
+                l.Add(() => System.Console.WriteLine(a));
+                goto case 2;
+            case int a when a == 4:
+            case 2:
+                System.Console.WriteLine(await GetTask(string.Format(""case 2: {0}"", i)));
+                a = i++;
+                l.Add(() => System.Console.WriteLine(a));
+
+                if (i < 4)
+                {
+                    goto case 1;
+                }
+                break;
+        }
+
+        foreach (var a in l)
+        {
+            a();
+        }
+
+        return i;
+    }
+
+    static async Task<string> GetTask(string val)
+    {
+        await Task.Yield();
+        return val;
+    }
+}
+";
+            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe);
+            compilation.VerifyDiagnostics();
+            var comp = CompileAndVerify(compilation, expectedOutput:
+@"case 1: 1
+case 2: 2
+case 1: 3
+case 2: 4
+3
+4
+3
+4
+5");
+        }
+
+        [Fact]
+        [WorkItem(16066, "https://github.com/dotnet/roslyn/issues/16066")]
+        public void SwitchSectionWithAwait_02()
+        {
+            var source =
+@"
+using System.Threading.Tasks;
+
+class Program
+{
+    static void Main()
+    {
+        System.Console.WriteLine(Test().Result);
+    }
+
+    static async Task<int> Test()
+    {
+        int val = 3; 
+        int i = 1;                          
+        switch(val)
+        {
+            case int a when a == 3:
+            case 1:
+                System.Console.WriteLine(await GetTask(string.Format(""case 1: {0}"", i)));
+                a = i++;
+                System.Console.WriteLine(a);
+                goto case 2;
+            case int a when a == 4:
+            case 2:
+                System.Console.WriteLine(await GetTask(string.Format(""case 2: {0}"", i)));
+                a = i++;
+                System.Console.WriteLine(a);
+
+                if (i < 4)
+                {
+                    goto case 1;
+                }
+                break;
+        }
+
+        return i;
+    }
+
+    static async Task<string> GetTask(string val)
+    {
+        await Task.Yield();
+        return val;
+    }
+}
+";
+            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugExe);
+            compilation.VerifyDiagnostics();
+            var comp = CompileAndVerify(compilation, expectedOutput:
+@"case 1: 1
+1
+case 2: 2
+2
+case 1: 3
+3
+case 2: 4
+4
+5");
+        }
+
+        [Fact]
+        [WorkItem(16066, "https://github.com/dotnet/roslyn/issues/16066")]
+        public void SwitchSectionWithAwait_03()
+        {
+            var source =
+@"
+using System.Threading.Tasks;
+
+class Program
+{
+    static void Main()
+    {
+        System.Console.WriteLine(Test().Result);
+    }
+
+    static async Task<int> Test()
+    {
+        int val = 3; 
+        int i = 1;                          
+        switch(val)
+        {
+            case int a when a == 3:
+            case 1:
+                System.Console.WriteLine(""case 1: {0}"", i);
+                a = i++;
+                System.Console.WriteLine(a);
+                goto case 2;
+            case int a when a == 4:
+            case 2:
+                System.Console.WriteLine(""case 2: {0}"", i);
+                a = i++;
+                System.Console.WriteLine(a);
+
+                if (i < 4)
+                {
+                    goto case 1;
+                }
+                break;
+        }
+
+        await Task.Yield();
+        return i;
+    }
+}
+";
+            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.ReleaseExe);
+            compilation.VerifyDiagnostics();
+            var comp = CompileAndVerify(compilation, expectedOutput:
+@"case 1: 1
+1
+case 2: 2
+2
+case 1: 3
+3
+case 2: 4
+4
+5");
+        }
+
+        [Fact]
+        [WorkItem(16066, "https://github.com/dotnet/roslyn/issues/16066")]
+        public void SwitchSectionWithAwait_04()
+        {
+            var source =
+@"
+using System.Threading.Tasks;
+
+class Program
+{
+    static void Main()
+    {
+        System.Console.WriteLine(Test().Result);
+    }
+
+    static async Task<int> Test()
+    {
+        int val = 3; 
+        switch(val)
+        {
+            case int a when TakeOutVar(out var b) && a == b:
+                System.Console.WriteLine(await GetTask(string.Format(""case: {0}"", val)));
+                return a;
+        }
+
+        return 0;
+    }
+
+    static bool TakeOutVar(out int x)
+    {
+        x = 3;
+        return true;
+    }
+
+    static async Task<string> GetTask(string val)
+    {
+        await Task.Yield();
+        return val;
+    }
+}
+";
+            var compilation = CreateCompilationWithMscorlib45(source, options: TestOptions.ReleaseExe);
+            compilation.VerifyDiagnostics();
+            var comp = CompileAndVerify(compilation, expectedOutput:
+@"case: 3
+3");
+        }
     }
 }
diff --git a/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/Symbols/EELocalSymbolBase.cs b/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/Symbols/EELocalSymbolBase.cs
index d36f918aa33fa89aafabf79b2211eab6a1274b24..dbc962592920ddef71734e698ac3164ce0460c09 100644
--- a/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/Symbols/EELocalSymbolBase.cs
+++ b/src/ExpressionEvaluator/CSharp/Source/ExpressionCompiler/Symbols/EELocalSymbolBase.cs
@@ -43,6 +43,11 @@ internal sealed override SynthesizedLocalKind SynthesizedKind
             get { return SynthesizedLocalKind.UserDefined; }
         }
 
+        internal override SyntaxNode ScopeDesignatorOpt
+        {
+            get { return null; }
+        }
+
         internal sealed override LocalSymbol WithSynthesizedLocalKindAndSyntax(SynthesizedLocalKind kind, SyntaxNode syntax)
         {
             throw ExceptionUtilities.Unreachable;
diff --git a/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/LocalsTests.cs b/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/LocalsTests.cs
index 9c5b600ddaed3344366ee77c622e4177948f05ed..0d2ea0817b4df4bc3fd84f1e8451c7c6a9c6fbc6 100644
--- a/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/LocalsTests.cs
+++ b/src/ExpressionEvaluator/CSharp/Test/ExpressionCompiler/LocalsTests.cs
@@ -124,6 +124,658 @@ .maxstack  1
             });
         }
 
+        [Fact]
+        public void LocalsInSwitch()
+        {
+            var source =
+@"class C
+{
+    void M(object o)
+    {
+        switch (o)
+        {
+            case string s:
+                var a = s;
+#line 1000
+                return;
+            case int s:
+#line 2000
+                return;
+            default:
+                return;
+        }
+    }
+}";
+            var compilation0 = CreateCompilationWithMscorlib(source, options: TestOptions.DebugDll);
+            WithRuntimeInstance(compilation0, runtime =>
+            {
+                var context = CreateMethodContext(runtime, "C.M", atLineNumber: 1000);
+
+                var testData = new CompilationTestData();
+                var locals = ArrayBuilder<LocalAndMethod>.GetInstance();
+                string typeName;
+                var assembly = context.CompileGetLocals(locals, argumentsOnly: false, typeName: out typeName, testData: testData);
+                Assert.NotNull(assembly);
+                Assert.NotEqual(assembly.Count, 0);
+
+                Assert.Equal(locals.Count, 4);
+                VerifyLocal(testData, typeName, locals[0], "<>m0", "this", expectedILOpt:
+@"{
+  // Code size        2 (0x2)
+  .maxstack  1
+  .locals init (object V_0,
+                string V_1,
+                int V_2,
+                object V_3,
+                string V_4, //a
+                string V_5, //s
+                int V_6,
+                object V_7,
+                int? V_8)
+  IL_0000:  ldarg.0
+  IL_0001:  ret
+}");
+                VerifyLocal(testData, typeName, locals[1], "<>m1", "o", expectedILOpt:
+@"{
+  // Code size        2 (0x2)
+  .maxstack  1
+  .locals init (object V_0,
+                string V_1,
+                int V_2,
+                object V_3,
+                string V_4, //a
+                string V_5, //s
+                int V_6,
+                object V_7,
+                int? V_8)
+  IL_0000:  ldarg.1
+  IL_0001:  ret
+}");
+                VerifyLocal(testData, typeName, locals[2], "<>m2", "a", expectedILOpt:
+@"{
+  // Code size        3 (0x3)
+  .maxstack  1
+  .locals init (object V_0,
+                string V_1,
+                int V_2,
+                object V_3,
+                string V_4, //a
+                string V_5, //s
+                int V_6,
+                object V_7,
+                int? V_8)
+  IL_0000:  ldloc.s    V_4
+  IL_0002:  ret
+}
+");
+                VerifyLocal(testData, typeName, locals[3], "<>m3", "s", expectedILOpt:
+@"{
+  // Code size        3 (0x3)
+  .maxstack  1
+  .locals init (object V_0,
+                string V_1,
+                int V_2,
+                object V_3,
+                string V_4, //a
+                string V_5, //s
+                int V_6,
+                object V_7,
+                int? V_8)
+  IL_0000:  ldloc.s    V_5
+  IL_0002:  ret
+}");
+                locals.Free();
+
+                context = CreateMethodContext(runtime, "C.M", atLineNumber: 2000);
+
+                testData = new CompilationTestData();
+                locals = ArrayBuilder<LocalAndMethod>.GetInstance();
+                assembly = context.CompileGetLocals(locals, argumentsOnly: false, typeName: out typeName, testData: testData);
+                Assert.NotNull(assembly);
+                Assert.NotEqual(assembly.Count, 0);
+
+                Assert.Equal(locals.Count, 4);
+                VerifyLocal(testData, typeName, locals[0], "<>m0", "this", expectedILOpt:
+@"{
+  // Code size        2 (0x2)
+  .maxstack  1
+  .locals init (object V_0,
+                string V_1,
+                int V_2,
+                object V_3,
+                string V_4, //a
+                string V_5,
+                int V_6, //s
+                object V_7,
+                int? V_8)
+  IL_0000:  ldarg.0
+  IL_0001:  ret
+}");
+                VerifyLocal(testData, typeName, locals[1], "<>m1", "o", expectedILOpt:
+@"{
+  // Code size        2 (0x2)
+  .maxstack  1
+  .locals init (object V_0,
+                string V_1,
+                int V_2,
+                object V_3,
+                string V_4, //a
+                string V_5,
+                int V_6, //s
+                object V_7,
+                int? V_8)
+  IL_0000:  ldarg.1
+  IL_0001:  ret
+}");
+                VerifyLocal(testData, typeName, locals[2], "<>m2", "a", expectedILOpt:
+@"{
+  // Code size        3 (0x3)
+  .maxstack  1
+  .locals init (object V_0,
+                string V_1,
+                int V_2,
+                object V_3,
+                string V_4, //a
+                string V_5,
+                int V_6, //s
+                object V_7,
+                int? V_8)
+  IL_0000:  ldloc.s    V_4
+  IL_0002:  ret
+}
+");
+                VerifyLocal(testData, typeName, locals[3], "<>m3", "s", expectedILOpt:
+@"{
+  // Code size        3 (0x3)
+  .maxstack  1
+  .locals init (object V_0,
+                string V_1,
+                int V_2,
+                object V_3,
+                string V_4, //a
+                string V_5,
+                int V_6, //s
+                object V_7,
+                int? V_8)
+  IL_0000:  ldloc.s    V_6
+  IL_0002:  ret
+}");
+                locals.Free();
+            });
+        }
+
+        [Fact]
+        [WorkItem(16594, "https://github.com/dotnet/roslyn/issues/16594")]
+        public void LocalsInSwitchWithLambda()
+        {
+            var source =
+@"class C
+{
+    System.Action M(object o)
+    {
+        switch (o)
+        {
+            case string s:
+                var a = s;
+#line 1000
+                return () =>
+                       {
+#line 2000
+                           System.Console.WriteLine(s + a); 
+                       };
+            case int s:
+#line 3000
+                return () =>
+                       {
+#line 4000
+                           System.Console.WriteLine(s); 
+                       };
+            default:
+                return null;
+        }
+    }
+}";
+            var compilation0 = CreateCompilationWithMscorlib(source, options: TestOptions.DebugDll);
+            WithRuntimeInstance(compilation0, runtime =>
+            {
+                var context = CreateMethodContext(runtime, "C.M", atLineNumber: 1000);
+
+                var testData = new CompilationTestData();
+                var locals = ArrayBuilder<LocalAndMethod>.GetInstance();
+                string typeName;
+                var assembly = context.CompileGetLocals(locals, argumentsOnly: false, typeName: out typeName, testData: testData);
+                Assert.NotNull(assembly);
+                Assert.NotEqual(assembly.Count, 0);
+
+                Assert.Equal(locals.Count, 3);
+                VerifyLocal(testData, typeName, locals[0], "<>m0", "this", expectedILOpt:
+@"{
+  // Code size        2 (0x2)
+  .maxstack  1
+  .locals init (C.<>c__DisplayClass0_0 V_0, //CS$<>8__locals0
+                object V_1,
+                string V_2,
+                int V_3,
+                object V_4,
+                object V_5,
+                int? V_6,
+                System.Action V_7)
+  IL_0000:  ldarg.0
+  IL_0001:  ret
+}");
+                VerifyLocal(testData, typeName, locals[1], "<>m1", "o", expectedILOpt:
+@"{
+  // Code size        2 (0x2)
+  .maxstack  1
+  .locals init (C.<>c__DisplayClass0_0 V_0, //CS$<>8__locals0
+                object V_1,
+                string V_2,
+                int V_3,
+                object V_4,
+                object V_5,
+                int? V_6,
+                System.Action V_7)
+  IL_0000:  ldarg.1
+  IL_0001:  ret
+}");
+                VerifyLocal(testData, typeName, locals[2], "<>m2", "a", expectedILOpt:
+@"{
+  // Code size        7 (0x7)
+  .maxstack  1
+  .locals init (C.<>c__DisplayClass0_0 V_0, //CS$<>8__locals0
+                object V_1,
+                string V_2,
+                int V_3,
+                object V_4,
+                object V_5,
+                int? V_6,
+                System.Action V_7)
+  IL_0000:  ldloc.0
+  IL_0001:  ldfld      ""string C.<>c__DisplayClass0_0.a""
+  IL_0006:  ret
+}
+");
+                // We should be able to evaluate "s" within this context, https://github.com/dotnet/roslyn/issues/16594.
+//                VerifyLocal(testData, typeName, locals[3], "<>m3", "s", expectedILOpt:
+//@"{
+//  // Code size        8 (0x8)
+//  .maxstack  1
+//  .locals init (C.<>c__DisplayClass0_1 V_0, //CS$<>8__locals0
+//                object V_1,
+//                string V_2,
+//                int V_3,
+//                object V_4,
+//                object V_5,
+//                int? V_6,
+//                C.<>c__DisplayClass0_0 V_7, //CS$<>8__locals1
+//                System.Action V_8,
+//                C.<>c__DisplayClass0_2 V_9)
+//  IL_0000:  ldloc.s    V_7
+//  IL_0002:  ldfld      ""string C.<>c__DisplayClass0_0.s""
+//  IL_0007:  ret
+//}");
+                locals.Free();
+
+                context = CreateMethodContext(runtime, "C.M", atLineNumber: 3000);
+
+                testData = new CompilationTestData();
+                locals = ArrayBuilder<LocalAndMethod>.GetInstance();
+                assembly = context.CompileGetLocals(locals, argumentsOnly: false, typeName: out typeName, testData: testData);
+                Assert.NotNull(assembly);
+                Assert.NotEqual(assembly.Count, 0);
+
+                Assert.Equal(locals.Count, 3);
+                VerifyLocal(testData, typeName, locals[0], "<>m0", "this", expectedILOpt:
+@"{
+  // Code size        2 (0x2)
+  .maxstack  1
+  .locals init (C.<>c__DisplayClass0_0 V_0, //CS$<>8__locals0
+                object V_1,
+                string V_2,
+                int V_3,
+                object V_4,
+                object V_5,
+                int? V_6,
+                System.Action V_7)
+  IL_0000:  ldarg.0
+  IL_0001:  ret
+}");
+                VerifyLocal(testData, typeName, locals[1], "<>m1", "o", expectedILOpt:
+@"{
+  // Code size        2 (0x2)
+  .maxstack  1
+  .locals init (C.<>c__DisplayClass0_0 V_0, //CS$<>8__locals0
+                object V_1,
+                string V_2,
+                int V_3,
+                object V_4,
+                object V_5,
+                int? V_6,
+                System.Action V_7)
+  IL_0000:  ldarg.1
+  IL_0001:  ret
+}");
+                VerifyLocal(testData, typeName, locals[2], "<>m2", "a", expectedILOpt:
+@"{
+  // Code size        7 (0x7)
+  .maxstack  1
+  .locals init (C.<>c__DisplayClass0_0 V_0, //CS$<>8__locals0
+                object V_1,
+                string V_2,
+                int V_3,
+                object V_4,
+                object V_5,
+                int? V_6,
+                System.Action V_7)
+  IL_0000:  ldloc.0
+  IL_0001:  ldfld      ""string C.<>c__DisplayClass0_0.a""
+  IL_0006:  ret
+}
+");
+                // We should be able to evaluate "s" within this context, https://github.com/dotnet/roslyn/issues/16594.
+//                VerifyLocal(testData, typeName, locals[3], "<>m3", "s", expectedILOpt:
+//@"{
+//  // Code size        8 (0x8)
+//  .maxstack  1
+//  .locals init (C.<>c__DisplayClass0_1 V_0, //CS$<>8__locals0
+//                object V_1,
+//                string V_2,
+//                int V_3,
+//                object V_4,
+//                object V_5,
+//                int? V_6,
+//                C.<>c__DisplayClass0_0 V_7,
+//                System.Action V_8,
+//                C.<>c__DisplayClass0_2 V_9) //CS$<>8__locals2
+//  IL_0000:  ldloc.s    V_9
+//  IL_0002:  ldfld      ""int C.<>c__DisplayClass0_2.s""
+//  IL_0007:  ret
+//}");
+                locals.Free();
+
+                context = CreateMethodContext(runtime, "C.<>c__DisplayClass0_0.<M>b__0", atLineNumber: 2000);
+
+                testData = new CompilationTestData();
+                locals = ArrayBuilder<LocalAndMethod>.GetInstance();
+                assembly = context.CompileGetLocals(locals, argumentsOnly: false, typeName: out typeName, testData: testData);
+                Assert.NotNull(assembly);
+                Assert.NotEqual(assembly.Count, 0);
+
+                Assert.Equal(locals.Count, 1);
+                // We should be able to evaluate "s" within this context, https://github.com/dotnet/roslyn/issues/16594.
+//                VerifyLocal(testData, typeName, locals[0], "<>m0", "s", expectedILOpt:
+//@"{
+//  // Code size        7 (0x7)
+//  .maxstack  1
+//  IL_0000:  ldarg.0
+//  IL_0001:  ldfld      ""string C.<>c__DisplayClass0_0.s""
+//  IL_0006:  ret
+//}");
+                VerifyLocal(testData, typeName, locals[0], "<>m0", "a", expectedILOpt:
+@"{
+  // Code size        7 (0x7)
+  .maxstack  1
+  IL_0000:  ldarg.0
+  IL_0001:  ldfld      ""string C.<>c__DisplayClass0_0.a""
+  IL_0006:  ret
+}");
+                locals.Free();
+
+                context = CreateMethodContext(runtime, "C.<>c__DisplayClass0_0.<M>b__1", atLineNumber: 4000);
+
+                testData = new CompilationTestData();
+                locals = ArrayBuilder<LocalAndMethod>.GetInstance();
+                assembly = context.CompileGetLocals(locals, argumentsOnly: false, typeName: out typeName, testData: testData);
+                Assert.NotNull(assembly);
+                Assert.NotEqual(assembly.Count, 0);
+
+                Assert.Equal(locals.Count, 1);
+                // We should be able to evaluate "s" within this context, https://github.com/dotnet/roslyn/issues/16594.
+//                VerifyLocal(testData, typeName, locals[0], "<>m0", "s", expectedILOpt:
+//@"{
+//  // Code size        7 (0x7)
+//  .maxstack  1
+//  IL_0000:  ldarg.0
+//  IL_0001:  ldfld      ""int C.<>c__DisplayClass0_2.s""
+//  IL_0006:  ret
+//}");
+                VerifyLocal(testData, typeName, locals[0], "<>m0", "a", expectedILOpt:
+@"{
+  // Code size        7 (0x7)
+  .maxstack  1
+  IL_0000:  ldarg.0
+  IL_0001:  ldfld      ""string C.<>c__DisplayClass0_0.a""
+  IL_0006:  ret
+}");
+                locals.Free();
+            });
+        }
+
+        [Fact]
+        public void LocalsInSwitchWithAwait()
+        {
+            var source =
+@"
+using System.Threading.Tasks;
+
+class C
+{
+    async Task<object> F()
+    {
+        return new object();
+    }
+
+    async Task<object> M(object o)
+    {
+        switch (o)
+        {
+            case string s:
+                var a = s;
+#line 1000
+                await F();
+                System.Console.WriteLine(s + a); 
+                return o;
+            case int s:
+#line 2000
+                await F();
+                System.Console.WriteLine(s); 
+                return o;
+            default:
+                return o;
+        }
+    }
+}";
+            var compilation0 = CreateCompilationWithMscorlib45(source, options: TestOptions.DebugDll, 
+                references: new[] { SystemRef_v4_0_30319_17929, SystemCoreRef_v4_0_30319_17929, CSharpRef });
+            WithRuntimeInstance(compilation0, runtime =>
+            {
+                var context = CreateMethodContext(runtime, "C.<M>d__1.MoveNext", atLineNumber: 1000);
+
+                var testData = new CompilationTestData();
+                var locals = ArrayBuilder<LocalAndMethod>.GetInstance();
+                string typeName;
+                var assembly = context.CompileGetLocals(locals, argumentsOnly: false, typeName: out typeName, testData: testData);
+                Assert.NotNull(assembly);
+                Assert.NotEqual(assembly.Count, 0);
+
+                Assert.Equal(locals.Count, 4);
+                VerifyLocal(testData, typeName, locals[0], "<>m0", "this", expectedILOpt:
+@"{
+  // Code size        7 (0x7)
+  .maxstack  1
+  .locals init (int V_0,
+                object V_1,
+                object V_2,
+                string V_3,
+                int V_4,
+                object V_5,
+                object V_6,
+                int? V_7,
+                System.Runtime.CompilerServices.TaskAwaiter<object> V_8,
+                C.<M>d__1 V_9,
+                System.Runtime.CompilerServices.TaskAwaiter<object> V_10,
+                System.Exception V_11)
+  IL_0000:  ldarg.0
+  IL_0001:  ldfld      ""C C.<M>d__1.<>4__this""
+  IL_0006:  ret
+}");
+                VerifyLocal(testData, typeName, locals[1], "<>m1", "o", expectedILOpt:
+@"{
+  // Code size        7 (0x7)
+  .maxstack  1
+  .locals init (int V_0,
+                object V_1,
+                object V_2,
+                string V_3,
+                int V_4,
+                object V_5,
+                object V_6,
+                int? V_7,
+                System.Runtime.CompilerServices.TaskAwaiter<object> V_8,
+                C.<M>d__1 V_9,
+                System.Runtime.CompilerServices.TaskAwaiter<object> V_10,
+                System.Exception V_11)
+  IL_0000:  ldarg.0
+  IL_0001:  ldfld      ""object C.<M>d__1.o""
+  IL_0006:  ret
+}");
+                VerifyLocal(testData, typeName, locals[2], "<>m2", "a", expectedILOpt:
+@"{
+  // Code size        7 (0x7)
+  .maxstack  1
+  .locals init (int V_0,
+                object V_1,
+                object V_2,
+                string V_3,
+                int V_4,
+                object V_5,
+                object V_6,
+                int? V_7,
+                System.Runtime.CompilerServices.TaskAwaiter<object> V_8,
+                C.<M>d__1 V_9,
+                System.Runtime.CompilerServices.TaskAwaiter<object> V_10,
+                System.Exception V_11)
+  IL_0000:  ldarg.0
+  IL_0001:  ldfld      ""string C.<M>d__1.<a>5__1""
+  IL_0006:  ret
+}
+");
+                VerifyLocal(testData, typeName, locals[3], "<>m3", "s", expectedILOpt:
+@"{
+  // Code size        7 (0x7)
+  .maxstack  1
+  .locals init (int V_0,
+                object V_1,
+                object V_2,
+                string V_3,
+                int V_4,
+                object V_5,
+                object V_6,
+                int? V_7,
+                System.Runtime.CompilerServices.TaskAwaiter<object> V_8,
+                C.<M>d__1 V_9,
+                System.Runtime.CompilerServices.TaskAwaiter<object> V_10,
+                System.Exception V_11)
+  IL_0000:  ldarg.0
+  IL_0001:  ldfld      ""string C.<M>d__1.<s>5__2""
+  IL_0006:  ret
+}");
+                locals.Free();
+
+                context = CreateMethodContext(runtime, "C.<M>d__1.MoveNext", atLineNumber: 2000);
+
+                testData = new CompilationTestData();
+                locals = ArrayBuilder<LocalAndMethod>.GetInstance();
+                assembly = context.CompileGetLocals(locals, argumentsOnly: false, typeName: out typeName, testData: testData);
+                Assert.NotNull(assembly);
+                Assert.NotEqual(assembly.Count, 0);
+
+                Assert.Equal(locals.Count, 4);
+                VerifyLocal(testData, typeName, locals[0], "<>m0", "this", expectedILOpt:
+@"{
+  // Code size        7 (0x7)
+  .maxstack  1
+  .locals init (int V_0,
+                object V_1,
+                object V_2,
+                string V_3,
+                int V_4,
+                object V_5,
+                object V_6,
+                int? V_7,
+                System.Runtime.CompilerServices.TaskAwaiter<object> V_8,
+                C.<M>d__1 V_9,
+                System.Runtime.CompilerServices.TaskAwaiter<object> V_10,
+                System.Exception V_11)
+  IL_0000:  ldarg.0
+  IL_0001:  ldfld      ""C C.<M>d__1.<>4__this""
+  IL_0006:  ret
+}");
+                VerifyLocal(testData, typeName, locals[1], "<>m1", "o", expectedILOpt:
+@"{
+  // Code size        7 (0x7)
+  .maxstack  1
+  .locals init (int V_0,
+                object V_1,
+                object V_2,
+                string V_3,
+                int V_4,
+                object V_5,
+                object V_6,
+                int? V_7,
+                System.Runtime.CompilerServices.TaskAwaiter<object> V_8,
+                C.<M>d__1 V_9,
+                System.Runtime.CompilerServices.TaskAwaiter<object> V_10,
+                System.Exception V_11)
+  IL_0000:  ldarg.0
+  IL_0001:  ldfld      ""object C.<M>d__1.o""
+  IL_0006:  ret
+}");
+                VerifyLocal(testData, typeName, locals[2], "<>m2", "a", expectedILOpt:
+@"{
+  // Code size        7 (0x7)
+  .maxstack  1
+  .locals init (int V_0,
+                object V_1,
+                object V_2,
+                string V_3,
+                int V_4,
+                object V_5,
+                object V_6,
+                int? V_7,
+                System.Runtime.CompilerServices.TaskAwaiter<object> V_8,
+                C.<M>d__1 V_9,
+                System.Runtime.CompilerServices.TaskAwaiter<object> V_10,
+                System.Exception V_11)
+  IL_0000:  ldarg.0
+  IL_0001:  ldfld      ""string C.<M>d__1.<a>5__1""
+  IL_0006:  ret
+}
+");
+                VerifyLocal(testData, typeName, locals[3], "<>m3", "s", expectedILOpt:
+@"{
+  // Code size        7 (0x7)
+  .maxstack  1
+  .locals init (int V_0,
+                object V_1,
+                object V_2,
+                string V_3,
+                int V_4,
+                object V_5,
+                object V_6,
+                int? V_7,
+                System.Runtime.CompilerServices.TaskAwaiter<object> V_8,
+                C.<M>d__1 V_9,
+                System.Runtime.CompilerServices.TaskAwaiter<object> V_10,
+                System.Exception V_11)
+  IL_0000:  ldarg.0
+  IL_0001:  ldfld      ""int C.<M>d__1.<s>5__3""
+  IL_0006:  ret
+}");
+                locals.Free();
+            });
+        }
+
         /// <summary>
         /// No local signature (debugging a .dmp with no heap). Local
         /// names are known but types are not so the locals are dropped.
@@ -1419,7 +2071,7 @@ .maxstack  1
         }
 
         [Fact]
-        public void Async_StaticMethod()
+        public void Async_StaticMethod_01()
         {
             var source =
 @"using System.Threading.Tasks;
@@ -1482,6 +2134,123 @@ .maxstack  1
             });
         }
 
+        [Fact]
+        public void Async_StaticMethod_02()
+        {
+            var source =
+@"using System.Threading.Tasks;
+class C
+{
+    static async Task<object> F(object o)
+    {
+        return o;
+    }
+    static async Task M(object x)
+    {
+        {
+#line 1000
+            int y = (int)await F(x);
+            await F(y);
+        }
+        {
+#line 2000
+            long y = (long)await F(x);
+            await F(y);
+        }
+    }
+}";
+            var compilation0 = CreateCompilationWithMscorlib45(
+                source,
+                options: TestOptions.DebugDll,
+                references: new[] { SystemRef_v4_0_30319_17929, SystemCoreRef_v4_0_30319_17929, CSharpRef });
+
+            WithRuntimeInstance(compilation0, runtime =>
+            {
+                var context = CreateMethodContext(runtime, "C.<M>d__1.MoveNext", atLineNumber: 1000);
+
+                var testData = new CompilationTestData();
+                var locals = ArrayBuilder<LocalAndMethod>.GetInstance();
+                string typeName;
+                context.CompileGetLocals(locals, argumentsOnly: false, typeName: out typeName, testData: testData);
+
+                VerifyLocal(testData, "<>x", locals[0], "<>m0", "x", expectedILOpt:
+@"{
+  // Code size        7 (0x7)
+  .maxstack  1
+  .locals init (int V_0,
+                System.Runtime.CompilerServices.TaskAwaiter<object> V_1,
+                object V_2,
+                C.<M>d__1 V_3,
+                System.Runtime.CompilerServices.TaskAwaiter<object> V_4,
+                System.Runtime.CompilerServices.TaskAwaiter<object> V_5,
+                System.Runtime.CompilerServices.TaskAwaiter<object> V_6,
+                System.Exception V_7)
+  IL_0000:  ldarg.0
+  IL_0001:  ldfld      ""object C.<M>d__1.x""
+  IL_0006:  ret
+}");
+                VerifyLocal(testData, "<>x", locals[1], "<>m1", "y", expectedILOpt:
+@"{
+  // Code size        7 (0x7)
+  .maxstack  1
+  .locals init (int V_0,
+                System.Runtime.CompilerServices.TaskAwaiter<object> V_1,
+                object V_2,
+                C.<M>d__1 V_3,
+                System.Runtime.CompilerServices.TaskAwaiter<object> V_4,
+                System.Runtime.CompilerServices.TaskAwaiter<object> V_5,
+                System.Runtime.CompilerServices.TaskAwaiter<object> V_6,
+                System.Exception V_7)
+  IL_0000:  ldarg.0
+  IL_0001:  ldfld      ""int C.<M>d__1.<y>5__1""
+  IL_0006:  ret
+}");
+                Assert.Equal(locals.Count, 2);
+                locals.Free();
+
+                context = CreateMethodContext(runtime, "C.<M>d__1.MoveNext", atLineNumber: 2000);
+
+                testData = new CompilationTestData();
+                locals = ArrayBuilder<LocalAndMethod>.GetInstance();
+                context.CompileGetLocals(locals, argumentsOnly: false, typeName: out typeName, testData: testData);
+
+                VerifyLocal(testData, "<>x", locals[0], "<>m0", "x", expectedILOpt:
+@"{
+  // Code size        7 (0x7)
+  .maxstack  1
+  .locals init (int V_0,
+                System.Runtime.CompilerServices.TaskAwaiter<object> V_1,
+                object V_2,
+                C.<M>d__1 V_3,
+                System.Runtime.CompilerServices.TaskAwaiter<object> V_4,
+                System.Runtime.CompilerServices.TaskAwaiter<object> V_5,
+                System.Runtime.CompilerServices.TaskAwaiter<object> V_6,
+                System.Exception V_7)
+  IL_0000:  ldarg.0
+  IL_0001:  ldfld      ""object C.<M>d__1.x""
+  IL_0006:  ret
+}");
+                VerifyLocal(testData, "<>x", locals[1], "<>m1", "y", expectedILOpt:
+@"{
+  // Code size        7 (0x7)
+  .maxstack  1
+  .locals init (int V_0,
+                System.Runtime.CompilerServices.TaskAwaiter<object> V_1,
+                object V_2,
+                C.<M>d__1 V_3,
+                System.Runtime.CompilerServices.TaskAwaiter<object> V_4,
+                System.Runtime.CompilerServices.TaskAwaiter<object> V_5,
+                System.Runtime.CompilerServices.TaskAwaiter<object> V_6,
+                System.Exception V_7)
+  IL_0000:  ldarg.0
+  IL_0001:  ldfld      ""long C.<M>d__1.<y>5__3""
+  IL_0006:  ret
+}");
+                Assert.Equal(locals.Count, 2);
+                locals.Free();
+            });
+        }
+
         [WorkItem(995976, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/995976")]
         [WorkItem(10649, "https://github.com/dotnet/roslyn/issues/10649")]
         [Fact]