gitnexus 1.6.6-rc.99 → 1.6.6

package/dist/core/ingestion/languages/kotlin/capture-side-channel.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Kotlin capture-time side-channel serialization (#1983).
+ *
+ * `emitKotlinScopeCaptures` populates one MODULE-LEVEL, per-file map as a side
+ * effect that is NOT part of the returned `ParsedFile`'s scopes/defs:
+ *
+ *   - `companionScopesByFile`  (companion-scopes.ts) — the `ScopeId`s that came
+ *     from a `companion_object` AST node, recorded via `markCompanionScope`
+ *     from the `@scope.companion` marker capture.
+ *
+ * On the worker path that map is filled in the WORKER process and lost across
+ * the worker→main MessageChannel (and the disk-backed parsedfile-store),
+ * because scope-resolution reuses the serialized `ParsedFile` and SKIPS the
+ * main-thread re-extraction (the #1983 fix that avoids a main-thread
+ * tree-sitter re-parse / OOM on huge repos). The main thread then reads the map
+ * empty in `isKotlinStaticOnly` / `populateCompanionMembersOnEnclosingClass`
+ * (owners.ts) — so companion methods aren't identified as static and
+ * companion/static dispatch emits no CALLS edges.
+ *
+ * This module snapshots the per-file slice of that map into a plain,
+ * JSON-serializable object (carried on `ParsedFile.captureSideChannel`) and
+ * restores it on the main thread WITHOUT any parse. It mirrors the C++ pattern
+ * in `cpp/capture-side-channel.ts`.
+ *
+ * The single generic `ParsedFile.captureSideChannel` field is shared with C++,
+ * which is safe because each file is one language (a `.kt` file uses the kotlin
+ * provider, a `.cpp` file the cpp provider). The payload is self-describing
+ * (`{ kind: 'kotlin', companionScopes }`) so `applyKotlinCaptureSideChannel`
+ * only restores kotlin state and ignores a foreign-shaped snapshot.
+ */
+import type { ParsedFile, ScopeId } from '../../../../_shared/index.js';
+/**
+ * Plain JSON-serializable snapshot of the per-file Kotlin capture-time
+ * side-channel. Carried opaquely on `ParsedFile.captureSideChannel`. The
+ * `kind` tag makes the payload self-describing so `apply` can distinguish a
+ * kotlin snapshot from another language's (C++ shares the same field).
+ */
+export interface KotlinCaptureSideChannel {
+    readonly kind: 'kotlin';
+    /** Companion-object scope ids recorded for this file. */
+    readonly companionScopes: readonly ScopeId[];
+}
+/**
+ * `LanguageProvider.collectCaptureSideChannel` implementation for Kotlin.
+ * Returns `undefined` when this file recorded no companion scopes at all, so
+ * the produced `ParsedFile` carries the field only when there's data to ship.
+ */
+export declare function collectKotlinCaptureSideChannel(filePath: string): KotlinCaptureSideChannel | undefined;
+/**
+ * `ScopeResolver.applyCaptureSideChannel` implementation for Kotlin. Reads the
+ * worker-serialized snapshot from `parsed.captureSideChannel` and re-populates
+ * the module-level companion-scope map via `markCompanionScope`. Tolerant of
+ * `undefined` (file carried no data) and of an unexpected / foreign shape
+ * (defensive — the `kind` tag guards against restoring a non-kotlin payload).
+ * Does NO tree-sitter parse.
+ */
+export declare function applyKotlinCaptureSideChannel(parsed: ParsedFile): void;

package/dist/core/ingestion/languages/kotlin/capture-side-channel.js

@@ -0,0 +1,60 @@
+/**
+ * Kotlin capture-time side-channel serialization (#1983).
+ *
+ * `emitKotlinScopeCaptures` populates one MODULE-LEVEL, per-file map as a side
+ * effect that is NOT part of the returned `ParsedFile`'s scopes/defs:
+ *
+ *   - `companionScopesByFile`  (companion-scopes.ts) — the `ScopeId`s that came
+ *     from a `companion_object` AST node, recorded via `markCompanionScope`
+ *     from the `@scope.companion` marker capture.
+ *
+ * On the worker path that map is filled in the WORKER process and lost across
+ * the worker→main MessageChannel (and the disk-backed parsedfile-store),
+ * because scope-resolution reuses the serialized `ParsedFile` and SKIPS the
+ * main-thread re-extraction (the #1983 fix that avoids a main-thread
+ * tree-sitter re-parse / OOM on huge repos). The main thread then reads the map
+ * empty in `isKotlinStaticOnly` / `populateCompanionMembersOnEnclosingClass`
+ * (owners.ts) — so companion methods aren't identified as static and
+ * companion/static dispatch emits no CALLS edges.
+ *
+ * This module snapshots the per-file slice of that map into a plain,
+ * JSON-serializable object (carried on `ParsedFile.captureSideChannel`) and
+ * restores it on the main thread WITHOUT any parse. It mirrors the C++ pattern
+ * in `cpp/capture-side-channel.ts`.
+ *
+ * The single generic `ParsedFile.captureSideChannel` field is shared with C++,
+ * which is safe because each file is one language (a `.kt` file uses the kotlin
+ * provider, a `.cpp` file the cpp provider). The payload is self-describing
+ * (`{ kind: 'kotlin', companionScopes }`) so `applyKotlinCaptureSideChannel`
+ * only restores kotlin state and ignores a foreign-shaped snapshot.
+ */
+import { getCompanionScopesForFile, markCompanionScope } from './companion-scopes.js';
+/**
+ * `LanguageProvider.collectCaptureSideChannel` implementation for Kotlin.
+ * Returns `undefined` when this file recorded no companion scopes at all, so
+ * the produced `ParsedFile` carries the field only when there's data to ship.
+ */
+export function collectKotlinCaptureSideChannel(filePath) {
+    const companionScopes = getCompanionScopesForFile(filePath);
+    if (companionScopes.length === 0)
+        return undefined;
+    return { kind: 'kotlin', companionScopes };
+}
+/**
+ * `ScopeResolver.applyCaptureSideChannel` implementation for Kotlin. Reads the
+ * worker-serialized snapshot from `parsed.captureSideChannel` and re-populates
+ * the module-level companion-scope map via `markCompanionScope`. Tolerant of
+ * `undefined` (file carried no data) and of an unexpected / foreign shape
+ * (defensive — the `kind` tag guards against restoring a non-kotlin payload).
+ * Does NO tree-sitter parse.
+ */
+export function applyKotlinCaptureSideChannel(parsed) {
+    const data = parsed.captureSideChannel;
+    if (data === undefined || data === null || typeof data !== 'object')
+        return;
+    if (data.kind !== 'kotlin' || !Array.isArray(data.companionScopes))
+        return;
+    for (const scopeId of data.companionScopes) {
+        markCompanionScope(parsed.filePath, scopeId);
+    }
+}

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

@@ -1,5 +1,5 @@
 import { makeScopeId } from '../../../../_shared/index.js';
-import { findNodeAtRange, nodeToCapture, syntheticCapture, } from '../../utils/ast-helpers.js';
+import { nodeIfType, nodeToCapture, syntheticCapture, } from '../../utils/ast-helpers.js';
 import { getTreeSitterBufferSize } from '../../constants.js';
 import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
 import { computeKotlinArityMetadata } from './arity-metadata.js';
@@ -27,11 +27,20 @@ export function emitKotlinScopeCaptures(sourceText, filePath, cachedTree) {
     out.push(...synthesizeKotlinLoopBindings(tree.rootNode, returnTypes));
     out.push(...synthesizeKotlinSmartCastBindings(tree.rootNode));
     out.push(...synthesizeKotlinLambdaBindings(tree.rootNode, returnTypes));
+    out.push(...synthesizeKotlinInheritanceReferences(tree.rootNode));
+    out.push(...synthesizeKotlinSecondaryConstructorDeclarations(tree.rootNode));
     for (const match of getKotlinScopeQuery().matches(tree.rootNode)) {
         const grouped = {};
+        // Parallel tag -> captured SyntaxNode map. The query hands us each matched
+        // node as capture.node, so anchors resolve via a type-guarded lookup
+        // (nodeIfType) instead of re-deriving them with
+        // findNodeAtRange(tree.rootNode, ...) per match — the O(matches x N)
+        // root-walk fixed for go #1915 / python #1918 / csharp, mirrored here.
+        const groupedNodes = {};
         for (const capture of match.captures) {
             const tag = '@' + capture.name;
             grouped[tag] = nodeToCapture(tag, capture.node);
+            groupedNodes[tag] = capture.node;
         }
         if (Object.keys(grouped).length === 0)
             continue;
@@ -56,7 +65,7 @@ export function emitKotlinScopeCaptures(sourceText, filePath, cachedTree) {
             continue;
         }
         if (grouped['@import.statement'] !== undefined) {
-            const importNode = findNodeAtRange(tree.rootNode, grouped['@import.statement'].range, 'import_header');
+            const importNode = nodeIfType(groupedNodes['@import.statement'], 'import_header');
             if (importNode !== null) {
                 const decomposed = splitKotlinImportHeader(importNode);
                 if (decomposed !== null) {
@@ -65,13 +74,46 @@ export function emitKotlinScopeCaptures(sourceText, filePath, cachedTree) {
                 }
             }
         }
+        // Callable references (`::method`, `Type::new`, `obj::m`) — F47 (#1919).
+        // The query captures the referenced member as `@reference.name`, an
+        // optional receiver type as `@reference.receiver`, and the whole node as
+        // `@reference.callable`. Rewrite into a call reference so it participates
+        // in call-graph resolution: a bare `::member` resolves as a free call;
+        // a `Receiver::member` resolves as a member call against the receiver
+        // type. The function/constructor is referenced (not invoked), so no
+        // arity/argument metadata is attached.
+        if (grouped['@reference.callable'] !== undefined) {
+            const nameCap = grouped['@reference.name'];
+            const callableNode = groupedNodes['@reference.callable'];
+            if (nameCap !== undefined && callableNode !== undefined) {
+                const receiverCap = grouped['@reference.receiver'];
+                // The anchor Capture must carry the call-form tag as its `name` —
+                // the scope-extractor reads `Capture.name` (not the map key) to
+                // classify the reference kind, so re-wrap via nodeToCapture rather
+                // than reusing the `@reference.callable`-named Capture (whose head
+                // `callable` resolves to no ReferenceKind and silently drops it).
+                if (receiverCap !== undefined) {
+                    out.push({
+                        '@reference.call.member': nodeToCapture('@reference.call.member', callableNode),
+                        '@reference.name': nameCap,
+                        '@reference.receiver': receiverCap,
+                    });
+                }
+                else {
+                    out.push({
+                        '@reference.call.free': nodeToCapture('@reference.call.free', callableNode),
+                        '@reference.name': nameCap,
+                    });
+                }
+            }
+            continue;
+        }
         if (grouped['@reference.call.free'] !== undefined &&
             grouped['@reference.receiver'] !== undefined) {
             continue;
         }
         if (grouped['@reference.read.member'] !== undefined) {
-            const anchor = grouped['@reference.read.member'];
-            const navNode = findNodeAtRange(tree.rootNode, anchor.range, 'navigation_expression');
+            const navNode = nodeIfType(groupedNodes['@reference.read.member'], 'navigation_expression');
             if (navNode === null || !shouldEmitReadMember(navNode))
                 continue;
         }
@@ -91,14 +133,14 @@ export function emitKotlinScopeCaptures(sourceText, filePath, cachedTree) {
         if (grouped['@type-binding.annotation'] !== undefined &&
             grouped['@type-binding.name'] !== undefined &&
             grouped['@type-binding.type'] !== undefined) {
-            const annotation = grouped['@type-binding.annotation'];
-            if (propertyDeclHasConstructorValue(tree.rootNode, annotation.range)) {
+            const propNode = nodeIfType(groupedNodes['@type-binding.annotation'], 'property_declaration');
+            if (propNode !== null && propertyDeclHasConstructorValue(propNode)) {
                 continue;
             }
         }
         if (grouped['@scope.function'] !== undefined) {
             out.push(grouped);
-            const fnNode = findNodeAtRange(tree.rootNode, grouped['@scope.function'].range, 'function_declaration');
+            const fnNode = nodeIfType(groupedNodes['@scope.function'], 'function_declaration');
             if (fnNode !== null) {
                 out.push(...synthesizeKotlinReceiverBinding(fnNode));
             }
@@ -106,7 +148,7 @@ export function emitKotlinScopeCaptures(sourceText, filePath, cachedTree) {
         }
         const declTag = FUNCTION_DECL_TAGS.find((tag) => grouped[tag] !== undefined);
         if (declTag !== undefined) {
-            const fnNode = findNodeAtRange(tree.rootNode, grouped[declTag].range, 'function_declaration');
+            const fnNode = nodeIfType(groupedNodes[declTag], 'function_declaration');
             if (fnNode !== null) {
                 const arity = computeKotlinArityMetadata(fnNode);
                 if (arity.parameterCount !== undefined) {
@@ -122,7 +164,7 @@ export function emitKotlinScopeCaptures(sourceText, filePath, cachedTree) {
         }
         const callTag = ['@reference.call.free', '@reference.call.member', '@reference.call.constructor'].find((tag) => grouped[tag] !== undefined);
         if (callTag !== undefined && grouped['@reference.arity'] === undefined) {
-            const callNode = findNodeAtRange(tree.rootNode, grouped[callTag].range, 'call_expression');
+            const callNode = nodeIfType(groupedNodes[callTag], 'call_expression');
             if (callNode !== null) {
                 const args = callArguments(callNode);
                 grouped['@reference.arity'] = syntheticCapture('@reference.arity', callNode, String(args.length));
@@ -130,12 +172,161 @@ export function emitKotlinScopeCaptures(sourceText, filePath, cachedTree) {
             }
         }
         out.push(grouped);
-        const extensionFallback = extensionFreeCallFallback(grouped, tree.rootNode);
+        const extensionFallback = extensionFreeCallFallback(grouped, groupedNodes);
         if (extensionFallback !== null)
             out.push(extensionFallback);
     }
     return out;
 }
+/**
+ * Synthesize `@reference.inherits` captures from Kotlin `class_declaration`
+ * delegation specifiers so the registry-primary scope-resolution path emits
+ * EXTENDS / IMPLEMENTS edges (mirrors C# `synthesizeCsharpInheritanceReferences`
+ * and C++ `emitCppInheritanceCaptures`). Without this, Kotlin inheritance edges
+ * came only from the legacy heritage-capture leg (removed in #942), which the
+ * worker pipeline drops for registry-primary languages → 0 inheritance edges in
+ * worker mode (#1951).
+ *
+ * Scope mirrors the legacy KOTLIN_QUERIES heritage patterns exactly
+ * (the config-driven `kotlinHeritageShapes`: `user_type`,
+ * `constructor_invocation`, `explicit_delegation`). Each `delegation_specifier`
+ * child of a `class_declaration`, in one of three forms —
+ *   - bare interface/superclass: `class Foo : Bar`
+ *     `(delegation_specifier (user_type (type_identifier)))`
+ *   - constructor-call superclass: `class Foo : Bar()`
+ *     `(delegation_specifier (constructor_invocation (user_type (type_identifier))))`
+ *   - interface delegation: `class Foo : Bar by delegate`
+ *     `(delegation_specifier (explicit_delegation (user_type (type_identifier)) …))`
+ *     — the delegated interface is the LEADING `user_type`; the trailing
+ *     delegate expression (`by delegate`) is NOT a supertype (#1951). This is
+ *     the dropped shape the registry-primary synth previously skipped, leaving
+ *     `class F : Iface by d` with no IMPLEMENTS edge in worker mode.
+ *
+ * Kotlin uses `:` for BOTH superclass and interfaces — the EXTENDS-vs-IMPLEMENTS
+ * split is decided downstream from the resolved target's symbol kind
+ * (`preEmitInheritanceEdges`), so every base is emitted with the same `inherits`
+ * kind here. The bare lookup name is normalized to the simple identifier
+ * (`Base()` → `Base`, `Base<T>` → `Base`, `pkg.Base` → `Base`,
+ * `Iface by d` → `Iface`) so V1's simple-name `findClassBindingInScope`
+ * resolves it. The extracted bare name agrees with the legacy leg's
+ * `normalizeSupertypeName` for every shape (verified by real-parse).
+ */
+function synthesizeKotlinInheritanceReferences(rootNode) {
+    const out = [];
+    for (const classNode of descendantsOfType(rootNode, 'class_declaration')) {
+        for (const child of classNode.namedChildren) {
+            if (child.type !== 'delegation_specifier')
+                continue;
+            // Three wrappers, all resolving to a leading `user_type` →
+            // `type_identifier`:
+            //   - `(delegation_specifier (constructor_invocation (user_type …)))` for `Base()`
+            //   - `(delegation_specifier (explicit_delegation (user_type …) <delegate>))`
+            //     for `Iface by d` — the supertype is the FIRST `user_type`; the
+            //     delegate expression that trails `by` is ignored.
+            //   - `(delegation_specifier (user_type …))` for a bare interface/superclass.
+            const ctor = child.namedChildren.find((n) => n.type === 'constructor_invocation');
+            const delegation = child.namedChildren.find((n) => n.type === 'explicit_delegation');
+            const userType = ctor?.namedChildren.find((n) => n.type === 'user_type') ??
+                delegation?.namedChildren.find((n) => n.type === 'user_type') ??
+                child.namedChildren.find((n) => n.type === 'user_type');
+            if (userType === undefined)
+                continue;
+            const nameNode = kotlinUserTypeNameNode(userType);
+            if (nameNode === null)
+                continue;
+            out.push({
+                '@reference.inherits': nodeToCapture('@reference.inherits', child),
+                '@reference.name': nodeToCapture('@reference.name', nameNode),
+            });
+        }
+    }
+    return out;
+}
+/**
+ * The enclosing type name for a node nested in a class/object/companion body.
+ * Walks up to the first `class_declaration` / `object_declaration` /
+ * `companion_object` ancestor and returns its `type_identifier` name node.
+ * Used to qualify a secondary-constructor declaration as `<ClassName>.constructor`.
+ */
+function kotlinEnclosingTypeNameNode(node) {
+    for (let cur = node.parent; cur !== null; cur = cur.parent) {
+        if (cur.type === 'class_declaration' ||
+            cur.type === 'object_declaration' ||
+            cur.type === 'companion_object') {
+            const nameNode = cur.namedChildren.find((c) => c.type === 'type_identifier');
+            return nameNode ?? null;
+        }
+    }
+    return null;
+}
+/**
+ * Synthesize a `@declaration.constructor` capture for each Kotlin
+ * `secondary_constructor` (issue #1919 review CF1). The structure phase already
+ * materializes a `Constructor` graph node (`Constructor:file:Class.constructor#<arity>`),
+ * but the registry-primary scope-resolution path had no Constructor *def* in the
+ * scope tree — so a call inside the constructor body resolved its caller anchor
+ * up to the enclosing Class def, mis-attributing the CALLS edge to the class.
+ *
+ * Paired with `(secondary_constructor) @scope.function` in query.ts: that rule
+ * makes the constructor body its own Function scope; this declaration places a
+ * Constructor def in that scope so `pickCallerCallableDef` anchors calls on the
+ * Constructor. The def is keyed to match the structure-phase node id:
+ *   - `@declaration.qualified_name` = `<ClassName>.constructor` so the bridge's
+ *     qualified key (`<q>:file::Constructor::Class.constructor`) hits the node.
+ *   - `@declaration.parameter-types` so two same-name secondary constructors are
+ *     disambiguated by the bridge's parameter-types key (`~Int,Int`), matching
+ *     the `#<arity>`-suffixed structure node for the overload with the same
+ *     parameter shape. (The zero-arg overload carries no parameter types and
+ *     resolves via the qualified/simple key to the `#0` node.)
+ *
+ * The anchor spans the whole `secondary_constructor` node — same range as the
+ * `@scope.function` it pairs with — so the def is owned by that Function scope
+ * and the constructor name auto-hoists to the enclosing class scope (exactly the
+ * binding shape a normal method declaration produces).
+ */
+function synthesizeKotlinSecondaryConstructorDeclarations(rootNode) {
+    const out = [];
+    for (const ctorNode of descendantsOfType(rootNode, 'secondary_constructor')) {
+        const keyword = ctorNode.namedChildren.find((c) => c.type === 'constructor');
+        // The `constructor` keyword is an anonymous token; fall back to the node
+        // itself for the name capture position when the named-child lookup misses.
+        const nameAnchor = keyword ?? ctorNode;
+        const classNameNode = kotlinEnclosingTypeNameNode(ctorNode);
+        const qualifiedName = classNameNode !== null ? `${classNameNode.text}.constructor` : 'constructor';
+        const match = {
+            '@declaration.constructor': nodeToCapture('@declaration.constructor', ctorNode),
+            '@declaration.name': syntheticCapture('@declaration.name', nameAnchor, 'constructor'),
+            '@declaration.qualified_name': syntheticCapture('@declaration.qualified_name', ctorNode, qualifiedName),
+        };
+        const arity = computeKotlinArityMetadata(ctorNode);
+        if (arity.parameterCount !== undefined) {
+            match['@declaration.parameter-count'] = syntheticCapture('@declaration.parameter-count', ctorNode, String(arity.parameterCount));
+        }
+        if (arity.requiredParameterCount !== undefined) {
+            match['@declaration.required-parameter-count'] = syntheticCapture('@declaration.required-parameter-count', ctorNode, String(arity.requiredParameterCount));
+        }
+        if (arity.parameterTypes !== undefined) {
+            match['@declaration.parameter-types'] = syntheticCapture('@declaration.parameter-types', ctorNode, JSON.stringify(arity.parameterTypes));
+        }
+        out.push(match);
+    }
+    return out;
+}
+/**
+ * The bare simple-name `type_identifier` of a `user_type`. Strips generic
+ * type arguments (`Base<T>` → `Base`) and qualifier tails (`pkg.Base` → `Base`)
+ * by taking the LAST direct `type_identifier` child, matching the legacy
+ * heritage capture of a `user_type`'s `type_identifier` and V1's
+ * simple-name `findClassBindingInScope` contract.
+ */
+function kotlinUserTypeNameNode(userType) {
+    let nameNode = null;
+    for (const child of userType.namedChildren) {
+        if (child.type === 'type_identifier')
+            nameNode = child;
+    }
+    return nameNode;
+}
 function synthesizeKotlinLoopBindings(rootNode, returnTypes) {
     const out = [];
     for (const fnNode of descendantsOfType(rootNode, 'function_declaration')) {
@@ -882,14 +1073,11 @@ function shouldEmitReadMember(navNode) {
         return false;
     return true;
 }
-/** True when the property_declaration anchored at `range` has a
- *  `call_expression` value sibling (i.e. `val x: T = Foo()`). Used to
- *  suppress the explicit-annotation type-binding capture so the
- *  constructor-inferred binding wins (#1762). */
-function propertyDeclHasConstructorValue(rootNode, range) {
-    const propNode = findNodeAtRange(rootNode, range, 'property_declaration');
-    if (propNode === null)
-        return false;
+/** True when the given `property_declaration` has a `call_expression`
+ *  value sibling (i.e. `val x: T = Foo()`). Used to suppress the
+ *  explicit-annotation type-binding capture so the constructor-inferred
+ *  binding wins (#1762). */
+function propertyDeclHasConstructorValue(propNode) {
     const variable = propNode.namedChildren.find((c) => c.type === 'variable_declaration');
     if (variable === undefined)
         return false;
@@ -929,17 +1117,20 @@ function inferArgType(argNode) {
             return '';
     }
 }
-function extensionFreeCallFallback(grouped, rootNode) {
+function extensionFreeCallFallback(grouped, groupedNodes) {
     const member = grouped['@reference.call.member'];
     const receiver = grouped['@reference.receiver'];
     const name = grouped['@reference.name'];
     if (member === undefined || receiver === undefined || name === undefined)
         return null;
-    const callNode = findNodeAtRange(rootNode, member.range, 'call_expression');
+    // The `@reference.call.member` anchor IS the `call_expression`, and the
+    // `@reference.receiver` anchor IS the receiver node — both threaded from the
+    // query match (no per-match root walk).
+    const callNode = nodeIfType(groupedNodes['@reference.call.member'], 'call_expression');
     if (callNode === null)
         return null;
-    const receiverNode = findNodeAtRange(rootNode, receiver.range);
-    if (receiverNode === null || !isLiteralReceiver(receiverNode))
+    const receiverNode = groupedNodes['@reference.receiver'];
+    if (receiverNode === undefined || !isLiteralReceiver(receiverNode))
         return null;
     const out = {
         '@reference.call.free': syntheticCapture('@reference.call.free', callNode, callNode.text),

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

@@ -3,5 +3,12 @@ import type { ScopeId } from '../../../../_shared/index.js';
 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;
+/**
+ * Snapshot the companion-object scope ids recorded for `filePath` as a plain
+ * array (for the worker→main capture side-channel, #1983). Returns an empty
+ * array when the file recorded no companion scopes. See
+ * `capture-side-channel.ts`.
+ */
+export declare function getCompanionScopesForFile(filePath: string): ScopeId[];
 /** Clear all tracked companion scopes (for testing). */
 export declare function clearCompanionScopes(): void;

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

@@ -50,6 +50,16 @@ export function markCompanionScope(filePath, scopeId) {
 export function isCompanionScope(filePath, scopeId) {
     return companionScopesByFile.get(filePath)?.has(scopeId) ?? false;
 }
+/**
+ * Snapshot the companion-object scope ids recorded for `filePath` as a plain
+ * array (for the worker→main capture side-channel, #1983). Returns an empty
+ * array when the file recorded no companion scopes. See
+ * `capture-side-channel.ts`.
+ */
+export function getCompanionScopesForFile(filePath) {
+    const scopes = companionScopesByFile.get(filePath);
+    return scopes === undefined ? [] : [...scopes];
+}
 /** Clear all tracked companion scopes (for testing). */
 export function clearCompanionScopes() {
     companionScopesByFile.clear();

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

@@ -1,4 +1,5 @@
 export { emitKotlinScopeCaptures } from './captures.js';
+export { collectKotlinCaptureSideChannel, applyKotlinCaptureSideChannel, type KotlinCaptureSideChannel, } from './capture-side-channel.js';
 export { getKotlinCaptureCacheStats, resetKotlinCaptureCacheStats } from './cache-stats.js';
 export { interpretKotlinImport, interpretKotlinTypeBinding } from './interpret.js';
 export { kotlinArityCompatibility } from './arity.js';

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

@@ -1,4 +1,5 @@
 export { emitKotlinScopeCaptures } from './captures.js';
+export { collectKotlinCaptureSideChannel, applyKotlinCaptureSideChannel, } from './capture-side-channel.js';
 export { getKotlinCaptureCacheStats, resetKotlinCaptureCacheStats } from './cache-stats.js';
 export { interpretKotlinImport, interpretKotlinTypeBinding } from './interpret.js';
 export { kotlinArityCompatibility } from './arity.js';

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

@@ -8,6 +8,16 @@ const KOTLIN_SCOPE_QUERY = `
 (companion_object) @scope.class
 (function_declaration) @scope.function
 
+;; Secondary-constructor body scope (issue #1919 review CF1). A
+;; secondary constructor's "constructor(...) { ... }" body executes statements
+;; just like a method body, so it must be its OWN Function scope — otherwise a
+;; call inside the body resolves its caller anchor up to the enclosing Class
+;; scope (the class's Class def), mis-attributing the CALLS edge to the class
+;; rather than the Constructor. The matching @declaration.constructor is
+;; synthesized in captures.ts (synthesizeKotlinSecondaryConstructorDeclarations)
+;; so this scope owns a Constructor def keyed to the structure-phase node id.
+(secondary_constructor) @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.
@@ -116,6 +126,26 @@ const KOTLIN_SCOPE_QUERY = `
   (function_value_parameters)
   [(user_type) (nullable_type) (function_type)] @type-binding.type) @type-binding.return
 
+;; References — callable references ("::method", "Type::new", "obj::m") — F47.
+;; A "callable_reference" references a function/constructor as a value (no
+;; call_suffix), so the registry-primary call path never saw it. Real-parse
+;; (issue #1919) shows the canonical shape inside a function body is:
+;;   "::topLevelFn"   -> (callable_reference :: (simple_identifier))   member only
+;;   "String::length" -> (callable_reference (type_identifier) :: (simple_identifier))
+;;   "obj::method"    -> (callable_reference (type_identifier) :: (simple_identifier))
+;;   "Type::new"      -> (callable_reference (type_identifier) :: (simple_identifier))
+;; The receiver (real type OR object) is always a "type_identifier"; the
+;; referenced member is the LAST "simple_identifier". One rule with an
+;; optional receiver and an end-anchored member covers all four forms with
+;; exactly one match per callable_reference (no sibling-branch double-match).
+;; (NOTE: a qualified "A.B::m" parses as a nested navigation_expression, not a
+;; callable_reference, and is already captured by the read.member rule below.)
+;; emitKotlinScopeCaptures rewrites this into a free/member call reference.
+(callable_reference
+  (type_identifier)? @reference.receiver
+  (simple_identifier) @reference.name
+  .) @reference.callable
+
 ;; References — direct calls / constructor syntax
 (call_expression
   (simple_identifier) @reference.name) @reference.call.free

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

@@ -2,14 +2,12 @@ import type { ScopeResolver } from '../../scope-resolution/contract/scope-resolv
 /**
  * Kotlin scope resolver for RFC #909 Ring 3.
  *
- * **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.
+ * Kotlin resolves via the scope-resolution registry — production
+ * resolution flows through the scope-resolution pipeline as the sole
+ * call-resolution path.
  *
- * **Forced-mode parity (`REGISTRY_PRIMARY_KOTLIN=1`):** 208/208
- * fixtures pass after the migration sub-issues #1758–#1763, the
+ * **Coverage:** 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,

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

@@ -5,18 +5,17 @@ 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 { applyKotlinCaptureSideChannel } from './capture-side-channel.js';
 import { isKotlinStaticOnly } from './owners.js';
 /**
  * Kotlin scope resolver for RFC #909 Ring 3.
  *
- * **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.
+ * Kotlin resolves via the scope-resolution registry — production
+ * resolution flows through the scope-resolution pipeline as the sole
+ * call-resolution path.
  *
- * **Forced-mode parity (`REGISTRY_PRIMARY_KOTLIN=1`):** 208/208
- * fixtures pass after the migration sub-issues #1758–#1763, the
+ * **Coverage:** 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,
@@ -67,6 +66,22 @@ export const kotlinScopeResolver = {
     mergeBindings: (existing, incoming) => [...kotlinMergeBindings([...existing, ...incoming])],
     arityCompatibility: (callsite, def) => kotlinArityCompatibility(def, callsite),
     buildMro: (graph, parsedFiles, nodeLookup) => buildKotlinMro(graph, parsedFiles, nodeLookup),
+    // Worker-boundary restore (see `ScopeResolver.applyCaptureSideChannel`).
+    // `emitKotlinScopeCaptures` records per-file companion-object scope ids
+    // (`markCompanionScope` → `companionScopesByFile`) as a SIDE EFFECT — that
+    // state is NOT serialized onto the returned ParsedFile's scopes/defs. On the
+    // worker path those marks are populated in the worker process and lost across
+    // the MessageChannel / disk store; the main thread reuses the serialized
+    // ParsedFile and skips `extractParsedFile`, so `isKotlinStaticOnly` and
+    // `populateCompanionMembersOnEnclosingClass` (owners.ts) would see an empty
+    // map and companion/static dispatch would emit zero CALLS edges. The worker
+    // stashed a plain-data snapshot on `parsed.captureSideChannel` via
+    // `kotlinProvider.collectCaptureSideChannel`; this restores it into the
+    // module map WITHOUT any tree-sitter re-parse (the #1983 fix). The
+    // freshly-extracted leg never calls this — its marks were just populated in
+    // this process. Runs BEFORE `populateOwners` so the restored companion map is
+    // visible to it.
+    applyCaptureSideChannel: applyKotlinCaptureSideChannel,
     populateOwners: (parsed) => populateKotlinOwners(parsed),
     isSuperReceiver: (text) => text.trim() === 'super',
     isStaticOnly: isKotlinStaticOnly,