fix(resolve): same-line if-is smart-cast, as-cast type inference, nested-ctor qualifier loss

[Hessesian]

Summary

Three fixes from a Gap-scout pass on the real Moneta corpus (resolution-accuracy benchmark against main tip), each independently verified:

• start: if_is_smart_cast's backward scan (infer_lines.rs) excluded the cursor's own line — if (drawable is Animatable) drawable.start() puts the test and the access on one physical line, never inspected. Made the range inclusive.
• finishAffinity/general: no code path inferred a type from as/as? cast expressions at all. Added as_expression to infer_expr_type_at_depth's CST dispatch (expr_type.rs) — the cast's own target type is the expression's type, verbatim.
• fragmentArguments/fragmentBundle: constructor_fallback (chain.rs) reported only the bare leaf name for a nested-class constructor call (Outer.Builder(...) → "Builder"), discarding the qualifier and colliding with every other same-named nested class in the corpus once that bare name hit a global lookup. Now uses the callee's full dotted text.

Investigated, not implemented

A fourth candidate (firstOrNull/filter/toString) was scoped from an initial hypothesis (generic-arg stripping in value_path_anchor) that direct testing disproved: infer_variable_type already strips generics before that function ever sees them, and tracing the benchmark's actual reference-classification path (resolve_identity, cst_symbol.rs) showed it passes a CST-resolved uppercase receiver_type into qualified resolution — routing through type_path_anchors, not value_path_anchor at all (that function only serves the LSP cursor char-scan path, a different consumer). Left for a fresh, correctly-targeted investigation rather than forcing a fix based on the disproven premise.

Test plan

• cargo test — 1940 passed, 0 failed
• cargo clippy --all-targets -- -D warnings — clean
• Every fix has a red-before/green-after test; two required a decoy fixture to avoid a global bare-name fallback masking the real behavior (documented inline)
• Live-verified against the real Moneta corpus (resolution-accuracy): recall 90.9%→91.4%, Gap total 8342→7652 (member-ref). start and fragmentArguments/fragmentBundle both confirmed gone from the Gap top-20.
• finishAffinity did NOT move despite the as-cast fix being independently verified correct in isolation — the real call site sits several lambda/when scopes below its val ... as Activity declaration, pointing at a separate, pre-existing cross-scope variable-lookup gap upstream of this fix. Documented in the commit message, not chased further here.

🤖 Generated with Claude Code

https://claude.ai/code/session_01L7ZonwYUh94VsuQphiHykF

[Copilot]

🟡 Changes recommended

Four unresolved moderate findings remain in smart-cast, cast nullability, and qualified-constructor resolution.

Get a fresh assessment by requesting another Copilot review.

Pull request overview

Improves Kotlin resolver inference for same-line smart casts, cast expressions, and qualified nested-class constructors.

Changes:

• Includes the current line in smart-cast scanning.
• Adds as/as? expression type inference.
• Preserves qualified nested-constructor names and adds regression tests.

File summaries

File	Summary
src/resolver/tests.rs	Adds same-line smart-cast coverage.
src/resolver/infer_lines.rs	Expands smart-cast scanning. Moderate (3 votes): the line-wide scan can incorrectly retain a smart cast after a semicolon.
src/queries.rs	Adds the as_expression CST kind.
src/indexer/infer/mod_tests.rs	Adds cast and nested-constructor tests.
src/indexer/infer/expr_type.rs	Infers types from cast expressions. Moderate (3 votes): safe casts are inferred as non-null instead of nullable.
src/indexer/infer/chain.rs	Preserves qualified constructor names. Moderate (1 vote each): qualified names are rejected by the normal resolver gate, and formatted qualified calls are not normalized.

Review details

Suppressed comments (2)

src/indexer/infer/chain.rs:855

• Returning Outer.Builder here does not reach the intended qualified resolver in the normal member-reference path. cst_symbol accepts a CstQuery receiver only when indexer.has_type_definition(...) succeeds, but nested symbols are indexed by their leaf name and the qualified resolver explicitly notes that no literal Outer.Builder symbol exists; the new value is therefore rejected, receiver_type becomes None, and resolution falls back to the same global lookup. Update that receiver-type gate/normalization and add an end-to-end Outer.Builder(...).member test alongside this fallback.

    let type_name = if ctx.callee.kind() == KIND_NAV_EXPR {
        ctx.callee
            .utf8_text(ctx.bytes)
            .map(str::to_owned)
            .unwrap_or_else(|_| ctx.fn_name.to_owned())

src/indexer/infer/chain.rs:855

• utf8_text preserves source formatting, so valid Outer . Builder(...) (or a newline/comment around .) produces whitespace/comment bytes in type_name. resolve_symbol splits dotted names without normalizing those bytes, so this fallback cannot resolve the qualified type for formatted calls. Build the name from CST identifier segments instead of raw callee text, and add a formatted-qualified regression test.

    let type_name = if ctx.callee.kind() == KIND_NAV_EXPR {
        ctx.callee
            .utf8_text(ctx.bytes)
            .map(str::to_owned)
            .unwrap_or_else(|_| ctx.fn_name.to_owned())

• Files reviewed: 6/6 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.