fix(mocks): respect generic type argument accessibility (#5453)

[thomhurst]

Summary

• Fixes [Bug]: CS9338 for class mock when class is not public #5453: source generator emitted public mock wrappers and extension classes for public generic interfaces closed over a non-public type argument (e.g. Mock.Of<ILogger<InternalClass>>()), producing CS9338/CS0051 inconsistent-accessibility errors.
• Extends the effective-accessibility check from [Bug]: CS9338 for interface mock when interface is not public #5426 — which only walked containing types — to also recursively walk generic type arguments and array element types. Collapses the previous helper pair into a single IsEffectivelyPublic(ITypeSymbol) that switches on type kind.
• Adds compile-time regression tests in TUnit.Mocks.Tests/Issue5453Tests.cs. If the generator regresses, the test project will not build.

Test plan

• New Issue5453Tests (3 tests, including a separate internal sealed partial case matching the original report) pass
• All 775 TUnit.Mocks.Tests pass
• All 35 TUnit.Mocks.SourceGenerator.Tests snapshot tests pass — no snapshot churn
• All 30 TUnit.Mocks.Analyzers.Tests pass

[claude]

Code Review

This is a clean, well-scoped fix for the generic type argument accessibility leak. The analysis is correct and the implementation handles the full problem well.

What the fix does right

The original IsEffectivelyPublic only walked the containing-type chain, so ILogger<InternalClass> would pass (the interface itself is public), while the bound type argument InternalClass was never inspected. The new approach recursively descends all structural positions — containing types, type arguments, array elements — which is the correct complete model of effective public accessibility.

The collapse from a helper pair into one IsEffectivelyPublic(ITypeSymbol) switch is a good simplification; the single-entry-point recursive approach is easier to reason about and extend.

One architectural observation worth considering

The ITypeParameterSymbol → true branch is defensively correct (open generics can't be mocked directly at a call site), but the comment could be tightened: if an unbound generic were somehow discovered, emitting a public wrapper for an unconstrained T is only safe because Roslyn won't bind a generic type argument to a non-public symbol in a context visible to the generator. This is a reasonable assumption but might be worth a one-liner note so a future reader understands the invariant, not just the decision.

Edge case coverage looks solid

A quick mental walkthrough of harder cases:

• IReadOnlyDictionary<string, IEnumerable<InternalClass>> → descends two levels, correctly returns false ✓
• Jagged arrays InternalClass[][] → recursion through nested IArrayTypeSymbol → INamedTypeSymbol → false ✓
• Nullable<InternalStruct> → Nullable<T> is public, descends to InternalStruct → false ✓

Test file

The three test cases are well-chosen:

1. Basic internal type argument
2. partial modifier (preserves traceability to the original report)
3. Task<T> return path (different generated extension overload)

The compile-time-failure-as-regression-test pattern is the right call here — if the generator regresses, you find out at build time, not at runtime.

One cosmetic note: the nested classes InternalConsumer / InternalPartialConsumer could sit in a dedicated Issue5453TestTypes static class at the top to make the internal visibility unambiguous (nested classes inside a public outer class are internal-by-default in C# but readers occasionally have to stop and think about it). Not a blocking concern.

Summary

Correct fix, correct scope, good tests. No issues blocking merge.

[codacy-production]

Not up to standards ⛔

🔴 Issues 2 minor

Alerts:
⚠ 2 issues (≤ 0 issues of at least minor severity)

Results:
2 new issues

Category	Results
CodeStyle	2 minor

View in Codacy

🟢 Metrics 4 complexity

Metric	Results
Complexity	4

View in Codacy

_{TIP This summary will be updated as you push new changes. Give us feedback}