Move generating deleted method bodies before freezing PrivateImplementationDetails.

Fix tests.

Improve IL/field data validation in EnC tests

Author: tmat

src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs

@@ -183,6 +183,11 @@ public static void CompileMethodBodies(
 
                 methodCompiler.WaitForWorkers();
 
+                // Deleted definitions must be emitted before PrivateImplementationDetails are frozen since
+                // it may add new members to it. All changes to PrivateImplementationDetails are additions,
+                // so we don't need to create deleted method defs for those.
+                moduleBeingBuiltOpt.CreateDeletedMethodDefinitions(diagnostics.DiagnosticBag);
+
                 // all threads that were adding methods must be finished now, we can freeze the class:
                 var privateImplClass = moduleBeingBuiltOpt.FreezePrivateImplementationDetails();
                 if (privateImplClass != null)

src/Compilers/CSharp/Portable/Emitter/EditAndContinue/EmitHelpers.cs

@@ -132,7 +132,6 @@ internal static EmitDifferenceResult EmitDifference(
                 newBaseline = compilation.SerializeToDeltaStreams(
                     moduleBeingBuilt,
                     definitionMap,
-                    changes,
                     metadataStream,
                     ilStream,
                     pdbStream,

src/Compilers/CSharp/Portable/Emitter/EditAndContinue/PEDeltaAssemblyBuilder.cs

@@ -238,7 +238,7 @@ public SynthesizedTypeMaps GetSynthesizedTypes()
         }
 
         public override IEnumerable<Cci.INamespaceTypeDefinition> GetTopLevelTypeDefinitions(EmitContext context)
-            => GetTopLevelTypeDefinitionsCore(context);
+            => GetTopLevelTypeDefinitionsExcludingNoPiaAndRootModule(context, includePrivateImplementationDetails: true);
 
         public override IEnumerable<Cci.INamespaceTypeDefinition> GetTopLevelSourceTypeDefinitions(EmitContext context)
         {

src/Compilers/CSharp/Test/Emit/Emit/EmitMetadataTests.cs

@@ -3144,6 +3144,65 @@ .maxstack  1
             Assert.Equal(0, verifier.Compilation.DataSectionStringLiteralThreshold);
         }
 
+        [Fact]
+        public void DataSectionStringLiterals_Switch()
+        {
+            var source = """
+                System.Console.Write(args[0] switch 
+                {
+                    "a" => 1,
+                    "bb" => 2,
+                    "ccc" => 3,
+                    _ => 4
+                });
+                """;
+
+            var verifier = CompileAndVerify(
+                source,
+                parseOptions: TestOptions.Regular.WithFeature("experimental-data-section-string-literals", "0"),
+                verify: Verification.Skipped);
+
+            verifier.VerifyIL("<top-level-statements-entry-point>", """
+                {
+                  // Code size       66 (0x42)
+                  .maxstack  2
+                  .locals init (int V_0,
+                                string V_1)
+                  IL_0000:  ldarg.0
+                  IL_0001:  ldc.i4.0
+                  IL_0002:  ldelem.ref
+                  IL_0003:  stloc.1
+                  IL_0004:  ldloc.1
+                  IL_0005:  ldsfld     "string <PrivateImplementationDetails>.<S>A96FAF705AF16834E6C632B61E964E1F.s"
+                  IL_000a:  call       "bool string.op_Equality(string, string)"
+                  IL_000f:  brtrue.s   IL_002d
+                  IL_0011:  ldloc.1
+                  IL_0012:  ldsfld     "string <PrivateImplementationDetails>.<S>DB1DE4B3DA6C7871B776D5CB968AA5A4.s"
+                  IL_0017:  call       "bool string.op_Equality(string, string)"
+                  IL_001c:  brtrue.s   IL_0031
+                  IL_001e:  ldloc.1
+                  IL_001f:  ldsfld     "string <PrivateImplementationDetails>.<S>BE20CA004CC2993A396345E0D52DF013.s"
+                  IL_0024:  call       "bool string.op_Equality(string, string)"
+                  IL_0029:  brtrue.s   IL_0035
+                  IL_002b:  br.s       IL_0039
+                  IL_002d:  ldc.i4.1
+                  IL_002e:  stloc.0
+                  IL_002f:  br.s       IL_003b
+                  IL_0031:  ldc.i4.2
+                  IL_0032:  stloc.0
+                  IL_0033:  br.s       IL_003b
+                  IL_0035:  ldc.i4.3
+                  IL_0036:  stloc.0
+                  IL_0037:  br.s       IL_003b
+                  IL_0039:  ldc.i4.4
+                  IL_003a:  stloc.0
+                  IL_003b:  ldloc.0
+                  IL_003c:  call       "void System.Console.Write(int)"
+                  IL_0041:  ret
+                }
+                """);
+        }
+
         [Fact]
         public void DataSectionStringLiterals_InvalidUtf8()
         {

src/Compilers/CSharp/Test/Emit2/Emit/EditAndContinue/AssemblyReferencesTests.cs

@@ -83,7 +83,10 @@ class C
 
             compilation1.EmitDifference(baseline, edits, s => false, mdStream, ilStream, pdbStream, EmitDifferenceOptions.Default, CancellationToken.None);
 
-            var actualIL = ImmutableArray.Create(ilStream.ToArray()).GetMethodIL();
+            var il = ImmutableArray.Create(ilStream.ToArray());
+            using var mdReaderProvider = MetadataReaderProvider.FromMetadataStream(mdStream);
+
+            var actualIL = ILValidation.DumpEncDeltaMethodBodies(il, [mdReaderProvider.GetMetadataReader()]);
             var expectedIL = @"
 {
   // Code size        7 (0x7)
@@ -155,7 +158,10 @@ class C
 
             compilation1.EmitDifference(baseline, edits, s => false, mdStream, ilStream, pdbStream, EmitDifferenceOptions.Default, CancellationToken.None);
 
-            var actualIL = ImmutableArray.Create(ilStream.ToArray()).GetMethodIL();
+            var il = ImmutableArray.Create(ilStream.ToArray());
+            using var mdReaderProvider = MetadataReaderProvider.FromMetadataStream(mdStream);
+
+            var actualIL = ILValidation.DumpEncDeltaMethodBodies(il, [mdReaderProvider.GetMetadataReader()]);
 
             // Symbol matcher should ignore overloads with missing type symbols and match 
             // F(object).