Expression breakpoints for switch expression.

src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml

@@ -776,7 +776,37 @@
     <Field Name="StatementOpt" Type="BoundStatement?"/>
     <Field Name="Span" Type="TextSpan"/>
   </Node>
-
+
+  <!--
+    This is used to save the debugger's idea of what the enclosing sequence
+    point is at this location in the code so that it can be restored later
+    by a BoundRestorePreviousSequencePoint node. When this statement appears,
+    the previous non-hidden sequence point is saved and associated with the
+    given Identifier.
+    -->
+  <Node Name="BoundSavePreviousSequencePoint" Base="BoundStatement">
+    <Field Name="Identifier" Type="object"/>
+  </Node>
+
+  <!--
+    This is used to restore the debugger's idea of what the enclosing statement
+    is to some previous location without introducing a place where a breakpoint
+    would cause the debugger to stop. The identifier must have
+    previously been given in a BoundSavePreviousSequencePoint statement. This is used
+    to implement breakpoints within expressions (e.g. a switch expression).
+    -->
+  <Node Name="BoundRestorePreviousSequencePoint" Base="BoundStatement">
+    <Field Name="Identifier" Type="object"/>
+  </Node>
+
+  <!--
+    This is used to set the debugger's idea of what the enclosing statement
+    is without causing the debugger to stop here when single stepping.
+    -->
+  <Node Name="BoundStepThroughSequencePoint" Base="BoundStatement">
+    <Field Name="Span" Type="TextSpan"/>
+  </Node>
+
   <!--  
   BoundBlock contains 
     a) Statements - actions performed within the scope of the block

src/Compilers/CSharp/Portable/CodeGen/CodeGenerator.cs

@@ -35,7 +35,7 @@ internal sealed partial class CodeGenerator
 
         // There are scenarios where rvalues need to be passed to ref/in parameters
         // in such cases the values must be spilled into temps and retained for the entirety of
-        // the most encompassing expression.       
+        // the most encompassing expression.
         private ArrayBuilder<LocalDefinition> _expressionTemps;
 
         // not 0 when in a protected region with a handler. 
@@ -57,6 +57,11 @@ internal sealed partial class CodeGenerator
         /// </summary>
         private IndirectReturnState _indirectReturnState;
 
+        /// <summary>
+        /// Used to implement <see cref="BoundSavePreviousSequencePoint"/> and <see cref="BoundRestorePreviousSequencePoint"/>.
+        /// </summary>
+        private PooledDictionary<object, TextSpan> _savedSequencePoints;
+
         private enum IndirectReturnState : byte
         {
             NotNeeded = 0,  // did not see indirect returns
@@ -294,6 +299,7 @@ private void GenerateImpl()
 
             Debug.Assert(!(_expressionTemps?.Count > 0), "leaking expression temps?");
             _expressionTemps?.Free();
+            _savedSequencePoints?.Free();
         }
 
         private void HandleReturn()
@@ -401,6 +407,58 @@ private void EmitSequencePointStatement(BoundSequencePointWithSpan node)
             }
         }
 
+        private void EmitSavePreviousSequencePoint(BoundSavePreviousSequencePoint statement)
+        {
+            if (!_emitPdbSequencePoints)
+                return;
+
+            ArrayBuilder<RawSequencePoint> sequencePoints = _builder.SeqPointsOpt;
+            if (sequencePoints is null)
+                return;
+
+            for (int i = sequencePoints.Count - 1; i >= 0; i--)
+            {
+                var span = sequencePoints[i].Span;
+                if (span == RawSequencePoint.HiddenSequencePointSpan)
+                    continue;
+
+                // Found the previous non-hidden sequence point.  Save it.
+                _savedSequencePoints ??= PooledDictionary<object, TextSpan>.GetInstance();
+                _savedSequencePoints.Add(statement.Identifier, span);
+                return;
+            }
+        }
+
+        private void EmitRestorePreviousSequencePoint(BoundRestorePreviousSequencePoint node)
+        {
+            Debug.Assert(node.Syntax is { });
+            if (_savedSequencePoints is null || !_savedSequencePoints.TryGetValue(node.Identifier, out var span))
+                return;
+
+            EmitStepThroughSequencePoint(node.Syntax.SyntaxTree, span);
+        }
+
+        private void EmitStepThroughSequencePoint(BoundStepThroughSequencePoint node)
+        {
+            EmitStepThroughSequencePoint(node.Syntax.SyntaxTree, node.Span);
+        }
+
+        private void EmitStepThroughSequencePoint(SyntaxTree syntaxTree, TextSpan span)
+        {
+            if (!_emitPdbSequencePoints)
+                return;
+
+            var label = new object();
+            // The IL builder is eager to discard unreachable code, so
+            // we fool it by branching on a condition that is always true at runtime.
+            _builder.EmitConstantValue(ConstantValue.Create(true));
+            _builder.EmitBranch(ILOpCode.Brtrue, label);
+            EmitSequencePoint(syntaxTree, span);
+            _builder.EmitOpCode(ILOpCode.Nop);
+            _builder.MarkLabel(label);
+            EmitHiddenSequencePoint();
+        }
+
         private void SetInitialDebugDocument()
         {
             if (_emitPdbSequencePoints && _methodBodySyntaxOpt != null)

src/Compilers/CSharp/Portable/CodeGen/EmitStatement.cs

@@ -41,6 +41,18 @@ private void EmitStatement(BoundStatement statement)
                     this.EmitSequencePointStatement((BoundSequencePointWithSpan)statement);
                     break;
 
+                case BoundKind.SavePreviousSequencePoint:
+                    this.EmitSavePreviousSequencePoint((BoundSavePreviousSequencePoint)statement);
+                    break;
+
+                case BoundKind.RestorePreviousSequencePoint:
+                    this.EmitRestorePreviousSequencePoint((BoundRestorePreviousSequencePoint)statement);
+                    break;
+
+                case BoundKind.StepThroughSequencePoint:
+                    this.EmitStepThroughSequencePoint((BoundStepThroughSequencePoint)statement);
+                    break;
+
                 case BoundKind.ExpressionStatement:
                     EmitExpression(((BoundExpressionStatement)statement).Expression, false);
                     break;

src/Compilers/CSharp/Portable/FlowAnalysis/AbstractFlowPass.cs

@@ -3064,6 +3064,21 @@ protected virtual void VisitAssignmentOfNullCoalescingAssignment(
             }
         }
 
+        public override BoundNode VisitSavePreviousSequencePoint(BoundSavePreviousSequencePoint node)
+        {
+            return null;
+        }
+
+        public override BoundNode VisitRestorePreviousSequencePoint(BoundRestorePreviousSequencePoint node)
+        {
+            return null;
+        }
+
+        public override BoundNode VisitStepThroughSequencePoint(BoundStepThroughSequencePoint node)
+        {
+            return null;
+        }
+
         /// <summary>
         /// This visitor represents just the non-assignment part of the null coalescing assignment
         /// operator (when the left operand is non-null).

src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_BasePatternSwitchLocalRewriter.cs

@@ -48,7 +48,7 @@ protected BaseSwitchLocalRewriter(
 
                     // We start each switch block of a switch statement with a hidden sequence point so that
                     // we do not appear to be in the previous switch block when we begin.
-                    if (IsSwitchStatement)
+                    if (GenerateSequencePoints)
                         armBuilder.Add(_factory.HiddenSequencePoint());
 
                     _switchArms.Add(arm, armBuilder);