Simplify and unify assembly loader provider

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

@@ -57,7 +57,7 @@ public LanguageServerWorkspaceFactory(
     public async Task InitializeSolutionLevelAnalyzersAsync(ImmutableArray<string> analyzerPaths)
     {
         var references = new List<AnalyzerFileReference>();
-        var analyzerLoader = Workspace.Services.GetRequiredService<IAnalyzerAssemblyLoaderProvider>().GetShadowCopyLoader();
+        var analyzerLoader = Workspace.Services.GetRequiredService<IAnalyzerAssemblyLoaderProvider>().SharedShadowCopyLoader;
 
         foreach (var analyzerPath in analyzerPaths)
         {

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

@@ -2,7 +2,6 @@
 // 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 System.Composition;
 using System.Reflection;
 using Microsoft.CodeAnalysis.Host;
@@ -15,20 +14,14 @@ namespace Microsoft.CodeAnalysis.LanguageServer.HostWorkspace;
 [ExportWorkspaceService(typeof(IAnalyzerAssemblyLoaderProvider), [WorkspaceKind.Host]), Shared]
 [method: ImportingConstructor]
 [method: Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
-internal sealed class VSCodeAnalyzerLoaderProvider(
+internal sealed class VSCodeAnalyzerLoaderProviderFactory(
     ExtensionAssemblyManager extensionAssemblyManager,
     ILoggerFactory loggerFactory,
     [ImportMany] IEnumerable<IAnalyzerAssemblyResolver> externalResolvers)
-    : AbstractAnalyzerAssemblyLoaderProvider(externalResolvers.ToImmutableArray())
+    : AbstractAnalyzerAssemblyLoaderProvider(externalResolvers)
 {
-    private readonly ExtensionAssemblyManager _extensionAssemblyManager = extensionAssemblyManager;
-    private readonly ILoggerFactory _loggerFactory = loggerFactory;
-
-    protected override IAnalyzerAssemblyLoaderInternal CreateShadowCopyLoader(ImmutableArray<IAnalyzerAssemblyResolver> externalResolvers)
-    {
-        var baseLoader = base.CreateShadowCopyLoader(externalResolvers);
-        return new VSCodeExtensionAssemblyAnalyzerLoader(baseLoader, _extensionAssemblyManager, _loggerFactory.CreateLogger<VSCodeExtensionAssemblyAnalyzerLoader>());
-    }
+    protected override IAnalyzerAssemblyLoaderInternal WrapLoader(IAnalyzerAssemblyLoaderInternal baseLoader)
+        => new VSCodeExtensionAssemblyAnalyzerLoader(baseLoader, extensionAssemblyManager, loggerFactory.CreateLogger<VSCodeExtensionAssemblyAnalyzerLoader>());
 
     /// <summary>
     /// Analyzer loader that will re-use already loaded assemblies from the extension load context.

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

@@ -151,7 +151,7 @@ protected virtual AnalyzerReference ReadAnalyzerReferenceFrom(ObjectReader reade
         {
             case nameof(AnalyzerFileReference):
                 var fullPath = reader.ReadRequiredString();
-                return new AnalyzerFileReference(fullPath, _analyzerLoaderProvider.GetShadowCopyLoader());
+                return new AnalyzerFileReference(fullPath, _analyzerLoaderProvider.SharedShadowCopyLoader);
 
             case nameof(AnalyzerImageReference):
                 var guid = reader.ReadGuid();

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

@@ -2,9 +2,50 @@
 // 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.Generic;
+using System.Collections.Immutable;
+using System.Composition;
+using System.IO;
+using Microsoft.CodeAnalysis.Host.Mef;
+
 namespace Microsoft.CodeAnalysis.Host;
 
 internal interface IAnalyzerAssemblyLoaderProvider : IWorkspaceService
 {
-    IAnalyzerAssemblyLoaderInternal GetShadowCopyLoader();
+    IAnalyzerAssemblyLoaderInternal SharedShadowCopyLoader { get; }
 }
+
+/// <summary>
+/// Abstract implementation of an analyzer assembly loader that can be used by VS/VSCode to provide a <see
+/// cref="IAnalyzerAssemblyLoader"/> with an appropriate path.
+/// </summary>
+internal abstract class AbstractAnalyzerAssemblyLoaderProvider : IAnalyzerAssemblyLoaderProvider
+{
+    private readonly ImmutableArray<IAnalyzerAssemblyResolver> _externalResolvers;
+    private readonly Lazy<IAnalyzerAssemblyLoaderInternal> _shadowCopyLoader;
+
+    public AbstractAnalyzerAssemblyLoaderProvider(IEnumerable<IAnalyzerAssemblyResolver> externalResolvers)
+    {
+        _externalResolvers = externalResolvers.ToImmutableArray();
+        _shadowCopyLoader = new(CreateShadowCopyLoader);
+    }
+
+    public IAnalyzerAssemblyLoaderInternal SharedShadowCopyLoader
+        => _shadowCopyLoader.Value;
+
+    private IAnalyzerAssemblyLoaderInternal CreateShadowCopyLoader()
+        => this.WrapLoader(DefaultAnalyzerAssemblyLoader.CreateNonLockingLoader(
+                Path.Combine(Path.GetTempPath(), nameof(Roslyn), "AnalyzerAssemblyLoader"),
+                _externalResolvers));
+
+    protected virtual IAnalyzerAssemblyLoaderInternal WrapLoader(IAnalyzerAssemblyLoaderInternal loader)
+        => loader;
+}
+
+[ExportWorkspaceService(typeof(IAnalyzerAssemblyLoaderProvider)), Shared]
+[method: ImportingConstructor]
+[method: Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+internal sealed class DefaultAnalyzerAssemblyLoaderProvider(
+    [ImportMany] IEnumerable<IAnalyzerAssemblyResolver> externalResolvers)
+    : AbstractAnalyzerAssemblyLoaderProvider(externalResolvers);

src/Workspaces/Core/Portable/Workspace/ProjectSystem/ProjectSystemProject.cs

@@ -169,7 +169,7 @@ internal ProjectSystemProject(
         var provider = _projectSystemProjectFactory.SolutionServices.GetRequiredService<IAnalyzerAssemblyLoaderProvider>();
         // NOTE: The provider will always return the same singleton, shadow copying, analyzer loader instance, which is
         // important to ensure that analyzer dependencies are correctly loaded.
-        _analyzerAssemblyLoader = provider.GetShadowCopyLoader();
+        _analyzerAssemblyLoader = provider.SharedShadowCopyLoader;
 
         _sourceFiles = new BatchingDocumentCollection(
             this,
@@ -752,7 +752,7 @@ static ProjectUpdateState UpdateAnalyzerReferences(
                 projectUpdateState = projectUpdateState.WithIncrementalAnalyzerReferencesAdded(analyzersAddedInBatch);
 
                 var loaderProvider = solutionChanges.Solution.Services.GetRequiredService<IAnalyzerAssemblyLoaderProvider>();
-                var shadowCopyLoader = loaderProvider.GetShadowCopyLoader();
+                var shadowCopyLoader = loaderProvider.SharedShadowCopyLoader;
 
                 solutionChanges.UpdateSolutionForProjectAction(
                     projectId,

src/Workspaces/Core/Portable/Workspace/ProjectSystem/ProjectSystemProjectFactory.cs

@@ -847,7 +847,7 @@ private Task StartRefreshingAnalyzerReferenceForFileAsync(string fullFilePath, C
 
                 var project = solution.GetRequiredProject(projectId);
                 var oldAnalyzerReference = project.AnalyzerReferences.First(r => r.FullPath == oldReferenceFullPath);
-                var newAnalyzerReference = new AnalyzerFileReference(oldReferenceFullPath, assemblyLoaderProvider.GetShadowCopyLoader());
+                var newAnalyzerReference = new AnalyzerFileReference(oldReferenceFullPath, assemblyLoaderProvider.SharedShadowCopyLoader);
 
                 var newSolution = solution
                     .RemoveAnalyzerReference(projectId, oldAnalyzerReference)