fix(mocks): let one type be mocked regularly and wrapped in one compilation

[thomhurst]

Fixes #6834.

Problem

Reaching one type through both a regular mock and Mock.Wrap in the same compilation aborts the generator:

warning CS8785: Generator 'MockGenerator' failed to generate source. ... Exception was of type
'ArgumentException' with message 'The hintName 'MyNamespace_MyType_MockImplFactory.g.cs' of the
added source file must be unique within a generator. (Parameter 'hintName')'

Because the generator aborts, every mock in the compilation disappears and the build fails with a cascade of CS1061 "does not contain a definition for ..." errors on unrelated mocks; the real cause is visible only in that one warning.

var partial = Service.Mock();          // on its own: fine
var wrapped = Mock.Wrap(new Service()); // on its own: fine
                                        // together: the generator aborts

Mock.Of<T>() and Mock.Wrap(instance) produce two MockTypeModels differing only in IsWrapMock. Model equality includes that flag, so both survive dedup — correctly, since each needs its own impl and factory — but GenerateWrapMock and GenerateSingleTypeMock both routed through GenerateImplFactoryMembersAndEvents, adding the same _MockImplFactory.g.cs, _MockMembers.g.cs and _MockEvents.g.cs hint names.

GeneratedNameCollisionDetector already recognised this situation — its own comment names "Mock.Of and Mock.Wrap of one type" as models sharing an identity — and deliberately does not report TM008 for it, but nothing downstream prevented the duplicate emission.

Fix

The wrap impl and factory are already distinct types ({name}WrapMockImpl / {name}WrapMockFactory, both file-scoped), so they only needed a hint name of their own: {name}_WrapMockImplFactory.g.cs.

The setup and verification surface is a different matter. It describes the mocked type rather than the construction mode, is byte-identical between the two models, and its extension class is not file-scoped — so it has to be emitted exactly once. A new SharedMemberSurfaceResolver step runs over the collected requests and assigns ownership: the regular model emits it (it also emits the static Mock() entry point), and a wrap model emits it only when it is the type's only model.

The identity used to recognise one target reached in several modes is now shared with GeneratedNameCollisionDetector, which already had to tell that case apart from a genuine #6505 collision.

Tests

• tests/TUnit.Mocks.Tests/Issue6834Tests.cs — one type used both ways in one compilation: the regular mock, the wrap mock falling through to the real instance and then being configured, one setup surface serving both, and raise extensions emitted once and working for both.
• tests/TUnit.Mocks.SourceGenerator.Tests/Issue6834Tests.cs — a snapshot of the dual-mode output plus assertions that hint names are unique, that both impl/factory files are present, that _MockMembers.g.cs is emitted exactly once, and that wrapping without a regular mock still emits the member surface.

Four existing wrap snapshots are re-recorded. Renaming the wrap hint changes where that file sorts in the concatenated snapshot; the generated code is unchanged (verified by comparing the sorted contents).

Suites on net10.0: TUnit.Mocks.Tests 1309/1309, TUnit.Mocks.SourceGenerator.Tests 156/156, Analyzers 63/63, Http 58/58, Logging 31/31, InternalsAccess 29/29.

Note

#6833 works around this bug by using two separate types in its tests (VirtualInitOnlyProperty / WrappableInitOnlyProperty). Once this merges that split is no longer needed and the comment there can go.

Summary by CodeRabbit

• Bug Fixes

  • Improved handling when the same type is mocked through both regular and wrapped modes.
  • Prevented duplicate generated mock APIs and naming collisions.
  • Ensured wrapped mocks continue forwarding unconfigured calls correctly.

• Tests

  • Added regression coverage for shared setup, verification, event handling, factory naming, and generated output.
  • Updated snapshots to reflect consistent generated mock APIs and ordering.

[chatgpt-codex-connector]

You have reached your Codex usage limits for code reviews. You can see your limits in the Codex usage dashboard.

[coderabbitai]

No actionable comments were generated in the recent review. 🎉

ℹ️ Recent review info

⚙️ Run configuration

Configuration used: Organization UI

Review profile: CHILL

Plan: Advanced

Run ID: c8d8a335-262c-4a5d-8812-8a9f99d17239

📥 Commits

Reviewing files that changed from the base of the PR and between ad3a4e0 and 4a3fcf0.

📒 Files selected for processing (12)

• src/TUnit.Mocks.SourceGenerator/Discovery/GeneratedNameCollisionDetector.cs
• src/TUnit.Mocks.SourceGenerator/Discovery/MockTypeIdentity.cs
• src/TUnit.Mocks.SourceGenerator/Discovery/SharedMemberSurfaceResolver.cs
• src/TUnit.Mocks.SourceGenerator/MockGenerator.cs
• src/TUnit.Mocks.SourceGenerator/Models/MockTypeModel.cs
• tests/TUnit.Mocks.SourceGenerator.Tests/Issue6834Tests.cs
• tests/TUnit.Mocks.SourceGenerator.Tests/Snapshots/Class_Constructor_Callback_Initialization_Snapshot.verified.txt
• tests/TUnit.Mocks.SourceGenerator.Tests/Snapshots/Type_Mocked_Regularly_And_Wrapped.verified.txt
• tests/TUnit.Mocks.SourceGenerator.Tests/Snapshots/Wrap_Mock_Filters_Internal_Virtual_Members_From_External_Assembly.verified.txt
• tests/TUnit.Mocks.SourceGenerator.Tests/Snapshots/Wrap_Mock_With_Generic_Constrained_Virtual_Methods.verified.txt
• tests/TUnit.Mocks.SourceGenerator.Tests/Snapshots/Wrap_Mock_Without_Parameterless_Constructor.verified.txt
• tests/TUnit.Mocks.Tests/Issue6834Tests.cs

Included review availability: Your plan provides up to 8 included reviews per hour; 5 remain after this review.

---

📝 Walkthrough

Walkthrough

The source generator now supports regular and wrap mocks for the same type. It assigns distinct implementation and factory hint names, emits shared member and event surfaces once, and adds generator and runtime regression coverage.

Changes

Dual-mode mock generation

Layer / File(s)	Summary
Identity and shared-surface ownership src/TUnit.Mocks.SourceGenerator/Discovery/MockTypeIdentity.cs, src/TUnit.Mocks.SourceGenerator/Discovery/GeneratedNameCollisionDetector.cs, src/TUnit.Mocks.SourceGenerator/Discovery/SharedMemberSurfaceResolver.cs, src/TUnit.Mocks.SourceGenerator/Models/MockTypeModel.cs	Models use a shared type identity. A resolver assigns ownership of the shared member and event surface.
Separate generation outputs src/TUnit.Mocks.SourceGenerator/MockGenerator.cs	Regular and wrap mocks use separate generated outputs. Wrap generation emits the shared surface only when the model owns it.
Generator regression coverage tests/TUnit.Mocks.SourceGenerator.Tests/Issue6834Tests.cs, tests/TUnit.Mocks.SourceGenerator.Tests/Snapshots/*	Tests verify distinct hint names, one shared surface, wrapped-only generation, and updated generated sources.
Runtime dual-mode behavior tests/TUnit.Mocks.Tests/Issue6834Tests.cs	Tests verify setup, wrapped-instance forwarding, shared verification members, and event raising for both mock modes.

Priority: ➖ Normal

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

Change: Bug fix · Severity of issue fixed: Medium

Sequence Diagram(s)

sequenceDiagram
  participant TestSource
  participant MockGenerator
  participant MockRegistry
  participant MockEngine
  TestSource->>MockGenerator: Generate regular and wrap mocks
  MockGenerator->>MockRegistry: Register regular factory
  MockGenerator->>MockRegistry: Register wrap factory
  TestSource->>MockEngine: Configure shared setup
  MockEngine-->>TestSource: Handle regular and wrapped calls

Loading

Merge Risk: ⚪ Minimal · up to 4a3fc

The dual-mode mock generation change has no identified actionable risk and is ready to merge.

🚥 Pre-merge checks | ✅ 4 | ❌ 1

❌ Failed checks (1 warning)

Check name	Status	Explanation	Resolution
Docstring Coverage	⚠️ Warning	Docstring coverage is 9.09% which is insufficient. The required threshold is 80.00%. Docstring coverage is scoped to functions touched by this diff. Analyzed 22 functions across 7 files. (5 skipped: 5…	Write docstrings for the functions missing them to satisfy the coverage threshold.

✅ Passed checks (4 passed)

Check name	Status	Explanation
Description Check	✅ Passed	Check skipped - CodeRabbit’s high-level summary is enabled.
Title check	✅ Passed	The title clearly and concisely describes the main change: allowing one type to be mocked regularly and through Mock.Wrap in the same compilation.
Linked Issues check	✅ Passed	The changes satisfy the coding requirements in [#6834]. SharedMemberSurfaceResolver assigns shared-surface ownership when regular and wrap models target the same identity. GenerateWrapMock emits t…
Out of Scope Changes check	✅ Passed	The changed production files implement the linked issue directly. MockTypeIdentity centralizes the identity used by collision handling and shared-surface resolution. The new resolver and generator c…

Full details: Docstring Coverage

Explanation

Docstring coverage is 9.09% which is insufficient. The required threshold is 80.00%. Docstring coverage is scoped to functions touched by this diff. Analyzed 22 functions across 7 files. (5 skipped: 5 unsupported.)

• Fix all pre-merge checks with AI

✨ Finishing Touches 💡 1

📝 Generate docstrings 💡

• Commit to this branch
• Create a new PR

🧪 Generate unit tests (beta)

• Commit to this branch
• Create a new PR

---

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 the mock files bright
Two paths now keep their names just right
One shared surface joins the play
Wrapped calls forward without delay
Tests hop through both modes today
The generator blooms in a safer way}

_{Comment @coderabbitai help to get the list of available commands.}

[github-actions]

Code review

Reviewed the fix for #6834 (duplicate hint name when a type is reached through both Mock.Of<T> and Mock.Wrap in one compilation).

Summary of the change

• SharedMemberSurfaceResolver (new) walks the deduped request list and clears MockTypeModel.EmitsSharedMemberSurface on a wrap model whenever the same target (by MockTypeIdentity, shared with GeneratedNameCollisionDetector) is also mocked regularly.
• MockGenerator.GenerateWrapMock now emits the wrap impl/factory under its own _WrapMockImplFactory.g.cs hint name unconditionally, and only emits _MockMembers.g.cs/_MockEvents.g.cs when it owns the shared surface.
• GeneratedNameCollisionDetector's ad hoc Identity helper was extracted to the shared MockTypeIdentity.Of, so the "different mode, same target" carve-out used for TM008 and the new surface-ownership logic stay in sync by construction rather than by convention.

This is a clean, well-targeted fix. It correctly recognizes that the wrap impl/factory are already file-scoped and only needed their own hint name, while the setup/verify surface is per-type and must be emitted exactly once — assigning ownership to the regular model (since it also emits the static Mock() entry point) and falling back to the wrap model when it's the only model for that type is the right call. Coverage is strong: source-generator snapshot tests assert unique hint names, single emission of the member surface, and the "wrap only" fallback case, plus integration tests in TUnit.Mocks.Tests exercise both modes sharing one setup surface and raise extensions. Snapshot diffs are just file-ordering churn consistent with the code change, and no .received.txt files were committed.

One maintainability nit (not a live bug today):

MockTypeModel.Equals was updated to compare EmitsSharedMemberSurface, but MockTypeModel.GetHashCode was not (src/TUnit.Mocks.SourceGenerator/Models/MockTypeModel.cs). This doesn't break anything right now — the only HashSet<MockTypeModel> in the pipeline (MockGenerator.AddDistinctRequests) runs before SharedMemberSurfaceResolver sets the field to false, so every model in that set still has the default true at hash-time. But it's a latent trap: if MockTypeModel is ever hashed after the resolver runs (e.g. a future refactor reorders the pipeline, or another HashSet/Dictionary<MockTypeModel, _> is added downstream), two models that differ only in EmitsSharedMemberSurface will be unequal per Equals yet share a hash bucket — not incorrect per the .NET contract, but it signals the two members drifted out of sync. Worth adding hash = hash * 31 + EmitsSharedMemberSurface.GetHashCode(); to GetHashCode() for consistency, so future readers don't have to reason about why one boolean was special-cased out.

[greptile-apps]

Confidence Score: 5/5

The PR appears safe to merge, with the dual-mode generation path and wrap-only fallback covered by focused generator and runtime tests.

Summary

This PR prevents source-generator failure when one type is mocked both regularly and through Mock.Wrap.

• Gives wrap implementations and factories a distinct generated hint name.
• Assigns the shared setup, verification, and event surface to exactly one model.
• Reuses the existing target identity logic from generated-name collision detection.
• Adds generator snapshots and runtime coverage for regular mocks, wrapped mocks, shared setup APIs, and event raising.

Diagram

%%{init: {'theme': 'neutral'}}%%
flowchart TD
    A[Collected mock requests] --> B[Detect genuine generated-name collisions]
    B --> C[Resolve shared member-surface ownership]
    C --> D{Mocking mode}
    D -->|Regular| E[Emit regular impl and factory]
    D -->|Wrap| F[Emit wrap impl and factory with distinct hint]
    E --> G[Emit shared members and events]
    F --> H{Regular sibling exists?}
    H -->|No| G
    H -->|Yes| I[Reuse regular sibling's shared surface]

Loading

_{Reviews (1) · Last reviewed commit: "fix(mocks): let one type be mocked regul..."}