gitnexus 1.6.6-rc.45 → 1.6.6-rc.47

package/dist/core/ingestion/languages/kotlin/captures.d.ts

@@ -1,2 +1,2 @@
-import type { CaptureMatch } from '../../../../_shared/index.js';
-export declare function emitKotlinScopeCaptures(sourceText: string, _filePath: string, cachedTree?: unknown): readonly CaptureMatch[];
+import { type CaptureMatch } from '../../../../_shared/index.js';
+export declare function emitKotlinScopeCaptures(sourceText: string, filePath: string, cachedTree?: unknown): readonly CaptureMatch[];

package/dist/core/ingestion/languages/kotlin/captures.js

@@ -1,3 +1,4 @@
+import { makeScopeId } from '../../../../_shared/index.js';
 import { findNodeAtRange, nodeToCapture, syntheticCapture, } from '../../utils/ast-helpers.js';
 import { getTreeSitterBufferSize } from '../../constants.js';
 import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
@@ -7,8 +8,9 @@ import { recordKotlinCacheHit, recordKotlinCacheMiss } from './cache-stats.js';
 import { normalizeKotlinType } from './interpret.js';
 import { synthesizeKotlinReceiverBinding } from './receiver-binding.js';
 import { getKotlinParser, getKotlinScopeQuery } from './query.js';
+import { markCompanionScope } from './companion-scopes.js';
 const FUNCTION_DECL_TAGS = ['@declaration.function'];
-export function emitKotlinScopeCaptures(sourceText, _filePath, cachedTree) {
+export function emitKotlinScopeCaptures(sourceText, filePath, cachedTree) {
     let tree = cachedTree;
     if (tree === undefined) {
         tree = parseSourceSafe(getKotlinParser(), sourceText, undefined, {
@@ -24,6 +26,7 @@ export function emitKotlinScopeCaptures(sourceText, _filePath, cachedTree) {
     out.push(...synthesizeKotlinLocalAssignmentBindings(tree.rootNode, returnTypes));
     out.push(...synthesizeKotlinLoopBindings(tree.rootNode, returnTypes));
     out.push(...synthesizeKotlinSmartCastBindings(tree.rootNode));
+    out.push(...synthesizeKotlinLambdaBindings(tree.rootNode, returnTypes));
     for (const match of getKotlinScopeQuery().matches(tree.rootNode)) {
         const grouped = {};
         for (const capture of match.captures) {
@@ -32,6 +35,26 @@ export function emitKotlinScopeCaptures(sourceText, _filePath, cachedTree) {
         }
         if (Object.keys(grouped).length === 0)
             continue;
+        // Companion-object marker (#1756 / U4). The `@scope.companion`
+        // capture is a side-channel marker — it shares its range with the
+        // existing `(companion_object) @scope.class` rule, so the Class
+        // scope already exists in the scope tree. Record the scope id into
+        // the per-file companion-scope set so `populateCompanionMembersOn
+        // EnclosingClass` (owners.ts) can identify companion scopes
+        // unambiguously, regardless of whether they are anonymous, named,
+        // or contain nested classes. The match itself is consumed here and
+        // NOT pushed to the output — the scope-extractor would reject the
+        // `companion` kind suffix anyway, but suppressing the emit keeps
+        // downstream pipelines from re-processing the same range twice.
+        if (grouped['@scope.companion'] !== undefined) {
+            const scopeId = makeScopeId({
+                filePath,
+                range: grouped['@scope.companion'].range,
+                kind: 'Class',
+            });
+            markCompanionScope(filePath, scopeId);
+            continue;
+        }
         if (grouped['@import.statement'] !== undefined) {
             const importNode = findNodeAtRange(tree.rootNode, grouped['@import.statement'].range, 'import_header');
             if (importNode !== null) {
@@ -234,6 +257,286 @@ function buildNarrowedTypeBindingCapture(subject, bodyAnchor, typeNode) {
         '@type-binding.narrowed': syntheticCapture('@type-binding.narrowed', bodyAnchor, '1'),
     };
 }
+/**
+ * Synthesize lambda-body type-bindings — issue #1757.
+ *
+ * For each `lambda_literal` we emit one or more `@type-binding.annotation`
+ * captures anchored INSIDE the lambda body (the lambda's `statements` child
+ * — or the `lambda_literal` itself when no statements child exists). The
+ * `@scope.block` query rule (see query.ts) makes each `lambda_literal` a
+ * Block scope, and the `@type-binding.lambda-scoped` marker forces the
+ * scope-extractor to keep the binding at the innermost (lambda body) scope
+ * via `kotlinBindingScopeFor`. This guarantees:
+ *   - explicit parameter names (`{ user -> ... }`) bind only inside the
+ *     body, NOT in the enclosing function scope;
+ *   - implicit `it` is visible only inside the lambda body and shadows
+ *     any same-named outer binding (`val it = "outer"; users.forEach
+ *     { it.save() }` — inner `it` is the lambda parameter);
+ *   - nested lambdas shadow deterministically (innermost lambda's `it`
+ *     wins; outer lambda's parameters are still visible by their own
+ *     names through the parent scope chain).
+ *
+ * Receiver-type inference is best-effort: the lambda's call-expression
+ * parent is inspected; if the receiver has a known local-variable type
+ * and the call's member is a well-known stdlib idiom (`forEach`/`map`/
+ * `filter` → element type of the collection; `let`/`apply`/`also`/`run`/
+ * `takeIf`/`takeUnless`/`use` → receiver type itself), the inferred type
+ * is attached. When inference fails (chained receivers, unknown member,
+ * non-stdlib idiom), we still emit the binding with a sentinel/erased
+ * type so the binding's scope semantics (no leak; no `it` cross-fire) are
+ * enforced — call-resolution from the body still falls through to free-
+ * call fallback, which is the correct behavior when the type is unknown.
+ *
+ * Standard-library coverage: `forEach`, `map`, `filter`, `flatMap`,
+ * `mapNotNull`, `filterNotNull`, `onEach`, `find`, `firstOrNull`,
+ * `lastOrNull`, `any`, `all`, `none`, `count`, `forEachIndexed`,
+ * `let`, `apply`, `also`, `run`, `takeIf`, `takeUnless`, `use`, `with`.
+ *
+ * Lambda-receiver typing for non-stdlib higher-order functions is a
+ * follow-up; the binding-existence guarantee above is the minimum
+ * acceptance criterion per the U9 plan.
+ */
+function synthesizeKotlinLambdaBindings(rootNode, returnTypes) {
+    const out = [];
+    const classMembers = collectKotlinClassMembers(rootNode);
+    for (const fnNode of descendantsOfType(rootNode, 'function_declaration')) {
+        const localTypes = collectKotlinLocalTypeTexts(fnNode, returnTypes);
+        for (const lambdaNode of descendantsOfType(fnNode, 'lambda_literal')) {
+            const anchor = lambdaBodyAnchor(lambdaNode);
+            if (anchor === null)
+                continue;
+            const inferredType = inferKotlinLambdaReceiverType(lambdaNode, localTypes, returnTypes, classMembers);
+            const params = explicitLambdaParameters(lambdaNode);
+            if (params.length === 0) {
+                // No explicit `(x ->)` parameter list — implicit `it` is in
+                // scope inside the body. Synthesize the `it` type-binding so
+                // calls like `it.save()` resolve through the typeBinding chain.
+                const typeNode = inferredType?.typeNode ?? lambdaNode;
+                const typeText = inferredType?.typeText ?? '';
+                out.push(buildLambdaTypeBindingCapture(anchor, 'it', typeNode, typeText));
+            }
+            else {
+                // Explicit parameters: `{ user -> ... }`, `{ (a, b) -> ... }`,
+                // `{ key, value -> ... }`. Emit one binding per parameter.
+                // For multi-arg lambdas (destructuring, `forEachIndexed { i, x
+                // -> ... }`), the per-arg type inference is finer than what we
+                // currently support — we bind the FIRST parameter to the
+                // inferred receiver type (matches single-arg idioms) and bind
+                // additional parameters with an empty/erased type, which still
+                // gates leakage but won't drive call resolution for those names.
+                for (let i = 0; i < params.length; i++) {
+                    const paramName = params[i].text;
+                    const typeNode = i === 0 ? (inferredType?.typeNode ?? params[i]) : params[i];
+                    const typeText = i === 0 ? (inferredType?.typeText ?? '') : '';
+                    out.push(buildLambdaTypeBindingCapture(anchor, paramName, typeNode, typeText));
+                }
+            }
+        }
+    }
+    return out;
+}
+/** Anchor node used for synthesized lambda-body type-bindings.
+ *  Prefers the `statements` child of `lambda_literal` (always strictly
+ *  inside the lambda body, so the scope-extractor's `rangesEqual` auto-
+ *  hoist check fails — the binding stays in the Block scope). Falls
+ *  back to the lambda_literal itself when no statements child exists
+ *  (e.g. empty lambda); the `@type-binding.lambda-scoped` marker in
+ *  `kotlinBindingScopeFor` then forces no-hoist explicitly. */
+function lambdaBodyAnchor(lambdaNode) {
+    const statements = lambdaNode.namedChildren.find((c) => c.type === 'statements');
+    return statements ?? lambdaNode;
+}
+/** Extract explicit lambda parameter `simple_identifier` nodes from a
+ *  `lambda_literal`. Returns an empty array when no `lambda_parameters`
+ *  is present (implicit `it` form). */
+function explicitLambdaParameters(lambdaNode) {
+    const params = lambdaNode.namedChildren.find((c) => c.type === 'lambda_parameters');
+    if (params === undefined)
+        return [];
+    const out = [];
+    for (const child of params.namedChildren) {
+        if (child.type !== 'variable_declaration')
+            continue;
+        const ident = child.namedChildren.find((c) => c.type === 'simple_identifier');
+        if (ident !== undefined)
+            out.push(ident);
+    }
+    return out;
+}
+function buildLambdaTypeBindingCapture(anchor, name, typeNode, typeText) {
+    return {
+        '@type-binding.annotation': nodeToCapture('@type-binding.annotation', anchor),
+        '@type-binding.name': syntheticCapture('@type-binding.name', anchor, name),
+        '@type-binding.type': syntheticCapture('@type-binding.type', typeNode, typeText === '' ? '' : normalizeKotlinType(typeText)),
+        // Marker consumed by `kotlinBindingScopeFor` (simple-hooks.ts) to
+        // pin this binding inside the lambda Block scope — without it the
+        // scope-extractor would auto-hoist the binding to the enclosing
+        // function scope and `it` (or the lambda parameter name) would
+        // leak past the closing brace.
+        '@type-binding.lambda-scoped': syntheticCapture('@type-binding.lambda-scoped', anchor, '1'),
+    };
+}
+/** Stdlib higher-order functions whose lambda parameter receives the
+ *  ELEMENT type of the receiver collection (Map / Iterable element). */
+const KOTLIN_ELEMENT_TYPE_LAMBDAS = new Set([
+    'forEach',
+    'forEachIndexed',
+    'map',
+    'mapNotNull',
+    'mapIndexed',
+    'filter',
+    'filterNot',
+    'filterNotNull',
+    'filterIsInstance',
+    'flatMap',
+    'flatten',
+    'onEach',
+    'find',
+    'findLast',
+    'firstOrNull',
+    'lastOrNull',
+    'singleOrNull',
+    'any',
+    'all',
+    'none',
+    'count',
+    'partition',
+    'sortedBy',
+    'sortedByDescending',
+    'groupBy',
+    'associate',
+    'associateBy',
+    'associateWith',
+    'minByOrNull',
+    'maxByOrNull',
+    'sumOf',
+    'distinctBy',
+]);
+/** Stdlib scope functions whose lambda receives the RECEIVER itself as
+ *  `it` (or as `this` for `apply`/`run`/`with`). For the binding-
+ *  existence guarantee we treat both forms the same way — `it` binds
+ *  to the receiver type; `apply`/`run`/`with` callers see free calls
+ *  inside the body which fall through to free-call resolution against
+ *  the enclosing scope (no `this`-aware dispatch yet — follow-up). */
+const KOTLIN_SCOPE_FUNCTION_LAMBDAS = new Set(['let', 'also', 'takeIf', 'takeUnless', 'use']);
+/** `apply`, `run`, `with` expose the receiver as `this` rather than
+ *  `it`. We still synthesize an `it` binding because the lambda may
+ *  reference the receiver elsewhere — but the more common usage
+ *  (`user.apply { save() }`) goes through free-call resolution on the
+ *  body, not through `it`. Including these here keeps the binding
+ *  scope correct without claiming we resolve `this`-form correctly. */
+const KOTLIN_THIS_RECEIVER_LAMBDAS = new Set(['apply', 'run', 'with']);
+/** Walk up from `lambdaNode` to the enclosing `call_expression` and
+ *  infer the lambda parameter's type from the call's receiver and
+ *  member name. Returns null when the inference path is not yet
+ *  supported (chained receivers, unknown member, non-stdlib idiom).
+ *
+ *  Best-effort: a null return is harmless — `synthesizeKotlinLambda
+ *  Bindings` still emits the binding with an empty type so the scope
+ *  semantics (no leak, no cross-fire) are enforced; only the call-
+ *  resolution path from `it.method()` may fall through to free-call
+ *  fallback when the type isn't known. */
+function inferKotlinLambdaReceiverType(lambdaNode, localTypes, returnTypes, classMembers) {
+    const callExpr = findEnclosingCallExpression(lambdaNode);
+    if (callExpr === null)
+        return null;
+    const callee = callExpr.namedChildren.find((c) => c.type === 'navigation_expression' || c.type === 'simple_identifier');
+    if (callee === undefined)
+        return null;
+    if (callee.type === 'simple_identifier') {
+        // `with(receiver) { ... }` — argument is the receiver. Not yet
+        // wired through; defer to follow-up.
+        return null;
+    }
+    // navigation_expression: <receiver>.<member>
+    const receiver = callee.namedChild(0);
+    const memberName = callee.namedChildren
+        .find((c) => c.type === 'navigation_suffix')
+        ?.namedChildren.find((c) => c.type === 'simple_identifier')?.text;
+    if (receiver === null || memberName === undefined)
+        return null;
+    const receiverType = inferKotlinLambdaReceiverExpressionType(receiver, localTypes, returnTypes, classMembers);
+    if (receiverType === null)
+        return null;
+    if (KOTLIN_ELEMENT_TYPE_LAMBDAS.has(memberName)) {
+        const element = kotlinContainerElementType(receiverType, 'values');
+        if (element === null || element === '')
+            return null;
+        return { typeText: element, typeNode: lambdaNode };
+    }
+    if (KOTLIN_SCOPE_FUNCTION_LAMBDAS.has(memberName) ||
+        KOTLIN_THIS_RECEIVER_LAMBDAS.has(memberName)) {
+        // Strip nullable suffix for `?.let { ... }` semantics — inside the
+        // body, the receiver is non-null per Kotlin smart-cast.
+        const stripped = normalizeKotlinType(receiverType);
+        return { typeText: stripped, typeNode: lambdaNode };
+    }
+    return null;
+}
+/** Infer the static type of the expression that produced the lambda's
+ *  enclosing call. Supports: `simple_identifier` (lookup in
+ *  `localTypes`), `indexing_expression` on a Map-typed receiver, and
+ *  `call_expression` whose callee return type is in `returnTypes`. */
+function inferKotlinLambdaReceiverExpressionType(receiver, localTypes, returnTypes, classMembers) {
+    if (receiver.type === 'simple_identifier') {
+        return localTypes.get(receiver.text) ?? null;
+    }
+    if (receiver.type === 'indexing_expression') {
+        // `posts[user]` — the underlying receiver's container type tells
+        // us the element/value type.
+        const base = receiver.namedChild(0);
+        if (base === null)
+            return null;
+        const baseType = base.type === 'simple_identifier' ? localTypes.get(base.text) : null;
+        if (baseType === undefined || baseType === null)
+            return null;
+        // Indexing a Map returns the value type; indexing a List returns
+        // the element type. `kotlinContainerElementType` already encodes
+        // both via the 'values' tag.
+        return kotlinContainerElementType(baseType, 'values');
+    }
+    if (receiver.type === 'navigation_expression') {
+        // `users.map { ... }` chain — receiver is itself a navigation/
+        // call. Tier-2 chain inference: try the navigation field/method.
+        const navField = inferKotlinNavigationFieldType(receiver, localTypes, classMembers);
+        if (navField !== null)
+            return navField;
+        const callee = receiver.namedChildren
+            .find((c) => c.type === 'navigation_suffix')
+            ?.namedChildren.find((c) => c.type === 'simple_identifier');
+        if (callee !== undefined) {
+            return inferKotlinNavigationCallReturnType(receiver, localTypes, classMembers);
+        }
+        return null;
+    }
+    if (receiver.type === 'call_expression') {
+        const callee = receiver.namedChildren.find((c) => c.type === 'simple_identifier');
+        if (callee === undefined)
+            return null;
+        return returnTypes.get(callee.text) ?? null;
+    }
+    return null;
+}
+/** Walk up from `lambdaNode` (lambda_literal) to the enclosing call:
+ *  `lambda_literal → annotated_lambda → call_suffix → call_expression`
+ *  for trailing lambdas, or `lambda_literal → value_argument →
+ *  value_arguments → call_suffix → call_expression` for paren form.
+ *  Returns null if the lambda is not inside a call. */
+function findEnclosingCallExpression(lambdaNode) {
+    let current = lambdaNode.parent;
+    while (current !== null) {
+        if (current.type === 'call_expression')
+            return current;
+        // Don't cross out of the immediate call boundary — if we hit a
+        // function_body or function_declaration ancestor, the lambda is
+        // not call-bound.
+        if (current.type === 'function_body' || current.type === 'function_declaration') {
+            return null;
+        }
+        current = current.parent;
+    }
+    return null;
+}
 function synthesizeKotlinLocalAssignmentBindings(rootNode, returnTypes) {
     const out = [];
     const classMembers = collectKotlinClassMembers(rootNode);
@@ -303,13 +606,23 @@ function collectKotlinClassMembers(rootNode) {
                         fmap.set(fname, ftype);
                 }
                 else if (member.type === 'function_declaration') {
-                    const mname = member.namedChildren.find((c) => c.type === 'simple_identifier')?.text;
-                    const paramsIdx = member.namedChildren.findIndex((c) => c.type === 'function_value_parameters');
-                    const rtype = paramsIdx < 0
-                        ? undefined
-                        : member.namedChildren.slice(paramsIdx + 1).find((c) => isKotlinTypeNode(c))?.text;
-                    if (mname !== undefined && rtype !== undefined)
-                        mmap.set(mname, rtype);
+                    collectKotlinFunctionReturn(member, mmap);
+                }
+                else if (member.type === 'companion_object') {
+                    // Companion-object methods (`companion object { fun create() … }`)
+                    // are addressable via the outer class name (`Logger.create()`).
+                    // Register them on the outer class so chain-binding for
+                    // `val x = Logger.create(...)` picks up the return type (#1756).
+                    // The receiver-side filtering needed to prevent
+                    // `instance.companionMethod()` crossover is handled elsewhere.
+                    const compBody = member.namedChildren.find((c) => c.type === 'class_body');
+                    if (compBody !== undefined) {
+                        for (const compMember of compBody.namedChildren) {
+                            if (compMember.type !== 'function_declaration')
+                                continue;
+                            collectKotlinFunctionReturn(compMember, mmap);
+                        }
+                    }
                 }
             }
         }
@@ -318,6 +631,15 @@ function collectKotlinClassMembers(rootNode) {
     }
     return { fields, methods };
 }
+function collectKotlinFunctionReturn(fnNode, target) {
+    const mname = fnNode.namedChildren.find((c) => c.type === 'simple_identifier')?.text;
+    const paramsIdx = fnNode.namedChildren.findIndex((c) => c.type === 'function_value_parameters');
+    const rtype = paramsIdx < 0
+        ? undefined
+        : fnNode.namedChildren.slice(paramsIdx + 1).find((c) => isKotlinTypeNode(c))?.text;
+    if (mname !== undefined && rtype !== undefined)
+        target.set(mname, rtype);
+}
 function collectKotlinLocalTypeTexts(fnNode, returnTypes) {
     const out = new Map();
     for (const node of descendants(fnNode)) {
@@ -408,9 +730,19 @@ function inferKotlinNavigationFieldType(nav, localTypes, classMembers) {
         return null;
     return classMembers.fields.get(normalizeKotlinType(recvType))?.get(member) ?? null;
 }
-/** Resolve `receiver.method()` → method's declared return type, where
- *  `receiver` is a simple identifier whose type is in `localTypes` and
- *  `method` is declared on that type in `classMembers.methods`. */
+/** Resolve `receiver.method()` → method's declared return type. The
+ *  `receiver` is a simple identifier; we try two interpretations in
+ *  order:
+ *
+ *    1. `receiver` is a local variable whose type is in `localTypes` —
+ *       look up `method` on that type's class members.
+ *    2. `receiver` is itself a class name (e.g. `Logger.create("app")`,
+ *       a companion-object call via the class) — look up `method` on
+ *       `classMembers.methods.get(receiver.text)` directly.
+ *
+ *  Tier 2 supports `val logger = Logger.create(...)` patterns where the
+ *  RHS is a companion-object factory: the loop variable's type is the
+ *  factory's return type (#1756). */
 function inferKotlinNavigationCallReturnType(navCallee, localTypes, classMembers) {
     if (classMembers === undefined)
         return null;
@@ -423,9 +755,10 @@ function inferKotlinNavigationCallReturnType(navCallee, localTypes, classMembers
     if (methodName === undefined)
         return null;
     const recvType = localTypes.get(receiver.text);
-    if (recvType === undefined)
-        return null;
-    return classMembers.methods.get(normalizeKotlinType(recvType))?.get(methodName) ?? null;
+    if (recvType !== undefined) {
+        return classMembers.methods.get(normalizeKotlinType(recvType))?.get(methodName) ?? null;
+    }
+    return classMembers.methods.get(receiver.text)?.get(methodName) ?? null;
 }
 function inferKotlinIterableElementType(iterable, localTypes, returnTypes) {
     if (iterable.type === 'simple_identifier') {

package/dist/core/ingestion/languages/kotlin/companion-scopes.d.ts

@@ -0,0 +1,7 @@
+import type { ScopeId } from '../../../../_shared/index.js';
+/** Record a scope id as a companion-object scope for the given file. */
+export declare function markCompanionScope(filePath: string, scopeId: ScopeId): void;
+/** Check whether `scopeId` belongs to a companion-object scope in `filePath`. */
+export declare function isCompanionScope(filePath: string, scopeId: ScopeId): boolean;
+/** Clear all tracked companion scopes (for testing). */
+export declare function clearCompanionScopes(): void;

package/dist/core/ingestion/languages/kotlin/companion-scopes.js

@@ -0,0 +1,56 @@
+/**
+ * Per-file set of `ScopeId`s that came from a `companion_object` AST node
+ * (issue #1756 / U4 remediation).
+ *
+ * Populated during `emitKotlinScopeCaptures` from the `@scope.companion`
+ * marker capture (see `query.ts`) and consumed by
+ * `populateCompanionMembersOnEnclosingClass` in `owners.ts` to decide
+ * whether to promote a class scope's methods onto its enclosing class.
+ *
+ * The previous `ownedDefs.some(isClassLike)` heuristic in `owners.ts`
+ * silently misclassified two shapes as "regular classes":
+ *   - named companions (`companion object Helper { ... }`) — the `Helper`
+ *     `type_identifier` registered as a class-like def on the companion
+ *     scope, hiding the companion-ness from the heuristic; AND
+ *   - companions containing nested classes (`companion object { class
+ *     Token; fun create() }`) — the nested class def lived on the
+ *     companion scope, again hiding it from the heuristic.
+ *
+ * The marker capture lifts that distinction up to the parser layer
+ * where it is unambiguous (any `companion_object` AST node is a
+ * companion, regardless of what it contains).
+ *
+ * Parallels the C-language pattern in `c/static-linkage.ts`: per-file
+ * `Map<filePath, Set<key>>` side-channel for language-specific def /
+ * scope metadata that does not belong on the shared `Scope` /
+ * `SymbolDefinition` types.
+ *
+ * NOTE: module-level state. `clearCompanionScopes()` is called once per
+ * workspace pass from `kotlinScopeResolver.loadResolutionConfig`, which
+ * the scope-resolution orchestrator awaits before extracting any
+ * `ParsedFile`s for this language (see `pipeline/phase.ts` and the
+ * mirror pattern in `c/scope-resolver.ts` — `clearStaticNames()`). This
+ * keeps server-mode and multi-repo-in-one-process callers safe from
+ * unbounded memory growth and from stale companion-scope ids from a
+ * previous workspace's files. Tests that exercise the captures /
+ * owners modules directly may still need to call `clearCompanionScopes`
+ * themselves (see `test/unit/kotlin-static-marker.test.ts`).
+ */
+const companionScopesByFile = new Map();
+/** Record a scope id as a companion-object scope for the given file. */
+export function markCompanionScope(filePath, scopeId) {
+    let scopes = companionScopesByFile.get(filePath);
+    if (scopes === undefined) {
+        scopes = new Set();
+        companionScopesByFile.set(filePath, scopes);
+    }
+    scopes.add(scopeId);
+}
+/** Check whether `scopeId` belongs to a companion-object scope in `filePath`. */
+export function isCompanionScope(filePath, scopeId) {
+    return companionScopesByFile.get(filePath)?.has(scopeId) ?? false;
+}
+/** Clear all tracked companion scopes (for testing). */
+export function clearCompanionScopes() {
+    companionScopesByFile.clear();
+}

package/dist/core/ingestion/languages/kotlin/owners.d.ts

@@ -1,2 +1,3 @@
-import type { ParsedFile } from '../../../../_shared/index.js';
+import type { ParsedFile, SymbolDefinition } from '../../../../_shared/index.js';
+export declare function isKotlinStaticOnly(def: SymbolDefinition): boolean;
 export declare function populateKotlinOwners(parsed: ParsedFile): void;

package/dist/core/ingestion/languages/kotlin/owners.js

@@ -1,4 +1,17 @@
 import { isClassLike, populateClassOwnedMembers } from '../../scope-resolution/scope/walkers.js';
+import { isCompanionScope } from './companion-scopes.js';
+/** Module-level identity-based marker for companion-promoted Kotlin
+ *  method defs (the "this member can only be dispatched through the
+ *  class name" set). Parallels the C language `static-linkage.ts`
+ *  side-channel pattern but uses a WeakSet because the mark is
+ *  per-def (no per-name keying needed). Eliminates the cast-and-
+ *  mutate pattern the previous marker implementation required,
+ *  removes any serialization-survival risk surface, and keeps the
+ *  Kotlin-specific metadata off the shared `SymbolDefinition` type. */
+const KOTLIN_STATIC_DEFS = new WeakSet();
+export function isKotlinStaticOnly(def) {
+    return KOTLIN_STATIC_DEFS.has(def);
+}
 export function populateKotlinOwners(parsed) {
     populateClassOwnedMembers(parsed);
     populateCompanionMembersOnEnclosingClass(parsed);
@@ -37,15 +50,49 @@ function populateCompanionMembersOnEnclosingClass(parsed) {
         const parent = scopesById.get(scope.parent);
         if (parent === undefined || parent.kind !== 'Class')
             continue;
-        if (parent.ownedDefs.some((def) => isClassLike(def.type)))
+        // Identify companion-object scopes via the `@scope.companion` marker
+        // capture (see captures.ts / companion-scopes.ts) rather than via
+        // the old `parent.ownedDefs.some(isClassLike)` heuristic. The
+        // heuristic silently bypassed two real shapes (#1756 / U4):
+        //   - named companions (`companion object Helper { ... }`) — `Helper`
+        //     registered as a class-like def on the companion scope; AND
+        //   - companions containing nested classes (`companion object {
+        //     class Token; fun create() }`) — the nested class lived on
+        //     the companion scope.
+        // Both bypasses left companion methods unpromoted and unmarked,
+        // breaking class-name dispatch (`Outer.create()`) and crossover
+        // suppression (`outer.create()`) for those shapes. The marker
+        // capture lifts the distinction to the parser layer where any
+        // `companion_object` AST node is a companion, full stop.
+        if (!isCompanionScope(parsed.filePath, parent.id))
             continue;
         const enclosing = findEnclosingClassWithDef(parent.parent, scopesById);
         if (enclosing === undefined)
             continue;
         for (const def of scope.ownedDefs) {
-            if (def.ownerId !== undefined)
+            // Class-like defs nested inside the companion's methods (rare —
+            // would be a local class declared inside a fun-body) are not
+            // companion members and must not be promoted. The companion's
+            // direct nested classes live in their OWN scope's ownedDefs
+            // (NOT the function-scope ownedDefs we iterate here), so this
+            // guard is defense-in-depth.
+            if (isClassLike(def.type))
                 continue;
+            // OVERRIDE rather than skip-when-set: for named companions,
+            // `populateClassOwnedMembers` already set `ownerId = Helper`
+            // (the named-companion class-like def). That is the WRONG
+            // owner — companion methods are dispatched through the
+            // enclosing outer class, not through the companion's own
+            // type name. Overwriting restores the intended ownership.
             def.ownerId = enclosing.nodeId;
+            // Mark as static-only so `ScopeResolver.isStaticOnly` (see
+            // `isKotlinStaticOnly`) can filter these out of instance-receiver
+            // dispatch (#1756). Promoting the companion method onto the
+            // outer class lets `Foo.companionMethod()` resolve via Case 2;
+            // without this marker, `fooInstance.companionMethod()` would
+            // ALSO resolve to it via Case 4, which is incorrect (and a
+            // compile error in real Kotlin).
+            KOTLIN_STATIC_DEFS.add(def);
             qualify(def, enclosing);
         }
     }
@@ -66,9 +113,18 @@ function findEnclosingClassWithDef(start, scopesById) {
     return undefined;
 }
 function qualify(def, owner) {
-    if (def.qualifiedName === undefined || def.qualifiedName.includes('.'))
+    if (def.qualifiedName === undefined)
         return;
     if (owner.qualifiedName === undefined || owner.qualifiedName.length === 0)
         return;
-    def.qualifiedName = `${owner.qualifiedName}.${def.qualifiedName}`;
+    // For named companions, `populateClassOwnedMembers` qualified the
+    // def as `Helper.create`. Strip the companion-class prefix and
+    // re-qualify with the outer class so the graph-bridge lookup keys
+    // resolve to `Outer.create` rather than the spurious `Helper.create`.
+    // For unqualified defs (the anonymous-companion path), the simple
+    // name is unchanged — `populateClassOwnedMembers` found no class-like
+    // def in the anonymous companion scope, so the prior pass left the
+    // simple name in place.
+    const simple = def.qualifiedName.split('.').pop() ?? def.qualifiedName;
+    def.qualifiedName = `${owner.qualifiedName}.${simple}`;
 }

package/dist/core/ingestion/languages/kotlin/query.js

@@ -8,6 +8,20 @@ const KOTLIN_SCOPE_QUERY = `
 (companion_object) @scope.class
 (function_declaration) @scope.function
 
+;; Companion-object marker (issue #1756 / U4). Side-channel capture that
+;; lets populateCompanionMembersOnEnclosingClass distinguish a companion
+;; Class scope from a regular Class scope without inspecting ownedDefs.
+;; Anonymous companions AND companions containing nested classes both
+;; look like regular classes through the old ownedDefs-based heuristic;
+;; the marker lifts the distinction up to the parser layer where it is
+;; unambiguous (any companion_object AST node is a companion, full
+;; stop). Consumed by markCompanionScope / isCompanionScope in
+;; captures.ts / companion-scopes.ts. The scope-extractor ignores the
+;; "companion" suffix (no ScopeKind mapping), so this rule contributes
+;; no Scope record of its own — the existing (companion_object)
+;; @scope.class rule still creates the Class scope.
+(companion_object) @scope.companion
+
 ;; Smart-cast narrowing scopes (RFC #909 Ring 3, issue #1758).
 ;; Each is-test arm body and each if-then body becomes its own Block
 ;; scope so synthesized narrowed type-bindings (see captures.ts
@@ -21,6 +35,25 @@ const KOTLIN_SCOPE_QUERY = `
   (check_expression)
   (control_structure_body) @scope.block)
 
+;; Lambda body scope (issue #1757). Each lambda_literal becomes its
+;; own Block scope so synthesized lambda-parameter and implicit-'it'
+;; type-bindings (see captures.ts synthesizeKotlinLambdaBindings) stay
+;; inside the lambda — they must not leak to the enclosing function
+;; scope and must shadow same-named outer bindings (val it = "outer";
+;; users.forEach { it.save() } — inner 'it' is the lambda's, not the
+;; outer String).
+;;
+;; Lambdas appear inside call_suffix for trailing-lambda syntax
+;; (list.forEach { it.foo() }) and inside value_arguments for
+;; explicit-paren syntax (list.forEach({ x -> x.foo() })); both AST
+;; positions produce the same lambda_literal subtree, so a single
+;; capture suffices.
+;;
+;; Uses @scope.block (not @scope.function) to match the smart-cast
+;; precedent (#1758) — keeps narrowed/lambda bindings scope-local
+;; without the auto-hoist semantics of Function scopes.
+(lambda_literal) @scope.block
+
 ;; Declarations — types
 (class_declaration
   "interface"