fix: use async/await instead of .GetWaiter().GetResult() (#176)

Corniel Nobel · amis92 · commit 0641357071c9 · 2019-12-14T00:10:31.000+01:00
diff --git a/src/CodeGeneration.Roslyn.Engine/CompilationGenerator.cs b/src/CodeGeneration.Roslyn.Engine/CompilationGenerator.cs
@@ -65,7 +65,7 @@ public class CompilationGenerator
         public string IntermediateOutputDirectory { get; set; }
 
         /// <summary>
-        /// Gets the set of files generated after <see cref="Generate"/> is invoked.
+        /// Gets the set of files generated after <see cref="GenerateAsync"/> is invoked.
         /// </summary>
         public IEnumerable<string> GeneratedFiles => this.generatedFiles;
 
@@ -106,7 +106,8 @@ public CompilationGenerator()
         /// </summary>
         /// <param name="progress">Optional handler of diagnostics provided by code generator.</param>
         /// <param name="cancellationToken">Cancellation token to interrupt async operations.</param>
-        public void Generate(IProgress<Diagnostic> progress = null, CancellationToken cancellationToken = default)
+        /// <returns>A <see cref="Task.CompletedTask"/>.</returns>
+        public async Task GenerateAsync(IProgress<Diagnostic> progress = null, CancellationToken cancellationToken = default)
         {
             Verify.Operation(this.Compile != null, $"{nameof(Compile)} must be set first.");
             Verify.Operation(this.ReferencePath != null, $"{nameof(ReferencePath)} must be set first.");
@@ -142,12 +143,12 @@ public void Generate(IProgress<Diagnostic> progress = null, CancellationToken ca
                         {
                             try
                             {
-                                var generatedSyntaxTree = DocumentTransform.TransformAsync(
+                                var generatedSyntaxTree = await DocumentTransform.TransformAsync(
                                     compilation,
                                     inputSyntaxTree,
                                     this.ProjectDirectory,
                                     this.LoadAssembly,
-                                    progress).GetAwaiter().GetResult();
+                                    progress);
 
                                 var outputText = generatedSyntaxTree.GetText(cancellationToken);
                                 using (var outputFileStream = File.OpenWrite(outputFilePath))
@@ -160,12 +161,15 @@ public void Generate(IProgress<Diagnostic> progress = null, CancellationToken ca
                                     outputFileStream.SetLength(outputFileStream.Position);
                                 }
 
-                                bool anyTypesGenerated = generatedSyntaxTree?.GetRoot(cancellationToken).DescendantNodes().OfType<TypeDeclarationSyntax>().Any() ?? false;
-                                if (!anyTypesGenerated)
+                                if (!(generatedSyntaxTree is null))
                                 {
-                                    this.emptyGeneratedFiles.Add(outputFilePath);
+                                    var root = await generatedSyntaxTree.GetRootAsync(cancellationToken);
+                                    bool anyTypesGenerated = root.DescendantNodes().OfType<TypeDeclarationSyntax>().Any();
+                                    if (!anyTypesGenerated)
+                                    {
+                                        this.emptyGeneratedFiles.Add(outputFilePath);
+                                    }
                                 }
-
                                 break;
                             }
                             catch (IOException ex) when (ex.HResult == ProcessCannotAccessFileHR && retriesLeft > 0)
diff --git a/src/CodeGeneration.Roslyn.Engine/DocumentTransform.cs b/src/CodeGeneration.Roslyn.Engine/DocumentTransform.cs
@@ -70,8 +70,8 @@ public static async Task<SyntaxTree> TransformAsync(
             var emittedAttributeLists = ImmutableArray<AttributeListSyntax>.Empty;
             var emittedMembers = ImmutableArray<MemberDeclarationSyntax>.Empty;
 
-            var memberNodes = inputDocument
-                .GetRoot()
+            var root = await inputDocument.GetRootAsync();
+            var memberNodes = root
                 .DescendantNodesAndSelf(n => n is CompilationUnitSyntax || n is NamespaceDeclarationSyntax || n is TypeDeclarationSyntax)
                 .OfType<CSharpSyntaxNode>();
 
diff --git a/src/CodeGeneration.Roslyn.Tests/DocumentTransformTests.cs b/src/CodeGeneration.Roslyn.Tests/DocumentTransformTests.cs
@@ -1,25 +1,26 @@
 ﻿// Copyright (c) Andrew Arnott. All rights reserved.
 // Licensed under the MS-PL license. See LICENSE.txt file in the project root for full license information.
 
+using System.Threading.Tasks;
 using Xunit;
 
 public class DocumentTransformTests : CompilationTestsBase
 {
     [Fact]
-    public void EmptyFile_NoGenerators()
+    public async Task EmptyFile_NoGenerators()
     {
-        AssertGeneratedAsExpected("", "");
+        await AssertGeneratedAsExpected("", "");
     }
 
     [Fact]
-    public void Usings_WhenNoCode_CopiedToOutput()
+    public async Task Usings_WhenNoCode_CopiedToOutput()
     {
         const string usings = "using System;";
-        AssertGeneratedAsExpected(usings, usings);
+        await AssertGeneratedAsExpected(usings, usings);
     }
 
     [Fact]
-    public void AncestorTree_IsBuiltProperly()
+    public async Task AncestorTree_IsBuiltProperly()
     {
         const string source = @"
 using System;
@@ -66,11 +67,11 @@ partial struct InnerStruct<T1, T2>
         }
     }
 }";
-        AssertGeneratedAsExpected(source, generated);
+        await AssertGeneratedAsExpected(source, generated);
     }
 
     [Fact]
-    public void DefineDirective_Dropped()
+    public async Task DefineDirective_Dropped()
     {
         // define directives must be leading any other tokens to be valid in C#
         const string source = @"
@@ -80,11 +81,11 @@ public void DefineDirective_Dropped()
         const string generated = @"
 using System;
 using System.Linq;";
-        AssertGeneratedAsExpected(source, generated);
+        await AssertGeneratedAsExpected(source, generated);
     }
 
     [Fact]
-    public void Comment_BetweenUsings_Dropped()
+    public async Task Comment_BetweenUsings_Dropped()
     {
         const string source = @"
 using System;
@@ -93,11 +94,11 @@ public void Comment_BetweenUsings_Dropped()
         const string generated = @"
 using System;
 using System.Linq;";
-        AssertGeneratedAsExpected(source, generated);
+        await AssertGeneratedAsExpected(source, generated);
     }
 
     [Fact]
-    public void Region_TrailingUsings_Dropped()
+    public async Task Region_TrailingUsings_Dropped()
     {
         const string source = @"
 using System;
@@ -107,11 +108,11 @@ public void Region_TrailingUsings_Dropped()
         const string generated = @"
 using System;
 using System.Linq;";
-        AssertGeneratedAsExpected(source, generated);
+        await AssertGeneratedAsExpected(source, generated);
     }
 
     [Fact]
-    public void IfElseDirective_OnUsings_InactiveUsingAndDirectives_Dropped()
+    public async Task IfElseDirective_OnUsings_InactiveUsingAndDirectives_Dropped()
     {
         const string source = @"
 using System;
@@ -134,11 +135,11 @@ partial class Empty {}";
 partial class Empty
 {
 }";
-        AssertGeneratedAsExpected(source, generated);
+        await AssertGeneratedAsExpected(source, generated);
     }
 
     [Fact]
-    public void RegionDirective_InsideClass_Dropped()
+    public async Task RegionDirective_InsideClass_Dropped()
     {
         const string source = @"
 using System;
@@ -158,11 +159,11 @@ partial class Empty
 partial class Empty
 {
 }";
-        AssertGeneratedAsExpected(source, generated);
+        await AssertGeneratedAsExpected(source, generated);
     }
 
     [Fact]
-    public void RegionDirective_InsideStruct_Dropped()
+    public async Task RegionDirective_InsideStruct_Dropped()
     {
         const string source = @"
 using System;
@@ -182,11 +183,11 @@ partial struct Empty
 partial struct Empty
 {
 }";
-        AssertGeneratedAsExpected(source, generated);
+        await AssertGeneratedAsExpected(source, generated);
     }
 
     [Fact]
-    public void RegionDirective_InsideNamespace_Dropped()
+    public async Task RegionDirective_InsideNamespace_Dropped()
     {
         const string source = @"
 using System;
@@ -209,11 +210,11 @@ partial class Empty
     {
     }
 }";
-        AssertGeneratedAsExpected(source, generated);
+        await AssertGeneratedAsExpected(source, generated);
     }
 
     [Fact]
-    public void Class_Modifiers_ArePreserved_WithoutTrivia()
+    public async Task Class_Modifiers_ArePreserved_WithoutTrivia()
     {
         const string source = @"
 using System;
@@ -238,11 +239,11 @@ public static partial class Empty
     {
     }
 }";
-        AssertGeneratedAsExpected(source, generated);
+        await AssertGeneratedAsExpected(source, generated);
     }
 
     [Fact]
-    public void Struct_Modifiers_ArePreserved_WithoutTrivia()
+    public async Task Struct_Modifiers_ArePreserved_WithoutTrivia()
     {
         const string source = @"
 using System;
@@ -267,11 +268,11 @@ internal partial struct Empty
     {
     }
 }";
-        AssertGeneratedAsExpected(source, generated);
+        await AssertGeneratedAsExpected(source, generated);
     }
 
     [Fact]
-    public void Class_TypeParameters_ArePreserved()
+    public async Task Class_TypeParameters_ArePreserved()
     {
         const string source = @"
 using System;
@@ -295,11 +296,11 @@ partial class Empty<T>
     {
     }
 }";
-        AssertGeneratedAsExpected(source, generated);
+        await AssertGeneratedAsExpected(source, generated);
     }
 
     [Fact]
-    public void Struct_TypeParameters_ArePreserved()
+    public async Task Struct_TypeParameters_ArePreserved()
     {
         const string source = @"
 using System;
@@ -323,11 +324,11 @@ partial struct Empty<T>
     {
     }
 }";
-        AssertGeneratedAsExpected(source, generated);
+        await AssertGeneratedAsExpected(source, generated);
     }
 
     [Fact]
-    public void RichGenerator_Wraps_InOtherNamespace()
+    public async Task RichGenerator_Wraps_InOtherNamespace()
     {
         const string source = @"
 using System;
@@ -350,11 +351,11 @@ class Something
     {
     }
 }";
-        AssertGeneratedAsExpected(source, generated);
+        await AssertGeneratedAsExpected(source, generated);
     }
 
     [Fact]
-    public void RichGenerator_Adds_Using()
+    public async Task RichGenerator_Adds_Using()
     {
         const string source = @"
 using System;
@@ -373,11 +374,11 @@ partial class Something
 using System.Collections.Generic;
 
 ";
-        AssertGeneratedAsExpected(source, generated);
+        await AssertGeneratedAsExpected(source, generated);
     }
 
     [Fact]
-    public void RichGenerator_Adds_ExternAlias()
+    public async Task RichGenerator_Adds_ExternAlias()
     {
         const string source = @"
 using System;
@@ -397,11 +398,11 @@ partial class Something
 using CodeGeneration.Roslyn.Tests.Generators;
 
 ";
-        AssertGeneratedAsExpected(source, generated);
+        await AssertGeneratedAsExpected(source, generated);
     }
 
     [Fact]
-    public void RichGenerator_Adds_Attribute()
+    public async Task RichGenerator_Adds_Attribute()
     {
         const string source = @"
 using System;
@@ -420,11 +421,11 @@ partial class Something
 
 [GeneratedAttribute]
 ";
-        AssertGeneratedAsExpected(source, generated);
+        await AssertGeneratedAsExpected(source, generated);
     }
 
     [Fact]
-    public void RichGenerator_Appends_MultipleResults()
+    public async Task RichGenerator_Appends_MultipleResults()
     {
         const string source = @"
 using System;
@@ -469,6 +470,6 @@ class Something
     }
 }
 ";
-        AssertGeneratedAsExpected(source, generated);
+        await AssertGeneratedAsExpected(source, generated);
     }
 }
diff --git a/src/CodeGeneration.Roslyn.Tests/Helpers/CompilationTestsBase.cs b/src/CodeGeneration.Roslyn.Tests/Helpers/CompilationTestsBase.cs
@@ -6,6 +6,7 @@
 using System.IO;
 using System.Linq;
 using System.Reflection;
+using System.Threading.Tasks;
 using CodeGeneration.Roslyn;
 using CodeGeneration.Roslyn.Engine;
 using CodeGeneration.Roslyn.Tests.Generators;
@@ -54,9 +55,9 @@ static CompilationTestsBase()
 
     internal static readonly ImmutableArray<MetadataReference> MetadataReferences;
 
-    protected static void AssertGeneratedAsExpected(string source, string expected)
+    protected static async Task AssertGeneratedAsExpected(string source, string expected)
     {
-        var generatedTree = Generate(source);
+        var generatedTree = await GenerateAsync(source);
         // normalize line endings to just LF
         var generatedText = NormalizeToLf(generatedTree.GetText().ToString());
         // and append preamble to the expected
@@ -69,15 +70,15 @@ protected static string NormalizeToLf(string input)
         return input?.Replace(CrLf, Lf);
     }
 
-    protected static SyntaxTree Generate(string source)
+    protected static async Task<SyntaxTree> GenerateAsync(string source)
     {
         var document = CreateProject(source).Documents.Single();
-        var tree = document.GetSyntaxTreeAsync().GetAwaiter().GetResult();
-        var compilation = (CSharpCompilation)document.Project.GetCompilationAsync().GetAwaiter().GetResult();
+        var tree = await document.GetSyntaxTreeAsync();
+        var compilation = (CSharpCompilation)(await document.Project.GetCompilationAsync());
         var diagnostics = compilation.GetDiagnostics();
         Assert.Empty(diagnostics.Where(x => x.Severity >= DiagnosticSeverity.Warning));
         var progress = new Progress<Diagnostic>();
-        var result = DocumentTransform.TransformAsync(compilation, tree, null, Assembly.Load, progress).GetAwaiter().GetResult();
+        var result = await DocumentTransform.TransformAsync(compilation, tree, null, Assembly.Load, progress);
         return result;
     }
 
diff --git a/src/CodeGeneration.Roslyn.Tool/Program.cs b/src/CodeGeneration.Roslyn.Tool/Program.cs
@@ -6,13 +6,14 @@ namespace CodeGeneration.Roslyn.Generate
     using System;
     using System.Collections.Generic;
     using System.IO;
+    using System.Threading.Tasks;
     using CodeGeneration.Roslyn.Engine;
     using CodeGeneration.Roslyn.Tool.CommandLine;
     using Microsoft.CodeAnalysis;
 
     internal static class Program
     {
-        private static int Main(string[] args)
+        private static async Task<int> Main(string[] args)
         {
             IReadOnlyList<string> compile = Array.Empty<string>();
             IReadOnlyList<string> refs = Array.Empty<string>();
@@ -65,7 +66,7 @@ private static int Main(string[] args)
 
             try
             {
-                generator.Generate(progress);
+                await generator.GenerateAsync(progress);
             }
             catch (Exception e)
             {

Original file line number	Diff line number	Diff line change
`@@ -1,25 +1,26 @@`
`1`	`1`	`// Copyright (c) Andrew Arnott. All rights reserved.`
`2`	`2`	`// Licensed under the MS-PL license. See LICENSE.txt file in the project root for full license information.`
`3`	`3`
	`4`	`+using System.Threading.Tasks;`
`4`	`5`	`using Xunit;`
`5`	`6`
`6`	`7`	`public class DocumentTransformTests : CompilationTestsBase`
`7`	`8`	`{`
`8`	`9`	`[Fact]`
`9`		`- public void EmptyFile_NoGenerators()`
	`10`	`+ public async Task EmptyFile_NoGenerators()`
`10`	`11`	`{`
`11`		`- AssertGeneratedAsExpected("", "");`
	`12`	`+ await AssertGeneratedAsExpected("", "");`
`12`	`13`	`}`
`13`	`14`
`14`	`15`	`[Fact]`
`15`		`- public void Usings_WhenNoCode_CopiedToOutput()`
	`16`	`+ public async Task Usings_WhenNoCode_CopiedToOutput()`
`16`	`17`	`{`
`17`	`18`	`const string usings = "using System;";`
`18`		`- AssertGeneratedAsExpected(usings, usings);`
	`19`	`+ await AssertGeneratedAsExpected(usings, usings);`
`19`	`20`	`}`
`20`	`21`
`21`	`22`	`[Fact]`
`22`		`- public void AncestorTree_IsBuiltProperly()`
	`23`	`+ public async Task AncestorTree_IsBuiltProperly()`
`23`	`24`	`{`
`24`	`25`	`const string source = @"`
`25`	`26`	`using System;`
`@@ -66,11 +67,11 @@ partial struct InnerStruct<T1, T2>`
`66`	`67`	`}`
`67`	`68`	`}`
`68`	`69`	`}";`
`69`		`- AssertGeneratedAsExpected(source, generated);`
	`70`	`+ await AssertGeneratedAsExpected(source, generated);`
`70`	`71`	`}`
`71`	`72`
`72`	`73`	`[Fact]`
`73`		`- public void DefineDirective_Dropped()`
	`74`	`+ public async Task DefineDirective_Dropped()`
`74`	`75`	`{`
`75`	`76`	`// define directives must be leading any other tokens to be valid in C#`
`76`	`77`	`const string source = @"`
`@@ -80,11 +81,11 @@ public void DefineDirective_Dropped()`
`80`	`81`	`const string generated = @"`
`81`	`82`	`using System;`
`82`	`83`	`using System.Linq;";`
`83`		`- AssertGeneratedAsExpected(source, generated);`
	`84`	`+ await AssertGeneratedAsExpected(source, generated);`
`84`	`85`	`}`
`85`	`86`
`86`	`87`	`[Fact]`
`87`		`- public void Comment_BetweenUsings_Dropped()`
	`88`	`+ public async Task Comment_BetweenUsings_Dropped()`
`88`	`89`	`{`
`89`	`90`	`const string source = @"`
`90`	`91`	`using System;`
`@@ -93,11 +94,11 @@ public void Comment_BetweenUsings_Dropped()`
`93`	`94`	`const string generated = @"`
`94`	`95`	`using System;`
`95`	`96`	`using System.Linq;";`
`96`		`- AssertGeneratedAsExpected(source, generated);`
	`97`	`+ await AssertGeneratedAsExpected(source, generated);`
`97`	`98`	`}`
`98`	`99`
`99`	`100`	`[Fact]`
`100`		`- public void Region_TrailingUsings_Dropped()`
	`101`	`+ public async Task Region_TrailingUsings_Dropped()`
`101`	`102`	`{`
`102`	`103`	`const string source = @"`
`103`	`104`	`using System;`
`@@ -107,11 +108,11 @@ public void Region_TrailingUsings_Dropped()`
`107`	`108`	`const string generated = @"`
`108`	`109`	`using System;`
`109`	`110`	`using System.Linq;";`
`110`		`- AssertGeneratedAsExpected(source, generated);`
	`111`	`+ await AssertGeneratedAsExpected(source, generated);`
`111`	`112`	`}`
`112`	`113`
`113`	`114`	`[Fact]`
`114`		`- public void IfElseDirective_OnUsings_InactiveUsingAndDirectives_Dropped()`
	`115`	`+ public async Task IfElseDirective_OnUsings_InactiveUsingAndDirectives_Dropped()`
`115`	`116`	`{`
`116`	`117`	`const string source = @"`
`117`	`118`	`using System;`
`@@ -134,11 +135,11 @@ partial class Empty {}";`
`134`	`135`	`partial class Empty`
`135`	`136`	`{`
`136`	`137`	`}";`
`137`		`- AssertGeneratedAsExpected(source, generated);`
	`138`	`+ await AssertGeneratedAsExpected(source, generated);`
`138`	`139`	`}`
`139`	`140`
`140`	`141`	`[Fact]`
`141`		`- public void RegionDirective_InsideClass_Dropped()`
	`142`	`+ public async Task RegionDirective_InsideClass_Dropped()`
`142`	`143`	`{`
`143`	`144`	`const string source = @"`
`144`	`145`	`using System;`
`@@ -158,11 +159,11 @@ partial class Empty`
`158`	`159`	`partial class Empty`
`159`	`160`	`{`
`160`	`161`	`}";`
`161`		`- AssertGeneratedAsExpected(source, generated);`
	`162`	`+ await AssertGeneratedAsExpected(source, generated);`
`162`	`163`	`}`
`163`	`164`
`164`	`165`	`[Fact]`
`165`		`- public void RegionDirective_InsideStruct_Dropped()`
	`166`	`+ public async Task RegionDirective_InsideStruct_Dropped()`
`166`	`167`	`{`
`167`	`168`	`const string source = @"`
`168`	`169`	`using System;`
`@@ -182,11 +183,11 @@ partial struct Empty`
`182`	`183`	`partial struct Empty`
`183`	`184`	`{`
`184`	`185`	`}";`
`185`		`- AssertGeneratedAsExpected(source, generated);`
	`186`	`+ await AssertGeneratedAsExpected(source, generated);`
`186`	`187`	`}`
`187`	`188`
`188`	`189`	`[Fact]`
`189`		`- public void RegionDirective_InsideNamespace_Dropped()`
	`190`	`+ public async Task RegionDirective_InsideNamespace_Dropped()`
`190`	`191`	`{`
`191`	`192`	`const string source = @"`
`192`	`193`	`using System;`
`@@ -209,11 +210,11 @@ partial class Empty`
`209`	`210`	`{`
`210`	`211`	`}`
`211`	`212`	`}";`
`212`		`- AssertGeneratedAsExpected(source, generated);`
	`213`	`+ await AssertGeneratedAsExpected(source, generated);`
`213`	`214`	`}`
`214`	`215`
`215`	`216`	`[Fact]`
`216`		`- public void Class_Modifiers_ArePreserved_WithoutTrivia()`
	`217`	`+ public async Task Class_Modifiers_ArePreserved_WithoutTrivia()`
`217`	`218`	`{`
`218`	`219`	`const string source = @"`
`219`	`220`	`using System;`
`@@ -238,11 +239,11 @@ public static partial class Empty`
`238`	`239`	`{`
`239`	`240`	`}`
`240`	`241`	`}";`
`241`		`- AssertGeneratedAsExpected(source, generated);`
	`242`	`+ await AssertGeneratedAsExpected(source, generated);`
`242`	`243`	`}`
`243`	`244`
`244`	`245`	`[Fact]`
`245`		`- public void Struct_Modifiers_ArePreserved_WithoutTrivia()`
	`246`	`+ public async Task Struct_Modifiers_ArePreserved_WithoutTrivia()`
`246`	`247`	`{`
`247`	`248`	`const string source = @"`
`248`	`249`	`using System;`
`@@ -267,11 +268,11 @@ internal partial struct Empty`
`267`	`268`	`{`
`268`	`269`	`}`
`269`	`270`	`}";`
`270`		`- AssertGeneratedAsExpected(source, generated);`
	`271`	`+ await AssertGeneratedAsExpected(source, generated);`
`271`	`272`	`}`
`272`	`273`
`273`	`274`	`[Fact]`
`274`		`- public void Class_TypeParameters_ArePreserved()`
	`275`	`+ public async Task Class_TypeParameters_ArePreserved()`
`275`	`276`	`{`
`276`	`277`	`const string source = @"`
`277`	`278`	`using System;`
`@@ -295,11 +296,11 @@ partial class Empty<T>`
`295`	`296`	`{`
`296`	`297`	`}`
`297`	`298`	`}";`
`298`		`- AssertGeneratedAsExpected(source, generated);`
	`299`	`+ await AssertGeneratedAsExpected(source, generated);`
`299`	`300`	`}`
`300`	`301`
`301`	`302`	`[Fact]`
`302`		`- public void Struct_TypeParameters_ArePreserved()`
	`303`	`+ public async Task Struct_TypeParameters_ArePreserved()`
`303`	`304`	`{`
`304`	`305`	`const string source = @"`
`305`	`306`	`using System;`
`@@ -323,11 +324,11 @@ partial struct Empty<T>`
`323`	`324`	`{`
`324`	`325`	`}`
`325`	`326`	`}";`
`326`		`- AssertGeneratedAsExpected(source, generated);`
	`327`	`+ await AssertGeneratedAsExpected(source, generated);`
`327`	`328`	`}`
`328`	`329`
`329`	`330`	`[Fact]`
`330`		`- public void RichGenerator_Wraps_InOtherNamespace()`
	`331`	`+ public async Task RichGenerator_Wraps_InOtherNamespace()`
`331`	`332`	`{`
`332`	`333`	`const string source = @"`
`333`	`334`	`using System;`
`@@ -350,11 +351,11 @@ class Something`
`350`	`351`	`{`
`351`	`352`	`}`
`352`	`353`	`}";`
`353`		`- AssertGeneratedAsExpected(source, generated);`
	`354`	`+ await AssertGeneratedAsExpected(source, generated);`
`354`	`355`	`}`
`355`	`356`
`356`	`357`	`[Fact]`
`357`		`- public void RichGenerator_Adds_Using()`
	`358`	`+ public async Task RichGenerator_Adds_Using()`
`358`	`359`	`{`
`359`	`360`	`const string source = @"`
`360`	`361`	`using System;`
`@@ -373,11 +374,11 @@ partial class Something`
`373`	`374`	`using System.Collections.Generic;`
`374`	`375`
`375`	`376`	`";`
`376`		`- AssertGeneratedAsExpected(source, generated);`
	`377`	`+ await AssertGeneratedAsExpected(source, generated);`
`377`	`378`	`}`
`378`	`379`
`379`	`380`	`[Fact]`
`380`		`- public void RichGenerator_Adds_ExternAlias()`
	`381`	`+ public async Task RichGenerator_Adds_ExternAlias()`
`381`	`382`	`{`
`382`	`383`	`const string source = @"`
`383`	`384`	`using System;`
`@@ -397,11 +398,11 @@ partial class Something`
`397`	`398`	`using CodeGeneration.Roslyn.Tests.Generators;`
`398`	`399`
`399`	`400`	`";`
`400`		`- AssertGeneratedAsExpected(source, generated);`
	`401`	`+ await AssertGeneratedAsExpected(source, generated);`
`401`	`402`	`}`
`402`	`403`
`403`	`404`	`[Fact]`
`404`		`- public void RichGenerator_Adds_Attribute()`
	`405`	`+ public async Task RichGenerator_Adds_Attribute()`
`405`	`406`	`{`
`406`	`407`	`const string source = @"`
`407`	`408`	`using System;`
`@@ -420,11 +421,11 @@ partial class Something`
`420`	`421`
`421`	`422`	`[GeneratedAttribute]`
`422`	`423`	`";`
`423`		`- AssertGeneratedAsExpected(source, generated);`
	`424`	`+ await AssertGeneratedAsExpected(source, generated);`
`424`	`425`	`}`
`425`	`426`
`426`	`427`	`[Fact]`
`427`		`- public void RichGenerator_Appends_MultipleResults()`
	`428`	`+ public async Task RichGenerator_Appends_MultipleResults()`
`428`	`429`	`{`
`429`	`430`	`const string source = @"`
`430`	`431`	`using System;`
`@@ -469,6 +470,6 @@ class Something`
`469`	`470`	`}`
`470`	`471`	`}`
`471`	`472`	`";`
`472`		`- AssertGeneratedAsExpected(source, generated);`
	`473`	`+ await AssertGeneratedAsExpected(source, generated);`
`473`	`474`	`}`
`474`	`475`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,13 +6,14 @@ namespace CodeGeneration.Roslyn.Generate`
`6`	`6`	`using System;`
`7`	`7`	`using System.Collections.Generic;`
`8`	`8`	`using System.IO;`
	`9`	`+ using System.Threading.Tasks;`
`9`	`10`	`using CodeGeneration.Roslyn.Engine;`
`10`	`11`	`using CodeGeneration.Roslyn.Tool.CommandLine;`
`11`	`12`	`using Microsoft.CodeAnalysis;`
`12`	`13`
`13`	`14`	`internal static class Program`
`14`	`15`	`{`
`15`		`- private static int Main(string[] args)`
	`16`	`+ private static async Task<int> Main(string[] args)`
`16`	`17`	`{`
`17`	`18`	`IReadOnlyList<string> compile = Array.Empty<string>();`
`18`	`19`	`IReadOnlyList<string> refs = Array.Empty<string>();`
`@@ -65,7 +66,7 @@ private static int Main(string[] args)`
`65`	`66`
`66`	`67`	`try`
`67`	`68`	`{`
`68`		`- generator.Generate(progress);`
	`69`	`+ await generator.GenerateAsync(progress);`
`69`	`70`	`}`
`70`	`71`	`catch (Exception e)`
`71`	`72`	`{`