Load analyzers and generators in isolated ALCs in our OOP process

src/Compilers/Core/Portable/DiagnosticAnalyzer/DefaultAnalyzerAssemblyLoader.cs

@@ -12,6 +12,10 @@
 using System.Runtime.InteropServices;
 using Roslyn.Utilities;
 
+#if NET
+using System.Runtime.Loader;
+#endif
+
 namespace Microsoft.CodeAnalysis
 {
     internal sealed class DefaultAnalyzerAssemblyLoader : AnalyzerAssemblyLoader
@@ -57,12 +61,17 @@ protected override string PrepareSatelliteAssemblyToLoad(string assemblyFilePath
         /// </summary>
         /// <param name="windowsShadowPath">A shadow copy path will be created on Windows and this value 
         /// will be the base directory where shadow copy assemblies are stored. </param>
-        internal static IAnalyzerAssemblyLoaderInternal CreateNonLockingLoader(string windowsShadowPath, ImmutableArray<IAnalyzerAssemblyResolver>? externalResolvers = null)
+        internal static IAnalyzerAssemblyLoaderInternal CreateNonLockingLoader(
+#if NET
+            AssemblyLoadContext? loadContext,
+#endif
+            string windowsShadowPath,
+            ImmutableArray<IAnalyzerAssemblyResolver>? externalResolvers = null)
         {
 #if NETCOREAPP
             if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
             {
-                return new DefaultAnalyzerAssemblyLoader(loadOption: AnalyzerLoadOption.LoadFromStream, externalResolvers: externalResolvers);
+                return new DefaultAnalyzerAssemblyLoader(loadContext, loadOption: AnalyzerLoadOption.LoadFromStream, externalResolvers: externalResolvers);
             }
 #endif
 
@@ -74,7 +83,12 @@ internal static IAnalyzerAssemblyLoaderInternal CreateNonLockingLoader(string wi
                 throw new ArgumentException("Must be a full path.", nameof(windowsShadowPath));
             }
 
-            return new ShadowCopyAnalyzerAssemblyLoader(windowsShadowPath, externalResolvers);
+            return new ShadowCopyAnalyzerAssemblyLoader(
+#if NET
+                loadContext,
+#endif
+                windowsShadowPath,
+                externalResolvers);
         }
     }
 }

src/Compilers/Server/VBCSCompiler/CompilerRequestHandler.cs

@@ -72,7 +72,11 @@ internal CompilerServerHost(string clientDirectory, string? sdkDirectory, ICompi
             ClientDirectory = clientDirectory;
             SdkDirectory = sdkDirectory;
             Logger = logger;
-            AnalyzerAssemblyLoader = DefaultAnalyzerAssemblyLoader.CreateNonLockingLoader(Path.Combine(Path.GetTempPath(), "VBCSCompiler", "AnalyzerAssemblyLoader"));
+            AnalyzerAssemblyLoader = DefaultAnalyzerAssemblyLoader.CreateNonLockingLoader(
+#if NET
+                loadContext: null,
+#endif
+                Path.Combine(Path.GetTempPath(), "VBCSCompiler", "AnalyzerAssemblyLoader"));
         }
 
         public bool TryCreateCompiler(in RunRequest request, BuildPaths buildPaths, [NotNullWhen(true)] out CommonCompiler? compiler)

src/Compilers/Server/VBCSCompilerTests/AnalyzerConsistencyCheckerTests.cs

@@ -84,7 +84,11 @@ public void LoadLibraryWithMissingReference()
         {
             var directory = Temp.CreateDirectory();
             _ = directory.CopyFile(TestFixture.Alpha);
-            var assemblyLoader = DefaultAnalyzerAssemblyLoader.CreateNonLockingLoader(directory.CreateDirectory("shadow").Path);
+            var assemblyLoader = DefaultAnalyzerAssemblyLoader.CreateNonLockingLoader(
+#if NET
+                loadContext: null,
+#endif
+                directory.CreateDirectory("shadow").Path);
 
             var analyzerReferences = ImmutableArray.Create(new CommandLineAnalyzerReference("Alpha.dll"));
             var result = AnalyzerConsistencyChecker.Check(directory.Path, analyzerReferences, assemblyLoader, Logger);
@@ -95,7 +99,11 @@ public void LoadLibraryWithMissingReference()
         public void LoadLibraryAll()
         {
             var directory = Temp.CreateDirectory();
-            var assemblyLoader = DefaultAnalyzerAssemblyLoader.CreateNonLockingLoader(directory.CreateDirectory("shadow").Path);
+            var assemblyLoader = DefaultAnalyzerAssemblyLoader.CreateNonLockingLoader(
+#if NET
+                loadContext: null,
+#endif
+                directory.CreateDirectory("shadow").Path);
             var analyzerReferences = ImmutableArray.Create(
                 new CommandLineAnalyzerReference("Alpha.dll"),
                 new CommandLineAnalyzerReference("Beta.dll"),
@@ -110,7 +118,11 @@ public void LoadLibraryAll()
         public void DifferingMvidsDifferentDirectory()
         {
             var directory = Temp.CreateDirectory();
-            var assemblyLoader = DefaultAnalyzerAssemblyLoader.CreateNonLockingLoader(directory.CreateDirectory("shadow").Path);
+            var assemblyLoader = DefaultAnalyzerAssemblyLoader.CreateNonLockingLoader(
+#if NET
+                loadContext: null,
+#endif
+                directory.CreateDirectory("shadow").Path);
 
             var key = NetStandard20.References.netstandard.GetAssemblyIdentity().PublicKey;
             var mvidAlpha1 = CreateNetStandardDll(directory.CreateDirectory("mvid1"), "MvidAlpha", "1.0.0.0", key, "class C { }");
@@ -135,7 +147,11 @@ public void DifferingMvidsDifferentDirectory()
         public void DifferingMvidsSameDirectory()
         {
             var directory = Temp.CreateDirectory();
-            var assemblyLoader = DefaultAnalyzerAssemblyLoader.CreateNonLockingLoader(directory.CreateDirectory("shadow").Path);
+            var assemblyLoader = DefaultAnalyzerAssemblyLoader.CreateNonLockingLoader(
+#if NET
+                loadContext: null,
+#endif
+                directory.CreateDirectory("shadow").Path);
 
             var key = NetStandard20.References.netstandard.GetAssemblyIdentity().PublicKey;
             var mvidAlpha1 = CreateNetStandardDll(directory, "MvidAlpha", "1.0.0.0", key, "class C { }");

src/Compilers/Server/VBCSCompilerTests/TouchedFileLoggingTests.cs

@@ -46,7 +46,11 @@ End Class
         [ConditionalFact(typeof(DesktopOnly))]
         public void CSharpTrivialMetadataCaching()
         {
-            var loader = DefaultAnalyzerAssemblyLoader.CreateNonLockingLoader(Temp.CreateDirectory().Path);
+            var loader = DefaultAnalyzerAssemblyLoader.CreateNonLockingLoader(
+#if NET
+                loadContext: null,
+#endif
+                Temp.CreateDirectory().Path);
             var filelist = new List<string>();
 
             // Do the following compilation twice.
@@ -97,7 +101,11 @@ public void CSharpTrivialMetadataCaching()
         [ConditionalFact(typeof(DesktopOnly))]
         public void VisualBasicTrivialMetadataCaching()
         {
-            var loader = DefaultAnalyzerAssemblyLoader.CreateNonLockingLoader(Temp.CreateDirectory().Path);
+            var loader = DefaultAnalyzerAssemblyLoader.CreateNonLockingLoader(
+#if NET
+                loadContext: null,
+#endif
+                Temp.CreateDirectory().Path);
             var filelist = new List<string>();
 
             // Do the following compilation twice.

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

@@ -5,6 +5,7 @@
 using System.Collections.Immutable;
 using System.Composition;
 using System.Reflection;
+using System.Runtime.Loader;
 using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.LanguageServer.Services;
@@ -24,9 +25,10 @@ internal sealed class VSCodeAnalyzerLoaderProvider(
     private readonly ExtensionAssemblyManager _extensionAssemblyManager = extensionAssemblyManager;
     private readonly ILoggerFactory _loggerFactory = loggerFactory;
 
-    protected override IAnalyzerAssemblyLoader CreateShadowCopyLoader(ImmutableArray<IAnalyzerAssemblyResolver> externalResolvers)
+    protected override IAnalyzerAssemblyLoader CreateShadowCopyLoader(
+        AssemblyLoadContext? loadContext, string isolatedRoot)
     {
-        var baseLoader = base.CreateShadowCopyLoader(externalResolvers);
+        var baseLoader = base.CreateShadowCopyLoader(loadContext, isolatedRoot);
         return new VSCodeExtensionAssemblyAnalyzerLoader(baseLoader, _extensionAssemblyManager, _loggerFactory.CreateLogger<VSCodeExtensionAssemblyAnalyzerLoader>());
     }
 

src/LanguageServer/Protocol/Features/AbstractAnalyzerAssemblyLoaderProvider.cs

@@ -6,6 +6,10 @@
 using System.Collections.Immutable;
 using System.IO;
 
+#if NET
+using System.Runtime.Loader;
+#endif
+
 namespace Microsoft.CodeAnalysis.Host;
 
 /// <summary>
@@ -15,20 +19,47 @@ namespace Microsoft.CodeAnalysis.Host;
 internal abstract class AbstractAnalyzerAssemblyLoaderProvider : IAnalyzerAssemblyLoaderProvider
 {
     private readonly Lazy<IAnalyzerAssemblyLoader> _shadowCopyLoader;
+    private readonly ImmutableArray<IAnalyzerAssemblyResolver> _externalResolvers;
 
     public AbstractAnalyzerAssemblyLoaderProvider(ImmutableArray<IAnalyzerAssemblyResolver> externalResolvers)
     {
         // We use a lazy here in case creating the loader requires MEF imports in the derived constructor.
-        _shadowCopyLoader = new Lazy<IAnalyzerAssemblyLoader>(() => CreateShadowCopyLoader(externalResolvers));
+        _shadowCopyLoader = new Lazy<IAnalyzerAssemblyLoader>(() => CreateShadowCopyLoader(
+#if NET
+            loadContext: null,
+#endif
+            isolatedRoot: ""));
+        _externalResolvers = externalResolvers;
     }
 
-    public IAnalyzerAssemblyLoader GetShadowCopyLoader()
-        => _shadowCopyLoader.Value;
+    private static string GetPath(string isolatedRoot)
+        => Path.Combine(Path.GetTempPath(), "VS", "AnalyzerAssemblyLoader", isolatedRoot);
 
-    protected virtual IAnalyzerAssemblyLoader CreateShadowCopyLoader(ImmutableArray<IAnalyzerAssemblyResolver> externalResolvers)
+    protected virtual IAnalyzerAssemblyLoader CreateShadowCopyLoader(
+#if NET
+        AssemblyLoadContext? loadContext,
+#endif
+        string isolatedRoot)
     {
         return DefaultAnalyzerAssemblyLoader.CreateNonLockingLoader(
-            Path.Combine(Path.GetTempPath(), "VS", "AnalyzerAssemblyLoader"),
-            externalResolvers: externalResolvers);
+#if NET
+            loadContext,
+#endif
+            GetPath(isolatedRoot),
+            _externalResolvers);
     }
+
+#if NET
+
+    public IAnalyzerAssemblyLoader GetShadowCopyLoader(AssemblyLoadContext? loadContext, string isolatedRoot)
+        => loadContext is null && isolatedRoot == ""
+            ? _shadowCopyLoader.Value
+            : CreateShadowCopyLoader(loadContext, isolatedRoot);
+
+#else
+
+    public IAnalyzerAssemblyLoader GetShadowCopyLoader()
+        => _shadowCopyLoader.Value;
+
+#endif
 }

src/Workspaces/Core/Portable/Diagnostics/DefaultAnalyzerAssemblyLoaderService.cs

@@ -9,6 +9,10 @@
 using System.Collections.Immutable;
 using System.Collections.Generic;
 
+#if NET
+using System.Runtime.Loader;
+#endif
+
 namespace Microsoft.CodeAnalysis.Host;
 
 [ExportWorkspaceServiceFactory(typeof(IAnalyzerAssemblyLoaderProvider)), Shared]
@@ -31,10 +35,27 @@ private sealed class DefaultAnalyzerAssemblyLoaderProvider(string workspaceKind,
         /// correctness.  But it is annoying and does cause noise in our perf test harness.
         /// </summary>
         private readonly IAnalyzerAssemblyLoader _shadowCopyLoader = DefaultAnalyzerAssemblyLoader.CreateNonLockingLoader(
-            Path.Combine(Path.GetTempPath(), "CodeAnalysis", "WorkspacesAnalyzerShadowCopies", workspaceKind),
-            externalResolvers: externalResolvers);
+#if NET
+            loadContext: null,
+#endif
+            GetPath(workspaceKind, isolatedRoot: ""),
+            externalResolvers);
+
+        private static string GetPath(string workspaceKind, string isolatedRoot)
+            => Path.Combine(Path.GetTempPath(), "CodeAnalysis", "WorkspacesAnalyzerShadowCopies", workspaceKind, isolatedRoot);
+
+#if NET
+
+        public IAnalyzerAssemblyLoader GetShadowCopyLoader(AssemblyLoadContext? loadContext, string isolatedRoot)
+            => loadContext is null && isolatedRoot == ""
+                ? _shadowCopyLoader
+                : DefaultAnalyzerAssemblyLoader.CreateNonLockingLoader(loadContext, GetPath(workspaceKind, isolatedRoot));
+
+#else
 
         public IAnalyzerAssemblyLoader GetShadowCopyLoader()
             => _shadowCopyLoader;
+
+#endif
     }
 }

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

@@ -0,0 +1,43 @@
+// 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 Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Host;
+
+namespace Microsoft.CodeAnalysis.Serialization;
+
+internal partial class SerializerService
+{
+    /// <summary>
+    /// No methods on this serialized type should be called.  It exists as a placeholder to allow the data to be
+    /// transmitted from the host to the remote side.  On the remote side we will first collect *all* of these
+    /// serialized analyzer references, then create the actual <see cref="AnalyzerFileReference"/>s in their own safe
+    /// AssemblyLoadContext distinct from everything else.
+    /// </summary>
+    public sealed class SerializedAnalyzerReference(string fullPath) : AnalyzerReference
+    {
+        public override string FullPath { get; } = fullPath;
+
+        public override object Id
+            => throw new InvalidOperationException();
+
+        public override ImmutableArray<DiagnosticAnalyzer> GetAnalyzers(string language)
+            => throw new InvalidOperationException();
+
+        public override ImmutableArray<DiagnosticAnalyzer> GetAnalyzersForAllLanguages()
+            => throw new InvalidOperationException();
+
+        [Obsolete]
+        public override ImmutableArray<ISourceGenerator> GetGenerators()
+            => throw new InvalidOperationException();
+
+        public override ImmutableArray<ISourceGenerator> GetGenerators(string language)
+            => throw new InvalidOperationException();
+
+        public override ImmutableArray<ISourceGenerator> GetGeneratorsForAllLanguages()
+            => throw new InvalidOperationException();
+    }
+}

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

@@ -161,8 +161,10 @@ public virtual AnalyzerReference ReadAnalyzerReferenceFrom(ObjectReader reader,
         switch (reader.ReadString())
         {
             case nameof(AnalyzerFileReference):
-                var fullPath = reader.ReadRequiredString();
-                return new AnalyzerFileReference(fullPath, _analyzerLoaderProvider.GetShadowCopyLoader());
+                // Don't rehydrate an AnalyzerFileReference.  That will happen in
+                // RemoteWorkspace.CreateAnalyzerReferencesInIsolatedAssemblyLoadContextAsync when it sees the entire
+                // set of assembly references it wants to populate its solution with.
+                return new SerializedAnalyzerReference(reader.ReadRequiredString());
 
             case nameof(AnalyzerImageReference):
                 var guid = reader.ReadGuid();

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

@@ -2,9 +2,27 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using Microsoft.CodeAnalysis.Diagnostics;
+
+#if NET
+using System.Runtime.Loader;
+#endif
+
 namespace Microsoft.CodeAnalysis.Host;
 
 internal interface IAnalyzerAssemblyLoaderProvider : IWorkspaceService
 {
+#if NET
+    /// <summary>
+    /// In .Net core, gives back a shadow copying loader that will load all <see cref="AnalyzerReference"/> in the
+    /// requested <paramref name="loadContext"/> (or a default one if unspecified).  <paramref name="isolatedRoot"/> can
+    /// be used to ensure a dedicated directory for the shadow copying to happen in, to prevent any collisions
+    /// whatsoever.  For example, given two <see cref="AnalyzerReference"/>s with the same MVID, but loaded into
+    /// different <see cref="AssemblyLoadContext"/>s; different paths would be desired to prevent collisions.
+    /// </summary>
+    IAnalyzerAssemblyLoader GetShadowCopyLoader(AssemblyLoadContext? loadContext = null, string isolatedRoot = "");
+#else
+
     IAnalyzerAssemblyLoader GetShadowCopyLoader();
+#endif
 }