Implement FixAllProvider for RCS1014

ChangeLog.md

@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- Add Custom FixAllProvider for [RCS1014](https://github.com/JosefPihrt/Roslynator/blob/main/docs/analyzers/RCS1014.md) ([#1070](https://github.com/JosefPihrt/Roslynator/pull/1070)).
+
 ### Changed
 
 - [CLI] Bump Roslyn to 4.5.0 ([#1043](https://github.com/josefpihrt/roslynator/pull/1043)).

src/Analyzers.CodeFixes/CSharp/CodeFixes/UseExplicitlyOrImplicitlyTypedArrayCodeFixProvider.cs

@@ -10,6 +10,7 @@
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Roslynator.CodeFixes;
+using Roslynator.CSharp.CSharp.CodeFixes;
 using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
 
 namespace Roslynator.CSharp.CodeFixes;
@@ -22,6 +23,11 @@ public override ImmutableArray<string> FixableDiagnosticIds
     {
         get { return ImmutableArray.Create(DiagnosticIdentifiers.UseExplicitlyOrImplicitlyTypedArray); }
     }
+
+    public override FixAllProvider GetFixAllProvider()
+    {
+        return UseExplicitlyOrImplicitlyTypedArrayFixAllProvider.Instance;
+    }
 
     public override async Task RegisterCodeFixesAsync(CodeFixContext context)
     {
@@ -39,29 +45,41 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context)
         Document document = context.Document;
         Diagnostic diagnostic = context.Diagnostics[0];
 
-        switch (node)
+        var title = node switch
         {
-            case ImplicitArrayCreationExpressionSyntax implicitArrayCreation:
-                {
-                    CodeAction codeAction = CodeAction.Create(
-                        "Use explicitly typed array",
-                        ct => ChangeArrayTypeToExplicitAsync(document, implicitArrayCreation, ct),
-                        GetEquivalenceKey(diagnostic));
-
-                    context.RegisterCodeFix(codeAction, diagnostic);
-                    break;
-                }
-            case ArrayCreationExpressionSyntax arrayCreation:
-                {
-                    CodeAction codeAction = CodeAction.Create(
-                        "Use implicitly typed array",
-                        ct => ChangeArrayTypeToImplicitAsync(document, arrayCreation, ct),
-                        GetEquivalenceKey(diagnostic));
-
-                    context.RegisterCodeFix(codeAction, diagnostic);
-                    break;
-                }
+            ImplicitArrayCreationExpressionSyntax => "Use explicitly typed array",
+            ArrayCreationExpressionSyntax => "Use implicitly typed array",
+            _ => "",
+        };
+
+        CodeAction codeAction = CodeAction.Create(
+            title,
+            ct => ApplyFixToDocument(document, diagnostic, ct),
+            GetEquivalenceKey(diagnostic));
+
+        context.RegisterCodeFix(codeAction, diagnostic);
+    }
+
+    public async Task<Document> ApplyFixToDocument(Document document, Diagnostic diag, CancellationToken cancellationToken)
+    {
+        var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+
+        if (!TryFindFirstAncestorOrSelf(
+                root,
+                diag.Location.SourceSpan,
+                out SyntaxNode node,
+                predicate: f =>
+                    f.IsKind(SyntaxKind.ImplicitArrayCreationExpression, SyntaxKind.ArrayCreationExpression)))
+        {
+            return null;
         }
+
+        return node switch
+        {
+            ImplicitArrayCreationExpressionSyntax implicitArrayCreation => await ChangeArrayTypeToExplicitAsync(document, implicitArrayCreation, cancellationToken),
+            ArrayCreationExpressionSyntax arrayCreation => await ChangeArrayTypeToImplicitAsync(document, arrayCreation, cancellationToken),
+            _ => null
+        };
     }
 
     private static async Task<Document> ChangeArrayTypeToExplicitAsync(
@@ -101,13 +119,10 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context)
         ArrayCreationExpressionSyntax arrayCreation,
         CancellationToken cancellationToken)
     {
-        SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
-
         ArrayTypeSyntax arrayType = arrayCreation.Type;
         SyntaxList<ArrayRankSpecifierSyntax> rankSpecifiers = arrayType.RankSpecifiers;
         InitializerExpressionSyntax initializer = arrayCreation.Initializer;
 
-        ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(arrayType.ElementType, cancellationToken);
         TypeSyntax castType;
 
         if (rankSpecifiers.Count > 1)

src/Analyzers.CodeFixes/CSharp/CodeFixes/UseExplicitlyOrImplicitlyTypedArrayFixAllProvider.cs

@@ -0,0 +1,25 @@
+using System.Collections.Immutable;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Roslynator.CSharp.CodeFixes;
+
+namespace Roslynator.CSharp.CSharp.CodeFixes;
+
+public class UseExplicitlyOrImplicitlyTypedArrayFixAllProvider : DocumentBasedFixAllProvider
+{
+    public static readonly UseExplicitlyOrImplicitlyTypedArrayFixAllProvider Instance = new();
+    private UseExplicitlyOrImplicitlyTypedArrayFixAllProvider() { }
+
+    protected override async Task<Document> FixAllAsync(FixAllContext fixAllContext, Document document, ImmutableArray<Diagnostic> diagnostics)
+    {
+        var codeFixProvider = (UseExplicitlyOrImplicitlyTypedArrayCodeFixProvider)fixAllContext.CodeFixProvider;
+        foreach (var diag in diagnostics.OrderByDescending(d => d.Location.SourceSpan.Start))
+        {
+            document = await codeFixProvider.ApplyFixToDocument(document, diag, fixAllContext.CancellationToken);
+        }
+
+        return document;
+    }
+}