Add AsyncVoidReturningRelayCommandMethodCodeFixer

Author: Sergio0694

src/CommunityToolkit.Mvvm.CodeFixers/AsyncVoidReturningRelayCommandMethodCodeFixer.cs

@@ -0,0 +1,93 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Immutable;
+using System.Composition;
+using System.Threading;
+using System.Threading.Tasks;
+using CommunityToolkit.Mvvm.SourceGenerators;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Editing;
+using Microsoft.CodeAnalysis.Simplification;
+using Microsoft.CodeAnalysis.Text;
+using static CommunityToolkit.Mvvm.SourceGenerators.Diagnostics.DiagnosticDescriptors;
+
+namespace CommunityToolkit.Mvvm.CodeFixers;
+
+/// <summary>
+/// A code fixer that automatically updates the return type of <see langword="async"/> <see cref="void"/> methods using <c>[RelayCommand]</c> to return a <see cref="Task"/> instead.
+/// </summary>
+[ExportCodeFixProvider(LanguageNames.CSharp)]
+[Shared]
+public sealed class AsyncVoidReturningRelayCommandMethodCodeFixer : CodeFixProvider
+{
+    /// <inheritdoc/>
+    public override ImmutableArray<string> FixableDiagnosticIds { get; } = ImmutableArray.Create(AsyncVoidReturningRelayCommandMethodId);
+
+    /// <inheritdoc/>
+    public override FixAllProvider? GetFixAllProvider()
+    {
+        return WellKnownFixAllProviders.BatchFixer;
+    }
+
+    /// <inheritdoc/>
+    public override async Task RegisterCodeFixesAsync(CodeFixContext context)
+    {
+        Diagnostic diagnostic = context.Diagnostics[0];
+        TextSpan diagnosticSpan = context.Span;
+
+        // Retrieve the property passed by the analyzer
+        if (diagnostic.Properties[AsyncVoidReturningRelayCommandMethodAnalyzer.MethodNameKey] is not string methodName)
+        {
+            return;
+        }
+
+        SyntaxNode? root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
+
+        // Get the method declaration from the target diagnostic
+        if (root!.FindNode(diagnosticSpan) is MethodDeclarationSyntax { Identifier.Text: string identifierName } methodDeclaration &&
+            identifierName == methodName)
+        {
+            // Register the code fix to update the return type to be Task instead
+            context.RegisterCodeFix(
+                CodeAction.Create(
+                    title: "Change return type to Task",
+                    createChangedDocument: token => ChangeReturnType(context.Document, root, methodDeclaration, token),
+                    equivalenceKey: "Change return type to Task"),
+                diagnostic);
+        }
+    }
+
+    /// <summary>
+    /// Applies the code fix to a target method declaration and returns an updated document.
+    /// </summary>
+    /// <param name="document">The original document being fixed.</param>
+    /// <param name="root">The original tree root belonging to the current document.</param>
+    /// <param name="methodDeclaration">The <see cref="MethodDeclarationSyntax"/> to update.</param>
+    /// <param name="cancellationToken">The cancellation token for the operation.</param>
+    /// <returns>An updated document with the applied code fix, and the return type of the method being <see cref="Task"/>.</returns>
+    private static async Task<Document> ChangeReturnType(Document document, SyntaxNode root, MethodDeclarationSyntax methodDeclaration, CancellationToken cancellationToken)
+    {
+        // Get the semantic model (bail if it's not available)
+        if (await document.GetSemanticModelAsync(cancellationToken) is not SemanticModel semanticModel)
+        {
+            return document;
+        }
+
+        // Also bail if we can't resolve the Task symbol (this should really never happen)
+        if (semanticModel.Compilation.GetTypeByMetadataName("System.Threading.Tasks.Task") is not INamedTypeSymbol taskSymbol)
+        {
+            return document;
+        }
+
+        // Create the new syntax node for the return, and configure it to automatically add "using System.Threading.Tasks;" if needed
+        SyntaxNode typeSyntax = SyntaxGenerator.GetGenerator(document).TypeExpression(taskSymbol).WithAdditionalAnnotations(Simplifier.AddImportsAnnotation);
+
+        // Replace the void return type with the newly created Task type expression
+        return document.WithSyntaxRoot(root.ReplaceNode(methodDeclaration.ReturnType, typeSyntax));
+    }
+}

src/CommunityToolkit.Mvvm.CodeFixers/ClassUsingAttributeInsteadOfInheritanceCodeFixer.cs

@@ -40,9 +40,9 @@ public sealed class ClassUsingAttributeInsteadOfInheritanceCodeFixer : CodeFixPr
     public override async Task RegisterCodeFixesAsync(CodeFixContext context)
     {
         Diagnostic diagnostic = context.Diagnostics[0];
-        TextSpan diagnosticSpan = diagnostic.Location.SourceSpan;
+        TextSpan diagnosticSpan = context.Span;
 
-        // Retrieve the property passed by the analyzer
+        // Retrieve the properties passed by the analyzer
         if (diagnostic.Properties[ClassUsingAttributeInsteadOfInheritanceAnalyzer.TypeNameKey] is not string typeName ||
             diagnostic.Properties[ClassUsingAttributeInsteadOfInheritanceAnalyzer.AttributeTypeNameKey] is not string attributeTypeName)
         {
@@ -59,11 +59,9 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context)
             context.RegisterCodeFix(
                 CodeAction.Create(
                     title: "Inherit from ObservableObject",
-                    createChangedDocument: token => UpdateReference(context.Document, root, classDeclaration, attributeTypeName),
+                    createChangedDocument: token => RemoveAttribute(context.Document, root, classDeclaration, attributeTypeName),
                     equivalenceKey: "Inherit from ObservableObject"),
                 diagnostic);
-
-            return;
         }
     }
 
@@ -75,7 +73,7 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context)
     /// <param name="classDeclaration">The <see cref="ClassDeclarationSyntax"/> to update.</param>
     /// <param name="attributeTypeName">The name of the attribute that should be removed.</param>
     /// <returns>An updated document with the applied code fix, and <paramref name="classDeclaration"/> inheriting from <c>ObservableObject</c>.</returns>
-    private static Task<Document> UpdateReference(Document document, SyntaxNode root, ClassDeclarationSyntax classDeclaration, string attributeTypeName)
+    private static Task<Document> RemoveAttribute(Document document, SyntaxNode root, ClassDeclarationSyntax classDeclaration, string attributeTypeName)
     {
         // Insert ObservableObject always in first position in the base list. The type might have
         // some interfaces in the base list, so we just copy them back after ObservableObject.

src/CommunityToolkit.Mvvm.CodeFixers/FieldReferenceForObservablePropertyFieldCodeFixer.cs

@@ -37,7 +37,7 @@ public sealed class FieldReferenceForObservablePropertyFieldCodeFixer : CodeFixP
     public override async Task RegisterCodeFixesAsync(CodeFixContext context)
     {
         Diagnostic diagnostic = context.Diagnostics[0];
-        TextSpan diagnosticSpan = diagnostic.Location.SourceSpan;
+        TextSpan diagnosticSpan = context.Span;
 
         // Retrieve the properties passed by the analyzer
         if (diagnostic.Properties[FieldReferenceForObservablePropertyFieldAnalyzer.FieldNameKey] is not string fieldName ||

src/CommunityToolkit.Mvvm.SourceGenerators/Diagnostics/Analyzers/AsyncVoidReturningRelayCommandMethodAnalyzer.cs

@@ -17,6 +17,11 @@ namespace CommunityToolkit.Mvvm.SourceGenerators;
 [DiagnosticAnalyzer(LanguageNames.CSharp)]
 public sealed class AsyncVoidReturningRelayCommandMethodAnalyzer : DiagnosticAnalyzer
 {
+    /// <summary>
+    /// The key for the name of the target method to update.
+    /// </summary>
+    internal const string MethodNameKey = "MethodName";
+
     /// <inheritdoc/>
     public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableArray.Create(AsyncVoidReturningRelayCommandMethod);
 
@@ -52,6 +57,7 @@ public override void Initialize(AnalysisContext context)
                 context.ReportDiagnostic(Diagnostic.Create(
                     AsyncVoidReturningRelayCommandMethod,
                     context.Symbol.Locations.FirstOrDefault(),
+                    ImmutableDictionary.Create<string, string?>().Add(MethodNameKey, methodSymbol.Name),
                     context.Symbol));
             }, SymbolKind.Method);
         });

src/CommunityToolkit.Mvvm.SourceGenerators/Diagnostics/DiagnosticDescriptors.cs

@@ -29,6 +29,11 @@ internal static class DiagnosticDescriptors
     /// </summary>
     public const string FieldReferenceForObservablePropertyFieldId = "MVVMTK0034";
 
+    /// <summary>
+    /// The diagnostic id for <see cref="AsyncVoidReturningRelayCommandMethod"/>.
+    /// </summary>
+    public const string AsyncVoidReturningRelayCommandMethodId = "MVVMTK0039";
+
     /// <summary>
     /// Gets a <see cref="DiagnosticDescriptor"/> indicating when a duplicate declaration of <see cref="INotifyPropertyChanged"/> would happen.
     /// <para>
@@ -645,7 +650,7 @@ internal static class DiagnosticDescriptors
     /// </para>
     /// </summary>
     public static readonly DiagnosticDescriptor AsyncVoidReturningRelayCommandMethod = new DiagnosticDescriptor(
-        id: "MVVMTK0039",
+        id: AsyncVoidReturningRelayCommandMethodId,
         title: "Async void returning method annotated with RelayCommand",
         messageFormat: "The method {0} annotated with [RelayCommand] is async void (make sure to return a Task type instead)",
         category: typeof(RelayCommandGenerator).FullName,