Add FlowExceptionsToTaskScheduler generator support

Author: Sergio0694

CommunityToolkit.Mvvm.SourceGenerators/AnalyzerReleases.Shipped.md

@@ -37,3 +37,4 @@ MVVMTK0027 | CommunityToolkit.Mvvm.SourceGenerators.ObservablePropertyGenerator
 MVVMTK0028 | CommunityToolkit.Mvvm.SourceGenerators.ObservablePropertyGenerator | Error | See https://aka.ms/mvvmtoolkit/error
 MVVMTK0029 | CommunityToolkit.Mvvm.SourceGenerators.ObservablePropertyGenerator | Warning | See https://aka.ms/mvvmtoolkit/error
 MVVMTK0030 | CommunityToolkit.Mvvm.SourceGenerators.ObservablePropertyGenerator | Warning | See https://aka.ms/mvvmtoolkit/error
+MVVMTK0031 | CommunityToolkit.Mvvm.SourceGenerators.RelayCommandGenerator | Error | See https://aka.ms/mvvmtoolkit/error

CommunityToolkit.Mvvm.SourceGenerators/Diagnostics/DiagnosticDescriptors.cs

@@ -191,17 +191,17 @@ internal static class DiagnosticDescriptors
     /// <summary>
     /// Gets a <see cref="DiagnosticDescriptor"/> indicating when <c>RelayCommandAttribute.AllowConcurrentExecutions</c> is being set for a non-asynchronous method.
     /// <para>
-    /// Format: <c>"The method {0}.{1} cannot be annotated with the [RelayCommand] attribute specifying a concurrency control setting, as it maps to a non-asynchronous command type"</c>.
+    /// Format: <c>"The method {0}.{1} cannot be annotated with the [RelayCommand] attribute specifying a concurrency control option, as it maps to a non-asynchronous command type"</c>.
     /// </para>
     /// </summary>
     public static readonly DiagnosticDescriptor InvalidConcurrentExecutionsParameterError = new DiagnosticDescriptor(
         id: "MVVMTK0012",
-        title: "Invalid concurrency control setting usage",
-        messageFormat: "The method {0}.{1} cannot be annotated with the [RelayCommand] attribute specifying a concurrency control setting, as it maps to a non-asynchronous command type",
+        title: "Invalid concurrency control option usage",
+        messageFormat: "The method {0}.{1} cannot be annotated with the [RelayCommand] attribute specifying a concurrency control option, as it maps to a non-asynchronous command type",
         category: typeof(RelayCommandGenerator).FullName,
         defaultSeverity: DiagnosticSeverity.Error,
         isEnabledByDefault: true,
-        description: "Cannot apply the [RelayCommand] attribute specifying a concurrency control setting to methods mapping to non-asynchronous command types.",
+        description: "Cannot apply the [RelayCommand] attribute specifying a concurrency control option to methods mapping to non-asynchronous command types.",
         helpLinkUri: "https://aka.ms/mvvmtoolkit");
 
     /// <summary>
@@ -491,4 +491,20 @@ internal static class DiagnosticDescriptors
         isEnabledByDefault: true,
         description: "Annotating a field with [NotifyDataErrorInfo] is not necessary if the containing type has or inherits [NotifyDataErrorInfo] at the class-level.",
         helpLinkUri: "https://aka.ms/mvvmtoolkit");
+
+    /// <summary>
+    /// Gets a <see cref="DiagnosticDescriptor"/> indicating when <c>RelayCommandAttribute.FlowExceptionsToTaskScheduler</c> is being set for a non-asynchronous method.
+    /// <para>
+    /// Format: <c>"The method {0}.{1} cannot be annotated with the [RelayCommand] attribute specifying an exception flow option, as it maps to a non-asynchronous command type"</c>.
+    /// </para>
+    /// </summary>
+    public static readonly DiagnosticDescriptor InvalidFlowExceptionsToTaskSchedulerParameterError = new DiagnosticDescriptor(
+        id: "MVVMTK0031",
+        title: "Invalid task scheduler exception flow option usage",
+        messageFormat: "The method {0}.{1} cannot be annotated with the [RelayCommand] attribute specifying a task scheduler exception flow option, as it maps to a non-asynchronous command type",
+        category: typeof(RelayCommandGenerator).FullName,
+        defaultSeverity: DiagnosticSeverity.Error,
+        isEnabledByDefault: true,
+        description: "Cannot apply the [RelayCommand] attribute specifying a task scheduler exception flow option to methods mapping to non-asynchronous command types.",
+        helpLinkUri: "https://aka.ms/mvvmtoolkit");
 }

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

@@ -25,6 +25,7 @@ namespace CommunityToolkit.Mvvm.SourceGenerators.Input.Models;
 /// <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 enabled.</param>
+/// <param name="FlowExceptionsToTaskScheduler">Whether or not exceptions should flow to the task scheduler.</param>
 /// <param name="IncludeCancelCommand">Whether or not to also generate a cancel command.</param>
 internal sealed record CommandInfo(
     string MethodName,
@@ -38,6 +39,7 @@ internal sealed record CommandInfo(
     string? CanExecuteMemberName,
     CanExecuteExpressionType? CanExecuteExpressionType,
     bool AllowConcurrentExecutions,
+    bool FlowExceptionsToTaskScheduler,
     bool IncludeCancelCommand)
 {
     /// <summary>
@@ -59,6 +61,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.FlowExceptionsToTaskScheduler);
             hashCode.Add(obj.IncludeCancelCommand);
         }
 
@@ -77,6 +80,7 @@ protected override bool AreEqual(CommandInfo x, CommandInfo y)
                 x.CanExecuteMemberName == y.CanExecuteMemberName &&
                 x.CanExecuteExpressionType == y.CanExecuteExpressionType &&
                 x.AllowConcurrentExecutions == y.AllowConcurrentExecutions &&
+                x.FlowExceptionsToTaskScheduler == y.FlowExceptionsToTaskScheduler &&
                 x.IncludeCancelCommand == y.IncludeCancelCommand;
         }
     }

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

@@ -71,6 +71,17 @@ internal static class Execute
                 goto Failure;   
             }
 
+            // Check the switch to control exception flow
+            if (!TryGetFlowExceptionsToTaskSchedulerSwitch(
+                methodSymbol,
+                attributeData,
+                commandClassType,
+                builder,
+                out bool flowExceptionsToTaskScheduler))
+            {
+                goto Failure;
+            }
+
             // Get the CanExecute expression type, if any
             if (!TryGetCanExecuteExpressionType(
                 methodSymbol,
@@ -109,6 +120,7 @@ internal static class Execute
                 canExecuteMemberName,
                 canExecuteExpressionType,
                 allowConcurrentExecutions,
+                flowExceptionsToTaskScheduler,
                 generateCancelCommand);
 
             Failure:
@@ -205,14 +217,38 @@ public static ImmutableArray<MemberDeclarationSyntax> GetSyntax(CommandInfo comm
             }
 
             // Enable concurrent executions, if requested
-            if (commandInfo.AllowConcurrentExecutions)
+            if (commandInfo.AllowConcurrentExecutions && !commandInfo.FlowExceptionsToTaskScheduler)
             {
                 commandCreationArguments.Add(
                     Argument(MemberAccessExpression(
                         SyntaxKind.SimpleMemberAccessExpression,
                         IdentifierName("global::CommunityToolkit.Mvvm.Input.AsyncRelayCommandOptions"),
                         IdentifierName("AllowConcurrentExecutions"))));
             }
+            else if (commandInfo.FlowExceptionsToTaskScheduler && !commandInfo.AllowConcurrentExecutions)
+            {
+                // Enable exception flow, if requested
+                commandCreationArguments.Add(
+                    Argument(MemberAccessExpression(
+                        SyntaxKind.SimpleMemberAccessExpression,
+                        IdentifierName("global::CommunityToolkit.Mvvm.Input.AsyncRelayCommandOptions"),
+                        IdentifierName("FlowExceptionsToTaskScheduler"))));
+            }
+            else if (commandInfo.AllowConcurrentExecutions && commandInfo.FlowExceptionsToTaskScheduler)
+            {
+                // Enable both concurrency control and exception flow
+                commandCreationArguments.Add(
+                    Argument(BinaryExpression(
+                        SyntaxKind.BitwiseOrExpression,
+                        MemberAccessExpression(
+                            SyntaxKind.SimpleMemberAccessExpression,
+                            IdentifierName("global::CommunityToolkit.Mvvm.Input.AsyncRelayCommandOptions"),
+                            IdentifierName("AllowConcurrentExecutions")),
+                        MemberAccessExpression(
+                            SyntaxKind.SimpleMemberAccessExpression,
+                            IdentifierName("global::CommunityToolkit.Mvvm.Input.AsyncRelayCommandOptions"),
+                            IdentifierName("FlowExceptionsToTaskScheduler")))));
+            }
 
             // Construct the generated property as follows (the explicit delegate cast is needed to avoid overload resolution conflicts):
             //
@@ -559,6 +595,43 @@ private static bool TryGetAllowConcurrentExecutionsSwitch(
             }
         }
 
+        /// <summary>
+        /// Checks whether or not the user has requested to configure the task scheduler exception flow option.
+        /// </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="diagnostics">The current collection of gathered diagnostics.</param>
+        /// <param name="flowExceptionsToTaskScheduler">Whether or not task scheduler exception flow have been enabled.</param>
+        /// <returns>Whether or not a value for <paramref name="flowExceptionsToTaskScheduler"/> could be retrieved successfully.</returns>
+        private static bool TryGetFlowExceptionsToTaskSchedulerSwitch(
+            IMethodSymbol methodSymbol,
+            AttributeData attributeData,
+            string commandClassType,
+            ImmutableArray<Diagnostic>.Builder diagnostics,
+            out bool flowExceptionsToTaskScheduler)
+        {
+            // Try to get the custom switch for task scheduler exception flow (the default is false)
+            if (!attributeData.TryGetNamedArgument("FlowExceptionsToTaskScheduler", out flowExceptionsToTaskScheduler))
+            {
+                flowExceptionsToTaskScheduler = false;
+
+                return true;
+            }
+
+            // Just like with the concurrency control option, check that the target command type is asynchronous
+            if (commandClassType is "global::CommunityToolkit.Mvvm.Input.AsyncRelayCommand")
+            {
+                return true;
+            }
+            else
+            {
+                diagnostics.Add(InvalidFlowExceptionsToTaskSchedulerParameterError, methodSymbol, methodSymbol.ContainingType, methodSymbol);
+
+                return false;
+            }
+        }
+
         /// <summary>
         /// Checks whether or not the user has requested to also generate a cancel command.
         /// </summary>

CommunityToolkit.Mvvm/Input/Attributes/RelayCommandAttribute.cs

@@ -75,15 +75,30 @@ public sealed class RelayCommandAttribute : Attribute
 
     /// <summary>
     /// Gets or sets a value indicating whether or not to allow concurrent executions for an asynchronous command.
+    /// <para>
     /// When set for an attribute used on a method that would result in an <see cref="AsyncRelayCommand"/> or an
     /// <see cref="AsyncRelayCommand{T}"/> property to be generated, this will modify the behavior of these commands
     /// 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}, AsyncRelayCommandOptions)"/>
     /// and using the <see cref="AsyncRelayCommandOptions.AllowConcurrentExecutions"/> value.
+    /// </para>
     /// </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 or not to exceptions should be propagated to <see cref="System.Threading.Tasks.TaskScheduler.UnobservedTaskException"/>.
+    /// <para>
+    /// When set for an attribute used on a method that would result in an <see cref="AsyncRelayCommand"/> or an
+    /// <see cref="AsyncRelayCommand{T}"/> property to be generated, this will modify the behavior of these commands
+    /// in case an exception is thrown by the underlying operation. 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}, AsyncRelayCommandOptions)"/>
+    /// and using the <see cref="AsyncRelayCommandOptions.FlowExceptionsToTaskScheduler"/> value.
+    /// </para>
+    /// </summary>
+    /// <remarks>Using this property is not valid if the target command doesn't map to an asynchronous command.</remarks>
+    public bool FlowExceptionsToTaskScheduler { get; init; }
+
     /// <summary>
     /// Gets or sets a value indicating whether a cancel command should also be generated for an asynchronous command.
     /// <para>