Fix assembly layering for .NET SDK (#57386)

* Fix assembly layering for .NET SDK

* Feedback

* Fix

Author: tmat

src/EditorFeatures/CSharpTest/EditAndContinue/ActiveStatementTests.cs

@@ -7,8 +7,8 @@
 using System;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.EditAndContinue;
+using Microsoft.CodeAnalysis.EditAndContinue.Contracts;
 using Microsoft.CodeAnalysis.EditAndContinue.UnitTests;
-using Microsoft.VisualStudio.Debugger.Contracts.EditAndContinue;
 using Microsoft.CodeAnalysis.Test.Utilities;
 using Roslyn.Test.Utilities;
 using Xunit;

src/EditorFeatures/CSharpTest/EditAndContinue/ActiveStatementTrackingServiceTests.cs

@@ -9,12 +9,12 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.EditAndContinue;
+using Microsoft.CodeAnalysis.EditAndContinue.Contracts;
 using Microsoft.CodeAnalysis.EditAndContinue.UnitTests;
 using Microsoft.CodeAnalysis.Editor.Implementation.EditAndContinue;
 using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
 using Microsoft.CodeAnalysis.Test.Utilities;
 using Microsoft.CodeAnalysis.Text;
-using Microsoft.VisualStudio.Debugger.Contracts.EditAndContinue;
 using Roslyn.Test.Utilities;
 using Roslyn.Utilities;
 using Xunit;

src/EditorFeatures/CSharpTest/EditAndContinue/CSharpEditAndContinueAnalyzerTests.cs

@@ -14,11 +14,11 @@
 using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
 using Microsoft.CodeAnalysis.Differencing;
 using Microsoft.CodeAnalysis.EditAndContinue;
+using Microsoft.CodeAnalysis.EditAndContinue.Contracts;
 using Microsoft.CodeAnalysis.EditAndContinue.UnitTests;
 using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
 using Microsoft.CodeAnalysis.Test.Utilities;
 using Microsoft.CodeAnalysis.Text;
-using Microsoft.VisualStudio.Debugger.Contracts.EditAndContinue;
 using Roslyn.Test.Utilities;
 using Roslyn.Utilities;
 using Xunit;

src/EditorFeatures/CSharpTest/EditAndContinue/Helpers/EditAndContinueValidation.cs

@@ -6,8 +6,8 @@
 using System.Collections.Immutable;
 using Microsoft.CodeAnalysis.Differencing;
 using Microsoft.CodeAnalysis.EditAndContinue;
+using Microsoft.CodeAnalysis.EditAndContinue.Contracts;
 using Microsoft.CodeAnalysis.EditAndContinue.UnitTests;
-using Microsoft.VisualStudio.Debugger.Contracts.EditAndContinue;
 using Roslyn.Test.Utilities;
 using Xunit;
 

src/EditorFeatures/CSharpTest/EditAndContinue/Helpers/EditingTestBase.cs

@@ -10,11 +10,11 @@
 using Microsoft.CodeAnalysis.CSharp.UnitTests;
 using Microsoft.CodeAnalysis.Differencing;
 using Microsoft.CodeAnalysis.EditAndContinue;
+using Microsoft.CodeAnalysis.EditAndContinue.Contracts;
 using Microsoft.CodeAnalysis.EditAndContinue.UnitTests;
 using Microsoft.CodeAnalysis.Emit;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Text;
-using Microsoft.VisualStudio.Debugger.Contracts.EditAndContinue;
 using Roslyn.Utilities;
 using Xunit;
 

src/EditorFeatures/CSharpTest/EditAndContinue/LineEditTests.cs

@@ -9,10 +9,10 @@
 using System.Linq;
 using Microsoft.CodeAnalysis.CSharp.UnitTests;
 using Microsoft.CodeAnalysis.EditAndContinue;
+using Microsoft.CodeAnalysis.EditAndContinue.Contracts;
 using Microsoft.CodeAnalysis.EditAndContinue.UnitTests;
 using Microsoft.CodeAnalysis.Emit;
 using Microsoft.CodeAnalysis.Test.Utilities;
-using Microsoft.VisualStudio.Debugger.Contracts.EditAndContinue;
 using Roslyn.Test.Utilities;
 using Xunit;
 

src/EditorFeatures/Core/Implementation/EditAndContinue/ActiveStatementTrackingSpan.cs

@@ -3,8 +3,8 @@
 // See the LICENSE file in the project root for more information.
 
 using Microsoft.CodeAnalysis.EditAndContinue;
+using Microsoft.CodeAnalysis.EditAndContinue.Contracts;
 using Microsoft.CodeAnalysis.Text.Shared.Extensions;
-using Microsoft.VisualStudio.Debugger.Contracts.EditAndContinue;
 using Microsoft.VisualStudio.Text;
 
 namespace Microsoft.CodeAnalysis.Editor.Implementation.EditAndContinue

src/EditorFeatures/Core/Implementation/EditAndContinue/Contracts/ContractWrappers.cs

@@ -0,0 +1,69 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Immutable;
+using Microsoft.VisualStudio.Debugger.Contracts.EditAndContinue;
+using Microsoft.VisualStudio.Debugger.Contracts.HotReload;
+
+using Contracts = Microsoft.CodeAnalysis.EditAndContinue.Contracts;
+
+namespace Microsoft.CodeAnalysis.Editor.Implementation.EditAndContinue
+{
+    internal static class ContractWrappers
+    {
+        public static Contracts.ManagedActiveStatementDebugInfo ToContract(this ManagedActiveStatementDebugInfo info)
+            => new(ToContract(info.ActiveInstruction), info.DocumentName, ToContract(info.SourceSpan), (Contracts.ActiveStatementFlags)info.Flags);
+
+        public static Contracts.ManagedInstructionId ToContract(this ManagedInstructionId id)
+            => new(ToContract(id.Method), id.ILOffset);
+
+        public static Contracts.ManagedMethodId ToContract(this ManagedMethodId id)
+            => new(id.Module, id.Token, id.Version);
+
+        public static Contracts.SourceSpan ToContract(this SourceSpan id)
+            => new(id.StartLine, id.StartColumn, id.EndLine, id.EndColumn);
+
+        public static Contracts.ManagedHotReloadAvailability ToContract(this ManagedHotReloadAvailability value)
+            => new((Contracts.ManagedHotReloadAvailabilityStatus)value.Status, value.LocalizedMessage);
+
+        public static ManagedModuleUpdates FromContract(this Contracts.ManagedModuleUpdates updates)
+            => new((ManagedModuleUpdateStatus)updates.Status, updates.Updates.SelectAsArray(FromContract));
+
+        public static ManagedModuleUpdate FromContract(this Contracts.ManagedModuleUpdate update)
+            => new(
+                update.Module,
+                update.ILDelta,
+                update.MetadataDelta,
+                update.PdbDelta,
+                update.SequencePoints.SelectAsArray(FromContract),
+                update.UpdatedMethods,
+                update.UpdatedTypes,
+                update.ActiveStatements.SelectAsArray(FromContract),
+                update.ExceptionRegions.SelectAsArray(FromContract));
+
+        public static SequencePointUpdates FromContract(this Contracts.SequencePointUpdates updates)
+            => new(updates.FileName, updates.LineUpdates.SelectAsArray(FromContract));
+
+        public static SourceLineUpdate FromContract(this Contracts.SourceLineUpdate update)
+            => new(update.OldLine, update.NewLine);
+
+        public static ManagedActiveStatementUpdate FromContract(this Contracts.ManagedActiveStatementUpdate update)
+            => new(FromContract(update.Method), update.ILOffset, FromContract(update.NewSpan));
+
+        public static ManagedModuleMethodId FromContract(this Contracts.ManagedModuleMethodId update)
+            => new(update.Token, update.Version);
+
+        public static SourceSpan FromContract(this Contracts.SourceSpan id)
+            => new(id.StartLine, id.StartColumn, id.EndLine, id.EndColumn);
+
+        public static ManagedExceptionRegionUpdate FromContract(this Contracts.ManagedExceptionRegionUpdate update)
+            => new(FromContract(update.Method), update.Delta, FromContract(update.NewSpan));
+
+        public static ImmutableArray<ManagedHotReloadDiagnostic> FromContract(this ImmutableArray<Contracts.ManagedHotReloadDiagnostic> diagnostics)
+            => diagnostics.SelectAsArray(FromContract);
+
+        public static ManagedHotReloadDiagnostic FromContract(this Contracts.ManagedHotReloadDiagnostic diagnostic)
+            => new(diagnostic.Id, diagnostic.Message, (ManagedHotReloadDiagnosticSeverity)diagnostic.Severity, diagnostic.FilePath, FromContract(diagnostic.Span));
+    }
+}

src/EditorFeatures/Core/Implementation/EditAndContinue/Contracts/ManagedHotReloadServiceImpl.cs

@@ -0,0 +1,34 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Immutable;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.VisualStudio.Debugger.Contracts.HotReload;
+
+using Contracts = Microsoft.CodeAnalysis.EditAndContinue.Contracts;
+
+namespace Microsoft.CodeAnalysis.Editor.Implementation.EditAndContinue
+{
+    internal sealed class ManagedHotReloadServiceImpl : Contracts.IManagedHotReloadService
+    {
+        private readonly IManagedHotReloadService _service;
+
+        public ManagedHotReloadServiceImpl(IManagedHotReloadService service)
+            => _service = service;
+
+        public async ValueTask<ImmutableArray<Contracts.ManagedActiveStatementDebugInfo>> GetActiveStatementsAsync(CancellationToken cancellation)
+            => (await _service.GetActiveStatementsAsync(cancellation).ConfigureAwait(false)).SelectAsArray(a => a.ToContract());
+
+        public async ValueTask<Contracts.ManagedHotReloadAvailability> GetAvailabilityAsync(Guid module, CancellationToken cancellation)
+            => (await _service.GetAvailabilityAsync(module, cancellation).ConfigureAwait(false)).ToContract();
+
+        public ValueTask<ImmutableArray<string>> GetCapabilitiesAsync(CancellationToken cancellation)
+            => _service.GetCapabilitiesAsync(cancellation);
+
+        public ValueTask PrepareModuleForUpdateAsync(Guid module, CancellationToken cancellation)
+            => _service.PrepareModuleForUpdateAsync(module, cancellation);
+    }
+}

src/EditorFeatures/Core/Implementation/EditAndContinue/EditAndContinueLanguageService.cs

@@ -100,7 +100,7 @@ public async ValueTask StartSessionAsync(CancellationToken cancellationToken)
 
                 _debuggingSession = await proxy.StartDebuggingSessionAsync(
                     solution,
-                    _debuggerService.Value,
+                    new ManagedHotReloadServiceImpl(_debuggerService.Value),
                     captureMatchingDocuments: openedDocumentIds,
                     captureAllMatchingDocuments: false,
                     reportDiagnostics: true,
@@ -278,7 +278,7 @@ public async ValueTask<ManagedModuleUpdates> GetEditAndContinueUpdatesAsync(Canc
             var activeStatementSpanProvider = GetActiveStatementSpanProvider(solution);
             var (updates, _, _, _) = await GetDebuggingSession().EmitSolutionUpdateAsync(solution, activeStatementSpanProvider, _diagnosticService, _diagnosticUpdateSource, cancellationToken).ConfigureAwait(false);
             _pendingUpdatedSolution = solution;
-            return updates;
+            return updates.FromContract();
         }
 
         public async ValueTask<ManagedHotReloadUpdates> GetHotReloadUpdatesAsync(CancellationToken cancellationToken)
@@ -297,7 +297,7 @@ public async ValueTask<ManagedHotReloadUpdates> GetHotReloadUpdatesAsync(Cancell
 
             var diagnostics = await EmitSolutionUpdateResults.GetHotReloadDiagnosticsAsync(solution, diagnosticData, rudeEdits, syntaxError, cancellationToken).ConfigureAwait(false);
 
-            return new ManagedHotReloadUpdates(updates, diagnostics);
+            return new ManagedHotReloadUpdates(updates, diagnostics.FromContract());
         }
 
         public async ValueTask<SourceSpan?> GetCurrentActiveStatementPositionAsync(ManagedInstructionId instruction, CancellationToken cancellationToken)
@@ -310,8 +310,8 @@ public async ValueTask<ManagedHotReloadUpdates> GetHotReloadUpdatesAsync(Cancell
                 var activeStatementSpanProvider = new ActiveStatementSpanProvider((documentId, filePath, cancellationToken) =>
                     activeStatementTrackingService.GetSpansAsync(solution, documentId, filePath, cancellationToken));
 
-                var span = await GetDebuggingSession().GetCurrentActiveStatementPositionAsync(solution, activeStatementSpanProvider, instruction, cancellationToken).ConfigureAwait(false);
-                return span?.ToSourceSpan();
+                var span = await GetDebuggingSession().GetCurrentActiveStatementPositionAsync(solution, activeStatementSpanProvider, instruction.ToContract(), cancellationToken).ConfigureAwait(false);
+                return span?.ToSourceSpan().FromContract();
             }
             catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e, cancellationToken))
             {
@@ -324,7 +324,7 @@ public async ValueTask<ManagedHotReloadUpdates> GetHotReloadUpdatesAsync(Cancell
             try
             {
                 var solution = GetCurrentCompileTimeSolution();
-                return await GetDebuggingSession().IsActiveStatementInExceptionRegionAsync(solution, instruction, cancellationToken).ConfigureAwait(false);
+                return await GetDebuggingSession().IsActiveStatementInExceptionRegionAsync(solution, instruction.ToContract(), cancellationToken).ConfigureAwait(false);
             }
             catch (Exception e) when (FatalError.ReportAndCatchUnlessCanceled(e, cancellationToken))
             {