Merge pull request #74985 from dotnet/revert-74780-isolatedALC

Revert "Load analyzers and generators in isolated ALCs in our OOP process"

Author: 333fred

src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/LanguageServerWorkspaceFactory.cs

@@ -57,12 +57,7 @@ public LanguageServerWorkspaceFactory(
     public async Task InitializeSolutionLevelAnalyzersAsync(ImmutableArray<string> analyzerPaths)
     {
         var references = new List<AnalyzerFileReference>();
-        var loaderProvider = Workspace.Services.GetRequiredService<IAnalyzerAssemblyLoaderProvider>();
-
-        // Load all analyzers into a fresh shadow copied load context.  In the future, if we want to support reloading
-        // of solution-level analyzer references, we should just need to listen for changes to those analyzer paths and
-        // then call back into this method to update the solution accordingly.
-        var analyzerLoader = loaderProvider.CreateNewShadowCopyLoader();
+        var analyzerLoader = Workspace.Services.GetRequiredService<IAnalyzerAssemblyLoaderProvider>().SharedShadowCopyLoader;
 
         foreach (var analyzerPath in analyzerPaths)
         {

src/VisualStudio/Core/Test.Next/Remote/SerializationValidator.cs

@@ -110,8 +110,7 @@ public async Task<T> GetValueAsync<T>(Checksum checksum)
 
         public async Task<Solution> GetSolutionAsync(SolutionAssetStorage.Scope scope)
         {
-            var solutionInfo = await new AssetProvider(this).CreateSolutionInfoAsync(
-                scope.SolutionChecksum, this.Services.SolutionServices, CancellationToken.None).ConfigureAwait(false);
+            var solutionInfo = await new AssetProvider(this).CreateSolutionInfoAsync(scope.SolutionChecksum, CancellationToken.None).ConfigureAwait(false);
 
             var workspace = new AdhocWorkspace(Services.HostServices);
             return workspace.AddSolution(solutionInfo);

src/VisualStudio/Core/Test.Next/Services/SolutionServiceTests.cs

@@ -15,7 +15,6 @@
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Editor.Test;
 using Microsoft.CodeAnalysis.Formatting;
-using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Remote;
 using Microsoft.CodeAnalysis.Remote.Testing;
 using Microsoft.CodeAnalysis.Serialization;
@@ -447,10 +446,7 @@ public async Task TestRemoteWorkspace()
         await Verify(remoteWorkspace, currentSolution, remoteSolution3);
 
         // move to new solution backward
-        var solutionInfo2 = await assetProvider.CreateSolutionInfoAsync(
-            await solution1.CompilationState.GetChecksumAsync(CancellationToken.None),
-            remoteWorkspace.Services.SolutionServices,
-            CancellationToken.None);
+        var solutionInfo2 = await assetProvider.CreateSolutionInfoAsync(await solution1.CompilationState.GetChecksumAsync(CancellationToken.None), CancellationToken.None);
         var solution2 = remoteWorkspace.GetTestAccessor().CreateSolutionFromInfo(solutionInfo2);
 
         // move to new solution forward

src/Workspaces/Core/Portable/Serialization/SerializerService_Reference.cs

@@ -8,6 +8,7 @@
 using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Reflection.Metadata;
+using System.Threading;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Shared.Extensions;
@@ -53,24 +54,15 @@ private static Checksum CreateChecksum(MetadataReference reference)
 
     protected virtual Checksum CreateChecksum(AnalyzerReference reference)
     {
-#if NET
-        // If we're in the oop side and we're being asked to produce our local checksum (so we can compare it to the
-        // host checksum), then we want to just defer to the underlying analyzer reference of our isolated reference.
-        // This underlying reference corresponds to the reference that the host has, and we do not want to make any
-        // changes as long as they're both in agreement.
-        if (reference is IsolatedAnalyzerFileReference { UnderlyingAnalyzerFileReference: var underlyingReference })
-            reference = underlyingReference;
-#endif
-
         using var stream = SerializableBytes.CreateWritableStream();
 
         using (var writer = new ObjectWriter(stream, leaveOpen: true))
         {
             switch (reference)
             {
-                case AnalyzerFileReference fileReference:
-                    writer.WriteString(fileReference.FullPath);
-                    writer.WriteGuid(TryGetAnalyzerFileReferenceMvid(fileReference));
+                case AnalyzerFileReference file:
+                    writer.WriteString(file.FullPath);
+                    writer.WriteGuid(TryGetAnalyzerFileReferenceMvid(file));
                     break;
 
                 case AnalyzerImageReference analyzerImageReference:
@@ -117,11 +109,11 @@ protected virtual void WriteAnalyzerReferenceTo(AnalyzerReference reference, Obj
     {
         switch (reference)
         {
-            case AnalyzerFileReference fileReference:
+            case AnalyzerFileReference file:
                 writer.WriteString(nameof(AnalyzerFileReference));
-                writer.WriteString(fileReference.FullPath);
+                writer.WriteString(file.FullPath);
 
-                // Note: it is intentional that we are not writing the MVID of the analyzer file reference over in (even
+                // Note: it is intentional that we are not writing the MVID of the analyzer file reference over (even
                 // though we mixed it into the checksum).  We don't actually need the data on the other side as it will
                 // be read out from the file itself.  So the flow is as follows when an analyzer-file-reference changes:
                 //
@@ -158,10 +150,8 @@ protected virtual AnalyzerReference ReadAnalyzerReferenceFrom(ObjectReader reade
         switch (reader.ReadString())
         {
             case nameof(AnalyzerFileReference):
-                // Rehydrate the analyzer file reference with the simple shared shadow copy loader.  Note: we won't
-                // actually use this instance we create.  Instead, the caller will use create an IsolatedAssemblyReferenceSet
-                // from these to ensure that all the types can be safely loaded into their own ALC.
-                return new AnalyzerFileReference(reader.ReadRequiredString(), _analyzerLoaderProvider.SharedShadowCopyLoader);
+                var fullPath = reader.ReadRequiredString();
+                return new AnalyzerFileReference(fullPath, _analyzerLoaderProvider.SharedShadowCopyLoader);
 
             case nameof(AnalyzerImageReference):
                 var guid = reader.ReadGuid();
@@ -296,7 +286,7 @@ private PortableExecutableReference ReadPortableExecutableReferenceFrom(ObjectRe
         // so that we can put xml doc comment as part of snapshot. but until we believe that is necessary,
         // it will go with simpler approach
         var documentProvider = filePath != null && _documentationService != null ?
-            _documentationService.GetDocumentationProvider(filePath) : DocumentationProvider.Default;
+            _documentationService.GetDocumentationProvider(filePath) : XmlDocumentationProvider.Default;
 
         return new SerializedPortableExecutableReference(
             properties, filePath, metadata, storageHandles, documentProvider);

src/Workspaces/Core/Portable/Workspace/Host/Metadata/IAnalyzerAssemblyLoaderProvider.cs

@@ -9,24 +9,11 @@
 using System.IO;
 using Microsoft.CodeAnalysis.Host.Mef;
 
-#if NET
-using Microsoft.CodeAnalysis.Diagnostics;
-using System.Runtime.Loader;
-#endif
-
 namespace Microsoft.CodeAnalysis.Host;
 
 internal interface IAnalyzerAssemblyLoaderProvider : IWorkspaceService
 {
     IAnalyzerAssemblyLoaderInternal SharedShadowCopyLoader { get; }
-
-#if NET
-    /// <summary>
-    /// Creates a fresh shadow copying loader that will load all <see cref="AnalyzerReference"/>s and <see
-    /// cref="ISourceGenerator"/>s in a fresh <see cref="AssemblyLoadContext"/>.
-    /// </summary>
-    IAnalyzerAssemblyLoaderInternal CreateNewShadowCopyLoader();
-#endif
 }
 
 /// <summary>
@@ -41,13 +28,13 @@ internal abstract class AbstractAnalyzerAssemblyLoaderProvider : IAnalyzerAssemb
     public AbstractAnalyzerAssemblyLoaderProvider(IEnumerable<IAnalyzerAssemblyResolver> externalResolvers)
     {
         _externalResolvers = externalResolvers.ToImmutableArray();
-        _shadowCopyLoader = new(CreateNewShadowCopyLoader);
+        _shadowCopyLoader = new(CreateShadowCopyLoader);
     }
 
     public IAnalyzerAssemblyLoaderInternal SharedShadowCopyLoader
         => _shadowCopyLoader.Value;
 
-    public IAnalyzerAssemblyLoaderInternal CreateNewShadowCopyLoader()
+    private IAnalyzerAssemblyLoaderInternal CreateShadowCopyLoader()
         => this.WrapLoader(DefaultAnalyzerAssemblyLoader.CreateNonLockingLoader(
                 Path.Combine(Path.GetTempPath(), nameof(Roslyn), "AnalyzerAssemblyLoader"),
                 _externalResolvers));