Add logic to match partial properties

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

@@ -30,6 +30,66 @@ partial class ObservablePropertyGenerator
     /// </summary>
     internal static class Execute
     {
+        /// <summary>
+        /// Checks whether an input syntax node is a candidate property declaration for the generator.
+        /// </summary>
+        /// <param name="node">The input syntax node to check.</param>
+        /// <param name="token">The <see cref="CancellationToken"/> used to cancel the operation, if needed.</param>
+        /// <returns>Whether <paramref name="node"/> is a candidate property declaration.</returns>
+        public static bool IsCandidatePropertyDeclaration(SyntaxNode node, CancellationToken token)
+        {
+            // Matches a valid field declaration, for legacy support
+            static bool IsCandidateField(SyntaxNode node)
+            {
+                return node is VariableDeclaratorSyntax {
+                    Parent: VariableDeclarationSyntax {
+                        Parent: FieldDeclarationSyntax {
+                            Parent: ClassDeclarationSyntax or RecordDeclarationSyntax, AttributeLists.Count: > 0 } } };
+            }
+
+#if ROSLYN_4_11_0_OR_GREATER
+            // Matches a valid partial property declaration
+            static bool IsCandidateProperty(SyntaxNode node)
+            {
+                // The node must be a property declaration with two accessors
+                if (node is not PropertyDeclarationSyntax { AccessorList.Accessors: { Count: 2 } accessors } property)
+                {
+                    return false;
+                }
+
+                // The property must be partial (we'll check that it's a declaration from its symbol)
+                if (!property.Modifiers.Any(SyntaxKind.PartialKeyword))
+                {
+                    return false;
+                }
+
+                // The accessors must be a get and a set (with any accessibility)
+                if (accessors[0].Kind() is not (SyntaxKind.GetAccessorDeclaration or SyntaxKind.SetAccessorDeclaration) ||
+                    accessors[1].Kind() is not (SyntaxKind.GetAccessorDeclaration or SyntaxKind.SetAccessorDeclaration))
+                {
+                    return false;
+                }
+
+                return true;
+            }
+
+            // We only support matching properties on Roslyn 4.11 and greater
+            if (!IsCandidateField(node) && !IsCandidateProperty(node))
+            {
+                return false;
+            }
+#else
+            // Otherwise, we only support matching fields
+            if (!IsCandidateField(node))
+            {
+                return false;
+            }
+#endif
+
+            // The property must be in a type with a base type (as it must derive from ObservableObject)
+            return node.Parent?.IsTypeDeclarationWithOrPotentiallyWithBaseTypes<ClassDeclarationSyntax>() == true;
+        }
+
         /// <summary>
         /// Processes a given field.
         /// </summary>
@@ -799,6 +859,60 @@ private static void GetNullabilityInfo(
                 semanticModel.Compilation.HasAccessibleTypeWithMetadataName("System.Diagnostics.CodeAnalysis.MemberNotNullAttribute");
         }
 
+        /// <summary>
+        /// Tries to get the accessibility of the property and accessors, if possible.
+        /// </summary>
+        /// <param name="node">The input <see cref="PropertyDeclarationSyntax"/> node.</param>
+        /// <param name="symbol">The input <see cref="IPropertySymbol"/> instance.</param>
+        /// <param name="declaredAccessibility">The accessibility of the property, if available.</param>
+        /// <param name="getterAccessibility">The accessibility of the <see langword="get"/> accessor, if available.</param>
+        /// <param name="setterAccessibility">The accessibility of the <see langword="set"/> accessor, if available.</param>
+        /// <returns>Whether the property was valid and the accessibilities could be retrieved.</returns>
+        private static bool TryGetAccessibilityModifiers(
+            PropertyDeclarationSyntax node,
+            IPropertySymbol symbol,
+            out Accessibility declaredAccessibility,
+            out Accessibility getterAccessibility,
+            out Accessibility setterAccessibility)
+        {
+            declaredAccessibility = Accessibility.NotApplicable;
+            getterAccessibility = Accessibility.NotApplicable;
+            setterAccessibility = Accessibility.NotApplicable;
+
+            // Ensure that we have a getter and a setter, and that the setter is not init-only
+            if (symbol is not { GetMethod: { } getMethod, SetMethod: { IsInitOnly: false } setMethod })
+            {
+                return false;
+            }
+
+            // Track the property accessibility if explicitly set
+            if (node.Modifiers.Count > 0)
+            {
+                declaredAccessibility = symbol.DeclaredAccessibility;
+            }
+
+            // Track the accessors accessibility, if explicitly set
+            foreach (AccessorDeclarationSyntax accessor in node.AccessorList?.Accessors ?? [])
+            {
+                if (accessor.Modifiers.Count == 0)
+                {
+                    continue;
+                }
+
+                switch (accessor.Kind())
+                {
+                    case SyntaxKind.GetAccessorDeclaration:
+                        getterAccessibility = getMethod.DeclaredAccessibility;
+                        break;
+                    case SyntaxKind.SetAccessorDeclaration:
+                        setterAccessibility = setMethod.DeclaredAccessibility;
+                        break;
+                }
+            }
+
+            return true;
+        }
+
         /// <summary>
         /// Gets a <see cref="CompilationUnitSyntax"/> instance with the cached args for property changing notifications.
         /// </summary>

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

@@ -27,7 +27,7 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
         IncrementalValuesProvider<(HierarchyInfo Hierarchy, Result<PropertyInfo?> Info)> propertyInfoWithErrors =
             context.ForAttributeWithMetadataNameAndOptions(
                 "CommunityToolkit.Mvvm.ComponentModel.ObservablePropertyAttribute",
-                static (node, _) => node is VariableDeclaratorSyntax { Parent: VariableDeclarationSyntax { Parent: FieldDeclarationSyntax { Parent: ClassDeclarationSyntax or RecordDeclarationSyntax, AttributeLists.Count: > 0 } } },
+                Execute.IsCandidatePropertyDeclaration,
                 static (context, token) =>
                 {
                     if (!context.SemanticModel.Compilation.HasLanguageVersionAtLeastEqualTo(LanguageVersion.CSharp8))

src/CommunityToolkit.Mvvm.SourceGenerators/Extensions/SyntaxNodeExtensions.cs

@@ -3,6 +3,8 @@
 // See the LICENSE file in the project root for more information.
 
 using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.CSharp;
 
 namespace CommunityToolkit.Mvvm.SourceGenerators.Extensions;
 
@@ -30,4 +32,30 @@ public static bool IsFirstSyntaxDeclarationForSymbol(this SyntaxNode syntaxNode,
             syntaxReference.SyntaxTree == syntaxNode.SyntaxTree &&
             syntaxReference.Span == syntaxNode.Span;
     }
+
+    /// <summary>
+    /// Checks whether a given <see cref="SyntaxNode"/> is a given type declaration with or potentially with any base types, using only syntax.
+    /// </summary>
+    /// <typeparam name="T">The type of declaration to check for.</typeparam>
+    /// <param name="node">The input <see cref="SyntaxNode"/> to check.</param>
+    /// <returns>Whether <paramref name="node"/> is a given type declaration with or potentially with any base types.</returns>
+    public static bool IsTypeDeclarationWithOrPotentiallyWithBaseTypes<T>(this SyntaxNode node)
+        where T : TypeDeclarationSyntax
+    {
+        // Immediately bail if the node is not a type declaration of the specified type
+        if (node is not T typeDeclaration)
+        {
+            return false;
+        }
+
+        // If the base types list is not empty, the type can definitely has implemented interfaces
+        if (typeDeclaration.BaseList is { Types.Count: > 0 })
+        {
+            return true;
+        }
+
+        // If the base types list is empty, check if the type is partial. If it is, it means
+        // that there could be another partial declaration with a non-empty base types list.
+        return typeDeclaration.Modifiers.Any(SyntaxKind.PartialKeyword);
+    }
 }