Invoke dotnet run-api to obtain virtual project

src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/VirtualProjectXmlProviderTests.cs

@@ -0,0 +1,189 @@
+// 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.
+
+// Uncomment this to test run-api locally.
+// Eventually when a new enough SDK is adopted in-repo we can remove this
+//#define RoslynTestRunApi
+
+using System.Text;
+using System.Text.RegularExpressions;
+using Microsoft.CodeAnalysis.LanguageServer.FileBasedPrograms;
+using Microsoft.Extensions.Logging;
+using Roslyn.LanguageServer.Protocol;
+using Roslyn.Test.Utilities;
+using Xunit.Abstractions;
+
+namespace Microsoft.CodeAnalysis.LanguageServer.UnitTests;
+
+/// <summary>
+/// Goal of these tests:
+/// - Ensure that the various request/response forms work as expected in basic scenarios.
+/// - Ensure that various properties on the response are populated in a reasonable way.
+/// Non-goals:
+/// - Thorough behavioral testing.
+/// - Testing of more intricate behaviors which are subject to change.
+/// </summary>
+public sealed class VirtualProjectXmlProviderTests : AbstractLanguageServerHostTests
+{
+    public VirtualProjectXmlProviderTests(ITestOutputHelper testOutputHelper) : base(testOutputHelper)
+    {
+    }
+
+    private class EnableRunApiTests : ExecutionCondition
+    {
+        public override bool ShouldSkip =>
+#if RoslynTestRunApi
+            false;
+#else
+            true;
+#endif
+
+        public override string SkipReason => $"Compilation symbol 'RoslynTestRunApi' is not defined.";
+    }
+
+    private async Task<VirtualProjectXmlProvider> GetProjectXmlProviderAsync()
+    {
+        var (exportProvider, _) = await LanguageServerTestComposition.CreateExportProviderAsync(
+            LoggerFactory, includeDevKitComponents: false, MefCacheDirectory.Path, extensionPaths: null);
+        return exportProvider.GetExportedValue<VirtualProjectXmlProvider>();
+    }
+
+    [Fact]
+    public async Task GetProjectXml_FileBasedProgram_SdkTooOld_01()
+    {
+        var projectProvider = await GetProjectXmlProviderAsync();
+
+        var tempDir = TempRoot.CreateDirectory();
+        var appFile = tempDir.CreateFile("app.cs");
+        await appFile.WriteAllTextAsync("""
+            Console.WriteLine("Hello, world!");
+            """);
+
+        var globalJsonFile = tempDir.CreateFile("global.json");
+        globalJsonFile.WriteAllBytes(Encoding.UTF8.GetBytes("""
+            {
+              "sdk": {
+                "version": "9.0.105"
+              }
+            }
+            """));
+
+        var contentNullable = await projectProvider.GetVirtualProjectContentAsync(appFile.Path, CancellationToken.None);
+        Assert.Null(contentNullable);
+    }
+
+    [ConditionalFact(typeof(EnableRunApiTests))]
+    public async Task GetProjectXml_FileBasedProgram_01()
+    {
+        var projectProvider = await GetProjectXmlProviderAsync();
+
+        var tempDir = TempRoot.CreateDirectory();
+        var appFile = tempDir.CreateFile("app.cs");
+        await appFile.WriteAllTextAsync("""
+            Console.WriteLine("Hello, world!");
+            """);
+
+        var globalJsonFile = tempDir.CreateFile("global.json");
+        await globalJsonFile.WriteAllTextAsync("""
+            {
+              "sdk": {
+                "version": "10.0.100-preview.5.25265.12"
+              }
+            }
+            """);
+
+        var contentNullable = await projectProvider.GetVirtualProjectContentAsync(appFile.Path, CancellationToken.None);
+        var content = contentNullable.Value;
+        var virtualProjectXml = content.VirtualProjectXml;
+        LoggerFactory.CreateLogger<VirtualProjectXmlProviderTests>().LogTrace(virtualProjectXml);
+
+        Assert.Contains("<TargetFramework>net10.0</TargetFramework>", virtualProjectXml);
+        Assert.Contains("<ArtifactsPath>", virtualProjectXml);
+        Assert.Empty(content.Diagnostics);
+    }
+
+    [ConditionalFact(typeof(EnableRunApiTests))]
+    public async Task GetProjectXml_NonFileBasedProgram_01()
+    {
+        var projectProvider = await GetProjectXmlProviderAsync();
+
+        var tempDir = TempRoot.CreateDirectory();
+        var appFile = tempDir.CreateFile("app.cs");
+        await appFile.WriteAllTextAsync("""
+            public class C
+            {
+            }
+            """);
+
+        var globalJsonFile = tempDir.CreateFile("global.json");
+        await globalJsonFile.WriteAllTextAsync("""
+            {
+              "sdk": {
+                "version": "10.0.100-preview.5.25265.12"
+              }
+            }
+            """);
+
+        var contentNullable = await projectProvider.GetVirtualProjectContentAsync(appFile.Path, CancellationToken.None);
+        var content = contentNullable.Value;
+        LoggerFactory.CreateLogger<VirtualProjectXmlProviderTests>().LogTrace(content.VirtualProjectXml);
+
+        Assert.Contains("<TargetFramework>net10.0</TargetFramework>", content.VirtualProjectXml);
+        Assert.Contains("<ArtifactsPath>", content.VirtualProjectXml);
+        Assert.Empty(content.Diagnostics);
+    }
+
+    [ConditionalFact(typeof(EnableRunApiTests))]
+    public async Task GetProjectXml_BadPath_01()
+    {
+        var projectProvider = await GetProjectXmlProviderAsync();
+
+        var tempDir = TempRoot.CreateDirectory();
+
+        var globalJsonFile = tempDir.CreateFile("global.json");
+        await globalJsonFile.WriteAllTextAsync("""
+            {
+              "sdk": {
+                "version": "10.0.100-preview.5.25265.12"
+              }
+            }
+            """);
+
+        var content = await projectProvider.GetVirtualProjectContentAsync(Path.Combine(tempDir.Path, "BAD"), CancellationToken.None);
+        Assert.Null(content);
+    }
+
+    [ConditionalFact(typeof(EnableRunApiTests))]
+    public async Task GetProjectXml_BadDirective_01()
+    {
+        var projectProvider = await GetProjectXmlProviderAsync();
+
+        var tempDir = TempRoot.CreateDirectory();
+        var appFile = tempDir.CreateFile("app.cs");
+        await appFile.WriteAllTextAsync("""
+            #:package [email protected]
+            #:BAD
+            Console.WriteLine("Hello, world!");
+            """);
+
+        var globalJsonFile = tempDir.CreateFile("global.json");
+        await globalJsonFile.WriteAllTextAsync("""
+            {
+              "sdk": {
+                "version": "10.0.100-preview.5.25265.12"
+              }
+            }
+            """);
+
+        var contentNullable = await projectProvider.GetVirtualProjectContentAsync(appFile.Path, CancellationToken.None);
+        var content = contentNullable.Value;
+        var diagnostic = content.Diagnostics.Single();
+        Assert.Contains("Unrecognized directive 'BAD'", diagnostic.Message);
+        Assert.Equal(appFile.Path, diagnostic.Location.Path);
+
+        // LinePositionSpan is not deserializing properly.
+        // Address when implementing editor squiggles. https://github.com/dotnet/roslyn/issues/78688
+        Assert.Equal("(0,0)-(0,0)", diagnostic.Location.Span.ToString());
+    }
+}

src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/DotnetCliHelper.cs

@@ -68,14 +68,15 @@ private async Task<string> GetDotnetSdkFolderFromDotnetExecutableAsync(string pr
         return dotnetSdkFolderPath;
     }
 
-    public Process Run(string[] arguments, string? workingDirectory, bool shouldLocalizeOutput)
+    public Process Run(string[] arguments, string? workingDirectory, bool shouldLocalizeOutput, bool redirectStandardInput = false)
     {
         _logger.LogDebug($"Running dotnet CLI command at {_dotnetExecutablePath.Value} in directory {workingDirectory} with arguments {arguments}");
 
         var startInfo = new ProcessStartInfo(_dotnetExecutablePath.Value)
         {
             CreateNoWindow = true,
             UseShellExecute = false,
+            RedirectStandardInput = redirectStandardInput,
             RedirectStandardOutput = true,
             RedirectStandardError = true,
         };

src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/FileBasedProgramsProjectSystem.cs → src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/FileBasedPrograms/FileBasedProgramsProjectSystem.cs

@@ -4,8 +4,10 @@
 
 using System.Collections.Immutable;
 using System.Security;
+using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Features.Workspaces;
 using Microsoft.CodeAnalysis.Host;
+using Microsoft.CodeAnalysis.LanguageServer.HostWorkspace;
 using Microsoft.CodeAnalysis.LanguageServer.HostWorkspace.ProjectTelemetry;
 using Microsoft.CodeAnalysis.MetadataAsSource;
 using Microsoft.CodeAnalysis.MSBuild;
@@ -22,18 +24,20 @@
 using Roslyn.Utilities;
 using static Microsoft.CodeAnalysis.MSBuild.BuildHostProcessManager;
 
-namespace Microsoft.CodeAnalysis.LanguageServer.HostWorkspace;
+namespace Microsoft.CodeAnalysis.LanguageServer.FileBasedPrograms;
 
 /// <summary>Handles loading both miscellaneous files and file-based program projects.</summary>
 internal sealed class FileBasedProgramsProjectSystem : LanguageServerProjectLoader, ILspMiscellaneousFilesWorkspaceProvider
 {
     private readonly ILspServices _lspServices;
     private readonly ILogger<FileBasedProgramsProjectSystem> _logger;
     private readonly IMetadataAsSourceFileService _metadataAsSourceFileService;
+    private readonly VirtualProjectXmlProvider _projectXmlProvider;
 
     public FileBasedProgramsProjectSystem(
         ILspServices lspServices,
         IMetadataAsSourceFileService metadataAsSourceFileService,
+        VirtualProjectXmlProvider projectXmlProvider,
         LanguageServerWorkspaceFactory workspaceFactory,
         IFileChangeWatcher fileChangeWatcher,
         IGlobalOptionService globalOptionService,
@@ -57,6 +61,7 @@ public FileBasedProgramsProjectSystem(
         _lspServices = lspServices;
         _logger = loggerFactory.CreateLogger<FileBasedProgramsProjectSystem>();
         _metadataAsSourceFileService = metadataAsSourceFileService;
+        _projectXmlProvider = projectXmlProvider;
     }
 
     public Workspace Workspace => ProjectFactory.Workspace;
@@ -124,20 +129,33 @@ public async ValueTask TryRemoveMiscellaneousDocumentAsync(DocumentUri uri, bool
         await UnloadProjectAsync(documentPath);
     }
 
-    protected override async Task<(RemoteProjectFile projectFile, bool hasAllInformation, BuildHostProcessKind preferred, BuildHostProcessKind actual)?> TryLoadProjectInMSBuildHostAsync(
+    protected override async Task<RemoteProjectLoadResult?> TryLoadProjectInMSBuildHostAsync(
         BuildHostProcessManager buildHostProcessManager, string documentPath, CancellationToken cancellationToken)
     {
-        const BuildHostProcessKind buildHostKind = BuildHostProcessKind.NetCore;
-        var buildHost = await buildHostProcessManager.GetBuildHostAsync(buildHostKind, cancellationToken);
+        var content = await _projectXmlProvider.GetVirtualProjectContentAsync(documentPath, cancellationToken);
+        if (content is not var (virtualProjectContent, diagnostics))
+        {
+            // 'GetVirtualProjectContentAsync' will log errors when it fails
+            return null;
+        }
 
-        var loader = ProjectFactory.CreateFileTextLoader(documentPath);
-        var textAndVersion = await loader.LoadTextAsync(new LoadTextOptions(SourceHashAlgorithms.Default), cancellationToken);
-        var (virtualProjectContent, isFileBasedProgram) = VirtualCSharpFileBasedProgramProject.MakeVirtualProjectContent(documentPath, textAndVersion.Text);
+        foreach (var diagnostic in diagnostics)
+        {
+            // https://github.com/dotnet/roslyn/issues/78688: Surface diagnostics in editor
+            _logger.LogError($"{diagnostic.Location.Path}{diagnostic.Location.Span.Start}: {diagnostic.Message}");
+        }
 
         // When loading a virtual project, the path to the on-disk source file is not used. Instead the path is adjusted to end with .csproj.
         // This is necessary in order to get msbuild to apply the standard c# props/targets to the project.
-        var virtualProjectPath = VirtualCSharpFileBasedProgramProject.GetVirtualProjectPath(documentPath);
+        var virtualProjectPath = VirtualProjectXmlProvider.GetVirtualProjectPath(documentPath);
+
+        var loader = ProjectFactory.CreateFileTextLoader(documentPath);
+        var textAndVersion = await loader.LoadTextAsync(new LoadTextOptions(SourceHashAlgorithms.Default), cancellationToken);
+        var isFileBasedProgram = VirtualProjectXmlProvider.IsFileBasedProgram(documentPath, textAndVersion.Text);
+
+        const BuildHostProcessKind buildHostKind = BuildHostProcessKind.NetCore;
+        var buildHost = await buildHostProcessManager.GetBuildHostAsync(buildHostKind, cancellationToken);
         var loadedFile = await buildHost.LoadProjectAsync(virtualProjectPath, virtualProjectContent, languageName: LanguageNames.CSharp, cancellationToken);
-        return (loadedFile, hasAllInformation: isFileBasedProgram, preferred: buildHostKind, actual: buildHostKind);
+        return new RemoteProjectLoadResult(loadedFile, HasAllInformation: isFileBasedProgram, Preferred: buildHostKind, Actual: buildHostKind);
     }
 }

src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/HostWorkspace/FileBasedProgramsWorkspaceProviderFactory.cs → src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/FileBasedPrograms/FileBasedProgramsWorkspaceProviderFactory.cs

@@ -6,6 +6,7 @@
 using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.LanguageServer.Handler;
+using Microsoft.CodeAnalysis.LanguageServer.HostWorkspace;
 using Microsoft.CodeAnalysis.LanguageServer.HostWorkspace.ProjectTelemetry;
 using Microsoft.CodeAnalysis.MetadataAsSource;
 using Microsoft.CodeAnalysis.MSBuild;
@@ -15,7 +16,7 @@
 using Microsoft.CommonLanguageServerProtocol.Framework;
 using Microsoft.Extensions.Logging;
 
-namespace Microsoft.CodeAnalysis.LanguageServer.HostWorkspace;
+namespace Microsoft.CodeAnalysis.LanguageServer.FileBasedPrograms;
 
 /// <summary>
 /// Service to create <see cref="LspMiscellaneousFilesWorkspaceProvider"/> instances.
@@ -27,6 +28,7 @@ namespace Microsoft.CodeAnalysis.LanguageServer.HostWorkspace;
 [method: Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
 internal sealed class FileBasedProgramsWorkspaceProviderFactory(
     IMetadataAsSourceFileService metadataAsSourceFileService,
+    VirtualProjectXmlProvider projectXmlProvider,
     LanguageServerWorkspaceFactory workspaceFactory,
     IFileChangeWatcher fileChangeWatcher,
     IGlobalOptionService globalOptionService,
@@ -38,6 +40,17 @@ internal sealed class FileBasedProgramsWorkspaceProviderFactory(
 {
     public ILspMiscellaneousFilesWorkspaceProvider CreateLspMiscellaneousFilesWorkspaceProvider(ILspServices lspServices, HostServices hostServices)
     {
-        return new FileBasedProgramsProjectSystem(lspServices, metadataAsSourceFileService, workspaceFactory, fileChangeWatcher, globalOptionService, loggerFactory, listenerProvider, projectLoadTelemetry, serverConfigurationFactory, binLogPathProvider);
+        return new FileBasedProgramsProjectSystem(
+            lspServices,
+            metadataAsSourceFileService,
+            projectXmlProvider,
+            workspaceFactory,
+            fileChangeWatcher,
+            globalOptionService,
+            loggerFactory,
+            listenerProvider,
+            projectLoadTelemetry,
+            serverConfigurationFactory,
+            binLogPathProvider);
     }
 }