fix(resolve): enum name/ordinal go-to-def + whole-receiver-as-T generic return substitution

[Hessesian]

Summary

Two scouted fixes from the "name"/"title"/"text" Gap investigation the user pushed back on (correctly flagging real value, not import-filtering noise). Stacked on #317.

• .name/.ordinal resolution: these are compiler-generated kotlin.Enum instance members, same class of gap as .entries/values()/valueOf() which synthesize_enum_members already handled. Its own doc comment claimed .name/.ordinal were "a separate, already-handled concern" via the indexer's synthetic_enum_field — that helper only feeds type inference (hover/inlay chain propagation), never a real go-to-def Location, so qualified resolution dead-ended. Extended the same synthesis site. Confirmed on the real Moneta corpus: name drops out of the member-ref Gap list entirely (was fix: recover annotation-mis-parsed interfaces + strip suspend before receiver type #182, e.g. Insurance.EType.entries.firstOrNull { it.name.equals(...) }).

• Generic return-type substitution for whole-receiver-as-T: StrategyOutcome::finalize's ReceiverDerived arm only substituted a type param nested inside the receiver's own type argument (List<T>'s T, via build_type_arg_subst). It missed the shape where the extension's own type parameter IS the whole receiver (fun <T> T?.required(field): T) — filled the gap using build_ext_fn_type_subst, an existing helper already used by a different call path, without overriding any key the existing substitution already resolved. Covered by a unit test using the real resolve_call_expr_type entry point (not just the substitution helper in isolation).

CACHE_VERSION bumped (31→32): the parser's synthesized-symbol set changed shape.

Known limitation (documented, not fixed here)

The second fix is real and correctly tested, but corpus verification showed it does not by itself move the title/text Gap counts. Root cause: chain.rs's receiver_based_method never reaches the new substitution for required()'s actual real-world declaration shape (a member extension on a bare generic type parameter receiver, fun <T : Any> T?.required(...): T inside class NullableScope) — find_method_return_type_for_type returns None before substitution ever runs, because extension_by_receiver keys extensions by literal receiver text ("T"), with no wildcard match against a concrete receiver ("String"). That's a separate, deeper extension-registry gap affecting both type inference and (likely) other consumers — left for its own scoped investigation rather than folded in here.

Test plan

• cargo test — 1930 passed, 0 failed
• cargo clippy --all-targets -- -D warnings — clean
• Both fixes have red-before/green-after unit tests
• Live-verified against the real Moneta corpus via resolution-accuracy: overall member-ref recall 91.1% (flat/slightly up vs. prior 90.8-91.0%), name gone from the Gap top-20

🤖 Generated with Claude Code

https://claude.ai/code/session_01L7ZonwYUh94VsuQphiHykF

[Copilot]

🟡 Changes recommended

Resolver correctness issues and unsafe callable metadata lookup remain unresolved.

Get a fresh assessment by requesting another Copilot review.

Pull request overview

Fixes enum name/ordinal go-to-definition and whole-receiver generic return substitution.

Changes:

• Synthesizes enum name and ordinal members.
• Adds receiver-based generic substitution and regression tests.
• Bumps the cache version to 32.

File summaries

File	Summary
src/resolver/tests.rs	Tests enum member resolution; coverage should use instance access and reject Flavor.name.
src/parser.rs	Adds synthetic enum members; current exposure can affect invalid qualified and unqualified lookups.
src/indexer/infer/mod_tests.rs	Adds whole-receiver generic substitution coverage.
src/indexer/infer/chain.rs	Applies receiver substitutions; callable metadata lookup may select the wrong declaration and adds unnecessary hot-path work.
src/indexer/cache.rs	Bumps the cache version.

Review details

Suppressed comments (3)

src/indexer/infer/chain.rs:619

• This lookup is unconditional for every ReceiverDerived call, including methods whose raw_return is already concrete. It repeats a name scan and can invoke ensure_jar_definitions_for on the chain-inference hot path, adding avoidable work to ordinary calls; gate it on an unresolved generic return or reuse metadata from method resolution.

                if let Some(info) = ctx.deps.find_fun_callable_info(ctx.fn_name, ctx.uri) {
                    if !info.extension_receiver_type.is_empty() && !info.type_params.is_empty() {

src/parser.rs:555

• name/ordinal are instance-only members, but synthesizing them with container: Some(cls.name) makes them direct members of the enum's type scope. resolve_qualified treats a TypePath such as Flavor.name as companion-only (see src/resolver/qualified.rs:92-105), so this causes invalid class-qualified accesses to resolve. Keep these symbols available from value/receiver lookups without exposing them from the type-root candidate tier, or model them through kotlin.Enum; add a negative Flavor.name regression test.

        symbols.push(SymbolEntry {
            name: "name".to_owned(),
            kind: SymbolKind::PROPERTY,
            visibility: cls.visibility,
            range: cls.selection_range,

src/resolver/tests.rs:1152

• Flavor is passed as a type qualifier here, so this exercises Flavor.name, not the intended instance access (flavor.name/it.name). Per resolve_qualified, type-qualified lookup must not return instance members; with the new symbols this assertion passes only by introducing that invalid behavior and therefore cannot prove the Moneta regression. Test through a value or lambda receiver and separately assert that Flavor.name remains unresolved.

    assert!(
        !resolve_symbol(&idx, "name", Some("Flavor"), &uri).is_empty(),
        "Flavor.name (kotlin.Enum.name) did not resolve"

• Files reviewed: 5/5 changed files
• Comments generated: 2
• Review effort level: Lite

---

💡 Add a code-review agent skill or configure MCP servers for context-aware, tailored reviews. Learn more in the docs.