Add support for forwarded field/property command attributes

Sergio0694 · Sergio0694 · commit 1320475d0d53 · 2023-03-08T18:59:34.000+01:00
diff --git a/src/CommunityToolkit.Mvvm.SourceGenerators/AnalyzerReleases.Shipped.md b/src/CommunityToolkit.Mvvm.SourceGenerators/AnalyzerReleases.Shipped.md
@@ -49,3 +49,11 @@ MVVMTK0032 | CommunityToolkit.Mvvm.SourceGenerators.INotifyPropertyChangedGenera
 MVVMTK0033 | CommunityToolkit.Mvvm.SourceGenerators.ObservableObjectGenerator | Warning | See https://aka.ms/mvvmtoolkit/errors/mvvmtk0033
 MVVMTK0034 | CommunityToolkit.Mvvm.SourceGenerators.ObservablePropertyGenerator | Warning | See https://aka.ms/mvvmtoolkit/errors/mvvmtk0034
 MVVMTK0035 | CommunityToolkit.Mvvm.SourceGenerators.ObservablePropertyGenerator | Error | See https://aka.ms/mvvmtoolkit/errors/mvvmtk0035
+
+## Release 8.2
+
+### New Rules
+
+Rule ID | Category | Severity | Notes
+--------|----------|----------|-------
+MVVMTK0036 | CommunityToolkit.Mvvm.SourceGenerators.RelayCommandGenerator | Error | See https://aka.ms/mvvmtoolkit/errors/mvvmtk0036
diff --git a/src/CommunityToolkit.Mvvm.SourceGenerators/Diagnostics/DiagnosticDescriptors.cs b/src/CommunityToolkit.Mvvm.SourceGenerators/Diagnostics/DiagnosticDescriptors.cs
@@ -589,4 +589,20 @@ internal static class DiagnosticDescriptors
         isEnabledByDefault: true,
         description: "All attributes targeting the generated property for a field annotated with [ObservableProperty] must correctly be resolved to valid types.",
         helpLinkUri: "https://aka.ms/mvvmtoolkit/errors/mvvmtk0035");
+
+    /// <summary>
+    /// Gets a <see cref="DiagnosticDescriptor"/> indicating when a method with <c>[RelayCommand]</c> is using an invalid attribute targeting the field or property.
+    /// <para>
+    /// Format: <c>"The method {0} annotated with [RelayCommand] is using attribute "{1}" which was not recognized as a valid type (are you missing a using directive?)"</c>.
+    /// </para>
+    /// </summary>
+    public static readonly DiagnosticDescriptor InvalidFieldOrPropertyTargetedAttributeOnRelayCommandMethod = new DiagnosticDescriptor(
+        id: "MVVMTK0036",
+        title: "Invalid field targeted attribute type",
+        messageFormat: "The method {0} annotated with [RelayCommand] is using attribute \"{1}\" which was not recognized as a valid type (are you missing a using directive?)",
+        category: typeof(RelayCommandGenerator).FullName,
+        defaultSeverity: DiagnosticSeverity.Error,
+        isEnabledByDefault: true,
+        description: "All attributes targeting the generated field or property for a method annotated with [RelayCommand] must correctly be resolved to valid types.",
+        helpLinkUri: "https://aka.ms/mvvmtoolkit/errors/mvvmtk0036");
 }
diff --git a/src/CommunityToolkit.Mvvm.SourceGenerators/Input/Models/CommandInfo.cs b/src/CommunityToolkit.Mvvm.SourceGenerators/Input/Models/CommandInfo.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using CommunityToolkit.Mvvm.SourceGenerators.ComponentModel.Models;
 using CommunityToolkit.Mvvm.SourceGenerators.Helpers;
 
 namespace CommunityToolkit.Mvvm.SourceGenerators.Input.Models;
@@ -22,6 +23,8 @@ namespace CommunityToolkit.Mvvm.SourceGenerators.Input.Models;
 /// <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>
+/// <param name="ForwardedFieldAttributes">The sequence of forwarded attributes for the generated field.</param>
+/// <param name="ForwardedPropertyAttributes">The sequence of forwarded attributes for the generated property.</param>
 internal sealed record CommandInfo(
     string MethodName,
     string FieldName,
@@ -35,4 +38,6 @@ internal sealed record CommandInfo(
     CanExecuteExpressionType? CanExecuteExpressionType,
     bool AllowConcurrentExecutions,
     bool FlowExceptionsToTaskScheduler,
-    bool IncludeCancelCommand);
+    bool IncludeCancelCommand,
+    EquatableArray<AttributeInfo> ForwardedFieldAttributes,
+    EquatableArray<AttributeInfo> ForwardedPropertyAttributes);
diff --git a/src/CommunityToolkit.Mvvm.SourceGenerators/Input/RelayCommandGenerator.Execute.cs b/src/CommunityToolkit.Mvvm.SourceGenerators/Input/RelayCommandGenerator.Execute.cs
@@ -7,6 +7,8 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 using System.Linq;
+using System.Threading;
+using CommunityToolkit.Mvvm.SourceGenerators.ComponentModel.Models;
 using CommunityToolkit.Mvvm.SourceGenerators.Extensions;
 using CommunityToolkit.Mvvm.SourceGenerators.Helpers;
 using CommunityToolkit.Mvvm.SourceGenerators.Input.Models;
@@ -32,12 +34,16 @@ internal static class Execute
         /// </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="semanticModel">The <see cref="SemanticModel"/> instance for the current run.</param>
+        /// <param name="token">The cancellation token for the current operation.</param>
         /// <param name="commandInfo">The resulting <see cref="CommandInfo"/> instance, if successfully generated.</param>
         /// <param name="diagnostics">The resulting diagnostics from the processing operation.</param>
         /// <returns>Whether a <see cref="CommandInfo"/> instance could be generated successfully.</returns>
         public static bool TryGetInfo(
             IMethodSymbol methodSymbol,
             AttributeData attributeData,
+            SemanticModel semanticModel,
+            CancellationToken token,
             [NotNullWhen(true)] out CommandInfo? commandInfo,
             out ImmutableArray<DiagnosticInfo> diagnostics)
         {
@@ -113,6 +119,15 @@ public static bool TryGetInfo(
                 goto Failure;
             }
 
+            // Get all forwarded attributes (don't stop in case of errors, just ignore faulting attributes)
+            GatherForwardedAttributes(
+                methodSymbol,
+                semanticModel,
+                token,
+                in builder,
+                out ImmutableArray<AttributeInfo> fieldAttributes,
+                out ImmutableArray<AttributeInfo> propertyAttributes);
+
             commandInfo = new CommandInfo(
                 methodSymbol.Name,
                 fieldName,
@@ -126,7 +141,9 @@ public static bool TryGetInfo(
                 canExecuteExpressionType,
                 allowConcurrentExecutions,
                 flowExceptionsToTaskScheduler,
-                generateCancelCommand);
+                generateCancelCommand,
+                fieldAttributes,
+                propertyAttributes);
 
             diagnostics = builder.ToImmutable();
 
@@ -160,10 +177,23 @@ public static ImmutableArray<MemberDeclarationSyntax> GetSyntax(CommandInfo comm
                 ? commandInfo.DelegateType
                 : $"{commandInfo.DelegateType}<{string.Join(", ", commandInfo.DelegateTypeArguments)}>";
 
+            // Prepare the forwarded field attributes, if any
+            ImmutableArray<AttributeListSyntax> forwardedFieldAttributes =
+                commandInfo.ForwardedFieldAttributes
+                .Select(static a => AttributeList(SingletonSeparatedList(a.GetSyntax())))
+                .ToImmutableArray();
+
+            // Also prepare any forwarded property attributes
+            ImmutableArray<AttributeListSyntax> forwardedPropertyAttributes =
+                commandInfo.ForwardedPropertyAttributes
+                .Select(static a => AttributeList(SingletonSeparatedList(a.GetSyntax())))
+                .ToImmutableArray();
+
             // Construct the generated field as follows:
             //
             // /// <summary>The backing field for <see cref="<COMMAND_PROPERTY_NAME>"/></summary>
             // [global::System.CodeDom.Compiler.GeneratedCode("...", "...")]
+            // <FORWARDED_ATTRIBUTES>
             // private <COMMAND_TYPE>? <COMMAND_FIELD_NAME>;
             FieldDeclarationSyntax fieldDeclaration =
                 FieldDeclaration(
@@ -176,7 +206,8 @@ public static ImmutableArray<MemberDeclarationSyntax> GetSyntax(CommandInfo comm
                         .AddArgumentListArguments(
                             AttributeArgument(LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(typeof(RelayCommandGenerator).FullName))),
                             AttributeArgument(LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(typeof(RelayCommandGenerator).Assembly.GetName().Version.ToString()))))))
-                    .WithOpenBracketToken(Token(TriviaList(Comment($"/// <summary>The backing field for <see cref=\"{commandInfo.PropertyName}\"/>.</summary>")), SyntaxKind.OpenBracketToken, TriviaList())));
+                    .WithOpenBracketToken(Token(TriviaList(Comment($"/// <summary>The backing field for <see cref=\"{commandInfo.PropertyName}\"/>.</summary>")), SyntaxKind.OpenBracketToken, TriviaList())))
+                .AddAttributeLists(forwardedFieldAttributes.ToArray());
 
             // Prepares the argument to pass the underlying method to invoke
             using ImmutableArrayBuilder<ArgumentSyntax> commandCreationArguments = ImmutableArrayBuilder<ArgumentSyntax>.Rent();
@@ -265,6 +296,7 @@ public static ImmutableArray<MemberDeclarationSyntax> GetSyntax(CommandInfo comm
             // /// <summary>Gets an <see cref="<COMMAND_INTERFACE_TYPE>" instance wrapping <see cref="<METHOD_NAME>"/> and <see cref="<OPTIONAL_CAN_EXECUTE>"/>.</summary>
             // [global::System.CodeDom.Compiler.GeneratedCode("...", "...")]
             // [global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
+            // <FORWARDED_ATTRIBUTES>
             // public <COMMAND_TYPE> <COMMAND_PROPERTY_NAME> => <COMMAND_FIELD_NAME> ??= new <RELAY_COMMAND_TYPE>(<COMMAND_CREATION_ARGUMENTS>);
             PropertyDeclarationSyntax propertyDeclaration =
                 PropertyDeclaration(
@@ -282,6 +314,7 @@ public static ImmutableArray<MemberDeclarationSyntax> GetSyntax(CommandInfo comm
                         SyntaxKind.OpenBracketToken,
                         TriviaList())),
                     AttributeList(SingletonSeparatedList(Attribute(IdentifierName("global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage")))))
+                .AddAttributeLists(forwardedPropertyAttributes.ToArray())
                 .WithExpressionBody(
                     ArrowExpressionClause(
                         AssignmentExpression(
@@ -898,5 +931,75 @@ private static bool TryGetCanExecuteMemberFromGeneratedProperty(
 
             return false;
         }
+
+        /// <summary>
+        /// Gathers all forwarded attributes for the generated field and property.
+        /// </summary>
+        /// <param name="methodSymbol">The input <see cref="IMethodSymbol"/> instance to process.</param>
+        /// <param name="semanticModel">The <see cref="SemanticModel"/> instance for the current run.</param>
+        /// <param name="token">The cancellation token for the current operation.</param>
+        /// <param name="diagnostics">The current collection of gathered diagnostics.</param>
+        /// <param name="fieldAttributes">The resulting field attributes to forward.</param>
+        /// <param name="propertyAttributes">The resulting property attributes to forward.</param>
+        private static void GatherForwardedAttributes(
+            IMethodSymbol methodSymbol,
+            SemanticModel semanticModel,
+            CancellationToken token,
+            in ImmutableArrayBuilder<DiagnosticInfo> diagnostics,
+            out ImmutableArray<AttributeInfo> fieldAttributes,
+            out ImmutableArray<AttributeInfo> propertyAttributes)
+        {
+            using ImmutableArrayBuilder<AttributeInfo> fieldAttributesInfo = ImmutableArrayBuilder<AttributeInfo>.Rent();
+            using ImmutableArrayBuilder<AttributeInfo> propertyAttributesInfo = ImmutableArrayBuilder<AttributeInfo>.Rent();
+
+            foreach (SyntaxReference syntaxReference in methodSymbol.DeclaringSyntaxReferences)
+            {
+                // Try to get the target method declaration syntax node
+                if (syntaxReference.GetSyntax(token) is not MethodDeclarationSyntax methodDeclaration)
+                {
+                    continue;
+                }
+
+                // Gather explicit forwarded attributes info
+                foreach (AttributeListSyntax attributeList in methodDeclaration.AttributeLists)
+                {
+                    // Same as in the [ObservableProperty] generator, except we're also looking for fields here
+                    if (attributeList.Target?.Identifier.Kind() is not (SyntaxKind.PropertyKeyword or SyntaxKind.FieldKeyword))
+                    {
+                        continue;
+                    }
+
+                    foreach (AttributeSyntax attribute in attributeList.Attributes)
+                    {
+                        // Get the symbol info for the attribute (once again just like in the [ObservableProperty] generator)
+                        if (!semanticModel.GetSymbolInfo(attribute, token).TryGetAttributeTypeSymbol(out INamedTypeSymbol? attributeTypeSymbol))
+                        {
+                            diagnostics.Add(
+                                InvalidFieldOrPropertyTargetedAttributeOnRelayCommandMethod,
+                                attribute,
+                                methodSymbol,
+                                attribute.Name);
+
+                            continue;
+                        }
+
+                        AttributeInfo attributeInfo = AttributeInfo.From(attributeTypeSymbol, semanticModel, attribute.ArgumentList?.Arguments ?? Enumerable.Empty<AttributeArgumentSyntax>(), token);
+
+                        // Add the new attribute info to the right builder
+                        if (attributeList.Target?.Identifier.Kind() is SyntaxKind.FieldKeyword)
+                        {
+                            fieldAttributesInfo.Add(attributeInfo);
+                        }
+                        else
+                        {
+                            propertyAttributesInfo.Add(attributeInfo);
+                        }
+                    }
+                }
+            }
+
+            fieldAttributes = fieldAttributesInfo.ToImmutable();
+            propertyAttributes = propertyAttributesInfo.ToImmutable();
+        }
     }
 }
diff --git a/src/CommunityToolkit.Mvvm.SourceGenerators/Input/RelayCommandGenerator.cs b/src/CommunityToolkit.Mvvm.SourceGenerators/Input/RelayCommandGenerator.cs
@@ -40,7 +40,13 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
                     // Get the hierarchy info for the target symbol, and try to gather the command info
                     HierarchyInfo? hierarchy = HierarchyInfo.From(methodSymbol.ContainingType);
 
-                    _ = Execute.TryGetInfo(methodSymbol, context.Attributes[0], out CommandInfo? commandInfo, out ImmutableArray<DiagnosticInfo> diagnostics);
+                    _ = Execute.TryGetInfo(
+                        methodSymbol,
+                        context.Attributes[0],
+                        context.SemanticModel,
+                        token,
+                        out CommandInfo? commandInfo,
+                        out ImmutableArray<DiagnosticInfo> diagnostics);
 
                     return (Hierarchy: hierarchy, new Result<CommandInfo?>(commandInfo, diagnostics));
                 })
