Convert to async

Author: GrahamTheCoder

CodeConverter/CSharp/VBToCSConversion.cs

@@ -164,16 +164,16 @@ private VisualBasicCompiler CreateCompiler()
             return new VisualBasicCompiler(ConversionOptions.RootNamespaceOverride);
         }
 
-        public Document CreateProjectDocumentFromTree(SyntaxTree tree, IEnumerable<MetadataReference> references)
+        public async Task<Document> CreateProjectDocumentFromTreeAsync(SyntaxTree tree, IEnumerable<MetadataReference> references)
         {
-            var project = CreateEmptyVbProject(references);
+            var project = await CreateEmptyVbProjectAsync(references);
             return project.AddDocumentFromTree(tree);
         }
 
-        private Project CreateEmptyVbProject(IEnumerable<MetadataReference> references)
+        private async Task<Project> CreateEmptyVbProjectAsync(IEnumerable<MetadataReference> references)
         {
-            return VisualBasicCompiler.CreateCompilationOptions(ConversionOptions.RootNamespaceOverride)
-                            .CreateProject(references, VisualBasicParseOptions.Default, ISymbolExtensions.ForcePartialTypesAssemblyName);
+            return await VisualBasicCompiler.CreateCompilationOptions(ConversionOptions.RootNamespaceOverride)
+                            .CreateProjectAsync(references, VisualBasicParseOptions.Default, ISymbolExtensions.ForcePartialTypesAssemblyName);
         }
     }
 }

CodeConverter/ILanguageConversion.cs

@@ -27,6 +27,6 @@ SyntaxNode GetSurroundedNode(IEnumerable<SyntaxNode> descendantNodes,
         Task<IProjectContentsConverter> CreateProjectContentsConverter(Project project, IProgress<ConversionProgress> progress, CancellationToken cancellationToken);
         string PostTransformProjectFile(string xml);
 
-        Document CreateProjectDocumentFromTree(SyntaxTree tree, IEnumerable<MetadataReference> references);
+        Task<Document> CreateProjectDocumentFromTreeAsync(SyntaxTree tree, IEnumerable<MetadataReference> references);
     }
 }

CodeConverter/Shared/CompilationOptionsExtensions.cs

@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using System.IO;
+using System.Threading.Tasks;
 using ICSharpCode.CodeConverter.CSharp;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Host.Mef;
@@ -13,13 +14,13 @@ public static Document AddDocumentFromTree(this Project project, SyntaxTree tree
             return project.AddDocument("CodeToConvert", tree.GetRoot(), filePath: Path.Combine(Directory.GetCurrentDirectory(), "TempCodeToConvert.txt"));
         }
 
-        public static Project CreateProject(this CompilationOptions options, IEnumerable<MetadataReference> references, ParseOptions parseOptions, string singleDocumentAssemblyName = "ProjectToBeConverted")
+        public static async Task<Project> CreateProjectAsync(this CompilationOptions options, IEnumerable<MetadataReference> references, ParseOptions parseOptions, string singleDocumentAssemblyName = "ProjectToBeConverted")
         {
             ProjectId projectId = ProjectId.CreateNewId();
 
             string projFileExtension = parseOptions.Language == LanguageNames.CSharp ? ".csproj" : ".vbproj";
             var projectFilePath = Path.Combine(Directory.GetCurrentDirectory() + singleDocumentAssemblyName + projFileExtension);
-            var solution = ThreadSafeWorkspaceHelper.EmptyAdhocSolution.AddProject(projectId, singleDocumentAssemblyName,
+            var solution = (await ThreadSafeWorkspaceHelper.EmptyAdhocSolution.GetValueAsync()).AddProject(projectId, singleDocumentAssemblyName,
                 singleDocumentAssemblyName, options.Language)
                 .WithProjectFilePath(projectId, projectFilePath);
 

CodeConverter/Shared/JoinableTaskFactorySingleton.cs

@@ -0,0 +1,18 @@
+using System;
+using Microsoft.VisualStudio.Threading;
+
+namespace ICSharpCode.CodeConverter.Shared
+{
+    /// <summary>
+    /// If you have a JoinableTaskFactory, set it here to help avoid deadlocks
+    /// </summary>
+    internal static class JoinableTaskFactorySingleton
+    {
+        public static JoinableTaskFactory Instance { get; private set; }
+
+        internal static void EnsureInitialized()
+        {
+            Instance = new JoinableTaskFactory(new JoinableTaskContext());
+        }
+    }
+}

CodeConverter/Shared/ProjectConversion.cs

@@ -12,6 +12,7 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.Text;
+using Microsoft.VisualStudio.Threading;
 
 namespace ICSharpCode.CodeConverter.Shared
 {
@@ -46,7 +47,7 @@ private ProjectConversion(IProjectContentsConverter projectContentsConverter, IE
             var languageConversion = new TLanguageConversion { ConversionOptions = conversionOptions };
             var syntaxTree = languageConversion.MakeFullCompilationUnit(text, out var textSpan);
             if (textSpan.HasValue) conversionOptions.SelectedTextSpan = textSpan.Value;
-            var document = languageConversion.CreateProjectDocumentFromTree(syntaxTree, conversionOptions.References);
+            var document = await languageConversion.CreateProjectDocumentFromTreeAsync(syntaxTree, conversionOptions.References);
             return await ConvertSingle<TLanguageConversion>(document, conversionOptions, progress, cancellationToken);
         }
 
@@ -343,6 +344,7 @@ private string PathRelativeToSolutionDir(string path)
 
         private static async Task<IDisposable> RoslynEntryPoint(IProgress<ConversionProgress> progress)
         {
+            JoinableTaskFactorySingleton.EnsureInitialized();
             await new SynchronizationContextRemover();
             return RoslynCrashPreventer.Create(LogError);
 

CodeConverter/Shared/ThreadSafeWorkspaceHelper.cs

@@ -20,7 +20,10 @@ public static class ThreadSafeWorkspaceHelper
         /// <summary>
         /// Empty solution in an adhoc workspace
         /// </summary>
-        public static Solution EmptyAdhocSolution => _emptyAdhocSolution.GetAwaiter().GetResult();
+        public static AsyncLazy<Solution> EmptyAdhocSolution { get; } = new AsyncLazy<Solution>(async () => {
+            var hostServices = await CreateHostServicesAsync(MefHostServices.DefaultAssemblies);
+            return new AdhocWorkspace(hostServices).CurrentSolution;
+        }, JoinableTaskFactorySingleton.Instance);
 
         /// <summary>
         /// Use this in all workspace creation
@@ -41,15 +44,5 @@ private static async Task<IExportProviderFactory> CreateExportProviderFactoryAsy
             var runtimeComposition = RuntimeComposition.CreateRuntimeComposition(configuration);
             return runtimeComposition.CreateExportProviderFactory();
         }
-
-        /// <summary>
-        /// Empty solution in an adhoc workspace
-        /// </summary>
-        private static Task<Solution> _emptyAdhocSolution =
-            Task.Run(async () => {
-                var hostServices = await CreateHostServicesAsync(MefHostServices.DefaultAssemblies);
-                return new AdhocWorkspace(hostServices).CurrentSolution;
-            });
-        
     }
 }

CodeConverter/VB/CSToVBConversion.cs

@@ -152,9 +152,10 @@ public SyntaxTree CreateTree(string text)
             return new CSharpCompiler().CreateTree(text);
         }
 
-        public Document CreateProjectDocumentFromTree(SyntaxTree tree, IEnumerable<MetadataReference> references)
+        public async Task<Document> CreateProjectDocumentFromTreeAsync(SyntaxTree tree, IEnumerable<MetadataReference> references)
         {
-            return CSharpCompiler.CreateCompilationOptions().CreateProject(references, CSharpParseOptions.Default).AddDocumentFromTree(tree);
+            return (await CSharpCompiler.CreateCompilationOptions().CreateProjectAsync(references, CSharpParseOptions.Default))
+                .AddDocumentFromTree(tree);
         }
     }
 }

Tests/TestRunners/ConverterTestBase.cs

@@ -183,9 +183,9 @@ async Task<IProjectContentsConverter> ILanguageConversion.CreateProjectContentsC
             return await baseConversion.CreateProjectContentsConverter(project, progress, cancellationToken);
         }
 
-        Document ILanguageConversion.CreateProjectDocumentFromTree(SyntaxTree tree, IEnumerable<MetadataReference> references)
+        async Task<Document> ILanguageConversion.CreateProjectDocumentFromTreeAsync(SyntaxTree tree, IEnumerable<MetadataReference> references)
         {
-            return baseConversion.CreateProjectDocumentFromTree(tree, references);
+            return await baseConversion.CreateProjectDocumentFromTreeAsync(tree, references);
         }
 
         SyntaxTree ILanguageConversion.CreateTree(string text) {