From 312a56886b2b3aba66f7dad92475afa7d7ff6764 Mon Sep 17 00:00:00 2001
From: tmat <tomas.matousek@microsoft.com>
Date: Sat, 24 Jun 2023 18:53:44 -0700
Subject: [PATCH 1/7] Improve sequence point placement in primary constructors
 and records

---
 .../Compiler/MethodBodySynthesizer.cs         |   1 +
 .../Instrumentation/DebugInfoInjector.cs      |  87 ++++--
 .../DebugInfoInjector_SequencePoints.cs       |  27 +-
 .../Records/SynthesizedRecordCopyCtor.cs      |  18 ++
 .../CSharp/Test/Emit/PDB/PDBLambdaTests.cs    |   8 +-
 .../CSharp/Test/Emit/PDB/PDBTests.cs          | 252 ++++++++++++++++++
 .../Core/Portable/CodeGen/ILBuilder.cs        |   4 +-
 .../EditAndContinue/BreakpointSpansTests.cs   | 154 ++++++++++-
 .../EditAndContinue/BreakpointSpans.cs        |  82 +++++-
 9 files changed, 586 insertions(+), 47 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Compiler/MethodBodySynthesizer.cs b/src/Compilers/CSharp/Portable/Compiler/MethodBodySynthesizer.cs
index ab95aec4a2fc1..36c2bf96ef216 100644
--- a/src/Compilers/CSharp/Portable/Compiler/MethodBodySynthesizer.cs
+++ b/src/Compilers/CSharp/Portable/Compiler/MethodBodySynthesizer.cs
@@ -194,6 +194,7 @@ internal static BoundBlock ConstructAutoPropertyAccessorBody(SourceMemberMethodS
             else
             {
                 Debug.Assert(accessor.MethodKind == MethodKind.PropertySet);
+
                 var parameter = accessor.Parameters[0];
                 statement = new BoundExpressionStatement(
                     accessor.SyntaxNode,
diff --git a/src/Compilers/CSharp/Portable/Lowering/Instrumentation/DebugInfoInjector.cs b/src/Compilers/CSharp/Portable/Lowering/Instrumentation/DebugInfoInjector.cs
index 29dbfd4a3326d..eca22779e4dbf 100644
--- a/src/Compilers/CSharp/Portable/Lowering/Instrumentation/DebugInfoInjector.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/Instrumentation/DebugInfoInjector.cs
@@ -58,21 +58,65 @@ public override BoundStatement InstrumentExpressionStatement(BoundExpressionStat
 
             if (original.IsConstructorInitializer())
             {
-                switch (original.Syntax.Kind())
+                switch (original.Syntax)
                 {
-                    case SyntaxKind.ConstructorDeclaration:
-                        // This is an implicit constructor initializer.
-                        var decl = (ConstructorDeclarationSyntax)original.Syntax;
-                        return new BoundSequencePointWithSpan(decl, rewritten, CreateSpanForConstructorInitializer(decl));
-                    case SyntaxKind.BaseConstructorInitializer:
-                    case SyntaxKind.ThisConstructorInitializer:
-                        var init = (ConstructorInitializerSyntax)original.Syntax;
-                        Debug.Assert(init.Parent is object);
-                        return new BoundSequencePointWithSpan(init, rewritten, CreateSpanForConstructorInitializer((ConstructorDeclarationSyntax)init.Parent));
+                    case ConstructorDeclarationSyntax ctorDecl:
+                        // Implicit constructor initializer:
+                        return new BoundSequencePointWithSpan(ctorDecl, rewritten, createSpanForConstructorInitializer(ctorDecl));
+
+                    case ConstructorInitializerSyntax ctorInit:
+                        // Explicit constructor initializer:
+                        Debug.Assert(ctorInit.Parent is ConstructorDeclarationSyntax);
+                        return new BoundSequencePointWithSpan(ctorInit, rewritten, createSpanForConstructorInitializer((ConstructorDeclarationSyntax)ctorInit.Parent));
+
+                    case TypeDeclarationSyntax typeDecl:
+                        // Primary constructor with implicit base initializer:
+                        //   class [|C<T>(int X, int Y)|] : B;
+                        Debug.Assert(typeDecl.ParameterList != null);
+                        Debug.Assert(typeDecl.BaseList?.Types.Any(t => t is PrimaryConstructorBaseTypeSyntax { ArgumentList: not null }) != true);
+
+                        return new BoundSequencePointWithSpan(typeDecl, rewritten, TextSpan.FromBounds(typeDecl.Identifier.SpanStart, typeDecl.ParameterList.Span.End));
+
+                    case PrimaryConstructorBaseTypeSyntax baseInit:
+                        // Explicit base initializer:
+                        //   class C<T>(int X, int Y) : [|B(...)|];
+                        return new BoundSequencePointWithSpan(baseInit, rewritten, baseInit.Span);
+
+                    default:
+                        throw ExceptionUtilities.UnexpectedValue(original.Syntax.Kind());
                 }
             }
+            else if (original.Syntax is ParameterSyntax parameterSyntax)
+            {
+                // Record property setter sequence point.
+                return new BoundSequencePointWithSpan(parameterSyntax, rewritten, CreateSpan(parameterSyntax));
+            }
 
             return AddSequencePoint(rewritten);
+
+            static TextSpan createSpanForConstructorInitializer(ConstructorDeclarationSyntax constructorSyntax)
+            {
+                if (constructorSyntax.Initializer != null)
+                {
+                    //  [SomeAttribute] public MyCtorName(params int[] values): [|base()|] { ... }
+                    var start = constructorSyntax.Initializer.ThisOrBaseKeyword.SpanStart;
+                    var end = constructorSyntax.Initializer.ArgumentList.CloseParenToken.Span.End;
+                    return TextSpan.FromBounds(start, end);
+                }
+
+                if (constructorSyntax.Modifiers.Any(SyntaxKind.StaticKeyword))
+                {
+                    Debug.Assert(constructorSyntax.Body != null);
+
+                    // [SomeAttribute] static MyCtorName(...) [|{|] ... }
+                    var start = constructorSyntax.Body.OpenBraceToken.SpanStart;
+                    var end = constructorSyntax.Body.OpenBraceToken.Span.End;
+                    return TextSpan.FromBounds(start, end);
+                }
+
+                //  [SomeAttribute] [|public MyCtorName(params int[] values)|] { ... }
+                return CreateSpan(constructorSyntax.Modifiers, constructorSyntax.Identifier, constructorSyntax.ParameterList.CloseParenToken);
+            }
         }
 
         public override BoundStatement InstrumentFieldOrPropertyInitializer(BoundStatement original, BoundStatement rewritten)
@@ -94,7 +138,8 @@ private static BoundStatement InstrumentFieldOrPropertyInitializer(BoundStatemen
             if (syntax.IsKind(SyntaxKind.Parameter))
             {
                 // This is an initialization of a generated property based on record parameter.
-                return AddSequencePoint(rewritten);
+                // Do not add sequence point - the initialization is trivial and there is no value stepping over every backing field assignment.
+                return rewritten;
             }
 
             Debug.Assert(syntax is { Parent: { Parent: { } } });
@@ -163,14 +208,18 @@ public override void InstrumentBlock(BoundBlock original, LocalRewriter rewriter
             }
             else if (original == rewriter.CurrentMethodBody)
             {
-                if (previousPrologue != null)
+                // Add hidden sequence point at the start of
+                // 1) a prologue added by instrumentation.
+                // 2) a synthesized main entry point for top-level code.
+                // 3) synthesized body of primary and copy constructors of a record type that has at least one parameter.
+                //    This hidden sequence point covers assignments of parameters/original fields to the current instance backing fields.
+                //    These assignments do not have their own sequence points.
+                if (previousPrologue != null ||
+                    rewriter.Factory.TopLevelMethod is SynthesizedSimpleProgramEntryPointSymbol ||
+                    original.Syntax is RecordDeclarationSyntax { ParameterList.Parameters.Count: > 0 })
                 {
                     prologue = BoundSequencePoint.CreateHidden(previousPrologue);
                 }
-                else if (rewriter.Factory.TopLevelMethod is SynthesizedSimpleProgramEntryPointSymbol)
-                {
-                    prologue = BoundSequencePoint.CreateHidden();
-                }
 
                 if (previousEpilogue != null)
                 {
@@ -364,6 +413,12 @@ public override BoundStatement InstrumentReturnStatement(BoundReturnStatement or
                 return new BoundSequencePointWithSpan(original.Syntax, rewritten, ((BlockSyntax)original.Syntax).CloseBraceToken.Span);
             }
 
+            if (original.Syntax is ParameterSyntax parameterSyntax)
+            {
+                // Record property getter sequence point
+                return new BoundSequencePointWithSpan(parameterSyntax, rewritten, CreateSpan(parameterSyntax));
+            }
+
             return new BoundSequencePoint(original.Syntax, rewritten);
         }
 
diff --git a/src/Compilers/CSharp/Portable/Lowering/Instrumentation/DebugInfoInjector_SequencePoints.cs b/src/Compilers/CSharp/Portable/Lowering/Instrumentation/DebugInfoInjector_SequencePoints.cs
index 575615d34a2b5..bed18cb6964c4 100644
--- a/src/Compilers/CSharp/Portable/Lowering/Instrumentation/DebugInfoInjector_SequencePoints.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/Instrumentation/DebugInfoInjector_SequencePoints.cs
@@ -45,29 +45,10 @@ internal static BoundStatement AddSequencePoint(UsingStatementSyntax usingSyntax
             return new BoundSequencePointWithSpan(usingSyntax, rewrittenStatement, span);
         }
 
-        private static TextSpan CreateSpanForConstructorInitializer(ConstructorDeclarationSyntax constructorSyntax)
-        {
-            if (constructorSyntax.Initializer != null)
-            {
-                //  [SomeAttribute] public MyCtorName(params int[] values): [|base()|] { ... }
-                var start = constructorSyntax.Initializer.ThisOrBaseKeyword.SpanStart;
-                var end = constructorSyntax.Initializer.ArgumentList.CloseParenToken.Span.End;
-                return TextSpan.FromBounds(start, end);
-            }
-
-            if (constructorSyntax.Modifiers.Any(SyntaxKind.StaticKeyword))
-            {
-                Debug.Assert(constructorSyntax.Body != null);
-
-                // [SomeAttribute] static MyCtorName(...) [|{|] ... }
-                var start = constructorSyntax.Body.OpenBraceToken.SpanStart;
-                var end = constructorSyntax.Body.OpenBraceToken.Span.End;
-                return TextSpan.FromBounds(start, end);
-            }
-
-            //  [SomeAttribute] [|public MyCtorName(params int[] values)|] { ... }
-            return CreateSpan(constructorSyntax.Modifiers, constructorSyntax.Identifier, constructorSyntax.ParameterList.CloseParenToken);
-        }
+        private static TextSpan CreateSpan(ParameterSyntax parameter)
+            // exclude attributes and default value:
+            // [A] [|in T p|] = default
+            => CreateSpan(parameter.Modifiers, parameter.Type, parameter.Identifier);
 
         private static TextSpan CreateSpan(SyntaxTokenList startOpt, SyntaxNodeOrToken startFallbackOpt, SyntaxNodeOrToken endOpt)
         {
diff --git a/src/Compilers/CSharp/Portable/Symbols/Synthesized/Records/SynthesizedRecordCopyCtor.cs b/src/Compilers/CSharp/Portable/Symbols/Synthesized/Records/SynthesizedRecordCopyCtor.cs
index 47baaace29767..b48ce17b0db22 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Synthesized/Records/SynthesizedRecordCopyCtor.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Synthesized/Records/SynthesizedRecordCopyCtor.cs
@@ -5,7 +5,9 @@
 using System.Collections.Immutable;
 using System.Diagnostics;
 using Microsoft.CodeAnalysis.CSharp.Emit;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.PooledObjects;
+using Microsoft.CodeAnalysis.Text;
 
 namespace Microsoft.CodeAnalysis.CSharp.Symbols
 {
@@ -53,6 +55,22 @@ internal override void GenerateMethodBodyStatements(SyntheticBoundNodeFactory F,
                     statements.Add(F.Assignment(F.Field(F.This(), field), F.Field(param, field)));
                 }
             }
+
+            // Add a sequence point at the end of the copy-constructor, so that a breakpoint placed on the record constructor
+            // can be hit whenever a new instance of the record is created (either via a primary constructor or vie a copy constructor).
+            // 
+            // If the record doesn't have base initializer the span overlaps the span of the sequence point generated for primary
+            // constructor implicit base initializer:
+            //
+            // record [|C<T>(int P, int Q)|]               // implicit base constructor initializer span
+            // record C<T>(int P, int Q) : [|B(...)|]      // explicit base constructor initializer span
+            // record [|C<T>|](int P, int Q)               // copy-constructor span
+            //
+            // The copy-constructor span does not include the parameter list since the parameters are not in scope.
+            var recordDeclaration = (RecordDeclarationSyntax)F.Syntax;
+            statements.Add(new BoundSequencePointWithSpan(recordDeclaration, statementOpt: null,
+                (recordDeclaration.TypeParameterList == null) ? recordDeclaration.Identifier.Span :
+                TextSpan.FromBounds(recordDeclaration.Identifier.Span.Start, recordDeclaration.TypeParameterList.Span.End)));
         }
 
         internal override void AddSynthesizedAttributes(PEModuleBuilder moduleBuilder, ref ArrayBuilder<SynthesizedAttributeData> attributes)
diff --git a/src/Compilers/CSharp/Test/Emit/PDB/PDBLambdaTests.cs b/src/Compilers/CSharp/Test/Emit/PDB/PDBLambdaTests.cs
index 0c623da3363ab..71b4b6d1c16d1 100644
--- a/src/Compilers/CSharp/Test/Emit/PDB/PDBLambdaTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/PDB/PDBLambdaTests.cs
@@ -1912,7 +1912,7 @@ public static void M(int a)
         }
 
         [Fact]
-        public void Record_1()
+        public void LiftedPrimaryParameter_Record()
         {
             var source = WithWindowsLineBreaks(@"
 using System;
@@ -1949,7 +1949,7 @@ record D(int X)
             <entry offset=""0x0"" hidden=""true"" document=""1"" />
             <entry offset=""0xd"" startLine=""3"" startColumn=""10"" endLine=""3"" endColumn=""15"" document=""1"" />
             <entry offset=""0x19"" startLine=""5"" startColumn=""34"" endLine=""5"" endColumn=""74"" document=""1"" />
-            <entry offset=""0x31"" startLine=""3"" startColumn=""1"" endLine=""6"" endColumn=""2"" document=""1"" />
+            <entry offset=""0x31"" startLine=""3"" startColumn=""8"" endLine=""3"" endColumn=""16"" document=""1"" />
           </sequencePoints>
           <scope startOffset=""0x0"" endOffset=""0x39"">
             <namespace name=""System"" />
@@ -1989,7 +1989,7 @@ record D(int X)
         }
 
         [Fact]
-        public void Record_2()
+        public void PrimaryBaseInitializer()
         {
             var source = WithWindowsLineBreaks(@"
 using System;
@@ -2029,7 +2029,7 @@ static int F(int x, out int p)
           </customDebugInfo>
           <sequencePoints>
             <entry offset=""0x0"" startLine=""3"" startColumn=""10"" endLine=""3"" endColumn=""15"" document=""1"" />
-            <entry offset=""0x7"" startLine=""3"" startColumn=""1"" endLine=""9"" endColumn=""2"" document=""1"" />
+            <entry offset=""0x7"" startLine=""3"" startColumn=""8"" endLine=""3"" endColumn=""16"" document=""1"" />
           </sequencePoints>
           <scope startOffset=""0x0"" endOffset=""0xf"">
             <namespace name=""System"" />
diff --git a/src/Compilers/CSharp/Test/Emit/PDB/PDBTests.cs b/src/Compilers/CSharp/Test/Emit/PDB/PDBTests.cs
index 0f7f25e7cf185..3d221744e961f 100644
--- a/src/Compilers/CSharp/Test/Emit/PDB/PDBTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/PDB/PDBTests.cs
@@ -12267,6 +12267,258 @@ public void SyntaxOffset_OutVarInSwitchExpression()
 ");
         }
 
+        [Fact]
+        public void SyntaxOffset_OutVarInPrimaryConstructorInitializer()
+        {
+            var source = @"
+class B(int x, int y)
+{
+}
+
+class C(int x) : B(F(out var y), y)
+{
+    int Z = F(out var z);
+    static int F(out int a) => a = 1;
+}";
+
+            var c = CreateCompilationWithMscorlib40AndSystemCore(source, options: TestOptions.DebugDll);
+            c.VerifyPdb(@"
+<symbols>
+  <files>
+    <file id=""1"" name="""" language=""C#"" />
+  </files>
+  <methods>
+    <method containingType=""B"" name="".ctor"" parameterNames=""x, y"">
+      <customDebugInfo>
+        <using>
+          <namespace usingCount=""0"" />
+        </using>
+      </customDebugInfo>
+      <sequencePoints>
+        <entry offset=""0x0"" startLine=""2"" startColumn=""7"" endLine=""2"" endColumn=""22"" document=""1"" />
+      </sequencePoints>
+    </method>
+    <method containingType=""C"" name="".ctor"" parameterNames=""x"">
+      <customDebugInfo>
+        <forward declaringType=""B"" methodName="".ctor"" parameterNames=""x, y"" />
+        <encLocalSlotMap>
+          <slot kind=""0"" offset=""-6"" />
+          <slot kind=""0"" offset=""-20"" />
+        </encLocalSlotMap>
+      </customDebugInfo>
+      <sequencePoints>
+        <entry offset=""0x0"" startLine=""8"" startColumn=""5"" endLine=""8"" endColumn=""26"" document=""1"" />
+        <entry offset=""0xd"" startLine=""6"" startColumn=""18"" endLine=""6"" endColumn=""36"" document=""1"" />
+      </sequencePoints>
+      <scope startOffset=""0x0"" endOffset=""0x1d"">
+        <local name=""y"" il_index=""0"" il_start=""0x0"" il_end=""0x1d"" attributes=""0"" />
+        <scope startOffset=""0x0"" endOffset=""0xd"">
+          <local name=""z"" il_index=""1"" il_start=""0x0"" il_end=""0xd"" attributes=""0"" />
+        </scope>
+      </scope>
+    </method>
+    <method containingType=""C"" name=""F"" parameterNames=""a"">
+      <customDebugInfo>
+        <forward declaringType=""B"" methodName="".ctor"" parameterNames=""x, y"" />
+      </customDebugInfo>
+      <sequencePoints>
+        <entry offset=""0x0"" startLine=""9"" startColumn=""32"" endLine=""9"" endColumn=""37"" document=""1"" />
+      </sequencePoints>
+    </method>
+  </methods>
+</symbols>
+");
+        }
+
+        #endregion
+
+        #region Primary Constructors
+
+        [Fact]
+        [WorkItem("https://github.com/dotnet/roslyn/issues/63299")]
+        public void SequencePoints_PrimaryConstructor_ExplicitBaseInitializer()
+        {
+            var source = @"
+class B() : object()
+{
+}
+
+class C(int x) : B()
+{
+    int y = 1;
+}";
+
+            var c = CompileAndVerify(source);
+            c.VerifyMethodBody("B..ctor", @"
+{
+  // Code size        7 (0x7)
+  .maxstack  1
+  // sequence point: object()
+  IL_0000:  ldarg.0
+  IL_0001:  call       ""object..ctor()""
+  IL_0006:  ret
+}
+");
+            c.VerifyMethodBody("C..ctor", @"
+ {
+  // Code size       14 (0xe)
+  .maxstack  2
+  // sequence point: int y = 1;
+  IL_0000:  ldarg.0
+  IL_0001:  ldc.i4.1
+  IL_0002:  stfld      ""int C.y""
+  // sequence point: B()
+  IL_0007:  ldarg.0
+  IL_0008:  call       ""B..ctor()""
+  IL_000d:  ret
+}
+");
+        }
+
+        [Fact]
+        [WorkItem("https://github.com/dotnet/roslyn/issues/63299")]
+        public void SequencePoints_PrimaryConstructor_ImplicitBaseInitializer()
+        {
+            var source = @"
+class B()
+{
+}
+
+class C(int x) : B
+{
+}";
+
+            var c = CompileAndVerify(source);
+            c.VerifyMethodBody("B..ctor", @"
+{
+  // Code size        7 (0x7)
+  .maxstack  1
+  // sequence point: B()
+  IL_0000:  ldarg.0
+  IL_0001:  call       ""object..ctor()""
+  IL_0006:  ret
+}
+");
+            c.VerifyMethodBody("C..ctor", @"
+{
+  // Code size        7 (0x7)
+  .maxstack  1
+  // sequence point: C(int x)
+  IL_0000:  ldarg.0
+  IL_0001:  call       ""B..ctor()""
+  IL_0006:  ret
+}
+");
+        }
+
+        [Fact]
+        [WorkItem("https://github.com/dotnet/roslyn/issues/63299")]
+        public void SequencePoints_RecordConstructors_ModiifersAndDefault()
+        {
+            var source = @"
+record C<T>([A]in T P = default) where T : struct;
+
+class A : System.Attribute {}
+" + IsExternalInitTypeDefinition;
+
+            var c = CompileAndVerify(source);
+
+            // primary constructor
+            c.VerifyMethodBody("C<T>..ctor(in T)", @"
+{
+  // Code size       19 (0x13)
+  .maxstack  2
+  // sequence point: <hidden>
+  IL_0000:  ldarg.0
+  IL_0001:  ldarg.1
+  IL_0002:  ldobj      ""T""
+  IL_0007:  stfld      ""T C<T>.<P>k__BackingField""
+  // sequence point: C<T>([A]in T P = default)
+  IL_000c:  ldarg.0
+  IL_000d:  call       ""object..ctor()""
+  IL_0012:  ret
+}
+");
+            // copy constructor
+            c.VerifyMethodBody("C<T>..ctor(C<T>)", @"
+{
+  // Code size       19 (0x13)
+  .maxstack  2
+  // sequence point: <hidden>
+  IL_0000:  ldarg.0
+  IL_0001:  call       ""object..ctor()""
+  IL_0006:  ldarg.0
+  IL_0007:  ldarg.1
+  IL_0008:  ldfld      ""T C<T>.<P>k__BackingField""
+  IL_000d:  stfld      ""T C<T>.<P>k__BackingField""
+  // sequence point: C<T>
+  IL_0012:  ret
+}
+");
+            // primary auto-property getter
+            c.VerifyMethodBody("C<T>.P.get", @"
+{
+  // Code size        7 (0x7)
+  .maxstack  1
+  // sequence point: in T P
+  IL_0000:  ldarg.0
+  IL_0001:  ldfld      ""T C<T>.<P>k__BackingField""
+  IL_0006:  ret
+}
+");
+            // primary auto-property setter
+            c.VerifyMethodBody("C<T>.P.init", @"
+{
+  // Code size        8 (0x8)
+  .maxstack  2
+  // sequence point: in T P
+  IL_0000:  ldarg.0
+  IL_0001:  ldarg.1
+  IL_0002:  stfld      ""T C<T>.<P>k__BackingField""
+  IL_0007:  ret
+}
+");
+        }
+        
+        [Theory]
+        [InlineData("int[] P = default", "int[] P")]
+        [InlineData("[A]int[] P", "int[] P")]
+        [InlineData("params int[] P", "params int[] P")]
+        [WorkItem("https://github.com/dotnet/roslyn/issues/63299")]
+        public void SequencePoints_RecordPropertyAccessors(string parameterSyntax, string expectedSpan)
+        {
+            var source =
+                "record C(" + parameterSyntax + ");" +
+                "class A : System.Attribute { }" +
+                IsExternalInitTypeDefinition;
+
+            var c = CompileAndVerify(source);
+
+            // primary auto-property getter
+            c.VerifyMethodBody("C.P.get", $@"
+{{
+  // Code size        7 (0x7)
+  .maxstack  1
+  // sequence point: {expectedSpan}
+  IL_0000:  ldarg.0
+  IL_0001:  ldfld      ""int[] C.<P>k__BackingField""
+  IL_0006:  ret
+}}
+");
+            // primary auto-property setter
+            c.VerifyMethodBody("C.P.init", $@"
+{{
+  // Code size        8 (0x8)
+  .maxstack  2
+  // sequence point: {expectedSpan}
+  IL_0000:  ldarg.0
+  IL_0001:  ldarg.1
+  IL_0002:  stfld      ""int[] C.<P>k__BackingField""
+  IL_0007:  ret
+}}
+");
+        }
+
         #endregion
 
         [WorkItem(4370, "https://github.com/dotnet/roslyn/issues/4370")]
diff --git a/src/Compilers/Core/Portable/CodeGen/ILBuilder.cs b/src/Compilers/Core/Portable/CodeGen/ILBuilder.cs
index 02604889c347c..31c1053d5c5e9 100644
--- a/src/Compilers/Core/Portable/CodeGen/ILBuilder.cs
+++ b/src/Compilers/Core/Portable/CodeGen/ILBuilder.cs
@@ -56,10 +56,10 @@ internal sealed partial class ILBuilder
         /// don't know the actual IL offset, but only {block/offset-in-the-block} pair.
         ///
         /// Thus, whenever we need to mark some IL position we allocate a new marker id, store it
-        /// in allocatedILMarkers and reference this IL marker in the entity requiring the IL offset.
+        /// in <see cref="_allocatedILMarkers"/> and reference this IL marker in the entity requiring the IL offset.
         ///
         /// IL markers will be 'materialized' when the builder is realized; the resulting offsets
-        /// will be put into allocatedILMarkers array. Note that only markers from reachable blocks
+        /// will be put into <see cref="_allocatedILMarkers"/> array. Note that only markers from reachable blocks
         /// are materialized, the rest will have offset -1.
         /// </summary>
         private ArrayBuilder<ILMarker> _allocatedILMarkers;
diff --git a/src/EditorFeatures/CSharpTest/EditAndContinue/BreakpointSpansTests.cs b/src/EditorFeatures/CSharpTest/EditAndContinue/BreakpointSpansTests.cs
index 5cb1ea0b82e1f..1988ff8b883b0 100644
--- a/src/EditorFeatures/CSharpTest/EditAndContinue/BreakpointSpansTests.cs
+++ b/src/EditorFeatures/CSharpTest/EditAndContinue/BreakpointSpansTests.cs
@@ -10,6 +10,7 @@
 using System.Threading;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Completion.Providers;
 using Microsoft.CodeAnalysis.CSharp.EditAndContinue;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Test.Utilities;
@@ -1291,7 +1292,7 @@ public void GroupBy_NoLambda3()
 
         #endregion
 
-        #region Field and Veriable Declarators
+        #region Field and Variable Declarators
 
         [Fact]
         public void FieldDeclarator_WithoutInitializer_All()
@@ -4409,6 +4410,157 @@ public void InstanceConstructor_NoInitializer_Attributes()
 }");
         }
 
+        [Theory]
+        [CombinatorialData]
+        public void InstanceConstructor_Primary_ImplicitBaseInitializer_OutsideOfIdentifierAndNonEmptyParameters(
+            [CombinatorialValues("class", "struct", "record", "record struct")] string keyword,
+            [CombinatorialValues(
+                "$$[A]class [|C()|];",
+                "$$class [|C()|];",
+                "class$$ [|C()|];",
+                "class [|C($$)|];",
+                "$$class [|C(int a)|];",
+                "$$class [|C(int a, int b)|];",
+                "class [|C(int a, int b)|]$$;",
+                "class [|C(int a, int b)|]$$ { }",
+                "class [|C(int a, int b)|]$$ : B { }",
+                "class [|C<T>(int a, int b)|]$$ where T : notnull;",
+                "class [|C<T>(int a, int b)|] where $$T : notnull;",
+                "class [|C<T>(int a, int b)|] where T : notnull$$;",
+                "class [|C<T>(int a, int b)|] where T : notnull$$ { }")] string source)
+        {
+            TestSpan(source.Replace("class", keyword));
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void InstanceConstructor_Primary_ImplicitBaseInitializer_OnIdentifierOrNonEmptyParameters_NonRecord(
+            [CombinatorialValues("class", "struct")] string keyword,
+            [CombinatorialValues(
+                "class [|$$C(int a, int b)|];",
+                "class [|C$$(int a, int b)|];",
+                "class [|C$$<T>(int a, int b)|];",
+                "class [|C<$$T>(int a, int b)|];",
+                "class [|C<$$[A]T>(int a, int b)|];",
+                "class [|C<T>$$(int a, int b)|];",
+                "class [|C<T>($$int a, int b)|];",
+                "class [|C<T>($$[A]int a, int b)|];",
+                "class [|C<T>(int a, int b$$)|];")] string source)
+        {
+            TestSpan(source.Replace("class", keyword));
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void InstanceConstructor_Primary_ImplicitBaseInitializer_OnIdentifierOrNonEmptyParameters_Record(
+            [CombinatorialValues("record", "record struct")] string keyword,
+            [CombinatorialValues(
+                "record [|$$C|](int a, int b);",          // copy-ctor
+                "record [|C$$|](int a, int b);",          // copy-ctor
+                "record [|C$$<T>|](int a, int b);",       // copy-ctor
+                "record [|C<$$T>|](int a, int b);",       // copy-ctor
+                "record [|C<$$[A]T>|](int a, int b);",    // copy-ctor
+                "record [|C<T>$$|](int a, int b);",       // copy-ctor
+                "record C<T>([|$$int a|], int b);",       // property getter and setter
+                "record C<T>($$[A][|int a|], int b);",    // property getter and setter
+                "record C<T>($$   [A][|int a|], int b);", // property getter and setter
+                "record C<T>(int a, [|int b$$|]);",       // property getter and setter
+                "record C<T>(int a,  $$ [|int b|]);",     // property getter and setter
+                "record C<T>(int a, [|params int[] b|]  $$);",     // property getter and setter
+                "record C<T>(int a, [|int b|] = default$$);")] string source) // property getter and setter
+        {
+            TestSpan(source.Replace("record", keyword));
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void InstanceConstructor_Primary_ImplicitBaseInitializer_NoBreakpoint(
+            [CombinatorialValues("class", "struct", "record", "record struct")] string keyword,
+            [CombinatorialValues(
+                "$$[A]class C;",
+                "$$class C;",
+                "class C$$;",
+                "class C(int a, int b) : B$$ { }",
+                "class C(int a, int b) : B {$$ }",
+                "class C(int a, int b) : B { }$$",
+                "class C(int a, int b) : B, $$I { }")] string source)
+        {
+            TestMissing(source.Replace("class", keyword));
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void InstanceConstructor_Primary_ExplicitBaseInitializer_OutsideOfIdentifierAndNonEmptyParameters(
+            [CombinatorialValues("class", "struct", "record", "record struct")] string keyword,
+            [CombinatorialValues(
+                "$$[A]class C() : [|B()|];",
+                "$$class C() : [|B()|];",
+                "$$class C(int a) : [|B()|];",
+                "$$class C(int a, int b) : [|B()|];",
+                "class C(int a, int b)$$ : [|B()|];",
+                "class C(int a, int b) :$$ [|B()|];",
+                "class C(int a, int b) : [|$$B()|];",
+                "class C(int a, int b) : [|B($$)|];",
+                "class C(int a, int b) : [|B()$$|];",
+                "class C(int a, int b) : [|B()|] $$;",
+                "class C(int a, int b) : [|B()|] $$ {}",
+                "class C(int a, int b) : [|B()|], $$I {}",
+                "class C(int a, int b) : [|B()|], I$$ {}",
+                "class C<T>(int a, int b) : [|B()|] $$ where T : notnull;",
+                "class C<T>(int a, int b) : [|B()|], $$I where T : notnull { }",
+                "class C<T>(int a, int b) : [|B()|], I$$ where T : notnull { }",
+                "class C<T>(int a, int b) : [|B()|]  where $$T : notnull;",
+                "class C<T>(int a, int b) : [|B()|]  where T : notnull$$;",
+                "class C<T>(int a, int b) : [|B()|]  where T : notnull$$ { }")] string source)
+        {
+            TestSpan(source.Replace("class", keyword));
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void InstanceConstructor_Primary_ExplicitBaseInitializer_OnIdentifierOrNonEmptyParameters_NonRecord(
+            [CombinatorialValues("class", "struct")] string keyword,
+            [CombinatorialValues(
+                "class $$C(int a, int b) : [|B()|];",
+                "class C$$(int a, int b) : [|B()|];",
+                "class C<$$[A]T>(int a, int b) : [|B()|];",
+                "class C<T>$$(int a, int b) : [|B()|];",
+                "record C<T>($$int a, int b) : [|B()|];",
+                "record C<T>(int a, $$int b) : [|B()|];",
+                "record C<T>(int a, int b =$$ 1) : [|B()|];")] string source)
+        {
+            TestSpan(source.Replace("class", keyword));
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void InstanceConstructor_Primary_ExplicitBaseInitializer_OnIdentifierOrNonEmptyParameters_Record(
+            [CombinatorialValues("record", "record struct")] string keyword,
+            [CombinatorialValues(
+                "record [|$$C|](int a, int b) : B();",        // copy-constructor
+                "record [|C$$|](int a, int b) : B();",        // copy-constructor
+                "record [|C<$$[A]T>|](int a, int b) : B();",  // copy-constructor
+                "record [|C<T>$$|](int a, int b) : B();",     // copy-constructor
+                "record C<T>([|$$int a|], int b) : B();",     // property getter and setter
+                "record C<T>(int a, [|$$int b|]) : B();",     // property getter and setter
+                "record C<T>(int a, [|$$int b = 1|]) : B();")] string source) // property getter and setter
+        {
+            TestSpan(source.Replace("record", keyword));
+        }
+
+        [Theory]
+        [CombinatorialData]
+        public void InstanceConstructor_Primary_ExplicitBaseInitializer_NoBreakpoint(
+            [CombinatorialValues("class", "struct", "record", "record struct")] string keyword,
+            [CombinatorialValues(
+                "class C(int a, int b) : B() {$$ }",
+                "class C(int a, int b) : B();$$",
+                "class C(int a, int b) : B() { }$$",
+                "class C(int a, int b) : B(), I { }$$")] string source)
+        {
+            TestMissing(source.Replace("class", keyword));
+        }
+
         [Fact]
         public void InstanceConstructor_BaseInitializer_BlockBody_All()
         {
diff --git a/src/Features/CSharp/Portable/EditAndContinue/BreakpointSpans.cs b/src/Features/CSharp/Portable/EditAndContinue/BreakpointSpans.cs
index 9dfcfb0276f06..1af4568ed92ba 100644
--- a/src/Features/CSharp/Portable/EditAndContinue/BreakpointSpans.cs
+++ b/src/Features/CSharp/Portable/EditAndContinue/BreakpointSpans.cs
@@ -153,6 +153,86 @@ private static int GetEndPosition(SyntaxNodeOrToken nodeOrToken)
                 case SyntaxKind.ConstructorDeclaration:
                     return CreateSpanForConstructorDeclaration((ConstructorDeclarationSyntax)node, position);
 
+                case SyntaxKind.RecordDeclaration:
+                case SyntaxKind.RecordStructDeclaration:
+                case SyntaxKind.StructDeclaration:
+                case SyntaxKind.ClassDeclaration:
+                    var typeDeclaration = (TypeDeclarationSyntax)node;
+                    if (typeDeclaration.ParameterList != null)
+                    {
+                        // after brace or semicolon
+                        // class C<T>(...) {$$ ... }
+                        // class C<T>(...) ;$$
+                        if (position > LastNotMissing(typeDeclaration.SemicolonToken, typeDeclaration.OpenBraceToken).SpanStart)
+                        {
+                            return null;
+                        }
+
+                        // on or after explicit base initializer:
+                        //   C<T>(...) :$$ [|B(...)|], I
+                        //   C<T>(...) : [|B(...)|], I where ... $$
+                        var baseInitializer = typeDeclaration.BaseList?.Types.FirstOrDefault(t => t.IsKind(SyntaxKind.PrimaryConstructorBaseType));
+                        if (baseInitializer != null && position > typeDeclaration.BaseList!.ColonToken.SpanStart)
+                        {
+                            return baseInitializer.Span;
+                        }
+
+                        // record properties and copy constructor
+                        if (position >= typeDeclaration.Identifier.SpanStart && node is RecordDeclarationSyntax)
+                        {
+                            // on identifier:
+                            // record $$C<T>(...) : B(...);
+                            // record C<T>$$(...) : B(...);
+                            if (position <= typeDeclaration.ParameterList.SpanStart)
+                            {
+                                // copy-constructor: [|C<T>|]
+                                return CreateSpan(
+                                    typeDeclaration.Identifier,
+                                    LastNotMissing(typeDeclaration.Identifier, typeDeclaration.TypeParameterList?.GreaterThanToken ?? default));
+                            }
+
+                            // on parameter:
+                            // record C<T>(..., $$ int p, ...) : B(...);
+                            if (position < typeDeclaration.ParameterList.CloseParenToken.Span.End)
+                            {
+                                var parameter = GetParameter(position, typeDeclaration.ParameterList.Parameters);
+                                if (parameter != null)
+                                {
+                                    // [A][|int p|] = default
+                                    return CreateSpan(parameter.Modifiers, parameter.Type, parameter.Identifier);
+                                }
+
+                                static ParameterSyntax? GetParameter(int position, SeparatedSyntaxList<ParameterSyntax> parameters)
+                                {
+                                    if (parameters.Count == 0)
+                                    {
+                                        return null;
+                                    }
+
+                                    for (var i = 0; i < parameters.SeparatorCount; i++)
+                                    {
+                                        var separator = parameters.GetSeparator(i);
+                                        if (position <= separator.SpanStart)
+                                        {
+                                            return parameters[i];
+                                        }
+                                    }
+
+                                    return parameters.Last();
+                                }
+                            }
+                        }
+
+                        // explicit base initializer
+                        //   C<T>(...) : [|B(...)|]
+                        // implicit base initializer
+                        //   [|C<T>(...)|]
+                        return (baseInitializer != null) ? baseInitializer.Span :
+                            TextSpan.FromBounds(typeDeclaration.Identifier.SpanStart, typeDeclaration.ParameterList.Span.End);
+                    }
+
+                    return null;
+
                 case SyntaxKind.VariableDeclarator:
                     // handled by the parent node
                     return null;
@@ -586,7 +666,7 @@ private static TextSpan CreateSpanForBlock(BlockSyntax block, int position)
         }
 
         private static SyntaxToken LastNotMissing(SyntaxToken token1, SyntaxToken token2)
-            => token2.IsMissing ? token1 : token2;
+            => token2.IsKind(SyntaxKind.None) || token2.IsMissing ? token1 : token2;
 
         private static TextSpan? TryCreateSpanForVariableDeclaration(VariableDeclarationSyntax declaration, int position)
             => declaration.Parent!.Kind() switch

From 9110372d06614ced93041c77ead0d5463fd56e48 Mon Sep 17 00:00:00 2001
From: tmat <tomas.matousek@microsoft.com>
Date: Mon, 26 Jun 2023 12:16:39 -0700
Subject: [PATCH 2/7] Fixes

---
 .../CSharp/Test/Emit/PDB/PDBLambdaTests.cs    | 28 +++++++++++++++++--
 .../CSharp/Test/Emit/PDB/PDBTests.cs          |  6 ++--
 .../EditAndContinue/BreakpointSpansTests.cs   | 24 ++++++++++------
 3 files changed, 44 insertions(+), 14 deletions(-)

diff --git a/src/Compilers/CSharp/Test/Emit/PDB/PDBLambdaTests.cs b/src/Compilers/CSharp/Test/Emit/PDB/PDBLambdaTests.cs
index 71b4b6d1c16d1..3eac5be19f705 100644
--- a/src/Compilers/CSharp/Test/Emit/PDB/PDBLambdaTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/PDB/PDBLambdaTests.cs
@@ -1947,7 +1947,7 @@ record D(int X)
           </customDebugInfo>
           <sequencePoints>
             <entry offset=""0x0"" hidden=""true"" document=""1"" />
-            <entry offset=""0xd"" startLine=""3"" startColumn=""10"" endLine=""3"" endColumn=""15"" document=""1"" />
+            <entry offset=""0xd"" hidden=""true"" document=""1"" />
             <entry offset=""0x19"" startLine=""5"" startColumn=""34"" endLine=""5"" endColumn=""74"" document=""1"" />
             <entry offset=""0x31"" startLine=""3"" startColumn=""8"" endLine=""3"" endColumn=""16"" document=""1"" />
           </sequencePoints>
@@ -1976,6 +1976,15 @@ record D(int X)
             <entry offset=""0x0"" startLine=""5"" startColumn=""25"" endLine=""5"" endColumn=""29"" document=""1"" />
           </sequencePoints>
         </method>
+        <method containingType=""D"" name="".ctor"" parameterNames=""original"">
+          <customDebugInfo>
+        <forward declaringType=""D"" methodName="".ctor"" parameterNames=""X"" />
+          </customDebugInfo>
+          <sequencePoints>
+        <entry offset=""0x0"" hidden=""true"" document=""1"" />
+        <entry offset=""0x1f"" startLine=""3"" startColumn=""8"" endLine=""3"" endColumn=""9"" document=""1"" />
+          </sequencePoints>
+        </method>
         <method containingType=""D+&lt;&gt;c__DisplayClass0_0"" name=""&lt;.ctor&gt;b__0"" parameterNames=""a"">
           <customDebugInfo>
             <forward declaringType=""D"" methodName="".ctor"" parameterNames=""X"" />
@@ -2028,7 +2037,7 @@ static int F(int x, out int p)
             </using>
           </customDebugInfo>
           <sequencePoints>
-            <entry offset=""0x0"" startLine=""3"" startColumn=""10"" endLine=""3"" endColumn=""15"" document=""1"" />
+            <entry offset=""0x0"" hidden=""true"" document=""1"" />
             <entry offset=""0x7"" startLine=""3"" startColumn=""8"" endLine=""3"" endColumn=""16"" document=""1"" />
           </sequencePoints>
           <scope startOffset=""0x0"" endOffset=""0xf"">
@@ -2055,6 +2064,15 @@ static int F(int x, out int p)
             <entry offset=""0x9"" startLine=""8"" startColumn=""5"" endLine=""8"" endColumn=""6"" document=""1"" />
           </sequencePoints>
         </method>
+        <method containingType=""C"" name="".ctor"" parameterNames=""original"">
+          <customDebugInfo>
+        <forward declaringType=""C"" methodName="".ctor"" parameterNames=""X"" />
+          </customDebugInfo>
+          <sequencePoints>
+        <entry offset=""0x0"" hidden=""true"" document=""1"" />
+        <entry offset=""0x13"" startLine=""3"" startColumn=""8"" endLine=""3"" endColumn=""9"" document=""1"" />
+          </sequencePoints>
+        </method>
         <method containingType=""D"" name="".ctor"" parameterNames=""X"">
           <customDebugInfo>
             <forward declaringType=""C"" methodName="".ctor"" parameterNames=""X"" />
@@ -2089,6 +2107,12 @@ static int F(int x, out int p)
             <entry offset=""0xa"" startLine=""17"" startColumn=""5"" endLine=""17"" endColumn=""6"" document=""1"" />
           </sequencePoints>
         </method>
+        <method containingType=""D"" name="".ctor"" parameterNames=""original"">
+          <sequencePoints>
+        <entry offset=""0x0"" hidden=""true"" document=""1"" />
+        <entry offset=""0x8"" startLine=""11"" startColumn=""8"" endLine=""11"" endColumn=""9"" document=""1"" />
+          </sequencePoints>
+        </method>
         <method containingType=""D+&lt;&gt;c__DisplayClass0_0"" name=""&lt;.ctor&gt;b__0"">
           <customDebugInfo>
             <forward declaringType=""C"" methodName="".ctor"" parameterNames=""X"" />
diff --git a/src/Compilers/CSharp/Test/Emit/PDB/PDBTests.cs b/src/Compilers/CSharp/Test/Emit/PDB/PDBTests.cs
index 3d221744e961f..379be9e4dc103 100644
--- a/src/Compilers/CSharp/Test/Emit/PDB/PDBTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/PDB/PDBTests.cs
@@ -12413,7 +12413,7 @@ .maxstack  1
 
         [Fact]
         [WorkItem("https://github.com/dotnet/roslyn/issues/63299")]
-        public void SequencePoints_RecordConstructors_ModiifersAndDefault()
+        public void SequencePoints_RecordConstructors_ModifiersAndDefault()
         {
             var source = @"
 record C<T>([A]in T P = default) where T : struct;
@@ -12421,7 +12421,7 @@ record C<T>([A]in T P = default) where T : struct;
 class A : System.Attribute {}
 " + IsExternalInitTypeDefinition;
 
-            var c = CompileAndVerify(source);
+            var c = CompileAndVerify(source, verify: Verification.Skipped);
 
             // primary constructor
             c.VerifyMethodBody("C<T>..ctor(in T)", @"
@@ -12492,7 +12492,7 @@ public void SequencePoints_RecordPropertyAccessors(string parameterSyntax, strin
                 "class A : System.Attribute { }" +
                 IsExternalInitTypeDefinition;
 
-            var c = CompileAndVerify(source);
+            var c = CompileAndVerify(source, verify: Verification.Skipped);
 
             // primary auto-property getter
             c.VerifyMethodBody("C.P.get", $@"
diff --git a/src/EditorFeatures/CSharpTest/EditAndContinue/BreakpointSpansTests.cs b/src/EditorFeatures/CSharpTest/EditAndContinue/BreakpointSpansTests.cs
index 1988ff8b883b0..571490c4f775c 100644
--- a/src/EditorFeatures/CSharpTest/EditAndContinue/BreakpointSpansTests.cs
+++ b/src/EditorFeatures/CSharpTest/EditAndContinue/BreakpointSpansTests.cs
@@ -55,7 +55,10 @@ private static void Test(string markup, bool isMissing, bool isLine, ParseOption
             else
             {
                 Assert.True(hasBreakpoint);
-                Assert.Equal(expectedSpan.Value, breakpointSpan);
+                AssertEx.AreEqual(
+                    expectedSpan.Value,
+                    breakpointSpan,
+                    message: $"Expected: [|{source.Substring(expectedSpan.Value.Start, expectedSpan.Value.Length)}|], Actual: [|{source.Substring(breakpointSpan.Start, breakpointSpan.Length)}|]");
             }
         }
 
@@ -4424,6 +4427,8 @@ public void InstanceConstructor_Primary_ImplicitBaseInitializer_OutsideOfIdentif
                 "class [|C(int a, int b)|]$$;",
                 "class [|C(int a, int b)|]$$ { }",
                 "class [|C(int a, int b)|]$$ : B { }",
+                "class [|C(int a, int b)|] : B$$ { }",
+                "class [|C(int a, int b)|] : B, $$I { }",
                 "class [|C<T>(int a, int b)|]$$ where T : notnull;",
                 "class [|C<T>(int a, int b)|] where $$T : notnull;",
                 "class [|C<T>(int a, int b)|] where T : notnull$$;",
@@ -4480,10 +4485,10 @@ public void InstanceConstructor_Primary_ImplicitBaseInitializer_NoBreakpoint(
                 "$$[A]class C;",
                 "$$class C;",
                 "class C$$;",
-                "class C(int a, int b) : B$$ { }",
-                "class C(int a, int b) : B {$$ }",
-                "class C(int a, int b) : B { }$$",
-                "class C(int a, int b) : B, $$I { }")] string source)
+                "class C;$$",
+                "class C(int a, int b);$$",
+                "class C(int a, int b) : B;$$",
+                "class C(int a, int b) : B { }$$")] string source)
         {
             TestMissing(source.Replace("class", keyword));
         }
@@ -4525,9 +4530,9 @@ public void InstanceConstructor_Primary_ExplicitBaseInitializer_OnIdentifierOrNo
                 "class C$$(int a, int b) : [|B()|];",
                 "class C<$$[A]T>(int a, int b) : [|B()|];",
                 "class C<T>$$(int a, int b) : [|B()|];",
-                "record C<T>($$int a, int b) : [|B()|];",
-                "record C<T>(int a, $$int b) : [|B()|];",
-                "record C<T>(int a, int b =$$ 1) : [|B()|];")] string source)
+                "class C<T>($$int a, int b) : [|B()|];",
+                "class C<T>(int a, $$int b) : [|B()|];",
+                "class C<T>(int a, int b =$$ 1) : [|B()|];")] string source)
         {
             TestSpan(source.Replace("class", keyword));
         }
@@ -4543,7 +4548,7 @@ public void InstanceConstructor_Primary_ExplicitBaseInitializer_OnIdentifierOrNo
                 "record [|C<T>$$|](int a, int b) : B();",     // copy-constructor
                 "record C<T>([|$$int a|], int b) : B();",     // property getter and setter
                 "record C<T>(int a, [|$$int b|]) : B();",     // property getter and setter
-                "record C<T>(int a, [|$$int b = 1|]) : B();")] string source) // property getter and setter
+                "record C<T>(int a, [|$$int b|] = 1) : B();")] string source) // property getter and setter
         {
             TestSpan(source.Replace("record", keyword));
         }
@@ -4556,6 +4561,7 @@ public void InstanceConstructor_Primary_ExplicitBaseInitializer_NoBreakpoint(
                 "class C(int a, int b) : B() {$$ }",
                 "class C(int a, int b) : B();$$",
                 "class C(int a, int b) : B() { }$$",
+                "class C(int a, int b) : B {$$ }",
                 "class C(int a, int b) : B(), I { }$$")] string source)
         {
             TestMissing(source.Replace("class", keyword));

From 97f9a426a6c8958c2e4dfa32bff810371f32145b Mon Sep 17 00:00:00 2001
From: tmat <tomas.matousek@microsoft.com>
Date: Mon, 26 Jun 2023 13:26:45 -0700
Subject: [PATCH 3/7] Fix

---
 .../CSharp/Test/Emit/PDB/PDBTests.cs          |  2 +-
 .../Test/Semantic/Semantics/RecordTests.cs    | 39 ++++++++++---------
 2 files changed, 22 insertions(+), 19 deletions(-)

diff --git a/src/Compilers/CSharp/Test/Emit/PDB/PDBTests.cs b/src/Compilers/CSharp/Test/Emit/PDB/PDBTests.cs
index 379be9e4dc103..85bdea0b25fae 100644
--- a/src/Compilers/CSharp/Test/Emit/PDB/PDBTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/PDB/PDBTests.cs
@@ -12479,7 +12479,7 @@ .maxstack  2
 }
 ");
         }
-        
+
         [Theory]
         [InlineData("int[] P = default", "int[] P")]
         [InlineData("[A]int[] P", "int[] P")]
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/RecordTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/RecordTests.cs
index b65892db19231..9b794c3a5d5bf 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/RecordTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/RecordTests.cs
@@ -13220,24 +13220,27 @@ public static void Main()
 ";
             var comp = CreateCompilation(new[] { source, IsExternalInitTypeDefinition }, parseOptions: TestOptions.Regular9, options: TestOptions.DebugExe);
             var verifier = CompileAndVerify(comp, expectedOutput: "(1, 2, 42) (10, 20, 42)", verify: ExecutionConditionUtil.IsCoreClr ? Verification.Skipped : Verification.Fails).VerifyDiagnostics();
-            verifier.VerifyIL("D..ctor(D)", @"
- {
-      // Code size       33 (0x21)
-      .maxstack  2
-      IL_0000:  ldarg.0
-      IL_0001:  ldarg.1
-      IL_0002:  call       ""C..ctor(C)""
-      IL_0007:  nop
-      IL_0008:  ldarg.0
-      IL_0009:  ldarg.1
-      IL_000a:  ldfld      ""int D.<J>k__BackingField""
-      IL_000f:  stfld      ""int D.<J>k__BackingField""
-      IL_0014:  ldarg.0
-      IL_0015:  ldarg.1
-      IL_0016:  ldfld      ""int D.field""
-      IL_001b:  stfld      ""int D.field""
-      IL_0020:  ret
-    }
+            verifier.VerifyMethodBody("D..ctor(D)", @"
+{
+  // Code size       34 (0x22)
+  .maxstack  2
+  // sequence point: <hidden>
+  IL_0000:  ldarg.0
+  IL_0001:  ldarg.1
+  IL_0002:  call       ""C..ctor(C)""
+  IL_0007:  nop
+  IL_0008:  ldarg.0
+  IL_0009:  ldarg.1
+  IL_000a:  ldfld      ""int D.<J>k__BackingField""
+  IL_000f:  stfld      ""int D.<J>k__BackingField""
+  IL_0014:  ldarg.0
+  IL_0015:  ldarg.1
+  IL_0016:  ldfld      ""int D.field""
+  IL_001b:  stfld      ""int D.field""
+  // sequence point: D
+  IL_0020:  nop
+  IL_0021:  ret
+}
 ");
         }
 

From 9949c8125d0d79340249cd24f8a52d739cc0d9da Mon Sep 17 00:00:00 2001
From: tmat <tomas.matousek@microsoft.com>
Date: Mon, 26 Jun 2023 13:50:49 -0700
Subject: [PATCH 4/7] Undo

---
 src/Compilers/CSharp/Portable/Compiler/MethodBodySynthesizer.cs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/Compilers/CSharp/Portable/Compiler/MethodBodySynthesizer.cs b/src/Compilers/CSharp/Portable/Compiler/MethodBodySynthesizer.cs
index 36c2bf96ef216..ab95aec4a2fc1 100644
--- a/src/Compilers/CSharp/Portable/Compiler/MethodBodySynthesizer.cs
+++ b/src/Compilers/CSharp/Portable/Compiler/MethodBodySynthesizer.cs
@@ -194,7 +194,6 @@ internal static BoundBlock ConstructAutoPropertyAccessorBody(SourceMemberMethodS
             else
             {
                 Debug.Assert(accessor.MethodKind == MethodKind.PropertySet);
-
                 var parameter = accessor.Parameters[0];
                 statement = new BoundExpressionStatement(
                     accessor.SyntaxNode,

From a670b3514baa2e632f128daa4dca473651077c62 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tom=C3=A1=C5=A1=20Matou=C5=A1ek?=
 <tmat@users.noreply.github.com>
Date: Mon, 10 Jul 2023 14:35:04 -0700
Subject: [PATCH 5/7] Update
 src/Compilers/CSharp/Portable/Symbols/Synthesized/Records/SynthesizedRecordCopyCtor.cs

Co-authored-by: Rikki Gibson <rikkigibson@gmail.com>
---
 .../Symbols/Synthesized/Records/SynthesizedRecordCopyCtor.cs    | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Compilers/CSharp/Portable/Symbols/Synthesized/Records/SynthesizedRecordCopyCtor.cs b/src/Compilers/CSharp/Portable/Symbols/Synthesized/Records/SynthesizedRecordCopyCtor.cs
index b48ce17b0db22..fadf78c917471 100644
--- a/src/Compilers/CSharp/Portable/Symbols/Synthesized/Records/SynthesizedRecordCopyCtor.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/Synthesized/Records/SynthesizedRecordCopyCtor.cs
@@ -57,7 +57,7 @@ internal override void GenerateMethodBodyStatements(SyntheticBoundNodeFactory F,
             }
 
             // Add a sequence point at the end of the copy-constructor, so that a breakpoint placed on the record constructor
-            // can be hit whenever a new instance of the record is created (either via a primary constructor or vie a copy constructor).
+            // can be hit whenever a new instance of the record is created (either via a primary constructor or via a copy constructor).
             // 
             // If the record doesn't have base initializer the span overlaps the span of the sequence point generated for primary
             // constructor implicit base initializer:

From 5131fe187b653346f898becf815ecf836da707e2 Mon Sep 17 00:00:00 2001
From: tmat <tomas.matousek@microsoft.com>
Date: Tue, 18 Jul 2023 14:13:11 -0700
Subject: [PATCH 6/7] Feedback

---
 .../Instrumentation/DebugInfoInjector.cs      |  52 +-
 .../CSharp/Test/Emit/PDB/PDBTests.cs          | 475 +++---------------
 2 files changed, 104 insertions(+), 423 deletions(-)

diff --git a/src/Compilers/CSharp/Portable/Lowering/Instrumentation/DebugInfoInjector.cs b/src/Compilers/CSharp/Portable/Lowering/Instrumentation/DebugInfoInjector.cs
index eca22779e4dbf..5f12229415f08 100644
--- a/src/Compilers/CSharp/Portable/Lowering/Instrumentation/DebugInfoInjector.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/Instrumentation/DebugInfoInjector.cs
@@ -62,12 +62,32 @@ public override BoundStatement InstrumentExpressionStatement(BoundExpressionStat
                 {
                     case ConstructorDeclarationSyntax ctorDecl:
                         // Implicit constructor initializer:
-                        return new BoundSequencePointWithSpan(ctorDecl, rewritten, createSpanForConstructorInitializer(ctorDecl));
+                        Debug.Assert(ctorDecl.Initializer == null);
+
+                        TextSpan span;
+                        if (ctorDecl.Modifiers.Any(SyntaxKind.StaticKeyword))
+                        {
+                            Debug.Assert(ctorDecl.Body != null);
+
+                            // [SomeAttribute] static MyCtorName(...) [|{|] ... }
+                            var start = ctorDecl.Body.OpenBraceToken.SpanStart;
+                            var end = ctorDecl.Body.OpenBraceToken.Span.End;
+                            span = TextSpan.FromBounds(start, end);
+                        }
+                        else
+                        {
+                            //  [SomeAttribute] [|public MyCtorName(params int[] values)|] { ... }
+                            span = CreateSpan(ctorDecl.Modifiers, ctorDecl.Identifier, ctorDecl.ParameterList.CloseParenToken);
+                        }
+
+                        return new BoundSequencePointWithSpan(ctorDecl, rewritten, span);
 
                     case ConstructorInitializerSyntax ctorInit:
                         // Explicit constructor initializer:
-                        Debug.Assert(ctorInit.Parent is ConstructorDeclarationSyntax);
-                        return new BoundSequencePointWithSpan(ctorInit, rewritten, createSpanForConstructorInitializer((ConstructorDeclarationSyntax)ctorInit.Parent));
+
+                        //  [SomeAttribute] public MyCtorName(params int[] values): [|base()|] { ... }
+                        return new BoundSequencePointWithSpan(ctorInit, rewritten,
+                            TextSpan.FromBounds(ctorInit.ThisOrBaseKeyword.SpanStart, ctorInit.ArgumentList.CloseParenToken.Span.End));
 
                     case TypeDeclarationSyntax typeDecl:
                         // Primary constructor with implicit base initializer:
@@ -93,30 +113,6 @@ public override BoundStatement InstrumentExpressionStatement(BoundExpressionStat
             }
 
             return AddSequencePoint(rewritten);
-
-            static TextSpan createSpanForConstructorInitializer(ConstructorDeclarationSyntax constructorSyntax)
-            {
-                if (constructorSyntax.Initializer != null)
-                {
-                    //  [SomeAttribute] public MyCtorName(params int[] values): [|base()|] { ... }
-                    var start = constructorSyntax.Initializer.ThisOrBaseKeyword.SpanStart;
-                    var end = constructorSyntax.Initializer.ArgumentList.CloseParenToken.Span.End;
-                    return TextSpan.FromBounds(start, end);
-                }
-
-                if (constructorSyntax.Modifiers.Any(SyntaxKind.StaticKeyword))
-                {
-                    Debug.Assert(constructorSyntax.Body != null);
-
-                    // [SomeAttribute] static MyCtorName(...) [|{|] ... }
-                    var start = constructorSyntax.Body.OpenBraceToken.SpanStart;
-                    var end = constructorSyntax.Body.OpenBraceToken.Span.End;
-                    return TextSpan.FromBounds(start, end);
-                }
-
-                //  [SomeAttribute] [|public MyCtorName(params int[] values)|] { ... }
-                return CreateSpan(constructorSyntax.Modifiers, constructorSyntax.Identifier, constructorSyntax.ParameterList.CloseParenToken);
-            }
         }
 
         public override BoundStatement InstrumentFieldOrPropertyInitializer(BoundStatement original, BoundStatement rewritten)
@@ -415,6 +411,8 @@ public override BoundStatement InstrumentReturnStatement(BoundReturnStatement or
 
             if (original.Syntax is ParameterSyntax parameterSyntax)
             {
+                Debug.Assert(parameterSyntax is { Parent.Parent: RecordDeclarationSyntax });
+
                 // Record property getter sequence point
                 return new BoundSequencePointWithSpan(parameterSyntax, rewritten, CreateSpan(parameterSyntax));
             }
diff --git a/src/Compilers/CSharp/Test/Emit/PDB/PDBTests.cs b/src/Compilers/CSharp/Test/Emit/PDB/PDBTests.cs
index 85bdea0b25fae..40709f0d06d4b 100644
--- a/src/Compilers/CSharp/Test/Emit/PDB/PDBTests.cs
+++ b/src/Compilers/CSharp/Test/Emit/PDB/PDBTests.cs
@@ -28,6 +28,12 @@ namespace Microsoft.CodeAnalysis.CSharp.UnitTests.PDB
 {
     public class PDBTests : CSharpPDBTestBase
     {
+        public const PdbValidationOptions SyntaxOffsetPdbValidationOptions =
+            PdbValidationOptions.ExcludeDocuments |
+            PdbValidationOptions.ExcludeSequencePoints |
+            PdbValidationOptions.ExcludeScopes |
+            PdbValidationOptions.ExcludeNamespaces;
+
         private static readonly MetadataReference[] s_valueTupleRefs = new[] { SystemRuntimeFacadeRef, ValueTupleRef };
 
         #region General
@@ -8530,10 +8536,8 @@ public void SyntaxOffset_IsPattern()
             var source = @"class C { bool F(object o) => o is int i && o is 3 && o is bool; }";
             var c = CreateCompilationWithMscorlib40AndSystemCore(source, options: TestOptions.DebugDll);
 
-            c.VerifyPdb("C.F", @"<symbols>
-  <files>
-    <file id=""1"" name="""" language=""C#"" />
-  </files>
+            c.VerifyPdb("C.F", @"
+<symbols>
   <methods>
     <method containingType=""C"" name=""F"" parameterNames=""o"">
       <customDebugInfo>
@@ -8544,15 +8548,10 @@ public void SyntaxOffset_IsPattern()
           <slot kind=""0"" offset=""12"" />
         </encLocalSlotMap>
       </customDebugInfo>
-      <sequencePoints>
-        <entry offset=""0x0"" startLine=""1"" startColumn=""31"" endLine=""1"" endColumn=""64"" document=""1"" />
-      </sequencePoints>
-      <scope startOffset=""0x0"" endOffset=""0x2d"">
-        <local name=""i"" il_index=""0"" il_start=""0x0"" il_end=""0x2d"" attributes=""0"" />
-      </scope>
     </method>
   </methods>
-</symbols>");
+</symbols>
+", options: SyntaxOffsetPdbValidationOptions);
         }
 
         [WorkItem(37172, "https://github.com/dotnet/roslyn/issues/37172")]
@@ -10759,47 +10758,26 @@ public void SyntaxOffset_OutVarInInitializers_SwitchExpression()
             var c = CreateCompilationWithMscorlib40AndSystemCore(source, options: TestOptions.DebugDll);
 
             c.VerifyPdb("C..ctor", @"
-    <symbols>
-      <files>
-        <file id=""1"" name="""" language=""C#"" />
-      </files>
-      <methods>
-        <method containingType=""C"" name="".ctor"">
-          <customDebugInfo>
-            <forward declaringType=""C"" methodName=""G"" parameterNames=""x"" />
-            <encLocalSlotMap>
-              <slot kind=""30"" offset=""-26"" />
-              <slot kind=""temp"" />
-              <slot kind=""35"" offset=""-26"" />
-            </encLocalSlotMap>
-            <encLambdaMap>
-              <methodOrdinal>2</methodOrdinal>
-              <closure offset=""-26"" />
-              <lambda offset=""-4"" closure=""0"" />
-            </encLambdaMap>
-          </customDebugInfo>
-          <sequencePoints>
-            <entry offset=""0x0"" hidden=""true"" document=""1"" />
-            <entry offset=""0x6"" startLine=""7"" startColumn=""5"" endLine=""7"" endColumn=""54"" document=""1"" />
-            <entry offset=""0x15"" startLine=""7"" startColumn=""27"" endLine=""7"" endColumn=""53"" document=""1"" />
-            <entry offset=""0x16"" hidden=""true"" document=""1"" />
-            <entry offset=""0x18"" startLine=""7"" startColumn=""41"" endLine=""7"" endColumn=""51"" document=""1"" />
-            <entry offset=""0x2c"" hidden=""true"" document=""1"" />
-            <entry offset=""0x2f"" startLine=""7"" startColumn=""5"" endLine=""7"" endColumn=""54"" document=""1"" />
-            <entry offset=""0x30"" hidden=""true"" document=""1"" />
-            <entry offset=""0x37"" startLine=""5"" startColumn=""5"" endLine=""5"" endColumn=""8"" document=""1"" />
-            <entry offset=""0x3e"" startLine=""5"" startColumn=""9"" endLine=""5"" endColumn=""10"" document=""1"" />
-            <entry offset=""0x3f"" startLine=""5"" startColumn=""11"" endLine=""5"" endColumn=""12"" document=""1"" />
-          </sequencePoints>
-          <scope startOffset=""0x0"" endOffset=""0x40"">
-            <scope startOffset=""0x0"" endOffset=""0x37"">
-              <local name=""CS$&lt;&gt;8__locals0"" il_index=""0"" il_start=""0x0"" il_end=""0x37"" attributes=""0"" />
-            </scope>
-          </scope>
-        </method>
-      </methods>
-    </symbols>
-");
+<symbols>
+  <methods>
+    <method containingType=""C"" name="".ctor"">
+      <customDebugInfo>
+        <forward declaringType=""C"" methodName=""G"" parameterNames=""x"" />
+        <encLocalSlotMap>
+          <slot kind=""30"" offset=""-26"" />
+          <slot kind=""temp"" />
+          <slot kind=""35"" offset=""-26"" />
+        </encLocalSlotMap>
+        <encLambdaMap>
+          <methodOrdinal>2</methodOrdinal>
+          <closure offset=""-26"" />
+          <lambda offset=""-4"" closure=""0"" />
+        </encLambdaMap>
+      </customDebugInfo>
+    </method>
+  </methods>
+</symbols>
+", options: SyntaxOffsetPdbValidationOptions);
         }
 
         [WorkItem(43468, "https://github.com/dotnet/roslyn/issues/43468")]
@@ -11188,10 +11166,8 @@ public void SyntaxOffset_TupleDeconstruction()
             var source = @"class C { int F() { (int a, (_, int c)) = (1, (2, 3)); return a + c; } }";
             var c = CreateCompilationWithMscorlib40AndSystemCore(source, options: TestOptions.DebugDll, references: s_valueTupleRefs);
 
-            c.VerifyPdb("C.F", @"<symbols>
-  <files>
-    <file id=""1"" name="""" language=""C#"" />
-  </files>
+            c.VerifyPdb("C.F", @"
+<symbols>
   <methods>
     <method containingType=""C"" name=""F"">
       <customDebugInfo>
@@ -11204,19 +11180,9 @@ public void SyntaxOffset_TupleDeconstruction()
           <slot kind=""21"" offset=""0"" />
         </encLocalSlotMap>
       </customDebugInfo>
-      <sequencePoints>
-        <entry offset=""0x0"" startLine=""1"" startColumn=""19"" endLine=""1"" endColumn=""20"" document=""1"" />
-        <entry offset=""0x1"" startLine=""1"" startColumn=""21"" endLine=""1"" endColumn=""55"" document=""1"" />
-        <entry offset=""0x5"" startLine=""1"" startColumn=""56"" endLine=""1"" endColumn=""69"" document=""1"" />
-        <entry offset=""0xb"" startLine=""1"" startColumn=""70"" endLine=""1"" endColumn=""71"" document=""1"" />
-      </sequencePoints>
-      <scope startOffset=""0x0"" endOffset=""0xd"">
-        <local name=""a"" il_index=""0"" il_start=""0x0"" il_end=""0xd"" attributes=""0"" />
-        <local name=""c"" il_index=""1"" il_start=""0x0"" il_end=""0xd"" attributes=""0"" />
-      </scope>
     </method>
   </methods>
-</symbols>");
+</symbols>", options: SyntaxOffsetPdbValidationOptions);
         }
 
         [Fact]
@@ -11271,10 +11237,8 @@ public void SyntaxOffset_TupleParenthesized()
             var source = @"class C { int F() { (int, (int, int)) x = (1, (2, 3)); return x.Item1 + x.Item2.Item1 + x.Item2.Item2; } }";
             var c = CreateCompilationWithMscorlib40AndSystemCore(source, options: TestOptions.DebugDll, references: s_valueTupleRefs);
 
-            c.VerifyPdb("C.F", @"<symbols>
-  <files>
-    <file id=""1"" name="""" language=""C#"" />
-  </files>
+            c.VerifyPdb("C.F", @"
+<symbols>
   <methods>
     <method containingType=""C"" name=""F"">
       <customDebugInfo>
@@ -11286,19 +11250,9 @@ public void SyntaxOffset_TupleParenthesized()
           <slot kind=""21"" offset=""0"" />
         </encLocalSlotMap>
       </customDebugInfo>
-      <sequencePoints>
-        <entry offset=""0x0"" startLine=""1"" startColumn=""19"" endLine=""1"" endColumn=""20"" document=""1"" />
-        <entry offset=""0x1"" startLine=""1"" startColumn=""21"" endLine=""1"" endColumn=""55"" document=""1"" />
-        <entry offset=""0x10"" startLine=""1"" startColumn=""56"" endLine=""1"" endColumn=""103"" document=""1"" />
-        <entry offset=""0x31"" startLine=""1"" startColumn=""104"" endLine=""1"" endColumn=""105"" document=""1"" />
-      </sequencePoints>
-      <scope startOffset=""0x0"" endOffset=""0x33"">
-        <local name=""x"" il_index=""0"" il_start=""0x0"" il_end=""0x33"" attributes=""0"" />
-      </scope>
     </method>
   </methods>
-</symbols>"
-);
+</symbols>", options: SyntaxOffsetPdbValidationOptions);
         }
 
         [Fact]
@@ -11307,10 +11261,8 @@ public void SyntaxOffset_TupleVarDefined()
             var source = @"class C { int F() { var x = (1, 2); return x.Item1 + x.Item2; } }";
             var c = CreateCompilationWithMscorlib40AndSystemCore(source, options: TestOptions.DebugDll, references: s_valueTupleRefs);
 
-            c.VerifyPdb("C.F", @"<symbols>
-  <files>
-    <file id=""1"" name="""" language=""C#"" />
-  </files>
+            c.VerifyPdb("C.F", @"
+<symbols>
   <methods>
     <method containingType=""C"" name=""F"">
       <customDebugInfo>
@@ -11322,18 +11274,9 @@ public void SyntaxOffset_TupleVarDefined()
           <slot kind=""21"" offset=""0"" />
         </encLocalSlotMap>
       </customDebugInfo>
-      <sequencePoints>
-        <entry offset=""0x0"" startLine=""1"" startColumn=""19"" endLine=""1"" endColumn=""20"" document=""1"" />
-        <entry offset=""0x1"" startLine=""1"" startColumn=""21"" endLine=""1"" endColumn=""36"" document=""1"" />
-        <entry offset=""0xa"" startLine=""1"" startColumn=""37"" endLine=""1"" endColumn=""62"" document=""1"" />
-        <entry offset=""0x1a"" startLine=""1"" startColumn=""63"" endLine=""1"" endColumn=""64"" document=""1"" />
-      </sequencePoints>
-      <scope startOffset=""0x0"" endOffset=""0x1c"">
-        <local name=""x"" il_index=""0"" il_start=""0x0"" il_end=""0x1c"" attributes=""0"" />
-      </scope>
     </method>
   </methods>
-</symbols>");
+</symbols>", options: SyntaxOffsetPdbValidationOptions);
         }
 
         [Fact]
@@ -11342,10 +11285,8 @@ public void SyntaxOffset_TupleIgnoreDeconstructionIfVariableDeclared()
             var source = @"class C { int F() { (int x, int y) a = (1, 2); return a.Item1 + a.Item2; } }";
             var c = CreateCompilationWithMscorlib40AndSystemCore(source, options: TestOptions.DebugDll, references: s_valueTupleRefs);
 
-            c.VerifyPdb("C.F", @"<symbols>
-  <files>
-    <file id=""1"" name="""" language=""C#"" />
-  </files>
+            c.VerifyPdb("C.F", @"
+<symbols>
   <methods>
     <method containingType=""C"" name=""F"">
       <customDebugInfo>
@@ -11360,18 +11301,9 @@ public void SyntaxOffset_TupleIgnoreDeconstructionIfVariableDeclared()
           <slot kind=""21"" offset=""0"" />
         </encLocalSlotMap>
       </customDebugInfo>
-      <sequencePoints>
-        <entry offset=""0x0"" startLine=""1"" startColumn=""19"" endLine=""1"" endColumn=""20"" document=""1"" />
-        <entry offset=""0x1"" startLine=""1"" startColumn=""21"" endLine=""1"" endColumn=""47"" document=""1"" />
-        <entry offset=""0x9"" startLine=""1"" startColumn=""48"" endLine=""1"" endColumn=""73"" document=""1"" />
-        <entry offset=""0x19"" startLine=""1"" startColumn=""74"" endLine=""1"" endColumn=""75"" document=""1"" />
-      </sequencePoints>
-      <scope startOffset=""0x0"" endOffset=""0x1b"">
-        <local name=""a"" il_index=""0"" il_start=""0x0"" il_end=""0x1b"" attributes=""0"" />
-      </scope>
     </method>
   </methods>
-</symbols>");
+</symbols>", options: SyntaxOffsetPdbValidationOptions);
         }
 
         #endregion
@@ -11424,9 +11356,6 @@ public void SyntaxOffset_OutVarInMethod()
             var c = CreateCompilationWithMscorlib40AndSystemCore(source, options: TestOptions.DebugDll);
             c.VerifyPdb("C.G", @"
 <symbols>
-  <files>
-    <file id=""1"" name="""" language=""C#"" />
-  </files>
   <methods>
     <method containingType=""C"" name=""G"" parameterNames=""x"">
       <customDebugInfo>
@@ -11441,23 +11370,10 @@ public void SyntaxOffset_OutVarInMethod()
           <slot kind=""21"" offset=""0"" />
         </encLocalSlotMap>
       </customDebugInfo>
-      <sequencePoints>
-        <entry offset=""0x0"" startLine=""1"" startColumn=""28"" endLine=""1"" endColumn=""29"" document=""1"" />
-        <entry offset=""0x1"" startLine=""1"" startColumn=""30"" endLine=""1"" endColumn=""40"" document=""1"" />
-        <entry offset=""0x3"" startLine=""1"" startColumn=""41"" endLine=""1"" endColumn=""54"" document=""1"" />
-        <entry offset=""0xc"" startLine=""1"" startColumn=""55"" endLine=""1"" endColumn=""68"" document=""1"" />
-        <entry offset=""0x15"" startLine=""1"" startColumn=""69"" endLine=""1"" endColumn=""82"" document=""1"" />
-        <entry offset=""0x1f"" startLine=""1"" startColumn=""83"" endLine=""1"" endColumn=""84"" document=""1"" />
-      </sequencePoints>
-      <scope startOffset=""0x0"" endOffset=""0x22"">
-        <local name=""z"" il_index=""0"" il_start=""0x0"" il_end=""0x22"" attributes=""0"" />
-        <local name=""y"" il_index=""1"" il_start=""0x0"" il_end=""0x22"" attributes=""0"" />
-        <local name=""w"" il_index=""2"" il_start=""0x0"" il_end=""0x22"" attributes=""0"" />
-      </scope>
     </method>
   </methods>
 </symbols>
-");
+", options: SyntaxOffsetPdbValidationOptions);
         }
 
         [Fact]
@@ -11489,9 +11405,6 @@ public A(int x) {}
             var c = CreateCompilationWithMscorlib40AndSystemCore(source, options: TestOptions.DebugDll);
             c.VerifyPdb("C..ctor", @"
 <symbols>
-  <files>
-    <file id=""1"" name="""" language=""C#"" />
-  </files>
   <methods>
     <method containingType=""C"" name="".ctor"">
       <customDebugInfo>
@@ -11504,28 +11417,10 @@ public A(int x) {}
           <slot kind=""0"" offset=""-3"" />
         </encLocalSlotMap>
       </customDebugInfo>
-      <sequencePoints>
-        <entry offset=""0x0"" startLine=""4"" startColumn=""5"" endLine=""4"" endColumn=""26"" document=""1"" />
-        <entry offset=""0xd"" startLine=""5"" startColumn=""20"" endLine=""5"" endColumn=""32"" document=""1"" />
-        <entry offset=""0x1a"" startLine=""7"" startColumn=""11"" endLine=""7"" endColumn=""29"" document=""1"" />
-        <entry offset=""0x28"" startLine=""8"" startColumn=""5"" endLine=""8"" endColumn=""6"" document=""1"" />
-        <entry offset=""0x29"" startLine=""9"" startColumn=""5"" endLine=""9"" endColumn=""6"" document=""1"" />
-      </sequencePoints>
-      <scope startOffset=""0x0"" endOffset=""0x2a"">
-        <scope startOffset=""0x0"" endOffset=""0xd"">
-          <local name=""x"" il_index=""0"" il_start=""0x0"" il_end=""0xd"" attributes=""0"" />
-        </scope>
-        <scope startOffset=""0xd"" endOffset=""0x1a"">
-          <local name=""y"" il_index=""1"" il_start=""0xd"" il_end=""0x1a"" attributes=""0"" />
-        </scope>
-        <scope startOffset=""0x1a"" endOffset=""0x2a"">
-          <local name=""z"" il_index=""2"" il_start=""0x1a"" il_end=""0x2a"" attributes=""0"" />
-        </scope>
-      </scope>
     </method>
   </methods>
 </symbols>
-");
+", options: SyntaxOffsetPdbValidationOptions);
         }
 
         [Fact]
@@ -11556,9 +11451,6 @@ public A(int x) {}
             var c = CreateCompilationWithMscorlib40AndSystemCore(source, options: TestOptions.DebugDll);
             c.VerifyPdb("C..ctor", @"
 <symbols>
-  <files>
-    <file id=""1"" name="""" language=""C#"" />
-  </files>
   <methods>
     <method containingType=""C"" name="".ctor"">
       <customDebugInfo>
@@ -11570,23 +11462,10 @@ public A(int x) {}
           <slot kind=""0"" offset=""16"" />
         </encLocalSlotMap>
       </customDebugInfo>
-      <sequencePoints>
-        <entry offset=""0x0"" startLine=""4"" startColumn=""11"" endLine=""4"" endColumn=""29"" document=""1"" />
-        <entry offset=""0xe"" startLine=""5"" startColumn=""5"" endLine=""5"" endColumn=""6"" document=""1"" />
-        <entry offset=""0xf"" startLine=""6"" startColumn=""9"" endLine=""6"" endColumn=""19"" document=""1"" />
-        <entry offset=""0x11"" startLine=""7"" startColumn=""9"" endLine=""7"" endColumn=""13"" document=""1"" />
-        <entry offset=""0x15"" startLine=""8"" startColumn=""5"" endLine=""8"" endColumn=""6"" document=""1"" />
-      </sequencePoints>
-      <scope startOffset=""0x0"" endOffset=""0x16"">
-        <local name=""x"" il_index=""0"" il_start=""0x0"" il_end=""0x16"" attributes=""0"" />
-        <scope startOffset=""0xe"" endOffset=""0x16"">
-          <local name=""y"" il_index=""1"" il_start=""0xe"" il_end=""0x16"" attributes=""0"" />
-        </scope>
-      </scope>
     </method>
   </methods>
 </symbols>
-");
+", options: SyntaxOffsetPdbValidationOptions);
         }
 
         [Fact]
@@ -11614,9 +11493,6 @@ public A(int x) {}
             var c = CreateCompilationWithMscorlib40AndSystemCore(source, options: TestOptions.DebugDll);
             c.VerifyPdb("C..ctor", @"
 <symbols>
-  <files>
-    <file id=""1"" name="""" language=""C#"" />
-  </files>
   <methods>
     <method containingType=""C"" name="".ctor"">
       <customDebugInfo>
@@ -11628,20 +11504,10 @@ public A(int x) {}
           <slot kind=""0"" offset=""13"" />
         </encLocalSlotMap>
       </customDebugInfo>
-      <sequencePoints>
-        <entry offset=""0x0"" startLine=""4"" startColumn=""11"" endLine=""4"" endColumn=""29"" document=""1"" />
-        <entry offset=""0xe"" startLine=""5"" startColumn=""8"" endLine=""5"" endColumn=""20"" document=""1"" />
-      </sequencePoints>
-      <scope startOffset=""0x0"" endOffset=""0x17"">
-        <local name=""x"" il_index=""0"" il_start=""0x0"" il_end=""0x17"" attributes=""0"" />
-        <scope startOffset=""0xe"" endOffset=""0x17"">
-          <local name=""y"" il_index=""1"" il_start=""0xe"" il_end=""0x17"" attributes=""0"" />
-        </scope>
-      </scope>
     </method>
   </methods>
 </symbols>
-");
+", options: SyntaxOffsetPdbValidationOptions);
         }
 
         [Fact]
@@ -11673,9 +11539,6 @@ static int F(System.Func<int> x)
 
             c.VerifyPdb("C..ctor", @"
 <symbols>
-  <files>
-    <file id=""1"" name="""" language=""C#"" />
-  </files>
   <methods>
     <method containingType=""C"" name="".ctor"">
       <customDebugInfo>
@@ -11689,40 +11552,22 @@ static int F(System.Func<int> x)
           <lambda offset=""-2"" closure=""0"" />
         </encLambdaMap>
       </customDebugInfo>
-      <sequencePoints>
-        <entry offset=""0x0"" hidden=""true"" document=""1"" />
-        <entry offset=""0x6"" startLine=""2000"" startColumn=""5"" endLine=""2000"" endColumn=""40"" document=""1"" />
-        <entry offset=""0x29"" startLine=""13"" startColumn=""5"" endLine=""13"" endColumn=""8"" document=""1"" />
-        <entry offset=""0x30"" startLine=""14"" startColumn=""5"" endLine=""14"" endColumn=""6"" document=""1"" />
-        <entry offset=""0x31"" startLine=""15"" startColumn=""5"" endLine=""15"" endColumn=""6"" document=""1"" />
-      </sequencePoints>
-      <scope startOffset=""0x0"" endOffset=""0x32"">
-        <scope startOffset=""0x0"" endOffset=""0x29"">
-          <local name=""CS$&lt;&gt;8__locals0"" il_index=""0"" il_start=""0x0"" il_end=""0x29"" attributes=""0"" />
-        </scope>
-      </scope>
     </method>
   </methods>
 </symbols>
-");
+", options: SyntaxOffsetPdbValidationOptions);
 
             c.VerifyPdb("C+<>c__DisplayClass2_0.<.ctor>b__0", @"
 <symbols>
-  <files>
-    <file id=""1"" name="""" language=""C#"" />
-  </files>
   <methods>
     <method containingType=""C+&lt;&gt;c__DisplayClass2_0"" name=""&lt;.ctor&gt;b__0"">
       <customDebugInfo>
         <forward declaringType=""C"" methodName=""G"" parameterNames=""x"" />
       </customDebugInfo>
-      <sequencePoints>
-        <entry offset=""0x0"" startLine=""2000"" startColumn=""37"" endLine=""2000"" endColumn=""38"" document=""1"" />
-      </sequencePoints>
     </method>
   </methods>
 </symbols>
-");
+", options: SyntaxOffsetPdbValidationOptions);
         }
 
         [Fact]
@@ -11750,9 +11595,6 @@ static int F(System.Func<int> x)
 
             c.VerifyPdb("C..ctor", @"
 <symbols>
-  <files>
-    <file id=""1"" name="""" language=""C#"" />
-  </files>
   <methods>
     <method containingType=""C"" name="".ctor"">
       <customDebugInfo>
@@ -11766,37 +11608,22 @@ static int F(System.Func<int> x)
           <lambda offset=""-2"" closure=""0"" />
         </encLambdaMap>
       </customDebugInfo>
-      <sequencePoints>
-        <entry offset=""0x0"" hidden=""true"" document=""1"" />
-        <entry offset=""0x6"" startLine=""2000"" startColumn=""23"" endLine=""2000"" endColumn=""48"" document=""1"" />
-      </sequencePoints>
-      <scope startOffset=""0x0"" endOffset=""0x31"">
-        <scope startOffset=""0x0"" endOffset=""0x29"">
-          <local name=""CS$&lt;&gt;8__locals0"" il_index=""0"" il_start=""0x0"" il_end=""0x29"" attributes=""0"" />
-        </scope>
-      </scope>
     </method>
   </methods>
 </symbols>
-");
+", options: SyntaxOffsetPdbValidationOptions);
 
             c.VerifyPdb("C+<>c__DisplayClass5_0.<.ctor>b__0", @"
 <symbols>
-  <files>
-    <file id=""1"" name="""" language=""C#"" />
-  </files>
   <methods>
     <method containingType=""C+&lt;&gt;c__DisplayClass5_0"" name=""&lt;.ctor&gt;b__0"">
       <customDebugInfo>
         <forward declaringType=""C"" methodName=""G"" parameterNames=""x"" />
       </customDebugInfo>
-      <sequencePoints>
-        <entry offset=""0x0"" startLine=""2000"" startColumn=""46"" endLine=""2000"" endColumn=""47"" document=""1"" />
-      </sequencePoints>
     </method>
   </methods>
 </symbols>
-");
+", options: SyntaxOffsetPdbValidationOptions);
         }
 
         [Fact]
@@ -11862,9 +11689,6 @@ .locals init (C.<>c__DisplayClass4_0 V_0, //CS$<>8__locals0
 
             c.VerifyPdb("C..ctor", @"
 <symbols>
-  <files>
-    <file id=""1"" name="""" language=""C#"" />
-  </files>
   <methods>
     <method containingType=""C"" name="".ctor"">
       <customDebugInfo>
@@ -11881,60 +11705,34 @@ .locals init (C.<>c__DisplayClass4_0 V_0, //CS$<>8__locals0
           <lambda offset=""-2"" closure=""1"" />
         </encLambdaMap>
       </customDebugInfo>
-      <sequencePoints>
-        <entry offset=""0x0"" hidden=""true"" document=""1"" />
-        <entry offset=""0x6"" startLine=""2000"" startColumn=""5"" endLine=""2000"" endColumn=""39"" document=""1"" />
-        <entry offset=""0x29"" hidden=""true"" document=""1"" />
-        <entry offset=""0x2f"" startLine=""2000"" startColumn=""41"" endLine=""2000"" endColumn=""71"" document=""1"" />
-      </sequencePoints>
-      <scope startOffset=""0x0"" endOffset=""0x5a"">
-        <scope startOffset=""0x0"" endOffset=""0x29"">
-          <local name=""CS$&lt;&gt;8__locals0"" il_index=""0"" il_start=""0x0"" il_end=""0x29"" attributes=""0"" />
-        </scope>
-        <scope startOffset=""0x29"" endOffset=""0x52"">
-          <local name=""CS$&lt;&gt;8__locals1"" il_index=""1"" il_start=""0x29"" il_end=""0x52"" attributes=""0"" />
-        </scope>
-      </scope>
     </method>
   </methods>
 </symbols>
-");
+", options: SyntaxOffsetPdbValidationOptions);
 
             c.VerifyPdb("C+<>c__DisplayClass4_0.<.ctor>b__0", @"
 <symbols>
-  <files>
-    <file id=""1"" name="""" language=""C#"" />
-  </files>
   <methods>
     <method containingType=""C+&lt;&gt;c__DisplayClass4_0"" name=""&lt;.ctor&gt;b__0"">
       <customDebugInfo>
         <forward declaringType=""C"" methodName=""G"" parameterNames=""x"" />
       </customDebugInfo>
-      <sequencePoints>
-        <entry offset=""0x0"" startLine=""2000"" startColumn=""37"" endLine=""2000"" endColumn=""38"" document=""1"" />
-      </sequencePoints>
     </method>
   </methods>
 </symbols>
-");
+", options: SyntaxOffsetPdbValidationOptions);
 
             c.VerifyPdb("C+<>c__DisplayClass4_1.<.ctor>b__1", @"
 <symbols>
-  <files>
-    <file id=""1"" name="""" language=""C#"" />
-  </files>
   <methods>
     <method containingType=""C+&lt;&gt;c__DisplayClass4_1"" name=""&lt;.ctor&gt;b__1"">
       <customDebugInfo>
         <forward declaringType=""C"" methodName=""G"" parameterNames=""x"" />
       </customDebugInfo>
-      <sequencePoints>
-        <entry offset=""0x0"" startLine=""2000"" startColumn=""69"" endLine=""2000"" endColumn=""70"" document=""1"" />
-      </sequencePoints>
     </method>
   </methods>
 </symbols>
-");
+", options: SyntaxOffsetPdbValidationOptions);
         }
 
         [Fact]
@@ -11968,9 +11766,6 @@ public A(int x) {}
             var c = CreateCompilationWithMscorlib40AndSystemCore(source, options: TestOptions.DebugDll);
             c.VerifyPdb("C..ctor", @"
 <symbols>
-  <files>
-    <file id=""1"" name="""" language=""C#"" />
-  </files>
   <methods>
     <method containingType=""C"" name="".ctor"">
       <customDebugInfo>
@@ -11986,37 +11781,22 @@ public A(int x) {}
           <lambda offset=""-3"" closure=""0"" />
         </encLambdaMap>
       </customDebugInfo>
-      <sequencePoints>
-        <entry offset=""0x0"" hidden=""true"" document=""1"" />
-        <entry offset=""0x6"" startLine=""2000"" startColumn=""11"" endLine=""2000"" endColumn=""41"" document=""1"" />
-        <entry offset=""0x2a"" startLine=""2001"" startColumn=""5"" endLine=""2001"" endColumn=""6"" document=""1"" />
-        <entry offset=""0x2b"" startLine=""2002"" startColumn=""5"" endLine=""2002"" endColumn=""6"" document=""1"" />
-      </sequencePoints>
-      <scope startOffset=""0x0"" endOffset=""0x2c"">
-        <local name=""CS$&lt;&gt;8__locals0"" il_index=""0"" il_start=""0x0"" il_end=""0x2c"" attributes=""0"" />
-      </scope>
     </method>
   </methods>
 </symbols>
-");
+", options: SyntaxOffsetPdbValidationOptions);
 
             c.VerifyPdb("C+<>c__DisplayClass0_0.<.ctor>b__0", @"
 <symbols>
-  <files>
-    <file id=""1"" name="""" language=""C#"" />
-  </files>
   <methods>
     <method containingType=""C+&lt;&gt;c__DisplayClass0_0"" name=""&lt;.ctor&gt;b__0"">
       <customDebugInfo>
         <forward declaringType=""C"" methodName="".ctor"" />
       </customDebugInfo>
-      <sequencePoints>
-        <entry offset=""0x0"" startLine=""2000"" startColumn=""38"" endLine=""2000"" endColumn=""39"" document=""1"" />
-      </sequencePoints>
     </method>
   </methods>
 </symbols>
-");
+", options: SyntaxOffsetPdbValidationOptions);
         }
 
         [Fact]
@@ -12046,9 +11826,6 @@ static int G(out int x)
             var c = CreateCompilationWithMscorlib40AndSystemCore(source, options: TestOptions.DebugDll);
             c.VerifyPdb("C..ctor", @"
 <symbols>
-  <files>
-    <file id=""1"" name="""" language=""C#"" />
-  </files>
   <methods>
     <method containingType=""C"" name="".ctor"">
       <customDebugInfo>
@@ -12063,28 +11840,13 @@ static int G(out int x)
           <lambda offset=""88"" />
         </encLambdaMap>
       </customDebugInfo>
-      <sequencePoints>
-        <entry offset=""0x0"" startLine=""6"" startColumn=""5"" endLine=""6"" endColumn=""8"" document=""1"" />
-        <entry offset=""0x7"" startLine=""7"" startColumn=""5"" endLine=""7"" endColumn=""6"" document=""1"" />
-        <entry offset=""0x8"" startLine=""8"" startColumn=""9"" endLine=""11"" endColumn=""26"" document=""1"" />
-        <entry offset=""0x37"" startLine=""12"" startColumn=""5"" endLine=""12"" endColumn=""6"" document=""1"" />
-      </sequencePoints>
-      <scope startOffset=""0x0"" endOffset=""0x38"">
-        <namespace name=""System.Linq"" />
-        <scope startOffset=""0x7"" endOffset=""0x38"">
-          <local name=""q"" il_index=""0"" il_start=""0x7"" il_end=""0x38"" attributes=""0"" />
-        </scope>
-      </scope>
     </method>
   </methods>
 </symbols>
-");
+", options: SyntaxOffsetPdbValidationOptions);
 
             c.VerifyPdb("C+<>c.<.ctor>b__0_0", @"
 <symbols>
-  <files>
-    <file id=""1"" name="""" language=""C#"" />
-  </files>
   <methods>
     <method containingType=""C+&lt;&gt;c"" name=""&lt;.ctor&gt;b__0_0"" parameterNames=""a"">
       <customDebugInfo>
@@ -12093,16 +11855,10 @@ static int G(out int x)
           <slot kind=""0"" offset=""98"" />
         </encLocalSlotMap>
       </customDebugInfo>
-      <sequencePoints>
-        <entry offset=""0x0"" startLine=""10"" startColumn=""23"" endLine=""10"" endColumn=""40"" document=""1"" />
-      </sequencePoints>
-      <scope startOffset=""0x0"" endOffset=""0xb"">
-        <local name=""x1"" il_index=""0"" il_start=""0x0"" il_end=""0xb"" attributes=""0"" />
-      </scope>
     </method>
   </methods>
 </symbols>
-");
+", options: SyntaxOffsetPdbValidationOptions);
         }
 
         [Fact]
@@ -12137,9 +11893,6 @@ static int F(System.Func<int> x)
             var c = CreateCompilationWithMscorlib40AndSystemCore(source, options: TestOptions.DebugDll);
             c.VerifyPdb("C..ctor", @"
 <symbols>
-  <files>
-    <file id=""1"" name="""" language=""C#"" />
-  </files>
   <methods>
     <method containingType=""C"" name="".ctor"">
       <customDebugInfo>
@@ -12156,28 +11909,13 @@ static int F(System.Func<int> x)
           <lambda offset=""112"" closure=""0"" />
         </encLambdaMap>
       </customDebugInfo>
-      <sequencePoints>
-        <entry offset=""0x0"" startLine=""6"" startColumn=""5"" endLine=""6"" endColumn=""8"" document=""1"" />
-        <entry offset=""0x7"" startLine=""2000"" startColumn=""5"" endLine=""2000"" endColumn=""6"" document=""1"" />
-        <entry offset=""0x8"" startLine=""2001"" startColumn=""9"" endLine=""2004"" endColumn=""26"" document=""1"" />
-        <entry offset=""0x37"" startLine=""2005"" startColumn=""5"" endLine=""2005"" endColumn=""6"" document=""1"" />
-      </sequencePoints>
-      <scope startOffset=""0x0"" endOffset=""0x38"">
-        <namespace name=""System.Linq"" />
-        <scope startOffset=""0x7"" endOffset=""0x38"">
-          <local name=""q"" il_index=""0"" il_start=""0x7"" il_end=""0x38"" attributes=""0"" />
-        </scope>
-      </scope>
     </method>
   </methods>
 </symbols>
-");
+", options: SyntaxOffsetPdbValidationOptions);
 
             c.VerifyPdb("C+<>c.<.ctor>b__0_0", @"
 <symbols>
-  <files>
-    <file id=""1"" name="""" language=""C#"" />
-  </files>
   <methods>
     <method containingType=""C+&lt;&gt;c"" name=""&lt;.ctor&gt;b__0_0"" parameterNames=""a"">
       <customDebugInfo>
@@ -12186,35 +11924,22 @@ static int F(System.Func<int> x)
           <slot kind=""30"" offset=""88"" />
         </encLocalSlotMap>
       </customDebugInfo>
-      <sequencePoints>
-        <entry offset=""0x0"" hidden=""true"" document=""1"" />
-        <entry offset=""0x6"" startLine=""2003"" startColumn=""23"" endLine=""2003"" endColumn=""50"" document=""1"" />
-      </sequencePoints>
-      <scope startOffset=""0x0"" endOffset=""0x25"">
-        <local name=""CS$&lt;&gt;8__locals0"" il_index=""0"" il_start=""0x0"" il_end=""0x25"" attributes=""0"" />
-      </scope>
     </method>
   </methods>
 </symbols>
-");
+", options: SyntaxOffsetPdbValidationOptions);
 
             c.VerifyPdb("C+<>c__DisplayClass0_0.<.ctor>b__1", @"
 <symbols>
-  <files>
-    <file id=""1"" name="""" language=""C#"" />
-  </files>
   <methods>
     <method containingType=""C+&lt;&gt;c__DisplayClass0_0"" name=""&lt;.ctor&gt;b__1"">
       <customDebugInfo>
         <forward declaringType=""C"" methodName="".ctor"" />
       </customDebugInfo>
-      <sequencePoints>
-        <entry offset=""0x0"" startLine=""2003"" startColumn=""47"" endLine=""2003"" endColumn=""49"" document=""1"" />
-      </sequencePoints>
     </method>
   </methods>
 </symbols>
-");
+", options: SyntaxOffsetPdbValidationOptions);
         }
 
         [Fact]
@@ -12224,47 +11949,24 @@ public void SyntaxOffset_OutVarInSwitchExpression()
 
             var c = CreateCompilationWithMscorlib40AndSystemCore(source, options: TestOptions.DebugDll);
             c.VerifyPdb("C.G", @"
-    <symbols>
-      <files>
-        <file id=""1"" name="""" language=""C#"" />
-      </files>
-      <methods>
-        <method containingType=""C"" name=""G"">
-          <customDebugInfo>
-            <using>
-              <namespace usingCount=""0"" />
-            </using>
-            <encLocalSlotMap>
-              <slot kind=""0"" offset=""13"" />
-              <slot kind=""temp"" />
-              <slot kind=""35"" offset=""16"" />
-              <slot kind=""temp"" />
-            </encLocalSlotMap>
-          </customDebugInfo>
-          <sequencePoints>
-            <entry offset=""0x0"" startLine=""1"" startColumn=""32"" endLine=""1"" endColumn=""99"" document=""1"" />
-            <entry offset=""0xb"" startLine=""1"" startColumn=""45"" endLine=""1"" endColumn=""99"" document=""1"" />
-            <entry offset=""0xc"" hidden=""true"" document=""1"" />
-            <entry offset=""0x11"" hidden=""true"" document=""1"" />
-            <entry offset=""0x14"" startLine=""1"" startColumn=""64"" endLine=""1"" endColumn=""89"" document=""1"" />
-            <entry offset=""0x15"" hidden=""true"" document=""1"" />
-            <entry offset=""0x1b"" startLine=""1"" startColumn=""78"" endLine=""1"" endColumn=""79"" document=""1"" />
-            <entry offset=""0x1f"" startLine=""1"" startColumn=""86"" endLine=""1"" endColumn=""87"" document=""1"" />
-            <entry offset=""0x23"" hidden=""true"" document=""1"" />
-            <entry offset=""0x26"" startLine=""1"" startColumn=""45"" endLine=""1"" endColumn=""99"" document=""1"" />
-            <entry offset=""0x27"" startLine=""1"" startColumn=""62"" endLine=""1"" endColumn=""89"" document=""1"" />
-            <entry offset=""0x2b"" startLine=""1"" startColumn=""96"" endLine=""1"" endColumn=""97"" document=""1"" />
-            <entry offset=""0x2f"" hidden=""true"" document=""1"" />
-            <entry offset=""0x32"" startLine=""1"" startColumn=""32"" endLine=""1"" endColumn=""99"" document=""1"" />
-            <entry offset=""0x33"" hidden=""true"" document=""1"" />
-          </sequencePoints>
-          <scope startOffset=""0x0"" endOffset=""0x3a"">
-            <local name=""x"" il_index=""0"" il_start=""0x0"" il_end=""0x3a"" attributes=""0"" />
-          </scope>
-        </method>
-      </methods>
-    </symbols>
-");
+<symbols>
+  <methods>
+    <method containingType=""C"" name=""G"">
+      <customDebugInfo>
+        <using>
+          <namespace usingCount=""0"" />
+        </using>
+        <encLocalSlotMap>
+          <slot kind=""0"" offset=""13"" />
+          <slot kind=""temp"" />
+          <slot kind=""35"" offset=""16"" />
+          <slot kind=""temp"" />
+        </encLocalSlotMap>
+      </customDebugInfo>
+    </method>
+  </methods>
+</symbols>
+", options: SyntaxOffsetPdbValidationOptions);
         }
 
         [Fact]
@@ -12284,9 +11986,6 @@ class C(int x) : B(F(out var y), y)
             var c = CreateCompilationWithMscorlib40AndSystemCore(source, options: TestOptions.DebugDll);
             c.VerifyPdb(@"
 <symbols>
-  <files>
-    <file id=""1"" name="""" language=""C#"" />
-  </files>
   <methods>
     <method containingType=""B"" name="".ctor"" parameterNames=""x, y"">
       <customDebugInfo>
@@ -12294,9 +11993,6 @@ class C(int x) : B(F(out var y), y)
           <namespace usingCount=""0"" />
         </using>
       </customDebugInfo>
-      <sequencePoints>
-        <entry offset=""0x0"" startLine=""2"" startColumn=""7"" endLine=""2"" endColumn=""22"" document=""1"" />
-      </sequencePoints>
     </method>
     <method containingType=""C"" name="".ctor"" parameterNames=""x"">
       <customDebugInfo>
@@ -12306,28 +12002,15 @@ class C(int x) : B(F(out var y), y)
           <slot kind=""0"" offset=""-20"" />
         </encLocalSlotMap>
       </customDebugInfo>
-      <sequencePoints>
-        <entry offset=""0x0"" startLine=""8"" startColumn=""5"" endLine=""8"" endColumn=""26"" document=""1"" />
-        <entry offset=""0xd"" startLine=""6"" startColumn=""18"" endLine=""6"" endColumn=""36"" document=""1"" />
-      </sequencePoints>
-      <scope startOffset=""0x0"" endOffset=""0x1d"">
-        <local name=""y"" il_index=""0"" il_start=""0x0"" il_end=""0x1d"" attributes=""0"" />
-        <scope startOffset=""0x0"" endOffset=""0xd"">
-          <local name=""z"" il_index=""1"" il_start=""0x0"" il_end=""0xd"" attributes=""0"" />
-        </scope>
-      </scope>
     </method>
     <method containingType=""C"" name=""F"" parameterNames=""a"">
       <customDebugInfo>
         <forward declaringType=""B"" methodName="".ctor"" parameterNames=""x, y"" />
       </customDebugInfo>
-      <sequencePoints>
-        <entry offset=""0x0"" startLine=""9"" startColumn=""32"" endLine=""9"" endColumn=""37"" document=""1"" />
-      </sequencePoints>
     </method>
   </methods>
 </symbols>
-");
+", options: SyntaxOffsetPdbValidationOptions);
         }
 
         #endregion

From 9e9887f263583cc5a599007783237a2aef6a8283 Mon Sep 17 00:00:00 2001
From: tmat <tomas.matousek@microsoft.com>
Date: Tue, 18 Jul 2023 14:36:02 -0700
Subject: [PATCH 7/7] Feedback

---
 .../CSharpTest/EditAndContinue/BreakpointSpansTests.cs           | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/EditorFeatures/CSharpTest/EditAndContinue/BreakpointSpansTests.cs b/src/EditorFeatures/CSharpTest/EditAndContinue/BreakpointSpansTests.cs
index 571490c4f775c..cc8db14a4feca 100644
--- a/src/EditorFeatures/CSharpTest/EditAndContinue/BreakpointSpansTests.cs
+++ b/src/EditorFeatures/CSharpTest/EditAndContinue/BreakpointSpansTests.cs
@@ -10,7 +10,6 @@
 using System.Threading;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.CodeAnalysis.CSharp.Completion.Providers;
 using Microsoft.CodeAnalysis.CSharp.EditAndContinue;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Test.Utilities;