Implement code review feedback

Author: sharwell

StyleCop.Analyzers/StyleCop.Analyzers.CodeFixes/Helpers/FixAllContextHelper.cs

@@ -143,32 +143,32 @@ public static async Task<ImmutableArray<Diagnostic>> GetAllDiagnosticsAsync(Comp
 
             // Note that the following loop to obtain syntax and semantic diagnostics for each document cannot operate
             // on parallel due to our use of a single CompilationWithAnalyzers instance.
-            var diagnostics = ImmutableArray<Diagnostic>.Empty;
+            var diagnostics = ImmutableArray.CreateBuilder<Diagnostic>();
             foreach (var document in documents)
             {
                 var syntaxTree = await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);
                 var syntaxDiagnostics = await GetAnalyzerSyntaxDiagnosticsAsync(compilationWithAnalyzers, syntaxTree, cancellationToken).ConfigureAwait(false);
-                diagnostics = diagnostics.AddRange(syntaxDiagnostics);
+                diagnostics.AddRange(syntaxDiagnostics);
 
                 var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
                 var semanticDiagnostics = await GetAnalyzerSemanticDiagnosticsAsync(compilationWithAnalyzers, semanticModel, default(TextSpan?), cancellationToken).ConfigureAwait(false);
-                diagnostics = diagnostics.AddRange(semanticDiagnostics);
+                diagnostics.AddRange(semanticDiagnostics);
             }
 
             foreach (var analyzer in analyzers)
             {
-                diagnostics = diagnostics.AddRange(await GetAnalyzerCompilationDiagnosticsAsync(compilationWithAnalyzers, ImmutableArray.Create(analyzer), cancellationToken).ConfigureAwait(false));
+                diagnostics.AddRange(await GetAnalyzerCompilationDiagnosticsAsync(compilationWithAnalyzers, ImmutableArray.Create(analyzer), cancellationToken).ConfigureAwait(false));
             }
 
             if (includeCompilerDiagnostics)
             {
                 // This is the special handling for cases where code fixes operate on warnings produced by the C#
                 // compiler, as opposed to being created by specific analyzers.
                 var compilerDiagnostics = compilation.GetDiagnostics(cancellationToken);
-                diagnostics = diagnostics.AddRange(compilerDiagnostics);
+                diagnostics.AddRange(compilerDiagnostics);
             }
 
-            return diagnostics;
+            return diagnostics.ToImmutable();
         }
 
         private static ImmutableDictionary<string, ImmutableArray<Type>> GetAllAnalyzers()

StyleCop.Analyzers/StyleCop.Analyzers.CodeFixes/MaintainabilityRules/SA1412FixAllProvider.cs

@@ -24,21 +24,21 @@ public override Task<CodeAction> GetFixAsync(FixAllContext fixAllContext)
             case FixAllScope.Document:
                 fixAction = CodeAction.Create(
                     title,
-                    cancellationToken => this.GetDocumentFixesAsync(fixAllContext.WithCancellationToken(cancellationToken)),
+                    cancellationToken => GetDocumentFixesAsync(fixAllContext.WithCancellationToken(cancellationToken)),
                     nameof(SA1412FixAllProvider));
                 break;
 
             case FixAllScope.Project:
                 fixAction = CodeAction.Create(
                     title,
-                    cancellationToken => this.GetProjectFixesAsync(fixAllContext.WithCancellationToken(cancellationToken), fixAllContext.Project),
+                    cancellationToken => GetProjectFixesAsync(fixAllContext.WithCancellationToken(cancellationToken)),
                     nameof(SA1412FixAllProvider));
                 break;
 
             case FixAllScope.Solution:
                 fixAction = CodeAction.Create(
                     title,
-                    cancellationToken => this.GetSolutionFixesAsync(fixAllContext.WithCancellationToken(cancellationToken)),
+                    cancellationToken => GetSolutionFixesAsync(fixAllContext.WithCancellationToken(cancellationToken)),
                     nameof(SA1412FixAllProvider));
                 break;
 
@@ -68,7 +68,7 @@ private static async Task<Solution> FixDocumentAsync(Solution solution, Document
             return await SA1412CodeFixProvider.GetTransformedSolutionAsync(document, cancellationToken).ConfigureAwait(false);
         }
 
-        private async Task<Solution> GetDocumentFixesAsync(FixAllContext fixAllContext)
+        private static async Task<Solution> GetDocumentFixesAsync(FixAllContext fixAllContext)
         {
             var documentDiagnosticsToFix = await FixAllContextHelper.GetDocumentDiagnosticsToFixAsync(fixAllContext).ConfigureAwait(false);
             ImmutableArray<Diagnostic> diagnostics;
@@ -80,7 +80,7 @@ private async Task<Solution> GetDocumentFixesAsync(FixAllContext fixAllContext)
             return await FixDocumentAsync(fixAllContext.Document.Project.Solution, fixAllContext.Document.Id, diagnostics, fixAllContext.CodeActionEquivalenceKey, fixAllContext.CancellationToken).ConfigureAwait(false);
         }
 
-        private async Task<Solution> GetSolutionFixesAsync(FixAllContext fixAllContext, ImmutableArray<Document> documents)
+        private static async Task<Solution> GetSolutionFixesAsync(FixAllContext fixAllContext, ImmutableArray<Document> documents)
         {
             var documentDiagnosticsToFix = await FixAllContextHelper.GetDocumentDiagnosticsToFixAsync(fixAllContext).ConfigureAwait(false);
 
@@ -99,15 +99,15 @@ private async Task<Solution> GetSolutionFixesAsync(FixAllContext fixAllContext,
             return solution;
         }
 
-        private Task<Solution> GetProjectFixesAsync(FixAllContext fixAllContext, Project project)
+        private static Task<Solution> GetProjectFixesAsync(FixAllContext fixAllContext)
         {
-            return this.GetSolutionFixesAsync(fixAllContext, project.Documents.ToImmutableArray());
+            return GetSolutionFixesAsync(fixAllContext, fixAllContext.Project.Documents.ToImmutableArray());
         }
 
-        private Task<Solution> GetSolutionFixesAsync(FixAllContext fixAllContext)
+        private static Task<Solution> GetSolutionFixesAsync(FixAllContext fixAllContext)
         {
             ImmutableArray<Document> documents = fixAllContext.Solution.Projects.SelectMany(i => i.Documents).ToImmutableArray();
-            return this.GetSolutionFixesAsync(fixAllContext, documents);
+            return GetSolutionFixesAsync(fixAllContext, documents);
         }
     }
 }