Fix a bug with It.Is<T>() and It.IsAny<T>() parameters check with the PosInfo1006 rule when using inherited types (fixes #47).

Author: GillesTourreau

src/Moq.Analyzers/AnalyzerReleases.Unshipped.md

@@ -1,4 +1 @@
-### New Rules
-Rule ID | Category | Severity | Notes
---------|----------|----------|-------
-PosInfoMoq1008 | Design | Warning | VerifyStaticMethodsRequiresMockParametersAnalyzer, [Documentation](https://posinformatique.github.io/PosInformatique.Moq.Analyzers/docs/Compilation/PosInfoMoq1008.html)
+

src/Moq.Analyzers/Analyzers/ItArgumentsMustMatchMockedMethodArgumentsAnalyzer.cs

@@ -64,22 +64,24 @@ private static void Analyze(SyntaxNodeAnalysisContext context)
                 var itIsAnyType = moqSymbols.GetItIsAnyType(invocationArgument.Symbol);
                 if (itIsAnyType is not null)
                 {
-                    if (!SymbolEqualityComparer.Default.Equals(itIsAnyType, invocationArgument.ParameterSymbol.Type))
+                    if (!itIsAnyType.IsOrInheritFrom(invocationArgument.ParameterSymbol.Type))
                     {
                         context.ReportDiagnostic(Rule, invocationArgument.Syntax.GetLocation());
-                        continue;
                     }
+
+                    continue;
                 }
 
                 // Check if the parameter is "It.Is<xxx>()"
                 var itIsType = moqSymbols.GetItIsType(invocationArgument.Symbol);
                 if (itIsType is not null)
                 {
-                    if (!SymbolEqualityComparer.Default.Equals(itIsType, invocationArgument.ParameterSymbol.Type))
+                    if (!itIsType.IsOrInheritFrom(invocationArgument.ParameterSymbol.Type))
                     {
                         context.ReportDiagnostic(Rule, invocationArgument.Syntax.GetLocation());
-                        continue;
                     }
+
+                    continue;
                 }
             }
         }

src/Moq.Analyzers/MoqSymbols.cs

@@ -131,7 +131,7 @@ public bool IsAnyType(ITypeSymbol symbol)
             return true;
         }
 
-        public ISymbol? GetItIsType(ISymbol? symbol)
+        public ITypeSymbol? GetItIsType(ISymbol? symbol)
         {
             if (symbol is not IMethodSymbol methodSymbol)
             {
@@ -164,7 +164,7 @@ public bool IsItIsAny(ISymbol? symbol)
             return true;
         }
 
-        public ISymbol? GetItIsAnyType(ISymbol? symbol)
+        public ITypeSymbol? GetItIsAnyType(ISymbol? symbol)
         {
             if (symbol is not IMethodSymbol methodSymbol)
             {

tests/Moq.Analyzers.Tests/Analyzers/ItArgumentsMustMatchMockedMethodArgumentsAnalyzerTest.cs

@@ -26,10 +26,17 @@ public class TestClass
                         public void TestMethod()
                         {
                             var mock1 = new Mock<I>();
+
                             mock1.Setup(m => m.NoParametersMethod());
                             mock1.Setup(m => m.TestMethod(It.IsAny<int?>(), 1, ""Ignored"", C.OtherMethod()));
                             mock1.Setup(m => m.TestMethod(It.Is<int?>(p => p == 10), 1, ""Ignored"", C.OtherMethod()));
                             mock1.Setup(m => m.TestMethod(It.Is<int?>(10, EqualityComparer<int?>.Default), 1, ""Ignored"", C.OtherMethod()));
+
+                            mock1.Setup(m => m.TestMethodWithBaseClass(null));
+                            mock1.Setup(m => m.TestMethodWithBaseClass(It.IsAny<BaseClass>()));
+                            mock1.Setup(m => m.TestMethodWithBaseClass(It.IsAny<InheritedClass>()));
+                            mock1.Setup(m => m.TestMethodWithBaseClass(It.Is<BaseClass>(c => c.Property == 10)));
+                            mock1.Setup(m => m.TestMethodWithBaseClass(It.Is<InheritedClass>(c => c.Property == 10)));
                        }
                     }
 
@@ -38,12 +45,23 @@ public interface I
                         void NoParametersMethod();
 
                         void TestMethod(int? a, int b, string c, int d);
+
+                        void TestMethodWithBaseClass(BaseClass a);
                     }
 
                     public class C
                     {
                         public static int OtherMethod() => default;
                     }
+
+                    public abstract class BaseClass
+                    {
+                        public int Property { get; set; }
+                    }
+
+                    public class InheritedClass : BaseClass
+                    {
+                    }
                 }";
 
             await Verifier.VerifyAnalyzerAsync(source);