Fix false recursion detection

Author: jnm2

PropertyChangedAnalyzers.Test/INPC015PropertyIsRecursive/Valid.cs

@@ -225,5 +225,72 @@ protected bool TrySet<T>(ref T field, T value, [CallerMemberName] string propert
 
             RoslynAssert.Valid(Analyzer, withProperties, code);
         }
+
+        [Test]
+        public static void SameExpressionWithDifferentMeanings()
+        {
+            var code = @"
+namespace ValidCode.Recursion
+{
+    using System;
+    using System.ComponentModel;
+    using System.Runtime.CompilerServices;
+
+    public class NotRecursion : INotifyPropertyChanged
+    {
+        public event PropertyChangedEventHandler? PropertyChanged;
+
+        protected virtual void OnPropertyChanged([CallerMemberName] string? propertyName = null)
+        {
+            this.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;
+        }
+
+        record DifferentClass
+        {
+            public int P;
+        }
+
+        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;
+                }
+            }
+        }
+    }
+}
+";
+
+            RoslynAssert.Valid(Analyzer, code);
+        }
     }
 }

PropertyChangedAnalyzers/Analyzers/PropertyDeclarationAnalyzer.cs

@@ -82,7 +82,14 @@ context.Node is PropertyDeclarationSyntax propertyDeclaration &&
                     }
 
                     using var assignmentWalker = AssignmentWalker.Borrow(setter);
-                    if (assignmentWalker.Assignments.TryFirst(x => IsProperty(x.Left) && !x.Parent.IsKind(SyntaxKind.ObjectInitializerExpression), out var recursiveAssignment))
+                    if (assignmentWalker.Assignments.TryFirst(
+                        x =>
+                            IsProperty(x.Left) &&
+                            !x.Parent.IsKind(SyntaxKind.ObjectInitializerExpression)
+                            && SymbolEqualityComparer.Default.Equals(
+                                context.SemanticModel.GetDeclaredSymbolSafe(propertyDeclaration, context.CancellationToken),
+                                context.SemanticModel.GetSymbolSafe(x.Left, context.CancellationToken)),
+                        out var recursiveAssignment))
                     {
                         context.ReportDiagnostic(Diagnostic.Create(Descriptors.INPC015PropertyIsRecursive, recursiveAssignment.Left.GetLocation(), "Setter assigns property, infinite recursion"));
                     }

ValidCode/Recursion/NotRecursion.cs

@@ -0,0 +1,58 @@
+namespace ValidCode.Recursion
+{
+    using System;
+    using System.ComponentModel;
+    using System.Runtime.CompilerServices;
+
+    public class NotRecursion : INotifyPropertyChanged
+    {
+        public event PropertyChangedEventHandler? PropertyChanged;
+
+        protected virtual void OnPropertyChanged([CallerMemberName] string? propertyName = null)
+        {
+            this.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;
+        }
+
+        record DifferentClass
+        {
+            public int P;
+        }
+
+        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;
+                }
+            }
+        }
+    }
+}