Implement code generation for [AlsoBroadcastChange]

Author: Sergio0694

CommunityToolkit.Mvvm.SourceGenerators/AnalyzerReleases.Unshipped.md

@@ -26,3 +26,4 @@ MVVMTK0018 | CommunityToolkit.Mvvm.SourceGenerators.ObservableObjectGenerator |
 MVVMTK0019 | CommunityToolkit.Mvvm.SourceGenerators.ObservablePropertyGenerator | Error | See https://aka.ms/mvvmtoolkit/error
 MVVMTK0020 | CommunityToolkit.Mvvm.SourceGenerators.ObservablePropertyGenerator | Error | See https://aka.ms/mvvmtoolkit/error
 MVVMTK0021 | CommunityToolkit.Mvvm.SourceGenerators.ObservableRecipientGenerator | Error | See https://aka.ms/mvvmtoolkit/error
+MVVMTK0022 | CommunityToolkit.Mvvm.SourceGenerators.ObservablePropertyGenerator | Error | See https://aka.ms/mvvmtoolkit/error

CommunityToolkit.Mvvm.SourceGenerators/ComponentModel/Models/PropertyInfo.cs

@@ -21,6 +21,7 @@ namespace CommunityToolkit.Mvvm.SourceGenerators.ComponentModel.Models;
 /// <param name="PropertyChangingNames">The sequence of property changing properties to notify.</param>
 /// <param name="PropertyChangedNames">The sequence of property changed properties to notify.</param>
 /// <param name="NotifiedCommandNames">The sequence of commands to notify.</param>
+/// <param name="AlsoBroadcastChange">Whether or not the generated property also broadcasts changes.</param>
 /// <param name="ValidationAttributes">The sequence of validation attributes for the generated property.</param>
 internal sealed record PropertyInfo(
     string TypeName,
@@ -30,6 +31,7 @@ internal sealed record PropertyInfo(
     ImmutableArray<string> PropertyChangingNames,
     ImmutableArray<string> PropertyChangedNames,
     ImmutableArray<string> NotifiedCommandNames,
+    bool AlsoBroadcastChange,
     ImmutableArray<AttributeInfo> ValidationAttributes)
 {
     /// <summary>
@@ -47,6 +49,7 @@ protected override void AddToHashCode(ref HashCode hashCode, PropertyInfo obj)
             hashCode.AddRange(obj.PropertyChangingNames);
             hashCode.AddRange(obj.PropertyChangedNames);
             hashCode.AddRange(obj.NotifiedCommandNames);
+            hashCode.Add(obj.AlsoBroadcastChange);
             hashCode.AddRange(obj.ValidationAttributes, AttributeInfo.Comparer.Default);
         }
 
@@ -61,6 +64,7 @@ protected override bool AreEqual(PropertyInfo x, PropertyInfo y)
                 x.PropertyChangingNames.SequenceEqual(y.PropertyChangingNames) &&
                 x.PropertyChangedNames.SequenceEqual(y.PropertyChangedNames) &&
                 x.NotifiedCommandNames.SequenceEqual(y.NotifiedCommandNames) &&
+                x.AlsoBroadcastChange == y.AlsoBroadcastChange &&
                 x.ValidationAttributes.SequenceEqual(y.ValidationAttributes, AttributeInfo.Comparer.Default);
         }
     }

CommunityToolkit.Mvvm.SourceGenerators/ComponentModel/ObservablePropertyGenerator.Execute.cs

@@ -75,6 +75,7 @@ internal static class Execute
             ImmutableArray<string>.Builder propertyChangingNames = ImmutableArray.CreateBuilder<string>();
             ImmutableArray<string>.Builder notifiedCommandNames = ImmutableArray.CreateBuilder<string>();
             ImmutableArray<AttributeInfo>.Builder validationAttributes = ImmutableArray.CreateBuilder<AttributeInfo>();
+            bool alsoBroadcastChange = false;
 
             // Track the property changing event for the property, if the type supports it
             if (shouldInvokeOnPropertyChanging)
@@ -90,7 +91,8 @@ internal static class Execute
             {
                 // Gather dependent property and command names
                 if (TryGatherDependentPropertyChangedNames(fieldSymbol, attributeData, propertyChangedNames, builder) ||
-                    TryGatherDependentCommandNames(fieldSymbol, attributeData, notifiedCommandNames, builder))
+                    TryGatherDependentCommandNames(fieldSymbol, attributeData, notifiedCommandNames, builder) ||
+                    TryGetIsBroadcastingChanges(fieldSymbol, attributeData, builder, out alsoBroadcastChange))
                 {
                     continue;
                 }
@@ -129,6 +131,7 @@ internal static class Execute
                 propertyChangingNames.ToImmutable(),
                 propertyChangedNames.ToImmutable(),
                 notifiedCommandNames.ToImmutable(),
+                alsoBroadcastChange,
                 validationAttributes.ToImmutable());
         }
 
@@ -326,6 +329,48 @@ bool IsCommandNameValidWithGeneratedMembers(string commandName)
             return false;
         }
 
+        /// <summary>
+        /// Checks whether a given generated property should also broadcast changes.
+        /// </summary>
+        /// <param name="fieldSymbol">The input <see cref="IFieldSymbol"/> instance to process.</param>
+        /// <param name="attributeData">The <see cref="AttributeData"/> instance for <paramref name="fieldSymbol"/>.</param>
+        /// <param name="diagnostics">The current collection of gathered diagnostics.</param>
+        /// <param name="alsoBroadcastChange">Whether or not the resulting property should also broadcast changes.</param>
+        /// <returns>Whether or not the generated property for <paramref name="fieldSymbol"/> used <c>[AlsoBroadcastChange]</c>.</returns>
+        private static bool TryGetIsBroadcastingChanges(
+            IFieldSymbol fieldSymbol,
+            AttributeData attributeData,
+            ImmutableArray<Diagnostic>.Builder diagnostics,
+            out bool alsoBroadcastChange)
+        {
+            if (attributeData.AttributeClass?.HasFullyQualifiedName("global::CommunityToolkit.Mvvm.ComponentModel.AlsoBroadcastChangeAttribute") == true)
+            {
+                // If the containing type is valid, track it
+                if (fieldSymbol.ContainingType.InheritsFromFullyQualifiedName("global::CommunityToolkit.Mvvm.ComponentModel.ObservableRecipient") ||
+                    fieldSymbol.ContainingType.HasOrInheritsAttributeWithFullyQualifiedName("global::CommunityToolkit.Mvvm.ComponentModel.ObservableRecipientAttribute"))
+                {
+                    alsoBroadcastChange = true;
+
+                    return true;
+                }
+
+                // Otherwise just emit the diagnostic and then ignore the attribute
+                diagnostics.Add(
+                    InvalidContainingTypeForAlsoBroadcastChangeFieldError,
+                    fieldSymbol,
+                    fieldSymbol.ContainingType,
+                    fieldSymbol.Name);
+
+                alsoBroadcastChange = false;
+
+                return true;
+            }
+
+            alsoBroadcastChange = false;
+
+            return false;
+        }
+
         /// <summary>
         /// Gets a <see cref="CompilationUnitSyntax"/> instance with the cached args for property changing notifications.
         /// </summary>
@@ -361,6 +406,33 @@ public static MemberDeclarationSyntax GetPropertySyntax(PropertyInfo propertyInf
         {
             ImmutableArray<StatementSyntax>.Builder setterStatements = ImmutableArray.CreateBuilder<StatementSyntax>();
 
+            // Get the property type syntax (adding the nullability annotation, if needed)
+            TypeSyntax propertyType = propertyInfo.IsNullableReferenceType
+                ? NullableType(IdentifierName(propertyInfo.TypeName))
+                : IdentifierName(propertyInfo.TypeName);
+
+            // In case the backing field is exactly named "value", we need to add the "this." prefix to ensure that comparisons and assignments
+            // with it in the generated setter body are executed correctly and without conflicts with the implicit value parameter.
+            ExpressionSyntax fieldExpression = propertyInfo.FieldName switch
+            {
+                "value" => MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, ThisExpression(), IdentifierName("value")),
+                string name => IdentifierName(name)
+            };
+
+            if (propertyInfo.AlsoBroadcastChange)
+            {
+                // If broadcasting changes are required, also store the old value.
+                // This code generates a statement as follows:
+                //
+                // <PROPERTY_TYPE> __oldValue = <FIELD_EXPRESSIONS>;
+                setterStatements.Add(
+                    LocalDeclarationStatement(
+                        VariableDeclaration(propertyType)
+                        .AddVariables(
+                            VariableDeclarator(Identifier("__oldValue"))
+                            .WithInitializer(EqualsValueClause(fieldExpression)))));
+            }
+
             // Add the OnPropertyChanging() call first:
             //
             // On<PROPERTY_NAME>Changing(value);
@@ -384,14 +456,6 @@ public static MemberDeclarationSyntax GetPropertySyntax(PropertyInfo propertyInf
                             IdentifierName(propertyName))))));
             }
 
-            // In case the backing field is exactly named "value", we need to add the "this." prefix to ensure that comparisons and assignments
-            // with it in the generated setter body are executed correctly and without conflicts with the implicit value parameter.
-            ExpressionSyntax fieldExpression = propertyInfo.FieldName switch
-            {
-                "value" => MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, ThisExpression(), IdentifierName("value")),
-                string name => IdentifierName(name)
-            };
-
             // Add the assignment statement:
             //
             // <FIELD_EXPRESSION> = value;
@@ -452,10 +516,20 @@ public static MemberDeclarationSyntax GetPropertySyntax(PropertyInfo propertyInf
                             IdentifierName("NotifyCanExecuteChanged")))));
             }
 
-            // Get the property type syntax (adding the nullability annotation, if needed)
-            TypeSyntax propertyType = propertyInfo.IsNullableReferenceType
-                ? NullableType(IdentifierName(propertyInfo.TypeName))
-                : IdentifierName(propertyInfo.TypeName);
+            // Also broadcast the change, if requested
+            if (propertyInfo.AlsoBroadcastChange)
+            {
+                // This code generates a statement as follows:
+                //
+                // Broadcast(__oldValue, value, "<PROPERTY_NAME>");
+                setterStatements.Add(
+                    ExpressionStatement(
+                        InvocationExpression(IdentifierName("Broadcast"))
+                        .AddArgumentListArguments(
+                            Argument(IdentifierName("__oldValue")),
+                            Argument(IdentifierName("value")),
+                            Argument(LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(propertyInfo.PropertyName))))));
+            }
 
             // Generate the inner setter block as follows:
             //

CommunityToolkit.Mvvm.SourceGenerators/Diagnostics/DiagnosticDescriptors.cs

@@ -347,4 +347,20 @@ internal static class DiagnosticDescriptors
         isEnabledByDefault: true,
         description: "Cannot apply [ObservableRecipient] to a type that already inherits this attribute from a base type.",
         helpLinkUri: "https://aka.ms/mvvmtoolkit");
+
+    /// <summary>
+    /// Gets a <see cref="DiagnosticDescriptor"/> indicating when <c>[AlsoBroadcastChange]</c> is applied to a field in an invalid type.
+    /// <para>
+    /// Format: <c>"The field {0}.{1} cannot be annotated with [AlsoBroadcastChange], as its containing type doesn't inherit from ObservableRecipient, nor does it use [ObservableRecipient]"</c>.
+    /// </para>
+    /// </summary>
+    public static readonly DiagnosticDescriptor InvalidContainingTypeForAlsoBroadcastChangeFieldError = new DiagnosticDescriptor(
+        id: "MVVMTK0022",
+        title: "Invalid containing type for [ObservableProperty] field",
+        messageFormat: "The field {0}.{1} cannot be annotated with [AlsoBroadcastChange], as its containing type doesn't inherit from ObservableRecipient, nor does it use [ObservableRecipient]",
+        category: typeof(ObservablePropertyGenerator).FullName,
+        defaultSeverity: DiagnosticSeverity.Error,
+        isEnabledByDefault: true,
+        description: "Fields annotated with [AlsoBroadcastChange] must be contained in a type that inherits from ObservableRecipient or that is annotated with [ObservableRecipient] (including base types).",
+        helpLinkUri: "https://aka.ms/mvvmtoolkit");
 }