Allow Razor to hook up the source generator in misc files (#79891)

Part of dotnet/vscode-csharp#8512
Tracked by dotnet/razor#9519 and
dotnet/razor#11833

This removes the `isRazor` hackiness in misc files, and allows Razor to
provide a source generator reference to the project. Needs work on Razor
not just to implement the service, which is trivial, but because the
source generator doesn't actually support misc files at the moment :)

Author: davidwengier

src/Features/Core/Portable/Workspace/IMiscellaneousProjectInfoService.cs

@@ -0,0 +1,17 @@
+// 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.Collections.Generic;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Host;
+
+namespace Microsoft.CodeAnalysis.Features.Workspaces;
+
+internal interface IMiscellaneousProjectInfoService : ILanguageService
+{
+    string ProjectLanguageOverride { get; }
+    bool AddAsAdditionalDocument { get; }
+
+    IEnumerable<AnalyzerReference>? GetAnalyzerReferences(SolutionServices services);
+}

src/Features/Core/Portable/Workspace/MiscellaneousFileUtilities.cs

@@ -27,11 +27,18 @@ internal static ProjectInfo CreateMiscellaneousProjectInfoForDocument(
         var fileExtension = PathUtilities.GetExtension(filePath);
         var fileName = PathUtilities.GetFileName(filePath);
 
-        // For Razor files we need to override the language name to C# as thats what code is generated
-        var isRazor = languageInformation.LanguageName == "Razor";
-        var languageName = isRazor ? LanguageNames.CSharp : languageInformation.LanguageName;
-
+        var languageName = languageInformation.LanguageName;
         var languageServices = services.GetLanguageServices(languageName);
+        var miscellaneousProjectInfoService = languageServices.GetService<IMiscellaneousProjectInfoService>();
+
+        if (miscellaneousProjectInfoService is not null)
+        {
+            // The MiscellaneousProjectInfoService can override the language name to use for the project, and therefore we have to re-get
+            // the right set of language services.
+            languageName = miscellaneousProjectInfoService.ProjectLanguageOverride;
+            languageServices = services.GetLanguageServices(languageName);
+        }
+
         var compilationOptions = languageServices.GetService<ICompilationFactoryService>()?.GetDefaultCompilationOptions();
 
         // Use latest language version which is more permissive, as we cannot find out language version of the project which the file belongs to
@@ -67,6 +74,7 @@ internal static ProjectInfo CreateMiscellaneousProjectInfoForDocument(
         // a random GUID can be used.
         var assemblyName = Guid.NewGuid().ToString("N");
 
+        var addAsAdditionalDocument = miscellaneousProjectInfoService?.AddAsAdditionalDocument ?? false;
         var projectInfo = ProjectInfo.Create(
             new ProjectInfo.ProjectAttributes(
                 id: projectId,
@@ -81,9 +89,10 @@ internal static ProjectInfo CreateMiscellaneousProjectInfoForDocument(
                 hasAllInformation: sourceCodeKind == SourceCodeKind.Script),
             compilationOptions: compilationOptions,
             parseOptions: parseOptions,
-            documents: isRazor ? null : [documentInfo],
-            additionalDocuments: isRazor ? [documentInfo] : null,
-            metadataReferences: metadataReferences);
+            documents: addAsAdditionalDocument ? null : [documentInfo],
+            additionalDocuments: addAsAdditionalDocument ? [documentInfo] : null,
+            metadataReferences: metadataReferences,
+            analyzerReferences: miscellaneousProjectInfoService?.GetAnalyzerReferences(services));
 
         return projectInfo;
     }

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

@@ -11,7 +11,7 @@
 
 namespace Microsoft.CodeAnalysis.LanguageServer.HostWorkspace;
 
-[ExportWorkspaceService(typeof(IAnalyzerAssemblyLoaderProvider), [WorkspaceKind.Host]), Shared]
+[ExportWorkspaceService(typeof(IAnalyzerAssemblyLoaderProvider), [WorkspaceKind.Host, WorkspaceKind.MiscellaneousFiles]), Shared]
 [method: ImportingConstructor]
 [method: Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
 internal sealed class VSCodeAnalyzerLoaderProviderFactory(

src/LanguageServer/Protocol.TestUtilities/AbstractLspMiscellaneousFilesWorkspaceTests.cs

@@ -2,14 +2,19 @@
 // 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.Composition;
 using System.IO;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Features.Workspaces;
 using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.CodeAnalysis.Test.Utilities;
-using Microsoft.CodeAnalysis.Text;
 using Roslyn.LanguageServer.Protocol;
 using Roslyn.Test.Utilities;
 using Xunit;
@@ -178,8 +183,10 @@ void M()
     [Theory, CombinatorialData]
     public async Task TestLooseFile_RazorFile(bool mutatingLspWorkspace)
     {
+        var composition = Composition.AddParts(typeof(TestRazorMiscellaneousProjectInfoService));
+
         // Create a server that supports LSP misc files and verify no misc files present.
-        await using var testLspServer = await CreateTestLspServerAsync(string.Empty, mutatingLspWorkspace, new InitializationOptions { ServerKind = WellKnownLspServerKinds.CSharpVisualBasicLspServer });
+        await using var testLspServer = await CreateTestLspServerAsync(string.Empty, mutatingLspWorkspace, new InitializationOptions { ServerKind = WellKnownLspServerKinds.CSharpVisualBasicLspServer }, composition);
         Assert.Null(await GetMiscellaneousDocumentAsync(testLspServer));
         Assert.Null(await GetMiscellaneousAdditionalDocumentAsync(testLspServer));
 
@@ -397,4 +404,17 @@ private async Task AssertFileInMainWorkspaceAsync(TestLspServer testLspServer, D
         Contract.ThrowIfNull(result);
         return result;
     }
+
+    // This is a test version of the real service which lives in the Razor EA, which is not referenced here
+    [PartNotDiscoverable]
+    [ExportLanguageService(typeof(IMiscellaneousProjectInfoService), "Razor"), Shared]
+    [method: ImportingConstructor]
+    [method: Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+    private sealed class TestRazorMiscellaneousProjectInfoService() : IMiscellaneousProjectInfoService
+    {
+        public string ProjectLanguageOverride => LanguageNames.CSharp;
+        public bool AddAsAdditionalDocument => true;
+
+        public IEnumerable<AnalyzerReference>? GetAnalyzerReferences(SolutionServices services) => null;
+    }
 }

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

@@ -0,0 +1,10 @@
+// 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.
+
+namespace Microsoft.CodeAnalysis.ExternalAccess.Razor.Features;
+
+internal interface IRazorSourceGeneratorLocator
+{
+    string GetGeneratorFilePath();
+}

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

@@ -0,0 +1,38 @@
+// 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.Generic;
+using System.Composition;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Features.Workspaces;
+using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.Host.Mef;
+
+namespace Microsoft.CodeAnalysis.ExternalAccess.Razor.Features;
+
+[Shared]
+[ExportLanguageService(typeof(IMiscellaneousProjectInfoService), Constants.RazorLanguageName)]
+[method: ImportingConstructor]
+[method: Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+internal sealed class RazorMiscellaneousProjectInfoService([Import(AllowDefault = true)] Lazy<IRazorSourceGeneratorLocator>? razorSourceGeneratorLocator) : IMiscellaneousProjectInfoService
+{
+    public string ProjectLanguageOverride => LanguageNames.CSharp;
+
+    public bool AddAsAdditionalDocument => true;
+
+    public IEnumerable<AnalyzerReference>? GetAnalyzerReferences(Host.SolutionServices services)
+    {
+        if (razorSourceGeneratorLocator is null)
+        {
+            return null;
+        }
+
+        var filePath = razorSourceGeneratorLocator.Value.GetGeneratorFilePath();
+        var loaderProvider = services.GetRequiredService<IAnalyzerAssemblyLoaderProvider>();
+        var reference = new AnalyzerFileReference(filePath, loaderProvider.SharedShadowCopyLoader);
+
+        return [reference];
+    }
+}