cgraphx 2.0.1 → 2.0.3

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

@@ -0,0 +1,243 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getKotlinParser = getKotlinParser;
+exports.getKotlinScopeQuery = getKotlinScopeQuery;
+const tree_sitter_1 = __importDefault(require("tree-sitter"));
+const index_js_1 = require("../../../../../shared/index.js");
+// `tree-sitter-kotlin` is a vendored grammar (loaded from vendor/ by absolute
+// path, never node_modules — vendored-grammars.ts / #2111) that may be absent on
+// a platform without a matching prebuild. Loaded lazily + guarded via parser-loader
+// rather than statically imported: this module is pulled onto the main thread
+// eagerly by the scope-resolution registry and the language-provider index, so
+// a top-level `import Kotlin from 'tree-sitter-kotlin'` would throw
+// ERR_MODULE_NOT_FOUND at module-load and crash `analyze` even for repos with no
+// Kotlin files (#2091, #2093). The grammar is only ever needed in the getters.
+const parser_loader_js_1 = require("../../../tree-sitter/parser-loader.js");
+const KOTLIN_SCOPE_QUERY = `
+;; Scopes
+(source_file) @scope.module
+(class_declaration) @scope.class
+(object_declaration) @scope.class
+(companion_object) @scope.class
+;; Anonymous object expression: \`val h = object { fun fetch() {} }\`
+;; (distinct from the named \`object_declaration\`/\`companion_object\` above).
+;; Without its own scope, a method's auto-hoist (scope-extractor.ts) has
+;; nowhere to stop and leaks the name past the literal into the enclosing
+;; scope -- the same failure mode fixed for TS/JS object literals (#2545).
+(object_literal) @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.
+;; 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
+;; synthesizeKotlinSmartCastBindings) shadow the outer parameter
+;; binding for calls inside the body — without leaking across arms.
+(when_entry
+  (when_condition (type_test))
+  (control_structure_body) @scope.block)
+
+(if_expression
+  (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
+;; The Kotlin grammar puts NO named fields on \`class_declaration\`, so the
+;; parameter list is matched positionally as an optional unnamed child, exactly
+;; as the name already is.
+;;
+;; Only the INLINE bound (\`<T : Repo>\`) is read. A \`where T : Repo\` clause is a
+;; separate \`type_constraints\` sibling and is left alone, so its bound reads as
+;; absent — "unknown", not "unbounded".
+(class_declaration
+  "interface"
+  (type_identifier) @declaration.name
+  (type_parameters)? @declaration.type-parameters) @declaration.interface
+
+(class_declaration
+  "class"
+  (type_identifier) @declaration.name
+  (type_parameters)? @declaration.type-parameters) @declaration.class
+
+(object_declaration
+  (type_identifier) @declaration.name) @declaration.class
+
+(companion_object
+  (type_identifier) @declaration.name) @declaration.class
+
+(type_alias
+  (type_identifier) @declaration.name) @declaration.type_alias
+
+;; Class annotation syntax is carried to post-resolution enrichment. Keeping
+;; this in the existing scope query avoids a second AST traversal. Eligibility
+;; filtering (class vs interface/enum/annotation class) happens in captures.ts.
+(class_declaration
+  (modifiers
+    [
+      (annotation
+        (user_type) @class-annotation.name)
+      (annotation
+        (constructor_invocation
+          (user_type) @class-annotation.name))
+    ])) @class-annotation.class
+
+;; Declarations — functions / methods / properties
+(function_declaration
+  (simple_identifier) @declaration.name) @declaration.function
+
+;; Lambda bound to a val/var: val handler = { x: Int -> target(x) }
+;; Anchor discipline (same contract as javascript/query.ts): @declaration.function
+;; sits on the INNER lambda_literal, NOT on the property_declaration wrapper, so
+;; anchor.range aligns with the (lambda_literal) @scope.block range. That
+;; alignment is what lets pickCallerCallableDef accept a Block-kind scope as a
+;; callable boundary: the scope IS the callable's body. The lambda stays
+;; @scope.block deliberately (#1757 smart casts) — do NOT re-kind it.
+(property_declaration
+  (variable_declaration (simple_identifier) @declaration.name)
+  (lambda_literal) @declaration.function)
+
+(property_declaration
+  (variable_declaration
+    (simple_identifier) @declaration.name)) @declaration.property
+
+(class_parameter
+  (binding_pattern_kind)
+  (simple_identifier) @declaration.name) @declaration.property
+
+;; Imports
+(import_header) @import.statement
+
+;; Type bindings — parameters
+(parameter
+  (simple_identifier) @type-binding.name
+  [(user_type) (nullable_type) (function_type)] @type-binding.type) @type-binding.parameter
+
+;; Type bindings — property / local annotations
+(property_declaration
+  (variable_declaration
+    (simple_identifier) @type-binding.name
+    [(user_type) (nullable_type) (function_type)] @type-binding.type)) @type-binding.annotation
+
+(class_parameter
+  (binding_pattern_kind)
+  (simple_identifier) @type-binding.name
+  [(user_type) (nullable_type) (function_type)] @type-binding.type) @type-binding.annotation
+
+;; Type bindings — constructor-inferred val user = User(...)
+(property_declaration
+  (variable_declaration
+    (simple_identifier) @type-binding.name)
+  (call_expression
+    (simple_identifier) @type-binding.type)) @type-binding.constructor
+
+;; Type bindings — return annotations after function parameters
+(function_declaration
+  (simple_identifier) @type-binding.name
+  (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
+
+;; References — member calls: obj.method()
+(call_expression
+  (navigation_expression
+    (_) @reference.receiver
+    (navigation_suffix
+      (simple_identifier) @reference.name))) @reference.call.member
+
+;; References — property writes
+(assignment
+  (directly_assignable_expression
+    (_) @reference.receiver
+    (navigation_suffix
+      (simple_identifier) @reference.name))
+  (_)) @reference.write.member
+
+;; References — property reads
+(navigation_expression
+  (_) @reference.receiver
+  (navigation_suffix
+    (simple_identifier) @reference.name)) @reference.read.member
+`;
+let parser = null;
+let query = null;
+function getKotlinParser() {
+    if (parser === null) {
+        parser = new tree_sitter_1.default();
+        parser.setLanguage((0, parser_loader_js_1.getLanguageGrammar)(index_js_1.SupportedLanguages.Kotlin));
+    }
+    return parser;
+}
+function getKotlinScopeQuery() {
+    if (query === null) {
+        query = new tree_sitter_1.default.Query((0, parser_loader_js_1.getLanguageGrammar)(index_js_1.SupportedLanguages.Kotlin), KOTLIN_SCOPE_QUERY);
+    }
+    return query;
+}

package/dist/core/code/engine/core/ingestion/languages/kotlin/receiver-binding.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.synthesizeKotlinReceiverBinding = synthesizeKotlinReceiverBinding;
+const ast_helpers_js_1 = require("../../utils/ast-helpers.js");
+const interpret_js_1 = require("./interpret.js");
+const TYPE_DECL_NODE_TYPES = new Set([
+    'class_declaration',
+    'object_declaration',
+    'companion_object',
+]);
+function synthesizeKotlinReceiverBinding(fnNode) {
+    if (fnNode.type !== 'function_declaration')
+        return [];
+    const anchorNode = findFunctionBody(fnNode);
+    if (anchorNode === null)
+        return [];
+    const extensionReceiver = extensionReceiverType(fnNode);
+    if (extensionReceiver !== null) {
+        return [buildReceiverMatch(anchorNode, 'this', extensionReceiver)];
+    }
+    const enclosingType = findEnclosingTypeDeclaration(fnNode);
+    if (enclosingType === null)
+        return [];
+    const enclosingName = typeDeclarationName(enclosingType);
+    if (enclosingName === null)
+        return [];
+    const out = [buildReceiverMatch(anchorNode, 'this', enclosingName)];
+    const superName = firstSuperclassText(enclosingType);
+    if (superName !== null)
+        out.push(buildReceiverMatch(anchorNode, 'super', superName));
+    return out;
+}
+function findFunctionBody(fnNode) {
+    for (let i = 0; i < fnNode.namedChildCount; i++) {
+        const child = fnNode.namedChild(i);
+        if (child?.type === 'function_body')
+            return child;
+    }
+    return fnNode;
+}
+function extensionReceiverType(fnNode) {
+    for (let i = 0; i < fnNode.namedChildCount; i++) {
+        const child = fnNode.namedChild(i);
+        if (child === null)
+            continue;
+        if (child.type === 'simple_identifier')
+            return null;
+        if (child.type === 'user_type' || child.type === 'nullable_type') {
+            return (0, interpret_js_1.normalizeKotlinType)(child.text);
+        }
+    }
+    return null;
+}
+function findEnclosingTypeDeclaration(node) {
+    let current = node.parent;
+    while (current !== null) {
+        if (TYPE_DECL_NODE_TYPES.has(current.type))
+            return current;
+        current = current.parent;
+    }
+    return null;
+}
+function typeDeclarationName(typeNode) {
+    if (typeNode.type === 'companion_object') {
+        return (typeNode.namedChildren.find((child) => child.type === 'type_identifier')?.text ??
+            enclosingNonCompanionTypeName(typeNode) ??
+            'Companion');
+    }
+    return typeNode.namedChildren.find((child) => child.type === 'type_identifier')?.text ?? null;
+}
+function enclosingNonCompanionTypeName(node) {
+    let current = node.parent;
+    while (current !== null) {
+        if (current.type === 'class_declaration' || current.type === 'object_declaration') {
+            return current.namedChildren.find((child) => child.type === 'type_identifier')?.text ?? null;
+        }
+        current = current.parent;
+    }
+    return null;
+}
+function firstSuperclassText(typeNode) {
+    if (typeNode.type !== 'class_declaration')
+        return null;
+    for (const child of typeNode.namedChildren) {
+        if (child.type !== 'delegation_specifier')
+            continue;
+        const ctor = child.namedChildren.find((n) => n.type === 'constructor_invocation');
+        const userType = ctor?.namedChildren.find((n) => n.type === 'user_type') ??
+            child.namedChildren.find((n) => n.type === 'user_type');
+        const name = userType?.namedChildren.find((n) => n.type === 'type_identifier')?.text;
+        if (name !== undefined)
+            return (0, interpret_js_1.normalizeKotlinType)(name);
+    }
+    return null;
+}
+function buildReceiverMatch(anchorNode, name, typeText) {
+    const out = {
+        '@type-binding.self': (0, ast_helpers_js_1.nodeToCapture)('@type-binding.self', anchorNode),
+        '@type-binding.name': (0, ast_helpers_js_1.syntheticCapture)('@type-binding.name', anchorNode, name),
+        '@type-binding.type': (0, ast_helpers_js_1.syntheticCapture)('@type-binding.type', anchorNode, typeText),
+    };
+    return out;
+}

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

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kotlinScopeResolver = void 0;
+const index_js_1 = require("../../../../../shared/index.js");
+const mro_js_1 = require("../../scope-resolution/passes/mro.js");
+const ids_js_1 = require("../../scope-resolution/graph-bridge/ids.js");
+const walkers_js_1 = require("../../scope-resolution/scope/walkers.js");
+const shared_js_1 = require("../../type-extractors/shared.js");
+const kotlin_js_1 = require("../kotlin.js");
+const index_js_2 = require("./index.js");
+const companion_scopes_js_1 = require("./companion-scopes.js");
+const capture_side_channel_js_1 = require("./capture-side-channel.js");
+const owners_js_1 = require("./owners.js");
+const package_siblings_js_1 = require("./package-siblings.js");
+const spring_bean_metadata_js_1 = require("./spring-bean-metadata.js");
+const spring_aop_js_1 = require("./spring-aop.js");
+const package_facts_js_1 = require("./package-facts.js");
+const spring_di_js_1 = require("./spring-di.js");
+const spring_conditionals_js_1 = require("./spring-conditionals.js");
+/**
+ * Kotlin scope resolver for RFC #909 Ring 3.
+ *
+ * Kotlin resolves via the scope-resolution registry — production
+ * resolution flows through the scope-resolution pipeline as the sole
+ * call-resolution path.
+ *
+ * **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,
+ * 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.
+ *
+ * **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.
+ */
+exports.kotlinScopeResolver = {
+    language: index_js_1.SupportedLanguages.Kotlin,
+    languageProvider: kotlin_js_1.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.
+        (0, companion_scopes_js_1.clearCompanionScopes)();
+        (0, capture_side_channel_js_1.clearKotlinClassAnnotationFacts)();
+        (0, package_facts_js_1.clearKotlinPackageFacts)();
+        return undefined;
+    },
+    resolveImportTarget: (targetRaw, fromFile, allFilePaths) => {
+        const ws = { fromFile, allFilePaths };
+        return (0, index_js_2.resolveKotlinImportTarget)({ kind: 'named', localName: '_', importedName: '_', targetRaw }, ws);
+    },
+    mergeBindings: (existing, incoming) => [...(0, index_js_2.kotlinMergeBindings)([...existing, ...incoming])],
+    arityCompatibility: (callsite, def) => (0, index_js_2.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: capture_side_channel_js_1.applyKotlinCaptureSideChannel,
+    populateOwners: (parsed) => (0, index_js_2.populateKotlinOwners)(parsed),
+    isSuperReceiver: (text) => text.trim() === 'super',
+    // Subscript route only — Kotlin's collection views (`.values`, `.keys`) are
+    // properties on the stdlib types, resolved by the ordinary member walk rather
+    // than by unwrapping a generic here.
+    //
+    // Fed the annotation AS WRITTEN (`List<User>`, `Map<String, User>`), which
+    // `normalizeKotlinType` had already reduced to `User`. `undefined` means "not
+    // a container", so an `operator fun get` class does not fold `cache[k]` onto
+    // `Cache` itself.
+    elementTypeOf: shared_js_1.indexOnlyElementType,
+    isStaticOnly: owners_js_1.isKotlinStaticOnly,
+    fieldFallbackOnMethodLookup: false,
+    propagatesReturnTypesAcrossImports: true,
+    collapseMemberCallsByCallerTarget: false,
+    hoistTypeBindingsToModule: true,
+    freeCallsRequireInstanceOwnership: true,
+    postExtractSourceTextPolicy: 'uncached-files',
+    populateNamespaceSiblings: package_siblings_js_1.populateKotlinPackageSiblings,
+    emitPostResolutionEdges: (graph, parsedFiles, nodeLookup, indexes) => {
+        (0, spring_bean_metadata_js_1.attachKotlinSpringBeanCandidateMetadata)(graph, parsedFiles, nodeLookup, indexes);
+        (0, spring_aop_js_1.attachKotlinSpringAopMetadata)(graph, parsedFiles, nodeLookup, indexes);
+        (0, spring_conditionals_js_1.attachKotlinSpringConditionalMetadata)(graph, parsedFiles, nodeLookup, indexes);
+        (0, spring_di_js_1.attachKotlinSpringDiMetadata)(graph, parsedFiles, nodeLookup, indexes);
+    },
+};
+/**
+ * Kotlin MRO builder — extends `defaultLinearize` (EXTENDS-only) with
+ * interface ancestors discovered via `IMPLEMENTS` edges. Interface
+ * default methods (`interface Validator { fun validate(): Boolean = true }`)
+ * are inherited by implementing classes without an explicit override;
+ * the generic MRO would not surface them because the implementor has
+ * no `EXTENDS` link to the interface (#1763).
+ *
+ * Interfaces are appended after the EXTENDS chain (Kotlin resolves
+ * conflicts by requiring an explicit override, so first-seen-in-MRO
+ * ordering is a reasonable approximation for method lookup). Transitive
+ * interface inheritance (`interface A : B`) is closed via BFS.
+ */
+function buildKotlinMro(graph, parsedFiles, nodeLookup) {
+    const mro = (0, mro_js_1.buildMro)(graph, parsedFiles, nodeLookup, mro_js_1.defaultLinearize);
+    const defIdByGraphId = new Map();
+    for (const parsed of parsedFiles) {
+        for (const def of parsed.localDefs) {
+            if (!(0, walkers_js_1.isClassLike)(def.type))
+                continue;
+            const graphId = (0, ids_js_1.resolveDefGraphId)(parsed.filePath, def, nodeLookup);
+            if (graphId !== undefined)
+                defIdByGraphId.set(graphId, def.nodeId);
+        }
+    }
+    // Direct IMPLEMENTS targets per class-like def.
+    const directImpls = new Map();
+    for (const rel of graph.iterRelationshipsByType('IMPLEMENTS')) {
+        const source = defIdByGraphId.get(rel.sourceId);
+        const target = defIdByGraphId.get(rel.targetId);
+        if (source === undefined || target === undefined)
+            continue;
+        let list = directImpls.get(source);
+        if (list === undefined) {
+            list = [];
+            directImpls.set(source, list);
+        }
+        if (!list.includes(target))
+            list.push(target);
+    }
+    // For each class, append the transitive closure of interfaces reachable
+    // through its own + ancestor classes' IMPLEMENTS edges. Walking
+    // ancestors picks up interfaces inherited via the EXTENDS chain
+    // (e.g. `class C : B; class B : A; interface A` — C inherits A's
+    // interface methods through B).
+    for (const [classDefId, extendsMro] of mro) {
+        const ancestorChain = [classDefId, ...extendsMro];
+        const seeds = [];
+        for (const ancestorId of ancestorChain) {
+            for (const ifaceId of directImpls.get(ancestorId) ?? []) {
+                seeds.push(ifaceId);
+            }
+        }
+        if (seeds.length === 0)
+            continue;
+        const interfaces = closeInterfaces(seeds, directImpls);
+        mro.set(classDefId, [...extendsMro, ...interfaces.filter((i) => !extendsMro.includes(i))]);
+    }
+    // Classes with no EXTENDS still need an MRO entry when they implement
+    // interfaces (e.g. `class User : Validator` — no `mro` entry from the
+    // EXTENDS-only pass because no EXTENDS edges exist).
+    for (const [classDefId, ifaces] of directImpls) {
+        if (mro.has(classDefId))
+            continue;
+        mro.set(classDefId, closeInterfaces([...ifaces], directImpls));
+    }
+    return mro;
+}
+function closeInterfaces(seeds, directImpls) {
+    const out = [];
+    const seen = new Set();
+    const queue = [...seeds];
+    while (queue.length > 0) {
+        const cur = queue.shift();
+        if (seen.has(cur))
+            continue;
+        seen.add(cur);
+        out.push(cur);
+        for (const next of directImpls.get(cur) ?? []) {
+            if (!seen.has(next))
+                queue.push(next);
+        }
+    }
+    return out;
+}

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

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kotlinBindingScopeFor = kotlinBindingScopeFor;
+exports.kotlinImportOwningScope = kotlinImportOwningScope;
+exports.kotlinReceiverBinding = kotlinReceiverBinding;
+function kotlinBindingScopeFor(decl, innermost, tree) {
+    // Smart-cast narrowed bindings (issue #1758) must stay at the innermost
+    // (Block) scope. Their anchor coincides with the Block's range for
+    // unbraced arm bodies (`is User -> obj.save()`), which would otherwise
+    // trigger scope-extractor auto-hoist into the enclosing function scope
+    // 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;
+    while (current !== undefined && current.kind !== 'Module') {
+        if (current.parent === null)
+            break;
+        current = tree.getScope(current.parent);
+    }
+    return current?.kind === 'Module' ? current.id : null;
+}
+function kotlinImportOwningScope(_imp, _innermost, _tree) {
+    return null;
+}
+function kotlinReceiverBinding(functionScope) {
+    if (functionScope.kind !== 'Function')
+        return null;
+    return functionScope.typeBindings.get('this') ?? functionScope.typeBindings.get('super') ?? null;
+}

package/dist/core/code/engine/core/ingestion/languages/kotlin/spring-aop.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attachKotlinSpringAopMetadata = void 0;
+exports.captureKotlinSpringAopFacts = captureKotlinSpringAopFacts;
+const index_js_1 = require("../../../../../shared/index.js");
+const aop_js_1 = require("../../frameworks/spring/aop.js");
+const ast_helpers_js_1 = require("../../utils/ast-helpers.js");
+const capture_side_channel_js_1 = require("./capture-side-channel.js");
+const package_siblings_js_1 = require("./package-siblings.js");
+const spring_di_js_1 = require("./spring-di.js");
+function scopeId(filePath, node, kind) {
+    return (0, index_js_1.makeScopeId)({
+        filePath,
+        range: (0, ast_helpers_js_1.nodeToCapture)('@spring-aop.owner', node).range,
+        kind,
+    });
+}
+function ownerRange(node) {
+    return (0, ast_helpers_js_1.nodeToCapture)('@spring-aop.owner', node).range;
+}
+/**
+ * Capture Spring AOP syntax from the class node already surfaced by Kotlin's
+ * scope query. The shared layer resolves annotations and rejects non-default
+ * use-site targets after imports and package visibility have finalized.
+ */
+function captureKotlinSpringAopFacts(classNode, filePath) {
+    const facts = [];
+    const classAnnotations = (0, spring_di_js_1.kotlinSpringAnnotationFacts)(classNode);
+    const singletonInstance = classNode.type === 'object_declaration' || classNode.type === 'companion_object';
+    // Kotlin import aliases can give a Spring annotation any local simple name.
+    // Capture annotated owners conservatively, then let the post-import shared
+    // resolver keep only recognized Spring AOP annotations. Objects also retain
+    // an empty owner fact so the shared phase can distinguish their singleton
+    // instance members from true static methods without naming Kotlin.
+    if (classAnnotations.length > 0 || singletonInstance) {
+        facts.push({
+            ownerScopeId: scopeId(filePath, classNode, 'Class'),
+            ownerKind: 'class',
+            ownerFilePath: filePath,
+            ownerRange: ownerRange(classNode),
+            ...(singletonInstance ? { singletonInstance: true } : {}),
+            annotations: classAnnotations,
+        });
+    }
+    const body = classNode.namedChildren.find((child) => child.type === 'class_body');
+    if (body === undefined)
+        return facts;
+    for (const member of body.namedChildren) {
+        if (member.type !== 'function_declaration')
+            continue;
+        const annotations = (0, spring_di_js_1.kotlinSpringAnnotationFacts)(member);
+        if (annotations.length === 0)
+            continue;
+        facts.push({
+            ownerScopeId: scopeId(filePath, member, 'Function'),
+            ownerKind: 'callable',
+            ownerFilePath: filePath,
+            ownerRange: ownerRange(member),
+            ...(singletonInstance ? { singletonInstance: true } : {}),
+            annotations,
+        });
+    }
+    return facts;
+}
+exports.attachKotlinSpringAopMetadata = (0, aop_js_1.createSpringAopMetadataAttacher)({
+    getFacts: capture_side_channel_js_1.getKotlinSpringAopFacts,
+    isPackageVisibilityIncomplete: package_siblings_js_1.isKotlinPackageSiblingVisibilityIncomplete,
+});

package/dist/core/code/engine/core/ingestion/languages/kotlin/spring-bean-metadata.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attachKotlinSpringBeanCandidateMetadata = void 0;
+const bean_candidates_js_1 = require("../../frameworks/spring/bean-candidates.js");
+const capture_side_channel_js_1 = require("./capture-side-channel.js");
+const package_siblings_js_1 = require("./package-siblings.js");
+/** Kotlin wiring for the language-neutral Spring candidate engine. */
+exports.attachKotlinSpringBeanCandidateMetadata = (0, bean_candidates_js_1.createSpringBeanCandidateAttacher)({
+    getClassAnnotationFacts: capture_side_channel_js_1.getKotlinClassAnnotationFacts,
+    isPackageVisibilityIncomplete: package_siblings_js_1.isKotlinPackageSiblingVisibilityIncomplete,
+});