Fix false positives where the same syntax has a different meaning

Author: jnm2

PropertyChangedAnalyzers.Test/INPC002MutablePublicPropertyShouldNotify/Valid.cs

@@ -1069,5 +1069,71 @@ protected bool Set<T>(ref T location, T value, [CallerMemberName] string propert
 
             RoslynAssert.Valid(Analyzer, code);
         }
+
+        [Test]
+        public static void SameExpressionWithDifferentMeaning()
+        {
+            var code = @"
+namespace ValidCode
+{
+    using System;
+    using System.ComponentModel;
+    using System.Runtime.CompilerServices;
+
+    record DifferentClass
+    {
+        public int p;
+    }
+
+    public class SomeViewModel : INotifyPropertyChanged
+    {
+        private int p;
+        public int P
+        {
+            get => p;
+            set
+            {
+                if (!Set(ref p, value)) return;
+
+                _ = new DifferentClass { p = value };
+                _ = new DifferentClass() with { p = value };
+
+                {
+                    int p;
+                    p = value;
+                }
+
+                _ = new Action<int>(p =>
+                {
+                    p = value;
+                });
+
+                LocalFunction(42);
+                void LocalFunction(int p)
+                {
+                    p = value;
+                }
+            }
+        }
+
+        public event PropertyChangedEventHandler? PropertyChanged;
+
+        protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
+        {
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+        }
+
+        protected bool Set<T>(ref T location, T value, [CallerMemberName] string propertyName = null)
+        {
+            if (RuntimeHelpers.Equals(location, value)) return false;
+            location = value;
+            OnPropertyChanged(propertyName);
+            return true;
+        }
+    }
+}";
+
+            RoslynAssert.Valid(Analyzer, code);
+        }
     }
 }

PropertyChangedAnalyzers/CodeFixes/MakePropertyNotifyFix.cs

@@ -69,7 +69,7 @@ async Task TrySet(DocumentEditor editor, CancellationToken cancellationToken)
                                 _ = editor.FormatNode(propertyDeclaration!);
                             }
                         }
-                        else if (FindSimpleAssignment(propertyDeclaration) is { } assignment)
+                        else if (FindSimpleAssignment(propertyDeclaration, semanticModel, context.CancellationToken) is { } assignment)
                         {
                             context.RegisterCodeFix(
                                 trySetMethod.DisplaySignature(),
@@ -127,7 +127,7 @@ async Task NotifyWhenValueChangesAsync(DocumentEditor editor, CancellationToken
                                 _ = editor.FormatNode(propertyDeclaration!);
                             }
                         }
-                        else if (FindSimpleAssignment(propertyDeclaration) is { } assignment)
+                        else if (FindSimpleAssignment(propertyDeclaration, semanticModel, context.CancellationToken) is { } assignment)
                         {
                             context.RegisterCodeFix(
                                 NotifyWhenValueChanges,
@@ -198,11 +198,14 @@ async Task NotifyAsync(DocumentEditor editor, CancellationToken cancellationToke
             }
         }
 
-        private static AssignmentExpressionSyntax? FindSimpleAssignment(PropertyDeclarationSyntax property)
+        private static AssignmentExpressionSyntax? FindSimpleAssignment(
+            PropertyDeclarationSyntax property,
+            SemanticModel semanticModel,
+            CancellationToken cancellationToken)
         {
             return property.TryGetSetter(out var setter) &&
                    IsSimple(setter)
-                   ? Setter.AssignsValueToBackingField(setter)
+                   ? Setter.AssignsValueToBackingField(setter, semanticModel, cancellationToken)
                    : null;
 
             static bool IsSimple(AccessorDeclarationSyntax localSetter)

PropertyChangedAnalyzers/Helpers/Property.cs

@@ -108,7 +108,7 @@ property.ContainingType is null ||
 
             if (declaration.TryGetSetter(out var setter))
             {
-                if (Setter.AssignsValueToBackingField(setter) is { } assignment)
+                if (Setter.AssignsValueToBackingField(setter, semanticModel, cancellationToken) is { } assignment)
                 {
                     return PropertyChanged.InvokesPropertyChangedFor(assignment, property, semanticModel, cancellationToken) == AnalysisResult.No;
                 }

PropertyChangedAnalyzers/Helpers/Setter.cs

@@ -108,7 +108,10 @@ IdentifierNameSyntax identifierName
             };
         }
 
-        internal static AssignmentExpressionSyntax? AssignsValueToBackingField(AccessorDeclarationSyntax setter)
+        internal static AssignmentExpressionSyntax? AssignsValueToBackingField(
+            AccessorDeclarationSyntax setter,
+            SemanticModel semanticModel,
+            CancellationToken cancellationToken)
         {
             if (setter.FirstAncestor<PropertyDeclarationSyntax>() is not { } property || !property.TrySingleReturned(out var backingExpression))
             {
@@ -120,7 +123,10 @@ IdentifierNameSyntax identifierName
             foreach (var assignment in walker.Assignments)
             {
                 if (assignment is { Right: IdentifierNameSyntax { Identifier: { ValueText: "value" } } } &&
-                    MemberPath.Equals(backingExpression, assignment.Left))
+                    MemberPath.Equals(backingExpression, assignment.Left) &&
+                    SymbolEqualityComparer.Default.Equals(
+                        semanticModel.GetSymbolSafe(backingExpression, cancellationToken),
+                        semanticModel.GetSymbolSafe(assignment.Left, cancellationToken)))
                 {
                     return assignment;
                 }

ValidCode/NotMutations.cs

@@ -1,5 +1,6 @@
 namespace ValidCode
 {
+    using System;
     using System.ComponentModel;
     using System.Runtime.CompilerServices;
 
@@ -40,5 +41,39 @@ public int SamePropertyNameOnUnrelatedInstance
                 Settings.Default.SamePropertyNameOnUnrelatedInstance = value;
             }
         }
+
+        record DifferentClass
+        {
+            public int sameExpressionWithDifferentMeaning;
+        }
+
+        private int sameExpressionWithDifferentMeaning;
+        public int SameExpressionWithDifferentMeaning
+        {
+            get => sameExpressionWithDifferentMeaning;
+            set
+            {
+                if (!Set(ref sameExpressionWithDifferentMeaning, value)) return;
+
+                _ = new DifferentClass { sameExpressionWithDifferentMeaning = value };
+                _ = new DifferentClass() with { sameExpressionWithDifferentMeaning = value };
+
+                {
+                    int sameExpressionWithDifferentMeaning;
+                    sameExpressionWithDifferentMeaning = value;
+                }
+
+                _ = new Action<int>(sameExpressionWithDifferentMeaning =>
+                {
+                    sameExpressionWithDifferentMeaning = value;
+                });
+
+                LocalFunction(42);
+                void LocalFunction(int sameExpressionWithDifferentMeaning)
+                {
+                    sameExpressionWithDifferentMeaning = value;
+                }
+            }
+        }
     }
 }