Expose async entrypoint for IWorkspaceProjectContextFactory

src/VisualStudio/Core/Def/Implementation/ProjectSystem/CPS/IWorkspaceProjectContext.cs

@@ -12,8 +12,12 @@
 namespace Microsoft.VisualStudio.LanguageServices.ProjectSystem
 {
     /// <summary>
-    /// Project context to initialize properties and items of a Workspace project created with <see cref="IWorkspaceProjectContextFactory.CreateProjectContext(string, string, string, Guid, object, string)"/>. 
+    /// Project context to initialize properties and items of a Workspace project created with <see
+    /// cref="IWorkspaceProjectContextFactory.CreateProjectContext(string, string, string, Guid, object, string)"/>. 
     /// </summary>
+    /// <remarks>
+    /// <see cref="IDisposable.Dispose"/> is safe to call on instances of this type on any thread.
+    /// </remarks>
     internal interface IWorkspaceProjectContext : IDisposable
     {
         // Project properties.

src/VisualStudio/Core/Def/Implementation/ProjectSystem/CPS/IWorkspaceProjectContextFactory.cs

@@ -5,7 +5,7 @@
 #nullable disable
 
 using System;
-using Microsoft.VisualStudio.LanguageServices.Implementation.TaskList;
+using System.Threading.Tasks;
 
 namespace Microsoft.VisualStudio.LanguageServices.ProjectSystem
 {
@@ -14,6 +14,10 @@ namespace Microsoft.VisualStudio.LanguageServices.ProjectSystem
     /// </summary>
     internal interface IWorkspaceProjectContextFactory
     {
+        /// <inheritdoc cref="CreateProjectContextAsync(string, string, string, Guid, object, string)"/>
+        [Obsolete("Use CreateProjectContextAsync instead")]
+        IWorkspaceProjectContext CreateProjectContext(string languageName, string projectUniqueName, string projectFilePath, Guid projectGuid, object hierarchy, string binOutputPath);
+
         /// <summary>
         /// Creates and initializes a new Workspace project and returns a <see cref="IWorkspaceProjectContext"/> to lazily initialize the properties and items for the project.
         /// </summary>
@@ -23,6 +27,6 @@ internal interface IWorkspaceProjectContextFactory
         /// <param name="projectGuid">Project guid.</param>
         /// <param name="hierarchy">Obsolete. The argument is ignored.</param>
         /// <param name="binOutputPath">Initial project binary output path.</param>
-        IWorkspaceProjectContext CreateProjectContext(string languageName, string projectUniqueName, string projectFilePath, Guid projectGuid, object hierarchy, string binOutputPath);
+        Task<IWorkspaceProjectContext> CreateProjectContextAsync(string languageName, string projectUniqueName, string projectFilePath, Guid projectGuid, object hierarchy, string binOutputPath);
     }
 }

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

@@ -7,13 +7,16 @@
 using System.Collections.Immutable;
 using System.ComponentModel.Composition;
 using System.IO;
+using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
 using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.VisualStudio.LanguageServices.ExternalAccess.VSTypeScript.Api;
 using Microsoft.VisualStudio.LanguageServices.Implementation.TaskList;
 using Microsoft.VisualStudio.Shell.Interop;
 using Microsoft.VisualStudio.Telemetry;
+using Microsoft.VisualStudio.Threading;
 
 namespace Microsoft.VisualStudio.LanguageServices.Implementation.ProjectSystem
 {
@@ -23,18 +26,20 @@ internal sealed class VisualStudioProjectFactory : IVsTypeScriptVisualStudioProj
     {
         private const string SolutionContextName = "Solution";
         private const string SolutionSessionIdPropertyName = "SolutionSessionID";
-
+        private readonly IThreadingContext _threadingContext;
         private readonly VisualStudioWorkspaceImpl _visualStudioWorkspaceImpl;
         private readonly HostDiagnosticUpdateSource _hostDiagnosticUpdateSource;
         private readonly ImmutableArray<Lazy<IDynamicFileInfoProvider, FileExtensionsMetadata>> _dynamicFileInfoProviders;
 
         [ImportingConstructor]
         [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
         public VisualStudioProjectFactory(
+            IThreadingContext threadingContext,
             VisualStudioWorkspaceImpl visualStudioWorkspaceImpl,
             [ImportMany] IEnumerable<Lazy<IDynamicFileInfoProvider, FileExtensionsMetadata>> fileInfoProviders,
             HostDiagnosticUpdateSource hostDiagnosticUpdateSource)
         {
+            _threadingContext = threadingContext;
             _visualStudioWorkspaceImpl = visualStudioWorkspaceImpl;
             _dynamicFileInfoProviders = fileInfoProviders.AsImmutableOrEmpty();
             _hostDiagnosticUpdateSource = hostDiagnosticUpdateSource;
@@ -44,12 +49,19 @@ public VisualStudioProject CreateAndAddToWorkspace(string projectSystemName, str
             => CreateAndAddToWorkspace(projectSystemName, language, new VisualStudioProjectCreationInfo());
 
         public VisualStudioProject CreateAndAddToWorkspace(string projectSystemName, string language, VisualStudioProjectCreationInfo creationInfo)
+            => _threadingContext.JoinableTaskFactory.Run(async () => await CreateAndAddToWorkspaceAsync(
+                projectSystemName, language, creationInfo).ConfigureAwait(false));
+
+        public async Task<VisualStudioProject> CreateAndAddToWorkspaceAsync(string projectSystemName, string language, VisualStudioProjectCreationInfo creationInfo)
         {
             // HACK: Fetch this service to ensure it's still created on the UI thread; once this is moved off we'll need to fix up it's constructor to be free-threaded.
             _visualStudioWorkspaceImpl.Services.GetRequiredService<VisualStudioMetadataReferenceManager>();
 
-            // HACK: since we're on the UI thread, ensure we initialize our options provider which depends on a UI-affinitized experimentation service
+            // HACK: switch to the UI thread, ensure we initialize our options provider which depends on a
+            // UI-affinitized experimentation service
+            await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync();
             _visualStudioWorkspaceImpl.EnsureDocumentOptionProvidersInitialized();
+            await TaskScheduler.Default;
 
             var id = ProjectId.CreateNewId(projectSystemName);
             var assemblyName = creationInfo.AssemblyName ?? projectSystemName;
@@ -89,16 +101,19 @@ public VisualStudioProject CreateAndAddToWorkspace(string projectSystemName, str
                 if (w.CurrentSolution.ProjectIds.Count == 0)
                 {
                     // Fetch the current solution path. Since we're on the UI thread right now, we can do that.
-                    string? solutionFilePath = null;
-                    var solution = (IVsSolution)Shell.ServiceProvider.GlobalProvider.GetService(typeof(SVsSolution));
-                    if (solution != null)
+                    var solutionFilePath = _threadingContext.JoinableTaskFactory.Run(async () =>
                     {
-                        if (ErrorHandler.Failed(solution.GetSolutionInfo(out _, out solutionFilePath, out _)))
+                        await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync();
+                        var solution = (IVsSolution)Shell.ServiceProvider.GlobalProvider.GetService(typeof(SVsSolution));
+                        if (solution != null)
                         {
-                            // Paranoia: if the call failed, we definitely don't want to use any stuff that was set
-                            solutionFilePath = null;
+                            if (ErrorHandler.Succeeded(solution.GetSolutionInfo(out _, out var filePath, out _)))
+                                return filePath;
                         }
-                    }
+
+                        // Paranoia: if the call failed, we definitely don't want to use any stuff that was set
+                        return null;
+                    });
 
                     var solutionSessionId = GetSolutionSessionId();
 

src/VisualStudio/Core/Impl/ProjectSystem/CPS/CPSProjectFactory.cs

@@ -9,7 +9,9 @@
 using System.Collections.Immutable;
 using System.ComponentModel.Composition;
 using System.IO;
+using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.VisualStudio.LanguageServices.Implementation.CodeModel;
 using Microsoft.VisualStudio.LanguageServices.Implementation.TaskList;
@@ -22,35 +24,47 @@ namespace Microsoft.VisualStudio.LanguageServices.Implementation.ProjectSystem.C
     [Export(typeof(IWorkspaceProjectContextFactory))]
     internal partial class CPSProjectFactory : IWorkspaceProjectContextFactory
     {
+        private readonly IThreadingContext _threadingContext;
         private readonly VisualStudioProjectFactory _projectFactory;
         private readonly VisualStudioWorkspaceImpl _workspace;
         private readonly IProjectCodeModelFactory _projectCodeModelFactory;
 
         [ImportingConstructor]
         [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
         public CPSProjectFactory(
+            IThreadingContext threadingContext,
             VisualStudioProjectFactory projectFactory,
             VisualStudioWorkspaceImpl workspace,
             IProjectCodeModelFactory projectCodeModelFactory)
         {
+            _threadingContext = threadingContext;
             _projectFactory = projectFactory;
             _workspace = workspace;
             _projectCodeModelFactory = projectCodeModelFactory;
         }
 
-        IWorkspaceProjectContext IWorkspaceProjectContextFactory.CreateProjectContext(
+        IWorkspaceProjectContext IWorkspaceProjectContextFactory.CreateProjectContext(string languageName, string projectUniqueName, string projectFilePath, Guid projectGuid, object hierarchy, string binOutputPath)
+        {
+            return _threadingContext.JoinableTaskFactory.Run(async () =>
+                await ((IWorkspaceProjectContextFactory)this).CreateProjectContextAsync(
+                    languageName, projectUniqueName, projectFilePath, projectGuid, hierarchy, binOutputPath).ConfigureAwait(false));
+        }
+
+        async Task<IWorkspaceProjectContext> IWorkspaceProjectContextFactory.CreateProjectContextAsync(
             string languageName,
             string projectUniqueName,
             string projectFilePath,
             Guid projectGuid,
             object hierarchy,
             string binOutputPath)
         {
-            var visualStudioProject = CreateVisualStudioProject(languageName, projectUniqueName, projectFilePath, hierarchy as IVsHierarchy, projectGuid);
+            var visualStudioProject = await CreateVisualStudioProjectAsync(
+                languageName, projectUniqueName, projectFilePath, hierarchy as IVsHierarchy, projectGuid).ConfigureAwait(false);
             return new CPSProject(visualStudioProject, _workspace, _projectCodeModelFactory, projectGuid, binOutputPath);
         }
 
-        private VisualStudioProject CreateVisualStudioProject(string languageName, string projectUniqueName, string projectFilePath, IVsHierarchy hierarchy, Guid projectGuid)
+        private async Task<VisualStudioProject> CreateVisualStudioProjectAsync(
+            string languageName, string projectUniqueName, string projectFilePath, IVsHierarchy hierarchy, Guid projectGuid)
         {
             var creationInfo = new VisualStudioProjectCreationInfo
             {
@@ -63,6 +77,7 @@ private VisualStudioProject CreateVisualStudioProject(string languageName, strin
 
             if (languageName == LanguageNames.FSharp)
             {
+                await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync();
                 var shell = (IVsShell)ServiceProvider.GlobalProvider.GetService(typeof(SVsShell));
 
                 // Force the F# package to load; this is necessary because the F# package listens to WorkspaceChanged to