[EnC] Allow deleting method

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

@@ -32,10 +32,11 @@ public CSharpSymbolMatcher(
             EmitContext sourceContext,
             SourceAssemblySymbol otherAssembly,
             EmitContext otherContext,
-            ImmutableDictionary<ISymbolInternal, ImmutableArray<ISymbolInternal>> otherSynthesizedMembersOpt)
+            ImmutableDictionary<ISymbolInternal, ImmutableArray<ISymbolInternal>>? otherSynthesizedMembers,
+            ImmutableDictionary<ISymbolInternal, ImmutableArray<ISymbolInternal>>? otherDeletedMembers)
         {
             _defs = new MatchDefsToSource(sourceContext, otherContext);
-            _symbols = new MatchSymbols(anonymousTypeMap, anonymousDelegates, anonymousDelegatesWithFixedTypes, sourceAssembly, otherAssembly, otherSynthesizedMembersOpt, new DeepTranslator(otherAssembly.GetSpecialType(SpecialType.System_Object)));
+            _symbols = new MatchSymbols(anonymousTypeMap, anonymousDelegates, anonymousDelegatesWithFixedTypes, sourceAssembly, otherAssembly, otherSynthesizedMembers, otherDeletedMembers, new DeepTranslator(otherAssembly.GetSpecialType(SpecialType.System_Object)));
         }
 
         public CSharpSymbolMatcher(
@@ -55,7 +56,8 @@ public CSharpSymbolMatcher(
                 sourceAssembly,
                 otherAssembly,
                 otherSynthesizedMembers: null,
-                deepTranslator: null);
+                deepTranslator: null,
+                otherDeletedMembers: null);
         }
 
         public override Cci.IDefinition? MapDefinition(Cci.IDefinition definition)
@@ -292,6 +294,8 @@ private sealed class MatchSymbols : CSharpSymbolVisitor<Symbol?>
             /// </summary>
             private readonly ImmutableDictionary<ISymbolInternal, ImmutableArray<ISymbolInternal>>? _otherSynthesizedMembers;
 
+            private readonly ImmutableDictionary<ISymbolInternal, ImmutableArray<ISymbolInternal>>? _otherDeletedMembers;
+
             private readonly SymbolComparer _comparer;
             private readonly ConcurrentDictionary<Symbol, Symbol?> _matches = new(ReferenceEqualityComparer.Instance);
 
@@ -310,6 +314,7 @@ public MatchSymbols(
                 SourceAssemblySymbol sourceAssembly,
                 AssemblySymbol otherAssembly,
                 ImmutableDictionary<ISymbolInternal, ImmutableArray<ISymbolInternal>>? otherSynthesizedMembers,
+                ImmutableDictionary<ISymbolInternal, ImmutableArray<ISymbolInternal>>? otherDeletedMembers,
                 DeepTranslator? deepTranslator)
             {
                 _anonymousTypeMap = anonymousTypeMap;
@@ -318,6 +323,7 @@ public MatchSymbols(
                 _sourceAssembly = sourceAssembly;
                 _otherAssembly = otherAssembly;
                 _otherSynthesizedMembers = otherSynthesizedMembers;
+                _otherDeletedMembers = otherDeletedMembers;
                 _comparer = new SymbolComparer(this, deepTranslator);
             }
 
@@ -987,6 +993,11 @@ private IReadOnlyDictionary<string, ImmutableArray<ISymbolInternal>> GetAllEmitt
                     members.AddRange(synthesizedMembers);
                 }
 
+                if (_otherDeletedMembers?.TryGetValue(symbol, out var deletedMembers) == true)
+                {
+                    members.AddRange(deletedMembers);
+                }
+
                 var result = members.ToDictionary(s => s.MetadataName, StringOrdinalComparer.Instance);
                 members.Free();
                 return result;
@@ -1006,6 +1017,11 @@ public SymbolComparer(MatchSymbols matcher, DeepTranslator? deepTranslator)
 
                 public bool Equals(TypeSymbol source, TypeSymbol other)
                 {
+                    if (ReferenceEquals(source, other))
+                    {
+                        return true;
+                    }
+
                     var visitedSource = (TypeSymbol?)_matcher.Visit(source);
                     var visitedOther = (_deepTranslator != null) ? (TypeSymbol)_deepTranslator.Visit(other) : other;
 

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

@@ -174,8 +174,10 @@ private static EmitBaseline MapToCompilation(
 
             RoslynDebug.AssertNotNull(previousGeneration.Compilation);
             RoslynDebug.AssertNotNull(previousGeneration.PEModuleBuilder);
+            RoslynDebug.AssertNotNull(moduleBeingBuilt.EncSymbolChanges);
 
             var currentSynthesizedMembers = moduleBeingBuilt.GetAllSynthesizedMembers();
+            var currentDeletedMembers = moduleBeingBuilt.EncSymbolChanges.GetAllDeletedMethods();
 
             // Mapping from previous compilation to the current.
             var anonymousTypeMap = moduleBeingBuilt.GetAnonymousTypeMap();
@@ -193,10 +195,14 @@ private static EmitBaseline MapToCompilation(
                 sourceContext,
                 compilation.SourceAssembly,
                 otherContext,
-                currentSynthesizedMembers);
+                currentSynthesizedMembers,
+                currentDeletedMembers);
 
             var mappedSynthesizedMembers = matcher.MapSynthesizedMembers(previousGeneration.SynthesizedMembers, currentSynthesizedMembers);
 
+            // Deleted members are mapped the same way as synthesized members, so we can just call the same method.
+            var mappedDeletedMembers = matcher.MapSynthesizedMembers(previousGeneration.DeletedMembers, currentDeletedMembers);
+
             // TODO: can we reuse some data from the previous matcher?
             var matcherWithAllSynthesizedMembers = new CSharpSymbolMatcher(
                 anonymousTypeMap,
@@ -206,13 +212,15 @@ private static EmitBaseline MapToCompilation(
                 sourceContext,
                 compilation.SourceAssembly,
                 otherContext,
-                mappedSynthesizedMembers);
+                mappedSynthesizedMembers,
+                mappedDeletedMembers);
 
             return matcherWithAllSynthesizedMembers.MapBaselineToCompilation(
                 previousGeneration,
                 compilation,
                 moduleBeingBuilt,
-                mappedSynthesizedMembers);
+                mappedSynthesizedMembers,
+                mappedDeletedMembers);
         }
     }
 }

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

@@ -72,7 +72,8 @@ public PEDeltaAssemblyBuilder(
                     sourceContext: context,
                     otherAssembly: previousAssembly,
                     otherContext: previousContext,
-                    otherSynthesizedMembersOpt: previousGeneration.SynthesizedMembers);
+                    otherSynthesizedMembers: previousGeneration.SynthesizedMembers,
+                    otherDeletedMembers: previousGeneration.DeletedMembers);
             }
 
             _previousDefinitions = new CSharpDefinitionMap(edits, metadataDecoder, matchToMetadata, matchToPrevious);

src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueTest.GenerationInfo.cs

@@ -5,6 +5,7 @@
 using System;
 using System.Reflection.Metadata;
 using Microsoft.CodeAnalysis.Emit;
+using Microsoft.CodeAnalysis.Test.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.EditAndContinue.UnitTests
 {
@@ -16,13 +17,15 @@ internal sealed class GenerationInfo
             public readonly MetadataReader MetadataReader;
             public readonly EmitBaseline Baseline;
             public readonly Action<GenerationVerifier> Verifier;
+            public readonly CompilationDifference? CompilationDifference;
 
-            public GenerationInfo(CSharpCompilation compilation, MetadataReader reader, EmitBaseline baseline, Action<GenerationVerifier> verifier)
+            public GenerationInfo(CSharpCompilation compilation, MetadataReader reader, CompilationDifference? diff, EmitBaseline baseline, Action<GenerationVerifier> verifier)
             {
                 Compilation = compilation;
                 MetadataReader = reader;
                 Baseline = baseline;
                 Verifier = verifier;
+                CompilationDifference = diff;
             }
         }
     }

src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueTest.GenerationVerifier.cs

@@ -6,6 +6,7 @@
 using System.Linq;
 using System.Reflection.Metadata;
 using System.Reflection.Metadata.Ecma335;
+using Microsoft.CodeAnalysis.CSharp.UnitTests;
 using Roslyn.Test.Utilities;
 using static Microsoft.CodeAnalysis.CSharp.EditAndContinue.UnitTests.EditAndContinueTestBase;
 
@@ -18,12 +19,14 @@ internal sealed class GenerationVerifier
             private readonly int _ordinal;
             private readonly MetadataReader _metadataReader;
             private readonly IEnumerable<MetadataReader> _readers;
+            private readonly GenerationInfo _generationInfo;
 
-            public GenerationVerifier(int ordinal, MetadataReader metadataReader, IEnumerable<MetadataReader> readers)
+            public GenerationVerifier(int ordinal, GenerationInfo generationInfo, IEnumerable<MetadataReader> readers)
             {
                 _ordinal = ordinal;
-                _metadataReader = metadataReader;
+                _metadataReader = generationInfo.MetadataReader;
                 _readers = readers;
+                _generationInfo = generationInfo;
             }
 
             private string GetAssertMessage(string message)
@@ -91,6 +94,11 @@ internal void VerifyCustomAttributes(IEnumerable<CustomAttributeRow> expected)
             {
                 AssertEx.Equal(expected, _metadataReader.GetCustomAttributeRows(), itemInspector: AttributeRowToString);
             }
+
+            internal void VerifyIL(string expectedIL)
+            {
+                _generationInfo.CompilationDifference!.VerifyIL(expectedIL);
+            }
         }
     }
 }

src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueTest.cs

@@ -45,7 +45,7 @@ internal EditAndContinueTest AddGeneration(string source, Action<GenerationVerif
 
             var baseline = EmitBaseline.CreateInitialBaseline(md, EditAndContinueTestBase.EmptyLocalsProvider);
 
-            _generations.Add(new GenerationInfo(compilation, md.MetadataReader, baseline, validator));
+            _generations.Add(new GenerationInfo(compilation, md.MetadataReader, diff: null, baseline, validator));
 
             return this;
         }
@@ -62,12 +62,20 @@ internal EditAndContinueTest AddGeneration(string source, SemanticEditDescriptio
 
             var semanticEdits = GetSemanticEdits(edits, prevGeneration.Compilation, compilation);
 
-            var diff = compilation.EmitDifference(prevGeneration.Baseline, semanticEdits);
+            CompilationDifference diff;
+            try
+            {
+                diff = compilation.EmitDifference(prevGeneration.Baseline, semanticEdits);
+            }
+            catch (Exception ex)
+            {
+                throw new Exception($"Exception during generation #{_generations.Count}. See inner stack trace for details.", ex);
+            }
 
             var md = diff.GetMetadata();
             _disposables.Add(md);
 
-            _generations.Add(new GenerationInfo(compilation, md.Reader, diff.NextGeneration, validator));
+            _generations.Add(new GenerationInfo(compilation, md.Reader, diff, diff.NextGeneration, validator));
 
             return this;
         }
@@ -88,7 +96,7 @@ internal EditAndContinueTest Verify()
                 }
 
                 readers.Add(generation.MetadataReader);
-                var verifier = new GenerationVerifier(index, generation.MetadataReader, readers);
+                var verifier = new GenerationVerifier(index, generation, readers);
                 generation.Verifier(verifier);
 
                 index++;
@@ -99,7 +107,7 @@ internal EditAndContinueTest Verify()
 
         private ImmutableArray<SemanticEdit> GetSemanticEdits(SemanticEditDescription[] edits, Compilation oldCompilation, Compilation newCompilation)
         {
-            return ImmutableArray.CreateRange(edits.Select(e => new SemanticEdit(e.Kind, e.SymbolProvider(oldCompilation), e.SymbolProvider(newCompilation))));
+            return ImmutableArray.CreateRange(edits.Select(e => new SemanticEdit(e.Kind, e.SymbolProvider(oldCompilation), e.NewSymbolProvider(newCompilation))));
         }
 
         public void Dispose()

src/Compilers/CSharp/Test/Emit/Emit/EditAndContinue/EditAndContinueTestBase.cs

@@ -129,8 +129,8 @@ internal static StatementSyntax GetNearestStatement(SyntaxNode node)
             return null;
         }
 
-        internal static SemanticEditDescription Edit(SemanticEditKind kind, Func<Compilation, ISymbol> symbolProvider)
-            => new(kind, symbolProvider);
+        internal static SemanticEditDescription Edit(SemanticEditKind kind, Func<Compilation, ISymbol> symbolProvider, Func<Compilation, ISymbol> newSymbolProvider = null)
+            => new(kind, symbolProvider, newSymbolProvider);
 
         internal static EditAndContinueLogEntry Row(int rowNumber, TableIndex table, EditAndContinueOperation operation)
         {