Feature: allow interception of any generic method call when using Arg.AnyType

src/NSubstitute/Core/CallInfo.cs

@@ -1,12 +1,13 @@
 using System.Diagnostics.CodeAnalysis;
+using System.Reflection;
 using NSubstitute.Exceptions;
 
 // Disable nullability for entry-point API
 #nullable disable annotations
 
 namespace NSubstitute.Core;
 
-public class CallInfo(Argument[] callArguments)
+public class CallInfo(Argument[] callArguments, MethodInfo methodInfo)
 {
 
     /// <summary>
@@ -25,6 +26,8 @@ public object this[int index]
         }
     }
 
+    public MethodInfo MethodInfo => methodInfo;
+
     private void EnsureArgIsSettable(Argument argument, int index, object value)
     {
         if (!argument.IsByRef)

src/NSubstitute/Core/CallInfoFactory.cs

@@ -5,7 +5,7 @@ public class CallInfoFactory : ICallInfoFactory
     public CallInfo Create(ICall call)
     {
         var arguments = GetArgumentsFromCall(call);
-        return new CallInfo(arguments);
+        return new CallInfo(arguments, call.GetMethodInfo());
     }
 
     private static Argument[] GetArgumentsFromCall(ICall call)

tests/NSubstitute.Acceptance.Specs/GenericArguments.cs

@@ -1,5 +1,6 @@
 using System.Collections;
 using System.Globalization;
+using System.Reflection;
 using NUnit.Framework;
 
 namespace NSubstitute.Acceptance.Specs;
@@ -11,6 +12,7 @@ public interface ISomethingWithGenerics
     {
         void SomeAction<TState>(int level, TState state);
         string SomeFunction<TState>(int level, TState state);
+        ICollection<TState> SomeFunction<TState>(int level);
         void SomeActionWithGenericConstraints<TState>(int level, TState state) where TState : IEnumerable<int>;
         string SomeFunctionWithGenericConstraints<TState>(int level, TState state) where TState : IEnumerable<int>;
     }
@@ -131,4 +133,35 @@ public void Is_matcher_works_with_AnyType_and_constraints()
 
         Assert.That(result, Is.EqualTo("matched"));
     }
+
+    [Test]
+    public void Callback_allows_access_to_method_call()
+    {
+        static ICollection<T> CreateSubstitute<T>(int count)
+        {
+            ICollection<T> substitute = Substitute.For<ICollection<T>>();
+            substitute.Count.Returns(count);
+            return substitute;
+        }
+
+        MethodInfo methodInfo = typeof(GenericArguments)
+            .GetMethods(BindingFlags.Static | BindingFlags.NonPublic)
+            .Single(x
+                => x.Name.Contains(nameof(CreateSubstitute))
+                && x.Name.Contains(nameof(Callback_allows_access_to_method_call)));
+
+        ISomethingWithGenerics something = Substitute.For<ISomethingWithGenerics>();
+        something
+            .SomeFunction<Arg.AnyType>(Arg.Any<int>())
+            .Returns(x =>
+            {
+                Type argumentType = x.MethodInfo.GetGenericArguments()[0];
+                MethodInfo method = methodInfo.MakeGenericMethod(argumentType);
+                return method.Invoke(null, [x.Arg<int>()]);
+            });
+
+        ICollection<int> result = something.SomeFunction<int>(7);
+
+        Assert.That(result.Count, Is.EqualTo(7));
+    }
 }