Add [MemberNotNull] to [ObservableProperty] set accessor

Author: Sergio0694

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

@@ -19,6 +19,7 @@ namespace CommunityToolkit.Mvvm.SourceGenerators.ComponentModel.Models;
 /// <param name="NotifyDataErrorInfo">Whether or not the generated property also validates its value.</param>
 /// <param name="IsOldPropertyValueDirectlyReferenced">Whether the old property value is being directly referenced.</param>
 /// <param name="IsReferenceType">Indicates whether the property is of a reference type.</param>
+/// <param name="IncludeMemberNotNullOnSetAccessor">Indicates whether to include nullability annotations on the setter.</param>
 /// <param name="ForwardedAttributes">The sequence of forwarded attributes for the generated property.</param>
 internal sealed record PropertyInfo(
     string TypeNameWithNullabilityAnnotations,
@@ -31,4 +32,5 @@ internal sealed record PropertyInfo(
     bool NotifyDataErrorInfo,
     bool IsOldPropertyValueDirectlyReferenced,
     bool IsReferenceType,
+    bool IncludeMemberNotNullOnSetAccessor,
     EquatableArray<AttributeInfo> ForwardedAttributes);

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

@@ -113,6 +113,7 @@ public static bool TryGetInfo(
             bool hasAnyValidationAttributes = false;
             bool isOldPropertyValueDirectlyReferenced = IsOldPropertyValueDirectlyReferenced(fieldSymbol, propertyName);
             bool isReferenceType = fieldSymbol.Type.IsReferenceType;
+            bool includeMemberNotNullOnSetAccessor = GetIncludeMemberNotNullOnSetAccessor(fieldSymbol, semanticModel);
 
             // Track the property changing event for the property, if the type supports it
             if (shouldInvokeOnPropertyChanging)
@@ -262,6 +263,7 @@ public static bool TryGetInfo(
                 notifyDataErrorInfo,
                 isOldPropertyValueDirectlyReferenced,
                 isReferenceType,
+                includeMemberNotNullOnSetAccessor,
                 forwardedAttributes.ToImmutable());
 
             diagnostics = builder.ToImmutable();
@@ -668,6 +670,36 @@ private static bool IsOldPropertyValueDirectlyReferenced(IFieldSymbol fieldSymbo
             return false;
         }
 
+        /// <summary>
+        /// Checks whether <see cref="MemberNotNullAttribute"/> should be used on the setter.
+        /// </summary>
+        /// <param name="fieldSymbol">The input <see cref="IFieldSymbol"/> instance to process.</param>
+        /// <param name="semanticModel">The <see cref="SemanticModel"/> instance for the current run.</param>
+        /// <returns>Whether <see cref="MemberNotNullAttribute"/> should be used on the setter.</returns>
+        private static bool GetIncludeMemberNotNullOnSetAccessor(IFieldSymbol fieldSymbol, SemanticModel semanticModel)
+        {
+            // This is used to avoid nullability warnings when setting the property from a constructor, in case the field
+            // was marked as not nullable. Nullability annotations are assumed to always be enabled to make the logic simpler.
+            // Consider this example:
+            //
+            // partial class MyViewModel : ObservableObject
+            // {
+            //    public MyViewModel()
+            //    {
+            //        Name = "Bob";
+            //    }
+            //
+            //    [ObservableProperty]
+            //    private string name;
+            // }
+            //
+            // The [MemberNotNull] attribute is needed on the setter for the generated Name property so that when Name
+            // is set, the compiler can determine that the name backing field is also being set (to a non null value).
+            return
+                fieldSymbol.Type is { NullableAnnotation: not NullableAnnotation.Annotated, IsReferenceType: true } &&
+                semanticModel.Compilation.HasAccessibleTypeWithMetadataName("System.Diagnostics.CodeAnalysis.MemberNotNullAttribute");
+        }
+
         /// <summary>
         /// Gets a <see cref="CompilationUnitSyntax"/> instance with the cached args for property changing notifications.
         /// </summary>
@@ -880,6 +912,27 @@ public static MemberDeclarationSyntax GetPropertySyntax(PropertyInfo propertyInf
                 .Select(static a => AttributeList(SingletonSeparatedList(a.GetSyntax())))
                 .ToImmutableArray();
 
+            // Prepare the setter for the generated property:
+            //
+            // set
+            // {
+            //     <BODY>
+            // }
+            AccessorDeclarationSyntax setAccessor = AccessorDeclaration(SyntaxKind.SetAccessorDeclaration).WithBody(Block(setterIfStatement));
+
+            // Add the [MemberNotNull] attribute if needed:
+            //
+            // [MemberNotNull("<FIELD_NAME>")]
+            // <SET_ACCESSOR>
+            if (propertyInfo.IncludeMemberNotNullOnSetAccessor)
+            {
+                setAccessor = setAccessor.AddAttributeLists(
+                    AttributeList(SingletonSeparatedList(
+                        Attribute(IdentifierName("global::System.Diagnostics.CodeAnalysis.MemberNotNull"))
+                        .AddArgumentListArguments(
+                            AttributeArgument(LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(propertyInfo.FieldName)))))));
+            }
+
             // Construct the generated property as follows:
             //
             // /// <inheritdoc cref="<FIELD_NAME>"/>
@@ -889,10 +942,7 @@ public static MemberDeclarationSyntax GetPropertySyntax(PropertyInfo propertyInf
             // public <FIELD_TYPE><NULLABLE_ANNOTATION?> <PROPERTY_NAME>
             // {
             //     get => <FIELD_NAME>;
-            //     set
-            //     {
-            //         <BODY>
-            //     }
+            //     <SET_ACCESSOR>
             // }
             return
                 PropertyDeclaration(propertyType, Identifier(propertyInfo.PropertyName))
@@ -910,8 +960,7 @@ public static MemberDeclarationSyntax GetPropertySyntax(PropertyInfo propertyInf
                     AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)
                     .WithExpressionBody(ArrowExpressionClause(IdentifierName(propertyInfo.FieldName)))
                     .WithSemicolonToken(Token(SyntaxKind.SemicolonToken)),
-                    AccessorDeclaration(SyntaxKind.SetAccessorDeclaration)
-                    .WithBody(Block(setterIfStatement)));
+                    setAccessor);
         }
 
         /// <summary>