fix(mocks): thread type args through ordered verification + immutable type-arg arrays

Round 7 review fixes:

- OrderedVerification now records and matches a generic expectation's type
  arguments, so VerifyInOrder discriminates Greet<Class1>() from
  Greet<Class2>() like unordered verification does. Failure messages include
  the type arguments. Regression tests added.

- Type-argument arrays are now ImmutableArray<Type> end-to-end
  (TypeArguments.Of<T>.Value, MethodSetup, CallRecord, engine dispatch,
  verification), closing the mutable-shared-array corruption risk while
  keeping array-speed indexed access on the hot matching path. The arity-5+
  generator fallback emits ImmutableArray.Create. All affected signatures
  were introduced on this branch, so no released surface changes.

- CreateVerification routing deduped into MockCallVerification.Create,
  shared by MockMethodCall and VoidMockMethodCall.

- Documented why the typed FindMatchingSetup<T1..T8> family omits a
  TypeArgumentsMatch check: typed dispatch never carries call-side type
  arguments, so the check would be a constant true (non-generic setups have
  none; virtual/partial generic methods use the documented degradation path).

Author: thomhurst

TUnit.Mocks.SourceGenerator/Builders/MockImplBuilder.cs

@@ -744,7 +744,7 @@ private static void GenerateEngineDispatchBody(CodeWriter writer, MockMemberMode
         }
 
         var (isTyped, typeArgs, argsList) = GetTypedDispatchInfo(method);
-        // Generic methods always dispatch through the object?[] + Type[] fallback so their concrete
+        // Generic methods always dispatch through the object?[] + type-arguments fallback so their concrete
         // type arguments reach the engine (typed dispatch can't carry them). Force the fallback path
         // here so argsArray is materialized; the emit helpers then select the type-arg overloads.
         if (method.IsGenericMethod)
@@ -1415,9 +1415,9 @@ private static string EmitHandleCallWithReturn(bool isTyped, string? typeArgs, s
     }
 
     /// <summary>
-    /// Emits the type-argument array for a generic method. For the common 1–2 type-parameter cases it
+    /// Emits the type-argument array for a generic method. For the common 1–4 type-parameter cases it
     /// references the per-closed-type cache (<c>TypeArguments.Of&lt;T&gt;.Value</c>) to avoid a per-call
-    /// allocation; higher arities fall back to a fresh <c>new global::System.Type[] { typeof(T), ... }</c>.
+    /// allocation; higher arities fall back to a per-call <c>ImmutableArray.Create(...)</c>.
     /// </summary>
     internal static string TypeArgumentsArrayLiteral(MockMemberModel method)
     {
@@ -1426,7 +1426,7 @@ internal static string TypeArgumentsArrayLiteral(MockMemberModel method)
         {
             return $"global::TUnit.Mocks.TypeArguments.Of<{string.Join(", ", typeParams.Select(tp => tp.Name))}>.Value";
         }
-        return $"new global::System.Type[] {{ {string.Join(", ", typeParams.Select(tp => $"typeof({tp.Name})"))} }}";
+        return $"global::System.Collections.Immutable.ImmutableArray.Create<global::System.Type>({string.Join(", ", typeParams.Select(tp => $"typeof({tp.Name})"))})";
     }
 
     /// <summary>Emits a TryHandleCall condition, choosing typed or fallback path.</summary>

TUnit.Mocks.SourceGenerator/Builders/MockMembersBuilder.cs

@@ -971,7 +971,8 @@ private static void EmitReturnConstruction(CodeWriter writer, MockMemberModel me
     {
         // For a generic method, pass the configured type arguments so the setup/verification can
         // discriminate calls by type argument. Non-generic methods omit the argument (overload with
-        // the trailing Type[] is not selected). The typed wrapper is never generated for generic methods.
+        // the trailing type-arguments parameter is not selected). The typed wrapper is never generated
+        // for generic methods.
         var typeArgs = method.IsGenericMethod
             ? $", {MockImplBuilder.TypeArgumentsArrayLiteral(method)}"
             : "";

TUnit.Mocks.Tests/GenericTests.cs

@@ -335,4 +335,46 @@ public async Task Generic_Method_Struct_Constraint_Distinguished_By_Type_Argumen
         await Assert.That(sut.Describe<int>()).IsEqualTo("int");
         await Assert.That(sut.Describe<long>()).IsEqualTo("long");
     }
+
+    [Test]
+    public void Ordered_Verification_Discriminates_By_Type_Argument()
+    {
+        var mock = IGenericGreeter.Mock();
+        IGenericGreeter greeter = mock.Object;
+
+        greeter.Greet<Class1>();
+        greeter.Greet<Class2>();
+
+        // Passes only if each expectation matches the call with its own type argument.
+        Mock.VerifyInOrder(() =>
+        {
+            mock.Greet<Class1>().WasCalled();
+            mock.Greet<Class2>().WasCalled();
+        });
+    }
+
+    [Test]
+    public async Task Ordered_Verification_Fails_When_Type_Arguments_Out_Of_Order()
+    {
+        var mock = IGenericGreeter.Mock();
+        IGenericGreeter greeter = mock.Object;
+
+        greeter.Greet<Class1>();
+        greeter.Greet<Class2>();
+
+        // Reversed type-argument order must fail. Before type arguments were threaded through
+        // ordered verification, both expectations matched both calls and this passed regardless
+        // of which type was actually called first.
+        var ex = Assert.Throws<MockVerificationException>(() =>
+            Mock.VerifyInOrder(() =>
+            {
+                mock.Greet<Class2>().WasCalled();
+                mock.Greet<Class1>().WasCalled();
+            }));
+
+        await Assert.That(ex!.Message).Contains("Ordered verification failed");
+        // The failure message names the expected calls with their type arguments.
+        await Assert.That(ex.Message).Contains("Greet<Class1>");
+        await Assert.That(ex.Message).Contains("Greet<Class2>");
+    }
 }

TUnit.Mocks/ITypeArgumentVerificationFactory.cs

@@ -1,3 +1,4 @@
+using System.Collections.Immutable;
 using TUnit.Mocks.Arguments;
 using TUnit.Mocks.Verification;
 
@@ -17,5 +18,20 @@ internal interface ITypeArgumentVerificationFactory
     /// Creates a call verification builder that filters recorded calls by the supplied type arguments
     /// (concrete types or <see cref="AnyType"/>/<see cref="AnyValueType"/> wildcards).
     /// </summary>
-    ICallVerification CreateVerification(int memberId, string memberName, IArgumentMatcher[] matchers, Type[]? typeArguments);
+    ICallVerification CreateVerification(int memberId, string memberName, IArgumentMatcher[] matchers, ImmutableArray<Type> typeArguments);
+}
+
+/// <summary>
+/// Shared verification-builder routing for <see cref="MockMethodCall{TReturn}"/> and
+/// <see cref="VoidMockMethodCall"/>: non-generic calls use the public engine surface unchanged;
+/// generic calls route through <see cref="ITypeArgumentVerificationFactory"/> (always implemented by
+/// MockEngine). A custom <see cref="IMockEngineAccess"/> implementation falls back to the public
+/// surface, losing type-argument filtering but never throwing.
+/// </summary>
+internal static class MockCallVerification
+{
+    public static ICallVerification Create(IMockEngineAccess engine, int memberId, string memberName, IArgumentMatcher[] matchers, ImmutableArray<Type> typeArguments)
+        => !typeArguments.IsDefault && engine is ITypeArgumentVerificationFactory typeArgFactory
+            ? typeArgFactory.CreateVerification(memberId, memberName, matchers, typeArguments)
+            : engine.CreateVerification(memberId, memberName, matchers);
 }

TUnit.Mocks/MockEngine.cs

@@ -4,6 +4,7 @@
 using TUnit.Mocks.Setup.Behaviors;
 using TUnit.Mocks.Verification;
 using System.Collections.Concurrent;
+using System.Collections.Immutable;
 using System.Runtime.CompilerServices;
 using System.Threading;
 using System.ComponentModel;
@@ -224,24 +225,24 @@ private void EnsureSetupArrayCapacity(int memberId)
     ICallVerification IMockEngineAccess.CreateVerification(int memberId, string memberName, IArgumentMatcher[] matchers)
         => new CallVerificationBuilder<T>(this, memberId, memberName, matchers);
 
-    ICallVerification ITypeArgumentVerificationFactory.CreateVerification(int memberId, string memberName, IArgumentMatcher[] matchers, Type[]? typeArguments)
+    ICallVerification ITypeArgumentVerificationFactory.CreateVerification(int memberId, string memberName, IArgumentMatcher[] matchers, ImmutableArray<Type> typeArguments)
         => new CallVerificationBuilder<T>(this, memberId, memberName, matchers, typeArguments);
 
     /// <summary>
     /// Handles a void method call. Records the call and executes matching setup behavior.
     /// </summary>
     public void HandleCall(int memberId, string memberName, object?[] args)
-        => HandleCallCore(memberId, memberName, args, null);
+        => HandleCallCore(memberId, memberName, args, default);
 
     /// <summary>
     /// Handles a void generic-method call. <paramref name="typeArguments"/> are the concrete closed
     /// type arguments, used to discriminate setups and recorded calls by type argument.
     /// </summary>
     [EditorBrowsable(EditorBrowsableState.Never)]
-    public void HandleCall(int memberId, string memberName, object?[] args, Type[] typeArguments)
+    public void HandleCall(int memberId, string memberName, object?[] args, ImmutableArray<Type> typeArguments)
         => HandleCallCore(memberId, memberName, args, typeArguments);
 
-    private void HandleCallCore(int memberId, string memberName, object?[] args, Type[]? typeArguments)
+    private void HandleCallCore(int memberId, string memberName, object?[] args, ImmutableArray<Type> typeArguments)
     {
         RawReturnContext.Clear();
         var callRecord = RecordCall(memberId, memberName, args, typeArguments);
@@ -296,29 +297,29 @@ private void HandleCallCore(int memberId, string memberName, object?[] args, Typ
     /// or returns default/throws for strict mode.
     /// </summary>
     public TReturn HandleCallWithReturn<TReturn>(int memberId, string memberName, object?[] args, TReturn defaultValue)
-        => HandleCallWithReturnCore(memberId, memberName, args, defaultValue, null, null);
+        => HandleCallWithReturnCore(memberId, memberName, args, defaultValue, null, default);
 
     [EditorBrowsable(EditorBrowsableState.Never)]
     public TReturn HandleCallWithReturn<TReturn>(int memberId, string memberName, object?[] args, TReturn defaultValue, Func<MockBehavior, IMock>? autoMockFactory)
-        => HandleCallWithReturnCore(memberId, memberName, args, defaultValue, autoMockFactory, null);
+        => HandleCallWithReturnCore(memberId, memberName, args, defaultValue, autoMockFactory, default);
 
     /// <summary>
     /// Handles a generic-method call with a return value. <paramref name="typeArguments"/> are the
     /// concrete closed type arguments, used to discriminate setups and recorded calls by type argument.
     /// </summary>
     [EditorBrowsable(EditorBrowsableState.Never)]
-    public TReturn HandleCallWithReturn<TReturn>(int memberId, string memberName, object?[] args, TReturn defaultValue, Type[] typeArguments)
+    public TReturn HandleCallWithReturn<TReturn>(int memberId, string memberName, object?[] args, TReturn defaultValue, ImmutableArray<Type> typeArguments)
         => HandleCallWithReturnCore(memberId, memberName, args, defaultValue, null, typeArguments);
 
     /// <summary>
     /// Generic-method call with a return value that may also auto-mock its return type. Combines the
     /// <paramref name="autoMockFactory"/> and <paramref name="typeArguments"/> paths.
     /// </summary>
     [EditorBrowsable(EditorBrowsableState.Never)]
-    public TReturn HandleCallWithReturn<TReturn>(int memberId, string memberName, object?[] args, TReturn defaultValue, Func<MockBehavior, IMock>? autoMockFactory, Type[] typeArguments)
+    public TReturn HandleCallWithReturn<TReturn>(int memberId, string memberName, object?[] args, TReturn defaultValue, Func<MockBehavior, IMock>? autoMockFactory, ImmutableArray<Type> typeArguments)
         => HandleCallWithReturnCore(memberId, memberName, args, defaultValue, autoMockFactory, typeArguments);
 
-    private TReturn HandleCallWithReturnCore<TReturn>(int memberId, string memberName, object?[] args, TReturn defaultValue, Func<MockBehavior, IMock>? autoMockFactory, Type[]? typeArguments)
+    private TReturn HandleCallWithReturnCore<TReturn>(int memberId, string memberName, object?[] args, TReturn defaultValue, Func<MockBehavior, IMock>? autoMockFactory, ImmutableArray<Type> typeArguments)
     {
         RawReturnContext.Clear();
         var callRecord = RecordCall(memberId, memberName, args, typeArguments);
@@ -785,7 +786,7 @@ private void CollectCallRecords(List<CallRecord> target, Func<CallRecord, bool>?
     private CallRecord RecordCall(int memberId, string memberName, object?[] args)
         => StoreCallRecord(new CallRecord(memberId, memberName, args, MockCallSequence.Next()));
 
-    private CallRecord RecordCall(int memberId, string memberName, object?[] args, Type[]? typeArguments)
+    private CallRecord RecordCall(int memberId, string memberName, object?[] args, ImmutableArray<Type> typeArguments)
         => StoreCallRecord(new CallRecord(memberId, memberName, args, MockCallSequence.Next(), typeArguments));
 
     private CallRecord RecordCall(int memberId, string memberName, IArgumentStore store)
@@ -916,9 +917,9 @@ private void RebuildStaleSnapshots()
     // Adding a defaulted third parameter here would let the generic overload bind instead,
     // silently treating the args array as a single typed argument.
     private (bool SetupFound, IBehavior? Behavior, MethodSetup? Setup) FindMatchingSetup(int memberId, object?[] args)
-        => FindMatchingSetup(memberId, args, (Type[]?)null);
+        => FindMatchingSetup(memberId, args, default(ImmutableArray<Type>));
 
-    private (bool SetupFound, IBehavior? Behavior, MethodSetup? Setup) FindMatchingSetup(int memberId, object?[] args, Type[]? typeArguments)
+    private (bool SetupFound, IBehavior? Behavior, MethodSetup? Setup) FindMatchingSetup(int memberId, object?[] args, ImmutableArray<Type> typeArguments)
     {
         // Rebuild snapshots if setup phase just ended (batches all ToArray work into one pass)
         if (_hasStaleSetups)
@@ -963,7 +964,7 @@ private void RebuildStaleSnapshots()
 
     // FindMatchingSetupLocked has no generic sibling, so a defaulted parameter is safe here
     // (unlike FindMatchingSetup, which competes with FindMatchingSetup<T1>).
-    private (bool SetupFound, IBehavior? Behavior, MethodSetup? Setup) FindMatchingSetupLocked(int memberId, object?[] args, Type[]? typeArguments = null)
+    private (bool SetupFound, IBehavior? Behavior, MethodSetup? Setup) FindMatchingSetupLocked(int memberId, object?[] args, ImmutableArray<Type> typeArguments = default)
     {
         lock (Lock)
         {
@@ -999,6 +1000,14 @@ private void RebuildStaleSnapshots()
         return (false, null, null);
     }
 
+    // The typed FindMatchingSetup<T1..T8> family deliberately omits a TypeArgumentsMatch check.
+    // Typed dispatch never carries call-side type arguments, and per TypeArgumentMatching.Matches a
+    // default call side matches any setup — so the check would be a constant `true`. Two paths land
+    // here: non-generic methods (their setups never carry type arguments), and virtual/partial/wrap
+    // generic methods, which use the documented graceful-degradation path where setups are matched by
+    // arguments only, regardless of configured type arguments. Interface generic methods never use
+    // typed dispatch (see MockMembersBuilder.ShouldGenerateTypedWrapper) and are fully discriminated
+    // via the object?[] overloads above.
     private (bool SetupFound, IBehavior? Behavior, MethodSetup? Setup) FindMatchingSetup<T1>(int memberId, T1 arg1)
     {
         if (_hasStaleSetups) RebuildStaleSnapshots();

TUnit.Mocks/MockMethodCall.cs

@@ -1,3 +1,4 @@
+using System.Collections.Immutable;
 using System.ComponentModel;
 using TUnit.Mocks.Arguments;
 using TUnit.Mocks.Setup;
@@ -20,7 +21,7 @@ public sealed class MockMethodCall<TReturn> : IMethodSetup<TReturn>, ISetupChain
     private readonly int _memberId;
     private readonly string _memberName;
     private readonly IArgumentMatcher[] _matchers;
-    private readonly Type[]? _typeArguments;
+    private readonly ImmutableArray<Type> _typeArguments;
     private MethodSetupBuilder<TReturn>? _builder;
     private bool _builderInitialized;
     private object? _builderLock;
@@ -29,12 +30,12 @@ public sealed class MockMethodCall<TReturn> : IMethodSetup<TReturn>, ISetupChain
     // public binary signature for backward compatibility.
     [EditorBrowsable(EditorBrowsableState.Never)]
     public MockMethodCall(IMockEngineAccess engine, int memberId, string memberName, IArgumentMatcher[] matchers)
-        : this(engine, memberId, memberName, matchers, null)
+        : this(engine, memberId, memberName, matchers, default)
     {
     }
 
     [EditorBrowsable(EditorBrowsableState.Never)]
-    public MockMethodCall(IMockEngineAccess engine, int memberId, string memberName, IArgumentMatcher[] matchers, Type[]? typeArguments)
+    public MockMethodCall(IMockEngineAccess engine, int memberId, string memberName, IArgumentMatcher[] matchers, ImmutableArray<Type> typeArguments)
     {
         _engine = engine;
         _memberId = memberId;
@@ -119,14 +120,8 @@ public IMethodSetup<TReturn> Then()
 
     // ICallVerification implementation
 
-    // Non-generic calls use the public engine surface unchanged; generic calls route through the
-    // internal type-argument-aware factory (always implemented by MockEngine). A custom
-    // IMockEngineAccess implementation falls back to the public surface, losing type-argument
-    // filtering but never throwing.
     private ICallVerification CreateVerification()
-        => _typeArguments is not null && _engine is ITypeArgumentVerificationFactory typeArgFactory
-            ? typeArgFactory.CreateVerification(_memberId, _memberName, _matchers, _typeArguments)
-            : _engine.CreateVerification(_memberId, _memberName, _matchers);
+        => MockCallVerification.Create(_engine, _memberId, _memberName, _matchers, _typeArguments);
 
     public void WasCalled(Times times)
     {

TUnit.Mocks/Setup/MethodSetup.cs

@@ -1,3 +1,4 @@
+using System.Collections.Immutable;
 using System.ComponentModel;
 using System.Runtime.CompilerServices;
 using TUnit.Mocks.Arguments;
@@ -80,19 +81,19 @@ public string? TransitionTarget
 
     /// <summary>
     /// For a generic method, the configured type arguments (concrete types, or
-    /// <see cref="Arguments.AnyType"/>/<see cref="Arguments.AnyValueType"/> wildcards). Null for a
+    /// <see cref="Arguments.AnyType"/>/<see cref="Arguments.AnyValueType"/> wildcards). Default for a
     /// non-generic method, in which case the setup matches regardless of call-site type arguments.
     /// </summary>
     [EditorBrowsable(EditorBrowsableState.Never)]
-    public Type[]? TypeArguments { get; }
+    public ImmutableArray<Type> TypeArguments { get; }
 
     public MethodSetup(int memberId, IArgumentMatcher[] matchers, string memberName = "")
-        : this(memberId, matchers, memberName, null)
+        : this(memberId, matchers, memberName, default)
     {
     }
 
     [EditorBrowsable(EditorBrowsableState.Never)]
-    public MethodSetup(int memberId, IArgumentMatcher[] matchers, string memberName, Type[]? typeArguments)
+    public MethodSetup(int memberId, IArgumentMatcher[] matchers, string memberName, ImmutableArray<Type> typeArguments)
     {
         MemberId = memberId;
         _matchers = matchers;
@@ -102,10 +103,10 @@ public MethodSetup(int memberId, IArgumentMatcher[] matchers, string memberName,
 
     /// <summary>
     /// True if this setup's configured type arguments match a call made with
-    /// <paramref name="callTypeArgs"/>. Non-generic setups (null <see cref="TypeArguments"/>) match any call.
+    /// <paramref name="callTypeArgs"/>. Non-generic setups (default <see cref="TypeArguments"/>) match any call.
     /// </summary>
     [EditorBrowsable(EditorBrowsableState.Never)]
-    public bool TypeArgumentsMatch(Type[]? callTypeArgs)
+    public bool TypeArgumentsMatch(ImmutableArray<Type> callTypeArgs)
         => TypeArgumentMatching.Matches(TypeArguments, callTypeArgs);
 
     private RareState EnsureRareState()