fix: Stop using return-type assignability for generic call matching

src/NSubstitute/Core/CallSpecification.cs

@@ -50,16 +50,16 @@ private static bool CanCompareGenericMethods(MethodInfo a, MethodInfo b)
     {
         return
                AreEquivalentDefinitions(a, b)
-            && TypesAreAllEquivalent(ParameterTypes(a), ParameterTypes(b))
-            && TypesAreAllEquivalent(a.GetGenericArguments(), b.GetGenericArguments());
+            && TypesAreAllEquivalent(ParameterTypes(a), ParameterTypes(b), allowAssignableTypes: true)
+            && TypesAreAllEquivalent(a.GetGenericArguments(), b.GetGenericArguments(), allowAssignableTypes: true);
     }
 
     private static Type[] ParameterTypes(MethodInfo info)
     {
         return info.GetParameters().Select(p => p.ParameterType).ToArray();
     }
 
-    internal static bool TypesAreAllEquivalent(Type[] aArgs, Type[] bArgs)
+    internal static bool TypesAreAllEquivalent(Type[] aArgs, Type[] bArgs, bool allowAssignableTypes)
     {
         if (aArgs.Length != bArgs.Length) return false;
         for (var i = 0; i < aArgs.Length; i++)
@@ -80,20 +80,21 @@ internal static bool TypesAreAllEquivalent(Type[] aArgs, Type[] bArgs)
                 && first.GetGenericTypeDefinition() == second.GetGenericTypeDefinition())
             {
                 // both are the same generic type. If their GenericTypeArguments match then they are equivalent
-                if (!TypesAreAllEquivalent(first.GenericTypeArguments, second.GenericTypeArguments))
+                if (!TypesAreAllEquivalent(first.GenericTypeArguments, second.GenericTypeArguments, allowAssignableTypes))
                 {
                     return false;
                 }
                 continue;
             }
 
-            var areAssignable = first.IsAssignableFrom(second) || second.IsAssignableFrom(first);
+            var areIdentical = first == second;
+            var areAssignable = allowAssignableTypes && (first.IsAssignableFrom(second) || second.IsAssignableFrom(first));
             var areAnyTypeAssignable = typeof(Arg.AnyType).IsAssignableFrom(first) ||
                                        typeof(Arg.AnyType).IsAssignableFrom(second);
             var areByRefAnyTypeAssignable = first.IsByRef && second.IsByRef &&
                                             (typeof(Arg.AnyType).IsAssignableFrom(first.GetElementType()) ||
                                              typeof(Arg.AnyType).IsAssignableFrom(second.GetElementType()));
-            var areEquivalent = areAssignable || areAnyTypeAssignable || areByRefAnyTypeAssignable;
+            var areEquivalent = areIdentical || areAssignable || areAnyTypeAssignable || areByRefAnyTypeAssignable;
             if (!areEquivalent) return false;
         }
         return true;
@@ -102,7 +103,7 @@ internal static bool TypesAreAllEquivalent(Type[] aArgs, Type[] bArgs)
     private static bool AreEquivalentDefinitions(MethodInfo a, MethodInfo b)
     {
         return a.IsGenericMethod == b.IsGenericMethod
-               && TypesAreAllEquivalent([a.ReturnType], [b.ReturnType])
+               && TypesAreAllEquivalent([a.ReturnType], [b.ReturnType], allowAssignableTypes: false)
                && a.Name.Equals(b.Name, StringComparison.Ordinal);
     }
 

src/NSubstitute/Core/Extensions.cs

@@ -36,7 +36,7 @@ public static bool IsCompatibleWith(this object? instance, Type type)
                     aCompatibleInstanceType.GetGenericTypeDefinition() == genericTypeDefinition)
                 {
                     // both are the same generic type. If their GenericTypeArguments match then they are equivalent
-                    var typesAreAllEquivalent = CallSpecification.TypesAreAllEquivalent(aCompatibleInstanceType.GenericTypeArguments, type.GenericTypeArguments);
+                    var typesAreAllEquivalent = CallSpecification.TypesAreAllEquivalent(aCompatibleInstanceType.GenericTypeArguments, type.GenericTypeArguments, allowAssignableTypes: true);
                     if (typesAreAllEquivalent)
                         return true;
                 }

tests/NSubstitute.Acceptance.Specs/FieldReports/Issue974_ReturnsForGenericMethodWithRelatedReturnTypes.cs

@@ -0,0 +1,37 @@
+using NUnit.Framework;
+
+namespace NSubstitute.Acceptance.Specs.FieldReports;
+
+public class Issue974_ReturnsForGenericMethodWithRelatedReturnTypes
+{
+    // Based on: https://github.com/nsubstitute/NSubstitute/issues/974
+
+    public interface IResult { }
+    public interface IResult<T> : IResult { }
+
+    public interface IRequest<TResponse> { }
+    public class NonGenericRequest : IRequest<IResult> { }
+    public class GenericRequest : IRequest<IResult<int>> { }
+
+    public interface ISender
+    {
+        TResponse Send<TResponse>(IRequest<TResponse> request);
+    }
+
+    [Test]
+    public void ShouldNotThrowWhenConfiguringReturnsForClosedGenericMethodsWithRelatedReturnTypes()
+    {
+        // Arrange
+        var sender = Substitute.For<ISender>();
+        var firstResult = Substitute.For<IResult>();
+        var secondResult = Substitute.For<IResult<int>>();
+
+        // Act
+        sender.Send(Arg.Any<NonGenericRequest>()).Returns(firstResult);
+        sender.Send(Arg.Any<GenericRequest>()).Returns(secondResult);
+
+        // Assert
+        Assert.That(sender.Send(new NonGenericRequest()), Is.SameAs(firstResult));
+        Assert.That(sender.Send(new GenericRequest()), Is.SameAs(secondResult));
+    }
+}