Update generation to account for properties

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

@@ -4,12 +4,14 @@
 
 using CommunityToolkit.Mvvm.SourceGenerators.Helpers;
 using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
 
 namespace CommunityToolkit.Mvvm.SourceGenerators.ComponentModel.Models;
 
 /// <summary>
 /// A model representing an generated property
 /// </summary>
+/// <param name="AnnotatedMemberKind">The syntax kind of the annotated member that triggered this property generation.</param>
 /// <param name="TypeNameWithNullabilityAnnotations">The type name for the generated property, including nullability annotations.</param>
 /// <param name="FieldName">The field name.</param>
 /// <param name="PropertyName">The generated property name.</param>
@@ -27,6 +29,7 @@ namespace CommunityToolkit.Mvvm.SourceGenerators.ComponentModel.Models;
 /// <param name="IncludeRequiresUnreferencedCodeOnSetAccessor">Indicates whether to annotate the setter as requiring unreferenced code.</param>
 /// <param name="ForwardedAttributes">The sequence of forwarded attributes for the generated property.</param>
 internal sealed record PropertyInfo(
+    SyntaxKind AnnotatedMemberKind,
     string TypeNameWithNullabilityAnnotations,
     string FieldName,
     string PropertyName,

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

@@ -411,6 +411,7 @@ public static bool TryGetInfo(
             token.ThrowIfCancellationRequested();
 
             propertyInfo = new PropertyInfo(
+                memberSyntax.Kind(),
                 typeNameWithNullabilityAnnotations,
                 fieldName,
                 propertyName,
@@ -1092,11 +1093,17 @@ public static MemberDeclarationSyntax GetPropertySyntax(PropertyInfo propertyInf
             ExpressionSyntax getterFieldExpression;
             ExpressionSyntax setterFieldExpression;
 
-            // 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.
-            if (propertyInfo.FieldName == "value")
+            // If the annotated member is a partial property, we always use the 'field' keyword
+            if (propertyInfo.AnnotatedMemberKind is SyntaxKind.PropertyDeclaration)
             {
-                // We only need to add "this." when referencing the field in the setter (getter and XML docs are not ambiguous)
+                getterFieldIdentifierName = "field";
+                getterFieldExpression = setterFieldExpression = IdentifierName(getterFieldIdentifierName);
+            }    
+            else if (propertyInfo.FieldName == "value")
+            {
+                // 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. We only need
+                // to add "this." when referencing the field in the setter (getter and XML docs are not ambiguous)
                 getterFieldIdentifierName = "value";
                 getterFieldExpression = IdentifierName(getterFieldIdentifierName);
                 setterFieldExpression = MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, ThisExpression(), (IdentifierNameSyntax)getterFieldExpression);
@@ -1116,6 +1123,13 @@ public static MemberDeclarationSyntax GetPropertySyntax(PropertyInfo propertyInf
                 getterFieldExpression = setterFieldExpression = IdentifierName(getterFieldIdentifierName);
             }
 
+            // Prepare the XML docs:
+            //   - For partial properties, always just inherit from the partial declaration
+            //   - For fields, inherit from them
+            string xmlSummary = propertyInfo.AnnotatedMemberKind is SyntaxKind.PropertyDeclaration
+                ? "/// <inheritdoc/>"
+                : $"/// <inheritdoc cref=\"{getterFieldIdentifierName}\"/>";
+
             if (propertyInfo.NotifyPropertyChangedRecipients || propertyInfo.IsOldPropertyValueDirectlyReferenced)
             {
                 // Store the old value for later. This code generates a statement as follows:
@@ -1336,13 +1350,18 @@ public static MemberDeclarationSyntax GetPropertySyntax(PropertyInfo propertyInf
             // Also add any forwarded attributes
             setAccessor = setAccessor.AddAttributeLists(forwardedSetAccessorAttributes);
 
+            // Prepare the modifiers for the property
+            SyntaxTokenList propertyModifiers = propertyInfo.AnnotatedMemberKind is SyntaxKind.PropertyDeclaration
+                ? propertyInfo.PropertyAccessibility.ToSyntaxTokenList().Add(Token(SyntaxKind.PartialKeyword))
+                : propertyInfo.PropertyAccessibility.ToSyntaxTokenList();
+
             // Construct the generated property as follows:
             //
-            // /// <inheritdoc cref="<FIELD_NAME>"/>
+            // <XML_SUMMARY>
             // [global::System.CodeDom.Compiler.GeneratedCode("...", "...")]
             // [global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
             // <FORWARDED_ATTRIBUTES>
-            // <PROPERTY_ACCESSIBILITY> <FIELD_TYPE><NULLABLE_ANNOTATION?> <PROPERTY_NAME>
+            // <PROPERTY_MODIFIERS> <FIELD_TYPE><NULLABLE_ANNOTATION?> <PROPERTY_NAME>
             // {
             //     <FORWARDED_ATTRIBUTES>
             //     <GETTER_ACCESSIBILITY> get => <FIELD_NAME>;
@@ -1356,10 +1375,10 @@ public static MemberDeclarationSyntax GetPropertySyntax(PropertyInfo propertyInf
                         .AddArgumentListArguments(
                             AttributeArgument(LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(typeof(ObservablePropertyGenerator).FullName))),
                             AttributeArgument(LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(typeof(ObservablePropertyGenerator).Assembly.GetName().Version.ToString()))))))
-                    .WithOpenBracketToken(Token(TriviaList(Comment($"/// <inheritdoc cref=\"{getterFieldIdentifierName}\"/>")), SyntaxKind.OpenBracketToken, TriviaList())),
+                    .WithOpenBracketToken(Token(TriviaList(Comment(xmlSummary)), SyntaxKind.OpenBracketToken, TriviaList())),
                     AttributeList(SingletonSeparatedList(Attribute(IdentifierName("global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage")))))
                 .AddAttributeLists(forwardedPropertyAttributes)
-                .WithModifiers(propertyInfo.PropertyAccessibility.ToSyntaxTokenList())
+                .WithModifiers(propertyModifiers)
                 .AddAccessorListAccessors(
                     AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)
                     .WithModifiers(propertyInfo.GetterAccessibility.ToSyntaxTokenList())