Update SA1412FixAllProvider to use FixAllContextHelpers

Author: sharwell

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

@@ -3,77 +3,111 @@
 
 namespace StyleCop.Analyzers.MaintainabilityRules
 {
+    using System.Collections.Immutable;
+    using System.Linq;
+    using System.Threading;
     using System.Threading.Tasks;
+    using Helpers;
     using Microsoft.CodeAnalysis;
     using Microsoft.CodeAnalysis.CodeActions;
     using Microsoft.CodeAnalysis.CodeFixes;
 
     internal sealed class SA1412FixAllProvider : FixAllProvider
     {
-        public override async Task<CodeAction> GetFixAsync(FixAllContext fixAllContext)
+        public override Task<CodeAction> GetFixAsync(FixAllContext fixAllContext)
         {
-            Solution newSolution;
+            string title = string.Format(MaintainabilityResources.SA1412CodeFix, fixAllContext.CodeActionEquivalenceKey.Substring(fixAllContext.CodeActionEquivalenceKey.IndexOf('.') + 1));
 
+            CodeAction fixAction;
             switch (fixAllContext.Scope)
             {
             case FixAllScope.Document:
-                newSolution = await FixDocumentAsync(fixAllContext, fixAllContext.Document).ConfigureAwait(false);
+                fixAction = CodeAction.Create(
+                    title,
+                    cancellationToken => this.GetDocumentFixesAsync(fixAllContext.WithCancellationToken(cancellationToken)),
+                    nameof(SA1412FixAllProvider));
                 break;
 
             case FixAllScope.Project:
-                newSolution = await GetProjectFixesAsync(fixAllContext, fixAllContext.Project).ConfigureAwait(false);
+                fixAction = CodeAction.Create(
+                    title,
+                    cancellationToken => this.GetProjectFixesAsync(fixAllContext.WithCancellationToken(cancellationToken), fixAllContext.Project),
+                    nameof(SA1412FixAllProvider));
                 break;
 
             case FixAllScope.Solution:
-                newSolution = fixAllContext.Solution;
-                var projectIds = newSolution.ProjectIds;
-                for (int i = 0; i < projectIds.Count; i++)
-                {
-                    newSolution = await GetProjectFixesAsync(fixAllContext, newSolution.GetProject(projectIds[i])).ConfigureAwait(false);
-                }
-
+                fixAction = CodeAction.Create(
+                    title,
+                    cancellationToken => this.GetSolutionFixesAsync(fixAllContext.WithCancellationToken(cancellationToken)),
+                    nameof(SA1412FixAllProvider));
                 break;
 
             case FixAllScope.Custom:
             default:
-                return null;
+                fixAction = null;
+                break;
             }
 
-            return CodeAction.Create(
-                string.Format(MaintainabilityResources.SA1412CodeFix, fixAllContext.CodeActionEquivalenceKey.Substring(fixAllContext.CodeActionEquivalenceKey.IndexOf('.') + 1)),
-                token => Task.FromResult(newSolution));
+            return Task.FromResult(fixAction);
         }
 
-        private static async Task<Solution> FixDocumentAsync(FixAllContext fixAllContext, Document document)
+        private static async Task<Solution> FixDocumentAsync(Solution solution, DocumentId documentId, ImmutableArray<Diagnostic> diagnostics, string codeActionEquivalenceKey, CancellationToken cancellationToken)
         {
-            Solution solution = document.Project.Solution;
-            var diagnostics = await fixAllContext.GetDocumentDiagnosticsAsync(document).ConfigureAwait(false);
-            if (diagnostics.Length == 0)
+            if (diagnostics.IsEmpty)
             {
                 return solution;
             }
 
             string equivalenceKey = nameof(SA1412CodeFixProvider) + "." + diagnostics[0].Properties[SA1412StoreFilesAsUtf8.EncodingProperty];
-            if (fixAllContext.CodeActionEquivalenceKey != equivalenceKey)
+            if (codeActionEquivalenceKey != equivalenceKey)
             {
                 return solution;
             }
 
-            return await SA1412CodeFixProvider.GetTransformedSolutionAsync(document, fixAllContext.CancellationToken).ConfigureAwait(false);
+            Document document = solution.GetDocument(documentId);
+            return await SA1412CodeFixProvider.GetTransformedSolutionAsync(document, cancellationToken).ConfigureAwait(false);
         }
 
-        private static async Task<Solution> GetProjectFixesAsync(FixAllContext fixAllContext, Project project)
+        private async Task<Solution> GetDocumentFixesAsync(FixAllContext fixAllContext)
         {
-            Solution solution = project.Solution;
+            var documentDiagnosticsToFix = await FixAllContextHelper.GetDocumentDiagnosticsToFixAsync(fixAllContext).ConfigureAwait(false);
+            ImmutableArray<Diagnostic> diagnostics;
+            if (!documentDiagnosticsToFix.TryGetValue(fixAllContext.Document, out diagnostics))
+            {
+                return fixAllContext.Document.Project.Solution;
+            }
+
+            return await FixDocumentAsync(fixAllContext.Document.Project.Solution, fixAllContext.Document.Id, diagnostics, fixAllContext.CodeActionEquivalenceKey, fixAllContext.CancellationToken).ConfigureAwait(false);
+        }
 
-            var documentIds = project.DocumentIds;
+        private async Task<Solution> GetSolutionFixesAsync(FixAllContext fixAllContext, ImmutableArray<Document> documents)
+        {
+            var documentDiagnosticsToFix = await FixAllContextHelper.GetDocumentDiagnosticsToFixAsync(fixAllContext).ConfigureAwait(false);
 
-            foreach (var documentId in documentIds)
+            Solution solution = fixAllContext.Solution;
+            foreach (var document in documents)
             {
-                solution = await FixDocumentAsync(fixAllContext, solution.GetDocument(documentId)).ConfigureAwait(false);
+                ImmutableArray<Diagnostic> diagnostics;
+                if (!documentDiagnosticsToFix.TryGetValue(document, out diagnostics))
+                {
+                    continue;
+                }
+
+                solution = await FixDocumentAsync(solution, document.Id, diagnostics, fixAllContext.CodeActionEquivalenceKey, fixAllContext.CancellationToken).ConfigureAwait(false);
             }
 
             return solution;
         }
+
+        private Task<Solution> GetProjectFixesAsync(FixAllContext fixAllContext, Project project)
+        {
+            return this.GetSolutionFixesAsync(fixAllContext, project.Documents.ToImmutableArray());
+        }
+
+        private Task<Solution> GetSolutionFixesAsync(FixAllContext fixAllContext)
+        {
+            ImmutableArray<Document> documents = fixAllContext.Solution.Projects.SelectMany(i => i.Documents).ToImmutableArray();
+            return this.GetSolutionFixesAsync(fixAllContext, documents);
+        }
     }
 }