Razor assembly redirector (#78852)

* Implement razor redirection as an assembly redirector
- Remove the special casing for razor in projectsystemproject
- Remove HostDiagnosticAnalyzerProvider as it is no longer needed
- Add an EA redirector that razor can implement
- MEF import the redirectors where needed
- Remove RazorSourceGenerator option from language server

* Remove test that is no longer valid

* Restore razorSourceGeneratorOption:
- The VS Code C# extension is still passing the argument and we error if we get an unrecognized option. We can remove this once we update the C# side.

* Fix redirect message

Author: chsienki

src/Compilers/Core/Portable/CodeAnalysisEventSource.Common.cs

@@ -125,7 +125,7 @@ internal unsafe void NodeTransform(int nodeHashCode, string name, string tableTy
         [Event(16, Message = "Analyzer reference '{0}' was removed from project '{1}'", Keywords = Keywords.AnalyzerLoading, Level = EventLevel.Informational)]
         internal void AnalyzerReferenceRemovedFromProject(string path, string projectName) => WriteEvent(16, path, projectName);
 
-        [Event(17, Message = "Analyzer reference was redirected by '{0}' from '{1}' to '{2}' for project '{3}'", Keywords = Keywords.AnalyzerLoading, Level = EventLevel.Verbose, Task = Tasks.BuildStateTable)]
+        [Event(17, Message = "Analyzer reference was redirected by '{0}' from '{1}' to '{2}' for project '{3}'", Keywords = Keywords.AnalyzerLoading, Level = EventLevel.Informational)]
         internal unsafe void AnanlyzerReferenceRedirected(string redirectorType, string originalPath, string newPath, string project)
         {
             if (IsEnabled())

src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/LanguageServerTestComposition.cs

@@ -24,7 +24,6 @@ internal sealed class LanguageServerTestComposition
             SessionId: null,
             ExtensionAssemblyPaths: extensionPaths ?? [],
             DevKitDependencyPath: devKitDependencyPath,
-            RazorSourceGenerator: null,
             RazorDesignTimePath: null,
             ExtensionLogDirectory: string.Empty,
             ServerPipeName: null,

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

@@ -10,6 +10,7 @@
 using Microsoft.CodeAnalysis.LanguageServer.Handler.DebugConfiguration;
 using Microsoft.CodeAnalysis.LanguageServer.Services;
 using Microsoft.CodeAnalysis.ProjectSystem;
+using Microsoft.CodeAnalysis.Workspaces.AnalyzerRedirecting;
 using Microsoft.CodeAnalysis.Workspaces.ProjectSystem;
 using Microsoft.Extensions.Logging;
 using Microsoft.VisualStudio.Composition;
@@ -30,8 +31,8 @@ public LanguageServerWorkspaceFactory(
         IFileChangeWatcher fileChangeWatcher,
         [ImportMany] IEnumerable<Lazy<IDynamicFileInfoProvider, FileExtensionsMetadata>> dynamicFileInfoProviders,
         ProjectTargetFrameworkManager projectTargetFrameworkManager,
-        ServerConfigurationFactory serverConfigurationFactory,
         ExtensionAssemblyManager extensionManager,
+        [ImportMany] IEnumerable<IAnalyzerAssemblyRedirector> assemblyRedirectors,
         ILoggerFactory loggerFactory)
     {
         _logger = loggerFactory.CreateLogger(nameof(LanguageServerWorkspaceFactory));
@@ -62,11 +63,9 @@ public LanguageServerWorkspaceFactory(
             fileBasedProgramsWorkspace, fileChangeWatcher, static (_, _) => Task.CompletedTask, _ => { }, CancellationToken.None);
         fileBasedProgramsWorkspace.ProjectSystemProjectFactory = FileBasedProgramsProjectFactory;
 
-        var razorSourceGenerator = serverConfigurationFactory?.ServerConfiguration?.RazorSourceGenerator;
         ProjectSystemHostInfo = new ProjectSystemHostInfo(
             DynamicFileInfoProviders: [.. dynamicFileInfoProviders],
-            new HostDiagnosticAnalyzerProvider(razorSourceGenerator),
-            AnalyzerAssemblyRedirectors: []);
+            AnalyzerAssemblyRedirectors: [.. assemblyRedirectors]);
 
         TargetFrameworkManager = projectTargetFrameworkManager;
     }

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

@@ -273,7 +273,6 @@ static CommandLineConfiguration CreateCommandLineParser()
         var sessionId = parseResult.GetValue(sessionIdOption);
         var extensionAssemblyPaths = parseResult.GetValue(extensionAssemblyPathsOption) ?? [];
         var devKitDependencyPath = parseResult.GetValue(devKitDependencyPathOption);
-        var razorSourceGenerator = parseResult.GetValue(razorSourceGeneratorOption);
         var razorDesignTimePath = parseResult.GetValue(razorDesignTimePathOption);
         var extensionLogDirectory = parseResult.GetValue(extensionLogDirectoryOption)!;
         var serverPipeName = parseResult.GetValue(serverPipeNameOption);
@@ -287,7 +286,6 @@ static CommandLineConfiguration CreateCommandLineParser()
             SessionId: sessionId,
             ExtensionAssemblyPaths: extensionAssemblyPaths,
             DevKitDependencyPath: devKitDependencyPath,
-            RazorSourceGenerator: razorSourceGenerator,
             RazorDesignTimePath: razorDesignTimePath,
             ServerPipeName: serverPipeName,
             UseStdIo: useStdIo,

src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/Program.cs

@@ -48,7 +48,6 @@ internal sealed record class ServerConfiguration(
     string? SessionId,
     IEnumerable<string> ExtensionAssemblyPaths,
     string? DevKitDependencyPath,
-    string? RazorSourceGenerator,
     string? RazorDesignTimePath,
     string? ServerPipeName,
     bool UseStdIo,

src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/ServerConfigurationFactory.cs

@@ -0,0 +1,23 @@
+// 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.Composition;
+using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.CodeAnalysis.Workspaces.AnalyzerRedirecting;
+
+namespace Microsoft.CodeAnalysis.ExternalAccess.Razor;
+
+[Export(typeof(IAnalyzerAssemblyRedirector)), Shared]
+[method: ImportingConstructor]
+[method: Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+internal sealed class RazorAnalyzerAssemblyRedirector([Import(AllowDefault = true)] RazorAnalyzerAssemblyRedirector.IRazorAnalyzerAssemblyRedirector? razorRedirector = null) : IAnalyzerAssemblyRedirector
+{
+    public string? RedirectPath(string fullPath) => razorRedirector?.RedirectPath(fullPath);
+
+    internal interface IRazorAnalyzerAssemblyRedirector
+    {
+        string? RedirectPath(string fullPath);
+    }
+}

src/Tools/ExternalAccess/Razor/Features/RazorAnalyzerAssemblyRedirector.cs

@@ -18,7 +18,7 @@ namespace Microsoft.VisualStudio.LanguageServices.Implementation.Diagnostics;
 /// This service provides diagnostic analyzers from the analyzer assets specified in the manifest files of installed VSIX extensions.
 /// These analyzers are used across this workspace session.
 /// </summary>
-internal sealed partial class VisualStudioDiagnosticAnalyzerProvider : IHostDiagnosticAnalyzerProvider
+internal sealed partial class VisualStudioDiagnosticAnalyzerProvider
 {
     private const string AnalyzerContentTypeName = "Microsoft.VisualStudio.Analyzer";
 
@@ -33,7 +33,6 @@ internal sealed partial class VisualStudioDiagnosticAnalyzerProvider : IHostDiag
     private readonly Type _typeIExtensionContent;
 
     private readonly Lazy<ImmutableArray<(AnalyzerFileReference reference, string extensionId)>> _lazyAnalyzerReferences;
-    private readonly Lazy<ImmutableArray<(string path, string extensionId)>> _lazyRazorReferences;
 
     // internal for testing
     internal VisualStudioDiagnosticAnalyzerProvider(object extensionManager, Type typeIExtensionContent)
@@ -44,15 +43,11 @@ internal VisualStudioDiagnosticAnalyzerProvider(object extensionManager, Type ty
         _extensionManager = extensionManager;
         _typeIExtensionContent = typeIExtensionContent;
         _lazyAnalyzerReferences = new Lazy<ImmutableArray<(AnalyzerFileReference, string)>>(() => GetExtensionContent(AnalyzerContentTypeName).SelectAsArray(c => (new AnalyzerFileReference(c.path, AnalyzerAssemblyLoader), c.extensionId)));
-        _lazyRazorReferences = new Lazy<ImmutableArray<(string, string)>>(() => GetExtensionContent(RazorContentTypeName));
     }
 
     public ImmutableArray<(AnalyzerFileReference reference, string extensionId)> GetAnalyzerReferencesInExtensions()
         => _lazyAnalyzerReferences.Value;
 
-    public ImmutableArray<(string path, string extensionId)> GetRazorAssembliesInExtensions()
-        => _lazyRazorReferences.Value;
-
     private ImmutableArray<(string path, string extensionId)> GetExtensionContent(string contentTypeName)
     {
         try

src/VisualStudio/Core/Def/Diagnostics/VisualStudioDiagnosticAnalyzerProvider.cs

@@ -34,26 +34,23 @@ internal sealed class VisualStudioProjectFactory : IVsTypeScriptVisualStudioProj
     private readonly IThreadingContext _threadingContext;
     private readonly VisualStudioWorkspaceImpl _visualStudioWorkspaceImpl;
     private readonly ImmutableArray<Lazy<IDynamicFileInfoProvider, FileExtensionsMetadata>> _dynamicFileInfoProviders;
-    private readonly IVisualStudioDiagnosticAnalyzerProviderFactory _vsixAnalyzerProviderFactory;
     private readonly ImmutableArray<IAnalyzerAssemblyRedirector> _analyzerAssemblyRedirectors;
     private readonly IVsService<SVsBackgroundSolution, IVsBackgroundSolution> _solution;
 
-    private readonly JoinableTask<VisualStudioDiagnosticAnalyzerProvider> _initializationTask;
+    private readonly JoinableTask _initializationTask;
 
     [ImportingConstructor]
     [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
     public VisualStudioProjectFactory(
         IThreadingContext threadingContext,
         VisualStudioWorkspaceImpl visualStudioWorkspaceImpl,
         [ImportMany] IEnumerable<Lazy<IDynamicFileInfoProvider, FileExtensionsMetadata>> fileInfoProviders,
-        IVisualStudioDiagnosticAnalyzerProviderFactory vsixAnalyzerProviderFactory,
         [ImportMany] IEnumerable<IAnalyzerAssemblyRedirector> analyzerAssemblyRedirectors,
         IVsService<SVsBackgroundSolution, IVsBackgroundSolution> solution)
     {
         _threadingContext = threadingContext;
         _visualStudioWorkspaceImpl = visualStudioWorkspaceImpl;
         _dynamicFileInfoProviders = fileInfoProviders.AsImmutableOrEmpty();
-        _vsixAnalyzerProviderFactory = vsixAnalyzerProviderFactory;
         _analyzerAssemblyRedirectors = analyzerAssemblyRedirectors.AsImmutableOrEmpty();
         _solution = solution;
 
@@ -72,8 +69,6 @@ public VisualStudioProjectFactory(
 
                 _visualStudioWorkspaceImpl.SubscribeExternalErrorDiagnosticUpdateSourceToSolutionBuildEvents();
                 _visualStudioWorkspaceImpl.SubscribeToSourceGeneratorImpactingEvents();
-
-                return await _vsixAnalyzerProviderFactory.GetOrCreateProviderAsync(cancellationToken).ConfigureAwait(true);
             });
     }
 
@@ -83,7 +78,7 @@ public Task<ProjectSystemProject> CreateAndAddToWorkspaceAsync(string projectSys
     public async Task<ProjectSystemProject> CreateAndAddToWorkspaceAsync(
         string projectSystemName, string language, VisualStudioProjectCreationInfo creationInfo, CancellationToken cancellationToken)
     {
-        var vsixAnalyzerProvider = await _initializationTask.JoinAsync(cancellationToken).ConfigureAwait(false);
+        await _initializationTask.JoinAsync(cancellationToken).ConfigureAwait(false);
 
         // The rest of this method can be ran off the UI thread. We'll only switch though if the UI thread isn't already blocked -- the legacy project
         // system creates project synchronously, and during solution load we've seen traces where the thread pool is sufficiently saturated that this
@@ -102,7 +97,7 @@ public async Task<ProjectSystemProject> CreateAndAddToWorkspaceAsync(
         _visualStudioWorkspaceImpl.ProjectSystemProjectFactory.SolutionPath = solution?.SolutionFileName;
         _visualStudioWorkspaceImpl.ProjectSystemProjectFactory.SolutionTelemetryId = GetSolutionSessionId();
 
-        var hostInfo = new ProjectSystemHostInfo(_dynamicFileInfoProviders, vsixAnalyzerProvider, _analyzerAssemblyRedirectors);
+        var hostInfo = new ProjectSystemHostInfo(_dynamicFileInfoProviders, _analyzerAssemblyRedirectors);
         var project = await _visualStudioWorkspaceImpl.ProjectSystemProjectFactory.CreateAndAddToWorkspaceAsync(projectSystemName, language, creationInfo, hostInfo).ConfigureAwait(true);
 
         _visualStudioWorkspaceImpl.AddProjectToInternalMaps(project, creationInfo.Hierarchy, creationInfo.ProjectGuid, projectSystemName);

src/VisualStudio/Core/Def/ProjectSystem/VisualStudioProjectFactory.cs

@@ -61,20 +61,5 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests.Diagnostics
             End Using
         End Sub
 
-        <Fact>
-        Public Sub GetRazorReferencesInExtensions()
-            Dim extensionManager = New VisualStudioDiagnosticAnalyzerProvider(
-                New MockExtensionManager({({"razorPath1", "razorPath2"}, "RazorVsix")}, contentType:="Microsoft.VisualStudio.RazorAssembly"),
-                GetType(MockExtensionManager.MockContent))
-
-            Dim references = extensionManager.GetRazorAssembliesInExtensions()
-
-            AssertEx.SetEqual(
-            {
-                Path.Combine(TempRoot.Root, "InstallPath\razorPath1"),
-                Path.Combine(TempRoot.Root, "InstallPath\razorPath2")
-            },
-            references.Select(Function(pathAndId) pathAndId.path))
-        End Sub
     End Class
 End Namespace