Merge pull request #119 from CommunityToolkit/dev/partial-observable-property-methods

[ObservableProperty] generates partial OnPropertyChanging/Changed methods

Author: Sergio0694

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

@@ -142,10 +142,18 @@ public static PropertyInfo GetInfo(IFieldSymbol fieldSymbol, out ImmutableArray<
         /// </summary>
         /// <param name="propertyInfo">The input <see cref="PropertyInfo"/> instance to process.</param>
         /// <returns>The generated <see cref="MemberDeclarationSyntax"/> instance for <paramref name="propertyInfo"/>.</returns>
-        public static MemberDeclarationSyntax GetSyntax(PropertyInfo propertyInfo)
+        public static MemberDeclarationSyntax GetPropertySyntax(PropertyInfo propertyInfo)
         {
             ImmutableArray<StatementSyntax>.Builder setterStatements = ImmutableArray.CreateBuilder<StatementSyntax>();
 
+            // Add the OnPropertyChanging() call first:
+            //
+            // On<PROPERTY_NAME>Changing(value);
+            setterStatements.Add(
+                ExpressionStatement(
+                    InvocationExpression(IdentifierName($"On{propertyInfo.PropertyName}Changing"))
+                    .AddArgumentListArguments(Argument(IdentifierName("value")))));
+
             // Gather the statements to notify dependent properties
             foreach (string propertyName in propertyInfo.PropertyChangingNames)
             {
@@ -192,6 +200,14 @@ public static MemberDeclarationSyntax GetSyntax(PropertyInfo propertyInfo)
                             Argument(LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(propertyInfo.PropertyName))))));
             }
 
+            // Add the OnPropertyChanged() call:
+            //
+            // On<PROPERTY_NAME>Changed(value);
+            setterStatements.Add(
+                ExpressionStatement(
+                    InvocationExpression(IdentifierName($"On{propertyInfo.PropertyName}Changed"))
+                    .AddArgumentListArguments(Argument(IdentifierName("value")))));
+
             // Gather the statements to notify dependent properties
             foreach (string propertyName in propertyInfo.PropertyChangedNames)
             {
@@ -292,6 +308,57 @@ public static MemberDeclarationSyntax GetSyntax(PropertyInfo propertyInfo)
                     .WithBody(Block(setterIfStatement)));
         }
 
+        /// <summary>
+        /// Gets the <see cref="MemberDeclarationSyntax"/> instances for the <c>OnPropertyChanging</c> and <c>OnPropertyChanged</c> methods for the input field.
+        /// </summary>
+        /// <param name="propertyInfo">The input <see cref="PropertyInfo"/> instance to process.</param>
+        /// <returns>The generated <see cref="MemberDeclarationSyntax"/> instances for the <c>OnPropertyChanging</c> and <c>OnPropertyChanged</c> methods.</returns>
+        public static ImmutableArray<MemberDeclarationSyntax> GetOnPropertyChangeMethodsSyntax(PropertyInfo propertyInfo)
+        {
+            // Get the parameter type syntax (adding the nullability annotation, if needed)
+            TypeSyntax parameterType = propertyInfo.IsNullableReferenceType
+                ? NullableType(IdentifierName(propertyInfo.TypeName))
+                : IdentifierName(propertyInfo.TypeName);
+
+            // Construct the generated method as follows:
+            //
+            // /// <summary>Executes the logic for when <see cref="<PROPERTY_NAME>"/> is changing.</summary>
+            // [global::System.CodeDom.Compiler.GeneratedCode("...", "...")]
+            // partial void On<PROPERTY_NAME>Changing(<PROPERTY_TYPE> value);
+            MemberDeclarationSyntax onPropertyChangingDeclaration =
+                MethodDeclaration(PredefinedType(Token(SyntaxKind.VoidKeyword)), Identifier($"On{propertyInfo.PropertyName}Changing"))
+                .AddModifiers(Token(SyntaxKind.PartialKeyword))
+                .AddParameterListParameters(Parameter(Identifier("value")).WithType(parameterType))
+                .AddAttributeLists(
+                    AttributeList(SingletonSeparatedList(
+                        Attribute(IdentifierName("global::System.CodeDom.Compiler.GeneratedCode"))
+                        .AddArgumentListArguments(
+                            AttributeArgument(LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(typeof(ObservablePropertyGenerator).FullName))),
+                            AttributeArgument(LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(typeof(ObservablePropertyGenerator).Assembly.GetName().Version.ToString()))))))
+                    .WithOpenBracketToken(Token(TriviaList(Comment($"/// <summary>Executes the logic for when <see cref=\"{propertyInfo.PropertyName}\"/> is changing.</summary>")), SyntaxKind.OpenBracketToken, TriviaList())))
+                .WithSemicolonToken(Token(SyntaxKind.SemicolonToken));
+
+            // Construct the generated method as follows:
+            //
+            // /// <summary>Executes the logic for when <see cref="<PROPERTY_NAME>"/> ust changed.</summary>
+            // [global::System.CodeDom.Compiler.GeneratedCode("...", "...")]
+            // partial void On<PROPERTY_NAME>Changed(<PROPERTY_TYPE> value);
+            MemberDeclarationSyntax onPropertyChangedDeclaration =
+                MethodDeclaration(PredefinedType(Token(SyntaxKind.VoidKeyword)), Identifier($"On{propertyInfo.PropertyName}Changed"))
+                .AddModifiers(Token(SyntaxKind.PartialKeyword))
+                .AddParameterListParameters(Parameter(Identifier("value")).WithType(parameterType))
+                .AddAttributeLists(
+                    AttributeList(SingletonSeparatedList(
+                        Attribute(IdentifierName("global::System.CodeDom.Compiler.GeneratedCode"))
+                        .AddArgumentListArguments(
+                            AttributeArgument(LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(typeof(ObservablePropertyGenerator).FullName))),
+                            AttributeArgument(LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(typeof(ObservablePropertyGenerator).Assembly.GetName().Version.ToString()))))))
+                    .WithOpenBracketToken(Token(TriviaList(Comment($"/// <summary>Executes the logic for when <see cref=\"{propertyInfo.PropertyName}\"/> just changed.</summary>")), SyntaxKind.OpenBracketToken, TriviaList())))
+                .WithSemicolonToken(Token(SyntaxKind.SemicolonToken));
+
+            return ImmutableArray.Create(onPropertyChangingDeclaration, onPropertyChangedDeclaration);
+        }
+
         /// <summary>
         /// Gets a <see cref="CompilationUnitSyntax"/> instance with the cached args of a specified type.
         /// </summary>

CommunityToolkit.Mvvm.SourceGenerators/ComponentModel/ObservablePropertyGenerator.cs

@@ -69,17 +69,18 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
             .GroupBy(HierarchyInfo.Comparer.Default)
             .WithComparers(HierarchyInfo.Comparer.Default, PropertyInfo.Comparer.Default.ForImmutableArray());
 
-        // Generate the requested properties
+        // Generate the requested properties and methods
         context.RegisterSourceOutput(groupedPropertyInfo, static (context, item) =>
         {
-            // Generate all properties for the current type
-            ImmutableArray<MemberDeclarationSyntax> propertyDeclarations =
+            // Generate all member declarations for the current type
+            ImmutableArray<MemberDeclarationSyntax> memberDeclarations =
                 item.Properties
-                .Select(Execute.GetSyntax)
+                .Select(Execute.GetPropertySyntax)
+                .Concat(item.Properties.Select(Execute.GetOnPropertyChangeMethodsSyntax).SelectMany(static l => l))
                 .ToImmutableArray();
 
-            // Insert all properties into the same partial type declaration
-            CompilationUnitSyntax compilationUnit = item.Hierarchy.GetCompilationUnit(propertyDeclarations);
+            // Insert all members into the same partial type declaration
+            CompilationUnitSyntax compilationUnit = item.Hierarchy.GetCompilationUnit(memberDeclarations);
 
             context.AddSource(
                 hintName: $"{item.Hierarchy.FilenameHint}.cs",

tests/CommunityToolkit.Mvvm.UnitTests/Test_ObservablePropertyAttribute.cs

@@ -273,6 +273,38 @@ public void Test_AlsoNotifyChangeFor()
         CollectionAssert.AreEqual(new[] { nameof(model.Surname), nameof(model.FullName), nameof(model.Alias) }, propertyNames);
     }
 
+    [TestMethod]
+    public void Test_OnPropertyChangingAndChangedPartialMethods()
+    {
+        ViewModelWithImplementedUpdateMethods model = new();
+
+        model.Name = nameof(Test_OnPropertyChangingAndChangedPartialMethods);
+
+        Assert.AreEqual(nameof(Test_OnPropertyChangingAndChangedPartialMethods), model.NameChangingValue);
+        Assert.AreEqual(nameof(Test_OnPropertyChangingAndChangedPartialMethods), model.NameChangedValue);
+
+        model.Number = 99;
+
+        Assert.AreEqual(99, model.NumberChangedValue);
+    }
+
+    [TestMethod]
+    public void Test_OnPropertyChangingAndChangedPartialMethodWithAdditionalValidation()
+    {
+        ViewModelWithImplementedUpdateMethodAndAdditionalValidation model = new();
+
+        // The actual validation is performed inside the model itself.
+        // This test validates that the order with which methods/events are generated is:
+        //   - On<PROPERTY_NAME>Changing(value);
+        //   - OnProperyChanging();
+        //   - field = value;
+        //   - On<PROPERTY_NAME>Changed(value);
+        //   - OnProperyChanged();
+        model.Name = "B";
+
+        Assert.AreEqual("B", model.Name);
+    }
+
     public partial class SampleModel : ObservableObject
     {
         /// <summary>
@@ -398,4 +430,84 @@ public partial class ViewModelWithValidatableGeneratedProperties : ObservableVal
 
         public void RunValidation() => ValidateAllProperties();
     }
+
+    public partial class ViewModelWithImplementedUpdateMethods : ObservableObject
+    {
+        [ObservableProperty]
+        public string? name = "Bob";
+
+        [ObservableProperty]
+        public int number = 42;
+
+        public string? NameChangingValue { get; private set; }
+
+        public string? NameChangedValue { get; private set; }
+
+        public int NumberChangedValue { get; private set; }
+
+        partial void OnNameChanging(string? value)
+        {
+            NameChangingValue = value;
+        }
+
+        partial void OnNameChanged(string? value)
+        {
+            NameChangedValue = value;
+        }
+
+        partial void OnNumberChanged(int value)
+        {
+            NumberChangedValue = value;
+        }
+    }
+
+    public partial class ViewModelWithImplementedUpdateMethodAndAdditionalValidation : ObservableObject
+    {
+        private int step;
+
+        [ObservableProperty]
+        public string? name = "A";
+
+        partial void OnNameChanging(string? value)
+        {
+            Assert.AreEqual(0, this.step);
+
+            this.step = 1;
+
+            Assert.AreEqual("A", this.name);
+            Assert.AreEqual("B", value);
+        }
+
+        partial void OnNameChanged(string? value)
+        {
+            Assert.AreEqual(2, this.step);
+
+            this.step = 3;
+
+            Assert.AreEqual("B", this.name);
+            Assert.AreEqual("B", value);
+        }
+
+        protected override void OnPropertyChanging(PropertyChangingEventArgs e)
+        {
+            base.OnPropertyChanging(e);
+
+            Assert.AreEqual(1, this.step);
+
+            this.step = 2;
+
+            Assert.AreEqual("A", this.name);
+            Assert.AreEqual(nameof(Name), e.PropertyName);
+        }
+
+        protected override void OnPropertyChanged(PropertyChangedEventArgs e)
+        {
+            base.OnPropertyChanged(e);
+
+            Assert.AreEqual(3, this.step);
+
+            Assert.AreEqual("B", this.name);
+            Assert.AreEqual(nameof(Name), e.PropertyName);
+        }
+    }
 }