Add IncludeCancelCommand option to generator model

Author: Sergio0694

CommunityToolkit.Mvvm.SourceGenerators/AnalyzerReleases.Unshipped.md

@@ -17,3 +17,4 @@ MVVMTK0009 | CommunityToolkit.Mvvm.SourceGenerators.ICommandGenerator | Error |
 MVVMTK0010 | CommunityToolkit.Mvvm.SourceGenerators.ICommandGenerator | Error | See https://aka.ms/mvvmtoolkit/error
 MVVMTK0011 | CommunityToolkit.Mvvm.SourceGenerators.ICommandGenerator | Error | See https://aka.ms/mvvmtoolkit/error
 MVVMTK0012 | CommunityToolkit.Mvvm.SourceGenerators.ICommandGenerator | Error | See https://aka.ms/mvvmtoolkit/error
+MVVMTK0013 | CommunityToolkit.Mvvm.SourceGenerators.ICommandGenerator | Error | See https://aka.ms/mvvmtoolkit/error

CommunityToolkit.Mvvm.SourceGenerators/Diagnostics/DiagnosticDescriptors.cs

@@ -203,4 +203,20 @@ internal static class DiagnosticDescriptors
         isEnabledByDefault: true,
         description: "Cannot apply the [ICommand] attribute specifying a concurrency control setting to methods mapping to non-asynchronous command types.",
         helpLinkUri: "https://aka.ms/mvvmtoolkit");
+
+    /// <summary>
+    /// Gets a <see cref="DiagnosticDescriptor"/> indicating when <c>ICommandAttribute.IncludeCancelCommandParameter</c> is being set for an invalid method.
+    /// <para>
+    /// Format: <c>"The method {0}.{1} cannot be annotated with the [ICommand] attribute specifying to include a cancel command, as it does not map to an asynchronous command type taking a cancellation token"</c>.
+    /// </para>
+    /// </summary>
+    public static readonly DiagnosticDescriptor InvalidIncludeCancelCommandParameterError = new DiagnosticDescriptor(
+        id: "MVVMTK0013",
+        title: "Invalid concurrency control setting usage",
+        messageFormat: "The method {0}.{1} cannot be annotated with the [ICommand] attribute specifying to include a cancel command, as it does not map to an asynchronous command type taking a cancellation token",
+        category: typeof(ICommandGenerator).FullName,
+        defaultSeverity: DiagnosticSeverity.Error,
+        isEnabledByDefault: true,
+        description: "Cannot apply the [ICommand] attribute specifying to include a cancel command to methods not mapping to an asynchronous command type accepting a cancellation token.",
+        helpLinkUri: "https://aka.ms/mvvmtoolkit");
 }

CommunityToolkit.Mvvm.SourceGenerators/Input/ICommandGenerator.Execute.cs

@@ -46,6 +46,7 @@ private static class Execute
                 out string? commandInterfaceType,
                 out string? commandClassType,
                 out string? delegateType,
+                out bool supportsCancellation,
                 out ImmutableArray<string> commandTypeArguments,
                 out ImmutableArray<string> delegateTypeArguments))
             {
@@ -75,6 +76,18 @@ private static class Execute
                 goto Failure;
             }
 
+            // Get the option to include a cancel command, if any
+            if (!TryGetIncludeCancelCommandSwitch(
+                methodSymbol,
+                attributeData,
+                commandClassType,
+                supportsCancellation,
+                builder,
+                out bool generateCancelCommand))
+            {
+                goto Failure;
+            }
+
             diagnostics = builder.ToImmutable();
 
             return new(
@@ -88,7 +101,8 @@ private static class Execute
                 delegateTypeArguments,
                 canExecuteMemberName,
                 canExecuteExpressionType,
-                allowConcurrentExecutions);
+                allowConcurrentExecutions,
+                generateCancelCommand);
 
             Failure:
             diagnostics = builder.ToImmutable();
@@ -255,6 +269,7 @@ private static (string FieldName, string PropertyName) GetGeneratedFieldAndPrope
         /// <param name="commandInterfaceType">The command interface type name.</param>
         /// <param name="commandClassType">The command class type name.</param>
         /// <param name="delegateType">The delegate type name for the wrapped method.</param>
+        /// <param name="supportsCancellation">Indicates whether or not the resulting command supports cancellation.</param>
         /// <param name="commandTypeArguments">The type arguments for <paramref name="commandInterfaceType"/> and <paramref name="commandClassType"/>, if any.</param>
         /// <param name="delegateTypeArguments">The type arguments for <paramref name="delegateType"/>, if any.</param>
         /// <returns>Whether or not <paramref name="methodSymbol"/> was valid and the requested types have been set.</returns>
@@ -264,6 +279,7 @@ private static bool TryMapCommandTypesFromMethod(
             [NotNullWhen(true)] out string? commandInterfaceType,
             [NotNullWhen(true)] out string? commandClassType,
             [NotNullWhen(true)] out string? delegateType,
+            out bool supportsCancellation,
             out ImmutableArray<string> commandTypeArguments,
             out ImmutableArray<string> delegateTypeArguments)
         {
@@ -273,6 +289,7 @@ private static bool TryMapCommandTypesFromMethod(
                 commandInterfaceType = "global::CommunityToolkit.Mvvm.Input.IRelayCommand";
                 commandClassType = "global::CommunityToolkit.Mvvm.Input.RelayCommand";
                 delegateType = "global::System.Action";
+                supportsCancellation = false;
                 commandTypeArguments = ImmutableArray<string>.Empty;
                 delegateTypeArguments = ImmutableArray<string>.Empty;
 
@@ -287,6 +304,7 @@ private static bool TryMapCommandTypesFromMethod(
                 commandInterfaceType = "global::CommunityToolkit.Mvvm.Input.IRelayCommand";
                 commandClassType = "global::CommunityToolkit.Mvvm.Input.RelayCommand";
                 delegateType = "global::System.Action";
+                supportsCancellation = false;
                 commandTypeArguments = ImmutableArray.Create(parameter.Type.GetFullyQualifiedName());
                 delegateTypeArguments = ImmutableArray.Create(parameter.Type.GetFullyQualifiedName());
 
@@ -301,6 +319,7 @@ private static bool TryMapCommandTypesFromMethod(
                     commandInterfaceType = "global::CommunityToolkit.Mvvm.Input.IAsyncRelayCommand";
                     commandClassType = "global::CommunityToolkit.Mvvm.Input.AsyncRelayCommand";
                     delegateType = "global::System.Func";
+                    supportsCancellation = false;
                     commandTypeArguments = ImmutableArray<string>.Empty;
                     delegateTypeArguments = ImmutableArray.Create("global::System.Threading.Tasks.Task");
 
@@ -316,8 +335,9 @@ private static bool TryMapCommandTypesFromMethod(
                         commandInterfaceType = "global::CommunityToolkit.Mvvm.Input.IAsyncRelayCommand";
                         commandClassType = "global::CommunityToolkit.Mvvm.Input.AsyncRelayCommand";
                         delegateType = "global::System.Func";
+                        supportsCancellation = true;
                         commandTypeArguments = ImmutableArray<string>.Empty;
-                        delegateTypeArguments = ImmutableArray.Create("global::System.Threading.CancellationToken", "global::System.Threading.Tasks.Task");
+                        delegateTypeArguments = ImmutableArray.Create(singleParameter.Type.GetFullyQualifiedName(), "global::System.Threading.Tasks.Task");
 
                         return true;
                     }
@@ -326,6 +346,7 @@ private static bool TryMapCommandTypesFromMethod(
                     commandInterfaceType = "global::CommunityToolkit.Mvvm.Input.IAsyncRelayCommand";
                     commandClassType = "global::CommunityToolkit.Mvvm.Input.AsyncRelayCommand";
                     delegateType = "global::System.Func";
+                    supportsCancellation = false;
                     commandTypeArguments = ImmutableArray.Create(singleParameter.Type.GetFullyQualifiedName());
                     delegateTypeArguments = ImmutableArray.Create(singleParameter.Type.GetFullyQualifiedName(), "global::System.Threading.Tasks.Task");
 
@@ -341,6 +362,7 @@ private static bool TryMapCommandTypesFromMethod(
                     commandInterfaceType = "global::CommunityToolkit.Mvvm.Input.IAsyncRelayCommand";
                     commandClassType = "global::CommunityToolkit.Mvvm.Input.AsyncRelayCommand";
                     delegateType = "global::System.Func";
+                    supportsCancellation = true;
                     commandTypeArguments = ImmutableArray.Create(firstParameter.Type.GetFullyQualifiedName());
                     delegateTypeArguments = ImmutableArray.Create(firstParameter.Type.GetFullyQualifiedName(), secondParameter.Type.GetFullyQualifiedName(), "global::System.Threading.Tasks.Task");
 
@@ -353,6 +375,7 @@ private static bool TryMapCommandTypesFromMethod(
             commandInterfaceType = null;
             commandClassType = null;
             delegateType = null;
+            supportsCancellation = false;
             commandTypeArguments = ImmutableArray<string>.Empty;
             delegateTypeArguments = ImmutableArray<string>.Empty;
 
@@ -397,6 +420,47 @@ private static bool TryGetAllowConcurrentExecutionsSwitch(
             }
         }
 
+        /// <summary>
+        /// Checks whether or not the user has requested to also generate a cancel command.
+        /// </summary>
+        /// <param name="methodSymbol">The input <see cref="IMethodSymbol"/> instance to process.</param>
+        /// <param name="attributeData">The <see cref="AttributeData"/> instance the method was annotated with.</param>
+        /// <param name="commandClassType">The command class type name.</param>
+        /// <param name="supportsCancellation">Indicates whether or not the command supports cancellation.</param>
+        /// <param name="diagnostics">The current collection of gathered diagnostics.</param>
+        /// <param name="generateCancelCommand">Whether or not concurrent executions have been enabled.</param>
+        /// <returns>Whether or not a value for <paramref name="generateCancelCommand"/> could be retrieved successfully.</returns>
+        private static bool TryGetIncludeCancelCommandSwitch(
+            IMethodSymbol methodSymbol,
+            AttributeData attributeData,
+            string commandClassType,
+            bool supportsCancellation,
+            ImmutableArray<Diagnostic>.Builder diagnostics,
+            out bool generateCancelCommand)
+        {
+            // Try to get the custom switch for cancel command generation (the default is false)
+            if (!attributeData.TryGetNamedArgument("IncludeCancelCommand", out generateCancelCommand))
+            {
+                generateCancelCommand = false;
+
+                return true;
+            }
+
+            // If the current type is an async command type and cancellation is supported, pass that value to the constructor.
+            // Otherwise, the current attribute use is not valid, so a diagnostic message should be produced.
+            if (commandClassType is "global::CommunityToolkit.Mvvm.Input.AsyncRelayCommand" &&
+                supportsCancellation)
+            {
+                return true;
+            }
+            else
+            {
+                diagnostics.Add(InvalidIncludeCancelCommandParameterError, methodSymbol, methodSymbol.ContainingType, methodSymbol);
+
+                return false;
+            }
+        }
+
         /// <summary>
         /// Tries to get the expression type for the "CanExecute" property, if available.
         /// </summary>

CommunityToolkit.Mvvm.SourceGenerators/Input/Models/CommandInfo.cs

@@ -24,7 +24,8 @@ namespace CommunityToolkit.Mvvm.SourceGenerators.Input.Models;
 /// <param name="DelegateTypeArguments">The type arguments for <paramref name="DelegateType"/>, if any.</param>
 /// <param name="CanExecuteMemberName">The member name for the can execute check, if available.</param>
 /// <param name="CanExecuteExpressionType">The can execute expression type, if available.</param>
-/// <param name="AllowConcurrentExecutions">Whether or not concurrent executions have been disabled.</param>
+/// <param name="AllowConcurrentExecutions">Whether or not concurrent executions have been enabled.</param>
+/// <param name="IncludeCancelCommand">Whether or not to also generate a cancel command.</param>
 internal sealed record CommandInfo(
     string MethodName,
     string FieldName,
@@ -36,7 +37,8 @@ internal sealed record CommandInfo(
     ImmutableArray<string> DelegateTypeArguments,
     string? CanExecuteMemberName,
     CanExecuteExpressionType? CanExecuteExpressionType,
-    bool AllowConcurrentExecutions)
+    bool AllowConcurrentExecutions,
+    bool IncludeCancelCommand)
 {
     /// <summary>
     /// An <see cref="IEqualityComparer{T}"/> implementation for <see cref="CommandInfo"/>.
@@ -57,6 +59,7 @@ protected override void AddToHashCode(ref HashCode hashCode, CommandInfo obj)
             hashCode.Add(obj.CanExecuteMemberName);
             hashCode.Add(obj.CanExecuteExpressionType);
             hashCode.Add(obj.AllowConcurrentExecutions);
+            hashCode.Add(obj.IncludeCancelCommand);
         }
 
         /// <inheritdoc/>
@@ -73,7 +76,8 @@ protected override bool AreEqual(CommandInfo x, CommandInfo y)
                 x.DelegateTypeArguments.SequenceEqual(y.CommandTypeArguments) &&
                 x.CanExecuteMemberName == y.CanExecuteMemberName &&
                 x.CanExecuteExpressionType == y.CanExecuteExpressionType &&
-                x.AllowConcurrentExecutions == y.AllowConcurrentExecutions;
+                x.AllowConcurrentExecutions == y.AllowConcurrentExecutions &&
+                x.IncludeCancelCommand == y.IncludeCancelCommand;
         }
     }
 }

CommunityToolkit.Mvvm/Input/Attributes/ICommandAttribute.cs

@@ -78,5 +78,12 @@ public sealed class ICommandAttribute : Attribute
     /// when an execution is invoked while a previous one is still running. It is the same as creating an instance of
     /// these command types with a constructor such as <see cref="AsyncRelayCommand(Func{System.Threading.Tasks.Task}, bool)"/>.
     /// </summary>
+    /// <remarks>Using this property is not valid if the target command doesn't map to an asynchronous command.</remarks>
     public bool AllowConcurrentExecutions { get; init; }
+
+    /// <summary>
+    /// Gets or sets a value indicating whether a cancel command should also be generated for an asynchronous command.
+    /// </summary>
+    /// <remarks>Using this property is not valid if the target command doesn't map to a cancellable asynchronous command.</remarks>
+    public bool IncludeCancelCommand { get; init; }
 }