Allow MSBuildWorkspace to open file-based apps

eng/ensure-sources-synced.cs

@@ -6,8 +6,8 @@
 using System.Net.Http.Headers;
 using System.Text.Json;
 
-// Verifies or updates the shared source files under `src/Features/CSharp/Portable/SyncedSource/FileBasedPrograms`
-// using files from dotnet/sdk at the commit specified in `src/Features/CSharp/Portable/SyncedSource/commitid.txt`.
+// Verifies or updates the shared source files under `src/Workspaces/CSharp/Portable/SyncedSource/FileBasedPrograms`
+// using files from dotnet/sdk at the commit specified in `src/Workspaces/CSharp/Portable/SyncedSource/commitid.txt`.
 //
 // Usage:
 //   dotnet run --file eng/ensure-sources-synced.cs
@@ -34,13 +34,13 @@ static async Task MainAsync(string[] args)
 
     var mode = ParseMode(args);
 
-    var commitIdPath = Path.Combine(root, "src", "Features", "CSharp", "Portable", "SyncedSource", "commitid.txt");
+    var commitIdPath = Path.Combine(root, "src", "Workspaces", "CSharp", "Portable", "SyncedSource", "commitid.txt");
     if (!File.Exists(commitIdPath)) throw new InvalidOperationException($"'{commitIdPath}' not found.");
 
     var sdkCommit = File.ReadAllText(commitIdPath).Trim();
     if (string.IsNullOrWhiteSpace(sdkCommit)) throw new InvalidOperationException($"'{commitIdPath}' is empty.");
 
-    var localSourceDir = Path.Combine(root, "src", "Features", "CSharp", "Portable", "SyncedSource", "FileBasedPrograms");
+    var localSourceDir = Path.Combine(root, "src", "Workspaces", "CSharp", "Portable", "SyncedSource", "FileBasedPrograms");
 
     var httpClient = CreateHttpClient();
 
@@ -54,6 +54,13 @@ static async Task MainAsync(string[] args)
             name.EndsWith(".resx", StringComparison.OrdinalIgnoreCase),
         mapRelativePath: static name => name).ConfigureAwait(false);
 
+    var commonFiles = await GetDirectoryFilesAsync(
+        httpClient,
+        sdkCommit,
+        githubDirectoryPath: "src/Common",
+        includeFile: static name => string.Equals(name, "MSBuildUtilities.cs", StringComparison.OrdinalIgnoreCase),
+        mapRelativePath: static name => name).ConfigureAwait(false);
+
     var editorConfigFiles = await GetDirectoryFilesAsync(
         httpClient,
         sdkCommit,
@@ -62,6 +69,7 @@ static async Task MainAsync(string[] args)
         mapRelativePath: static _ => ".editorconfig").ConfigureAwait(false);
 
     var sourcePackageFiles = sourceFiles
+        .Concat(commonFiles)
         .Concat(editorConfigFiles)
         .ToList();
     if (sourcePackageFiles.Count == 0) throw new InvalidOperationException("No source files found in dotnet/sdk.");

src/Features/CSharp/Portable/Microsoft.CodeAnalysis.CSharp.Features.csproj

@@ -62,10 +62,6 @@
   </ItemGroup>
   <ItemGroup>
     <EmbeddedResource Update="CSharpFeaturesResources.resx" GenerateSource="true" />
-    <EmbeddedResource
-      Update="SyncedSource\FileBasedPrograms\FileBasedProgramsResources.resx"
-      GenerateSource="true"
-      Namespace="Microsoft.DotNet.FileBasedPrograms" />
   </ItemGroup>
   <ItemGroup>
     <PublicAPI Include="PublicAPI.Shipped.txt" />
@@ -74,9 +70,6 @@
   <ItemGroup>
     <PackageReference Include="Humanizer.Core" PrivateAssets="compile" />
   </ItemGroup>
-  <PropertyGroup>
-    <DefineConstants>$(DefineConstants);FILE_BASED_PROGRAMS_SOURCE_PACKAGE_GRACEFUL_EXCEPTION</DefineConstants>
-  </PropertyGroup>
   <Import Project="..\..\..\Analyzers\CSharp\Analyzers\CSharpAnalyzers.projitems" Label="Shared" />
   <Import Project="..\..\..\Analyzers\CSharp\CodeFixes\CSharpCodeFixes.projitems" Label="Shared" />
   <Import Project="..\..\..\Compilers\CSharp\CSharpAnalyzerDriver\CSharpAnalyzerDriver.projitems" Label="Shared" />

src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Microsoft.CodeAnalysis.LanguageServer.UnitTests.csproj

@@ -21,6 +21,7 @@
   </ItemGroup>
 
   <ItemGroup>
+    <PackageReference Include="Basic.Reference.Assemblies.Net100" />
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Analyzer.Testing" />
   </ItemGroup>
 

src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/MiscellaneousFiles/FileBasedProgramsWorkspaceTests.cs

@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using System.Collections.Immutable;
+using System.Text;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.LanguageServer.FileBasedPrograms;
 using Microsoft.CodeAnalysis.LanguageServer.HostWorkspace;
@@ -62,6 +63,51 @@ public async Task TestFileBasedProgram_Simple(bool mutatingLspWorkspace)
         Assert.Empty(syntaxTree.GetDiagnostics(CancellationToken.None));
     }
 
+    [Theory, CombinatorialData]
+    public async Task TestFileBasedProgram_RefDirective(bool mutatingLspWorkspace)
+    {
+        await using var testLspServer = await CreateTestLspServerAsync(string.Empty, mutatingLspWorkspace, new InitializationOptions { ServerKind = WellKnownLspServerKinds.CSharpVisualBasicLspServer });
+
+        Assert.Null(await GetMiscellaneousDocumentAsync(testLspServer));
+        var tempDir = CreateTempDirectoryWithGlobalJson();
+        tempDir.CreateFile("Util.cs").WriteAllText("""
+            #:property TargetFramework=net10.0
+            #:property OutputType=Library
+            public static class Util
+            {
+                public static string M() => "Util";
+            }
+            """);
+        var sourceText = """
+            #:property TargetFramework=net10.0
+            #:property ExperimentalFileBasedProgramEnableRefDirective=true
+            #:ref Util.cs
+            Console.WriteLine($"Hello {Util.M()}!");
+            """;
+        var sourceFile = tempDir.CreateFile("SomeFile.cs").WriteAllText(sourceText);
+
+        // Until we can discover the `#:ref`erenced project, build it so it works as metadata reference.
+        var dotnetCliHelper = testLspServer.GetRequiredLspService<DotnetCliHelper>();
+        using (var process = dotnetCliHelper.Run(["build", sourceFile.Path], workingDirectory: tempDir.Path, shouldLocalizeOutput: true))
+        {
+            var sb = new StringBuilder();
+            process.OutputDataReceived += (sender, args) => sb.AppendLine($"> {args.Data}");
+            process.ErrorDataReceived += (sender, args) => sb.AppendLine($"! {args.Data}");
+            process.BeginOutputReadLine();
+            process.BeginErrorReadLine();
+            await process.WaitForExitAsync();
+            Assert.True(process.ExitCode == 0, sb.ToString());
+        }
+
+        var looseFileUri = ProtocolConversions.CreateAbsoluteDocumentUri(sourceFile.Path);
+        await testLspServer.OpenDocumentAsync(looseFileUri, sourceText).ConfigureAwait(false);
+        await WaitForProjectLoad(looseFileUri, testLspServer);
+        var (workspace, document) = await GetRequiredLspWorkspaceAndDocumentAsync(looseFileUri, testLspServer).ConfigureAwait(false);
+        Assert.NotEmpty(document.Project.MetadataReferences);
+        var model = await document.GetRequiredSemanticModelAsync(CancellationToken.None);
+        model.GetDiagnostics().Verify();
+    }
+
     [Theory, CombinatorialData]
     public async Task TestDirectiveWithoutTopLevelStatements_IsMiscellaneousFile(bool mutatingLspWorkspace)
     {

src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/FileBasedPrograms/CanonicalMiscellaneousFilesProjectProvider.cs

@@ -74,7 +74,7 @@ private async Task<ImmutableArray<ProjectFileInfo>> LoadCanonicalProjectAsync(Ca
             binaryLogPathProvider: null,
             loggerFactory: _loggerFactory);
         var buildHost = await buildHostProcessManager.GetBuildHostAsync(BuildHostProcessKind.NetCore, virtualProjectPath, dotnetPath: null, cancellationToken);
-        var loadedFile = await buildHost.LoadProjectAsync(virtualProjectPath, virtualProjectXml, languageName: LanguageNames.CSharp, cancellationToken);
+        var loadedFile = await buildHost.LoadProjectAsync(virtualProjectPath, physicalFilePath: null, virtualProjectXml, languageName: LanguageNames.CSharp, globalProperties: null, cancellationToken);
         return await loadedFile.GetProjectFileInfosAsync(cancellationToken);
     }
 

src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/FileBasedPrograms/FileBasedProgramsEntryPointDiscovery.cs

@@ -5,22 +5,21 @@
 using System.Buffers;
 using System.Collections.Immutable;
 using System.Composition;
-using System.Diagnostics;
 using System.IO.Enumeration;
 using System.Runtime.CompilerServices;
 using System.Text.Json;
 using System.Text.Json.Serialization;
 using Microsoft.CodeAnalysis.Collections;
 using Microsoft.CodeAnalysis.ErrorReporting;
-using Microsoft.CodeAnalysis.Features.Workspaces;
+using Microsoft.CodeAnalysis.FileBasedPrograms;
+using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.LanguageServer.Handler;
 using Microsoft.CodeAnalysis.LanguageServer.HostWorkspace;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.CodeAnalysis.Shared.Utilities;
-using Microsoft.CodeAnalysis.Text;
 using Microsoft.Extensions.Logging;
 using Roslyn.LanguageServer.Protocol;
 using Roslyn.Utilities;
@@ -35,12 +34,21 @@ internal sealed class FileBasedProgramsEntryPointDiscoveryFactory(IGlobalOptionS
 {
     public ILspService CreateILspService(LspServices lspServices, WellKnownLspServerKinds serverKind)
     {
-        return new FileBasedProgramsEntryPointDiscovery(globalOptionService, listenerProvider.GetListener(FeatureAttribute.Workspace), lspServices.GetRequiredService<ILoggerFactory>(), lspServices);
+        return new FileBasedProgramsEntryPointDiscovery(
+            globalOptionService,
+            listenerProvider.GetListener(FeatureAttribute.Workspace),
+            lspServices.GetRequiredService<IHostWorkspaceProvider>().Workspace.Services.GetRequiredService<IFileBasedProgramService>(),
+            lspServices.GetRequiredService<ILoggerFactory>(),
+            lspServices);
     }
 }
 
 internal sealed partial class FileBasedProgramsEntryPointDiscovery(
-    IGlobalOptionService globalOptionService, IAsynchronousOperationListener listener, ILoggerFactory loggerFactory, LspServices lspServices) : ILspService, IOnInitialized
+    IGlobalOptionService globalOptionService,
+    IAsynchronousOperationListener listener,
+    IFileBasedProgramService fileBasedProgramService,
+    ILoggerFactory loggerFactory,
+    LspServices lspServices) : ILspService, IOnInitialized
 {
     private static readonly StringComparer s_pathComparer = StringComparer.OrdinalIgnoreCase;
 
@@ -114,16 +122,16 @@ internal async Task FindAndLoadEntryPointsAsync()
         // Discovery pass done. Find and delete old caches.
         IOUtilities.PerformIO(() =>
         {
-            using var enumerator = new OldCacheEnumerator();
+            using var enumerator = new OldCacheEnumerator(fileBasedProgramService);
             while (enumerator.MoveNext())
             {
                 IOUtilities.PerformIO(() => Directory.Delete(enumerator.Current, recursive: true));
             }
         });
     }
 
-    private sealed class OldCacheEnumerator() : FileSystemEnumerator<string>(
-        directory: VirtualProjectXmlProvider.GetDiscoveryCacheRootDirectory(),
+    private sealed class OldCacheEnumerator(IFileBasedProgramService fileBasedProgramService) : FileSystemEnumerator<string>(
+        directory: fileBasedProgramService.GetDiscoveryCacheRootDirectory(),
         options: new() { RecurseSubdirectories = false })
     {
         // Yield cache directories that have not been modified in 30 days (indicates they are stale and should be deleted)
@@ -140,7 +148,7 @@ protected override bool ShouldIncludeEntry(ref FileSystemEntry entry)
     internal ImmutableArray<string> FindEntryPoints(string workspaceFolder)
     {
         var stopwatch = SharedStopwatch.StartNew();
-        var cacheDirectory = VirtualProjectXmlProvider.GetDiscoveryCacheDirectory(workspaceFolder);
+        var cacheDirectory = fileBasedProgramService.GetDiscoveryCacheDirectory(workspaceFolder);
         var cacheFilePath = Path.Join(cacheDirectory, "cache.json");
         Cache? cache = null;
         try