update dogfood

giggio · giggio · commit 59f91b25c119 · 2015-01-28T13:53:22.000-02:00
diff --git a/codecracker.test.ruleset b/codecracker.test.ruleset
@@ -0,0 +1,6 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<RuleSet Name="CodeCracker Rules for tests" Description="Our own rules applied to our own code. :)" ToolsVersion="14.0">
+  <Rules AnalyzerId="CodeCracker.CSharp" RuleNamespace="CodeCracker.CSharp">
+    <Rule Id="CC0061" Action="None" />
+  </Rules>
+</RuleSet>
diff --git a/codecrackerandall.test.ruleset b/codecrackerandall.test.ruleset
@@ -0,0 +1,5 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<RuleSet Name="CodeCrackerTestAndAllRules" ToolsVersion="14.0">
+  <Include Path="codecrackerandall.ruleset" Action="Default" />
+  <Include Path="codecracker.test.ruleset" Action="Default" />
+</RuleSet>
diff --git a/src/CSharp/CodeCracker/CodeCracker.csproj b/src/CSharp/CodeCracker/CodeCracker.csproj
@@ -194,7 +194,7 @@
     <Folder Include="Security\" />
   </ItemGroup>
   <ItemGroup>
-    <Analyzer Include="..\..\..\packages\codecracker.CSharp.1.0.0-alpha3-0311\tools\analyzers\CodeCracker.CSharp.dll" />
+    <Analyzer Include="..\..\..\packages\codecracker.CSharp.1.0.0-alpha3-0339\tools\analyzers\CodeCracker.CSharp.dll" />
   </ItemGroup>
   <Import Project="$(MSBuildExtensionsPath32)\Microsoft\Portable\$(TargetFrameworkVersion)\Microsoft.Portable.CSharp.targets" />
   <PropertyGroup>
diff --git a/src/CSharp/CodeCracker/Design/CopyEventToVariableBeforeFireCodeFixProvider.cs b/src/CSharp/CodeCracker/Design/CopyEventToVariableBeforeFireCodeFixProvider.cs
@@ -30,10 +30,10 @@ public sealed override async Task ComputeFixesAsync(CodeFixContext context)
             var invocation = root.FindToken(sourceSpan.Start).Parent.AncestorsAndSelf().OfType<InvocationExpressionSyntax>().First();
 
             context.RegisterFix(
-                CodeAction.Create("Copy event reference to a variable", ct => CreateVariable(context.Document, invocation, ct)), diagnostic);
+                CodeAction.Create("Copy event reference to a variable", ct => CreateVariableAsync(context.Document, invocation, ct)), diagnostic);
         }
 
-        private async Task<Document> CreateVariable(Document document, InvocationExpressionSyntax invocation, CancellationToken ct)
+        private async Task<Document> CreateVariableAsync(Document document, InvocationExpressionSyntax invocation, CancellationToken ct)
         {
             const string handlerName = "handler";
 
diff --git a/src/CSharp/CodeCracker/Design/EmptyCatchBlockCodeFixProvider.cs b/src/CSharp/CodeCracker/Design/EmptyCatchBlockCodeFixProvider.cs
@@ -31,7 +31,7 @@ public sealed override async Task ComputeFixesAsync(CodeFixContext context)
             context.RegisterFix(CodeAction.Create("Insert Exception class to Catch", c => InsertExceptionClassCommentAsync(context.Document, declaration, c)), diagnostic);
         }
 
-        private async Task<Document> RemoveTry(Document document, CatchClauseSyntax catchStatement, CancellationToken cancellationToken, bool insertComment = false)
+        private async Task<Document> RemoveTryAsync(Document document, CatchClauseSyntax catchStatement, CancellationToken cancellationToken, bool insertComment = false)
         {
             var tryStatement = (TryStatementSyntax)catchStatement.Parent;
             var tryBlock = tryStatement.Block;
@@ -51,12 +51,12 @@ private async Task<Document> RemoveTry(Document document, CatchClauseSyntax catc
 
         private async Task<Document> RemoveEmptyCatchBlockAsync(Document document, CatchClauseSyntax catchStatement, CancellationToken cancellationToken)
         {
-            return await RemoveTry(document, catchStatement, cancellationToken);
+            return await RemoveTryAsync(document, catchStatement, cancellationToken);
         }
 
         private async Task<Document> RemoveEmptyCatchBlockPutCommentAsync(Document document, CatchClauseSyntax catchStatement, CancellationToken cancellationToken)
         {
-            return await RemoveTry(document, catchStatement, cancellationToken, true);
+            return await RemoveTryAsync(document, catchStatement, cancellationToken, true);
         }
 
         private async Task<Document> InsertExceptionClassCommentAsync(Document document, CatchClauseSyntax catchStatement, CancellationToken cancellationToken)
diff --git a/src/CSharp/CodeCracker/Design/StaticConstructorExceptionCodeFixProvider.cs b/src/CSharp/CodeCracker/Design/StaticConstructorExceptionCodeFixProvider.cs
@@ -27,10 +27,10 @@ public sealed override async Task ComputeFixesAsync(CodeFixContext context)
             var @throw = root.FindToken(sourceSpan.Start).Parent.AncestorsAndSelf().OfType<ThrowStatementSyntax>().First();
 
             context.RegisterFix(
-                CodeAction.Create("Remove this exception", ct => RemoveThrow(context.Document, @throw, ct)), diagnostic);
+                CodeAction.Create("Remove this exception", ct => RemoveThrowAsync(context.Document, @throw, ct)), diagnostic);
         }
 
-        private async Task<Document> RemoveThrow(Document document, ThrowStatementSyntax @throw, CancellationToken ct)
+        private async Task<Document> RemoveThrowAsync(Document document, ThrowStatementSyntax @throw, CancellationToken ct)
         {
             return document.WithSyntaxRoot((await document.GetSyntaxRootAsync(ct)).RemoveNode(@throw, SyntaxRemoveOptions.KeepNoTrivia));
         }
diff --git a/src/CSharp/CodeCracker/Design/UseInvokeMethodToFireEventCodeFixProvider.cs b/src/CSharp/CodeCracker/Design/UseInvokeMethodToFireEventCodeFixProvider.cs
@@ -33,10 +33,10 @@ public sealed override async Task ComputeFixesAsync(CodeFixContext context)
             var invocation = root.FindToken(sourceSpan.Start).Parent.AncestorsAndSelf().OfType<InvocationExpressionSyntax>().First();
 
             context.RegisterFix(
-                CodeAction.Create("Use ?.Invoke operator and method to fire an event.", ct => UseInvoke(context.Document, invocation, ct)), diagnostic);
+                CodeAction.Create("Use ?.Invoke operator and method to fire an event.", ct => UseInvokeAsync(context.Document, invocation, ct)), diagnostic);
         }
 
-        private async Task<Document> UseInvoke(Document document, InvocationExpressionSyntax invocation, CancellationToken ct)
+        private async Task<Document> UseInvokeAsync(Document document, InvocationExpressionSyntax invocation, CancellationToken ct)
         {
             var newInvocation =
                     SyntaxFactory.ConditionalAccessExpression(
diff --git a/src/CSharp/CodeCracker/Performance/EmptyFinalizerCodeFixProvider.cs b/src/CSharp/CodeCracker/Performance/EmptyFinalizerCodeFixProvider.cs
@@ -28,10 +28,10 @@ public sealed override async Task ComputeFixesAsync(CodeFixContext context)
             var finalizer = root.FindToken(sourceSpan.Start).Parent.AncestorsAndSelf().OfType<DestructorDeclarationSyntax>().First();
 
             context.RegisterFix(
-                CodeAction.Create("Remove finalizer", ct => RemoveThrow(context.Document, finalizer, ct)), diagnostic);
+                CodeAction.Create("Remove finalizer", ct => RemoveThrowAsync(context.Document, finalizer, ct)), diagnostic);
         }
 
-        private async Task<Document> RemoveThrow(Document document, DestructorDeclarationSyntax finalizer, CancellationToken ct)
+        private async Task<Document> RemoveThrowAsync(Document document, DestructorDeclarationSyntax finalizer, CancellationToken ct)
         {
             return document.WithSyntaxRoot((await document.GetSyntaxRootAsync(ct)).RemoveNode(finalizer, SyntaxRemoveOptions.KeepNoTrivia));
         }
diff --git a/src/CSharp/CodeCracker/Performance/RemoveWhereWhenItIsPossibleCodeFixProvider.cs b/src/CSharp/CodeCracker/Performance/RemoveWhereWhenItIsPossibleCodeFixProvider.cs
@@ -27,10 +27,10 @@ public sealed override async Task ComputeFixesAsync(CodeFixContext context)
             var whereInvoke = root.FindToken(diagnosticSpan.Start).Parent.AncestorsAndSelf().OfType<InvocationExpressionSyntax>().First();
             var nextMethodInvoke = whereInvoke.Parent.FirstAncestorOrSelf<InvocationExpressionSyntax>();
             var message = "Remove 'Where' moving predicate to '" + RemoveWhereWhenItIsPossibleAnalyzer.GetNameOfTheInvokedMethod(nextMethodInvoke) + "'";
-            context.RegisterFix(CodeAction.Create(message, c => RemoveWhere(context.Document, whereInvoke, nextMethodInvoke, c)), diagnostic);
+            context.RegisterFix(CodeAction.Create(message, c => RemoveWhereAsync(context.Document, whereInvoke, nextMethodInvoke, c)), diagnostic);
         }
 
-        private async Task<Document> RemoveWhere(Document document, InvocationExpressionSyntax whereInvoke, InvocationExpressionSyntax nextMethodInvoke, CancellationToken cancellationToken)
+        private async Task<Document> RemoveWhereAsync(Document document, InvocationExpressionSyntax whereInvoke, InvocationExpressionSyntax nextMethodInvoke, CancellationToken cancellationToken)
         {
             var root = await document.GetSyntaxRootAsync(cancellationToken);
             var whereMemberAccess = whereInvoke.ChildNodes().OfType<MemberAccessExpressionSyntax>().FirstOrDefault();
diff --git a/src/CSharp/CodeCracker/Performance/SealedAttributeCodeFixProvider.cs b/src/CSharp/CodeCracker/Performance/SealedAttributeCodeFixProvider.cs
@@ -27,10 +27,10 @@ public sealed override async Task ComputeFixesAsync(CodeFixContext context)
             var sourceSpan = diagnostic.Location.SourceSpan;
             var type = root.FindToken(sourceSpan.Start).Parent.AncestorsAndSelf().OfType<ClassDeclarationSyntax>().First();
 
-            context.RegisterFix(CodeAction.Create("Mark as sealed", ct => MarkClassAsSealed(context.Document, type, ct)), diagnostic);
+            context.RegisterFix(CodeAction.Create("Mark as sealed", ct => MarkClassAsSealedAsync(context.Document, type, ct)), diagnostic);
         }
 
-        private async Task<Document> MarkClassAsSealed(Document document, ClassDeclarationSyntax type, CancellationToken ct)
+        private async Task<Document> MarkClassAsSealedAsync(Document document, ClassDeclarationSyntax type, CancellationToken ct)
         {
             return document
                 .WithSyntaxRoot((await document.GetSyntaxRootAsync(ct))
diff --git a/src/CSharp/CodeCracker/Performance/StringBuilderInLoopCodeFixProvider.cs b/src/CSharp/CodeCracker/Performance/StringBuilderInLoopCodeFixProvider.cs
@@ -32,10 +32,10 @@ public sealed override async Task ComputeFixesAsync(CodeFixContext context)
             var diagnostic = context.Diagnostics.First();
             var diagnosticSpan = diagnostic.Location.SourceSpan;
             var assignmentExpression = root.FindToken(diagnosticSpan.Start).Parent.AncestorsAndSelf().OfType<AssignmentExpressionSyntax>().First();
-            context.RegisterFix(CodeAction.Create($"Use StringBuilder to create a value for '{assignmentExpression.Left.ToString()}'", c => UseStringBuilder(context.Document, assignmentExpression, c)), diagnostic);
+            context.RegisterFix(CodeAction.Create($"Use StringBuilder to create a value for '{assignmentExpression.Left.ToString()}'", c => UseStringBuilderAsync(context.Document, assignmentExpression, c)), diagnostic);
         }
 
-        private async Task<Document> UseStringBuilder(Document document, AssignmentExpressionSyntax assignmentExpression, CancellationToken cancellationToken)
+        private async Task<Document> UseStringBuilderAsync(Document document, AssignmentExpressionSyntax assignmentExpression, CancellationToken cancellationToken)
         {
             var expressionStatement = assignmentExpression.Parent;
             var expressionStatementParent = expressionStatement.Parent;
diff --git a/src/CSharp/CodeCracker/Refactoring/InvertForCodeFixProvider.cs b/src/CSharp/CodeCracker/Refactoring/InvertForCodeFixProvider.cs
@@ -37,16 +37,16 @@ public sealed override async Task ComputeFixesAsync(CodeFixContext context)
         private async Task<Document> InvertForAsync(Document document, ForStatementSyntax @for, CancellationToken cancellationToken)
         {
             if (InvertForAnalyzer.IsPostIncrement(@for.Incrementors[0]))
-                return await ConvertToDecrementingCounterForLoop(document, @for, cancellationToken);
-            return await ConvertToIncrementingCounterForLoop(document, @for, cancellationToken);
+                return await ConvertToDecrementingCounterForLoopAsync(document, @for, cancellationToken);
+            return await ConvertToIncrementingCounterForLoopAsync(document, @for, cancellationToken);
         }
 
         static readonly LiteralExpressionSyntax One = SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(
                             SyntaxFactory.TriviaList(),
                             @"1", 1,
                             SyntaxFactory.TriviaList()));
 
-        private static async Task<Document> ConvertToIncrementingCounterForLoop(Document document, ForStatementSyntax @for, CancellationToken cancellationToken)
+        private static async Task<Document> ConvertToIncrementingCounterForLoopAsync(Document document, ForStatementSyntax @for, CancellationToken cancellationToken)
         {
             var condition = (BinaryExpressionSyntax)@for.Condition;
             var newEndValue = @for.Declaration != null
@@ -59,14 +59,14 @@ private static async Task<Document> ConvertToIncrementingCounterForLoop(Document
             var newCondition = condition
                 .WithOperatorToken(SyntaxFactory.Token(SyntaxKind.LessThanToken))
                 .WithRight(newEndValue);
-            return await ReplaceFor(document, @for,
+            return await ReplaceForAsync(document, @for,
                 newDeclaration,
                 newInitializers,
                 newCondition,
                 cancellationToken);
         }
 
-        private static async Task<Document> ConvertToDecrementingCounterForLoop(Document document, ForStatementSyntax @for, CancellationToken cancellationToken)
+        private static async Task<Document> ConvertToDecrementingCounterForLoopAsync(Document document, ForStatementSyntax @for, CancellationToken cancellationToken)
         {
             var condition = (BinaryExpressionSyntax)@for.Condition;
             var newEndValue = @for.Declaration != null
@@ -78,7 +78,7 @@ private static async Task<Document> ConvertToDecrementingCounterForLoop(Document
             var newCondition = condition
                 .WithOperatorToken(SyntaxFactory.Token(SyntaxKind.GreaterThanEqualsToken))
                 .WithRight(newEndValue);
-            return await ReplaceFor(document, @for,
+            return await ReplaceForAsync(document, @for,
                 newDeclaration,
                 newInitializers,
                 newCondition,
@@ -99,7 +99,7 @@ static VariableDeclarationSyntax ReplaceStartValue(VariableDeclarationSyntax dec
             return declaration.WithVariables(new SeparatedSyntaxList<VariableDeclaratorSyntax>().Add(variable));
         }
 
-        static async Task<Document> ReplaceFor(Document document, ForStatementSyntax oldFor,
+        static async Task<Document> ReplaceForAsync(Document document, ForStatementSyntax oldFor,
             VariableDeclarationSyntax newDeclaration,
             SeparatedSyntaxList<ExpressionSyntax> newInitializers,
             BinaryExpressionSyntax newCondition,
@@ -111,7 +111,7 @@ static async Task<Document> ReplaceFor(Document document, ForStatementSyntax old
                 .WithCondition(newCondition)
                 .WithIncrementors(ToggleIncrement(oldFor))
                 .WithAdditionalAnnotations(Formatter.Annotation);
-            return await ReplaceFor(document, oldFor, newFor, cancellationToken);
+            return await ReplaceForAsync(document, oldFor, newFor, cancellationToken);
         }
 
         static SeparatedSyntaxList<ExpressionSyntax> ToggleIncrement(ForStatementSyntax @for)
@@ -124,7 +124,7 @@ static SeparatedSyntaxList<ExpressionSyntax> ToggleIncrement(ForStatementSyntax
             return new SeparatedSyntaxList<ExpressionSyntax>().Add(newIncrementor);
         }
 
-        static async Task<Document> ReplaceFor(Document document, ForStatementSyntax oldFor, ForStatementSyntax newFor, CancellationToken cancellationToken)
+        static async Task<Document> ReplaceForAsync(Document document, ForStatementSyntax oldFor, ForStatementSyntax newFor, CancellationToken cancellationToken)
         {
             var root = await document.GetSyntaxRootAsync(cancellationToken);
             var newRoot = root.ReplaceNode(oldFor, newFor);
diff --git a/src/CSharp/CodeCracker/Style/ConvertToExpressionBodiedMemberCodeFixProvider.cs b/src/CSharp/CodeCracker/Style/ConvertToExpressionBodiedMemberCodeFixProvider.cs
@@ -60,10 +60,10 @@ private async Task<Document> ConvertToExpressionBodiedMemberAsync(
 
             newDeclaration = newDeclaration.WithAdditionalAnnotations(Formatter.Annotation);
 
-            return await ReplaceNode(document, declaration, newDeclaration, cancellationToken);
+            return await ReplaceNodeAsync(document, declaration, newDeclaration, cancellationToken);
         }
 
-        public async Task<Document> ReplaceNode(Document document, SyntaxNode @old, SyntaxNode @new, CancellationToken cancellationToken)
+        public async Task<Document> ReplaceNodeAsync(Document document, SyntaxNode @old, SyntaxNode @new, CancellationToken cancellationToken)
         {
             var root = await document.GetSyntaxRootAsync(cancellationToken);
             var newRoot = root.ReplaceNode(@old, @new);
@@ -90,7 +90,7 @@ private async Task<Document> ConvertToExpressionBodiedMemberAsync(
 
             newDeclaration = newDeclaration.WithAdditionalAnnotations(Formatter.Annotation);
 
-            return await ReplaceNode(document, declaration, newDeclaration, cancellationToken);
+            return await ReplaceNodeAsync(document, declaration, newDeclaration, cancellationToken);
         }
     }
 }
diff --git a/src/CSharp/CodeCracker/Style/ExistenceOperatorCodeFixProvider.cs b/src/CSharp/CodeCracker/Style/ExistenceOperatorCodeFixProvider.cs
@@ -37,11 +37,11 @@ private async Task<Document> UseExistenceOperatorAsync(Document document, IfStat
             var returnIf = statementInsideIf as ReturnStatementSyntax;
             var returnElse = statementInsideElse as ReturnStatementSyntax;
             if (returnIf != null && returnElse != null)
-                return await UseExistenceOperatorAsyncWithReturn(document, ifStatement, cancellationToken, returnIf);
-            return await UseExistenceOperatorAsyncWithAssignment(document, ifStatement, cancellationToken, (ExpressionStatementSyntax)statementInsideIf);
+                return await UseExistenceOperatorAsyncWithReturnAsync(document, ifStatement, cancellationToken, returnIf);
+            return await UseExistenceOperatorAsyncWithAssignmentAsync(document, ifStatement, cancellationToken, (ExpressionStatementSyntax)statementInsideIf);
         }
 
-        private async Task<Document> UseExistenceOperatorAsyncWithReturn(Document document, IfStatementSyntax ifStatement, CancellationToken cancellationToken, ReturnStatementSyntax returnIf)
+        private async Task<Document> UseExistenceOperatorAsyncWithReturnAsync(Document document, IfStatementSyntax ifStatement, CancellationToken cancellationToken, ReturnStatementSyntax returnIf)
         {
             var newMemberAccess = ((MemberAccessExpressionSyntax)returnIf.Expression).ToConditionalAccessExpression();
             var newReturn = SyntaxFactory.ReturnStatement(newMemberAccess)
@@ -54,7 +54,7 @@ private async Task<Document> UseExistenceOperatorAsyncWithReturn(Document docume
             return newDocument;
         }
 
-        private async Task<Document> UseExistenceOperatorAsyncWithAssignment(Document document, IfStatementSyntax ifStatement, CancellationToken cancellationToken, ExpressionStatementSyntax expressionIf)
+        private async Task<Document> UseExistenceOperatorAsyncWithAssignmentAsync(Document document, IfStatementSyntax ifStatement, CancellationToken cancellationToken, ExpressionStatementSyntax expressionIf)
         {
             var memberAccessAssignment = (AssignmentExpressionSyntax)expressionIf.Expression;
             var newMemberAccess = ((MemberAccessExpressionSyntax)memberAccessAssignment.Right).ToConditionalAccessExpression();
diff --git a/src/CSharp/CodeCracker/Style/TaskNameAsyncAnalyzer.cs b/src/CSharp/CodeCracker/Style/TaskNameAsyncAnalyzer.cs
@@ -3,7 +3,6 @@
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 using System.Collections.Immutable;
-using System.Threading.Tasks;
 
 namespace CodeCracker.Style
 {
@@ -37,7 +36,7 @@ private static void AnalyzeMethod(SyntaxNodeAnalysisContext context)
         {
             var method = (MethodDeclarationSyntax)context.Node;
             if (method.Identifier.ToString().EndsWith("Async")) return;
-            
+
             var errorMessage = method.Identifier.ToString() + "Async";
             var diag = Diagnostic.Create(Rule, method.GetLocation(), errorMessage);
 
diff --git a/src/CSharp/CodeCracker/Usage/DisposableVariableNotDisposedCodeFixProvider.cs b/src/CSharp/CodeCracker/Usage/DisposableVariableNotDisposedCodeFixProvider.cs
@@ -30,10 +30,10 @@ public sealed override async Task ComputeFixesAsync(CodeFixContext context)
             var diagnosticSpan = diagnostic.Location.SourceSpan;
             var objectCreation = root.FindToken(diagnosticSpan.Start).Parent.AncestorsAndSelf().OfType<ObjectCreationExpressionSyntax>().FirstOrDefault();
             if (objectCreation != null)
-                context.RegisterFix(CodeAction.Create($"Dispose object: '{objectCreation.Type.ToString()}'", c => CreateUsing(context.Document, objectCreation, c)), diagnostic);
+                context.RegisterFix(CodeAction.Create($"Dispose object: '{objectCreation.Type.ToString()}'", c => CreateUsingAsync(context.Document, objectCreation, c)), diagnostic);
         }
 
-        private static async Task<Document> CreateUsing(Document document, ObjectCreationExpressionSyntax objectCreation, CancellationToken cancellationToken)
+        private static async Task<Document> CreateUsingAsync(Document document, ObjectCreationExpressionSyntax objectCreation, CancellationToken cancellationToken)
         {
             var semanticModel = await document.GetSemanticModelAsync(cancellationToken);
             SyntaxNode newRoot, root = await document.GetSyntaxRootAsync();
diff --git a/src/CSharp/CodeCracker/Usage/DisposablesShouldCallSuppressFinalizeAnalyzer.cs b/src/CSharp/CodeCracker/Usage/DisposablesShouldCallSuppressFinalizeAnalyzer.cs
diff --git a/src/CSharp/CodeCracker/Usage/DisposablesShouldCallSuppressFinalizeCodeFixProvider.cs b/src/CSharp/CodeCracker/Usage/DisposablesShouldCallSuppressFinalizeCodeFixProvider.cs
diff --git a/src/CSharp/CodeCracker/Usage/ReadonlyFieldCodeFixProvider.cs b/src/CSharp/CodeCracker/Usage/ReadonlyFieldCodeFixProvider.cs
diff --git a/src/CSharp/CodeCracker/Usage/UnusedParametersCodeFixProvider.cs b/src/CSharp/CodeCracker/Usage/UnusedParametersCodeFixProvider.cs
diff --git a/src/CSharp/CodeCracker/packages.config b/src/CSharp/CodeCracker/packages.config
diff --git a/test/CSharp/CodeCracker.Test/CodeCracker.Test.csproj b/test/CSharp/CodeCracker.Test/CodeCracker.Test.csproj
diff --git a/test/CSharp/CodeCracker.Test/GlobalSuppressions.cs b/test/CSharp/CodeCracker.Test/GlobalSuppressions.cs
diff --git a/test/CSharp/CodeCracker.Test/packages.config b/test/CSharp/CodeCracker.Test/packages.config

Original file line number	Diff line number	Diff line change
`@@ -30,10 +30,10 @@ public sealed override async Task ComputeFixesAsync(CodeFixContext context)`
`30`	`30`	`var invocation = root.FindToken(sourceSpan.Start).Parent.AncestorsAndSelf().OfType<InvocationExpressionSyntax>().First();`
`31`	`31`
`32`	`32`	`context.RegisterFix(`
`33`		`- CodeAction.Create("Copy event reference to a variable", ct => CreateVariable(context.Document, invocation, ct)), diagnostic);`
	`33`	`+ CodeAction.Create("Copy event reference to a variable", ct => CreateVariableAsync(context.Document, invocation, ct)), diagnostic);`
`34`	`34`	`}`
`35`	`35`
`36`		`- private async Task<Document> CreateVariable(Document document, InvocationExpressionSyntax invocation, CancellationToken ct)`
	`36`	`+ private async Task<Document> CreateVariableAsync(Document document, InvocationExpressionSyntax invocation, CancellationToken ct)`
`37`	`37`	`{`
`38`	`38`	`const string handlerName = "handler";`
`39`	`39`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ public sealed override async Task ComputeFixesAsync(CodeFixContext context)`
`31`	`31`	`context.RegisterFix(CodeAction.Create("Insert Exception class to Catch", c => InsertExceptionClassCommentAsync(context.Document, declaration, c)), diagnostic);`
`32`	`32`	`}`
`33`	`33`
`34`		`- private async Task<Document> RemoveTry(Document document, CatchClauseSyntax catchStatement, CancellationToken cancellationToken, bool insertComment = false)`
	`34`	`+ private async Task<Document> RemoveTryAsync(Document document, CatchClauseSyntax catchStatement, CancellationToken cancellationToken, bool insertComment = false)`
`35`	`35`	`{`
`36`	`36`	`var tryStatement = (TryStatementSyntax)catchStatement.Parent;`
`37`	`37`	`var tryBlock = tryStatement.Block;`
`@@ -51,12 +51,12 @@ private async Task<Document> RemoveTry(Document document, CatchClauseSyntax catc`
`51`	`51`
`52`	`52`	`private async Task<Document> RemoveEmptyCatchBlockAsync(Document document, CatchClauseSyntax catchStatement, CancellationToken cancellationToken)`
`53`	`53`	`{`
`54`		`- return await RemoveTry(document, catchStatement, cancellationToken);`
	`54`	`+ return await RemoveTryAsync(document, catchStatement, cancellationToken);`
`55`	`55`	`}`
`56`	`56`
`57`	`57`	`private async Task<Document> RemoveEmptyCatchBlockPutCommentAsync(Document document, CatchClauseSyntax catchStatement, CancellationToken cancellationToken)`
`58`	`58`	`{`
`59`		`- return await RemoveTry(document, catchStatement, cancellationToken, true);`
	`59`	`+ return await RemoveTryAsync(document, catchStatement, cancellationToken, true);`
`60`	`60`	`}`
`61`	`61`
`62`	`62`	`private async Task<Document> InsertExceptionClassCommentAsync(Document document, CatchClauseSyntax catchStatement, CancellationToken cancellationToken)`
Original file line number	Diff line number	Diff line change
`@@ -27,10 +27,10 @@ public sealed override async Task ComputeFixesAsync(CodeFixContext context)`
`27`	`27`	`var @throw = root.FindToken(sourceSpan.Start).Parent.AncestorsAndSelf().OfType<ThrowStatementSyntax>().First();`
`28`	`28`
`29`	`29`	`context.RegisterFix(`
`30`		`- CodeAction.Create("Remove this exception", ct => RemoveThrow(context.Document, @throw, ct)), diagnostic);`
	`30`	`+ CodeAction.Create("Remove this exception", ct => RemoveThrowAsync(context.Document, @throw, ct)), diagnostic);`
`31`	`31`	`}`
`32`	`32`
`33`		`- private async Task<Document> RemoveThrow(Document document, ThrowStatementSyntax @throw, CancellationToken ct)`
	`33`	`+ private async Task<Document> RemoveThrowAsync(Document document, ThrowStatementSyntax @throw, CancellationToken ct)`
`34`	`34`	`{`
`35`	`35`	`return document.WithSyntaxRoot((await document.GetSyntaxRootAsync(ct)).RemoveNode(@throw, SyntaxRemoveOptions.KeepNoTrivia));`
`36`	`36`	`}`
Original file line number	Diff line number	Diff line change
`@@ -33,10 +33,10 @@ public sealed override async Task ComputeFixesAsync(CodeFixContext context)`
`33`	`33`	`var invocation = root.FindToken(sourceSpan.Start).Parent.AncestorsAndSelf().OfType<InvocationExpressionSyntax>().First();`
`34`	`34`
`35`	`35`	`context.RegisterFix(`
`36`		`- CodeAction.Create("Use ?.Invoke operator and method to fire an event.", ct => UseInvoke(context.Document, invocation, ct)), diagnostic);`
	`36`	`+ CodeAction.Create("Use ?.Invoke operator and method to fire an event.", ct => UseInvokeAsync(context.Document, invocation, ct)), diagnostic);`
`37`	`37`	`}`
`38`	`38`
`39`		`- private async Task<Document> UseInvoke(Document document, InvocationExpressionSyntax invocation, CancellationToken ct)`
	`39`	`+ private async Task<Document> UseInvokeAsync(Document document, InvocationExpressionSyntax invocation, CancellationToken ct)`
`40`	`40`	`{`
`41`	`41`	`var newInvocation =`
`42`	`42`	`SyntaxFactory.ConditionalAccessExpression(`
Original file line number	Diff line number	Diff line change
`@@ -28,10 +28,10 @@ public sealed override async Task ComputeFixesAsync(CodeFixContext context)`
`28`	`28`	`var finalizer = root.FindToken(sourceSpan.Start).Parent.AncestorsAndSelf().OfType<DestructorDeclarationSyntax>().First();`
`29`	`29`
`30`	`30`	`context.RegisterFix(`
`31`		`- CodeAction.Create("Remove finalizer", ct => RemoveThrow(context.Document, finalizer, ct)), diagnostic);`
	`31`	`+ CodeAction.Create("Remove finalizer", ct => RemoveThrowAsync(context.Document, finalizer, ct)), diagnostic);`
`32`	`32`	`}`
`33`	`33`
`34`		`- private async Task<Document> RemoveThrow(Document document, DestructorDeclarationSyntax finalizer, CancellationToken ct)`
	`34`	`+ private async Task<Document> RemoveThrowAsync(Document document, DestructorDeclarationSyntax finalizer, CancellationToken ct)`
`35`	`35`	`{`
`36`	`36`	`return document.WithSyntaxRoot((await document.GetSyntaxRootAsync(ct)).RemoveNode(finalizer, SyntaxRemoveOptions.KeepNoTrivia));`
`37`	`37`	`}`