Make the generator cancellable

manne · manne · commit 34c830b0ae5d · 2020-01-06T19:41:37.000+01:00
diff --git a/src/.editorconfig b/src/.editorconfig
@@ -0,0 +1,4 @@
+﻿[*.cs]
+
+# CS0028: 'Program.Main(string[], CancellationToken)' has the wrong signature to be an entry point
+dotnet_diagnostic.CS0028.severity = none
diff --git a/src/CodeGeneration.Roslyn.Engine/CompilationGenerator.cs b/src/CodeGeneration.Roslyn.Engine/CompilationGenerator.cs
@@ -84,7 +84,7 @@ public class CompilationGenerator
         /// <param name="progress">Optional handler of diagnostics provided by code generator.</param>
         /// <param name="cancellationToken">Cancellation token to interrupt async operations.</param>
         /// <returns>A <see cref="Task.CompletedTask"/>.</returns>
-        public async Task GenerateAsync(IProgress<Diagnostic> progress = null, CancellationToken cancellationToken = default)
+        public async Task GenerateAsync(IProgress<Diagnostic> progress, CancellationToken cancellationToken)
         {
             Verify.Operation(this.Compile != null, $"{nameof(Compile)} must be set first.");
             Verify.Operation(this.ReferencePath != null, $"{nameof(ReferencePath)} must be set first.");
@@ -104,13 +104,14 @@ public async Task GenerateAsync(IProgress<Diagnostic> progress = null, Cancellat
                 {
                     cancellationToken.ThrowIfCancellationRequested();
 
-                    string sourceHash = Convert.ToBase64String(hasher.ComputeHash(Encoding.UTF8.GetBytes(inputSyntaxTree.FilePath)), 0, 6).Replace('/', '-');
+                    string sourceHash = Convert.ToBase64String(hasher.ComputeHash(Encoding.UTF8.GetBytes(inputSyntaxTree.FilePath)), 0, 6).Replace(Path.AltDirectorySeparatorChar, '-').Replace(Path.DirectorySeparatorChar, '-');
                     Logger.Info($"File \"{inputSyntaxTree.FilePath}\" hashed to {sourceHash}");
-                    string outputFilePath = Path.Combine(this.IntermediateOutputDirectory, Path.GetFileNameWithoutExtension(inputSyntaxTree.FilePath) + $".{sourceHash}.generated.cs");
+                    string outputFilePath = Path.Combine(this.IntermediateOutputDirectory, Path.GetFileNameWithoutExtension(inputSyntaxTree.FilePath) + FormattableString.Invariant($".{sourceHash}.generated.cs"));
+                    var outputFile = new FileInfo(outputFilePath);
 
                     // Code generation is relatively fast, but it's not free.
                     // So skip files that haven't changed since we last generated them.
-                    DateTime outputLastModified = File.Exists(outputFilePath) ? File.GetLastWriteTime(outputFilePath) : DateTime.MinValue;
+                    DateTime outputLastModified = outputFile.Exists ? outputFile.LastWriteTime : DateTime.MinValue;
                     if (File.GetLastWriteTime(inputSyntaxTree.FilePath) > outputLastModified || assembliesLastModified > outputLastModified)
                     {
                         int retriesLeft = 3;
@@ -123,13 +124,13 @@ public async Task GenerateAsync(IProgress<Diagnostic> progress = null, Cancellat
                                     inputSyntaxTree,
                                     this.ProjectDirectory,
                                     this.LoadPlugin,
-                                    progress);
-
-                                var outputText = generatedSyntaxTree.GetText(cancellationToken);
-                                using (var outputFileStream = File.OpenWrite(outputFilePath))
+                                    progress,
+                                    cancellationToken);
+                                var outputText = await generatedSyntaxTree.GetTextAsync(cancellationToken);
+                                using (var outputFileStream = outputFile.OpenWrite())
                                 using (var outputWriter = new StreamWriter(outputFileStream))
                                 {
-                                    outputText.Write(outputWriter);
+                                    outputText.Write(outputWriter, cancellationToken);
 
                                     // Truncate any data that may be beyond this point if the file existed previously.
                                     outputWriter.Flush();
@@ -142,15 +143,15 @@ public async Task GenerateAsync(IProgress<Diagnostic> progress = null, Cancellat
                                     bool anyTypesGenerated = root.DescendantNodes().OfType<TypeDeclarationSyntax>().Any();
                                     if (!anyTypesGenerated)
                                     {
-                                        this.emptyGeneratedFiles.Add(outputFilePath);
+                                        this.emptyGeneratedFiles.Add(outputFile.FullName);
                                     }
                                 }
                                 break;
                             }
                             catch (IOException ex) when (ex.HResult == ProcessCannotAccessFileHR && retriesLeft > 0)
                             {
                                 retriesLeft--;
-                                Task.Delay(200).Wait();
+                                await Task.Delay(200, cancellationToken);
                             }
                             catch (Exception ex)
                             {
@@ -162,7 +163,7 @@ public async Task GenerateAsync(IProgress<Diagnostic> progress = null, Cancellat
                         while (true);
                     }
 
-                    this.generatedFiles.Add(outputFilePath);
+                    this.generatedFiles.Add(outputFile.FullName);
                 }
             }
 
@@ -232,10 +233,7 @@ private static void ReportError(IProgress<Diagnostic> progress, string id, Synta
 
             var location = inputSyntaxTree != null ? Location.Create(inputSyntaxTree, TextSpan.FromBounds(0, 0)) : Location.None;
 
-            var messageArgs = new object[]
-            {
-                ex,
-            };
+            var messageArgs = new object[] { ex };
 
             var reportDiagnostic = Diagnostic.Create(descriptor, location, messageArgs);
 
diff --git a/src/CodeGeneration.Roslyn.Engine/DocumentTransform.cs b/src/CodeGeneration.Roslyn.Engine/DocumentTransform.cs
@@ -42,13 +42,15 @@ public static class DocumentTransform
         /// <param name="projectDirectory">The path of the <c>.csproj</c> project file.</param>
         /// <param name="assemblyLoader">A function that can load an assembly with the given name.</param>
         /// <param name="progress">Reports warnings and errors in code generation.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
         /// <returns>A task whose result is the generated document.</returns>
         public static async Task<SyntaxTree> TransformAsync(
             CSharpCompilation compilation,
             SyntaxTree inputDocument,
             string projectDirectory,
             Func<AssemblyName, Assembly> assemblyLoader,
-            IProgress<Diagnostic> progress)
+            IProgress<Diagnostic> progress,
+            CancellationToken cancellationToken)
         {
             Requires.NotNull(compilation, nameof(compilation));
             Requires.NotNull(inputDocument, nameof(inputDocument));
@@ -70,17 +72,19 @@ public static async Task<SyntaxTree> TransformAsync(
             var emittedAttributeLists = ImmutableArray<AttributeListSyntax>.Empty;
             var emittedMembers = ImmutableArray<MemberDeclarationSyntax>.Empty;
 
-            var root = await inputDocument.GetRootAsync();
+            var root = await inputDocument.GetRootAsync(cancellationToken);
             var memberNodes = root
                 .DescendantNodesAndSelf(n => n is CompilationUnitSyntax || n is NamespaceDeclarationSyntax || n is TypeDeclarationSyntax)
                 .OfType<CSharpSyntaxNode>();
 
             foreach (var memberNode in memberNodes)
             {
+                cancellationToken.ThrowIfCancellationRequested();
                 var attributeData = GetAttributeData(compilation, inputSemanticModel, memberNode);
                 var generators = FindCodeGenerators(attributeData, assemblyLoader);
                 foreach (var generator in generators)
                 {
+                    cancellationToken.ThrowIfCancellationRequested();
                     var context = new TransformationContext(
                         memberNode,
                         inputSemanticModel,
@@ -91,7 +95,7 @@ public static async Task<SyntaxTree> TransformAsync(
 
                     var richGenerator = generator as IRichCodeGenerator ?? new EnrichingCodeGeneratorProxy(generator);
 
-                    var emitted = await richGenerator.GenerateRichAsync(context, progress, CancellationToken.None);
+                    var emitted = await richGenerator.GenerateRichAsync(context, progress, cancellationToken);
 
                     emittedExterns = emittedExterns.AddRange(emitted.Externs);
                     emittedUsings = emittedUsings.AddRange(emitted.Usings);
@@ -244,7 +248,7 @@ public Task<SyntaxList<MemberDeclarationSyntax>> GenerateAsync(
 
             public async Task<RichGenerationResult> GenerateRichAsync(TransformationContext context, IProgress<Diagnostic> progress, CancellationToken cancellationToken)
             {
-                var generatedMembers = await CodeGenerator.GenerateAsync(context, progress, CancellationToken.None);
+                var generatedMembers = await CodeGenerator.GenerateAsync(context, progress, cancellationToken);
 
                 // Figure out ancestry for the generated type, including nesting types and namespaces.
                 var wrappedMembers = context.ProcessingNode.Ancestors().Aggregate(generatedMembers, WrapInAncestor);
diff --git a/src/CodeGeneration.Roslyn.Tests.Generators/DuplicateWithSuffixGenerator.cs b/src/CodeGeneration.Roslyn.Tests.Generators/DuplicateWithSuffixGenerator.cs
@@ -35,8 +35,7 @@ public Task<SyntaxList<MemberDeclarationSyntax>> GenerateAsync(TransformationCon
             var results = SyntaxFactory.List<MemberDeclarationSyntax>();
 
             MemberDeclarationSyntax copy = null;
-            var applyToClass = context.ProcessingNode as ClassDeclarationSyntax;
-            if (applyToClass != null)
+            if (context.ProcessingNode is ClassDeclarationSyntax applyToClass)
             {
                 copy = applyToClass
                     .WithIdentifier(SyntaxFactory.Identifier(applyToClass.Identifier.ValueText + this.suffix));
diff --git a/src/CodeGeneration.Roslyn.Tests.Generators/ExternalDuplicateWithSuffixGenerator.cs b/src/CodeGeneration.Roslyn.Tests.Generators/ExternalDuplicateWithSuffixGenerator.cs
@@ -4,10 +4,7 @@
 namespace CodeGeneration.Roslyn.Tests.Generators
 {
     using System;
-    using System.Collections.Generic;
     using System.Collections.Immutable;
-    using System.Linq;
-    using System.Text;
     using System.Threading;
     using System.Threading.Tasks;
     using CodeGeneration.Roslyn.Tests.Generators.Dependency;
@@ -36,8 +33,7 @@ public Task<SyntaxList<MemberDeclarationSyntax>> GenerateAsync(TransformationCon
             var results = SyntaxFactory.List<MemberDeclarationSyntax>();
 
             MemberDeclarationSyntax copy = null;
-            var applyToClass = context.ProcessingNode as MethodDeclarationSyntax;
-            if (applyToClass != null)
+            if (context.ProcessingNode is MethodDeclarationSyntax applyToClass)
             {
                 copy = applyToClass
                     .WithIdentifier(SyntaxFactory.Identifier(NameGenerator.Combine(applyToClass.Identifier.ValueText, this.suffix)))
diff --git a/src/CodeGeneration.Roslyn.Tests.Generators/MultiplySuffixGenerator.cs b/src/CodeGeneration.Roslyn.Tests.Generators/MultiplySuffixGenerator.cs
@@ -4,10 +4,7 @@
 namespace CodeGeneration.Roslyn.Tests.Generators
 {
     using System;
-    using System.Collections.Generic;
-    using System.Collections.Immutable;
     using System.Linq;
-    using System.Text;
     using System.Threading;
     using System.Threading.Tasks;
     using Microsoft.CodeAnalysis;
@@ -28,8 +25,7 @@ public Task<SyntaxList<MemberDeclarationSyntax>> GenerateAsync(TransformationCon
             var results = SyntaxFactory.List<MemberDeclarationSyntax>();
 
             MemberDeclarationSyntax copy = null;
-            var applyToClass = context.ProcessingNode as ClassDeclarationSyntax;
-            if (applyToClass != null)
+            if (context.ProcessingNode is ClassDeclarationSyntax applyToClass)
             {
                 var properties = applyToClass.Members.OfType<PropertyDeclarationSyntax>()
                     .Select(x =>
diff --git a/src/CodeGeneration.Roslyn.Tests.RunBuild/Program.cs b/src/CodeGeneration.Roslyn.Tests.RunBuild/Program.cs
@@ -5,7 +5,7 @@ namespace CodeGeneration.Roslyn.Tests.RunBuild
 {
     internal static class Program
     {
-        private static void Main(string[] args)
+        private static void Main()
         {
             // This app is a dummy. But when it is debugged within VS, it builds the Tests
             // allowing VS to debug into the build/code generation process.
diff --git a/src/CodeGeneration.Roslyn.Tests/CodeGenerationTests.cs b/src/CodeGeneration.Roslyn.Tests/CodeGenerationTests.cs
@@ -16,9 +16,9 @@ public partial class CodeGenerationTests
     [Fact]
     public void SimpleGenerationWorks()
     {
-        var foo = new CodeGenerationTests.Foo();
-        var fooA = new CodeGenerationTests.FooA();
-        var fooB = new CodeGenerationTests.FooB();
+        _ = new CodeGenerationTests.Foo();
+        _ = new CodeGenerationTests.FooA();
+        _ = new CodeGenerationTests.FooB();
         var multiplied = new MultipliedBar();
         multiplied.ValueSuff1020();
         Assert.EndsWith(Path.Combine("src", "CodeGeneration.Roslyn.Tests"), DirectoryPathTest.Path, StringComparison.OrdinalIgnoreCase);
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;
 using System.Threading.Tasks;
 using CodeGeneration.Roslyn;
 using CodeGeneration.Roslyn.Engine;
@@ -78,7 +79,7 @@ protected static async Task<SyntaxTree> GenerateAsync(string source)
         var diagnostics = compilation.GetDiagnostics();
         Assert.Empty(diagnostics.Where(x => x.Severity >= DiagnosticSeverity.Warning));
         var progress = new Progress<Diagnostic>();
-        var result = await DocumentTransform.TransformAsync(compilation, tree, null, Assembly.Load, progress);
+        var result = await DocumentTransform.TransformAsync(compilation, tree, null, Assembly.Load, progress, CancellationToken.None);
         return result;
     }
 
diff --git a/src/CodeGeneration.Roslyn.Tests/NestedNamespacesAndTypesTests.cs b/src/CodeGeneration.Roslyn.Tests/NestedNamespacesAndTypesTests.cs
@@ -13,7 +13,7 @@ public class NestedNamespacesAndTypesTests
     [Fact]
     public void NestedNamespaceTest()
     {
-        var nested = new A.B.OuterType.MiddleType.NestedNSTypeA();
+        _ = new A.B.OuterType.MiddleType.NestedNSTypeA();
     }
 }
 
diff --git a/src/CodeGeneration.Roslyn.Tests/OtherFolder/CodeGenerationTests.cs b/src/CodeGeneration.Roslyn.Tests/OtherFolder/CodeGenerationTests.cs
@@ -16,7 +16,7 @@ public partial class CodeGenerationTests
     [Fact]
     public void GenerationFromSecondFile()
     {
-        var bar = new BarC();
+        _ = new BarC();
     }
 
     [DuplicateWithSuffixByType("C")]
diff --git a/src/CodeGeneration.Roslyn.Tool/CommandLine/ArgumentToken.cs b/src/CodeGeneration.Roslyn.Tool/CommandLine/ArgumentToken.cs
@@ -49,14 +49,13 @@ private bool Equals(ArgumentToken other)
 
         public override bool Equals(object obj)
         {
-            if (ReferenceEquals(obj, null))
+            if (obj is null)
                 return false;
 
             if (ReferenceEquals(obj, this))
                 return true;
 
-            var other = obj as ArgumentToken;
-            return !ReferenceEquals(other, null) && Equals(other);
+            return (obj is ArgumentToken other) && Equals(other);
         }
 
         public override int GetHashCode()
diff --git a/src/CodeGeneration.Roslyn.Tool/Program.cs b/src/CodeGeneration.Roslyn.Tool/Program.cs
@@ -1,6 +1,8 @@
 ﻿// 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;
+
 namespace CodeGeneration.Roslyn.Generate
 {
     using System;
@@ -14,6 +16,24 @@ namespace CodeGeneration.Roslyn.Generate
     internal static class Program
     {
         private static async Task<int> Main(string[] args)
+        {
+            using (var cancellationTokenSource = new CancellationTokenSource())
+            {
+                var cancellationToken = cancellationTokenSource.Token;
+                Console.CancelKeyPress += ConsoleOnCancelKeyPress;
+
+                void ConsoleOnCancelKeyPress(object sender, ConsoleCancelEventArgs e)
+                {
+                    Console.CancelKeyPress -= ConsoleOnCancelKeyPress;
+                    cancellationTokenSource.Cancel();
+                    e.Cancel = true;
+                }
+
+                return await Core(args, cancellationToken);
+            }
+        }
+
+        private static async Task<int> Core(string[] args, CancellationToken cancellationToken)
         {
             IReadOnlyList<string> compile = Array.Empty<string>();
             IReadOnlyList<string> refs = Array.Empty<string>();
@@ -66,7 +86,7 @@ private static async Task<int> Main(string[] args)
 
             try
             {
-                await generator.GenerateAsync(progress);
+                await generator.GenerateAsync(progress, cancellationToken);
             }
             catch (Exception e)
             {
@@ -77,7 +97,7 @@ private static async Task<int> Main(string[] args)
 
             if (generatedCompileItemFile != null)
             {
-                File.WriteAllLines(generatedCompileItemFile, generator.GeneratedFiles);
+                await File.WriteAllLinesAsync(generatedCompileItemFile, generator.GeneratedFiles, cancellationToken);
             }
 
             foreach (var file in generator.GeneratedFiles)
@@ -88,6 +108,7 @@ private static async Task<int> Main(string[] args)
             return 0;
         }
 
+
         private static void OnDiagnosticProgress(Diagnostic diagnostic)
         {
             Console.WriteLine(diagnostic.ToString());
diff --git a/src/CodeGeneration.Roslyn.sln b/src/CodeGeneration.Roslyn.sln
@@ -5,6 +5,7 @@ VisualStudioVersion = 16.0.29519.181
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{0BA25C7A-1A7A-43DA-BF47-202B54C75C9B}"
 	ProjectSection(SolutionItems) = preProject
+		.editorconfig = .editorconfig
 		..\.gitignore = ..\.gitignore
 		..\azure-pipeline.yml = ..\azure-pipeline.yml
 		CodeGeneration.Roslyn.ruleset = CodeGeneration.Roslyn.ruleset
diff --git a/src/CodeGeneration.Roslyn/CodeGeneration.Roslyn.csproj b/src/CodeGeneration.Roslyn/CodeGeneration.Roslyn.csproj
@@ -5,6 +5,10 @@
     <Description>A package that offers libraries for creating a code generation attribute and the associated generator.</Description>
   </PropertyGroup>
 
+  <ItemGroup>
+    <None Include="..\.editorconfig" Link=".editorconfig" />
+  </ItemGroup>
+
   <ItemGroup>
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="[$(RoslynNugetVersion)]" />
   </ItemGroup>

-Original file line number
+Diff line change
@@ @@ -0,0 +1,4 @@ @@
 +[*.cs]
++
 +# CS0028: 'Program.Main(string[], CancellationToken)' has the wrong signature to be an entry point
 +dotnet_diagnostic.CS0028.severity = none
Original file line number	Diff line number	Diff line change
`@@ -84,7 +84,7 @@ public class CompilationGenerator`
`84`	`84`	`/// <param name="progress">Optional handler of diagnostics provided by code generator.</param>`
`85`	`85`	`/// <param name="cancellationToken">Cancellation token to interrupt async operations.</param>`
`86`	`86`	`/// <returns>A <see cref="Task.CompletedTask"/>.</returns>`
`87`		`- public async Task GenerateAsync(IProgress<Diagnostic> progress = null, CancellationToken cancellationToken = default)`
	`87`	`+ public async Task GenerateAsync(IProgress<Diagnostic> progress, CancellationToken cancellationToken)`
`88`	`88`	`{`
`89`	`89`	`Verify.Operation(this.Compile != null, $"{nameof(Compile)} must be set first.");`
`90`	`90`	`Verify.Operation(this.ReferencePath != null, $"{nameof(ReferencePath)} must be set first.");`
`@@ -104,13 +104,14 @@ public async Task GenerateAsync(IProgress<Diagnostic> progress = null, Cancellat`
`104`	`104`	`{`
`105`	`105`	`cancellationToken.ThrowIfCancellationRequested();`
`106`	`106`
`107`		`- string sourceHash = Convert.ToBase64String(hasher.ComputeHash(Encoding.UTF8.GetBytes(inputSyntaxTree.FilePath)), 0, 6).Replace('/', '-');`
	`107`	`+ string sourceHash = Convert.ToBase64String(hasher.ComputeHash(Encoding.UTF8.GetBytes(inputSyntaxTree.FilePath)), 0, 6).Replace(Path.AltDirectorySeparatorChar, '-').Replace(Path.DirectorySeparatorChar, '-');`
`108`	`108`	`Logger.Info($"File \"{inputSyntaxTree.FilePath}\" hashed to {sourceHash}");`
`109`		`- string outputFilePath = Path.Combine(this.IntermediateOutputDirectory, Path.GetFileNameWithoutExtension(inputSyntaxTree.FilePath) + $".{sourceHash}.generated.cs");`
	`109`	`+ string outputFilePath = Path.Combine(this.IntermediateOutputDirectory, Path.GetFileNameWithoutExtension(inputSyntaxTree.FilePath) + FormattableString.Invariant($".{sourceHash}.generated.cs"));`
	`110`	`+ var outputFile = new FileInfo(outputFilePath);`
`110`	`111`
`111`	`112`	`// Code generation is relatively fast, but it's not free.`
`112`	`113`	`// So skip files that haven't changed since we last generated them.`
`113`		`- DateTime outputLastModified = File.Exists(outputFilePath) ? File.GetLastWriteTime(outputFilePath) : DateTime.MinValue;`
	`114`	`+ DateTime outputLastModified = outputFile.Exists ? outputFile.LastWriteTime : DateTime.MinValue;`
`114`	`115`	`if (File.GetLastWriteTime(inputSyntaxTree.FilePath) > outputLastModified \|\| assembliesLastModified > outputLastModified)`
`115`	`116`	`{`
`116`	`117`	`int retriesLeft = 3;`
`@@ -123,13 +124,13 @@ public async Task GenerateAsync(IProgress<Diagnostic> progress = null, Cancellat`
`123`	`124`	`inputSyntaxTree,`
`124`	`125`	`this.ProjectDirectory,`
`125`	`126`	`this.LoadPlugin,`
`126`		`- progress);`
`127`		`-`
`128`		`- var outputText = generatedSyntaxTree.GetText(cancellationToken);`
`129`		`- using (var outputFileStream = File.OpenWrite(outputFilePath))`
	`127`	`+ progress,`
	`128`	`+ cancellationToken);`
	`129`	`+ var outputText = await generatedSyntaxTree.GetTextAsync(cancellationToken);`
	`130`	`+ using (var outputFileStream = outputFile.OpenWrite())`
`130`	`131`	`using (var outputWriter = new StreamWriter(outputFileStream))`
`131`	`132`	`{`
`132`		`- outputText.Write(outputWriter);`
	`133`	`+ outputText.Write(outputWriter, cancellationToken);`
`133`	`134`
`134`	`135`	`// Truncate any data that may be beyond this point if the file existed previously.`
`135`	`136`	`outputWriter.Flush();`
`@@ -142,15 +143,15 @@ public async Task GenerateAsync(IProgress<Diagnostic> progress = null, Cancellat`
`142`	`143`	`bool anyTypesGenerated = root.DescendantNodes().OfType<TypeDeclarationSyntax>().Any();`
`143`	`144`	`if (!anyTypesGenerated)`
`144`	`145`	`{`
`145`		`- this.emptyGeneratedFiles.Add(outputFilePath);`
	`146`	`+ this.emptyGeneratedFiles.Add(outputFile.FullName);`
`146`	`147`	`}`
`147`	`148`	`}`
`148`	`149`	`break;`
`149`	`150`	`}`
`150`	`151`	`catch (IOException ex) when (ex.HResult == ProcessCannotAccessFileHR && retriesLeft > 0)`
`151`	`152`	`{`
`152`	`153`	`retriesLeft--;`
`153`		`- Task.Delay(200).Wait();`
	`154`	`+ await Task.Delay(200, cancellationToken);`
`154`	`155`	`}`
`155`	`156`	`catch (Exception ex)`
`156`	`157`	`{`
`@@ -162,7 +163,7 @@ public async Task GenerateAsync(IProgress<Diagnostic> progress = null, Cancellat`
`162`	`163`	`while (true);`
`163`	`164`	`}`
`164`	`165`
`165`		`- this.generatedFiles.Add(outputFilePath);`
	`166`	`+ this.generatedFiles.Add(outputFile.FullName);`
`166`	`167`	`}`
`167`	`168`	`}`
`168`	`169`
`@@ -232,10 +233,7 @@ private static void ReportError(IProgress<Diagnostic> progress, string id, Synta`
`232`	`233`
`233`	`234`	`var location = inputSyntaxTree != null ? Location.Create(inputSyntaxTree, TextSpan.FromBounds(0, 0)) : Location.None;`
`234`	`235`
`235`		`- var messageArgs = new object[]`
`236`		`- {`
`237`		`- ex,`
`238`		`- };`
	`236`	`+ var messageArgs = new object[] { ex };`
`239`	`237`
`240`	`238`	`var reportDiagnostic = Diagnostic.Create(descriptor, location, messageArgs);`
`241`	`239`
Original file line number	Diff line number	Diff line change
`@@ -35,8 +35,7 @@ public Task<SyntaxList<MemberDeclarationSyntax>> GenerateAsync(TransformationCon`
`35`	`35`	`var results = SyntaxFactory.List<MemberDeclarationSyntax>();`
`36`	`36`
`37`	`37`	`MemberDeclarationSyntax copy = null;`
`38`		`- var applyToClass = context.ProcessingNode as ClassDeclarationSyntax;`
`39`		`- if (applyToClass != null)`
	`38`	`+ if (context.ProcessingNode is ClassDeclarationSyntax applyToClass)`
`40`	`39`	`{`
`41`	`40`	`copy = applyToClass`
`42`	`41`	`.WithIdentifier(SyntaxFactory.Identifier(applyToClass.Identifier.ValueText + this.suffix));`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@ namespace CodeGeneration.Roslyn.Tests.RunBuild`
`5`	`5`	`{`
`6`	`6`	`internal static class Program`
`7`	`7`	`{`
`8`		`- private static void Main(string[] args)`
	`8`	`+ private static void Main()`
`9`	`9`	`{`
`10`	`10`	`// This app is a dummy. But when it is debugged within VS, it builds the Tests`
`11`	`11`	`// allowing VS to debug into the build/code generation process.`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ public class NestedNamespacesAndTypesTests`
`13`	`13`	`[Fact]`
`14`	`14`	`public void NestedNamespaceTest()`
`15`	`15`	`{`
`16`		`- var nested = new A.B.OuterType.MiddleType.NestedNSTypeA();`
	`16`	`+ _ = new A.B.OuterType.MiddleType.NestedNSTypeA();`
`17`	`17`	`}`
`18`	`18`	`}`
`19`	`19`