Allow VS Code to provide razor source geneator references.

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

@@ -32,6 +32,7 @@ public static Task<ExportProvider> CreateExportProviderAsync(ILoggerFactory logg
             SessionId: null,
             ExtensionAssemblyPaths: [],
             DevKitDependencyPath: devKitDependencyPath,
+            DevKitRazorOutputPath: null,
             ExtensionLogDirectory: string.Empty);
         var extensionAssemblyManager = ExtensionAssemblyManager.Create(serverConfiguration, loggerFactory);
         return ExportProviderBuilder.CreateExportProviderAsync(extensionAssemblyManager, devKitDependencyPath, loggerFactory: loggerFactory);

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

@@ -3,15 +3,72 @@
 // See the LICENSE file in the project root for more information.
 
 using System.Collections.Immutable;
+using System.Reflection;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Workspaces.ProjectSystem;
+using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.LanguageServer.HostWorkspace;
 internal class HostDiagnosticAnalyzerProvider : IHostDiagnosticAnalyzerProvider
 {
+    /// <summary>
+    /// The directory where the analyzers are located
+    /// </summary>
+    public string? AnalyzerDirectory { get; set; }
+
+    private const string RazorVsixExtensionId = "Microsoft.VisualStudio.RazorExtension";
+    private static readonly HashSet<string> s_razorSourceGeneratorAssemblyNames = new[] {
+        "Microsoft.NET.Sdk.Razor.SourceGenerators",
+        "Microsoft.CodeAnalysis.Razor.Compiler.SourceGenerators",
+        "Microsoft.CodeAnalysis.Razor.Compiler",
+    }.ToHashSet<string>();
+
+    public HostDiagnosticAnalyzerProvider(string? analyzerDirectory)
+    {
+        AnalyzerDirectory = analyzerDirectory;
+    }
+
     public ImmutableArray<(AnalyzerFileReference reference, string extensionId)> GetAnalyzerReferencesInExtensions()
     {
-        // Right now we don't expose any way for the extensions in VS Code to provide analyzer references.
-        return ImmutableArray<(AnalyzerFileReference reference, string extensionId)>.Empty;
+        if (AnalyzerDirectory == null)
+        {
+            return ImmutableArray<(AnalyzerFileReference reference, string extensionId)>.Empty;
+        }
+
+        var analyzerReferences = new List<(AnalyzerFileReference, string)>();
+
+        // Get all the .dll files in the directory
+        var analyzerFiles = Directory.GetFiles(AnalyzerDirectory, "*.dll");
+
+        foreach (var analyzerFile in analyzerFiles)
+        {
+            // Create an AnalyzerFileReference for each file
+            var analyzerReference = new AnalyzerFileReference(analyzerFile, new SimpleAnalyzerAssemblyLoader());
+
+            if (s_razorSourceGeneratorAssemblyNames.Any(
+                name => analyzerReference.FullPath.Contains(name, StringComparison.OrdinalIgnoreCase)))
+            {
+                // Add the reference to the list, using the file name as the extension ID
+                analyzerReferences.Add((analyzerReference, RazorVsixExtensionId));
+            }
+        }
+
+        return analyzerReferences.ToImmutableArray();
+    }
+
+    private class SimpleAnalyzerAssemblyLoader : IAnalyzerAssemblyLoader
+    {
+        public void AddDependencyLocation(string fullPath)
+        {
+            // This method is used to add a path that should be probed for analyzer dependencies.
+            // In this simple implementation, we do nothing.
+        }
+
+        public Assembly LoadFromPath(string fullPath)
+        {
+            // This method is used to load an analyzer assembly from the specified path.
+            // In this simple implementation, we use Assembly.LoadFrom to load the assembly.
+            return Assembly.LoadFrom(fullPath);
+        }
     }
 }

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

@@ -29,6 +29,7 @@ public LanguageServerWorkspaceFactory(
         IFileChangeWatcher fileChangeWatcher,
         [ImportMany] IEnumerable<Lazy<IDynamicFileInfoProvider, Host.Mef.FileExtensionsMetadata>> dynamicFileInfoProviders,
         ProjectTargetFrameworkManager projectTargetFrameworkManager,
+        ServerConfigurationFactory serverConfigurationFactory,
         ILoggerFactory loggerFactory)
     {
         _logger = loggerFactory.CreateLogger(nameof(LanguageServerWorkspaceFactory));
@@ -40,10 +41,11 @@ public LanguageServerWorkspaceFactory(
 
         analyzerLoader.InitializeDiagnosticsServices(Workspace);
 
+        var devKitRazorOutputPath = serverConfigurationFactory?.ServerConfiguration?.DevKitRazorOutputPath;
         ProjectSystemHostInfo = new ProjectSystemHostInfo(
             DynamicFileInfoProviders: dynamicFileInfoProviders.ToImmutableArray(),
             new ProjectSystemDiagnosticSource(),
-            new HostDiagnosticAnalyzerProvider());
+            new HostDiagnosticAnalyzerProvider(devKitRazorOutputPath));
 
         TargetFrameworkManager = projectTargetFrameworkManager;
     }

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

@@ -198,6 +198,12 @@ static CliRootCommand CreateCommandLineParser()
         Required = false
     };
 
+    var devKitRazorOutputPathOption = new CliOption<string?>("--devKitRazorOutputPath")
+    {
+        Description = "Full path to the Razor output path used with DevKit (optional).",
+        Required = false
+    };
+
     var rootCommand = new CliRootCommand()
     {
         debugOption,
@@ -208,6 +214,7 @@ static CliRootCommand CreateCommandLineParser()
         sessionIdOption,
         extensionAssemblyPathsOption,
         devKitDependencyPathOption,
+        devKitRazorOutputPathOption,
         extensionLogDirectoryOption
     };
     rootCommand.SetAction((parseResult, cancellationToken) =>
@@ -219,6 +226,7 @@ static CliRootCommand CreateCommandLineParser()
         var sessionId = parseResult.GetValue(sessionIdOption);
         var extensionAssemblyPaths = parseResult.GetValue(extensionAssemblyPathsOption) ?? [];
         var devKitDependencyPath = parseResult.GetValue(devKitDependencyPathOption);
+        var devKitRazorOutputPath = parseResult.GetValue(devKitRazorOutputPathOption);
         var extensionLogDirectory = parseResult.GetValue(extensionLogDirectoryOption)!;
 
         var serverConfiguration = new ServerConfiguration(
@@ -229,6 +237,7 @@ static CliRootCommand CreateCommandLineParser()
             SessionId: sessionId,
             ExtensionAssemblyPaths: extensionAssemblyPaths,
             DevKitDependencyPath: devKitDependencyPath,
+            DevKitRazorOutputPath: devKitRazorOutputPath,
             ExtensionLogDirectory: extensionLogDirectory);
 
         return RunAsync(serverConfiguration, cancellationToken);

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

@@ -49,4 +49,5 @@ internal record class ServerConfiguration(
     string? SessionId,
     IEnumerable<string> ExtensionAssemblyPaths,
     string? DevKitDependencyPath,
+    string? DevKitRazorOutputPath,
     string ExtensionLogDirectory);

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

@@ -1002,6 +1002,7 @@ public void RemoveAnalyzerReference(string fullPath)
 
     private OneOrMany<string> GetMappedAnalyzerPaths(string fullPath)
     {
+        fullPath = Path.GetFullPath(fullPath);
         // Map all files in the SDK directory that contains the Razor source generator to source generator files loaded from VSIX.
         // Include the generator and all its dependencies shipped in VSIX, discard the generator and all dependencies in the SDK
         if (fullPath.LastIndexOf(s_razorSourceGeneratorSdkDirectory, StringComparison.OrdinalIgnoreCase) + s_razorSourceGeneratorSdkDirectory.Length - 1 ==