diff --git a/.claude/docs/project-structure.md b/.claude/docs/project-structure.md
index c656a981782..7f03ab7fd5a 100644
--- a/.claude/docs/project-structure.md
+++ b/.claude/docs/project-structure.md
@@ -16,3 +16,17 @@ Product projects live in `src/`, tests in `tests/`, and benchmarks in `benchmark
 Source-generated and reflection metadata feed the same execution path. Roslyn compatibility projects (`*.Roslyn414`, `*.Roslyn44`, `*.Roslyn47`) link shared sources from their base project; account for those variants when changing generators or analyzers.
 
 Generators, analyzers, code fixers and build tasks run inside consumers' compilers, so their behaviour must not depend on the build machine's culture (sv-SE renders negative numbers with U+2212, de-DE uses decimal commas, tr-TR lowercases `I` to `ı`). `Directory.Build.targets` applies `TUNITINT001` and `eng/BuildTimeGlobalization.globalconfig` (CA1304/CA1305/CA1309/CA1310/CA1311 as errors) to those projects; format and parse with `CultureInfo.InvariantCulture` and compare strings with `StringComparison.Ordinal`. `TUNITINT001` cannot see a number that is already typed `object` or an unconstrained generic before it is formatted (other than Roslyn's `TypedConstant.Value`); convert such values with `ToInvariantString()` or `Convert.ToString(value, CultureInfo.InvariantCulture)`. For a justified exception, such as text that is meant to follow the user's culture, wrap the line in `#pragma warning disable TUNITINT001` / `restore` with a comment explaining why; a false positive caused by a Roslyn or SDK change can be downgraded with `dotnet_diagnostic.TUNITINT001.severity` in `eng/BuildTimeGlobalization.globalconfig`.
+
+## Whole-tuple method inference
+
+Generated and reflection discovery must preserve the same whole-row boundary before inferring method types. `WholeTupleInferenceTests` snapshots the shared `_7638/WholeTupleInferenceTests.cs` fixtures; `Issue7638Tests` checks counts and failure outcomes in reflection and Native AOT modes in CI.
+
+| Rule | Generator | Runtime |
+| --- | --- | --- |
+| A tuple first argument with omitted optional, params, or collecting-array tails requires invariant constructed structure and consistent repeated generic bindings | Whole-row matcher in `TestMetadataGenerator` | `TupleHelper.MatchesOpenTuple`, used by `DataSourceHelpers`, `TestDataRowUnwrapper`, and `DataUnwrapper` |
+| A nested row that does not match the whole first tuple spreads into separate columns | Row-type inference falls back to ordinary column inference | Type-aware unwrapping spreads the row |
+| Explicit method types supplement inferred whole-row instantiations, deduplicating identical types | `InferTypesFromMethodDataSourceRowType` | `ReflectionTestDataCollector.InferTypesFromMethodDataSource` |
+| Async source declarations and outer Func, derived TestDataRow, and inner Func wrappers normalize before inference | `GetMethodDataSourceRowType` | `MethodDataSourceAttribute.GetDeclaredRowType` and `TestDataRowUnwrapper.GetInnerDataType` |
+| Ordinary spread columns retain last-column inference, including arrays and nullable values | `ProcessTypeForGenerics` | `MapGenericParameters` |
+
+Sole-tuple element conversion and reconstruction retain their existing behavior. Analyzer false positives for these whole-row shapes are tracked separately in #7622; matcher maintainability is tracked in #7588.
diff --git a/src/TUnit.Core.SourceGenerator/Generators/TestMetadataGenerator.cs b/src/TUnit.Core.SourceGenerator/Generators/TestMetadataGenerator.cs
index 9d4ec66e233..e7f06b0d396 100644
--- a/src/TUnit.Core.SourceGenerator/Generators/TestMetadataGenerator.cs
+++ b/src/TUnit.Core.SourceGenerator/Generators/TestMetadataGenerator.cs
@@ -7288,7 +7288,7 @@ private static IEnumerable<AttributeData> GetOwnClassMethodDataSourcesForInstant
             return namedType.TupleElements.Select(element => element.Type).ToArray();
         }
 
-        if (namedType is not { Name: "Tuple", Arity: >= 1 and <= 8, ContainingNamespace: { Name: "System", ContainingNamespace.IsGlobalNamespace: true } })
+        if (namedType is not { Name: "Tuple" or "ValueTuple", Arity: >= 1 and <= 8, ContainingNamespace: { Name: "System", ContainingNamespace.IsGlobalNamespace: true } })
         {
             return null;
         }
@@ -7303,6 +7303,35 @@ private static IEnumerable<AttributeData> GetOwnClassMethodDataSourcesForInstant
             : null;
     }
 
+    // A tuple passed as one argument must match its complete constructed shape. In particular,
+    // repeated generic parameters bind consistently and closed tuple arguments stay invariant.
+    private static bool MatchesOpenRowType(ITypeSymbol parameter, ITypeSymbol row,
+        Dictionary<ITypeSymbol, ITypeSymbol> bindings)
+    {
+        if (parameter is ITypeParameterSymbol)
+        {
+            if (bindings.TryGetValue(parameter, out var bound))
+                return SymbolEqualityComparer.Default.Equals(bound, row);
+            bindings.Add(parameter, row);
+            return true;
+        }
+
+        if (!CodeGenerationHelpers.ContainsTypeParameter(parameter))
+            return SymbolEqualityComparer.Default.Equals(parameter, row);
+
+        if (parameter is IArrayTypeSymbol array && row is IArrayTypeSymbol rowArray)
+            return array.Rank == rowArray.Rank && MatchesOpenRowType(array.ElementType, rowArray.ElementType, bindings);
+
+        if (parameter is not INamedTypeSymbol { IsGenericType: true } named
+            || row is not INamedTypeSymbol { IsGenericType: true } rowNamed
+            || !SymbolEqualityComparer.Default.Equals(named.OriginalDefinition, rowNamed.OriginalDefinition))
+            return false;
+
+        for (var i = 0; i < named.TypeArguments.Length; i++)
+            if (!MatchesOpenRowType(named.TypeArguments[i], rowNamed.TypeArguments[i], bindings)) return false;
+        return true;
+    }
+
     private static ITypeSymbol[]? InferTypesFromMethodDataSourceRowType(TestMethodMetadata testMethod, AttributeData mdsAttr, ITypeSymbol[]? classTypes = null)
     {
         if (mdsAttr.ConstructorArguments.Length == 0)
@@ -7346,14 +7375,33 @@ ITypeSymbol CloseClassType(ITypeSymbol type) => classTypes is null || classTypes
         var genericParams = testMethod.MethodSymbol.TypeParameters;
         var genericParamMap = new Dictionary<string, ITypeSymbol>();
 
-        if (rowType is INamedTypeSymbol { IsTupleType: true } tupleType
-            && !(testMethodParams.Length == 1 && testMethodParams[0].Type.IsTupleType))
+        Dictionary<ITypeSymbol, ITypeSymbol>? wholeTupleBindings = null;
+        var receivesWholeTuple = testMethodParams.Length > 1
+            && GetTupleElementTypes(CloseClassType(testMethodParams[0].Type)) is not null
+            && testMethodParams.Skip(1).All(parameter => parameter.IsOptional || parameter.IsParams
+                || SymbolEqualityComparer.Default.Equals(parameter, testMethodParams[^1]) && parameter.CollectsTrailingArguments())
+            && MatchesOpenRowType(CloseClassType(testMethodParams[0].Type), rowType,
+                wholeTupleBindings = new Dictionary<ITypeSymbol, ITypeSymbol>(SymbolEqualityComparer.Default));
+        var receivesBareReferenceTuple = testMethodParams.Length == 1
+            && testMethodParams[0].Type is ITypeParameterSymbol
+            && rowType is INamedTypeSymbol { IsTupleType: false, IsValueType: false }
+            && GetTupleElementTypes(rowType) is not null
+            && testMethod.MethodAttributes.Any(static attribute => attribute.AttributeClass?.IsOrInherits("global::TUnit.Core.GenerateGenericTestAttribute") is true);
+
+        if (receivesWholeTuple)
+        {
+            foreach (var binding in wholeTupleBindings!)
+                if (binding.Key is ITypeParameterSymbol parameter && genericParams.Contains(parameter))
+                    genericParamMap[parameter.Name] = binding.Value;
+        }
+        else if (GetTupleElementTypes(rowType) is { } tupleElements
+            && !receivesBareReferenceTuple
+            && !(testMethodParams.Length == 1 && GetTupleElementTypes(testMethodParams[0].Type) is not null))
         {
             // A tuple row is spread across the test method's parameters
-            var tupleElements = tupleType.TupleElements;
             for (var i = 0; i < testMethodParams.Length && i < tupleElements.Length; i++)
             {
-                ProcessTypeForGenerics(CloseClassType(testMethodParams[i].Type), tupleElements[i].Type, genericParams, genericParamMap);
+                ProcessTypeForGenerics(CloseClassType(testMethodParams[i].Type), tupleElements[i], genericParams, genericParamMap);
             }
         }
         else if (testMethodParams.Length > 0)
@@ -7797,9 +7845,14 @@ private static bool IsInvokeConversion(Microsoft.CodeAnalysis.Operations.CommonC
         // Func inside it. Anything nested deeper reaches the test as a value (e.g. a Func<int> row
         // from Func<Func<int>>), so inference must see that value's type too.
         type = Unwrap(type, funcType);
-        if (TryUnwrap(type, testDataRowType, out var rowData))
+        // Runtime unwrapping uses ITestDataRow, including records derived from TestDataRow<T>.
+        for (var candidate = type as INamedTypeSymbol; candidate is not null; candidate = candidate.BaseType)
         {
-            type = Unwrap(rowData, funcType);
+            if (TryUnwrap(candidate, testDataRowType, out var rowData))
+            {
+                type = Unwrap(rowData, funcType);
+                break;
+            }
         }
 
         if (type.SpecialType == SpecialType.System_Object
diff --git a/src/TUnit.Core/Helpers/DataSourceHelpers.cs b/src/TUnit.Core/Helpers/DataSourceHelpers.cs
index 55ab4c99077..8354f7e71b6 100644
--- a/src/TUnit.Core/Helpers/DataSourceHelpers.cs
+++ b/src/TUnit.Core/Helpers/DataSourceHelpers.cs
@@ -535,7 +535,9 @@ public static T InvokeIfFunc<T>(object? value)
                 // Keep a matching first tuple parameter whole, including when later parameters
                 // are omitted. A nested row of a different type still spreads into columns.
                 if (TupleHelper.IsTupleType(expectedTypes[0])
-                    && (expectedTypes.Length == 1 || expectedTypes[0].IsInstanceOfType(item)))
+                    && (expectedTypes.Length == 1 || expectedTypes[0].ContainsGenericParameters
+                        && TupleHelper.MatchesOpenTuple(expectedTypes[0], item.GetType())
+                        || expectedTypes[0].IsInstanceOfType(item)))
                 {
                     if (RequiresFlattenedTupleBinding(item))
                     {
diff --git a/src/TUnit.Core/Helpers/TestDataRowUnwrapper.cs b/src/TUnit.Core/Helpers/TestDataRowUnwrapper.cs
index b36a14477c0..5ab866a95fd 100644
--- a/src/TUnit.Core/Helpers/TestDataRowUnwrapper.cs
+++ b/src/TUnit.Core/Helpers/TestDataRowUnwrapper.cs
@@ -47,16 +47,19 @@ public static bool IsTestDataRowType(Type? type)
     }
 
     /// <summary>
-    /// Gets the inner data type from a <see cref="TestDataRow{T}"/> type.
+    /// Gets the inner data type from a <see cref="TestDataRow{T}"/> type or a derived record.
     /// </summary>
     public static Type? GetInnerDataType(Type testDataRowType)
     {
-        if (!IsTestDataRowType(testDataRowType))
+        for (var current = testDataRowType; current is not null; current = current.BaseType)
         {
-            return null;
+            if (IsTestDataRowType(current))
+            {
+                return current.GetGenericArguments()[0];
+            }
         }
 
-        return testDataRowType.GetGenericArguments()[0];
+        return null;
     }
 
     /// <summary>
@@ -83,7 +86,11 @@ public static (object?[] Data, TestDataRowMetadata? Metadata) UnwrapArray(object
             }
 
             // Check if the data is a tuple that should be expanded
-            if (DataSourceHelpers.IsTuple(data) && (expectedTupleType is null || !expectedTupleType.IsInstanceOfType(data)))
+            if (DataSourceHelpers.IsTuple(data)
+                && !(expectedTupleType is not null
+                    && (expectedTupleType.IsInstanceOfType(data)
+                        || expectedTupleType.ContainsGenericParameters
+                            && TupleHelper.MatchesOpenTuple(expectedTupleType, data!.GetType()))))
             {
                 return (data.ToObjectArray(), metadata);
             }
diff --git a/src/TUnit.Core/Helpers/TupleHelper.cs b/src/TUnit.Core/Helpers/TupleHelper.cs
index 3e6dc49bfb3..b7fc7a0f50c 100644
--- a/src/TUnit.Core/Helpers/TupleHelper.cs
+++ b/src/TUnit.Core/Helpers/TupleHelper.cs
@@ -11,6 +11,52 @@ namespace TUnit.Core.Helpers;
 public static class TupleHelper
 {
 
+    // Process-lifetime cache: one entry per distinct parameter/source type pair.
+    private static readonly ConcurrentDictionary<(Type Parameter, Type Row), bool> OpenTupleMatches = new();
+
+    // Open tuple types cannot use IsInstanceOfType. Match their complete shape so a nested
+    // row with separate columns is not mistaken for the first tuple argument.
+    internal static bool MatchesOpenTuple(Type parameter, Type row) =>
+        OpenTupleMatches.GetOrAdd((parameter, row), static pair => MatchesType(pair.Parameter, pair.Row, new Dictionary<Type, Type>()));
+
+    private static bool MatchesType(Type parameter, Type row, Dictionary<Type, Type> bindings)
+    {
+        if (parameter.IsGenericParameter)
+        {
+            if (bindings.TryGetValue(parameter, out var bound)) return bound == row;
+            bindings.Add(parameter, row);
+            return true;
+        }
+
+        if (!parameter.ContainsGenericParameters)
+        {
+            // Tuple type arguments are invariant. Element assignability alone does not make
+            // the constructed outer tuple assignable. Mirrors generator MatchesOpenRowType.
+            return parameter == row;
+        }
+
+        if (parameter.IsArray)
+        {
+            return row.IsArray && parameter.GetArrayRank() == row.GetArrayRank()
+                && MatchesType(parameter.GetElementType()!, row.GetElementType()!, bindings);
+        }
+
+        if (!parameter.IsGenericType || !row.IsGenericType
+            || parameter.GetGenericTypeDefinition() != row.GetGenericTypeDefinition())
+        {
+            return false;
+        }
+
+        var parameters = parameter.GetGenericArguments();
+        var arguments = row.GetGenericArguments();
+        for (var i = 0; i < parameters.Length; i++)
+        {
+            if (!MatchesType(parameters[i], arguments[i], bindings)) return false;
+        }
+
+        return true;
+    }
+
 #if NET
     /// <summary>
     /// Checks if a type is a tuple type (ValueTuple or Tuple)
diff --git a/src/TUnit.Engine/Discovery/ReflectionTestDataCollector.cs b/src/TUnit.Engine/Discovery/ReflectionTestDataCollector.cs
index 3f9eda280d5..ef7517a124e 100644
--- a/src/TUnit.Engine/Discovery/ReflectionTestDataCollector.cs
+++ b/src/TUnit.Engine/Discovery/ReflectionTestDataCollector.cs
@@ -2917,13 +2917,13 @@ private static bool IsSingleDimensionalZeroBasedArray(Type type)
     /// <summary>
     /// Mirrors the generator's <c>InferTypesFromMethodDataSource</c>. It only reads attributes whose first
     /// constructor argument is the member name (<c>[MethodDataSource("Rows")]</c> and
-    /// <c>[MethodDataSource&lt;T&gt;("Rows")]</c>), looks for a static parameterless method of that name
-    /// declared on the test class (or on <c>T</c>), and requires its declared return type to be
-    /// <c>IEnumerable&lt;Func&lt;(...)&gt;&gt;</c>. Each tuple element is matched against the data parameter
+    /// <c>[MethodDataSource&lt;T&gt;("Rows")]</c>), resolves the member using the same lookup as source invocation
+    /// on the test class (or on <c>T</c>), and requires its declared type to be
+    /// a supported row source, including asynchronous wrappers. Each tuple element is matched against the data parameter
     /// at the same position, including type arguments nested in generic parameter types. The caller passes
     /// the parameters without any CancellationToken, as the generator's <c>GetDataParameters</c> does.
     /// </summary>
-    [UnconditionalSuppressMessage("Trimming", "IL2070", Justification = "Reflection mode requires dynamic access to data source methods")]
+    [UnconditionalSuppressMessage("Trimming", "IL2070", Justification = "Reflection mode requires dynamic access to data source members")]
     private static Type[]? InferTypesFromMethodDataSource(
         Type testClass,
         MethodDataSourceAttribute methodDataSource,
@@ -2941,26 +2941,42 @@ private static bool IsSingleDimensionalZeroBasedArray(Type type)
 
         // [MethodDataSource<T>("Rows")] reads Rows from T, not from the test class
         var providerType = methodDataSource.ClassProvidingDataSource ?? testClass;
-        var dataMethod = providerType.GetMethod(
-            methodDataSource.MethodNameProvidingDataSource,
-            BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.DeclaredOnly,
-            binder: null,
-            Type.EmptyTypes,
-            modifiers: null);
+        Type? memberType;
+        try
+        {
+            memberType = methodDataSource.GetDeclaredMemberType(providerType);
+        }
+        catch (AmbiguousMatchException)
+        {
+            // Invocation reports the invalid source later; inference must not abort assembly discovery.
+            return null;
+        }
 
-        if (dataMethod?.ReturnType is not { IsGenericType: true } returnType
-            || returnType.GetGenericTypeDefinition() != typeof(IEnumerable<>)
-            || returnType.GetGenericArguments()[0] is not { IsGenericType: true } funcType
-            || funcType.GetGenericTypeDefinition() != typeof(Func<>)
-            || GetValueTupleElementTypes(funcType.GetGenericArguments()[0]) is not { } tupleElements)
+        // Normalize the same asynchronous and sequence wrappers as runtime row reading before
+        // supplementing explicit method types. Retain the bounded outer/inner Func unwrapping.
+        if (memberType is null || MethodDataSourceAttribute.GetDeclaredRowType(memberType) is not { } rowType
+            || GetTupleElementTypes(rowType) is not { } tupleElements)
         {
             return null;
         }
 
         var typeArguments = new Type?[genericParameterCount];
-        for (var i = 0; i < parameters.Length && i < tupleElements.Length; i++)
+        var receivesWholeTuple = parameters.Length > 0
+            && ((GetTupleElementTypes(parameters[0].ParameterType) is not null
+                    && parameters.Skip(1).All(parameter => parameter.IsOptional
+                        || parameter.IsDefined(typeof(ParamArrayAttribute), false)
+                        || IsParamCollection(parameter)
+                        || (parameter == parameters[^1] && IsSingleDimensionalZeroBasedArray(parameter.ParameterType)))
+                    && (parameters.Length == 1 || TupleHelper.MatchesOpenTuple(parameters[0].ParameterType, rowType)))
+                || (parameters.Length == 1 && parameters[0].ParameterType.IsGenericParameter && !rowType.IsValueType));
+        if (receivesWholeTuple)
+        {
+            MapGenericParameters(parameters[0].ParameterType, rowType, typeArguments);
+        }
+        else
         {
-            MapGenericParameters(parameters[i].ParameterType, tupleElements[i], typeArguments);
+            for (var i = 0; i < parameters.Length && i < tupleElements.Length; i++)
+                MapGenericParameters(parameters[i].ParameterType, tupleElements[i], typeArguments);
         }
 
         foreach (var typeArgument in typeArguments)
@@ -3001,8 +3017,18 @@ private static bool ReadsMemberOfOpenClass(IDataSourceAttribute dataSource) =>
     private static Type[]? InferClassTypeArgumentsFromOwnMemberRowType(Type genericTypeDefinition, MethodDataSourceAttribute methodDataSource, out ConstructorInfo? constructor)
     {
         constructor = null;
-        if (methodDataSource.GetDeclaredMemberType(genericTypeDefinition) is not { } memberType
-            || MethodDataSourceAttribute.GetDeclaredRowType(memberType) is not { } rowType)
+        Type? memberType;
+        try
+        {
+            memberType = methodDataSource.GetDeclaredMemberType(genericTypeDefinition);
+        }
+        catch (AmbiguousMatchException)
+        {
+            // Leave the invalid source to invocation instead of failing discovery for the assembly.
+            return null;
+        }
+
+        if (memberType is null || MethodDataSourceAttribute.GetDeclaredRowType(memberType) is not { } rowType)
         {
             return null;
         }
@@ -3128,6 +3154,19 @@ private static void MapGenericParameters(Type parameterType, Type actualType, Ty
             return;
         }
 
+        // Ordinary spread columns retain last-column inference through nullable values and arrays.
+        if (Nullable.GetUnderlyingType(parameterType) is { } nullableParameter
+            && actualType.IsValueType && Nullable.GetUnderlyingType(actualType) is null)
+        {
+            MapGenericParameters(nullableParameter, actualType, typeArguments);
+            return;
+        }
+        if (parameterType.IsArray && actualType.IsArray && parameterType.GetArrayRank() == actualType.GetArrayRank())
+        {
+            MapGenericParameters(parameterType.GetElementType()!, actualType.GetElementType()!, typeArguments);
+            return;
+        }
+
         if (parameterType.IsGenericType
             && actualType.IsGenericType
             && parameterType.GetGenericTypeDefinition() == actualType.GetGenericTypeDefinition())
diff --git a/src/TUnit.Engine/Helpers/DataUnwrapper.cs b/src/TUnit.Engine/Helpers/DataUnwrapper.cs
index 9d7b3b2b041..300c7933f01 100644
--- a/src/TUnit.Engine/Helpers/DataUnwrapper.cs
+++ b/src/TUnit.Engine/Helpers/DataUnwrapper.cs
@@ -171,7 +171,10 @@ public static (object?[] Data, TestDataRowMetadata? Metadata) UnwrapWithTypesAnd
         var firstDataParameterType = expectedParameters[firstDataParameterIndex].Type;
         if (dataParameterCount > 1
             && TupleHelper.IsTupleType(firstDataParameterType)
-            && (firstDataParameterType.IsInstanceOfType(values[0])
+            && (firstDataParameterType.ContainsGenericParameters
+                && values[0] is { } firstValue
+                && TupleHelper.MatchesOpenTuple(firstDataParameterType, firstValue is TupleArgument tupleArgument ? tupleArgument.TupleType : firstValue.GetType())
+                || firstDataParameterType.IsInstanceOfType(values[0])
                 || values[0] is TupleArgument argument && argument.TupleType == firstDataParameterType)
             && RemainingDataParametersAreOmittable(expectedParameters, firstDataParameterIndex))
         {
diff --git a/tests/TUnit.Core.SourceGenerator.Tests/WholeTupleInferenceTests.Test.verified.txt b/tests/TUnit.Core.SourceGenerator.Tests/WholeTupleInferenceTests.Test.verified.txt
new file mode 100644
index 00000000000..9a96f760d73
--- /dev/null
+++ b/tests/TUnit.Core.SourceGenerator.Tests/WholeTupleInferenceTests.Test.verified.txt
@@ -0,0 +1,5371 @@
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute]
+[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")]
+internal static class TUnit_TestProject_Bugs__7638_NestedTupleWithTrailingParametersTests_ValueOptional___T__B0EE96A7_TestSource
+{
+    private static readonly global::TUnit.Core.ClassMetadata __classMetadata =     global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests", new global::TUnit.Core.ClassMetadata
+    {
+        Type = typeof(global::TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests),
+        TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests)),
+        Name = "NestedTupleWithTrailingParametersTests",
+        Namespace = "TUnit.TestProject.Bugs._7638",
+        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"),
+        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+        Parent = null
+    });
+    private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests);
+    private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ValueOptional", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests), "ValueOptional", false, 1, new global::TUnit.Core.ParameterMetadata[]
+{
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false),
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int), "extra", new global::TUnit.Core.ConcreteType(typeof(int)), false)
+}));
+    private static global::TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args)
+    {
+        return new global::TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests();
+    }
+    private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken)
+    {
+        try
+        {
+            if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList<object> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0]))
+            {
+                var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]);
+                args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleElements[1])) };
+            }
+            switch (args.Length)
+            {
+                case 1:
+                    {
+                        instance.ValueOptional<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), (int)(5));
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 2:
+                    {
+                        instance.ValueOptional<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]));
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                default:
+                    throw new global::System.ArgumentException($"Expected between 1 and 2 arguments, but got {args.Length}");
+            }
+        }
+        catch (global::System.Exception ex)
+        {
+            return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+        }
+    }
+    private static global::System.Attribute[] __Attributes_0(int groupIndex)
+    {
+        return new global::System.Attribute[]
+        {
+            new global::TUnit.Core.TestAttribute(),
+            new global::TUnit.Core.MethodDataSourceAttribute("ValueRows")
+        };
+    }
+    public static readonly global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests>[] Entries_0 = new global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests>[]
+    {
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests>(
+            methodName: "ValueOptional<int>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests.ValueOptional<int>",
+            methodTypeArgumentsIdentity: "<int>",
+            filePath: "",
+            lineNumber: 11,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("ValueRows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests.ValueRows()),
+    },
+},
+            methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple<int, string>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple<int, string>)) }, __mm_0.Parameters[1] with { Type = typeof(int), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int)) } } },
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 0,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 0),
+    };
+}
+internal static partial class TUnit_TestRegistration
+{
+    static readonly int _r_TUnit_TestProject_Bugs__7638_NestedTupleWithTrailingParametersTests_ValueOptional___T__B0EE96A7_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries<global::TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests>(static () => TUnit_TestProject_Bugs__7638_NestedTupleWithTrailingParametersTests_ValueOptional___T__B0EE96A7_TestSource.Entries_0);
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute]
+[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")]
+internal static class TUnit_TestProject_Bugs__7638_NestedTupleWithTrailingParametersTests_ValueParams___T__s_2DF38BAF_TestSource
+{
+    private static readonly global::TUnit.Core.ClassMetadata __classMetadata =     global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests", new global::TUnit.Core.ClassMetadata
+    {
+        Type = typeof(global::TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests),
+        TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests)),
+        Name = "NestedTupleWithTrailingParametersTests",
+        Namespace = "TUnit.TestProject.Bugs._7638",
+        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"),
+        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+        Parent = null
+    });
+    private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests);
+    private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ValueParams", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests), "ValueParams", false, 1, new global::TUnit.Core.ParameterMetadata[]
+{
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false),
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int[]), "extra", new global::TUnit.Core.ConcreteType(typeof(int[])), false)
+}));
+    private static global::TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args)
+    {
+        return new global::TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests();
+    }
+    private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken)
+    {
+        try
+        {
+            if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList<object> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0]))
+            {
+                var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]);
+                args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleElements[1])) };
+            }
+            switch (args.Length)
+            {
+                case 1:
+                    {
+                        instance.ValueParams<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), global::System.Array.Empty<int>());
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 2:
+                    {
+                        instance.ValueParams<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), (args[1] is null ? null : args[1] is int[] arr ? arr : global::TUnit.Core.Helpers.CastHelper.ToTrailingArray<int>(args[1])));
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 3:
+                    {
+                        instance.ValueParams<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 4:
+                    {
+                        instance.ValueParams<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 5:
+                    {
+                        instance.ValueParams<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[4]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 6:
+                    {
+                        instance.ValueParams<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[4]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[5]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 7:
+                    {
+                        instance.ValueParams<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[4]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[5]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[6]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                default:
+                    if (args.Length < 1)
+                    {
+                        throw new global::System.ArgumentException($"Expected at least 1 argument, but got {args.Length}");
+                    }
+                    instance.ValueParams<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), (args.Length > 1 ? global::System.Linq.Enumerable.ToArray(global::System.Linq.Enumerable.Select(global::System.Linq.Enumerable.Range(1, args.Length - 1), i => global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[i]))) : global::System.Array.Empty<int>()));
+                    return default(global::System.Threading.Tasks.ValueTask);
+            }
+        }
+        catch (global::System.Exception ex)
+        {
+            return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+        }
+    }
+    private static global::System.Attribute[] __Attributes_0(int groupIndex)
+    {
+        return new global::System.Attribute[]
+        {
+            new global::TUnit.Core.TestAttribute(),
+            new global::TUnit.Core.MethodDataSourceAttribute("ValueParamsRows")
+        };
+    }
+    public static readonly global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests>[] Entries_0 = new global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests>[]
+    {
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests>(
+            methodName: "ValueParams<int>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests.ValueParams<int>",
+            methodTypeArgumentsIdentity: "<int>",
+            filePath: "",
+            lineNumber: 21,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("ValueParamsRows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests.ValueParamsRows()),
+    },
+},
+            methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple<int, string>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple<int, string>)) }, __mm_0.Parameters[1] with { Type = typeof(int[]), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int[])) } } },
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 0,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 0),
+    };
+}
+internal static partial class TUnit_TestRegistration
+{
+    static readonly int _r_TUnit_TestProject_Bugs__7638_NestedTupleWithTrailingParametersTests_ValueParams___T__s_2DF38BAF_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries<global::TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests>(static () => TUnit_TestProject_Bugs__7638_NestedTupleWithTrailingParametersTests_ValueParams___T__s_2DF38BAF_TestSource.Entries_0);
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute]
+[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")]
+internal static class TUnit_TestProject_Bugs__7638_NestedTupleWithTrailingParametersTests_ReferenceOptional__E7F78E99_TestSource
+{
+    private static readonly global::TUnit.Core.ClassMetadata __classMetadata =     global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests", new global::TUnit.Core.ClassMetadata
+    {
+        Type = typeof(global::TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests),
+        TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests)),
+        Name = "NestedTupleWithTrailingParametersTests",
+        Namespace = "TUnit.TestProject.Bugs._7638",
+        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"),
+        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+        Parent = null
+    });
+    private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests);
+    private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ReferenceOptional", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests), "ReferenceOptional", false, 1, new global::TUnit.Core.ParameterMetadata[]
+{
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false),
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int), "extra", new global::TUnit.Core.ConcreteType(typeof(int)), false)
+}));
+    private static global::TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args)
+    {
+        return new global::TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests();
+    }
+    private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken)
+    {
+        try
+        {
+            if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList<object> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0]))
+            {
+                var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]);
+                args = new object[] { new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleElements[1])) };
+            }
+            switch (args.Length)
+            {
+                case 1:
+                    {
+                        instance.ReferenceOptional<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<int, string>)new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int, string>>(__tupleFallback0) }), (int)(5));
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 2:
+                    {
+                        instance.ReferenceOptional<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<int, string>)new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int, string>>(__tupleFallback0) }), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]));
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                default:
+                    throw new global::System.ArgumentException($"Expected between 1 and 2 arguments, but got {args.Length}");
+            }
+        }
+        catch (global::System.Exception ex)
+        {
+            return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+        }
+    }
+    private static global::System.Attribute[] __Attributes_0(int groupIndex)
+    {
+        return new global::System.Attribute[]
+        {
+            new global::TUnit.Core.TestAttribute(),
+            new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows")
+        };
+    }
+    public static readonly global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests>[] Entries_0 = new global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests>[]
+    {
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests>(
+            methodName: "ReferenceOptional<int>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests.ReferenceOptional<int>",
+            methodTypeArgumentsIdentity: "<int>",
+            filePath: "",
+            lineNumber: 29,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests.ReferenceRows()),
+    },
+},
+            methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple<int, string>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple<int, string>)) }, __mm_0.Parameters[1] with { Type = typeof(int), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int)) } } },
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 0,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 0),
+    };
+}
+internal static partial class TUnit_TestRegistration
+{
+    static readonly int _r_TUnit_TestProject_Bugs__7638_NestedTupleWithTrailingParametersTests_ReferenceOptional__E7F78E99_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries<global::TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests>(static () => TUnit_TestProject_Bugs__7638_NestedTupleWithTrailingParametersTests_ReferenceOptional__E7F78E99_TestSource.Entries_0);
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute]
+[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")]
+internal static class TUnit_TestProject_Bugs__7638_NestedTupleWithTrailingParametersTests_ReferenceParams__T_93253A5D_TestSource
+{
+    private static readonly global::TUnit.Core.ClassMetadata __classMetadata =     global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests", new global::TUnit.Core.ClassMetadata
+    {
+        Type = typeof(global::TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests),
+        TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests)),
+        Name = "NestedTupleWithTrailingParametersTests",
+        Namespace = "TUnit.TestProject.Bugs._7638",
+        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"),
+        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+        Parent = null
+    });
+    private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests);
+    private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ReferenceParams", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests), "ReferenceParams", false, 1, new global::TUnit.Core.ParameterMetadata[]
+{
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false),
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int[]), "extra", new global::TUnit.Core.ConcreteType(typeof(int[])), false)
+}));
+    private static global::TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args)
+    {
+        return new global::TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests();
+    }
+    private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken)
+    {
+        try
+        {
+            if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList<object> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0]))
+            {
+                var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]);
+                args = new object[] { new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleElements[1])) };
+            }
+            switch (args.Length)
+            {
+                case 1:
+                    {
+                        instance.ReferenceParams<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<int, string>)new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int, string>>(__tupleFallback0) }), global::System.Array.Empty<int>());
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 2:
+                    {
+                        instance.ReferenceParams<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<int, string>)new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int, string>>(__tupleFallback0) }), (args[1] is null ? null : args[1] is int[] arr ? arr : global::TUnit.Core.Helpers.CastHelper.ToTrailingArray<int>(args[1])));
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 3:
+                    {
+                        instance.ReferenceParams<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<int, string>)new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 4:
+                    {
+                        instance.ReferenceParams<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<int, string>)new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 5:
+                    {
+                        instance.ReferenceParams<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<int, string>)new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[4]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 6:
+                    {
+                        instance.ReferenceParams<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<int, string>)new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[4]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[5]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 7:
+                    {
+                        instance.ReferenceParams<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<int, string>)new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[4]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[5]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[6]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                default:
+                    if (args.Length < 1)
+                    {
+                        throw new global::System.ArgumentException($"Expected at least 1 argument, but got {args.Length}");
+                    }
+                    instance.ReferenceParams<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<int, string>)new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int, string>>(__tupleFallback0) }), (args.Length > 1 ? global::System.Linq.Enumerable.ToArray(global::System.Linq.Enumerable.Select(global::System.Linq.Enumerable.Range(1, args.Length - 1), i => global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[i]))) : global::System.Array.Empty<int>()));
+                    return default(global::System.Threading.Tasks.ValueTask);
+            }
+        }
+        catch (global::System.Exception ex)
+        {
+            return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+        }
+    }
+    private static global::System.Attribute[] __Attributes_0(int groupIndex)
+    {
+        return new global::System.Attribute[]
+        {
+            new global::TUnit.Core.TestAttribute(),
+            new global::TUnit.Core.MethodDataSourceAttribute("ReferenceParamsRows")
+        };
+    }
+    public static readonly global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests>[] Entries_0 = new global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests>[]
+    {
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests>(
+            methodName: "ReferenceParams<int>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests.ReferenceParams<int>",
+            methodTypeArgumentsIdentity: "<int>",
+            filePath: "",
+            lineNumber: 39,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("ReferenceParamsRows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests.ReferenceParamsRows()),
+    },
+},
+            methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple<int, string>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple<int, string>)) }, __mm_0.Parameters[1] with { Type = typeof(int[]), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int[])) } } },
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 0,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 0),
+    };
+}
+internal static partial class TUnit_TestRegistration
+{
+    static readonly int _r_TUnit_TestProject_Bugs__7638_NestedTupleWithTrailingParametersTests_ReferenceParams__T_93253A5D_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries<global::TUnit.TestProject.Bugs._7638.NestedTupleWithTrailingParametersTests>(static () => TUnit_TestProject_Bugs__7638_NestedTupleWithTrailingParametersTests_ReferenceParams__T_93253A5D_TestSource.Entries_0);
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute]
+[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")]
+internal static class TUnit_TestProject_Bugs__7638_ClosedNestedTupleConversionTests_ClosedNested___T___objec_3B9317F2_TestSource
+{
+    private static readonly global::TUnit.Core.ClassMetadata __classMetadata =     global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7638.ClosedNestedTupleConversionTests", new global::TUnit.Core.ClassMetadata
+    {
+        Type = typeof(global::TUnit.TestProject.Bugs._7638.ClosedNestedTupleConversionTests),
+        TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7638.ClosedNestedTupleConversionTests)),
+        Name = "ClosedNestedTupleConversionTests",
+        Namespace = "TUnit.TestProject.Bugs._7638",
+        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"),
+        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+        Parent = null
+    });
+    private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7638.ClosedNestedTupleConversionTests);
+    private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ClosedNested", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7638.ClosedNestedTupleConversionTests), "ClosedNested", false, 1, new global::TUnit.Core.ParameterMetadata[]
+{
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "pair", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple<object, int>))]), false),
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(global::System.ValueTuple<int, int>?), "extra", new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple<int, int>?)), true)
+}));
+    private static global::TUnit.TestProject.Bugs._7638.ClosedNestedTupleConversionTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args)
+    {
+        return new global::TUnit.TestProject.Bugs._7638.ClosedNestedTupleConversionTests();
+    }
+    private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7638.ClosedNestedTupleConversionTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken)
+    {
+        try
+        {
+            if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList<object> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0]))
+            {
+                var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]);
+                args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleElements[0]), (__tupleElements[1] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<object, int> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<object, int>)(global::TUnit.Core.Helpers.CastHelper.Cast<object>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<object, int>>(__tupleFallback0) })) };
+            }
+            switch (args.Length)
+            {
+                case 1:
+                    {
+                        instance.ClosedNested<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, global::System.ValueTuple<object, int>> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, global::System.ValueTuple<object, int>>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), (__tupleInput0[1] switch { var __tupleValue1 when __tupleValue1 is not global::System.ValueTuple<object, int> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue1) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue1) is { Length: 2 } __tupleInput1 => (global::System.ValueTuple<object, int>)(global::TUnit.Core.Helpers.CastHelper.Cast<object>(__tupleInput1[0]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput1[1])), var __tupleFallback1 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<object, int>>(__tupleFallback1) })), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, global::System.ValueTuple<object, int>>>(__tupleFallback0) }), default(global::System.ValueTuple<int, int>?)!);
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 2:
+                    {
+                        instance.ClosedNested<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, global::System.ValueTuple<object, int>> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, global::System.ValueTuple<object, int>>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), (__tupleInput0[1] switch { var __tupleValue1 when __tupleValue1 is not global::System.ValueTuple<object, int> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue1) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue1) is { Length: 2 } __tupleInput1 => (global::System.ValueTuple<object, int>)(global::TUnit.Core.Helpers.CastHelper.Cast<object>(__tupleInput1[0]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput1[1])), var __tupleFallback1 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<object, int>>(__tupleFallback1) })), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, global::System.ValueTuple<object, int>>>(__tupleFallback0) }), (args[1] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, int> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, int>?)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, int>?>(__tupleFallback0) }));
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                default:
+                    throw new global::System.ArgumentException($"Expected between 1 and 2 arguments, but got {args.Length}");
+            }
+        }
+        catch (global::System.Exception ex)
+        {
+            return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+        }
+    }
+    private static global::System.Attribute[] __Attributes_0(int groupIndex)
+    {
+        return new global::System.Attribute[]
+        {
+            new global::TUnit.Core.TestAttribute(),
+            new global::TUnit.Core.MethodDataSourceAttribute("Rows")
+        };
+    }
+    public static readonly global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.ClosedNestedTupleConversionTests>[] Entries_0 = new global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.ClosedNestedTupleConversionTests>[]
+    {
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.ClosedNestedTupleConversionTests>(
+            methodName: "ClosedNested<int>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.ClosedNestedTupleConversionTests.ClosedNested<int>",
+            methodTypeArgumentsIdentity: "<int>",
+            filePath: "",
+            lineNumber: 52,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("Rows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.ClosedNestedTupleConversionTests.Rows()),
+    },
+},
+            methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple<int, global::System.ValueTuple<object, int>>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple<int, global::System.ValueTuple<object, int>>)) }, __mm_0.Parameters[1] with { Type = typeof(global::System.ValueTuple<int, int>?), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple<int, int>?)) } } },
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 0,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 0),
+    };
+}
+internal static partial class TUnit_TestRegistration
+{
+    static readonly int _r_TUnit_TestProject_Bugs__7638_ClosedNestedTupleConversionTests_ClosedNested___T___objec_3B9317F2_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries<global::TUnit.TestProject.Bugs._7638.ClosedNestedTupleConversionTests>(static () => TUnit_TestProject_Bugs__7638_ClosedNestedTupleConversionTests_ClosedNested___T___objec_3B9317F2_TestSource.Entries_0);
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute]
+[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")]
+internal static class TUnit_TestProject_Bugs__7638_RepeatedTupleBindingTests_RepeatedValue___T__T__int_TestSource
+{
+    private static readonly global::TUnit.Core.ClassMetadata __classMetadata =     global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7638.RepeatedTupleBindingTests", new global::TUnit.Core.ClassMetadata
+    {
+        Type = typeof(global::TUnit.TestProject.Bugs._7638.RepeatedTupleBindingTests),
+        TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7638.RepeatedTupleBindingTests)),
+        Name = "RepeatedTupleBindingTests",
+        Namespace = "TUnit.TestProject.Bugs._7638",
+        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"),
+        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+        Parent = null
+    });
+    private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7638.RepeatedTupleBindingTests);
+    private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("RepeatedValue", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7638.RepeatedTupleBindingTests), "RepeatedValue", false, 1, new global::TUnit.Core.ParameterMetadata[]
+{
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.GenericParameter(0, true, "T")]), false),
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int), "extra", new global::TUnit.Core.ConcreteType(typeof(int)), false)
+}));
+    private static global::TUnit.TestProject.Bugs._7638.RepeatedTupleBindingTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args)
+    {
+        return new global::TUnit.TestProject.Bugs._7638.RepeatedTupleBindingTests();
+    }
+    private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7638.RepeatedTupleBindingTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken)
+    {
+        try
+        {
+            if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList<object> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0]))
+            {
+                var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]);
+                args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleElements[1])) };
+            }
+            switch (args.Length)
+            {
+                case 1:
+                    {
+                        instance.RepeatedValue<string>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<string, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<string, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<string, string>>(__tupleFallback0) }), (int)(0));
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 2:
+                    {
+                        instance.RepeatedValue<string>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<string, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<string, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<string, string>>(__tupleFallback0) }), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]));
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                default:
+                    throw new global::System.ArgumentException($"Expected between 1 and 2 arguments, but got {args.Length}");
+            }
+        }
+        catch (global::System.Exception ex)
+        {
+            return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+        }
+    }
+    private static global::System.Attribute[] __Attributes_0(int groupIndex)
+    {
+        return new global::System.Attribute[]
+        {
+            new global::TUnit.Core.TestAttribute(),
+            new global::TUnit.Core.MethodDataSourceAttribute("ValueRows")
+        };
+    }
+    public static readonly global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.RepeatedTupleBindingTests>[] Entries_0 = new global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.RepeatedTupleBindingTests>[]
+    {
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.RepeatedTupleBindingTests>(
+            methodName: "RepeatedValue<string>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.RepeatedTupleBindingTests.RepeatedValue<string>",
+            methodTypeArgumentsIdentity: "<string>",
+            filePath: "",
+            lineNumber: 68,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("ValueRows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.RepeatedTupleBindingTests.ValueRows()),
+    },
+},
+            methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple<string, string>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple<string, string>)) }, __mm_0.Parameters[1] with { Type = typeof(int), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int)) } } },
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 0,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 0),
+    };
+}
+internal static partial class TUnit_TestRegistration
+{
+    static readonly int _r_TUnit_TestProject_Bugs__7638_RepeatedTupleBindingTests_RepeatedValue___T__T__int_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries<global::TUnit.TestProject.Bugs._7638.RepeatedTupleBindingTests>(static () => TUnit_TestProject_Bugs__7638_RepeatedTupleBindingTests_RepeatedValue___T__T__int_TestSource.Entries_0);
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute]
+[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")]
+internal static class TUnit_TestProject_Bugs__7638_RepeatedTupleBindingTests_RepeatedReference__Tuple_T__T___3D69F6B8_TestSource
+{
+    private static readonly global::TUnit.Core.ClassMetadata __classMetadata =     global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7638.RepeatedTupleBindingTests", new global::TUnit.Core.ClassMetadata
+    {
+        Type = typeof(global::TUnit.TestProject.Bugs._7638.RepeatedTupleBindingTests),
+        TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7638.RepeatedTupleBindingTests)),
+        Name = "RepeatedTupleBindingTests",
+        Namespace = "TUnit.TestProject.Bugs._7638",
+        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"),
+        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+        Parent = null
+    });
+    private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7638.RepeatedTupleBindingTests);
+    private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("RepeatedReference", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7638.RepeatedTupleBindingTests), "RepeatedReference", false, 1, new global::TUnit.Core.ParameterMetadata[]
+{
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.GenericParameter(0, true, "T")]), false),
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(global::System.Tuple<int, string>), "extra", new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple<int, string>)), true)
+}));
+    private static global::TUnit.TestProject.Bugs._7638.RepeatedTupleBindingTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args)
+    {
+        return new global::TUnit.TestProject.Bugs._7638.RepeatedTupleBindingTests();
+    }
+    private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7638.RepeatedTupleBindingTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken)
+    {
+        try
+        {
+            if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList<object> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0]))
+            {
+                var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]);
+                args = new object[] { new global::System.Tuple<int, int>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleElements[1])) };
+            }
+            switch (args.Length)
+            {
+                case 1:
+                    {
+                        instance.RepeatedReference<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int, int> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<int, int>)new global::System.Tuple<int, int>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int, int>>(__tupleFallback0) }), default(global::System.Tuple<int, string>)!);
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 2:
+                    {
+                        instance.RepeatedReference<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int, int> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<int, int>)new global::System.Tuple<int, int>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int, int>>(__tupleFallback0) }), (args[1] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<int, string>)new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int, string>>(__tupleFallback0) }));
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                default:
+                    throw new global::System.ArgumentException($"Expected between 1 and 2 arguments, but got {args.Length}");
+            }
+        }
+        catch (global::System.Exception ex)
+        {
+            return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+        }
+    }
+    private static global::System.Attribute[] __Attributes_0(int groupIndex)
+    {
+        return new global::System.Attribute[]
+        {
+            new global::TUnit.Core.TestAttribute(),
+            new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows")
+        };
+    }
+    public static readonly global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.RepeatedTupleBindingTests>[] Entries_0 = new global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.RepeatedTupleBindingTests>[]
+    {
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.RepeatedTupleBindingTests>(
+            methodName: "RepeatedReference<int>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.RepeatedTupleBindingTests.RepeatedReference<int>",
+            methodTypeArgumentsIdentity: "<int>",
+            filePath: "",
+            lineNumber: 76,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.RepeatedTupleBindingTests.ReferenceRows()),
+    },
+},
+            methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple<int, int>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple<int, int>)) }, __mm_0.Parameters[1] with { Type = typeof(global::System.Tuple<int, string>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple<int, string>)) } } },
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 0,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 0),
+    };
+}
+internal static partial class TUnit_TestRegistration
+{
+    static readonly int _r_TUnit_TestProject_Bugs__7638_RepeatedTupleBindingTests_RepeatedReference__Tuple_T__T___3D69F6B8_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries<global::TUnit.TestProject.Bugs._7638.RepeatedTupleBindingTests>(static () => TUnit_TestProject_Bugs__7638_RepeatedTupleBindingTests_RepeatedReference__Tuple_T__T___3D69F6B8_TestSource.Entries_0);
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute]
+[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")]
+internal static class TUnit_TestProject_Bugs__7638_RepeatedTupleBindingTests_RepeatedWhole___T__T__TestSource
+{
+    private static readonly global::TUnit.Core.ClassMetadata __classMetadata =     global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7638.RepeatedTupleBindingTests", new global::TUnit.Core.ClassMetadata
+    {
+        Type = typeof(global::TUnit.TestProject.Bugs._7638.RepeatedTupleBindingTests),
+        TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7638.RepeatedTupleBindingTests)),
+        Name = "RepeatedTupleBindingTests",
+        Namespace = "TUnit.TestProject.Bugs._7638",
+        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"),
+        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+        Parent = null
+    });
+    private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7638.RepeatedTupleBindingTests);
+    private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("RepeatedWhole", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7638.RepeatedTupleBindingTests), "RepeatedWhole", false, 1, new global::TUnit.Core.ParameterMetadata[]
+{
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.GenericParameter(0, true, "T")]), false)
+}));
+    private static global::TUnit.TestProject.Bugs._7638.RepeatedTupleBindingTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args)
+    {
+        return new global::TUnit.TestProject.Bugs._7638.RepeatedTupleBindingTests();
+    }
+    private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7638.RepeatedTupleBindingTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken)
+    {
+        try
+        {
+            // Special handling for single tuple parameter
+            if (args.Length == 2)
+            {
+                // Arguments are unwrapped tuple elements, reconstruct the tuple
+                instance.RepeatedWhole<int>((global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1])));
+                return default(global::System.Threading.Tasks.ValueTask);
+            }
+            else if (args.Length == 1 && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0]))
+            {
+                // Rare case: tuple is wrapped as a single argument
+                instance.RepeatedWhole<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, int> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, int>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, int>>(__tupleFallback0) }));
+                return default(global::System.Threading.Tasks.ValueTask);
+            }
+            else
+            {
+                throw new global::System.ArgumentException($"Expected 2 unwrapped elements or 1 wrapped tuple, but got {args.Length} arguments");
+            }
+        }
+        catch (global::System.Exception ex)
+        {
+            return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+        }
+    }
+    private static global::System.Attribute[] __Attributes_0(int groupIndex)
+    {
+        return new global::System.Attribute[]
+        {
+            new global::TUnit.Core.TestAttribute(),
+            new global::TUnit.Core.MethodDataSourceAttribute("WholeRows")
+        };
+    }
+    public static readonly global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.RepeatedTupleBindingTests>[] Entries_0 = new global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.RepeatedTupleBindingTests>[]
+    {
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.RepeatedTupleBindingTests>(
+            methodName: "RepeatedWhole<int>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.RepeatedTupleBindingTests.RepeatedWhole<int>",
+            methodTypeArgumentsIdentity: "<int>",
+            filePath: "",
+            lineNumber: 84,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("WholeRows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.RepeatedTupleBindingTests.WholeRows()),
+    },
+},
+            methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple<int, int>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple<int, int>)) } } },
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 0,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 0),
+    };
+}
+internal static partial class TUnit_TestRegistration
+{
+    static readonly int _r_TUnit_TestProject_Bugs__7638_RepeatedTupleBindingTests_RepeatedWhole___T__T__TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries<global::TUnit.TestProject.Bugs._7638.RepeatedTupleBindingTests>(static () => TUnit_TestProject_Bugs__7638_RepeatedTupleBindingTests_RepeatedWhole___T__T__TestSource.Entries_0);
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute]
+[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")]
+internal static class TUnit_TestProject_Bugs__7638_WholeReferenceTupleSourceTests_WholeRow__T_TestSource
+{
+    private static readonly global::TUnit.Core.ClassMetadata __classMetadata =     global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7638.WholeReferenceTupleSourceTests", new global::TUnit.Core.ClassMetadata
+    {
+        Type = typeof(global::TUnit.TestProject.Bugs._7638.WholeReferenceTupleSourceTests),
+        TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7638.WholeReferenceTupleSourceTests)),
+        Name = "WholeReferenceTupleSourceTests",
+        Namespace = "TUnit.TestProject.Bugs._7638",
+        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"),
+        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+        Parent = null
+    });
+    private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7638.WholeReferenceTupleSourceTests);
+    private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("WholeRow", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7638.WholeReferenceTupleSourceTests), "WholeRow", false, 1, new global::TUnit.Core.ParameterMetadata[]
+{
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.GenericParameter(0, true, "T"), false)
+}));
+    private static global::TUnit.TestProject.Bugs._7638.WholeReferenceTupleSourceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args)
+    {
+        return new global::TUnit.TestProject.Bugs._7638.WholeReferenceTupleSourceTests();
+    }
+    private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7638.WholeReferenceTupleSourceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken)
+    {
+        try
+        {
+            // Special handling for single reference tuple parameter
+            if (args.Length == 2)
+            {
+                instance.WholeRow<global::System.Tuple<int, string>>(new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(args[1])));
+                return default(global::System.Threading.Tasks.ValueTask);
+            }
+            else
+            {
+                switch (args.Length)
+                {
+                    case 1:
+                        {
+                            instance.WholeRow<global::System.Tuple<int, string>>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<int, string>)new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int, string>>(__tupleFallback0) }));
+                            return default(global::System.Threading.Tasks.ValueTask);
+                        }
+                    default:
+                        throw new global::System.ArgumentException($"Expected exactly 1 argument, but got {args.Length}");
+                }
+            }
+        }
+        catch (global::System.Exception ex)
+        {
+            return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+        }
+    }
+    private static global::System.Attribute[] __Attributes_0(int groupIndex)
+    {
+        return new global::System.Attribute[]
+        {
+            new global::TUnit.Core.TestAttribute(),
+            new global::TUnit.Core.GenerateGenericTestAttribute(typeof(global::System.Tuple<int, string>)),
+            new global::TUnit.Core.MethodDataSourceAttribute("Rows")
+        };
+    }
+    public static readonly global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.WholeReferenceTupleSourceTests>[] Entries_0 = new global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.WholeReferenceTupleSourceTests>[]
+    {
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.WholeReferenceTupleSourceTests>(
+            methodName: "WholeRow<Tuple<int, string>>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.WholeReferenceTupleSourceTests.WholeRow<Tuple<int, string>>",
+            methodTypeArgumentsIdentity: "<global::System.Tuple<int, string>>",
+            filePath: "",
+            lineNumber: 97,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("Rows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.WholeReferenceTupleSourceTests.Rows()),
+    },
+},
+            methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple<int, string>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple<int, string>)) } } },
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 0,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 0),
+    };
+}
+internal static partial class TUnit_TestRegistration
+{
+    static readonly int _r_TUnit_TestProject_Bugs__7638_WholeReferenceTupleSourceTests_WholeRow__T_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries<global::TUnit.TestProject.Bugs._7638.WholeReferenceTupleSourceTests>(static () => TUnit_TestProject_Bugs__7638_WholeReferenceTupleSourceTests_WholeRow__T_TestSource.Entries_0);
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute]
+[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")]
+internal static class TUnit_TestProject_Bugs__7638_InferredReferenceTupleSourceTests_Element__T_TestSource
+{
+    private static readonly global::TUnit.Core.ClassMetadata __classMetadata =     global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7638.InferredReferenceTupleSourceTests", new global::TUnit.Core.ClassMetadata
+    {
+        Type = typeof(global::TUnit.TestProject.Bugs._7638.InferredReferenceTupleSourceTests),
+        TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7638.InferredReferenceTupleSourceTests)),
+        Name = "InferredReferenceTupleSourceTests",
+        Namespace = "TUnit.TestProject.Bugs._7638",
+        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"),
+        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+        Parent = null
+    });
+    private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7638.InferredReferenceTupleSourceTests);
+    private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Element", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7638.InferredReferenceTupleSourceTests), "Element", false, 1, new global::TUnit.Core.ParameterMetadata[]
+{
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "value", new global::TUnit.Core.GenericParameter(0, true, "T"), false)
+}));
+    private static global::TUnit.TestProject.Bugs._7638.InferredReferenceTupleSourceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args)
+    {
+        return new global::TUnit.TestProject.Bugs._7638.InferredReferenceTupleSourceTests();
+    }
+    private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7638.InferredReferenceTupleSourceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken)
+    {
+        try
+        {
+            instance.Element<int>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[0]));
+            return default(global::System.Threading.Tasks.ValueTask);
+        }
+        catch (global::System.Exception ex)
+        {
+            return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+        }
+    }
+    private static global::System.Attribute[] __Attributes_0(int groupIndex)
+    {
+        return new global::System.Attribute[]
+        {
+            new global::TUnit.Core.TestAttribute(),
+            new global::TUnit.Core.MethodDataSourceAttribute("Rows")
+        };
+    }
+    public static readonly global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.InferredReferenceTupleSourceTests>[] Entries_0 = new global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.InferredReferenceTupleSourceTests>[]
+    {
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.InferredReferenceTupleSourceTests>(
+            methodName: "Element<int>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.InferredReferenceTupleSourceTests.Element<int>",
+            methodTypeArgumentsIdentity: "<int>",
+            filePath: "",
+            lineNumber: 111,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("Rows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.InferredReferenceTupleSourceTests.Rows()),
+    },
+},
+            methodMetadata: __mm_0,
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 0,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 0),
+    };
+}
+internal static partial class TUnit_TestRegistration
+{
+    static readonly int _r_TUnit_TestProject_Bugs__7638_InferredReferenceTupleSourceTests_Element__T_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries<global::TUnit.TestProject.Bugs._7638.InferredReferenceTupleSourceTests>(static () => TUnit_TestProject_Bugs__7638_InferredReferenceTupleSourceTests_Element__T_TestSource.Entries_0);
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute]
+[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")]
+internal static class TUnit_TestProject_Bugs__7638_WholeTupleWithTrailingParametersTests_ValueOptional___T___625D2367_TestSource
+{
+    private static readonly global::TUnit.Core.ClassMetadata __classMetadata =     global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests", new global::TUnit.Core.ClassMetadata
+    {
+        Type = typeof(global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests),
+        TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests)),
+        Name = "WholeTupleWithTrailingParametersTests",
+        Namespace = "TUnit.TestProject.Bugs._7638",
+        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"),
+        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+        Parent = null
+    });
+    private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests);
+    private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ValueOptional", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests), "ValueOptional", false, 1, new global::TUnit.Core.ParameterMetadata[]
+{
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false),
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int), "extra", new global::TUnit.Core.ConcreteType(typeof(int)), false)
+}));
+    private static global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args)
+    {
+        return new global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests();
+    }
+    private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken)
+    {
+        try
+        {
+            if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList<object> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0]))
+            {
+                var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]);
+                args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleElements[1])) };
+            }
+            switch (args.Length)
+            {
+                case 1:
+                    {
+                        instance.ValueOptional<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), (int)(5));
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 2:
+                    {
+                        instance.ValueOptional<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]));
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                default:
+                    throw new global::System.ArgumentException($"Expected between 1 and 2 arguments, but got {args.Length}");
+            }
+        }
+        catch (global::System.Exception ex)
+        {
+            return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+        }
+    }
+    private static global::System.Attribute[] __Attributes_0(int groupIndex)
+    {
+        return new global::System.Attribute[]
+        {
+            new global::TUnit.Core.TestAttribute(),
+            new global::TUnit.Core.MethodDataSourceAttribute("ValueRows")
+        };
+    }
+    public static readonly global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests>[] Entries_0 = new global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests>[]
+    {
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests>(
+            methodName: "ValueOptional<int>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests.ValueOptional<int>",
+            methodTypeArgumentsIdentity: "<int>",
+            filePath: "",
+            lineNumber: 125,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("ValueRows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests.ValueRows()),
+    },
+},
+            methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple<int, string>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple<int, string>)) }, __mm_0.Parameters[1] with { Type = typeof(int), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int)) } } },
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 0,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 0),
+    };
+}
+internal static partial class TUnit_TestRegistration
+{
+    static readonly int _r_TUnit_TestProject_Bugs__7638_WholeTupleWithTrailingParametersTests_ValueOptional___T___625D2367_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries<global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests>(static () => TUnit_TestProject_Bugs__7638_WholeTupleWithTrailingParametersTests_ValueOptional___T___625D2367_TestSource.Entries_0);
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute]
+[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")]
+internal static class TUnit_TestProject_Bugs__7638_WholeTupleWithTrailingParametersTests_ValueParams___T__st_23AB006F_TestSource
+{
+    private static readonly global::TUnit.Core.ClassMetadata __classMetadata =     global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests", new global::TUnit.Core.ClassMetadata
+    {
+        Type = typeof(global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests),
+        TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests)),
+        Name = "WholeTupleWithTrailingParametersTests",
+        Namespace = "TUnit.TestProject.Bugs._7638",
+        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"),
+        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+        Parent = null
+    });
+    private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests);
+    private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ValueParams", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests), "ValueParams", false, 1, new global::TUnit.Core.ParameterMetadata[]
+{
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false),
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int[]), "extra", new global::TUnit.Core.ConcreteType(typeof(int[])), false)
+}));
+    private static global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args)
+    {
+        return new global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests();
+    }
+    private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken)
+    {
+        try
+        {
+            if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList<object> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0]))
+            {
+                var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]);
+                args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleElements[1])) };
+            }
+            switch (args.Length)
+            {
+                case 1:
+                    {
+                        instance.ValueParams<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), global::System.Array.Empty<int>());
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 2:
+                    {
+                        instance.ValueParams<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), (args[1] is null ? null : args[1] is int[] arr ? arr : global::TUnit.Core.Helpers.CastHelper.ToTrailingArray<int>(args[1])));
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 3:
+                    {
+                        instance.ValueParams<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 4:
+                    {
+                        instance.ValueParams<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 5:
+                    {
+                        instance.ValueParams<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[4]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 6:
+                    {
+                        instance.ValueParams<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[4]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[5]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 7:
+                    {
+                        instance.ValueParams<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[4]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[5]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[6]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                default:
+                    if (args.Length < 1)
+                    {
+                        throw new global::System.ArgumentException($"Expected at least 1 argument, but got {args.Length}");
+                    }
+                    instance.ValueParams<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), (args.Length > 1 ? global::System.Linq.Enumerable.ToArray(global::System.Linq.Enumerable.Select(global::System.Linq.Enumerable.Range(1, args.Length - 1), i => global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[i]))) : global::System.Array.Empty<int>()));
+                    return default(global::System.Threading.Tasks.ValueTask);
+            }
+        }
+        catch (global::System.Exception ex)
+        {
+            return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+        }
+    }
+    private static global::System.Attribute[] __Attributes_0(int groupIndex)
+    {
+        return new global::System.Attribute[]
+        {
+            new global::TUnit.Core.TestAttribute(),
+            new global::TUnit.Core.MethodDataSourceAttribute("ValueRows")
+        };
+    }
+    public static readonly global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests>[] Entries_0 = new global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests>[]
+    {
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests>(
+            methodName: "ValueParams<int>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests.ValueParams<int>",
+            methodTypeArgumentsIdentity: "<int>",
+            filePath: "",
+            lineNumber: 133,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("ValueRows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests.ValueRows()),
+    },
+},
+            methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple<int, string>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple<int, string>)) }, __mm_0.Parameters[1] with { Type = typeof(int[]), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int[])) } } },
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 0,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 0),
+    };
+}
+internal static partial class TUnit_TestRegistration
+{
+    static readonly int _r_TUnit_TestProject_Bugs__7638_WholeTupleWithTrailingParametersTests_ValueParams___T__st_23AB006F_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries<global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests>(static () => TUnit_TestProject_Bugs__7638_WholeTupleWithTrailingParametersTests_ValueParams___T__st_23AB006F_TestSource.Entries_0);
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute]
+[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")]
+internal static class TUnit_TestProject_Bugs__7638_WholeTupleWithTrailingParametersTests_ValueArray___T__str_67B8B3E2_TestSource
+{
+    private static readonly global::TUnit.Core.ClassMetadata __classMetadata =     global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests", new global::TUnit.Core.ClassMetadata
+    {
+        Type = typeof(global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests),
+        TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests)),
+        Name = "WholeTupleWithTrailingParametersTests",
+        Namespace = "TUnit.TestProject.Bugs._7638",
+        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"),
+        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+        Parent = null
+    });
+    private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests);
+    private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ValueArray", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests), "ValueArray", false, 1, new global::TUnit.Core.ParameterMetadata[]
+{
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false),
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int[]), "extra", new global::TUnit.Core.ConcreteType(typeof(int[])), false)
+}));
+    private static global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args)
+    {
+        return new global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests();
+    }
+    private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken)
+    {
+        try
+        {
+            if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList<object> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0]))
+            {
+                var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]);
+                args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleElements[1])) };
+            }
+            switch (args.Length)
+            {
+                case 1:
+                    {
+                        instance.ValueArray<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), global::System.Array.Empty<int>());
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 2:
+                    {
+                        instance.ValueArray<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), (args[1] is null ? null : args[1] is int[] arr ? arr : global::TUnit.Core.Helpers.CastHelper.ToTrailingArray<int>(args[1])));
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 3:
+                    {
+                        instance.ValueArray<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 4:
+                    {
+                        instance.ValueArray<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 5:
+                    {
+                        instance.ValueArray<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[4]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 6:
+                    {
+                        instance.ValueArray<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[4]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[5]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 7:
+                    {
+                        instance.ValueArray<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[4]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[5]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[6]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                default:
+                    if (args.Length < 1)
+                    {
+                        throw new global::System.ArgumentException($"Expected at least 1 argument, but got {args.Length}");
+                    }
+                    instance.ValueArray<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), (args.Length > 1 ? global::System.Linq.Enumerable.ToArray(global::System.Linq.Enumerable.Select(global::System.Linq.Enumerable.Range(1, args.Length - 1), i => global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[i]))) : global::System.Array.Empty<int>()));
+                    return default(global::System.Threading.Tasks.ValueTask);
+            }
+        }
+        catch (global::System.Exception ex)
+        {
+            return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+        }
+    }
+    private static global::System.Attribute[] __Attributes_0(int groupIndex)
+    {
+        return new global::System.Attribute[]
+        {
+            new global::TUnit.Core.TestAttribute(),
+            new global::TUnit.Core.MethodDataSourceAttribute("ValueRows")
+        };
+    }
+    public static readonly global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests>[] Entries_0 = new global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests>[]
+    {
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests>(
+            methodName: "ValueArray<int>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests.ValueArray<int>",
+            methodTypeArgumentsIdentity: "<int>",
+            filePath: "",
+            lineNumber: 141,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("ValueRows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests.ValueRows()),
+    },
+},
+            methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple<int, string>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple<int, string>)) }, __mm_0.Parameters[1] with { Type = typeof(int[]), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int[])) } } },
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 0,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 0),
+    };
+}
+internal static partial class TUnit_TestRegistration
+{
+    static readonly int _r_TUnit_TestProject_Bugs__7638_WholeTupleWithTrailingParametersTests_ValueArray___T__str_67B8B3E2_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries<global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests>(static () => TUnit_TestProject_Bugs__7638_WholeTupleWithTrailingParametersTests_ValueArray___T__str_67B8B3E2_TestSource.Entries_0);
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute]
+[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")]
+internal static class TUnit_TestProject_Bugs__7638_WholeTupleWithTrailingParametersTests_ReferenceOptional___314B5759_TestSource
+{
+    private static readonly global::TUnit.Core.ClassMetadata __classMetadata =     global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests", new global::TUnit.Core.ClassMetadata
+    {
+        Type = typeof(global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests),
+        TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests)),
+        Name = "WholeTupleWithTrailingParametersTests",
+        Namespace = "TUnit.TestProject.Bugs._7638",
+        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"),
+        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+        Parent = null
+    });
+    private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests);
+    private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ReferenceOptional", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests), "ReferenceOptional", false, 1, new global::TUnit.Core.ParameterMetadata[]
+{
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false),
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int), "extra", new global::TUnit.Core.ConcreteType(typeof(int)), false)
+}));
+    private static global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args)
+    {
+        return new global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests();
+    }
+    private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken)
+    {
+        try
+        {
+            if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList<object> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0]))
+            {
+                var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]);
+                args = new object[] { new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleElements[1])) };
+            }
+            switch (args.Length)
+            {
+                case 1:
+                    {
+                        instance.ReferenceOptional<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<int, string>)new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int, string>>(__tupleFallback0) }), (int)(5));
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 2:
+                    {
+                        instance.ReferenceOptional<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<int, string>)new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int, string>>(__tupleFallback0) }), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]));
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                default:
+                    throw new global::System.ArgumentException($"Expected between 1 and 2 arguments, but got {args.Length}");
+            }
+        }
+        catch (global::System.Exception ex)
+        {
+            return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+        }
+    }
+    private static global::System.Attribute[] __Attributes_0(int groupIndex)
+    {
+        return new global::System.Attribute[]
+        {
+            new global::TUnit.Core.TestAttribute(),
+            new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows")
+        };
+    }
+    public static readonly global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests>[] Entries_0 = new global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests>[]
+    {
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests>(
+            methodName: "ReferenceOptional<int>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests.ReferenceOptional<int>",
+            methodTypeArgumentsIdentity: "<int>",
+            filePath: "",
+            lineNumber: 149,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests.ReferenceRows()),
+    },
+},
+            methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple<int, string>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple<int, string>)) }, __mm_0.Parameters[1] with { Type = typeof(int), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int)) } } },
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 0,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 0),
+    };
+}
+internal static partial class TUnit_TestRegistration
+{
+    static readonly int _r_TUnit_TestProject_Bugs__7638_WholeTupleWithTrailingParametersTests_ReferenceOptional___314B5759_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries<global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests>(static () => TUnit_TestProject_Bugs__7638_WholeTupleWithTrailingParametersTests_ReferenceOptional___314B5759_TestSource.Entries_0);
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute]
+[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")]
+internal static class TUnit_TestProject_Bugs__7638_WholeTupleWithTrailingParametersTests_ReferenceParams__Tu_62E96A1D_TestSource
+{
+    private static readonly global::TUnit.Core.ClassMetadata __classMetadata =     global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests", new global::TUnit.Core.ClassMetadata
+    {
+        Type = typeof(global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests),
+        TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests)),
+        Name = "WholeTupleWithTrailingParametersTests",
+        Namespace = "TUnit.TestProject.Bugs._7638",
+        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"),
+        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+        Parent = null
+    });
+    private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests);
+    private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ReferenceParams", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests), "ReferenceParams", false, 1, new global::TUnit.Core.ParameterMetadata[]
+{
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false),
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int[]), "extra", new global::TUnit.Core.ConcreteType(typeof(int[])), false)
+}));
+    private static global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args)
+    {
+        return new global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests();
+    }
+    private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken)
+    {
+        try
+        {
+            if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList<object> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0]))
+            {
+                var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]);
+                args = new object[] { new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleElements[1])) };
+            }
+            switch (args.Length)
+            {
+                case 1:
+                    {
+                        instance.ReferenceParams<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<int, string>)new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int, string>>(__tupleFallback0) }), global::System.Array.Empty<int>());
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 2:
+                    {
+                        instance.ReferenceParams<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<int, string>)new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int, string>>(__tupleFallback0) }), (args[1] is null ? null : args[1] is int[] arr ? arr : global::TUnit.Core.Helpers.CastHelper.ToTrailingArray<int>(args[1])));
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 3:
+                    {
+                        instance.ReferenceParams<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<int, string>)new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 4:
+                    {
+                        instance.ReferenceParams<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<int, string>)new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 5:
+                    {
+                        instance.ReferenceParams<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<int, string>)new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[4]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 6:
+                    {
+                        instance.ReferenceParams<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<int, string>)new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[4]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[5]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 7:
+                    {
+                        instance.ReferenceParams<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<int, string>)new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[4]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[5]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[6]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                default:
+                    if (args.Length < 1)
+                    {
+                        throw new global::System.ArgumentException($"Expected at least 1 argument, but got {args.Length}");
+                    }
+                    instance.ReferenceParams<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<int, string>)new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int, string>>(__tupleFallback0) }), (args.Length > 1 ? global::System.Linq.Enumerable.ToArray(global::System.Linq.Enumerable.Select(global::System.Linq.Enumerable.Range(1, args.Length - 1), i => global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[i]))) : global::System.Array.Empty<int>()));
+                    return default(global::System.Threading.Tasks.ValueTask);
+            }
+        }
+        catch (global::System.Exception ex)
+        {
+            return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+        }
+    }
+    private static global::System.Attribute[] __Attributes_0(int groupIndex)
+    {
+        return new global::System.Attribute[]
+        {
+            new global::TUnit.Core.TestAttribute(),
+            new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows")
+        };
+    }
+    public static readonly global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests>[] Entries_0 = new global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests>[]
+    {
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests>(
+            methodName: "ReferenceParams<int>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests.ReferenceParams<int>",
+            methodTypeArgumentsIdentity: "<int>",
+            filePath: "",
+            lineNumber: 157,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests.ReferenceRows()),
+    },
+},
+            methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple<int, string>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple<int, string>)) }, __mm_0.Parameters[1] with { Type = typeof(int[]), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int[])) } } },
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 0,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 0),
+    };
+}
+internal static partial class TUnit_TestRegistration
+{
+    static readonly int _r_TUnit_TestProject_Bugs__7638_WholeTupleWithTrailingParametersTests_ReferenceParams__Tu_62E96A1D_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries<global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests>(static () => TUnit_TestProject_Bugs__7638_WholeTupleWithTrailingParametersTests_ReferenceParams__Tu_62E96A1D_TestSource.Entries_0);
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute]
+[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")]
+internal static class TUnit_TestProject_Bugs__7638_WholeTupleWithTrailingParametersTests_ReferenceArray__Tup_F0E8AE3E_TestSource
+{
+    private static readonly global::TUnit.Core.ClassMetadata __classMetadata =     global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests", new global::TUnit.Core.ClassMetadata
+    {
+        Type = typeof(global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests),
+        TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests)),
+        Name = "WholeTupleWithTrailingParametersTests",
+        Namespace = "TUnit.TestProject.Bugs._7638",
+        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"),
+        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+        Parent = null
+    });
+    private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests);
+    private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ReferenceArray", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests), "ReferenceArray", false, 1, new global::TUnit.Core.ParameterMetadata[]
+{
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false),
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int[]), "extra", new global::TUnit.Core.ConcreteType(typeof(int[])), false)
+}));
+    private static global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args)
+    {
+        return new global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests();
+    }
+    private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken)
+    {
+        try
+        {
+            if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList<object> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0]))
+            {
+                var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]);
+                args = new object[] { new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleElements[1])) };
+            }
+            switch (args.Length)
+            {
+                case 1:
+                    {
+                        instance.ReferenceArray<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<int, string>)new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int, string>>(__tupleFallback0) }), global::System.Array.Empty<int>());
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 2:
+                    {
+                        instance.ReferenceArray<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<int, string>)new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int, string>>(__tupleFallback0) }), (args[1] is null ? null : args[1] is int[] arr ? arr : global::TUnit.Core.Helpers.CastHelper.ToTrailingArray<int>(args[1])));
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 3:
+                    {
+                        instance.ReferenceArray<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<int, string>)new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 4:
+                    {
+                        instance.ReferenceArray<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<int, string>)new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 5:
+                    {
+                        instance.ReferenceArray<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<int, string>)new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[4]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 6:
+                    {
+                        instance.ReferenceArray<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<int, string>)new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[4]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[5]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 7:
+                    {
+                        instance.ReferenceArray<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<int, string>)new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[4]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[5]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[6]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                default:
+                    if (args.Length < 1)
+                    {
+                        throw new global::System.ArgumentException($"Expected at least 1 argument, but got {args.Length}");
+                    }
+                    instance.ReferenceArray<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<int, string>)new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int, string>>(__tupleFallback0) }), (args.Length > 1 ? global::System.Linq.Enumerable.ToArray(global::System.Linq.Enumerable.Select(global::System.Linq.Enumerable.Range(1, args.Length - 1), i => global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[i]))) : global::System.Array.Empty<int>()));
+                    return default(global::System.Threading.Tasks.ValueTask);
+            }
+        }
+        catch (global::System.Exception ex)
+        {
+            return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+        }
+    }
+    private static global::System.Attribute[] __Attributes_0(int groupIndex)
+    {
+        return new global::System.Attribute[]
+        {
+            new global::TUnit.Core.TestAttribute(),
+            new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows")
+        };
+    }
+    public static readonly global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests>[] Entries_0 = new global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests>[]
+    {
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests>(
+            methodName: "ReferenceArray<int>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests.ReferenceArray<int>",
+            methodTypeArgumentsIdentity: "<int>",
+            filePath: "",
+            lineNumber: 165,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests.ReferenceRows()),
+    },
+},
+            methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple<int, string>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple<int, string>)) }, __mm_0.Parameters[1] with { Type = typeof(int[]), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int[])) } } },
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 0,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 0),
+    };
+}
+internal static partial class TUnit_TestRegistration
+{
+    static readonly int _r_TUnit_TestProject_Bugs__7638_WholeTupleWithTrailingParametersTests_ReferenceArray__Tup_F0E8AE3E_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries<global::TUnit.TestProject.Bugs._7638.WholeTupleWithTrailingParametersTests>(static () => TUnit_TestProject_Bugs__7638_WholeTupleWithTrailingParametersTests_ReferenceArray__Tup_F0E8AE3E_TestSource.Entries_0);
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute]
+[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")]
+internal static class TUnit_TestProject_Bugs__7638_ExplicitWholeTupleInferenceTests_Optional___T__string__int_TestSource
+{
+    private static readonly global::TUnit.Core.ClassMetadata __classMetadata =     global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests", new global::TUnit.Core.ClassMetadata
+    {
+        Type = typeof(global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests),
+        TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests)),
+        Name = "ExplicitWholeTupleInferenceTests",
+        Namespace = "TUnit.TestProject.Bugs._7638",
+        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"),
+        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+        Parent = null
+    });
+    private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests);
+    private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Optional", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests), "Optional", false, 1, new global::TUnit.Core.ParameterMetadata[]
+{
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false),
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int), "extra", new global::TUnit.Core.ConcreteType(typeof(int)), false)
+}));
+    private static global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args)
+    {
+        return new global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests();
+    }
+    private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken)
+    {
+        switch (methodIndex)
+        {
+            case 0:
+            {
+                try
+                {
+                    if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList<object> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0]))
+                    {
+                        var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]);
+                        args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleElements[1])) };
+                    }
+                    switch (args.Length)
+                    {
+                        case 1:
+                            {
+                                instance.Optional<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), (int)(5));
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        case 2:
+                            {
+                                instance.Optional<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]));
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        default:
+                            throw new global::System.ArgumentException($"Expected between 1 and 2 arguments, but got {args.Length}");
+                    }
+                }
+                catch (global::System.Exception ex)
+                {
+                    return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+                }
+            }
+            case 1:
+            {
+                try
+                {
+                    if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList<object> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0]))
+                    {
+                        var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]);
+                        args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast<long>(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleElements[1])) };
+                    }
+                    switch (args.Length)
+                    {
+                        case 1:
+                            {
+                                instance.Optional<long>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<long, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<long, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<long>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<long, string>>(__tupleFallback0) }), (int)(5));
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        case 2:
+                            {
+                                instance.Optional<long>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<long, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<long, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<long>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<long, string>>(__tupleFallback0) }), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]));
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        default:
+                            throw new global::System.ArgumentException($"Expected between 1 and 2 arguments, but got {args.Length}");
+                    }
+                }
+                catch (global::System.Exception ex)
+                {
+                    return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+                }
+            }
+            default:
+                throw new global::System.ArgumentOutOfRangeException(nameof(methodIndex));
+        }
+    }
+    private static global::System.Attribute[] __Attributes_0(int groupIndex)
+    {
+        switch (groupIndex)
+        {
+            case 0:
+            {
+                return new global::System.Attribute[]
+                {
+                    new global::TUnit.Core.TestAttribute(),
+                    new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)),
+                    new global::TUnit.Core.MethodDataSourceAttribute("Rows")
+                };
+            }
+            case 1:
+            {
+                return new global::System.Attribute[]
+                {
+                    new global::TUnit.Core.TestAttribute(),
+                    new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)),
+                    new global::TUnit.Core.MethodDataSourceAttribute("Rows")
+                };
+            }
+            default:
+                throw new global::System.ArgumentOutOfRangeException(nameof(groupIndex));
+        }
+    }
+    public static readonly global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests>[] Entries_0 = new global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests>[]
+    {
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests>(
+            methodName: "Optional<int>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests.Optional<int>",
+            methodTypeArgumentsIdentity: "<int>",
+            filePath: "",
+            lineNumber: 179,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("Rows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests.Rows()),
+    },
+},
+            methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple<int, string>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple<int, string>)) }, __mm_0.Parameters[1] with { Type = typeof(int), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int)) } } },
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 0,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 0),
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests>(
+            methodName: "Optional<long>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests.Optional<long>",
+            methodTypeArgumentsIdentity: "<long>",
+            filePath: "",
+            lineNumber: 179,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("Rows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests.Rows()),
+    },
+},
+            methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple<long, string>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple<long, string>)) }, __mm_0.Parameters[1] with { Type = typeof(int), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int)) } } },
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 1,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 1),
+    };
+}
+internal static partial class TUnit_TestRegistration
+{
+    static readonly int _r_TUnit_TestProject_Bugs__7638_ExplicitWholeTupleInferenceTests_Optional___T__string__int_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries<global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests>(static () => TUnit_TestProject_Bugs__7638_ExplicitWholeTupleInferenceTests_Optional___T__string__int_TestSource.Entries_0);
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute]
+[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")]
+internal static class TUnit_TestProject_Bugs__7638_ExplicitWholeTupleInferenceTests_Params___T__string__int___TestSource
+{
+    private static readonly global::TUnit.Core.ClassMetadata __classMetadata =     global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests", new global::TUnit.Core.ClassMetadata
+    {
+        Type = typeof(global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests),
+        TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests)),
+        Name = "ExplicitWholeTupleInferenceTests",
+        Namespace = "TUnit.TestProject.Bugs._7638",
+        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"),
+        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+        Parent = null
+    });
+    private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests);
+    private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Params", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests), "Params", false, 1, new global::TUnit.Core.ParameterMetadata[]
+{
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false),
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int[]), "extra", new global::TUnit.Core.ConcreteType(typeof(int[])), false)
+}));
+    private static global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args)
+    {
+        return new global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests();
+    }
+    private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken)
+    {
+        switch (methodIndex)
+        {
+            case 0:
+            {
+                try
+                {
+                    if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList<object> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0]))
+                    {
+                        var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]);
+                        args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleElements[1])) };
+                    }
+                    switch (args.Length)
+                    {
+                        case 1:
+                            {
+                                instance.Params<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), global::System.Array.Empty<int>());
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        case 2:
+                            {
+                                instance.Params<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), (args[1] is null ? null : args[1] is int[] arr ? arr : global::TUnit.Core.Helpers.CastHelper.ToTrailingArray<int>(args[1])));
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        case 3:
+                            {
+                                instance.Params<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]) });
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        case 4:
+                            {
+                                instance.Params<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]) });
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        case 5:
+                            {
+                                instance.Params<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[4]) });
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        case 6:
+                            {
+                                instance.Params<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[4]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[5]) });
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        case 7:
+                            {
+                                instance.Params<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[4]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[5]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[6]) });
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        default:
+                            if (args.Length < 1)
+                            {
+                                throw new global::System.ArgumentException($"Expected at least 1 argument, but got {args.Length}");
+                            }
+                            instance.Params<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), (args.Length > 1 ? global::System.Linq.Enumerable.ToArray(global::System.Linq.Enumerable.Select(global::System.Linq.Enumerable.Range(1, args.Length - 1), i => global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[i]))) : global::System.Array.Empty<int>()));
+                            return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                }
+                catch (global::System.Exception ex)
+                {
+                    return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+                }
+            }
+            case 1:
+            {
+                try
+                {
+                    if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList<object> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0]))
+                    {
+                        var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]);
+                        args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast<long>(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleElements[1])) };
+                    }
+                    switch (args.Length)
+                    {
+                        case 1:
+                            {
+                                instance.Params<long>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<long, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<long, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<long>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<long, string>>(__tupleFallback0) }), global::System.Array.Empty<int>());
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        case 2:
+                            {
+                                instance.Params<long>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<long, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<long, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<long>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<long, string>>(__tupleFallback0) }), (args[1] is null ? null : args[1] is int[] arr ? arr : global::TUnit.Core.Helpers.CastHelper.ToTrailingArray<int>(args[1])));
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        case 3:
+                            {
+                                instance.Params<long>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<long, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<long, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<long>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<long, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]) });
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        case 4:
+                            {
+                                instance.Params<long>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<long, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<long, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<long>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<long, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]) });
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        case 5:
+                            {
+                                instance.Params<long>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<long, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<long, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<long>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<long, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[4]) });
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        case 6:
+                            {
+                                instance.Params<long>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<long, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<long, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<long>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<long, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[4]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[5]) });
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        case 7:
+                            {
+                                instance.Params<long>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<long, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<long, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<long>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<long, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[4]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[5]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[6]) });
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        default:
+                            if (args.Length < 1)
+                            {
+                                throw new global::System.ArgumentException($"Expected at least 1 argument, but got {args.Length}");
+                            }
+                            instance.Params<long>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<long, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<long, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<long>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<long, string>>(__tupleFallback0) }), (args.Length > 1 ? global::System.Linq.Enumerable.ToArray(global::System.Linq.Enumerable.Select(global::System.Linq.Enumerable.Range(1, args.Length - 1), i => global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[i]))) : global::System.Array.Empty<int>()));
+                            return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                }
+                catch (global::System.Exception ex)
+                {
+                    return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+                }
+            }
+            default:
+                throw new global::System.ArgumentOutOfRangeException(nameof(methodIndex));
+        }
+    }
+    private static global::System.Attribute[] __Attributes_0(int groupIndex)
+    {
+        switch (groupIndex)
+        {
+            case 0:
+            {
+                return new global::System.Attribute[]
+                {
+                    new global::TUnit.Core.TestAttribute(),
+                    new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)),
+                    new global::TUnit.Core.MethodDataSourceAttribute("Rows")
+                };
+            }
+            case 1:
+            {
+                return new global::System.Attribute[]
+                {
+                    new global::TUnit.Core.TestAttribute(),
+                    new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)),
+                    new global::TUnit.Core.MethodDataSourceAttribute("Rows")
+                };
+            }
+            default:
+                throw new global::System.ArgumentOutOfRangeException(nameof(groupIndex));
+        }
+    }
+    public static readonly global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests>[] Entries_0 = new global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests>[]
+    {
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests>(
+            methodName: "Params<int>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests.Params<int>",
+            methodTypeArgumentsIdentity: "<int>",
+            filePath: "",
+            lineNumber: 186,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("Rows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests.Rows()),
+    },
+},
+            methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple<int, string>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple<int, string>)) }, __mm_0.Parameters[1] with { Type = typeof(int[]), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int[])) } } },
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 0,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 0),
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests>(
+            methodName: "Params<long>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests.Params<long>",
+            methodTypeArgumentsIdentity: "<long>",
+            filePath: "",
+            lineNumber: 186,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("Rows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests.Rows()),
+    },
+},
+            methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple<long, string>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple<long, string>)) }, __mm_0.Parameters[1] with { Type = typeof(int[]), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int[])) } } },
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 1,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 1),
+    };
+}
+internal static partial class TUnit_TestRegistration
+{
+    static readonly int _r_TUnit_TestProject_Bugs__7638_ExplicitWholeTupleInferenceTests_Params___T__string__int___TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries<global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests>(static () => TUnit_TestProject_Bugs__7638_ExplicitWholeTupleInferenceTests_Params___T__string__int___TestSource.Entries_0);
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute]
+[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")]
+internal static class TUnit_TestProject_Bugs__7638_ExplicitWholeTupleInferenceTests_Array___T__string__int___TestSource
+{
+    private static readonly global::TUnit.Core.ClassMetadata __classMetadata =     global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests", new global::TUnit.Core.ClassMetadata
+    {
+        Type = typeof(global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests),
+        TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests)),
+        Name = "ExplicitWholeTupleInferenceTests",
+        Namespace = "TUnit.TestProject.Bugs._7638",
+        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"),
+        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+        Parent = null
+    });
+    private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests);
+    private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Array", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests), "Array", false, 1, new global::TUnit.Core.ParameterMetadata[]
+{
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false),
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int[]), "extra", new global::TUnit.Core.ConcreteType(typeof(int[])), false)
+}));
+    private static global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args)
+    {
+        return new global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests();
+    }
+    private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken)
+    {
+        switch (methodIndex)
+        {
+            case 0:
+            {
+                try
+                {
+                    if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList<object> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0]))
+                    {
+                        var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]);
+                        args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleElements[1])) };
+                    }
+                    switch (args.Length)
+                    {
+                        case 1:
+                            {
+                                instance.Array<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), global::System.Array.Empty<int>());
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        case 2:
+                            {
+                                instance.Array<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), (args[1] is null ? null : args[1] is int[] arr ? arr : global::TUnit.Core.Helpers.CastHelper.ToTrailingArray<int>(args[1])));
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        case 3:
+                            {
+                                instance.Array<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]) });
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        case 4:
+                            {
+                                instance.Array<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]) });
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        case 5:
+                            {
+                                instance.Array<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[4]) });
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        case 6:
+                            {
+                                instance.Array<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[4]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[5]) });
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        case 7:
+                            {
+                                instance.Array<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[4]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[5]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[6]) });
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        default:
+                            if (args.Length < 1)
+                            {
+                                throw new global::System.ArgumentException($"Expected at least 1 argument, but got {args.Length}");
+                            }
+                            instance.Array<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), (args.Length > 1 ? global::System.Linq.Enumerable.ToArray(global::System.Linq.Enumerable.Select(global::System.Linq.Enumerable.Range(1, args.Length - 1), i => global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[i]))) : global::System.Array.Empty<int>()));
+                            return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                }
+                catch (global::System.Exception ex)
+                {
+                    return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+                }
+            }
+            case 1:
+            {
+                try
+                {
+                    if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList<object> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0]))
+                    {
+                        var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]);
+                        args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast<long>(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleElements[1])) };
+                    }
+                    switch (args.Length)
+                    {
+                        case 1:
+                            {
+                                instance.Array<long>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<long, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<long, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<long>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<long, string>>(__tupleFallback0) }), global::System.Array.Empty<int>());
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        case 2:
+                            {
+                                instance.Array<long>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<long, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<long, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<long>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<long, string>>(__tupleFallback0) }), (args[1] is null ? null : args[1] is int[] arr ? arr : global::TUnit.Core.Helpers.CastHelper.ToTrailingArray<int>(args[1])));
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        case 3:
+                            {
+                                instance.Array<long>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<long, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<long, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<long>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<long, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]) });
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        case 4:
+                            {
+                                instance.Array<long>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<long, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<long, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<long>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<long, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]) });
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        case 5:
+                            {
+                                instance.Array<long>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<long, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<long, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<long>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<long, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[4]) });
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        case 6:
+                            {
+                                instance.Array<long>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<long, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<long, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<long>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<long, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[4]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[5]) });
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        case 7:
+                            {
+                                instance.Array<long>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<long, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<long, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<long>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<long, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[4]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[5]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[6]) });
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        default:
+                            if (args.Length < 1)
+                            {
+                                throw new global::System.ArgumentException($"Expected at least 1 argument, but got {args.Length}");
+                            }
+                            instance.Array<long>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<long, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<long, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<long>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<long, string>>(__tupleFallback0) }), (args.Length > 1 ? global::System.Linq.Enumerable.ToArray(global::System.Linq.Enumerable.Select(global::System.Linq.Enumerable.Range(1, args.Length - 1), i => global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[i]))) : global::System.Array.Empty<int>()));
+                            return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                }
+                catch (global::System.Exception ex)
+                {
+                    return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+                }
+            }
+            default:
+                throw new global::System.ArgumentOutOfRangeException(nameof(methodIndex));
+        }
+    }
+    private static global::System.Attribute[] __Attributes_0(int groupIndex)
+    {
+        switch (groupIndex)
+        {
+            case 0:
+            {
+                return new global::System.Attribute[]
+                {
+                    new global::TUnit.Core.TestAttribute(),
+                    new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)),
+                    new global::TUnit.Core.MethodDataSourceAttribute("Rows")
+                };
+            }
+            case 1:
+            {
+                return new global::System.Attribute[]
+                {
+                    new global::TUnit.Core.TestAttribute(),
+                    new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)),
+                    new global::TUnit.Core.MethodDataSourceAttribute("Rows")
+                };
+            }
+            default:
+                throw new global::System.ArgumentOutOfRangeException(nameof(groupIndex));
+        }
+    }
+    public static readonly global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests>[] Entries_0 = new global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests>[]
+    {
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests>(
+            methodName: "Array<int>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests.Array<int>",
+            methodTypeArgumentsIdentity: "<int>",
+            filePath: "",
+            lineNumber: 193,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("Rows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests.Rows()),
+    },
+},
+            methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple<int, string>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple<int, string>)) }, __mm_0.Parameters[1] with { Type = typeof(int[]), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int[])) } } },
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 0,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 0),
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests>(
+            methodName: "Array<long>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests.Array<long>",
+            methodTypeArgumentsIdentity: "<long>",
+            filePath: "",
+            lineNumber: 193,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("Rows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests.Rows()),
+    },
+},
+            methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple<long, string>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple<long, string>)) }, __mm_0.Parameters[1] with { Type = typeof(int[]), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int[])) } } },
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 1,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 1),
+    };
+}
+internal static partial class TUnit_TestRegistration
+{
+    static readonly int _r_TUnit_TestProject_Bugs__7638_ExplicitWholeTupleInferenceTests_Array___T__string__int___TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries<global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests>(static () => TUnit_TestProject_Bugs__7638_ExplicitWholeTupleInferenceTests_Array___T__string__int___TestSource.Entries_0);
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute]
+[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")]
+internal static class TUnit_TestProject_Bugs__7638_ExplicitWholeTupleInferenceTests_Nested___T__string__int_TestSource
+{
+    private static readonly global::TUnit.Core.ClassMetadata __classMetadata =     global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests", new global::TUnit.Core.ClassMetadata
+    {
+        Type = typeof(global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests),
+        TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests)),
+        Name = "ExplicitWholeTupleInferenceTests",
+        Namespace = "TUnit.TestProject.Bugs._7638",
+        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"),
+        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+        Parent = null
+    });
+    private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests);
+    private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Nested", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests), "Nested", false, 1, new global::TUnit.Core.ParameterMetadata[]
+{
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false),
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int), "extra", new global::TUnit.Core.ConcreteType(typeof(int)), false)
+}));
+    private static global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args)
+    {
+        return new global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests();
+    }
+    private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken)
+    {
+        switch (methodIndex)
+        {
+            case 0:
+            {
+                try
+                {
+                    if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList<object> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0]))
+                    {
+                        var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]);
+                        args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleElements[1])) };
+                    }
+                    switch (args.Length)
+                    {
+                        case 1:
+                            {
+                                instance.Nested<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), (int)(5));
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        case 2:
+                            {
+                                instance.Nested<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]));
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        default:
+                            throw new global::System.ArgumentException($"Expected between 1 and 2 arguments, but got {args.Length}");
+                    }
+                }
+                catch (global::System.Exception ex)
+                {
+                    return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+                }
+            }
+            case 1:
+            {
+                try
+                {
+                    if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList<object> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0]))
+                    {
+                        var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]);
+                        args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast<long>(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleElements[1])) };
+                    }
+                    switch (args.Length)
+                    {
+                        case 1:
+                            {
+                                instance.Nested<long>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<long, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<long, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<long>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<long, string>>(__tupleFallback0) }), (int)(5));
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        case 2:
+                            {
+                                instance.Nested<long>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<long, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<long, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<long>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<long, string>>(__tupleFallback0) }), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]));
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        default:
+                            throw new global::System.ArgumentException($"Expected between 1 and 2 arguments, but got {args.Length}");
+                    }
+                }
+                catch (global::System.Exception ex)
+                {
+                    return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+                }
+            }
+            default:
+                throw new global::System.ArgumentOutOfRangeException(nameof(methodIndex));
+        }
+    }
+    private static global::System.Attribute[] __Attributes_0(int groupIndex)
+    {
+        switch (groupIndex)
+        {
+            case 0:
+            {
+                return new global::System.Attribute[]
+                {
+                    new global::TUnit.Core.TestAttribute(),
+                    new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)),
+                    new global::TUnit.Core.MethodDataSourceAttribute("NestedRows")
+                };
+            }
+            case 1:
+            {
+                return new global::System.Attribute[]
+                {
+                    new global::TUnit.Core.TestAttribute(),
+                    new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)),
+                    new global::TUnit.Core.MethodDataSourceAttribute("NestedRows")
+                };
+            }
+            default:
+                throw new global::System.ArgumentOutOfRangeException(nameof(groupIndex));
+        }
+    }
+    public static readonly global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests>[] Entries_0 = new global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests>[]
+    {
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests>(
+            methodName: "Nested<int>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests.Nested<int>",
+            methodTypeArgumentsIdentity: "<int>",
+            filePath: "",
+            lineNumber: 200,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("NestedRows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests.NestedRows()),
+    },
+},
+            methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple<int, string>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple<int, string>)) }, __mm_0.Parameters[1] with { Type = typeof(int), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int)) } } },
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 0,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 0),
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests>(
+            methodName: "Nested<long>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests.Nested<long>",
+            methodTypeArgumentsIdentity: "<long>",
+            filePath: "",
+            lineNumber: 200,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("NestedRows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests.NestedRows()),
+    },
+},
+            methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple<long, string>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple<long, string>)) }, __mm_0.Parameters[1] with { Type = typeof(int), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int)) } } },
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 1,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 1),
+    };
+}
+internal static partial class TUnit_TestRegistration
+{
+    static readonly int _r_TUnit_TestProject_Bugs__7638_ExplicitWholeTupleInferenceTests_Nested___T__string__int_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries<global::TUnit.TestProject.Bugs._7638.ExplicitWholeTupleInferenceTests>(static () => TUnit_TestProject_Bugs__7638_ExplicitWholeTupleInferenceTests_Nested___T__string__int_TestSource.Entries_0);
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute]
+[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")]
+internal static class TUnit_TestProject_Bugs__7638_ExplicitBareReferenceTupleInferenceTests_WholeRow__T_TestSource
+{
+    private static readonly global::TUnit.Core.ClassMetadata __classMetadata =     global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7638.ExplicitBareReferenceTupleInferenceTests", new global::TUnit.Core.ClassMetadata
+    {
+        Type = typeof(global::TUnit.TestProject.Bugs._7638.ExplicitBareReferenceTupleInferenceTests),
+        TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7638.ExplicitBareReferenceTupleInferenceTests)),
+        Name = "ExplicitBareReferenceTupleInferenceTests",
+        Namespace = "TUnit.TestProject.Bugs._7638",
+        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"),
+        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+        Parent = null
+    });
+    private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7638.ExplicitBareReferenceTupleInferenceTests);
+    private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("WholeRow", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7638.ExplicitBareReferenceTupleInferenceTests), "WholeRow", false, 1, new global::TUnit.Core.ParameterMetadata[]
+{
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.GenericParameter(0, true, "T"), false)
+}));
+    private static global::TUnit.TestProject.Bugs._7638.ExplicitBareReferenceTupleInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args)
+    {
+        return new global::TUnit.TestProject.Bugs._7638.ExplicitBareReferenceTupleInferenceTests();
+    }
+    private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7638.ExplicitBareReferenceTupleInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken)
+    {
+        try
+        {
+            // Special handling for single reference tuple parameter
+            if (args.Length == 2)
+            {
+                instance.WholeRow<global::System.Tuple<int, string>>(new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(args[1])));
+                return default(global::System.Threading.Tasks.ValueTask);
+            }
+            else
+            {
+                switch (args.Length)
+                {
+                    case 1:
+                        {
+                            instance.WholeRow<global::System.Tuple<int, string>>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<int, string>)new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int, string>>(__tupleFallback0) }));
+                            return default(global::System.Threading.Tasks.ValueTask);
+                        }
+                    default:
+                        throw new global::System.ArgumentException($"Expected exactly 1 argument, but got {args.Length}");
+                }
+            }
+        }
+        catch (global::System.Exception ex)
+        {
+            return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+        }
+    }
+    private static global::System.Attribute[] __Attributes_0(int groupIndex)
+    {
+        return new global::System.Attribute[]
+        {
+            new global::TUnit.Core.TestAttribute(),
+            new global::TUnit.Core.GenerateGenericTestAttribute(typeof(global::System.Tuple<int, string>)),
+            new global::TUnit.Core.MethodDataSourceAttribute("Rows")
+        };
+    }
+    public static readonly global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.ExplicitBareReferenceTupleInferenceTests>[] Entries_0 = new global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.ExplicitBareReferenceTupleInferenceTests>[]
+    {
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.ExplicitBareReferenceTupleInferenceTests>(
+            methodName: "WholeRow<Tuple<int, string>>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.ExplicitBareReferenceTupleInferenceTests.WholeRow<Tuple<int, string>>",
+            methodTypeArgumentsIdentity: "<global::System.Tuple<int, string>>",
+            filePath: "",
+            lineNumber: 212,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("Rows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.ExplicitBareReferenceTupleInferenceTests.Rows()),
+    },
+},
+            methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple<int, string>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple<int, string>)) } } },
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 0,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 0),
+    };
+}
+internal static partial class TUnit_TestRegistration
+{
+    static readonly int _r_TUnit_TestProject_Bugs__7638_ExplicitBareReferenceTupleInferenceTests_WholeRow__T_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries<global::TUnit.TestProject.Bugs._7638.ExplicitBareReferenceTupleInferenceTests>(static () => TUnit_TestProject_Bugs__7638_ExplicitBareReferenceTupleInferenceTests_WholeRow__T_TestSource.Entries_0);
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute]
+[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")]
+internal static class TUnit_TestProject_Bugs__7638_ExplicitDirectTupleInferenceTests_Value___T__string__TestSource
+{
+    private static readonly global::TUnit.Core.ClassMetadata __classMetadata =     global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7638.ExplicitDirectTupleInferenceTests", new global::TUnit.Core.ClassMetadata
+    {
+        Type = typeof(global::TUnit.TestProject.Bugs._7638.ExplicitDirectTupleInferenceTests),
+        TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7638.ExplicitDirectTupleInferenceTests)),
+        Name = "ExplicitDirectTupleInferenceTests",
+        Namespace = "TUnit.TestProject.Bugs._7638",
+        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"),
+        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+        Parent = null
+    });
+    private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7638.ExplicitDirectTupleInferenceTests);
+    private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Value", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7638.ExplicitDirectTupleInferenceTests), "Value", false, 1, new global::TUnit.Core.ParameterMetadata[]
+{
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false)
+}));
+    private static global::TUnit.TestProject.Bugs._7638.ExplicitDirectTupleInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args)
+    {
+        return new global::TUnit.TestProject.Bugs._7638.ExplicitDirectTupleInferenceTests();
+    }
+    private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7638.ExplicitDirectTupleInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken)
+    {
+        switch (methodIndex)
+        {
+            case 0:
+            {
+                try
+                {
+                    // Special handling for single tuple parameter
+                    if (args.Length == 2)
+                    {
+                        // Arguments are unwrapped tuple elements, reconstruct the tuple
+                        instance.Value<int>((global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(args[1])));
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                    else if (args.Length == 1 && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0]))
+                    {
+                        // Rare case: tuple is wrapped as a single argument
+                        instance.Value<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }));
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                    else
+                    {
+                        throw new global::System.ArgumentException($"Expected 2 unwrapped elements or 1 wrapped tuple, but got {args.Length} arguments");
+                    }
+                }
+                catch (global::System.Exception ex)
+                {
+                    return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+                }
+            }
+            case 1:
+            {
+                try
+                {
+                    // Special handling for single tuple parameter
+                    if (args.Length == 2)
+                    {
+                        // Arguments are unwrapped tuple elements, reconstruct the tuple
+                        instance.Value<long>((global::TUnit.Core.Helpers.CastHelper.Cast<long>(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(args[1])));
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                    else if (args.Length == 1 && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0]))
+                    {
+                        // Rare case: tuple is wrapped as a single argument
+                        instance.Value<long>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<long, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<long, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<long>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<long, string>>(__tupleFallback0) }));
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                    else
+                    {
+                        throw new global::System.ArgumentException($"Expected 2 unwrapped elements or 1 wrapped tuple, but got {args.Length} arguments");
+                    }
+                }
+                catch (global::System.Exception ex)
+                {
+                    return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+                }
+            }
+            default:
+                throw new global::System.ArgumentOutOfRangeException(nameof(methodIndex));
+        }
+    }
+    private static global::System.Attribute[] __Attributes_0(int groupIndex)
+    {
+        switch (groupIndex)
+        {
+            case 0:
+            {
+                return new global::System.Attribute[]
+                {
+                    new global::TUnit.Core.TestAttribute(),
+                    new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)),
+                    new global::TUnit.Core.MethodDataSourceAttribute("ValueRows")
+                };
+            }
+            case 1:
+            {
+                return new global::System.Attribute[]
+                {
+                    new global::TUnit.Core.TestAttribute(),
+                    new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)),
+                    new global::TUnit.Core.MethodDataSourceAttribute("ValueRows")
+                };
+            }
+            default:
+                throw new global::System.ArgumentOutOfRangeException(nameof(groupIndex));
+        }
+    }
+    public static readonly global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.ExplicitDirectTupleInferenceTests>[] Entries_0 = new global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.ExplicitDirectTupleInferenceTests>[]
+    {
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.ExplicitDirectTupleInferenceTests>(
+            methodName: "Value<int>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.ExplicitDirectTupleInferenceTests.Value<int>",
+            methodTypeArgumentsIdentity: "<int>",
+            filePath: "",
+            lineNumber: 225,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("ValueRows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.ExplicitDirectTupleInferenceTests.ValueRows()),
+    },
+},
+            methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple<int, string>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple<int, string>)) } } },
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 0,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 0),
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.ExplicitDirectTupleInferenceTests>(
+            methodName: "Value<long>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.ExplicitDirectTupleInferenceTests.Value<long>",
+            methodTypeArgumentsIdentity: "<long>",
+            filePath: "",
+            lineNumber: 225,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("ValueRows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.ExplicitDirectTupleInferenceTests.ValueRows()),
+    },
+},
+            methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple<long, string>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple<long, string>)) } } },
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 1,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 1),
+    };
+}
+internal static partial class TUnit_TestRegistration
+{
+    static readonly int _r_TUnit_TestProject_Bugs__7638_ExplicitDirectTupleInferenceTests_Value___T__string__TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries<global::TUnit.TestProject.Bugs._7638.ExplicitDirectTupleInferenceTests>(static () => TUnit_TestProject_Bugs__7638_ExplicitDirectTupleInferenceTests_Value___T__string__TestSource.Entries_0);
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute]
+[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")]
+internal static class TUnit_TestProject_Bugs__7638_ExplicitDirectTupleInferenceTests_Reference__Tuple_T__string__TestSource
+{
+    private static readonly global::TUnit.Core.ClassMetadata __classMetadata =     global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7638.ExplicitDirectTupleInferenceTests", new global::TUnit.Core.ClassMetadata
+    {
+        Type = typeof(global::TUnit.TestProject.Bugs._7638.ExplicitDirectTupleInferenceTests),
+        TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7638.ExplicitDirectTupleInferenceTests)),
+        Name = "ExplicitDirectTupleInferenceTests",
+        Namespace = "TUnit.TestProject.Bugs._7638",
+        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"),
+        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+        Parent = null
+    });
+    private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7638.ExplicitDirectTupleInferenceTests);
+    private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Reference", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7638.ExplicitDirectTupleInferenceTests), "Reference", false, 1, new global::TUnit.Core.ParameterMetadata[]
+{
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false)
+}));
+    private static global::TUnit.TestProject.Bugs._7638.ExplicitDirectTupleInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args)
+    {
+        return new global::TUnit.TestProject.Bugs._7638.ExplicitDirectTupleInferenceTests();
+    }
+    private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7638.ExplicitDirectTupleInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken)
+    {
+        switch (methodIndex)
+        {
+            case 0:
+            {
+                try
+                {
+                    // Special handling for single reference tuple parameter
+                    if (args.Length == 2)
+                    {
+                        instance.Reference<int>(new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(args[1])));
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                    else
+                    {
+                        switch (args.Length)
+                        {
+                            case 1:
+                                {
+                                    instance.Reference<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<int, string>)new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int, string>>(__tupleFallback0) }));
+                                    return default(global::System.Threading.Tasks.ValueTask);
+                                }
+                            default:
+                                throw new global::System.ArgumentException($"Expected exactly 1 argument, but got {args.Length}");
+                        }
+                    }
+                }
+                catch (global::System.Exception ex)
+                {
+                    return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+                }
+            }
+            case 1:
+            {
+                try
+                {
+                    // Special handling for single reference tuple parameter
+                    if (args.Length == 2)
+                    {
+                        instance.Reference<long>(new global::System.Tuple<long, string>(global::TUnit.Core.Helpers.CastHelper.Cast<long>(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(args[1])));
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                    else
+                    {
+                        switch (args.Length)
+                        {
+                            case 1:
+                                {
+                                    instance.Reference<long>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<long, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<long, string>)new global::System.Tuple<long, string>(global::TUnit.Core.Helpers.CastHelper.Cast<long>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<long, string>>(__tupleFallback0) }));
+                                    return default(global::System.Threading.Tasks.ValueTask);
+                                }
+                            default:
+                                throw new global::System.ArgumentException($"Expected exactly 1 argument, but got {args.Length}");
+                        }
+                    }
+                }
+                catch (global::System.Exception ex)
+                {
+                    return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+                }
+            }
+            default:
+                throw new global::System.ArgumentOutOfRangeException(nameof(methodIndex));
+        }
+    }
+    private static global::System.Attribute[] __Attributes_0(int groupIndex)
+    {
+        switch (groupIndex)
+        {
+            case 0:
+            {
+                return new global::System.Attribute[]
+                {
+                    new global::TUnit.Core.TestAttribute(),
+                    new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)),
+                    new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows")
+                };
+            }
+            case 1:
+            {
+                return new global::System.Attribute[]
+                {
+                    new global::TUnit.Core.TestAttribute(),
+                    new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)),
+                    new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows")
+                };
+            }
+            default:
+                throw new global::System.ArgumentOutOfRangeException(nameof(groupIndex));
+        }
+    }
+    public static readonly global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.ExplicitDirectTupleInferenceTests>[] Entries_0 = new global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.ExplicitDirectTupleInferenceTests>[]
+    {
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.ExplicitDirectTupleInferenceTests>(
+            methodName: "Reference<int>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.ExplicitDirectTupleInferenceTests.Reference<int>",
+            methodTypeArgumentsIdentity: "<int>",
+            filePath: "",
+            lineNumber: 228,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.ExplicitDirectTupleInferenceTests.ReferenceRows()),
+    },
+},
+            methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple<int, string>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple<int, string>)) } } },
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 0,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 0),
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.ExplicitDirectTupleInferenceTests>(
+            methodName: "Reference<long>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.ExplicitDirectTupleInferenceTests.Reference<long>",
+            methodTypeArgumentsIdentity: "<long>",
+            filePath: "",
+            lineNumber: 228,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.ExplicitDirectTupleInferenceTests.ReferenceRows()),
+    },
+},
+            methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple<long, string>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple<long, string>)) } } },
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 1,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 1),
+    };
+}
+internal static partial class TUnit_TestRegistration
+{
+    static readonly int _r_TUnit_TestProject_Bugs__7638_ExplicitDirectTupleInferenceTests_Reference__Tuple_T__string__TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries<global::TUnit.TestProject.Bugs._7638.ExplicitDirectTupleInferenceTests>(static () => TUnit_TestProject_Bugs__7638_ExplicitDirectTupleInferenceTests_Reference__Tuple_T__string__TestSource.Entries_0);
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute]
+[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")]
+internal static class TUnit_TestProject_Bugs__7638_ExplicitWrappedTupleInferenceTests_Direct___T__string__int_TestSource
+{
+    private static readonly global::TUnit.Core.ClassMetadata __classMetadata =     global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7638.ExplicitWrappedTupleInferenceTests", new global::TUnit.Core.ClassMetadata
+    {
+        Type = typeof(global::TUnit.TestProject.Bugs._7638.ExplicitWrappedTupleInferenceTests),
+        TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7638.ExplicitWrappedTupleInferenceTests)),
+        Name = "ExplicitWrappedTupleInferenceTests",
+        Namespace = "TUnit.TestProject.Bugs._7638",
+        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"),
+        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+        Parent = null
+    });
+    private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7638.ExplicitWrappedTupleInferenceTests);
+    private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Direct", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7638.ExplicitWrappedTupleInferenceTests), "Direct", false, 1, new global::TUnit.Core.ParameterMetadata[]
+{
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false),
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int), "extra", new global::TUnit.Core.ConcreteType(typeof(int)), false)
+}));
+    private static global::TUnit.TestProject.Bugs._7638.ExplicitWrappedTupleInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args)
+    {
+        return new global::TUnit.TestProject.Bugs._7638.ExplicitWrappedTupleInferenceTests();
+    }
+    private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7638.ExplicitWrappedTupleInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken)
+    {
+        switch (methodIndex)
+        {
+            case 0:
+            {
+                try
+                {
+                    if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList<object> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0]))
+                    {
+                        var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]);
+                        args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleElements[1])) };
+                    }
+                    switch (args.Length)
+                    {
+                        case 1:
+                            {
+                                instance.Direct<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), (int)(5));
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        case 2:
+                            {
+                                instance.Direct<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]));
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        default:
+                            throw new global::System.ArgumentException($"Expected between 1 and 2 arguments, but got {args.Length}");
+                    }
+                }
+                catch (global::System.Exception ex)
+                {
+                    return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+                }
+            }
+            case 1:
+            {
+                try
+                {
+                    if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList<object> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0]))
+                    {
+                        var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]);
+                        args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast<long>(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleElements[1])) };
+                    }
+                    switch (args.Length)
+                    {
+                        case 1:
+                            {
+                                instance.Direct<long>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<long, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<long, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<long>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<long, string>>(__tupleFallback0) }), (int)(5));
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        case 2:
+                            {
+                                instance.Direct<long>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<long, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<long, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<long>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<long, string>>(__tupleFallback0) }), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]));
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        default:
+                            throw new global::System.ArgumentException($"Expected between 1 and 2 arguments, but got {args.Length}");
+                    }
+                }
+                catch (global::System.Exception ex)
+                {
+                    return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+                }
+            }
+            default:
+                throw new global::System.ArgumentOutOfRangeException(nameof(methodIndex));
+        }
+    }
+    private static global::System.Attribute[] __Attributes_0(int groupIndex)
+    {
+        switch (groupIndex)
+        {
+            case 0:
+            {
+                return new global::System.Attribute[]
+                {
+                    new global::TUnit.Core.TestAttribute(),
+                    new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)),
+                    new global::TUnit.Core.MethodDataSourceAttribute("Rows")
+                };
+            }
+            case 1:
+            {
+                return new global::System.Attribute[]
+                {
+                    new global::TUnit.Core.TestAttribute(),
+                    new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)),
+                    new global::TUnit.Core.MethodDataSourceAttribute("Rows")
+                };
+            }
+            default:
+                throw new global::System.ArgumentOutOfRangeException(nameof(groupIndex));
+        }
+    }
+    public static readonly global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.ExplicitWrappedTupleInferenceTests>[] Entries_0 = new global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.ExplicitWrappedTupleInferenceTests>[]
+    {
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.ExplicitWrappedTupleInferenceTests>(
+            methodName: "Direct<int>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.ExplicitWrappedTupleInferenceTests.Direct<int>",
+            methodTypeArgumentsIdentity: "<int>",
+            filePath: "",
+            lineNumber: 245,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("Rows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.ExplicitWrappedTupleInferenceTests.Rows()),
+    },
+},
+            methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple<int, string>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple<int, string>)) }, __mm_0.Parameters[1] with { Type = typeof(int), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int)) } } },
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 0,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 0),
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.ExplicitWrappedTupleInferenceTests>(
+            methodName: "Direct<long>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.ExplicitWrappedTupleInferenceTests.Direct<long>",
+            methodTypeArgumentsIdentity: "<long>",
+            filePath: "",
+            lineNumber: 245,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("Rows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.ExplicitWrappedTupleInferenceTests.Rows()),
+    },
+},
+            methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple<long, string>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple<long, string>)) }, __mm_0.Parameters[1] with { Type = typeof(int), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int)) } } },
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 1,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 1),
+    };
+}
+internal static partial class TUnit_TestRegistration
+{
+    static readonly int _r_TUnit_TestProject_Bugs__7638_ExplicitWrappedTupleInferenceTests_Direct___T__string__int_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries<global::TUnit.TestProject.Bugs._7638.ExplicitWrappedTupleInferenceTests>(static () => TUnit_TestProject_Bugs__7638_ExplicitWrappedTupleInferenceTests_Direct___T__string__int_TestSource.Entries_0);
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute]
+[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")]
+internal static class TUnit_TestProject_Bugs__7638_ExplicitWrappedTupleInferenceTests_Inner___T__string__int_TestSource
+{
+    private static readonly global::TUnit.Core.ClassMetadata __classMetadata =     global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7638.ExplicitWrappedTupleInferenceTests", new global::TUnit.Core.ClassMetadata
+    {
+        Type = typeof(global::TUnit.TestProject.Bugs._7638.ExplicitWrappedTupleInferenceTests),
+        TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7638.ExplicitWrappedTupleInferenceTests)),
+        Name = "ExplicitWrappedTupleInferenceTests",
+        Namespace = "TUnit.TestProject.Bugs._7638",
+        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"),
+        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+        Parent = null
+    });
+    private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7638.ExplicitWrappedTupleInferenceTests);
+    private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Inner", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7638.ExplicitWrappedTupleInferenceTests), "Inner", false, 1, new global::TUnit.Core.ParameterMetadata[]
+{
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false),
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int), "extra", new global::TUnit.Core.ConcreteType(typeof(int)), false)
+}));
+    private static global::TUnit.TestProject.Bugs._7638.ExplicitWrappedTupleInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args)
+    {
+        return new global::TUnit.TestProject.Bugs._7638.ExplicitWrappedTupleInferenceTests();
+    }
+    private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7638.ExplicitWrappedTupleInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken)
+    {
+        switch (methodIndex)
+        {
+            case 0:
+            {
+                try
+                {
+                    if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList<object> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0]))
+                    {
+                        var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]);
+                        args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleElements[1])) };
+                    }
+                    switch (args.Length)
+                    {
+                        case 1:
+                            {
+                                instance.Inner<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), (int)(5));
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        case 2:
+                            {
+                                instance.Inner<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]));
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        default:
+                            throw new global::System.ArgumentException($"Expected between 1 and 2 arguments, but got {args.Length}");
+                    }
+                }
+                catch (global::System.Exception ex)
+                {
+                    return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+                }
+            }
+            case 1:
+            {
+                try
+                {
+                    if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList<object> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0]))
+                    {
+                        var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]);
+                        args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast<long>(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleElements[1])) };
+                    }
+                    switch (args.Length)
+                    {
+                        case 1:
+                            {
+                                instance.Inner<long>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<long, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<long, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<long>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<long, string>>(__tupleFallback0) }), (int)(5));
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        case 2:
+                            {
+                                instance.Inner<long>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<long, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<long, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<long>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<long, string>>(__tupleFallback0) }), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]));
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        default:
+                            throw new global::System.ArgumentException($"Expected between 1 and 2 arguments, but got {args.Length}");
+                    }
+                }
+                catch (global::System.Exception ex)
+                {
+                    return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+                }
+            }
+            default:
+                throw new global::System.ArgumentOutOfRangeException(nameof(methodIndex));
+        }
+    }
+    private static global::System.Attribute[] __Attributes_0(int groupIndex)
+    {
+        switch (groupIndex)
+        {
+            case 0:
+            {
+                return new global::System.Attribute[]
+                {
+                    new global::TUnit.Core.TestAttribute(),
+                    new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)),
+                    new global::TUnit.Core.MethodDataSourceAttribute("InnerRows")
+                };
+            }
+            case 1:
+            {
+                return new global::System.Attribute[]
+                {
+                    new global::TUnit.Core.TestAttribute(),
+                    new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)),
+                    new global::TUnit.Core.MethodDataSourceAttribute("InnerRows")
+                };
+            }
+            default:
+                throw new global::System.ArgumentOutOfRangeException(nameof(groupIndex));
+        }
+    }
+    public static readonly global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.ExplicitWrappedTupleInferenceTests>[] Entries_0 = new global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.ExplicitWrappedTupleInferenceTests>[]
+    {
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.ExplicitWrappedTupleInferenceTests>(
+            methodName: "Inner<int>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.ExplicitWrappedTupleInferenceTests.Inner<int>",
+            methodTypeArgumentsIdentity: "<int>",
+            filePath: "",
+            lineNumber: 248,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("InnerRows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.ExplicitWrappedTupleInferenceTests.InnerRows()),
+    },
+},
+            methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple<int, string>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple<int, string>)) }, __mm_0.Parameters[1] with { Type = typeof(int), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int)) } } },
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 0,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 0),
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.ExplicitWrappedTupleInferenceTests>(
+            methodName: "Inner<long>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.ExplicitWrappedTupleInferenceTests.Inner<long>",
+            methodTypeArgumentsIdentity: "<long>",
+            filePath: "",
+            lineNumber: 248,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("InnerRows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.ExplicitWrappedTupleInferenceTests.InnerRows()),
+    },
+},
+            methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple<long, string>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple<long, string>)) }, __mm_0.Parameters[1] with { Type = typeof(int), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int)) } } },
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 1,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 1),
+    };
+}
+internal static partial class TUnit_TestRegistration
+{
+    static readonly int _r_TUnit_TestProject_Bugs__7638_ExplicitWrappedTupleInferenceTests_Inner___T__string__int_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries<global::TUnit.TestProject.Bugs._7638.ExplicitWrappedTupleInferenceTests>(static () => TUnit_TestProject_Bugs__7638_ExplicitWrappedTupleInferenceTests_Inner___T__string__int_TestSource.Entries_0);
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute]
+[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")]
+internal static class TUnit_TestProject_Bugs__7638_ExplicitWrappedTupleInferenceTests_Outer___T__string__int_TestSource
+{
+    private static readonly global::TUnit.Core.ClassMetadata __classMetadata =     global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7638.ExplicitWrappedTupleInferenceTests", new global::TUnit.Core.ClassMetadata
+    {
+        Type = typeof(global::TUnit.TestProject.Bugs._7638.ExplicitWrappedTupleInferenceTests),
+        TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7638.ExplicitWrappedTupleInferenceTests)),
+        Name = "ExplicitWrappedTupleInferenceTests",
+        Namespace = "TUnit.TestProject.Bugs._7638",
+        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"),
+        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+        Parent = null
+    });
+    private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7638.ExplicitWrappedTupleInferenceTests);
+    private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Outer", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7638.ExplicitWrappedTupleInferenceTests), "Outer", false, 1, new global::TUnit.Core.ParameterMetadata[]
+{
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false),
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int), "extra", new global::TUnit.Core.ConcreteType(typeof(int)), false)
+}));
+    private static global::TUnit.TestProject.Bugs._7638.ExplicitWrappedTupleInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args)
+    {
+        return new global::TUnit.TestProject.Bugs._7638.ExplicitWrappedTupleInferenceTests();
+    }
+    private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7638.ExplicitWrappedTupleInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken)
+    {
+        switch (methodIndex)
+        {
+            case 0:
+            {
+                try
+                {
+                    if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList<object> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0]))
+                    {
+                        var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]);
+                        args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleElements[1])) };
+                    }
+                    switch (args.Length)
+                    {
+                        case 1:
+                            {
+                                instance.Outer<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), (int)(5));
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        case 2:
+                            {
+                                instance.Outer<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]));
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        default:
+                            throw new global::System.ArgumentException($"Expected between 1 and 2 arguments, but got {args.Length}");
+                    }
+                }
+                catch (global::System.Exception ex)
+                {
+                    return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+                }
+            }
+            case 1:
+            {
+                try
+                {
+                    if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList<object> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0]))
+                    {
+                        var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]);
+                        args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast<long>(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleElements[1])) };
+                    }
+                    switch (args.Length)
+                    {
+                        case 1:
+                            {
+                                instance.Outer<long>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<long, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<long, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<long>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<long, string>>(__tupleFallback0) }), (int)(5));
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        case 2:
+                            {
+                                instance.Outer<long>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<long, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<long, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<long>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<long, string>>(__tupleFallback0) }), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]));
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        default:
+                            throw new global::System.ArgumentException($"Expected between 1 and 2 arguments, but got {args.Length}");
+                    }
+                }
+                catch (global::System.Exception ex)
+                {
+                    return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+                }
+            }
+            default:
+                throw new global::System.ArgumentOutOfRangeException(nameof(methodIndex));
+        }
+    }
+    private static global::System.Attribute[] __Attributes_0(int groupIndex)
+    {
+        switch (groupIndex)
+        {
+            case 0:
+            {
+                return new global::System.Attribute[]
+                {
+                    new global::TUnit.Core.TestAttribute(),
+                    new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)),
+                    new global::TUnit.Core.MethodDataSourceAttribute("OuterRows")
+                };
+            }
+            case 1:
+            {
+                return new global::System.Attribute[]
+                {
+                    new global::TUnit.Core.TestAttribute(),
+                    new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)),
+                    new global::TUnit.Core.MethodDataSourceAttribute("OuterRows")
+                };
+            }
+            default:
+                throw new global::System.ArgumentOutOfRangeException(nameof(groupIndex));
+        }
+    }
+    public static readonly global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.ExplicitWrappedTupleInferenceTests>[] Entries_0 = new global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.ExplicitWrappedTupleInferenceTests>[]
+    {
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.ExplicitWrappedTupleInferenceTests>(
+            methodName: "Outer<int>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.ExplicitWrappedTupleInferenceTests.Outer<int>",
+            methodTypeArgumentsIdentity: "<int>",
+            filePath: "",
+            lineNumber: 251,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("OuterRows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.ExplicitWrappedTupleInferenceTests.OuterRows()),
+    },
+},
+            methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple<int, string>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple<int, string>)) }, __mm_0.Parameters[1] with { Type = typeof(int), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int)) } } },
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 0,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 0),
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.ExplicitWrappedTupleInferenceTests>(
+            methodName: "Outer<long>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.ExplicitWrappedTupleInferenceTests.Outer<long>",
+            methodTypeArgumentsIdentity: "<long>",
+            filePath: "",
+            lineNumber: 251,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("OuterRows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.ExplicitWrappedTupleInferenceTests.OuterRows()),
+    },
+},
+            methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple<long, string>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple<long, string>)) }, __mm_0.Parameters[1] with { Type = typeof(int), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int)) } } },
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 1,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 1),
+    };
+}
+internal static partial class TUnit_TestRegistration
+{
+    static readonly int _r_TUnit_TestProject_Bugs__7638_ExplicitWrappedTupleInferenceTests_Outer___T__string__int_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries<global::TUnit.TestProject.Bugs._7638.ExplicitWrappedTupleInferenceTests>(static () => TUnit_TestProject_Bugs__7638_ExplicitWrappedTupleInferenceTests_Outer___T__string__int_TestSource.Entries_0);
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute]
+[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")]
+internal static class TUnit_TestProject_Bugs__7638_ExplicitSpreadColumnInferenceTests_Array__T_T___TestSource
+{
+    private static readonly global::TUnit.Core.ClassMetadata __classMetadata =     global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7638.ExplicitSpreadColumnInferenceTests", new global::TUnit.Core.ClassMetadata
+    {
+        Type = typeof(global::TUnit.TestProject.Bugs._7638.ExplicitSpreadColumnInferenceTests),
+        TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7638.ExplicitSpreadColumnInferenceTests)),
+        Name = "ExplicitSpreadColumnInferenceTests",
+        Namespace = "TUnit.TestProject.Bugs._7638",
+        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"),
+        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+        Parent = null
+    });
+    private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7638.ExplicitSpreadColumnInferenceTests);
+    private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Array", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7638.ExplicitSpreadColumnInferenceTests), "Array", false, 1, new global::TUnit.Core.ParameterMetadata[]
+{
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "first", new global::TUnit.Core.GenericParameter(0, true, "T"), false),
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "extra", new global::TUnit.Core.ConcreteType(typeof(object)), false)
+}));
+    private static global::TUnit.TestProject.Bugs._7638.ExplicitSpreadColumnInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args)
+    {
+        return new global::TUnit.TestProject.Bugs._7638.ExplicitSpreadColumnInferenceTests();
+    }
+    private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7638.ExplicitSpreadColumnInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken)
+    {
+        try
+        {
+            switch (args.Length)
+            {
+                case 1:
+                    {
+                        instance.Array<long>(global::TUnit.Core.Helpers.CastHelper.Cast<long>(args[0]), global::System.Array.Empty<long>());
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 2:
+                    {
+                        instance.Array<long>(global::TUnit.Core.Helpers.CastHelper.Cast<long>(args[0]), (args[1] is null ? null : args[1] is long[] arr ? arr : global::TUnit.Core.Helpers.CastHelper.ToTrailingArray<long>(args[1])));
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 3:
+                    {
+                        instance.Array<long>(global::TUnit.Core.Helpers.CastHelper.Cast<long>(args[0]), new long[] { global::TUnit.Core.Helpers.CastHelper.Cast<long>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<long>(args[2]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 4:
+                    {
+                        instance.Array<long>(global::TUnit.Core.Helpers.CastHelper.Cast<long>(args[0]), new long[] { global::TUnit.Core.Helpers.CastHelper.Cast<long>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<long>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<long>(args[3]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 5:
+                    {
+                        instance.Array<long>(global::TUnit.Core.Helpers.CastHelper.Cast<long>(args[0]), new long[] { global::TUnit.Core.Helpers.CastHelper.Cast<long>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<long>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<long>(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast<long>(args[4]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 6:
+                    {
+                        instance.Array<long>(global::TUnit.Core.Helpers.CastHelper.Cast<long>(args[0]), new long[] { global::TUnit.Core.Helpers.CastHelper.Cast<long>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<long>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<long>(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast<long>(args[4]), global::TUnit.Core.Helpers.CastHelper.Cast<long>(args[5]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 7:
+                    {
+                        instance.Array<long>(global::TUnit.Core.Helpers.CastHelper.Cast<long>(args[0]), new long[] { global::TUnit.Core.Helpers.CastHelper.Cast<long>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<long>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<long>(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast<long>(args[4]), global::TUnit.Core.Helpers.CastHelper.Cast<long>(args[5]), global::TUnit.Core.Helpers.CastHelper.Cast<long>(args[6]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                default:
+                    if (args.Length < 1)
+                    {
+                        throw new global::System.ArgumentException($"Expected at least 1 argument, but got {args.Length}");
+                    }
+                    instance.Array<long>(global::TUnit.Core.Helpers.CastHelper.Cast<long>(args[0]), (args.Length > 1 ? global::System.Linq.Enumerable.ToArray(global::System.Linq.Enumerable.Select(global::System.Linq.Enumerable.Range(1, args.Length - 1), i => global::TUnit.Core.Helpers.CastHelper.Cast<long>(args[i]))) : global::System.Array.Empty<long>()));
+                    return default(global::System.Threading.Tasks.ValueTask);
+            }
+        }
+        catch (global::System.Exception ex)
+        {
+            return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+        }
+    }
+    private static global::System.Attribute[] __Attributes_0(int groupIndex)
+    {
+        return new global::System.Attribute[]
+        {
+            new global::TUnit.Core.TestAttribute(),
+            new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)),
+            new global::TUnit.Core.MethodDataSourceAttribute("ArrayRows")
+        };
+    }
+    public static readonly global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.ExplicitSpreadColumnInferenceTests>[] Entries_0 = new global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.ExplicitSpreadColumnInferenceTests>[]
+    {
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.ExplicitSpreadColumnInferenceTests>(
+            methodName: "Array<long>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.ExplicitSpreadColumnInferenceTests.Array<long>",
+            methodTypeArgumentsIdentity: "<long>",
+            filePath: "",
+            lineNumber: 266,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("ArrayRows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.ExplicitSpreadColumnInferenceTests.ArrayRows()),
+    },
+},
+            methodMetadata: __mm_0,
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 0,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 0),
+    };
+}
+internal static partial class TUnit_TestRegistration
+{
+    static readonly int _r_TUnit_TestProject_Bugs__7638_ExplicitSpreadColumnInferenceTests_Array__T_T___TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries<global::TUnit.TestProject.Bugs._7638.ExplicitSpreadColumnInferenceTests>(static () => TUnit_TestProject_Bugs__7638_ExplicitSpreadColumnInferenceTests_Array__T_T___TestSource.Entries_0);
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute]
+[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")]
+internal static class TUnit_TestProject_Bugs__7638_ExplicitSpreadColumnInferenceTests_Nullable__T_T__TestSource
+{
+    private static readonly global::TUnit.Core.ClassMetadata __classMetadata =     global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7638.ExplicitSpreadColumnInferenceTests", new global::TUnit.Core.ClassMetadata
+    {
+        Type = typeof(global::TUnit.TestProject.Bugs._7638.ExplicitSpreadColumnInferenceTests),
+        TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7638.ExplicitSpreadColumnInferenceTests)),
+        Name = "ExplicitSpreadColumnInferenceTests",
+        Namespace = "TUnit.TestProject.Bugs._7638",
+        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"),
+        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+        Parent = null
+    });
+    private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7638.ExplicitSpreadColumnInferenceTests);
+    private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Nullable", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7638.ExplicitSpreadColumnInferenceTests), "Nullable", false, 1, new global::TUnit.Core.ParameterMetadata[]
+{
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "first", new global::TUnit.Core.GenericParameter(0, true, "T"), false),
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "extra", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Nullable<>), [new global::TUnit.Core.GenericParameter(0, true, "T")]), true)
+}));
+    private static global::TUnit.TestProject.Bugs._7638.ExplicitSpreadColumnInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args)
+    {
+        return new global::TUnit.TestProject.Bugs._7638.ExplicitSpreadColumnInferenceTests();
+    }
+    private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7638.ExplicitSpreadColumnInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken)
+    {
+        try
+        {
+            instance.Nullable<long>(global::TUnit.Core.Helpers.CastHelper.Cast<long>(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast<long?>(args[1]));
+            return default(global::System.Threading.Tasks.ValueTask);
+        }
+        catch (global::System.Exception ex)
+        {
+            return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+        }
+    }
+    private static global::System.Attribute[] __Attributes_0(int groupIndex)
+    {
+        return new global::System.Attribute[]
+        {
+            new global::TUnit.Core.TestAttribute(),
+            new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)),
+            new global::TUnit.Core.MethodDataSourceAttribute("NullableRows")
+        };
+    }
+    public static readonly global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.ExplicitSpreadColumnInferenceTests>[] Entries_0 = new global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.ExplicitSpreadColumnInferenceTests>[]
+    {
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.ExplicitSpreadColumnInferenceTests>(
+            methodName: "Nullable<long>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.ExplicitSpreadColumnInferenceTests.Nullable<long>",
+            methodTypeArgumentsIdentity: "<long>",
+            filePath: "",
+            lineNumber: 273,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("NullableRows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.ExplicitSpreadColumnInferenceTests.NullableRows()),
+    },
+},
+            methodMetadata: __mm_0,
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 0,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 0),
+    };
+}
+internal static partial class TUnit_TestRegistration
+{
+    static readonly int _r_TUnit_TestProject_Bugs__7638_ExplicitSpreadColumnInferenceTests_Nullable__T_T__TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries<global::TUnit.TestProject.Bugs._7638.ExplicitSpreadColumnInferenceTests>(static () => TUnit_TestProject_Bugs__7638_ExplicitSpreadColumnInferenceTests_Nullable__T_T__TestSource.Entries_0);
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute]
+[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")]
+internal static class TUnit_TestProject_Bugs__7638_DerivedRowWholeTupleInferenceTests_Run___T__string__TestSource
+{
+    private static readonly global::TUnit.Core.ClassMetadata __classMetadata =     global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7638.DerivedRowWholeTupleInferenceTests", new global::TUnit.Core.ClassMetadata
+    {
+        Type = typeof(global::TUnit.TestProject.Bugs._7638.DerivedRowWholeTupleInferenceTests),
+        TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7638.DerivedRowWholeTupleInferenceTests)),
+        Name = "DerivedRowWholeTupleInferenceTests",
+        Namespace = "TUnit.TestProject.Bugs._7638",
+        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"),
+        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+        Parent = null
+    });
+    private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7638.DerivedRowWholeTupleInferenceTests);
+    private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("Run", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7638.DerivedRowWholeTupleInferenceTests), "Run", false, 1, new global::TUnit.Core.ParameterMetadata[]
+{
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false)
+}));
+    private static global::TUnit.TestProject.Bugs._7638.DerivedRowWholeTupleInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args)
+    {
+        return new global::TUnit.TestProject.Bugs._7638.DerivedRowWholeTupleInferenceTests();
+    }
+    private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7638.DerivedRowWholeTupleInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken)
+    {
+        switch (methodIndex)
+        {
+            case 0:
+            {
+                try
+                {
+                    // Special handling for single tuple parameter
+                    if (args.Length == 2)
+                    {
+                        // Arguments are unwrapped tuple elements, reconstruct the tuple
+                        instance.Run<int>((global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(args[1])));
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                    else if (args.Length == 1 && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0]))
+                    {
+                        // Rare case: tuple is wrapped as a single argument
+                        instance.Run<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }));
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                    else
+                    {
+                        throw new global::System.ArgumentException($"Expected 2 unwrapped elements or 1 wrapped tuple, but got {args.Length} arguments");
+                    }
+                }
+                catch (global::System.Exception ex)
+                {
+                    return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+                }
+            }
+            case 1:
+            {
+                try
+                {
+                    // Special handling for single tuple parameter
+                    if (args.Length == 2)
+                    {
+                        // Arguments are unwrapped tuple elements, reconstruct the tuple
+                        instance.Run<long>((global::TUnit.Core.Helpers.CastHelper.Cast<long>(args[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(args[1])));
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                    else if (args.Length == 1 && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0]))
+                    {
+                        // Rare case: tuple is wrapped as a single argument
+                        instance.Run<long>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<long, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<long, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<long>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<long, string>>(__tupleFallback0) }));
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                    else
+                    {
+                        throw new global::System.ArgumentException($"Expected 2 unwrapped elements or 1 wrapped tuple, but got {args.Length} arguments");
+                    }
+                }
+                catch (global::System.Exception ex)
+                {
+                    return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+                }
+            }
+            default:
+                throw new global::System.ArgumentOutOfRangeException(nameof(methodIndex));
+        }
+    }
+    private static global::System.Attribute[] __Attributes_0(int groupIndex)
+    {
+        switch (groupIndex)
+        {
+            case 0:
+            {
+                return new global::System.Attribute[]
+                {
+                    new global::TUnit.Core.TestAttribute(),
+                    new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)),
+                    new global::TUnit.Core.MethodDataSourceAttribute("Rows")
+                };
+            }
+            case 1:
+            {
+                return new global::System.Attribute[]
+                {
+                    new global::TUnit.Core.TestAttribute(),
+                    new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)),
+                    new global::TUnit.Core.MethodDataSourceAttribute("Rows")
+                };
+            }
+            default:
+                throw new global::System.ArgumentOutOfRangeException(nameof(groupIndex));
+        }
+    }
+    public static readonly global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.DerivedRowWholeTupleInferenceTests>[] Entries_0 = new global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.DerivedRowWholeTupleInferenceTests>[]
+    {
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.DerivedRowWholeTupleInferenceTests>(
+            methodName: "Run<int>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.DerivedRowWholeTupleInferenceTests.Run<int>",
+            methodTypeArgumentsIdentity: "<int>",
+            filePath: "",
+            lineNumber: 294,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("Rows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.DerivedRowWholeTupleInferenceTests.Rows()),
+    },
+},
+            methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple<int, string>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple<int, string>)) } } },
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 0,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 0),
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.DerivedRowWholeTupleInferenceTests>(
+            methodName: "Run<long>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.DerivedRowWholeTupleInferenceTests.Run<long>",
+            methodTypeArgumentsIdentity: "<long>",
+            filePath: "",
+            lineNumber: 294,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("Rows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.DerivedRowWholeTupleInferenceTests.Rows()),
+    },
+},
+            methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple<long, string>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple<long, string>)) } } },
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 1,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 1),
+    };
+}
+internal static partial class TUnit_TestRegistration
+{
+    static readonly int _r_TUnit_TestProject_Bugs__7638_DerivedRowWholeTupleInferenceTests_Run___T__string__TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries<global::TUnit.TestProject.Bugs._7638.DerivedRowWholeTupleInferenceTests>(static () => TUnit_TestProject_Bugs__7638_DerivedRowWholeTupleInferenceTests_Run___T__string__TestSource.Entries_0);
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute]
+[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")]
+internal static class TUnit_TestProject_Bugs__7638_AsyncWholeTupleInferenceTests_TaskOptional___T__string__int_TestSource
+{
+    private static readonly global::TUnit.Core.ClassMetadata __classMetadata =     global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7638.AsyncWholeTupleInferenceTests", new global::TUnit.Core.ClassMetadata
+    {
+        Type = typeof(global::TUnit.TestProject.Bugs._7638.AsyncWholeTupleInferenceTests),
+        TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7638.AsyncWholeTupleInferenceTests)),
+        Name = "AsyncWholeTupleInferenceTests",
+        Namespace = "TUnit.TestProject.Bugs._7638",
+        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"),
+        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+        Parent = null
+    });
+    private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7638.AsyncWholeTupleInferenceTests);
+    private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("TaskOptional", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7638.AsyncWholeTupleInferenceTests), "TaskOptional", false, 1, new global::TUnit.Core.ParameterMetadata[]
+{
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false),
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int), "extra", new global::TUnit.Core.ConcreteType(typeof(int)), false)
+}));
+    private static global::TUnit.TestProject.Bugs._7638.AsyncWholeTupleInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args)
+    {
+        return new global::TUnit.TestProject.Bugs._7638.AsyncWholeTupleInferenceTests();
+    }
+    private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7638.AsyncWholeTupleInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken)
+    {
+        switch (methodIndex)
+        {
+            case 0:
+            {
+                try
+                {
+                    if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList<object> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0]))
+                    {
+                        var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]);
+                        args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleElements[1])) };
+                    }
+                    switch (args.Length)
+                    {
+                        case 1:
+                            {
+                                instance.TaskOptional<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), (int)(5));
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        case 2:
+                            {
+                                instance.TaskOptional<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]));
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        default:
+                            throw new global::System.ArgumentException($"Expected between 1 and 2 arguments, but got {args.Length}");
+                    }
+                }
+                catch (global::System.Exception ex)
+                {
+                    return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+                }
+            }
+            case 1:
+            {
+                try
+                {
+                    if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList<object> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0]))
+                    {
+                        var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]);
+                        args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast<long>(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleElements[1])) };
+                    }
+                    switch (args.Length)
+                    {
+                        case 1:
+                            {
+                                instance.TaskOptional<long>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<long, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<long, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<long>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<long, string>>(__tupleFallback0) }), (int)(5));
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        case 2:
+                            {
+                                instance.TaskOptional<long>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<long, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<long, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<long>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<long, string>>(__tupleFallback0) }), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]));
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        default:
+                            throw new global::System.ArgumentException($"Expected between 1 and 2 arguments, but got {args.Length}");
+                    }
+                }
+                catch (global::System.Exception ex)
+                {
+                    return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+                }
+            }
+            default:
+                throw new global::System.ArgumentOutOfRangeException(nameof(methodIndex));
+        }
+    }
+    private static global::System.Attribute[] __Attributes_0(int groupIndex)
+    {
+        switch (groupIndex)
+        {
+            case 0:
+            {
+                return new global::System.Attribute[]
+                {
+                    new global::TUnit.Core.TestAttribute(),
+                    new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)),
+                    new global::TUnit.Core.MethodDataSourceAttribute("TaskRows")
+                };
+            }
+            case 1:
+            {
+                return new global::System.Attribute[]
+                {
+                    new global::TUnit.Core.TestAttribute(),
+                    new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)),
+                    new global::TUnit.Core.MethodDataSourceAttribute("TaskRows")
+                };
+            }
+            default:
+                throw new global::System.ArgumentOutOfRangeException(nameof(groupIndex));
+        }
+    }
+    public static readonly global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.AsyncWholeTupleInferenceTests>[] Entries_0 = new global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.AsyncWholeTupleInferenceTests>[]
+    {
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.AsyncWholeTupleInferenceTests>(
+            methodName: "TaskOptional<int>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.AsyncWholeTupleInferenceTests.TaskOptional<int>",
+            methodTypeArgumentsIdentity: "<int>",
+            filePath: "",
+            lineNumber: 317,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("TaskRows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromTask(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.AsyncWholeTupleInferenceTests.TaskRows()),
+    },
+},
+            methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple<int, string>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple<int, string>)) }, __mm_0.Parameters[1] with { Type = typeof(int), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int)) } } },
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 0,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 0),
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.AsyncWholeTupleInferenceTests>(
+            methodName: "TaskOptional<long>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.AsyncWholeTupleInferenceTests.TaskOptional<long>",
+            methodTypeArgumentsIdentity: "<long>",
+            filePath: "",
+            lineNumber: 317,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("TaskRows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromTask(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.AsyncWholeTupleInferenceTests.TaskRows()),
+    },
+},
+            methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple<long, string>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple<long, string>)) }, __mm_0.Parameters[1] with { Type = typeof(int), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int)) } } },
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 1,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 1),
+    };
+}
+internal static partial class TUnit_TestRegistration
+{
+    static readonly int _r_TUnit_TestProject_Bugs__7638_AsyncWholeTupleInferenceTests_TaskOptional___T__string__int_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries<global::TUnit.TestProject.Bugs._7638.AsyncWholeTupleInferenceTests>(static () => TUnit_TestProject_Bugs__7638_AsyncWholeTupleInferenceTests_TaskOptional___T__string__int_TestSource.Entries_0);
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute]
+[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")]
+internal static class TUnit_TestProject_Bugs__7638_AsyncWholeTupleInferenceTests_ValueTaskOptional___T__string__int_TestSource
+{
+    private static readonly global::TUnit.Core.ClassMetadata __classMetadata =     global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7638.AsyncWholeTupleInferenceTests", new global::TUnit.Core.ClassMetadata
+    {
+        Type = typeof(global::TUnit.TestProject.Bugs._7638.AsyncWholeTupleInferenceTests),
+        TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7638.AsyncWholeTupleInferenceTests)),
+        Name = "AsyncWholeTupleInferenceTests",
+        Namespace = "TUnit.TestProject.Bugs._7638",
+        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"),
+        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+        Parent = null
+    });
+    private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7638.AsyncWholeTupleInferenceTests);
+    private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ValueTaskOptional", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7638.AsyncWholeTupleInferenceTests), "ValueTaskOptional", false, 1, new global::TUnit.Core.ParameterMetadata[]
+{
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false),
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int), "extra", new global::TUnit.Core.ConcreteType(typeof(int)), false)
+}));
+    private static global::TUnit.TestProject.Bugs._7638.AsyncWholeTupleInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args)
+    {
+        return new global::TUnit.TestProject.Bugs._7638.AsyncWholeTupleInferenceTests();
+    }
+    private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7638.AsyncWholeTupleInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken)
+    {
+        switch (methodIndex)
+        {
+            case 0:
+            {
+                try
+                {
+                    if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList<object> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0]))
+                    {
+                        var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]);
+                        args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleElements[1])) };
+                    }
+                    switch (args.Length)
+                    {
+                        case 1:
+                            {
+                                instance.ValueTaskOptional<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), (int)(5));
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        case 2:
+                            {
+                                instance.ValueTaskOptional<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]));
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        default:
+                            throw new global::System.ArgumentException($"Expected between 1 and 2 arguments, but got {args.Length}");
+                    }
+                }
+                catch (global::System.Exception ex)
+                {
+                    return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+                }
+            }
+            case 1:
+            {
+                try
+                {
+                    if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList<object> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0]))
+                    {
+                        var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]);
+                        args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast<long>(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleElements[1])) };
+                    }
+                    switch (args.Length)
+                    {
+                        case 1:
+                            {
+                                instance.ValueTaskOptional<long>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<long, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<long, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<long>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<long, string>>(__tupleFallback0) }), (int)(5));
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        case 2:
+                            {
+                                instance.ValueTaskOptional<long>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<long, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<long, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<long>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<long, string>>(__tupleFallback0) }), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]));
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        default:
+                            throw new global::System.ArgumentException($"Expected between 1 and 2 arguments, but got {args.Length}");
+                    }
+                }
+                catch (global::System.Exception ex)
+                {
+                    return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+                }
+            }
+            default:
+                throw new global::System.ArgumentOutOfRangeException(nameof(methodIndex));
+        }
+    }
+    private static global::System.Attribute[] __Attributes_0(int groupIndex)
+    {
+        switch (groupIndex)
+        {
+            case 0:
+            {
+                return new global::System.Attribute[]
+                {
+                    new global::TUnit.Core.TestAttribute(),
+                    new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)),
+                    new global::TUnit.Core.MethodDataSourceAttribute("ValueTaskRows")
+                };
+            }
+            case 1:
+            {
+                return new global::System.Attribute[]
+                {
+                    new global::TUnit.Core.TestAttribute(),
+                    new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)),
+                    new global::TUnit.Core.MethodDataSourceAttribute("ValueTaskRows")
+                };
+            }
+            default:
+                throw new global::System.ArgumentOutOfRangeException(nameof(groupIndex));
+        }
+    }
+    public static readonly global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.AsyncWholeTupleInferenceTests>[] Entries_0 = new global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.AsyncWholeTupleInferenceTests>[]
+    {
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.AsyncWholeTupleInferenceTests>(
+            methodName: "ValueTaskOptional<int>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.AsyncWholeTupleInferenceTests.ValueTaskOptional<int>",
+            methodTypeArgumentsIdentity: "<int>",
+            filePath: "",
+            lineNumber: 320,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("ValueTaskRows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromValueTask(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.AsyncWholeTupleInferenceTests.ValueTaskRows()),
+    },
+},
+            methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple<int, string>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple<int, string>)) }, __mm_0.Parameters[1] with { Type = typeof(int), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int)) } } },
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 0,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 0),
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.AsyncWholeTupleInferenceTests>(
+            methodName: "ValueTaskOptional<long>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.AsyncWholeTupleInferenceTests.ValueTaskOptional<long>",
+            methodTypeArgumentsIdentity: "<long>",
+            filePath: "",
+            lineNumber: 320,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("ValueTaskRows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromValueTask(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.AsyncWholeTupleInferenceTests.ValueTaskRows()),
+    },
+},
+            methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple<long, string>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple<long, string>)) }, __mm_0.Parameters[1] with { Type = typeof(int), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int)) } } },
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 1,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 1),
+    };
+}
+internal static partial class TUnit_TestRegistration
+{
+    static readonly int _r_TUnit_TestProject_Bugs__7638_AsyncWholeTupleInferenceTests_ValueTaskOptional___T__string__int_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries<global::TUnit.TestProject.Bugs._7638.AsyncWholeTupleInferenceTests>(static () => TUnit_TestProject_Bugs__7638_AsyncWholeTupleInferenceTests_ValueTaskOptional___T__string__int_TestSource.Entries_0);
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute]
+[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")]
+internal static class TUnit_TestProject_Bugs__7638_AsyncWholeTupleInferenceTests_AsyncOptional___T__string__int_TestSource
+{
+    private static readonly global::TUnit.Core.ClassMetadata __classMetadata =     global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7638.AsyncWholeTupleInferenceTests", new global::TUnit.Core.ClassMetadata
+    {
+        Type = typeof(global::TUnit.TestProject.Bugs._7638.AsyncWholeTupleInferenceTests),
+        TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7638.AsyncWholeTupleInferenceTests)),
+        Name = "AsyncWholeTupleInferenceTests",
+        Namespace = "TUnit.TestProject.Bugs._7638",
+        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"),
+        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+        Parent = null
+    });
+    private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7638.AsyncWholeTupleInferenceTests);
+    private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("AsyncOptional", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7638.AsyncWholeTupleInferenceTests), "AsyncOptional", false, 1, new global::TUnit.Core.ParameterMetadata[]
+{
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false),
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int), "extra", new global::TUnit.Core.ConcreteType(typeof(int)), false)
+}));
+    private static global::TUnit.TestProject.Bugs._7638.AsyncWholeTupleInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args)
+    {
+        return new global::TUnit.TestProject.Bugs._7638.AsyncWholeTupleInferenceTests();
+    }
+    private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7638.AsyncWholeTupleInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken)
+    {
+        switch (methodIndex)
+        {
+            case 0:
+            {
+                try
+                {
+                    if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList<object> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0]))
+                    {
+                        var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]);
+                        args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleElements[1])) };
+                    }
+                    switch (args.Length)
+                    {
+                        case 1:
+                            {
+                                instance.AsyncOptional<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), (int)(5));
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        case 2:
+                            {
+                                instance.AsyncOptional<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]));
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        default:
+                            throw new global::System.ArgumentException($"Expected between 1 and 2 arguments, but got {args.Length}");
+                    }
+                }
+                catch (global::System.Exception ex)
+                {
+                    return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+                }
+            }
+            case 1:
+            {
+                try
+                {
+                    if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList<object> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0]))
+                    {
+                        var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]);
+                        args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast<long>(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleElements[1])) };
+                    }
+                    switch (args.Length)
+                    {
+                        case 1:
+                            {
+                                instance.AsyncOptional<long>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<long, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<long, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<long>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<long, string>>(__tupleFallback0) }), (int)(5));
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        case 2:
+                            {
+                                instance.AsyncOptional<long>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<long, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<long, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<long>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<long, string>>(__tupleFallback0) }), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]));
+                                return default(global::System.Threading.Tasks.ValueTask);
+                            }
+                        default:
+                            throw new global::System.ArgumentException($"Expected between 1 and 2 arguments, but got {args.Length}");
+                    }
+                }
+                catch (global::System.Exception ex)
+                {
+                    return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+                }
+            }
+            default:
+                throw new global::System.ArgumentOutOfRangeException(nameof(methodIndex));
+        }
+    }
+    private static global::System.Attribute[] __Attributes_0(int groupIndex)
+    {
+        switch (groupIndex)
+        {
+            case 0:
+            {
+                return new global::System.Attribute[]
+                {
+                    new global::TUnit.Core.TestAttribute(),
+                    new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)),
+                    new global::TUnit.Core.MethodDataSourceAttribute("AsyncRows")
+                };
+            }
+            case 1:
+            {
+                return new global::System.Attribute[]
+                {
+                    new global::TUnit.Core.TestAttribute(),
+                    new global::TUnit.Core.GenerateGenericTestAttribute(typeof(long)),
+                    new global::TUnit.Core.MethodDataSourceAttribute("AsyncRows")
+                };
+            }
+            default:
+                throw new global::System.ArgumentOutOfRangeException(nameof(groupIndex));
+        }
+    }
+    public static readonly global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.AsyncWholeTupleInferenceTests>[] Entries_0 = new global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.AsyncWholeTupleInferenceTests>[]
+    {
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.AsyncWholeTupleInferenceTests>(
+            methodName: "AsyncOptional<int>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.AsyncWholeTupleInferenceTests.AsyncOptional<int>",
+            methodTypeArgumentsIdentity: "<int>",
+            filePath: "",
+            lineNumber: 323,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("AsyncRows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromAsyncEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.AsyncWholeTupleInferenceTests.AsyncRows()),
+    },
+},
+            methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple<int, string>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple<int, string>)) }, __mm_0.Parameters[1] with { Type = typeof(int), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int)) } } },
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 0,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 0),
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.AsyncWholeTupleInferenceTests>(
+            methodName: "AsyncOptional<long>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.AsyncWholeTupleInferenceTests.AsyncOptional<long>",
+            methodTypeArgumentsIdentity: "<long>",
+            filePath: "",
+            lineNumber: 323,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("AsyncRows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromAsyncEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.AsyncWholeTupleInferenceTests.AsyncRows()),
+    },
+},
+            methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple<long, string>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple<long, string>)) }, __mm_0.Parameters[1] with { Type = typeof(int), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int)) } } },
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 1,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 1),
+    };
+}
+internal static partial class TUnit_TestRegistration
+{
+    static readonly int _r_TUnit_TestProject_Bugs__7638_AsyncWholeTupleInferenceTests_AsyncOptional___T__string__int_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries<global::TUnit.TestProject.Bugs._7638.AsyncWholeTupleInferenceTests>(static () => TUnit_TestProject_Bugs__7638_AsyncWholeTupleInferenceTests_AsyncOptional___T__string__int_TestSource.Entries_0);
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute]
+[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")]
+internal static class TUnit_TestProject_Bugs__7638_WrappedWholeTupleInferenceTests_ValueOptional___T__string__int_TestSource
+{
+    private static readonly global::TUnit.Core.ClassMetadata __classMetadata =     global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests", new global::TUnit.Core.ClassMetadata
+    {
+        Type = typeof(global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests),
+        TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests)),
+        Name = "WrappedWholeTupleInferenceTests",
+        Namespace = "TUnit.TestProject.Bugs._7638",
+        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"),
+        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+        Parent = null
+    });
+    private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests);
+    private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ValueOptional", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests), "ValueOptional", false, 1, new global::TUnit.Core.ParameterMetadata[]
+{
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false),
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int), "extra", new global::TUnit.Core.ConcreteType(typeof(int)), false)
+}));
+    private static global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args)
+    {
+        return new global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests();
+    }
+    private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken)
+    {
+        try
+        {
+            if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList<object> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0]))
+            {
+                var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]);
+                args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleElements[1])) };
+            }
+            switch (args.Length)
+            {
+                case 1:
+                    {
+                        instance.ValueOptional<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), (int)(5));
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 2:
+                    {
+                        instance.ValueOptional<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]));
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                default:
+                    throw new global::System.ArgumentException($"Expected between 1 and 2 arguments, but got {args.Length}");
+            }
+        }
+        catch (global::System.Exception ex)
+        {
+            return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+        }
+    }
+    private static global::System.Attribute[] __Attributes_0(int groupIndex)
+    {
+        return new global::System.Attribute[]
+        {
+            new global::TUnit.Core.TestAttribute(),
+            new global::TUnit.Core.MethodDataSourceAttribute("ValueRows")
+        };
+    }
+    public static readonly global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests>[] Entries_0 = new global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests>[]
+    {
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests>(
+            methodName: "ValueOptional<int>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests.ValueOptional<int>",
+            methodTypeArgumentsIdentity: "<int>",
+            filePath: "",
+            lineNumber: 341,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("ValueRows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests.ValueRows()),
+    },
+},
+            methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple<int, string>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple<int, string>)) }, __mm_0.Parameters[1] with { Type = typeof(int), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int)) } } },
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 0,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 0),
+    };
+}
+internal static partial class TUnit_TestRegistration
+{
+    static readonly int _r_TUnit_TestProject_Bugs__7638_WrappedWholeTupleInferenceTests_ValueOptional___T__string__int_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries<global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests>(static () => TUnit_TestProject_Bugs__7638_WrappedWholeTupleInferenceTests_ValueOptional___T__string__int_TestSource.Entries_0);
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute]
+[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")]
+internal static class TUnit_TestProject_Bugs__7638_WrappedWholeTupleInferenceTests_ValueParams___T__string__int___TestSource
+{
+    private static readonly global::TUnit.Core.ClassMetadata __classMetadata =     global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests", new global::TUnit.Core.ClassMetadata
+    {
+        Type = typeof(global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests),
+        TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests)),
+        Name = "WrappedWholeTupleInferenceTests",
+        Namespace = "TUnit.TestProject.Bugs._7638",
+        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"),
+        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+        Parent = null
+    });
+    private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests);
+    private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ValueParams", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests), "ValueParams", false, 1, new global::TUnit.Core.ParameterMetadata[]
+{
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false),
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int[]), "extra", new global::TUnit.Core.ConcreteType(typeof(int[])), false)
+}));
+    private static global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args)
+    {
+        return new global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests();
+    }
+    private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken)
+    {
+        try
+        {
+            if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList<object> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0]))
+            {
+                var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]);
+                args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleElements[1])) };
+            }
+            switch (args.Length)
+            {
+                case 1:
+                    {
+                        instance.ValueParams<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), global::System.Array.Empty<int>());
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 2:
+                    {
+                        instance.ValueParams<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), (args[1] is null ? null : args[1] is int[] arr ? arr : global::TUnit.Core.Helpers.CastHelper.ToTrailingArray<int>(args[1])));
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 3:
+                    {
+                        instance.ValueParams<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 4:
+                    {
+                        instance.ValueParams<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 5:
+                    {
+                        instance.ValueParams<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[4]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 6:
+                    {
+                        instance.ValueParams<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[4]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[5]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 7:
+                    {
+                        instance.ValueParams<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[4]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[5]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[6]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                default:
+                    if (args.Length < 1)
+                    {
+                        throw new global::System.ArgumentException($"Expected at least 1 argument, but got {args.Length}");
+                    }
+                    instance.ValueParams<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), (args.Length > 1 ? global::System.Linq.Enumerable.ToArray(global::System.Linq.Enumerable.Select(global::System.Linq.Enumerable.Range(1, args.Length - 1), i => global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[i]))) : global::System.Array.Empty<int>()));
+                    return default(global::System.Threading.Tasks.ValueTask);
+            }
+        }
+        catch (global::System.Exception ex)
+        {
+            return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+        }
+    }
+    private static global::System.Attribute[] __Attributes_0(int groupIndex)
+    {
+        return new global::System.Attribute[]
+        {
+            new global::TUnit.Core.TestAttribute(),
+            new global::TUnit.Core.MethodDataSourceAttribute("ValueRows")
+        };
+    }
+    public static readonly global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests>[] Entries_0 = new global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests>[]
+    {
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests>(
+            methodName: "ValueParams<int>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests.ValueParams<int>",
+            methodTypeArgumentsIdentity: "<int>",
+            filePath: "",
+            lineNumber: 349,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("ValueRows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests.ValueRows()),
+    },
+},
+            methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple<int, string>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple<int, string>)) }, __mm_0.Parameters[1] with { Type = typeof(int[]), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int[])) } } },
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 0,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 0),
+    };
+}
+internal static partial class TUnit_TestRegistration
+{
+    static readonly int _r_TUnit_TestProject_Bugs__7638_WrappedWholeTupleInferenceTests_ValueParams___T__string__int___TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries<global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests>(static () => TUnit_TestProject_Bugs__7638_WrappedWholeTupleInferenceTests_ValueParams___T__string__int___TestSource.Entries_0);
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute]
+[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")]
+internal static class TUnit_TestProject_Bugs__7638_WrappedWholeTupleInferenceTests_ValueArray___T__string__int___TestSource
+{
+    private static readonly global::TUnit.Core.ClassMetadata __classMetadata =     global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests", new global::TUnit.Core.ClassMetadata
+    {
+        Type = typeof(global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests),
+        TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests)),
+        Name = "WrappedWholeTupleInferenceTests",
+        Namespace = "TUnit.TestProject.Bugs._7638",
+        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"),
+        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+        Parent = null
+    });
+    private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests);
+    private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ValueArray", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests), "ValueArray", false, 1, new global::TUnit.Core.ParameterMetadata[]
+{
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false),
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int[]), "extra", new global::TUnit.Core.ConcreteType(typeof(int[])), false)
+}));
+    private static global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args)
+    {
+        return new global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests();
+    }
+    private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken)
+    {
+        try
+        {
+            if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList<object> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0]))
+            {
+                var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]);
+                args = new object[] { (global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleElements[1])) };
+            }
+            switch (args.Length)
+            {
+                case 1:
+                    {
+                        instance.ValueArray<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), global::System.Array.Empty<int>());
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 2:
+                    {
+                        instance.ValueArray<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), (args[1] is null ? null : args[1] is int[] arr ? arr : global::TUnit.Core.Helpers.CastHelper.ToTrailingArray<int>(args[1])));
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 3:
+                    {
+                        instance.ValueArray<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 4:
+                    {
+                        instance.ValueArray<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 5:
+                    {
+                        instance.ValueArray<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[4]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 6:
+                    {
+                        instance.ValueArray<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[4]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[5]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 7:
+                    {
+                        instance.ValueArray<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[4]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[5]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[6]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                default:
+                    if (args.Length < 1)
+                    {
+                        throw new global::System.ArgumentException($"Expected at least 1 argument, but got {args.Length}");
+                    }
+                    instance.ValueArray<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.ValueTuple<int, string>)(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int, string>>(__tupleFallback0) }), (args.Length > 1 ? global::System.Linq.Enumerable.ToArray(global::System.Linq.Enumerable.Select(global::System.Linq.Enumerable.Range(1, args.Length - 1), i => global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[i]))) : global::System.Array.Empty<int>()));
+                    return default(global::System.Threading.Tasks.ValueTask);
+            }
+        }
+        catch (global::System.Exception ex)
+        {
+            return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+        }
+    }
+    private static global::System.Attribute[] __Attributes_0(int groupIndex)
+    {
+        return new global::System.Attribute[]
+        {
+            new global::TUnit.Core.TestAttribute(),
+            new global::TUnit.Core.MethodDataSourceAttribute("ValueRows")
+        };
+    }
+    public static readonly global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests>[] Entries_0 = new global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests>[]
+    {
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests>(
+            methodName: "ValueArray<int>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests.ValueArray<int>",
+            methodTypeArgumentsIdentity: "<int>",
+            filePath: "",
+            lineNumber: 357,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("ValueRows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests.ValueRows()),
+    },
+},
+            methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple<int, string>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple<int, string>)) }, __mm_0.Parameters[1] with { Type = typeof(int[]), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int[])) } } },
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 0,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 0),
+    };
+}
+internal static partial class TUnit_TestRegistration
+{
+    static readonly int _r_TUnit_TestProject_Bugs__7638_WrappedWholeTupleInferenceTests_ValueArray___T__string__int___TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries<global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests>(static () => TUnit_TestProject_Bugs__7638_WrappedWholeTupleInferenceTests_ValueArray___T__string__int___TestSource.Entries_0);
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute]
+[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")]
+internal static class TUnit_TestProject_Bugs__7638_WrappedWholeTupleInferenceTests_ReferenceOptional__Tuple__FCC20D73_TestSource
+{
+    private static readonly global::TUnit.Core.ClassMetadata __classMetadata =     global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests", new global::TUnit.Core.ClassMetadata
+    {
+        Type = typeof(global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests),
+        TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests)),
+        Name = "WrappedWholeTupleInferenceTests",
+        Namespace = "TUnit.TestProject.Bugs._7638",
+        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"),
+        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+        Parent = null
+    });
+    private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests);
+    private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ReferenceOptional", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests), "ReferenceOptional", false, 1, new global::TUnit.Core.ParameterMetadata[]
+{
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false),
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int), "extra", new global::TUnit.Core.ConcreteType(typeof(int)), false)
+}));
+    private static global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args)
+    {
+        return new global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests();
+    }
+    private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken)
+    {
+        try
+        {
+            if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList<object> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0]))
+            {
+                var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]);
+                args = new object[] { new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleElements[1])) };
+            }
+            switch (args.Length)
+            {
+                case 1:
+                    {
+                        instance.ReferenceOptional<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<int, string>)new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int, string>>(__tupleFallback0) }), (int)(5));
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 2:
+                    {
+                        instance.ReferenceOptional<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<int, string>)new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int, string>>(__tupleFallback0) }), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]));
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                default:
+                    throw new global::System.ArgumentException($"Expected between 1 and 2 arguments, but got {args.Length}");
+            }
+        }
+        catch (global::System.Exception ex)
+        {
+            return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+        }
+    }
+    private static global::System.Attribute[] __Attributes_0(int groupIndex)
+    {
+        return new global::System.Attribute[]
+        {
+            new global::TUnit.Core.TestAttribute(),
+            new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows")
+        };
+    }
+    public static readonly global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests>[] Entries_0 = new global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests>[]
+    {
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests>(
+            methodName: "ReferenceOptional<int>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests.ReferenceOptional<int>",
+            methodTypeArgumentsIdentity: "<int>",
+            filePath: "",
+            lineNumber: 365,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests.ReferenceRows()),
+    },
+},
+            methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple<int, string>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple<int, string>)) }, __mm_0.Parameters[1] with { Type = typeof(int), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int)) } } },
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 0,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 0),
+    };
+}
+internal static partial class TUnit_TestRegistration
+{
+    static readonly int _r_TUnit_TestProject_Bugs__7638_WrappedWholeTupleInferenceTests_ReferenceOptional__Tuple__FCC20D73_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries<global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests>(static () => TUnit_TestProject_Bugs__7638_WrappedWholeTupleInferenceTests_ReferenceOptional__Tuple__FCC20D73_TestSource.Entries_0);
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute]
+[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")]
+internal static class TUnit_TestProject_Bugs__7638_WrappedWholeTupleInferenceTests_ReferenceParams__Tuple_T__25295A9B_TestSource
+{
+    private static readonly global::TUnit.Core.ClassMetadata __classMetadata =     global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests", new global::TUnit.Core.ClassMetadata
+    {
+        Type = typeof(global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests),
+        TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests)),
+        Name = "WrappedWholeTupleInferenceTests",
+        Namespace = "TUnit.TestProject.Bugs._7638",
+        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"),
+        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+        Parent = null
+    });
+    private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests);
+    private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ReferenceParams", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests), "ReferenceParams", false, 1, new global::TUnit.Core.ParameterMetadata[]
+{
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false),
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int[]), "extra", new global::TUnit.Core.ConcreteType(typeof(int[])), false)
+}));
+    private static global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args)
+    {
+        return new global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests();
+    }
+    private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken)
+    {
+        try
+        {
+            if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList<object> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0]))
+            {
+                var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]);
+                args = new object[] { new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleElements[1])) };
+            }
+            switch (args.Length)
+            {
+                case 1:
+                    {
+                        instance.ReferenceParams<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<int, string>)new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int, string>>(__tupleFallback0) }), global::System.Array.Empty<int>());
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 2:
+                    {
+                        instance.ReferenceParams<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<int, string>)new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int, string>>(__tupleFallback0) }), (args[1] is null ? null : args[1] is int[] arr ? arr : global::TUnit.Core.Helpers.CastHelper.ToTrailingArray<int>(args[1])));
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 3:
+                    {
+                        instance.ReferenceParams<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<int, string>)new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 4:
+                    {
+                        instance.ReferenceParams<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<int, string>)new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 5:
+                    {
+                        instance.ReferenceParams<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<int, string>)new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[4]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 6:
+                    {
+                        instance.ReferenceParams<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<int, string>)new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[4]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[5]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 7:
+                    {
+                        instance.ReferenceParams<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<int, string>)new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[4]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[5]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[6]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                default:
+                    if (args.Length < 1)
+                    {
+                        throw new global::System.ArgumentException($"Expected at least 1 argument, but got {args.Length}");
+                    }
+                    instance.ReferenceParams<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<int, string>)new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int, string>>(__tupleFallback0) }), (args.Length > 1 ? global::System.Linq.Enumerable.ToArray(global::System.Linq.Enumerable.Select(global::System.Linq.Enumerable.Range(1, args.Length - 1), i => global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[i]))) : global::System.Array.Empty<int>()));
+                    return default(global::System.Threading.Tasks.ValueTask);
+            }
+        }
+        catch (global::System.Exception ex)
+        {
+            return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+        }
+    }
+    private static global::System.Attribute[] __Attributes_0(int groupIndex)
+    {
+        return new global::System.Attribute[]
+        {
+            new global::TUnit.Core.TestAttribute(),
+            new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows")
+        };
+    }
+    public static readonly global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests>[] Entries_0 = new global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests>[]
+    {
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests>(
+            methodName: "ReferenceParams<int>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests.ReferenceParams<int>",
+            methodTypeArgumentsIdentity: "<int>",
+            filePath: "",
+            lineNumber: 373,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests.ReferenceRows()),
+    },
+},
+            methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple<int, string>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple<int, string>)) }, __mm_0.Parameters[1] with { Type = typeof(int[]), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int[])) } } },
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 0,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 0),
+    };
+}
+internal static partial class TUnit_TestRegistration
+{
+    static readonly int _r_TUnit_TestProject_Bugs__7638_WrappedWholeTupleInferenceTests_ReferenceParams__Tuple_T__25295A9B_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries<global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests>(static () => TUnit_TestProject_Bugs__7638_WrappedWholeTupleInferenceTests_ReferenceParams__Tuple_T__25295A9B_TestSource.Entries_0);
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute]
+[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")]
+internal static class TUnit_TestProject_Bugs__7638_WrappedWholeTupleInferenceTests_ReferenceArray__Tuple_T___0C3181D8_TestSource
+{
+    private static readonly global::TUnit.Core.ClassMetadata __classMetadata =     global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests", new global::TUnit.Core.ClassMetadata
+    {
+        Type = typeof(global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests),
+        TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests)),
+        Name = "WrappedWholeTupleInferenceTests",
+        Namespace = "TUnit.TestProject.Bugs._7638",
+        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"),
+        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+        Parent = null
+    });
+    private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests);
+    private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ReferenceArray", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests), "ReferenceArray", false, 1, new global::TUnit.Core.ParameterMetadata[]
+{
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<,>), [new global::TUnit.Core.GenericParameter(0, true, "T"), new global::TUnit.Core.ConcreteType(typeof(string))]), false),
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int[]), "extra", new global::TUnit.Core.ConcreteType(typeof(int[])), false)
+}));
+    private static global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args)
+    {
+        return new global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests();
+    }
+    private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken)
+    {
+        try
+        {
+            if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList<object> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0]))
+            {
+                var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]);
+                args = new object[] { new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleElements[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleElements[1])) };
+            }
+            switch (args.Length)
+            {
+                case 1:
+                    {
+                        instance.ReferenceArray<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<int, string>)new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int, string>>(__tupleFallback0) }), global::System.Array.Empty<int>());
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 2:
+                    {
+                        instance.ReferenceArray<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<int, string>)new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int, string>>(__tupleFallback0) }), (args[1] is null ? null : args[1] is int[] arr ? arr : global::TUnit.Core.Helpers.CastHelper.ToTrailingArray<int>(args[1])));
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 3:
+                    {
+                        instance.ReferenceArray<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<int, string>)new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 4:
+                    {
+                        instance.ReferenceArray<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<int, string>)new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 5:
+                    {
+                        instance.ReferenceArray<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<int, string>)new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[4]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 6:
+                    {
+                        instance.ReferenceArray<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<int, string>)new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[4]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[5]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 7:
+                    {
+                        instance.ReferenceArray<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<int, string>)new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int, string>>(__tupleFallback0) }), new int[] { global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[2]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[3]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[4]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[5]), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[6]) });
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                default:
+                    if (args.Length < 1)
+                    {
+                        throw new global::System.ArgumentException($"Expected at least 1 argument, but got {args.Length}");
+                    }
+                    instance.ReferenceArray<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int, string> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 2 } __tupleInput0 => (global::System.Tuple<int, string>)new global::System.Tuple<int, string>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0]), global::TUnit.Core.Helpers.CastHelper.Cast<string>(__tupleInput0[1])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int, string>>(__tupleFallback0) }), (args.Length > 1 ? global::System.Linq.Enumerable.ToArray(global::System.Linq.Enumerable.Select(global::System.Linq.Enumerable.Range(1, args.Length - 1), i => global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[i]))) : global::System.Array.Empty<int>()));
+                    return default(global::System.Threading.Tasks.ValueTask);
+            }
+        }
+        catch (global::System.Exception ex)
+        {
+            return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+        }
+    }
+    private static global::System.Attribute[] __Attributes_0(int groupIndex)
+    {
+        return new global::System.Attribute[]
+        {
+            new global::TUnit.Core.TestAttribute(),
+            new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows")
+        };
+    }
+    public static readonly global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests>[] Entries_0 = new global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests>[]
+    {
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests>(
+            methodName: "ReferenceArray<int>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests.ReferenceArray<int>",
+            methodTypeArgumentsIdentity: "<int>",
+            filePath: "",
+            lineNumber: 381,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests.ReferenceRows()),
+    },
+},
+            methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple<int, string>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple<int, string>)) }, __mm_0.Parameters[1] with { Type = typeof(int[]), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int[])) } } },
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 0,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 0),
+    };
+}
+internal static partial class TUnit_TestRegistration
+{
+    static readonly int _r_TUnit_TestProject_Bugs__7638_WrappedWholeTupleInferenceTests_ReferenceArray__Tuple_T___0C3181D8_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries<global::TUnit.TestProject.Bugs._7638.WrappedWholeTupleInferenceTests>(static () => TUnit_TestProject_Bugs__7638_WrappedWholeTupleInferenceTests_ReferenceArray__Tuple_T___0C3181D8_TestSource.Entries_0);
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute]
+[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")]
+internal static class TUnit_TestProject_Bugs__7638_SingletonWholeTupleInferenceTests_ValueOptional__ValueTuple_T__int_TestSource
+{
+    private static readonly global::TUnit.Core.ClassMetadata __classMetadata =     global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7638.SingletonWholeTupleInferenceTests", new global::TUnit.Core.ClassMetadata
+    {
+        Type = typeof(global::TUnit.TestProject.Bugs._7638.SingletonWholeTupleInferenceTests),
+        TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7638.SingletonWholeTupleInferenceTests)),
+        Name = "SingletonWholeTupleInferenceTests",
+        Namespace = "TUnit.TestProject.Bugs._7638",
+        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"),
+        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+        Parent = null
+    });
+    private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7638.SingletonWholeTupleInferenceTests);
+    private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ValueOptional", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7638.SingletonWholeTupleInferenceTests), "ValueOptional", false, 1, new global::TUnit.Core.ParameterMetadata[]
+{
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.ValueTuple<>), [new global::TUnit.Core.GenericParameter(0, true, "T")]), false),
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int), "extra", new global::TUnit.Core.ConcreteType(typeof(int)), false)
+}));
+    private static global::TUnit.TestProject.Bugs._7638.SingletonWholeTupleInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args)
+    {
+        return new global::TUnit.TestProject.Bugs._7638.SingletonWholeTupleInferenceTests();
+    }
+    private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7638.SingletonWholeTupleInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken)
+    {
+        try
+        {
+            if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList<object> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0]))
+            {
+                var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]);
+                args = new object[] { new global::System.ValueTuple<int>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleElements[0])) };
+            }
+            switch (args.Length)
+            {
+                case 1:
+                    {
+                        instance.ValueOptional<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 1 } __tupleInput0 => (global::System.ValueTuple<int>)new global::System.ValueTuple<int>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int>>(__tupleFallback0) }), (int)(5));
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 2:
+                    {
+                        instance.ValueOptional<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.ValueTuple<int> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 1 } __tupleInput0 => (global::System.ValueTuple<int>)new global::System.ValueTuple<int>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.ValueTuple<int>>(__tupleFallback0) }), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]));
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                default:
+                    throw new global::System.ArgumentException($"Expected between 1 and 2 arguments, but got {args.Length}");
+            }
+        }
+        catch (global::System.Exception ex)
+        {
+            return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+        }
+    }
+    private static global::System.Attribute[] __Attributes_0(int groupIndex)
+    {
+        return new global::System.Attribute[]
+        {
+            new global::TUnit.Core.TestAttribute(),
+            new global::TUnit.Core.MethodDataSourceAttribute("ValueRows")
+        };
+    }
+    public static readonly global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.SingletonWholeTupleInferenceTests>[] Entries_0 = new global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.SingletonWholeTupleInferenceTests>[]
+    {
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.SingletonWholeTupleInferenceTests>(
+            methodName: "ValueOptional<int>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.SingletonWholeTupleInferenceTests.ValueOptional<int>",
+            methodTypeArgumentsIdentity: "<int>",
+            filePath: "",
+            lineNumber: 397,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("ValueRows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.SingletonWholeTupleInferenceTests.ValueRows()),
+    },
+},
+            methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.ValueTuple<int>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.ValueTuple<int>)) }, __mm_0.Parameters[1] with { Type = typeof(int), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int)) } } },
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 0,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 0),
+    };
+}
+internal static partial class TUnit_TestRegistration
+{
+    static readonly int _r_TUnit_TestProject_Bugs__7638_SingletonWholeTupleInferenceTests_ValueOptional__ValueTuple_T__int_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries<global::TUnit.TestProject.Bugs._7638.SingletonWholeTupleInferenceTests>(static () => TUnit_TestProject_Bugs__7638_SingletonWholeTupleInferenceTests_ValueOptional__ValueTuple_T__int_TestSource.Entries_0);
+}
+
+
+// ===== FILE SEPARATOR =====
+
+// <auto-generated/>
+#pragma warning disable
+
+#nullable enable
+namespace TUnit.Generated;
+[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute]
+[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")]
+internal static class TUnit_TestProject_Bugs__7638_SingletonWholeTupleInferenceTests_ReferenceOptional__Tuple_T__int_TestSource
+{
+    private static readonly global::TUnit.Core.ClassMetadata __classMetadata =     global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.Bugs._7638.SingletonWholeTupleInferenceTests", new global::TUnit.Core.ClassMetadata
+    {
+        Type = typeof(global::TUnit.TestProject.Bugs._7638.SingletonWholeTupleInferenceTests),
+        TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.Bugs._7638.SingletonWholeTupleInferenceTests)),
+        Name = "SingletonWholeTupleInferenceTests",
+        Namespace = "TUnit.TestProject.Bugs._7638",
+        Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"),
+        Parameters = global::System.Array.Empty<global::TUnit.Core.ParameterMetadata>(),
+        Properties = global::System.Array.Empty<global::TUnit.Core.PropertyMetadata>(),
+        Parent = null
+    });
+    private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.Bugs._7638.SingletonWholeTupleInferenceTests);
+    private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("ReferenceOptional", __classType, typeof(void), __classMetadata, genericTypeCount: 1, parameters: global::TUnit.Core.ParameterMetadataFactory.ForGenericMethod(typeof(global::TUnit.TestProject.Bugs._7638.SingletonWholeTupleInferenceTests), "ReferenceOptional", false, 1, new global::TUnit.Core.ParameterMetadata[]
+{
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(object), "row", new global::TUnit.Core.ConstructedGeneric(typeof(global::System.Tuple<>), [new global::TUnit.Core.GenericParameter(0, true, "T")]), false),
+global::TUnit.Core.ParameterMetadataFactory.Create(typeof(int), "extra", new global::TUnit.Core.ConcreteType(typeof(int)), false)
+}));
+    private static global::TUnit.TestProject.Bugs._7638.SingletonWholeTupleInferenceTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args)
+    {
+        return new global::TUnit.TestProject.Bugs._7638.SingletonWholeTupleInferenceTests();
+    }
+    private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.Bugs._7638.SingletonWholeTupleInferenceTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken)
+    {
+        try
+        {
+            if (args.Length == 1 && args[0] is global::System.Collections.Generic.IReadOnlyList<object> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(args[0]))
+            {
+                var __tupleElements = global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(args[0]);
+                args = new object[] { new global::System.Tuple<int>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleElements[0])) };
+            }
+            switch (args.Length)
+            {
+                case 1:
+                    {
+                        instance.ReferenceOptional<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 1 } __tupleInput0 => (global::System.Tuple<int>)new global::System.Tuple<int>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int>>(__tupleFallback0) }), (int)(5));
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                case 2:
+                    {
+                        instance.ReferenceOptional<int>((args[0] switch { var __tupleValue0 when __tupleValue0 is not global::System.Tuple<int> && global::TUnit.Core.Helpers.DataSourceHelpers.IsTuple(__tupleValue0) && global::TUnit.Core.Helpers.DataSourceHelpers.UnwrapTupleAot(__tupleValue0) is { Length: 1 } __tupleInput0 => (global::System.Tuple<int>)new global::System.Tuple<int>(global::TUnit.Core.Helpers.CastHelper.Cast<int>(__tupleInput0[0])), var __tupleFallback0 => global::TUnit.Core.Helpers.CastHelper.Cast<global::System.Tuple<int>>(__tupleFallback0) }), global::TUnit.Core.Helpers.CastHelper.Cast<int>(args[1]));
+                        return default(global::System.Threading.Tasks.ValueTask);
+                    }
+                default:
+                    throw new global::System.ArgumentException($"Expected between 1 and 2 arguments, but got {args.Length}");
+            }
+        }
+        catch (global::System.Exception ex)
+        {
+            return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex));
+        }
+    }
+    private static global::System.Attribute[] __Attributes_0(int groupIndex)
+    {
+        return new global::System.Attribute[]
+        {
+            new global::TUnit.Core.TestAttribute(),
+            new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows")
+        };
+    }
+    public static readonly global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.SingletonWholeTupleInferenceTests>[] Entries_0 = new global::TUnit.Core.TestEntry<global::TUnit.TestProject.Bugs._7638.SingletonWholeTupleInferenceTests>[]
+    {
+        global::TUnit.Core.TestEntryFactory.Create<global::TUnit.TestProject.Bugs._7638.SingletonWholeTupleInferenceTests>(
+            methodName: "ReferenceOptional<int>",
+            fullyQualifiedName: "TUnit.TestProject.Bugs._7638.SingletonWholeTupleInferenceTests.ReferenceOptional<int>",
+            methodTypeArgumentsIdentity: "<int>",
+            filePath: "",
+            lineNumber: 404,
+            hasDataSource: true,
+            testDataSources: new global::TUnit.Core.IDataSourceAttribute[]
+{
+    new global::TUnit.Core.MethodDataSourceAttribute("ReferenceRows")
+    {
+        Factory = static dataGeneratorMetadata => global::TUnit.Core.Helpers.DataSourceFactories.FromEnumerable(dataGeneratorMetadata, static () => global::TUnit.TestProject.Bugs._7638.SingletonWholeTupleInferenceTests.ReferenceRows()),
+    },
+},
+            methodMetadata: __mm_0 with { Parameters = new global::TUnit.Core.ParameterMetadata[] { __mm_0.Parameters[0] with { Type = typeof(global::System.Tuple<int>), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::System.Tuple<int>)) }, __mm_0.Parameters[1] with { Type = typeof(int), TypeInfo = new global::TUnit.Core.ConcreteType(typeof(int)) } } },
+            createInstance: __CreateInstance_0,
+            invokeBody: __Invoke_0,
+            methodIndex: 0,
+            createAttributes: __Attributes_0,
+            attributeGroupIndex: 0),
+    };
+}
+internal static partial class TUnit_TestRegistration
+{
+    static readonly int _r_TUnit_TestProject_Bugs__7638_SingletonWholeTupleInferenceTests_ReferenceOptional__Tuple_T__int_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries<global::TUnit.TestProject.Bugs._7638.SingletonWholeTupleInferenceTests>(static () => TUnit_TestProject_Bugs__7638_SingletonWholeTupleInferenceTests_ReferenceOptional__Tuple_T__int_TestSource.Entries_0);
+}
diff --git a/tests/TUnit.Core.SourceGenerator.Tests/WholeTupleInferenceTests.cs b/tests/TUnit.Core.SourceGenerator.Tests/WholeTupleInferenceTests.cs
new file mode 100644
index 00000000000..2d721b1a928
--- /dev/null
+++ b/tests/TUnit.Core.SourceGenerator.Tests/WholeTupleInferenceTests.cs
@@ -0,0 +1,8 @@
+namespace TUnit.Core.SourceGenerator.Tests;
+
+internal class WholeTupleInferenceTests : TestsBase
+{
+    [Test]
+    public Task Test() => RunTest(Path.Combine(Git.TestsDirectory.FullName,
+        "TUnit.TestProject", "Bugs", "_7638", "WholeTupleInferenceTests.cs"), _ => Task.CompletedTask);
+}
diff --git a/tests/TUnit.Engine.Tests/Issue7638Tests.cs b/tests/TUnit.Engine.Tests/Issue7638Tests.cs
new file mode 100644
index 00000000000..081070d54e3
--- /dev/null
+++ b/tests/TUnit.Engine.Tests/Issue7638Tests.cs
@@ -0,0 +1,36 @@
+using Shouldly;
+using TUnit.Engine.Tests.Enums;
+
+namespace TUnit.Engine.Tests;
+
+public class Issue7638Tests(TestMode testMode) : InvokableTestBase(testMode)
+{
+    [Test]
+    [Arguments("NestedTupleWithTrailingParametersTests", 4, 0)]
+    [Arguments("ClosedNestedTupleConversionTests", 1, 0)]
+    [Arguments("RepeatedTupleBindingTests", 3, 0)]
+    [Arguments("WholeReferenceTupleSourceTests", 1, 0)]
+    [Arguments("InferredReferenceTupleSourceTests", 1, 0)]
+    [Arguments("WholeTupleWithTrailingParametersTests", 6, 0)]
+    [Arguments("WrappedWholeTupleInferenceTests", 6, 0)]
+    [Arguments("ExplicitWholeTupleInferenceTests", 8, 3)]
+    [Arguments("ExplicitBareReferenceTupleInferenceTests", 1, 0)]
+    [Arguments("ExplicitDirectTupleInferenceTests", 4, 0)]
+    [Arguments("ExplicitWrappedTupleInferenceTests", 6, 3)]
+    [Arguments("ExplicitSpreadColumnInferenceTests", 2, 0)]
+    [Arguments("DerivedRowWholeTupleInferenceTests", 2, 0)]
+    [Arguments("SingletonWholeTupleInferenceTests", 2, 0)]
+    [Arguments("AsyncWholeTupleInferenceTests", 6, 3)]
+    [Arguments("MutableWholeTupleReviewTests", 2, 0)]
+    [Arguments("MemberWholeTupleReviewTests", 4, 2)]
+    public async Task Whole_Tuple_Discovery_And_Failures_Agree(string className, int total, int failed)
+    {
+        await RunTestsWithFilter(
+            $"/*/TUnit.TestProject.Bugs._7638/{className}/*",
+            [
+                result => result.ResultSummary.Counters.Total.ShouldBe(total),
+                result => result.ResultSummary.Counters.Passed.ShouldBe(total - failed),
+                result => result.ResultSummary.Counters.Failed.ShouldBe(failed)
+            ]);
+    }
+}
diff --git a/tests/TUnit.TestProject/Bugs/_7638/WholeTupleInferenceTests.cs b/tests/TUnit.TestProject/Bugs/_7638/WholeTupleInferenceTests.cs
new file mode 100644
index 00000000000..4efc0780a0d
--- /dev/null
+++ b/tests/TUnit.TestProject/Bugs/_7638/WholeTupleInferenceTests.cs
@@ -0,0 +1,411 @@
+namespace TUnit.TestProject.Bugs._7638;
+
+// #7622: analyzer spreading does not yet model whole tuples with generic method types.
+#pragma warning disable TUnit0001
+
+public class NestedTupleWithTrailingParametersTests
+{
+    public static IEnumerable<((int, string), int)> ValueRows() => [((1, "tuple"), 7)];
+    public static IEnumerable<Tuple<Tuple<int, string>, int>> ReferenceRows() => [Tuple.Create(Tuple.Create(1, "tuple"), 7)];
+
+    [Test]
+    [MethodDataSource(nameof(ValueRows))]
+    public void ValueOptional<T>((T, string) row, int extra = 5) where T : struct
+    {
+        if (typeof(T) != typeof(int) || row.Item2 != "tuple" || extra != 7)
+            throw new InvalidOperationException("Expected nested tuple and supplied column");
+    }
+
+    public static IEnumerable<((int, string), int[])> ValueParamsRows() => [((1, "tuple"), [7])];
+
+    [Test]
+    [MethodDataSource(nameof(ValueParamsRows))]
+    public void ValueParams<T>((T, string) row, params int[] extra) where T : struct
+    {
+        if (typeof(T) != typeof(int) || row.Item2 != "tuple" || extra is not [7])
+            throw new InvalidOperationException("Expected nested tuple and supplied params column");
+    }
+
+    [Test]
+    [MethodDataSource(nameof(ReferenceRows))]
+    public void ReferenceOptional<T>(Tuple<T, string> row, int extra = 5) where T : struct
+    {
+        if (typeof(T) != typeof(int) || row.Item2 != "tuple" || extra != 7)
+            throw new InvalidOperationException("Expected nested tuple and supplied column");
+    }
+
+    public static IEnumerable<Tuple<Tuple<int, string>, int[]>> ReferenceParamsRows() => [Tuple.Create(Tuple.Create(1, "tuple"), new[] { 7 })];
+
+    [Test]
+    [MethodDataSource(nameof(ReferenceParamsRows))]
+    public void ReferenceParams<T>(Tuple<T, string> row, params int[] extra) where T : struct
+    {
+        if (typeof(T) != typeof(int) || row.Item2 != "tuple" || extra is not [7])
+            throw new InvalidOperationException("Expected nested tuple and supplied params column");
+    }
+}
+
+public class ClosedNestedTupleConversionTests
+{
+    public static IEnumerable<((int, (object, int)), (int, int))> Rows() => [((1, (new object(), 2)), (3, 4))];
+
+    [Test]
+    [MethodDataSource(nameof(Rows))]
+    public void ClosedNested<T>((T, (object, int)) pair, (int, int)? extra = null)
+    {
+        if (typeof(T) != typeof(int) || pair.Item2.Item2 != 2 || extra != (3, 4))
+            throw new InvalidOperationException("Expected separate columns with a closed nested tuple");
+    }
+}
+
+public class RepeatedTupleBindingTests
+{
+    public static IEnumerable<((string, string), int)> ValueRows() => [(("a", "b"), 7)];
+    public static IEnumerable<Tuple<Tuple<int, int>, Tuple<int, string>>> ReferenceRows() =>
+        [Tuple.Create(Tuple.Create(1, 2), Tuple.Create(7, "extra"))];
+    public static IEnumerable<(int, int)> WholeRows() => [(1, 2)];
+
+    [Test]
+    [MethodDataSource(nameof(ValueRows))]
+    public void RepeatedValue<T>((T, T) row, int extra = 0)
+    {
+        if (typeof(T) != typeof(string) || extra != 7)
+            throw new InvalidOperationException("Expected consistent string binding and separate extra column");
+    }
+
+    [Test]
+    [MethodDataSource(nameof(ReferenceRows))]
+    public void RepeatedReference<T>(Tuple<T, T> row, Tuple<int, string>? extra = null)
+    {
+        if (typeof(T) != typeof(int) || extra?.Item2 != "extra")
+            throw new InvalidOperationException("Expected consistent int binding and separate extra column");
+    }
+
+    [Test]
+    [MethodDataSource(nameof(WholeRows))]
+    public void RepeatedWhole<T>((T, T) row)
+    {
+        if (typeof(T) != typeof(int))
+            throw new InvalidOperationException("Expected consistent whole-row int binding");
+    }
+}
+
+public class WholeReferenceTupleSourceTests
+{
+    public static IEnumerable<Tuple<int, string>> Rows() => [Tuple.Create(1, "tuple")];
+
+    [Test]
+    [GenerateGenericTest(typeof(Tuple<int, string>))]
+    [MethodDataSource(nameof(Rows))]
+    public void WholeRow<T>(T row)
+    {
+        if (row is not Tuple<int, string> { Item1: 1, Item2: "tuple" })
+            throw new InvalidOperationException("Expected the whole reference tuple exactly once");
+    }
+}
+
+public class InferredReferenceTupleSourceTests
+{
+    public static IEnumerable<Tuple<int>> Rows() => [Tuple.Create(2)];
+
+    [Test]
+    [MethodDataSource(nameof(Rows))]
+    public void Element<T>(T value) where T : struct
+    {
+        if (typeof(T) != typeof(int) || !Equals(value, 2))
+            throw new InvalidOperationException("Expected first reference-tuple element");
+    }
+}
+
+public class WholeTupleWithTrailingParametersTests
+{
+    public static IEnumerable<(int, string)> ValueRows() => [(1, "tuple")];
+    public static IEnumerable<Tuple<int, string>> ReferenceRows() => [Tuple.Create(1, "tuple")];
+
+    [Test]
+    [MethodDataSource(nameof(ValueRows))]
+    public void ValueOptional<T>((T, string) row, int extra = 5)
+    {
+        if (typeof(T) != typeof(int) || row.Item2 != "tuple" || extra != 5)
+            throw new InvalidOperationException("Expected whole value tuple and default optional value");
+    }
+
+    [Test]
+    [MethodDataSource(nameof(ValueRows))]
+    public void ValueParams<T>((T, string) row, params int[] extra)
+    {
+        if (typeof(T) != typeof(int) || row.Item2 != "tuple" || extra.Length != 0)
+            throw new InvalidOperationException("Expected whole value tuple and empty params");
+    }
+
+    [Test]
+    [MethodDataSource(nameof(ValueRows))]
+    public void ValueArray<T>((T, string) row, int[] extra)
+    {
+        if (typeof(T) != typeof(int) || row.Item2 != "tuple" || extra.Length != 0)
+            throw new InvalidOperationException("Expected whole value tuple and empty collecting array");
+    }
+
+    [Test]
+    [MethodDataSource(nameof(ReferenceRows))]
+    public void ReferenceOptional<T>(Tuple<T, string> row, int extra = 5)
+    {
+        if (typeof(T) != typeof(int) || row.Item2 != "tuple" || extra != 5)
+            throw new InvalidOperationException("Expected whole reference tuple and default optional value");
+    }
+
+    [Test]
+    [MethodDataSource(nameof(ReferenceRows))]
+    public void ReferenceParams<T>(Tuple<T, string> row, params int[] extra)
+    {
+        if (typeof(T) != typeof(int) || row.Item2 != "tuple" || extra.Length != 0)
+            throw new InvalidOperationException("Expected whole reference tuple and empty params");
+    }
+
+    [Test]
+    [MethodDataSource(nameof(ReferenceRows))]
+    public void ReferenceArray<T>(Tuple<T, string> row, int[] extra)
+    {
+        if (typeof(T) != typeof(int) || row.Item2 != "tuple" || extra.Length != 0)
+            throw new InvalidOperationException("Expected whole reference tuple and empty collecting array");
+    }
+}
+
+public class ExplicitWholeTupleInferenceTests
+{
+    public static IEnumerable<Func<(int, string)>> Rows() => [() => (1, "tuple")];
+    public static IEnumerable<Func<((int, string), int)>> NestedRows() => [() => ((1, "tuple"), 7)];
+
+    [Test, GenerateGenericTest(typeof(long)), MethodDataSource(nameof(Rows))]
+    public void Optional<T>((T, string) row, int extra = 5)
+    {
+        if (row.Item1 is not (int or long) || row.Item2 != "tuple" || extra != 5)
+            throw new InvalidOperationException("Expected whole tuple and optional default");
+    }
+
+    [Test, GenerateGenericTest(typeof(long)), MethodDataSource(nameof(Rows))]
+    public void Params<T>((T, string) row, params int[] extra)
+    {
+        if (row.Item1 is not (int or long) || row.Item2 != "tuple" || extra.Length != 0)
+            throw new InvalidOperationException("Expected whole tuple and empty params");
+    }
+
+    [Test, GenerateGenericTest(typeof(long)), MethodDataSource(nameof(Rows))]
+    public void Array<T>((T, string) row, int[] extra)
+    {
+        if (row.Item1 is not (int or long) || row.Item2 != "tuple" || extra.Length != 0)
+            throw new InvalidOperationException("Expected whole tuple and empty trailing array");
+    }
+
+    [Test, GenerateGenericTest(typeof(long)), MethodDataSource(nameof(NestedRows))]
+    public void Nested<T>((T, string) row, int extra = 5)
+    {
+        if (row.Item1 is not (int or long) || row.Item2 != "tuple" || extra != 7)
+            throw new InvalidOperationException("Expected nested tuple with supplied column");
+    }
+}
+
+public class ExplicitBareReferenceTupleInferenceTests
+{
+    public static IEnumerable<Func<Tuple<int, string>>> Rows() => [() => Tuple.Create(1, "tuple")];
+
+    [Test, GenerateGenericTest(typeof(Tuple<int, string>)), MethodDataSource(nameof(Rows))]
+    public void WholeRow<T>(T row)
+    {
+        if (typeof(T) != typeof(Tuple<int, string>) || row is not Tuple<int, string> { Item1: 1, Item2: "tuple" })
+            throw new InvalidOperationException("Expected only the whole reference-tuple instantiation");
+    }
+}
+
+public class ExplicitDirectTupleInferenceTests
+{
+    public static IEnumerable<(int, string)> ValueRows() => [(1, "tuple")];
+    public static IEnumerable<Tuple<int, string>> ReferenceRows() => [Tuple.Create(1, "tuple")];
+
+    [Test, GenerateGenericTest(typeof(long)), MethodDataSource(nameof(ValueRows))]
+    public void Value<T>((T, string) row) => Verify(row.Item1, row.Item2);
+
+    [Test, GenerateGenericTest(typeof(long)), MethodDataSource(nameof(ReferenceRows))]
+    public void Reference<T>(Tuple<T, string> row) => Verify(row.Item1, row.Item2);
+
+    private static void Verify<T>(T value, string text)
+    {
+        if (typeof(T) != typeof(int) && typeof(T) != typeof(long)
+            || value is not (int or long) || Convert.ToInt64(value) != 1 || text != "tuple")
+            throw new InvalidOperationException("Expected both explicit long and inferred int direct tuple instantiations");
+    }
+}
+
+public class ExplicitWrappedTupleInferenceTests
+{
+    public static IEnumerable<TestDataRow<(int, string)>> Rows() => [new((1, "tuple"))];
+    public static IEnumerable<TestDataRow<Func<(int, string)>>> InnerRows() => [new(() => (1, "tuple"))];
+    public static IEnumerable<Func<TestDataRow<Func<(int, string)>>>> OuterRows() => [() => new(() => (1, "tuple"))];
+
+    [Test, GenerateGenericTest(typeof(long)), MethodDataSource(nameof(Rows))]
+    public void Direct<T>((T, string) row, int extra = 5) => Verify(row, extra);
+
+    [Test, GenerateGenericTest(typeof(long)), MethodDataSource(nameof(InnerRows))]
+    public void Inner<T>((T, string) row, int extra = 5) => Verify(row, extra);
+
+    [Test, GenerateGenericTest(typeof(long)), MethodDataSource(nameof(OuterRows))]
+    public void Outer<T>((T, string) row, int extra = 5) => Verify(row, extra);
+
+    private static void Verify<T>((T, string) row, int extra)
+    {
+        if (typeof(T) != typeof(int) || Convert.ToInt64(row.Item1) != 1 || row.Item2 != "tuple" || extra != 5)
+            throw new InvalidOperationException("Expected inferred int whole row and optional default");
+    }
+}
+
+public class ExplicitSpreadColumnInferenceTests
+{
+    public static IEnumerable<(int, long[])> ArrayRows() => [(1, [2L])];
+    public static IEnumerable<(int, long)> NullableRows() => [(1, 2L)];
+
+    [Test, GenerateGenericTest(typeof(long)), MethodDataSource(nameof(ArrayRows))]
+    public void Array<T>(T first, T[] extra)
+    {
+        if (typeof(T) != typeof(long) || Convert.ToInt64(first) != 1 || extra.Length != 1 || Convert.ToInt64(extra[0]) != 2)
+            throw new InvalidOperationException("Expected only long inferred from the array column");
+    }
+
+    [Test, GenerateGenericTest(typeof(long)), MethodDataSource(nameof(NullableRows))]
+    public void Nullable<T>(T first, T? extra) where T : struct
+    {
+        if (typeof(T) != typeof(long) || Convert.ToInt64(first) != 1 || Convert.ToInt64(extra) != 2)
+            throw new InvalidOperationException("Expected only long inferred from the nullable column");
+    }
+}
+
+#pragma warning restore TUnit0001
+
+// #7622: analyzer spreading does not yet model whole tuples with generic method types.
+#pragma warning disable TUnit0001
+public class DerivedRowWholeTupleInferenceTests
+{
+    public sealed record Row : TestDataRow<(int, string)>
+    {
+        public Row() : base((1, "tuple")) { }
+    }
+
+    public static IEnumerable<Row> Rows() => [new()];
+
+    [Test, GenerateGenericTest(typeof(long)), MethodDataSource(nameof(Rows))]
+    public void Run<T>((T, string) row)
+    {
+        if (typeof(T) != typeof(int) && typeof(T) != typeof(long)
+            || Convert.ToInt64(row.Item1) != 1 || row.Item2 != "tuple")
+            throw new InvalidOperationException("Expected both explicit long and inferred int from a derived row");
+    }
+}
+
+public class AsyncWholeTupleInferenceTests
+{
+    public static Task<IEnumerable<Func<(int, string)>>> TaskRows() =>
+        Task.FromResult<IEnumerable<Func<(int, string)>>>([() => (1, "tuple")]);
+
+    public static ValueTask<IEnumerable<Func<(int, string)>>> ValueTaskRows() =>
+        new((IEnumerable<Func<(int, string)>>)[() => (1, "tuple")]);
+
+    public static async IAsyncEnumerable<Func<(int, string)>> AsyncRows()
+    {
+        await Task.CompletedTask;
+        yield return () => (1, "tuple");
+    }
+
+    [Test, GenerateGenericTest(typeof(long)), MethodDataSource(nameof(TaskRows))]
+    public void TaskOptional<T>((T, string) row, int extra = 5) => Verify(row, extra);
+
+    [Test, GenerateGenericTest(typeof(long)), MethodDataSource(nameof(ValueTaskRows))]
+    public void ValueTaskOptional<T>((T, string) row, int extra = 5) => Verify(row, extra);
+
+    [Test, GenerateGenericTest(typeof(long)), MethodDataSource(nameof(AsyncRows))]
+    public void AsyncOptional<T>((T, string) row, int extra = 5) => Verify(row, extra);
+
+    private static void Verify<T>((T, string) row, int extra)
+    {
+        if (typeof(T) != typeof(int) || Convert.ToInt64(row.Item1) != 1 || row.Item2 != "tuple" || extra != 5)
+            throw new InvalidOperationException("Expected inferred int whole row and optional default");
+    }
+}
+#pragma warning restore TUnit0001
+
+// #7622: analyzer whole-row matching is tracked separately.
+#pragma warning disable TUnit0001
+public class WrappedWholeTupleInferenceTests
+{
+    public static IEnumerable<TestDataRow<(int, string)>> ValueRows() => [new((1, "tuple"))];
+    public static IEnumerable<TestDataRow<Tuple<int, string>>> ReferenceRows() => [new(Tuple.Create(1, "tuple"))];
+
+    [Test]
+    [MethodDataSource(nameof(ValueRows))]
+    public void ValueOptional<T>((T, string) row, int extra = 5)
+    {
+        if (typeof(T) != typeof(int) || row.Item2 != "tuple" || extra != 5)
+            throw new InvalidOperationException("Expected whole value tuple and default optional value");
+    }
+
+    [Test]
+    [MethodDataSource(nameof(ValueRows))]
+    public void ValueParams<T>((T, string) row, params int[] extra)
+    {
+        if (typeof(T) != typeof(int) || row.Item2 != "tuple" || extra.Length != 0)
+            throw new InvalidOperationException("Expected whole value tuple and empty params");
+    }
+
+    [Test]
+    [MethodDataSource(nameof(ValueRows))]
+    public void ValueArray<T>((T, string) row, int[] extra)
+    {
+        if (typeof(T) != typeof(int) || row.Item2 != "tuple" || extra.Length != 0)
+            throw new InvalidOperationException("Expected whole value tuple and empty collecting array");
+    }
+
+    [Test]
+    [MethodDataSource(nameof(ReferenceRows))]
+    public void ReferenceOptional<T>(Tuple<T, string> row, int extra = 5)
+    {
+        if (typeof(T) != typeof(int) || row.Item2 != "tuple" || extra != 5)
+            throw new InvalidOperationException("Expected whole reference tuple and default optional value");
+    }
+
+    [Test]
+    [MethodDataSource(nameof(ReferenceRows))]
+    public void ReferenceParams<T>(Tuple<T, string> row, params int[] extra)
+    {
+        if (typeof(T) != typeof(int) || row.Item2 != "tuple" || extra.Length != 0)
+            throw new InvalidOperationException("Expected whole reference tuple and empty params");
+    }
+
+    [Test]
+    [MethodDataSource(nameof(ReferenceRows))]
+    public void ReferenceArray<T>(Tuple<T, string> row, int[] extra)
+    {
+        if (typeof(T) != typeof(int) || row.Item2 != "tuple" || extra.Length != 0)
+            throw new InvalidOperationException("Expected whole reference tuple and empty collecting array");
+    }
+}
+#pragma warning restore TUnit0001
+
+#pragma warning disable TUnit0001 // #7622: whole-tuple rows with omitted tails.
+public class SingletonWholeTupleInferenceTests
+{
+    public static IEnumerable<ValueTuple<int>> ValueRows() => [new(1)];
+    public static IEnumerable<Tuple<int>> ReferenceRows() => [Tuple.Create(1)];
+
+    [Test, MethodDataSource(nameof(ValueRows))]
+    public void ValueOptional<T>(ValueTuple<T> row, int extra = 5)
+    {
+        if (typeof(T) != typeof(int) || !Equals(row.Item1, 1) || extra != 5)
+            throw new InvalidOperationException("Expected whole singleton value tuple and default tail");
+    }
+
+    [Test, MethodDataSource(nameof(ReferenceRows))]
+    public void ReferenceOptional<T>(Tuple<T> row, int extra = 5)
+    {
+        if (typeof(T) != typeof(int) || !Equals(row.Item1, 1) || extra != 5)
+            throw new InvalidOperationException("Expected whole singleton reference tuple and default tail");
+    }
+}
+#pragma warning restore TUnit0001
diff --git a/tests/TUnit.TestProject/Bugs/_7638/WholeTupleReviewRegressionTests.cs b/tests/TUnit.TestProject/Bugs/_7638/WholeTupleReviewRegressionTests.cs
new file mode 100644
index 00000000000..5184eeb0566
--- /dev/null
+++ b/tests/TUnit.TestProject/Bugs/_7638/WholeTupleReviewRegressionTests.cs
@@ -0,0 +1,52 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.TestProject.Bugs._7638;
+
+#pragma warning disable TUnit0001 // #7622: whole-tuple rows with omitted tails.
+public class MutableWholeTupleReviewTests
+{
+    public static (Fixture, string) Row() => (new Fixture(), "tuple");
+    public static Tuple<Fixture, string> ReferenceRow() => Tuple.Create(new Fixture(), "tuple");
+
+    [Test, MethodDataSource(nameof(Row))]
+    public void ValueOptional<T>((T, string) row, int extra = 5) => Verify(row.Item1, row.Item2, extra);
+
+    [Test, MethodDataSource(nameof(ReferenceRow))]
+    public void ReferenceOptional<T>(Tuple<T, string> row, int extra = 5) => Verify(row.Item1, row.Item2, extra);
+
+    private static void Verify<T>(T value, string text, int extra)
+    {
+        if (value is not Fixture { Initialized: true } || text != "tuple" || extra != 5)
+            throw new InvalidOperationException("Expected initialized mutable tuple element and optional default");
+    }
+
+    public struct Fixture : IAsyncInitializer
+    {
+        public bool Initialized;
+        public Task InitializeAsync()
+        {
+            Initialized = true;
+            return Task.CompletedTask;
+        }
+    }
+}
+
+public class MemberWholeTupleReviewTests
+{
+    public static IEnumerable<(int, string)> PropertyRows => [(1, "tuple")];
+    public static readonly IEnumerable<(int, string)> FieldRows = [(1, "tuple")];
+
+    // The explicit long cases intentionally fail; the inferred int cases must also be discovered.
+    [Test, GenerateGenericTest(typeof(long)), MethodDataSource(nameof(PropertyRows))]
+    public void PropertyOptional<T>((T, string) row, int extra = 5) => Verify(row, extra);
+
+    [Test, GenerateGenericTest(typeof(long)), MethodDataSource(nameof(FieldRows))]
+    public void FieldOptional<T>((T, string) row, int extra = 5) => Verify(row, extra);
+
+    private static void Verify<T>((T, string) row, int extra)
+    {
+        if (typeof(T) != typeof(int) || row.Item2 != "tuple" || extra != 5)
+            throw new InvalidOperationException("Expected inferred int whole tuple and optional default");
+    }
+}
+#pragma warning restore TUnit0001
diff --git a/tests/TUnit.UnitTests/AmbiguousSourceInferenceTests.cs b/tests/TUnit.UnitTests/AmbiguousSourceInferenceTests.cs
new file mode 100644
index 00000000000..28c557cdd6f
--- /dev/null
+++ b/tests/TUnit.UnitTests/AmbiguousSourceInferenceTests.cs
@@ -0,0 +1,49 @@
+using System.Reflection;
+using TUnit.Engine.Discovery;
+
+#pragma warning disable TUnit0019 // Subjects are inspected by reflection, not executed as tests.
+
+namespace TUnit.UnitTests;
+
+public class AmbiguousSourceInferenceTests
+{
+    [Test]
+    public async Task Invalid_Overloads_Preserve_Explicit_Method_Instantiation()
+    {
+        var method = typeof(MethodSubject).GetMethod(nameof(MethodSubject.Run))!;
+        var instantiations = ReflectionTestDataCollector.ResolveMethodInstantiations(typeof(MethodSubject), method).ToArray();
+
+        await Assert.That(instantiations).Count().IsEqualTo(1);
+        await Assert.That(instantiations[0].Method.GetGenericArguments()[0]).IsEqualTo(typeof(int));
+    }
+
+    [Test]
+    public async Task Invalid_Overloads_Do_Not_Abort_Class_Inference()
+    {
+        // Exercise the class inference boundary directly without executing an invalid source.
+        var infer = typeof(ReflectionTestDataCollector).GetMethod(
+            "InferClassTypeArgumentsFromOwnMemberRowType", BindingFlags.NonPublic | BindingFlags.Static)!;
+        object?[] arguments = [typeof(ClassSubject<>), new MethodDataSourceAttribute("Rows"), null];
+
+        var inferred = infer.Invoke(null, arguments);
+
+        await Assert.That(inferred).IsNull();
+        await Assert.That(arguments[2]).IsNull();
+    }
+
+    public class MethodSubject
+    {
+        public static IEnumerable<(int, string)> Rows(int value) => [(value, "row")];
+        public static IEnumerable<(int, string)> Rows(string value) => [(1, value)];
+
+        [GenerateGenericTest(typeof(int)), MethodDataSource(nameof(Rows))]
+        public void Run<T>((T, string) row, int extra = 5) { }
+    }
+
+    public class ClassSubject<T>(T value)
+    {
+        public T Value => value;
+        public static IEnumerable<int> Rows(int value) => [value];
+        public static IEnumerable<int> Rows(string value) => [value.Length];
+    }
+}
diff --git a/tests/TUnit.UnitTests/DataSourceHelpersTests.cs b/tests/TUnit.UnitTests/DataSourceHelpersTests.cs
index db8ddb9025c..868ff35ace4 100644
--- a/tests/TUnit.UnitTests/DataSourceHelpersTests.cs
+++ b/tests/TUnit.UnitTests/DataSourceHelpersTests.cs
@@ -8,6 +8,85 @@ namespace TUnit.UnitTests;
 /// </summary>
 public class DataSourceHelpersTests
 {
+    private sealed record DerivedTupleRow : TestDataRow<(int, string)>
+    {
+        public DerivedTupleRow() : base((1, "tuple")) { }
+    }
+
+    [Test]
+    public async Task RowTypeLookup_UnwrapsOneLayerIncludingDerivedRecords()
+    {
+        await Assert.That(TestDataRowUnwrapper.GetInnerDataType(typeof(DerivedTupleRow)))
+            .IsEqualTo(typeof((int, string)));
+        await Assert.That(TestDataRowUnwrapper.GetInnerDataType(typeof(TestDataRow<TestDataRow<(int, string)>>)))
+            .IsEqualTo(typeof(TestDataRow<(int, string)>));
+    }
+
+    private static void OpenTuple<T>(Tuple<T, string> row) { }
+
+    private static void ObjectTuple<T>(Tuple<T, object> row) { }
+
+    [Test]
+    public async Task NullRow_DoesNotMatchOpenTupleWithTrailingParameter()
+    {
+        var parameter = typeof(DataSourceHelpersTests).GetMethod(nameof(OpenTuple),
+            System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic)!.GetParameters()[0].ParameterType;
+        object?[] values = [null];
+        var result = TUnit.Engine.Helpers.DataUnwrapper.UnwrapWithTypes(values,
+            [new ParameterMetadata(parameter) { Name = "row", TypeInfo = new ConcreteType(parameter) },
+                new ParameterMetadata(typeof(int)) { Name = "extra", TypeInfo = new ConcreteType(typeof(int)), CachedIsOptional = true }]);
+
+        await Assert.That(result.Length).IsEqualTo(1);
+        await Assert.That(result[0]).IsNull();
+    }
+
+    [Test]
+    public async Task OpenTupleBinding_RequiresOuterAssignability()
+    {
+        var parameter = typeof(DataSourceHelpersTests).GetMethod(nameof(ObjectTuple),
+            System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic)!.GetParameters()[0].ParameterType;
+        var whole = Tuple.Create(1, new object());
+        var nested = Tuple.Create(whole, "extra");
+        await Assert.That(TupleHelper.MatchesOpenTuple(parameter, whole.GetType())).IsTrue();
+        await Assert.That(TupleHelper.MatchesOpenTuple(parameter, Tuple.Create(1, "string").GetType())).IsFalse();
+        await Assert.That(TupleHelper.MatchesOpenTuple(parameter, nested.GetType())).IsFalse();
+        await Assert.That(nested.ToObjectArrayWithTypes([parameter, typeof(string)]).Length).IsEqualTo(2);
+    }
+
+    private static void RepeatedTuple<T>(Tuple<T, T> row) { }
+
+    [Test]
+    public async Task OpenTupleBinding_RequiresConsistentRepeatedParameters()
+    {
+        var parameter = typeof(DataSourceHelpersTests).GetMethod(nameof(RepeatedTuple),
+            System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic)!.GetParameters()[0].ParameterType;
+        var whole = Tuple.Create(1, 2);
+        var nested = Tuple.Create(whole, Tuple.Create(7, "extra"));
+        await Assert.That(TupleHelper.MatchesOpenTuple(parameter, whole.GetType())).IsTrue();
+        await Assert.That(TupleHelper.MatchesOpenTuple(parameter, nested.GetType())).IsFalse();
+        await Assert.That(TupleHelper.MatchesOpenTuple(parameter, Tuple.Create(1, 2L).GetType())).IsFalse();
+        await Assert.That(nested.ToObjectArrayWithTypes([parameter, typeof(Tuple<int, string>)]).Length).IsEqualTo(2);
+    }
+
+    [Test]
+    public async Task OpenTupleBinding_DistinguishesWholeAndNestedRows()
+    {
+        var parameter = typeof(DataSourceHelpersTests).GetMethod(nameof(OpenTuple),
+            System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic)!.GetParameters()[0].ParameterType;
+        var whole = Tuple.Create(1, "tuple");
+        var nested = Tuple.Create(whole, 7);
+        var mismatched = Tuple.Create(1, 2);
+
+        await Assert.That(TupleHelper.MatchesOpenTuple(parameter, whole.GetType())).IsTrue();
+        await Assert.That(TupleHelper.MatchesOpenTuple(parameter, nested.GetType())).IsFalse();
+        await Assert.That(TupleHelper.MatchesOpenTuple(parameter, mismatched.GetType())).IsFalse();
+        await Assert.That(whole.ToObjectArrayWithTypes([parameter, typeof(int)]).Length).IsEqualTo(1);
+        var columns = nested.ToObjectArrayWithTypes([parameter, typeof(int)]);
+        await Assert.That(columns.Length).IsEqualTo(2);
+        await Assert.That(columns[0]).IsEqualTo((object)whole);
+        await Assert.That(columns[1]).IsEqualTo((object)7);
+    }
+
     [Test]
     [Arguments(null, false)]
     [Arguments("text", true)]