[thomhurst]

Typed [Arguments<int[]>] rows now infer T = int for a T[] method parameter in both source-generated and reflection discovery. Array matching recurses through jagged and multidimensional arrays while requiring matching ranks and vector shapes. The analyzer closes generic method array parameters using the same inference so it accepts the new supported case.

A shared table compiles each method and row declaration once and passes its symbols and emitted metadata to the two real inferrers. Its 17 cases check expected results and parity for arrays, rank mismatch, nullable parameters, params arrays and collections, nested TestDataRow<Func<(...)>>, and conflicting bindings. Includes an execution regression and reviewed generator snapshot. Interface/base-class matching remains outside this change, as allowed by the issue.

Validation on net10.0:

• Parity table: 17 passed.
• Arguments analyzer tests: 12 passed.
• New generator snapshot: passed.
• Targeted execution regression: passed in source-generated and reflection modes.
• Engine netstandard2.0 build: passed.
• Release Native AOT publish for osx-arm64: succeeded; targeted native execution passed. Publishing emits trimming/AOT warnings from existing test fixtures and dependencies.

Closes #7399

Summary by CodeRabbit

• Bug Fixes
  • Generic test methods can infer type arguments from typed array data, including array element types.
  • Typed data rows can omit trailing optional parameters and are validated against the constructed method signature.
  • Trailing arrays and supported params collections are checked for compatible argument types, including injected cancellation tokens.
  • Generic type constraints are checked when resolving test data.
• Tests
  • Added coverage for array-based inference, omitted parameters, params compatibility, and consistent inference across test discovery and generation.

[coderabbitai]

Note

Reviews paused

It looks like this branch is under active development. To avoid overwhelming you with review comments due to an influx of new commits, CodeRabbit has automatically paused this review. You can configure this behavior by changing the reviews.auto_review.auto_pause_after_reviewed_commits setting.

• Last reviewed commit: dd4f46f

Use the following commands to manage reviews:

• @coderabbitai resume to resume automatic reviews.
• @coderabbitai review to trigger a single review.

Use the checkboxes below for quick actions:

• Resume reviews
• Trigger review

Walkthrough

Typed-row inference now matches array element types in source generation and reflection. Analyzer checks use inferred generic arguments, validate constraints, and account for eligible omitted parameters and trailing array or supported params collection values.

Changes: Typed Row Inference

Layer / File(s)	Summary
Array inference and parity src/TUnit.Core.SourceGenerator/Extensions/TypedDataSourceInference.cs, src/TUnit.Engine/Discovery/ReflectionTestDataCollector.cs, tests/TUnit.Core.SourceGenerator.Tests/TypedRowInferenceParityTests.cs	Both inference implementations recursively match array element types when ranks and single-dimensional zero-based array shapes match. The parity test compares inference results across parameter and row shapes.
Analyzer generic arguments and parameter validation src/TUnit.Analyzers/TestDataAnalyzer.cs, tests/TUnit.Analyzers.Tests/ArgumentsAnalyzerTests.cs, tests/TUnit.Core.SourceGenerator.Tests/TypedArrayParamsAnalyzerTests.cs, tests/TUnit.Core.SourceGenerator.Tests/TUnit.Core.SourceGenerator.Tests.csproj	The analyzer constructs generic method signatures from inferred type arguments, checks constraints, and accounts for eligible omitted parameters. It validates values against trailing array or supported params collection element types. Tests cover typed rows, optional parameters, injected cancellation tokens, params collections, and constraint diagnostics.
Array argument execution coverage tests/TUnit.TestProject/Bugs/_7399/TypedArrayArgumentsTests.cs, tests/TUnit.Core.SourceGenerator.Tests/TypedArrayArgumentsTests.cs, tests/TUnit.Core.SourceGenerator.Tests/TypedArrayArgumentsTests.Test.verified.txt	An engine test supplies an integer array to a generic array parameter. The source-generator test and verified output cover generated metadata and invocation dispatch.

Estimated code review effort: 3 (Moderate) | ~20 minutes

Change: Bug fix

Possibly related issues

• thomhurst/TUnit#7463: This issue describes remaining arity restrictions for expanded tuple values targeting trailing arrays or params collections. Those shapes relate to the typed-row validation covered here.
• thomhurst/TUnit#7223: This issue requests array element matching for generic class constructor parameters. This PR adds matching for generic method parameters, but does not change class-constructor inference.
• thomhurst/TUnit#7386: This issue requests a shared parity test for typed-row inference. This PR adds a test that compares source-generator and reflection inference.

Possibly related PRs

• thomhurst/TUnit#7343: This PR changes the typed-row method inference path introduced in PR #7343 by adding recursive array element matching.
• thomhurst/TUnit#7455: Both PRs affect typed-source method inference. This PR adds recursive array matching to the inference results used by discovery.

Merge Risk: Low · up to dd4f4

Invalid typed array rows may escape the analyzer’s constraint diagnostic. The remaining risk is bounded but warrants owner awareness.

Pre-merge checks: 4 · 1

Failed checks: 1 warning

Check name	Status	Explanation	Resolution
Docstring Coverage		Docstring coverage is 38.46% which is insufficient. The required threshold is 80.00%. Docstring coverage is scoped to functions touched by this diff with cyclomatic complexity of at least 2. Documenta…	Write docstrings for the functions missing them to satisfy the coverage threshold.

Passed checks: 4 passed

Check name	Status	Explanation
Description Check		Check skipped - CodeRabbit’s high-level summary is enabled.
Title check		The title "Infer generic method types from typed array rows in both discovery modes" matches the main change. The PR adds array-element type inference for typed [Arguments<int[]>] rows in both the s…
Linked Issues check		Directly linked issue [#7399] requires three things: array element inference in both discovery modes, a shared generator/reflection parity table, and a failing test when the two inferrers disagree. Ch…
Out of Scope Changes check		The production changes support typed-row array inference in both discovery paths and the closed-signature analyzer check. TypedDataSourceInference.cs and ReflectionTestDataCollector.cs implement t…

Full details: Title check

Explanation

The title "Infer generic method types from typed array rows in both discovery modes" matches the main change. The PR adds array-element type inference for typed [Arguments<int[]>] rows in both the source generator and reflection discovery, plus analyzer support for the same case. The title is specific and single-sentence. It does not mention the analyzer or parity tests, but those are secondary to the primary change.

Full details: Linked Issues check

Explanation

Directly linked issue [#7399] requires three things: array element inference in both discovery modes, a shared generator/reflection parity table, and a failing test when the two inferrers disagree. Checked at the reviewed head: (1) Generator: TypedDataSourceInference.MapTypeParameters recurses into IArrayTypeSymbol element types when Rank and IsSZArray match, so T[] with int[] binds T = int. (2) Reflection: ReflectionTestDataCollector.InferTypesFromTypedRow gains the same array recursion (rank and SZ shape check). The body read was truncated, so this rests on the diff summary and the prior assessment, not a full read. (3) Parity table: TypedRowInferenceParityTests.Shapes() covers T[], T[,], T[][], rank mismatch (T[] vs int[,], expected null), T?, params T[], params string[] after a required parameter, params ReadOnlySpan<T>, params IEnumerable<T> (NET9+), nested TestDataRow<Func<(int, int)>>, and conflicting bindings. Generator_and_reflection_infer_the_same_types compiles one method, asserts the expected result for each mode, and asserts that null-ness agrees. This meets the parity requirement. Interface and base-class matching is optional in [#7399] and is not required here. The ReadOnlySpan execution follow-up is tracked in [#7462] and is not required by [#7399]. The tests were not executed in this review; PASS rests on source inspection and the reported validation.

Full details: Out of Scope Changes check

Explanation

The production changes support typed-row array inference in both discovery paths and the closed-signature analyzer check. TypedDataSourceInference.cs and ReflectionTestDataCollector.cs implement the array recursion for [#7399]. TestDataAnalyzer.cs applies the same inference to generic method array parameters, which the PR description says is needed for the analyzer to accept the new supported case. The analyzer changes also cover optional, params, and trailing-array handling. These are supporting behaviors for the same array-row inference, not unrelated work. The tests and generator snapshot (ArgumentsAnalyzerTests, TypedArrayParamsAnalyzerTests, TypedRowInferenceParityTests, TypedArrayArgumentsTests, and TypedArrayArgumentsTests.Test.verified.txt) verify these changes. The project reference from the source generator test project to TUnit.Analyzers supports the analyzer tests. Tuple arity ([#7463]) and ReadOnlySpan execution ([#7462]) are documented as separate follow-ups and are not present in this change. No unrelated production area appears in the reviewed scope. Analyzer test totals were not re-run in this review.

Full details: Docstring Coverage

Explanation

Docstring coverage is 38.46% which is insufficient. The required threshold is 80.00%. Docstring coverage is scoped to functions touched by this diff with cyclomatic complexity of at least 2. Documentation-only edits and deletions within surviving functions are included; unchanged diff context and fully deleted functions are excluded. Analyzed 13 functions across 8 files.

Resolution

Write docstrings for the functions missing them to satisfy the coverage threshold.

Finishing Touches

Generate docstrings

• Commit to this branch
• Create a new PR

Generate unit tests (beta)

• Commit to this branch
• Create a new PR

• Autofix · Keep fixing CodeRabbit findings and required CI, and resolving merge conflicts

Warning

Some tools did not complete. Review the errors below.

ast-grep (0.51.1)

ast-grep could not parse rule config: /ast-grep-rules/ast-grep-essentials/rules/rust/security/postgres-empty-password-rust.yml

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

Share

• X
• Mastodon
• Reddit
• LinkedIn

_{A rabbit checks each row with care,
And finds the element hiding there.
The arrays match; the types align,
Constraints and optional values shine.
The test rows hop through every case,
Then leave a clean result in place.}

CodeRabbit Verify

• Run CodeRabbit Verify to test the changes in this pull request.

[thomhurst]

@codex review

[chatgpt-codex-connector]

Codex Review Summary

This comment shows the latest Codex review activity on this pull request.

Review	Status	Commit	Review trigger
📝 Code Review	✅ Completed 2026-11-03T07:29:50.837562Z	dd4f46f	New commits

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review" or "@codex security review".

Codex reacts with 👀 while any review is running, comments if it has suggestions, and reacts with 👍 once all reviews finish with no findings.

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 646c138faa

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[greptile-apps]

Confidence Score: 5/5

[Medium impact] The PR appears safe to merge; no new actionable issues remain.

Summary

Typed array rows now infer generic method element types in both discovery modes. The analyzer checks those rows against the closed method signature.

• Typed array rows now infer generic element types in both discovery modes.
• The analyzer checks typed rows against inferred generic method signatures.

_{Reviews (9) · Last reviewed commit: "fix: accept omitted trailing arrays in t..." · Reviewed by Greptile}

[github-actions]

Review

The change is small and coherent. Typed [Arguments<int[]>] rows now infer T = int for a T[] parameter. The generator and the reflection path get the same array-recursion rule, and the analyzer closes the method over the inferred types.

What I checked:

• Parity: the generator matches on Rank and IsSZArray. Reflection matches on GetArrayRank() and the existing IsSingleDimensionalZeroBasedArray helper, which already exists in the file. A rank-1 T[*] array is therefore not confused with T[].
• Tests: the parity table compiles each declaration once and runs both real inferrers. It asserts the expected result as well as parity, so both modes returning null cannot pass unnoticed. It covers jagged and multidimensional arrays, rank mismatch, nullable parameters, params collections and nested TestDataRow. There is also an execution regression, an analyzer test and a reviewed snapshot.

Minor points, none blocking:

1. The parity test reaches the inferrers through reflection on non-public members (InferTypesFromTypedRow and TUnit.Analyzers.Extensions.TypedDataSourceInference looked up by string). A rename would fail at runtime in the test rather than at compile time. InternalsVisibleTo or a shared linked source file would give compile-time safety. A runtime failure with a clear throwOnError message is acceptable here.
2. The long-term fix for duplicated generator and reflection inference is a single shared algorithm, for example a linked source file over an abstraction of type shapes. This PR keeps the duplication but guards it with the parity table, which is a reasonable trade-off. Please keep adding cases there as inference grows.
3. The analyzer branch only runs when an array parameter references a method type parameter. That limits the blast radius, and method.Construct(inferred) is guarded by a non-null result.

Looks good to merge once CI is green.

[thomhurst]

@codex review

Fixed the optional-parameter and inferred-constraint findings in c197077. Validation: 15 arguments-analyzer tests and 16 typed-data-source analyzer tests passed on net10.0.

[github-actions]

Review of #7460

I found no blocking issues. The change is small and focused, and the tests cover it well.

• Inference parity: the array recursion is the same in the source generator (TypedDataSourceInference) and the reflection collector (ReflectionTestDataCollector). Both require matching rank and SZ-array shape, so T[] does not match int[,], and jagged and multidimensional arrays recurse correctly.
• Tests: TypedRowInferenceParityTests runs the real generator and reflection inferrers against the same compiled declaration and asserts both the expected result and parity. That guards against the two modes drifting apart. The analyzer tests cover omitted optionals, a constraint diagnostic, and a typed source.
• Execution test and snapshot: the new _7399 test and .verified.txt snapshot look intentional.

Non-blocking suggestions:

1. Analyzer shortcut: the analyzer block in TestDataAnalyzer.CheckDataGenerator re-implements the "trailing optional/params parameters can be omitted" logic inline. Pulling it into a helper shared with the other closed-method path would keep the two from diverging.
2. Gating condition: the block only runs when an array parameter references a method type parameter. If a bare T sits next to a T[] in the same method, constraint checks run in this branch and not the later one. The existing tests suggest this is handled. A test combining T value, T[] values with a non-array row mismatch would pin it down.

Nice work.

[chatgpt-codex-connector]

Codex Review: Didn't find any major issues. Nice work!

Reviewed commit: c197077465

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[thomhurst]

Current head c197077 has positive Claude and Codex verdicts, and all blocking findings are fixed with resolved threads. The suggested helper extraction and extra parity cases are non-blocking follow-ups; the current targeted regressions cover the reported failures. Promoting to ready for CI and the required fresh Claude review.

[thomhurst]

Marked ready at unchanged head c197077. Waiting for post-promotion Claude review run 41590636200 and CI (.NET 41590635394; AOT 41590635416). Auto-merge remains unarmed until that fresh Claude run passes and its comment is read; then use scripts/Enable-AutoMerge.ps1. No blocking findings or unresolved threads remain.

[github-actions]

Review: typed array row inference (#7399)

I found no blocking issues. The change is small and focused.

What looks good

• Source-generator and reflection inference use the same rule: ranks must match, and SZ-array shape must match. So int[,] cannot bind to T[], and int[*] cannot bind to int[]. The recursion also covers jagged and multidimensional arrays.
• TypedRowInferenceParityTests compiles each declaration once and feeds the Roslyn symbols and the emitted reflection metadata to the two real inferrers. It asserts the expected result as well as parity, so both sides returning null cannot hide a bug. Parity tests like this keep the two metadata-collection paths from drifting apart.
• The analyzer closes the method with the inferred arguments before matching. It checks constraints first, while the original type parameters are still available. That avoids false positives on T[].
• The execution regression, the generator snapshot, and the analyzer cases for omitted optional parameters and constraint diagnostics are sufficient.

Suggestions (non-blocking)

1. The analyzer's "trim trailing optional parameters when the row is shorter" logic is inline in TestDataAnalyzer. It looks like a rule that the generator and reflection paths also apply. Pulling it into a shared helper next to TypedDataSourceInference would make it harder for the analyzer and discovery to disagree later.
2. The parity test finds the inferrers by reflection on internal names (InferMethodTypeArgumentsFromRowType, InferTypesFromTypedRow). A rename will surface as a null method lookup at runtime rather than a compile error. An InternalsVisibleTo or a small internal seam would be sturdier. This is acceptable for a test-only dependency.
3. The reflection check IsSingleDimensionalZeroBasedArray is cheap, but discovery is a hot path. Make sure it is not evaluated repeatedly per row for the same parameter type. Caching the per-method inference result would help if profiling shows it matters.

Looks good to merge once CI is green.

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: c197077465

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[coderabbitai]

• Fix comments: Fix CodeRabbit comments on this PR

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 7618f369a8

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[thomhurst]

Run 41590636200 completed successfully, so the earlier wait no longer holds. Fixed the new token/params findings in 08e098b and verified the existing wrapper fix with the exact reported regression. All 21 ArgumentsAnalyzerTests passed on net10.0. All review threads are dispositioned and resolved. Fresh CI and automated reviews are queued for this head; auto-merge remains unarmed until the current-head reviews pass. Non-blocking helper/caching suggestions remain follow-ups; this patch changes only analyzer validation.