Flag Assert.AreEqual(x, x) / AreSame(x, x) / AreNotEqual(x, x) / AreNotSame(x, x) (#9087)

src/Analyzers/MSTest.Analyzers/PreferAssertFailOverAlwaysFalseConditionsAnalyzer.cs

@@ -92,12 +92,22 @@ private static bool IsAlwaysFalse(IInvocationOperation operation)
             "IsTrue" => GetConditionArgument(operation) is { ConstantValue: { HasValue: true, Value: false } },
             "IsFalse" => GetConditionArgument(operation) is { ConstantValue: { HasValue: true, Value: true } },
             "AreEqual" => GetEqualityStatus(operation, ExpectedParameterName) == EqualityStatus.NotEqual,
-            "AreNotEqual" => GetEqualityStatus(operation, NotExpectedParameterName) == EqualityStatus.Equal,
+            "AreNotEqual" => GetEqualityStatus(operation, NotExpectedParameterName) == EqualityStatus.Equal
+                || HasIdenticalExpectedAndActual(operation, NotExpectedParameterName),
+            "AreNotSame" => HasIdenticalExpectedAndActual(operation, NotExpectedParameterName),
             "IsNotNull" => GetValueArgument(operation) is { ConstantValue: { HasValue: true, Value: null } },
             "IsNull" => GetValueArgument(operation) is { } valueArgumentOperation && IsNotNullableType(valueArgumentOperation),
             _ => false,
         };
 
+    private static bool HasIdenticalExpectedAndActual(IInvocationOperation operation, string expectedOrNotExpectedParameterName)
+        => GetRawArgumentValueWithName(operation, expectedOrNotExpectedParameterName) is { } expectedArgument
+        && GetRawArgumentValueWithName(operation, ActualParameterName) is { } actualArgument
+        && expectedArgument.IsEquivalentReferenceTo(actualArgument);
+
+    private static IOperation? GetRawArgumentValueWithName(IInvocationOperation operation, string name)
+        => operation.Arguments.FirstOrDefault(arg => arg.Parameter?.Name == name)?.Value;
+
     private static bool IsNotNullableType(IOperation valueArgumentOperation)
     {
         ITypeSymbol? valueArgType = valueArgumentOperation.GetReferencedMemberOrLocalOrParameter().GetReferencedMemberOrLocalOrParameter();

src/Analyzers/MSTest.Analyzers/ReviewAlwaysTrueAssertConditionAnalyzer.cs

@@ -81,13 +81,23 @@ private static bool IsAlwaysTrue(IInvocationOperation operation)
         {
             "IsTrue" => GetConditionArgument(operation) is { ConstantValue: { HasValue: true, Value: true } },
             "IsFalse" => GetConditionArgument(operation) is { ConstantValue: { HasValue: true, Value: false } },
-            "AreEqual" => GetEqualityStatus(operation, ExpectedParameterName) == EqualityStatus.Equal,
+            "AreEqual" => GetEqualityStatus(operation, ExpectedParameterName) == EqualityStatus.Equal
+                || HasIdenticalExpectedAndActual(operation, ExpectedParameterName),
             "AreNotEqual" => GetEqualityStatus(operation, NotExpectedParameterName) == EqualityStatus.NotEqual,
+            "AreSame" => HasIdenticalExpectedAndActual(operation, ExpectedParameterName),
             "IsNull" => GetValueArgument(operation) is { ConstantValue: { HasValue: true, Value: null } },
             "IsNotNull" => GetValueArgument(operation) is { } valueArgumentOperation && IsNotNullableType(valueArgumentOperation),
             _ => false,
         };
 
+    private static bool HasIdenticalExpectedAndActual(IInvocationOperation operation, string expectedOrNotExpectedParameterName)
+        => GetRawArgumentValueWithName(operation, expectedOrNotExpectedParameterName) is { } expectedArgument
+        && GetRawArgumentValueWithName(operation, ActualParameterName) is { } actualArgument
+        && expectedArgument.IsEquivalentReferenceTo(actualArgument);
+
+    private static IOperation? GetRawArgumentValueWithName(IInvocationOperation operation, string name)
+        => operation.Arguments.FirstOrDefault(arg => arg.Parameter?.Name == name)?.Value;
+
     private static bool IsNotNullableType(IOperation valueArgumentOperation)
     {
         ITypeSymbol? valueArgType = valueArgumentOperation.GetReferencedMemberOrLocalOrParameter().GetReferencedMemberOrLocalOrParameter();

src/Analyzers/MSTest.Analyzers/RoslynAnalyzerHelpers/IOperationExtensions.cs

@@ -56,4 +56,69 @@ public static IOperation WalkDownBuiltInConversion(this IOperation operation)
 
         return operation;
     }
+
+    /// <summary>
+    /// Returns <see langword="true"/> when the two operations are structurally equivalent
+    /// side-effect-free references to the same local, parameter, field, property, or <c>this</c>.
+    /// </summary>
+    /// <remarks>
+    /// This intentionally excludes method invocations and indexer accesses, since those may
+    /// have side effects or return different values on repeated evaluation. Parenthesized
+    /// expressions and <em>built-in</em> conversions are skipped transparently, but
+    /// user-defined conversions are treated as opaque because their operators may execute
+    /// arbitrary code with side effects.
+    /// </remarks>
+    public static bool IsEquivalentReferenceTo(this IOperation? left, IOperation? right)
+    {
+        if (left is null || right is null)
+        {
+            return false;
+        }
+
+        left = Unwrap(left);
+        right = Unwrap(right);
+
+        return (left, right) switch
+        {
+            (ILocalReferenceOperation la, ILocalReferenceOperation lb) =>
+                SymbolEqualityComparer.Default.Equals(la.Local, lb.Local),
+
+            (IParameterReferenceOperation pa, IParameterReferenceOperation pb) =>
+                SymbolEqualityComparer.Default.Equals(pa.Parameter, pb.Parameter),
+
+            (IFieldReferenceOperation fa, IFieldReferenceOperation fb) =>
+                SymbolEqualityComparer.Default.Equals(fa.Field, fb.Field) &&
+                AreInstancesEquivalent(fa.Instance, fb.Instance),
+
+            (IPropertyReferenceOperation pra, IPropertyReferenceOperation prb) =>
+                !pra.Property.IsIndexer &&
+                SymbolEqualityComparer.Default.Equals(pra.Property, prb.Property) &&
+                AreInstancesEquivalent(pra.Instance, prb.Instance),
+
+            (IInstanceReferenceOperation, IInstanceReferenceOperation) => true,
+
+            _ => false,
+        };
+
+        static IOperation Unwrap(IOperation operation)
+        {
+            while (true)
+            {
+                switch (operation)
+                {
+                    case IParenthesizedOperation parenthesized:
+                        operation = parenthesized.Operand;
+                        break;
+                    case IConversionOperation conversion when !conversion.Conversion.IsUserDefined:
+                        operation = conversion.Operand;
+                        break;
+                    default:
+                        return operation;
+                }
+            }
+        }
+
+        static bool AreInstancesEquivalent(IOperation? a, IOperation? b)
+            => (a is null && b is null) || IsEquivalentReferenceTo(a, b);
+    }
 }