gitnexus 1.6.6-rc.44 → 1.6.6-rc.46

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"

package/dist/core/ingestion/languages/kotlin/scope-resolver.d.ts

@@ -2,28 +2,38 @@ import type { ScopeResolver } from '../../scope-resolution/contract/scope-resolv
 /**
  * Kotlin scope resolver for RFC #909 Ring 3.
  *
- * Kotlin is intentionally registered but not yet listed in
- * `MIGRATED_LANGUAGES`, matching the Java migration pattern from #1482:
- * the resolver can run in shadow/forced mode, while production default
- * stays on the legacy DAG until the RFC flip criteria in #1746 are met.
+ * **Migration status:** Kotlin is in `MIGRATED_LANGUAGES`. Default
+ * production resolution flows through the scope-resolution pipeline;
+ * the legacy DAG is consulted only when the per-language env var
+ * (`REGISTRY_PRIMARY_KOTLIN=0`) explicitly forces the legacy parity
+ * run for CI comparison.
  *
- * **Forced-mode parity (`REGISTRY_PRIMARY_KOTLIN=1`):** 175/175 fixtures
- * after the migration sub-issues #1758–#1763 closed. Covers core
- * import, receiver, companion, default-param, vararg, constructor,
- * local assignment-chain, collection-iteration, smart casts
- * (`when (x) { is T -> … }` and `if (x is T)` — #1758), cross-file
- * iterable return propagation (#1759), single-level method-chain
- * fixpoint receiver types (#1760), parameter-type-narrowed overload
- * target-id selection (#1761), virtual dispatch via constructor RHS
- * (`val x: Animal = Dog()` — #1762), and interface default-method
- * dispatch via implements-split MRO (#1763).
+ * **Forced-mode parity (`REGISTRY_PRIMARY_KOTLIN=1`):** 208/208
+ * fixtures pass after the migration sub-issues #1758–#1763, the
+ * companion/instance dispatch fix #1756, and the lambda scopes
+ * fix #1757. Covers core import, receiver, companion, default-param,
+ * vararg, constructor, local assignment-chain, collection-iteration,
+ * smart casts (`when (x) { is T -> … }` and `if (x is T)` — #1758),
+ * cross-file iterable return propagation (#1759), single-level
+ * method-chain fixpoint receiver types (#1760), parameter-type-narrowed
+ * overload target-id selection (#1761), virtual dispatch via constructor
+ * RHS (`val x: Animal = Dog()` — #1762), interface default-method
+ * dispatch via implements-split MRO (#1763), companion-object vs
+ * instance member dispatch (#1756) via the `isStaticOnly` hook
+ * (including named companions and MRO-shadow / chain-typebinding /
+ * value-receiver crossover cases), and lambda-body Block scopes
+ * with scoped type-bindings for explicit parameters and implicit
+ * `it` (#1757) via `synthesizeKotlinLambdaBindings` plus the
+ * `(lambda_literal) @scope.block` query rule.
  *
- * **Remaining pre-flip blockers (#1746):** #1755 (forced-mode preview
- * CI workflow — obviated once Kotlin lands in `MIGRATED_LANGUAGES`
- * because the existing scope-parity matrix auto-discovers it), #1756
- * (companion vs instance member dispatch), and #1757 (lambda scopes
- * and lambda-parameter bindings). The flip PR adds
- * `SupportedLanguages.Kotlin` to `MIGRATED_LANGUAGES` after the named
- * blockers close.
+ * **Legacy parity skip list:** `LEGACY_RESOLVER_PARITY_EXPECTED_FAILURES.kotlin`
+ * in `test/integration/resolvers/helpers.ts` records scope-resolver-only
+ * correctness wins that the legacy DAG cannot replicate. As of #1756 /
+ * #1757 there are 8 entries covering: the bare companion-vs-instance
+ * crossover, three MRO-shadow / standalone-chain cases, the chained-
+ * forEach lambda-scope case, the named-companion crossover, and the
+ * Case-0 / Case-3b / Case-5 companion crossovers under
+ * `kotlin-companion-other-cases`. Each entry is documented inline with
+ * its issue ref and rationale.
  */
 export declare const kotlinScopeResolver: ScopeResolver;

package/dist/core/ingestion/languages/kotlin/scope-resolver.js

@@ -4,37 +4,62 @@ import { resolveDefGraphId } from '../../scope-resolution/graph-bridge/ids.js';
 import { isClassLike } from '../../scope-resolution/scope/walkers.js';
 import { kotlinProvider } from '../kotlin.js';
 import { kotlinArityCompatibility, kotlinMergeBindings, populateKotlinOwners, resolveKotlinImportTarget, } from './index.js';
+import { clearCompanionScopes } from './companion-scopes.js';
+import { isKotlinStaticOnly } from './owners.js';
 /**
  * Kotlin scope resolver for RFC #909 Ring 3.
  *
- * Kotlin is intentionally registered but not yet listed in
- * `MIGRATED_LANGUAGES`, matching the Java migration pattern from #1482:
- * the resolver can run in shadow/forced mode, while production default
- * stays on the legacy DAG until the RFC flip criteria in #1746 are met.
+ * **Migration status:** Kotlin is in `MIGRATED_LANGUAGES`. Default
+ * production resolution flows through the scope-resolution pipeline;
+ * the legacy DAG is consulted only when the per-language env var
+ * (`REGISTRY_PRIMARY_KOTLIN=0`) explicitly forces the legacy parity
+ * run for CI comparison.
  *
- * **Forced-mode parity (`REGISTRY_PRIMARY_KOTLIN=1`):** 175/175 fixtures
- * after the migration sub-issues #1758–#1763 closed. Covers core
- * import, receiver, companion, default-param, vararg, constructor,
- * local assignment-chain, collection-iteration, smart casts
- * (`when (x) { is T -> … }` and `if (x is T)` — #1758), cross-file
- * iterable return propagation (#1759), single-level method-chain
- * fixpoint receiver types (#1760), parameter-type-narrowed overload
- * target-id selection (#1761), virtual dispatch via constructor RHS
- * (`val x: Animal = Dog()` — #1762), and interface default-method
- * dispatch via implements-split MRO (#1763).
+ * **Forced-mode parity (`REGISTRY_PRIMARY_KOTLIN=1`):** 208/208
+ * fixtures pass after the migration sub-issues #1758–#1763, the
+ * companion/instance dispatch fix #1756, and the lambda scopes
+ * fix #1757. Covers core import, receiver, companion, default-param,
+ * vararg, constructor, local assignment-chain, collection-iteration,
+ * smart casts (`when (x) { is T -> … }` and `if (x is T)` — #1758),
+ * cross-file iterable return propagation (#1759), single-level
+ * method-chain fixpoint receiver types (#1760), parameter-type-narrowed
+ * overload target-id selection (#1761), virtual dispatch via constructor
+ * RHS (`val x: Animal = Dog()` — #1762), interface default-method
+ * dispatch via implements-split MRO (#1763), companion-object vs
+ * instance member dispatch (#1756) via the `isStaticOnly` hook
+ * (including named companions and MRO-shadow / chain-typebinding /
+ * value-receiver crossover cases), and lambda-body Block scopes
+ * with scoped type-bindings for explicit parameters and implicit
+ * `it` (#1757) via `synthesizeKotlinLambdaBindings` plus the
+ * `(lambda_literal) @scope.block` query rule.
  *
- * **Remaining pre-flip blockers (#1746):** #1755 (forced-mode preview
- * CI workflow — obviated once Kotlin lands in `MIGRATED_LANGUAGES`
- * because the existing scope-parity matrix auto-discovers it), #1756
- * (companion vs instance member dispatch), and #1757 (lambda scopes
- * and lambda-parameter bindings). The flip PR adds
- * `SupportedLanguages.Kotlin` to `MIGRATED_LANGUAGES` after the named
- * blockers close.
+ * **Legacy parity skip list:** `LEGACY_RESOLVER_PARITY_EXPECTED_FAILURES.kotlin`
+ * in `test/integration/resolvers/helpers.ts` records scope-resolver-only
+ * correctness wins that the legacy DAG cannot replicate. As of #1756 /
+ * #1757 there are 8 entries covering: the bare companion-vs-instance
+ * crossover, three MRO-shadow / standalone-chain cases, the chained-
+ * forEach lambda-scope case, the named-companion crossover, and the
+ * Case-0 / Case-3b / Case-5 companion crossovers under
+ * `kotlin-companion-other-cases`. Each entry is documented inline with
+ * its issue ref and rationale.
  */
 export const kotlinScopeResolver = {
     language: SupportedLanguages.Kotlin,
     languageProvider: kotlinProvider,
     importEdgeReason: 'kotlin-scope: import',
+    loadResolutionConfig: () => {
+        // Drop the module-level `companionScopesByFile` table from any
+        // prior workspace pass before this run populates it via
+        // `emitKotlinScopeCaptures`. Mirrors the C resolver's
+        // `clearStaticNames()` call in `loadResolutionConfig` — the
+        // orchestrator awaits this hook exactly once per workspace pass
+        // (see `pipeline/phase.ts`), making it the right lifecycle seam
+        // for clearing per-language side-channel state. Returns
+        // `undefined` because Kotlin has no external resolution config
+        // to load.
+        clearCompanionScopes();
+        return undefined;
+    },
     resolveImportTarget: (targetRaw, fromFile, allFilePaths) => {
         const ws = { fromFile, allFilePaths };
         return resolveKotlinImportTarget({ kind: 'named', localName: '_', importedName: '_', targetRaw }, ws);
@@ -44,6 +69,7 @@ export const kotlinScopeResolver = {
     buildMro: (graph, parsedFiles, nodeLookup) => buildKotlinMro(graph, parsedFiles, nodeLookup),
     populateOwners: (parsed) => populateKotlinOwners(parsed),
     isSuperReceiver: (text) => text.trim() === 'super',
+    isStaticOnly: isKotlinStaticOnly,
     fieldFallbackOnMethodLookup: false,
     propagatesReturnTypesAcrossImports: true,
     collapseMemberCallsByCallerTarget: false,

package/dist/core/ingestion/languages/kotlin/simple-hooks.js

@@ -6,6 +6,17 @@ export function kotlinBindingScopeFor(decl, innermost, tree) {
     // and erase the arm-local narrowing.
     if (decl['@type-binding.narrowed'] !== undefined)
         return innermost.id;
+    // Lambda-scoped bindings (issue #1757) — explicit lambda parameters
+    // and implicit `it` must stay inside the lambda body Block scope.
+    // Without this gating, the binding hoists to the enclosing function
+    // scope and:
+    //   - `it` leaks past the closing brace of the lambda, shadowing the
+    //     parameter-scope `it` (or outer `val it = "outer"`) for everything
+    //     that follows in the function body.
+    //   - Nested lambda parameters override each other across siblings.
+    // Same mechanism as the smart-cast precedent above.
+    if (decl['@type-binding.lambda-scoped'] !== undefined)
+        return innermost.id;
     if (decl['@type-binding.return'] === undefined)
         return null;
     let current = innermost;

package/dist/core/ingestion/registry-primary-flag.js

@@ -74,6 +74,7 @@ export const MIGRATED_LANGUAGES = new Set([
     SupportedLanguages.CPlusPlus,
     SupportedLanguages.PHP,
     SupportedLanguages.JavaScript,
+    SupportedLanguages.Kotlin,
 ]);
 /**
  * Return the env-var name that controls a given language's registry-

package/dist/core/ingestion/scope-resolution/contract/scope-resolver.d.ts

@@ -510,6 +510,43 @@ export interface ScopeResolver {
      * Languages without file-local linkage semantics leave this undefined.
      */
     readonly isFileLocalDef?: (def: SymbolDefinition) => boolean;
+    /**
+     * Optional predicate to identify members for which dispatch through
+     * an instance receiver is **invalid at the language level** — i.e.
+     * calling `instance.member()` would be a compile error or a
+     * type-system violation, even if a member of that name exists on
+     * the receiver's class. When provided, the receiver-bound calls
+     * pass filters out such members at every instance-receiver dispatch
+     * case (Case 0 compound receiver, Case 3b chain-typebinding, Case 4
+     * simple typeBinding, Case 5 value-receiver bridge) so the resolver
+     * does not emit a misleading `CALLS` edge for a call site the
+     * language itself would reject.
+     *
+     * **Reserved for the "instance receiver is invalid" semantic only.**
+     * Hooks for languages where static / class-level members are still
+     * legally callable through an instance (Python `@staticmethod`,
+     * JavaScript `static` methods accessed via the prototype chain in
+     * some lookup paths) should return `false` for those members — the
+     * filter would silently suppress legitimate edges otherwise. The
+     * canonical fit today is Kotlin companion-object methods, where
+     * `instance.companionMethod()` is a compile error.
+     *
+     * Case 2 (class-name receiver) is intentionally unaffected: a call
+     * through the class name (`Foo.staticMethod()`) is a legitimate
+     * dispatch.
+     *
+     * Case 0.5 (implicit `this` receiver) currently fires only for
+     * languages with `resolveThisViaEnclosingClass === true` (C++ at
+     * time of writing), none of which expose static-only semantics. A
+     * future language that enables BOTH `resolveThisViaEnclosingClass`
+     * AND `isStaticOnly` must wire the filter into Case 0.5's chain
+     * walk too — see the inline note in `receiver-bound-calls.ts`.
+     *
+     * Languages without static-only semantics leave this undefined and
+     * the legacy unfiltered behavior applies (every owned member of the
+     * receiver class is a dispatch candidate).
+     */
+    readonly isStaticOnly?: (def: SymbolDefinition) => boolean;
     /**
      * Optional predicate to gate free-call fallback emission by caller-side
      * visibility. When provided, `pickUniqueGlobalCallable` rejects candidates

package/dist/core/ingestion/scope-resolution/passes/receiver-bound-calls.d.ts

@@ -46,7 +46,7 @@ import type { WorkspaceResolutionIndex } from '../workspace-index.js';
 /** Subset of `ScopeResolver` consumed by this pass. Accepting the
  *  subset rather than the full provider keeps tests and partial
  *  refactors lighter — callers only need to populate what we read. */
-type ReceiverBoundProviderSubset = Pick<ScopeResolver, 'isSuperReceiver' | 'isSuperReceiverInContext' | 'fieldFallbackOnMethodLookup' | 'collapseMemberCallsByCallerTarget' | 'unwrapCollectionAccessor' | 'hoistTypeBindingsToModule' | 'resolveQualifiedReceiverMember' | 'resolveThisViaEnclosingClass' | 'conversionRankFn' | 'constraintCompatibility'>;
+type ReceiverBoundProviderSubset = Pick<ScopeResolver, 'isSuperReceiver' | 'isSuperReceiverInContext' | 'fieldFallbackOnMethodLookup' | 'collapseMemberCallsByCallerTarget' | 'unwrapCollectionAccessor' | 'hoistTypeBindingsToModule' | 'resolveQualifiedReceiverMember' | 'resolveThisViaEnclosingClass' | 'conversionRankFn' | 'constraintCompatibility' | 'isStaticOnly'>;
 export declare function emitReceiverBoundCalls(graph: KnowledgeGraph, scopes: ScopeResolutionIndexes, parsedFiles: readonly ParsedFile[], nodeLookup: GraphNodeLookup, handledSites: Set<string>, provider: ReceiverBoundProviderSubset, index: WorkspaceResolutionIndex, model: SemanticModel): number;
 /**
  * Sentinel returned by `pickOverload` when narrowing leaves >1 candidate

package/dist/core/ingestion/scope-resolution/passes/receiver-bound-calls.js

@@ -219,10 +219,29 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                 if (currentClass !== undefined) {
                     const chain = [currentClass.nodeId, ...scopes.methodDispatch.mroFor(currentClass.nodeId)];
                     let memberDef;
+                    // Static-only filter (#1756 / U3): same shape as Case 4's
+                    // chain walk (skip-and-walk-on) but without overload
+                    // narrowing — Case 0 uses `findOwnedMember` directly. When
+                    // an owner's resolved candidate is static-only (Kotlin
+                    // companion-promoted), continue to the next ancestor in
+                    // the MRO chain so a legitimate instance member can bind.
+                    // If the entire chain is static-only, no edge is emitted —
+                    // unlike Case 4, Case 0 does NOT mark the site handled in
+                    // that situation because compound receivers (`a.b.c()`)
+                    // are not pre-emitted by `emitReferencesViaLookup` (the
+                    // reference index has no compound-receiver entry for
+                    // shapes like `Logger.create("a")`), so there's no wrong
+                    // target to suppress.
                     for (const ownerId of chain) {
-                        memberDef = findOwnedMember(ownerId, memberName, model);
-                        if (memberDef !== undefined)
-                            break;
+                        const candidate = findOwnedMember(ownerId, memberName, model);
+                        if (candidate === undefined)
+                            continue;
+                        if (provider.isStaticOnly?.(candidate) === true) {
+                            // Skip static-only candidate; walk to next ancestor.
+                            continue;
+                        }
+                        memberDef = candidate;
+                        break;
                     }
                     if (memberDef !== undefined) {
                         const ok = tryEmitEdge(graph, scopes, nodeLookup, site, memberDef, memberDef.filePath !== parsed.filePath ? 'import-resolved' : 'global', seen, 0.85, collapse);
@@ -241,6 +260,17 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
             // C++ `this->member()` (and same-shape receivers in other OO
             // languages) should resolve against the enclosing class + MRO
             // even when there is no explicit `this` typeBinding in scope.
+            //
+            // **Static-only filter dependency (#1756 / U3):** this case does
+            // NOT currently consult `provider.isStaticOnly`. Today it fires
+            // only for C++ (the sole `resolveThisViaEnclosingClass === true`
+            // language), which has no static-only semantics. Kotlin — the
+            // current `isStaticOnly` consumer — leaves `resolveThisVia
+            // EnclosingClass` unset, so Case 0.5 is dead code for Kotlin
+            // crossover suppression and U3 leaves it untouched. If any
+            // future language enables BOTH `resolveThisViaEnclosingClass`
+            // AND `isStaticOnly`, the chain-walk below MUST adopt the
+            // skip-and-walk-on filter pattern used by Cases 0, 3b, and 4.
             if (provider.resolveThisViaEnclosingClass === true && receiverName === 'this') {
                 const enclosingClass = findEnclosingClassDef(site.inScope, scopes);
                 if (enclosingClass !== undefined) {
@@ -431,10 +461,23 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                 if (ownerDef !== undefined) {
                     const chain = [ownerDef.nodeId, ...scopes.methodDispatch.mroFor(ownerDef.nodeId)];
                     let memberDef;
+                    // Static-only filter (#1756 / U3): mirrors Case 0's chain
+                    // walk — `findOwnedMember` without overload narrowing. When
+                    // a static-only candidate is found at an ancestor, walk on
+                    // so a legitimate instance member can bind. If the entire
+                    // chain is static-only, no edge is emitted (Case 3b is fed
+                    // by chain-typebinding receivers, not pre-emitted by
+                    // `emitReferencesViaLookup` for compound shapes, so no
+                    // handled-site marker is needed for chain-only-static).
                     for (const ownerId of chain) {
-                        memberDef = findOwnedMember(ownerId, memberName, model);
-                        if (memberDef !== undefined)
-                            break;
+                        const candidate = findOwnedMember(ownerId, memberName, model);
+                        if (candidate === undefined)
+                            continue;
+                        if (provider.isStaticOnly?.(candidate) === true) {
+                            continue;
+                        }
+                        memberDef = candidate;
+                        break;
                     }
                     if (memberDef !== undefined) {
                         const ok = tryEmitEdge(graph, scopes, nodeLookup, site, memberDef, memberDef.filePath !== parsed.filePath ? 'import-resolved' : 'global', seen, 0.85, collapse);
@@ -475,16 +518,53 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                     const chain = [ownerDef.nodeId, ...scopes.methodDispatch.mroFor(ownerDef.nodeId)];
                     let memberDef;
                     let ambiguous = false;
+                    // Track whether the chain walk filtered out any static-only
+                    // candidates. When it did and the chain ended with no
+                    // legitimate instance member, we mark the site as handled so
+                    // `emitReferencesViaLookup` doesn't re-emit a wrong target
+                    // from the pre-resolved reference index (which has no
+                    // static-only awareness).
+                    let allFilteredStaticOnly = false;
+                    // Static-only filter (#1756 / U2): the filter must run INSIDE
+                    // the chain walk and BEFORE arity narrowing.
+                    //
+                    // INSIDE: when a derived owner's only candidates are static-
+                    // only (Kotlin companion-promoted), `pickFirstNonStaticOnly`
+                    // returns `undefined` and the loop `continue`s to the next
+                    // ancestor in the MRO chain — giving a legitimate ancestor
+                    // instance method a chance to bind. The earlier after-chain
+                    // filter aborted the entire site instead, producing a false
+                    // negative whenever the most-derived owner shadowed an
+                    // ancestor's instance method with a static-only companion
+                    // member.
+                    //
+                    // BEFORE narrowing: filtering survivors of `lookupAllByOwner`
+                    // (rather than survivors of `narrowOverloadCandidates`) means
+                    // a same-arity static + instance pair on one owner doesn't
+                    // collapse to `OVERLOAD_AMBIGUOUS`. Kotlin compile-resolves
+                    // such a pair unambiguously to the instance method because
+                    // companion members are not legal instance-dispatch
+                    // candidates.
                     for (const ownerId of chain) {
-                        const picked = pickOverload(ownerId, memberName, site, model, provider);
+                        const picked = pickFirstNonStaticOnly(ownerId, memberName, site, model, provider);
                         if (picked === OVERLOAD_AMBIGUOUS) {
                             ambiguous = true;
                             break;
                         }
+                        if (picked === STATIC_ONLY_FILTERED) {
+                            // At least one static-only candidate was filtered out at
+                            // this owner; remember so we can mark handled if the
+                            // chain ends with no legitimate match.
+                            allFilteredStaticOnly = true;
+                            continue;
+                        }
                         if (picked !== undefined) {
                             memberDef = picked;
                             break;
                         }
+                        // `picked === undefined` means this owner had no member of
+                        // this name at all. Walk on to the next ancestor in the
+                        // MRO chain.
                     }
                     if (ambiguous) {
                         // Suppress and mark handled so `emitReferencesViaLookup`
@@ -493,6 +573,15 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                         handledSites.add(siteKey);
                         continue;
                     }
+                    if (memberDef === undefined && allFilteredStaticOnly) {
+                        // The chain ended with no candidates because every viable
+                        // owner had only static-only members. Mark handled so
+                        // `emitReferencesViaLookup` doesn't re-emit a wrong target
+                        // from the pre-resolved reference index. Parallels the old
+                        // after-chain `isStaticOnly` suppression block.
+                        handledSites.add(siteKey);
+                        continue;
+                    }
                     if (memberDef !== undefined) {
                         // For read/write ACCESSES, mirror the legacy DAG's reason
                         // convention so consumers asserting `reason === 'write'`
@@ -549,6 +638,19 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                     continue;
                 }
                 if (picked !== undefined) {
+                    // Static-only filter (#1756 / U3): unlike Case 4 there's no
+                    // MRO chain to walk here — Case 5 dispatches on a single
+                    // owner via `pickOverload`. When the picked candidate is
+                    // static-only (Kotlin companion-promoted), suppress the
+                    // edge entirely and mark the site handled so
+                    // `emitReferencesViaLookup` doesn't re-emit a wrong target
+                    // from the pre-resolved reference index. Matches the after-
+                    // chain handled-marker semantic used by Case 4's
+                    // all-filtered fall-through.
+                    if (provider.isStaticOnly?.(picked) === true) {
+                        handledSites.add(siteKey);
+                        continue;
+                    }
                     const reason = site.kind === 'write' || site.kind === 'read'
                         ? site.kind
                         : picked.filePath !== parsed.filePath
@@ -610,3 +712,89 @@ function pickOverload(ownerId, memberName, site, model, provider) {
  * collapses distinct types in arity-metadata).
  */
 export const OVERLOAD_AMBIGUOUS = Symbol('overload-ambiguous');
+/**
+ * Sentinel returned by `pickFirstNonStaticOnly` when the only candidates
+ * at the queried owner were filtered out by `provider.isStaticOnly`. Lets
+ * the Case 4 chain walk distinguish "owner had no member of this name"
+ * (return `undefined`, continue silently) from "owner had only static-
+ * only members" (return this sentinel, continue and remember so the
+ * post-chain handled-marker logic can suppress wrong-target re-emission
+ * from `emitReferencesViaLookup`). See #1756 / remediation plan U2.
+ */
+const STATIC_ONLY_FILTERED = Symbol('static-only-filtered');
+/**
+ * Receiver-bound member lookup that filters static-only candidates BEFORE
+ * arity narrowing. Wraps the raw `lookupAllByOwner` → `narrowOverloadCandidates`
+ * pipeline so:
+ *
+ *   1. Candidates flagged by `provider.isStaticOnly` (Kotlin companion-
+ *      promoted methods today) never enter the narrowing stage. A same-
+ *      name same-arity static + instance pair on one owner therefore does
+ *      NOT collapse to `OVERLOAD_AMBIGUOUS` — the instance member wins
+ *      unambiguously, matching Kotlin's compile-time resolution.
+ *   2. The chain walk in `emitReceiverBoundCalls` Case 4 can fall through
+ *      to ancestors when only static-only candidates exist at the
+ *      most-derived owner (returns `STATIC_ONLY_FILTERED`), rather than
+ *      aborting the site as the previous after-chain filter did.
+ *
+ * Returns:
+ *   - `undefined` — no member with this name on this owner; chain walk
+ *     continues silently.
+ *   - `STATIC_ONLY_FILTERED` — at least one candidate existed but every
+ *     one was static-only; chain walk continues and remembers so the
+ *     post-chain handled-marker can fire if no ancestor binds.
+ *   - `OVERLOAD_AMBIGUOUS` — narrowing on the surviving non-static
+ *     candidates left >1 ambiguous match; chain walk aborts and the
+ *     site is marked handled (existing sentinel handling preserved).
+ *   - `SymbolDefinition` — single survivor (the chosen target).
+ *
+ * See remediation plan `docs/plans/2026-05-22-002-fix-lang-kotlin-1782-
+ * remediation-plan.md` § U2 for the full rationale.
+ */
+function pickFirstNonStaticOnly(ownerId, memberName, site, model, provider) {
+    const rawOverloads = model.methods.lookupAllByOwner(ownerId, memberName);
+    if (rawOverloads.length === 0) {
+        // Non-callable member (field / property / variable) — ACCESSES
+        // write/read sites target these too. Static-only filtering doesn't
+        // apply to fields, so delegate straight to `lookupFieldByOwner`.
+        return model.fields.lookupFieldByOwner(ownerId, memberName);
+    }
+    const isStaticOnly = provider.isStaticOnly;
+    let overloads = rawOverloads;
+    let filteredAny = false;
+    if (isStaticOnly !== undefined) {
+        const survivors = [];
+        for (const candidate of rawOverloads) {
+            if (isStaticOnly(candidate) === true) {
+                filteredAny = true;
+                continue;
+            }
+            survivors.push(candidate);
+        }
+        overloads = survivors;
+    }
+    if (overloads.length === 0) {
+        // Every candidate was static-only; the caller (Case 4 chain walk)
+        // should walk on to the next owner AND remember that filtering
+        // happened so it can mark the site handled if the whole chain
+        // ends with no legitimate match.
+        return filteredAny ? STATIC_ONLY_FILTERED : undefined;
+    }
+    if (overloads.length === 1)
+        return overloads[0];
+    const candidates = narrowOverloadCandidates(overloads, site.arity, site.argumentTypes, {
+        argumentTypeClasses: site.argumentTypeClasses,
+        conversionRankFn: provider.conversionRankFn,
+        constraintCompatibility: provider.constraintCompatibility,
+    });
+    // Same ambiguity handling as `pickOverload`: when normalization
+    // collapses the surviving overloads into a single bucket (e.g., C++
+    // `f(int)`/`f(long)` normalized to `['int']`), suppress rather than
+    // arbitrarily picking. When narrowing leaves >1 distinct candidate
+    // with no tie-breaker, suppress for the same reason.
+    if (isOverloadAmbiguousAfterNormalization(candidates, site.arity))
+        return OVERLOAD_AMBIGUOUS;
+    if (candidates.length > 1)
+        return OVERLOAD_AMBIGUOUS;
+    return candidates[0] ?? overloads[0];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.6-rc.44",
+  "version": "1.6.6-rc.46",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",