gitnexus 1.6.6-rc.157 → 1.6.6-rc.159

package/dist/core/ingestion/field-extractors/configs/dart.d.ts

@@ -1,8 +1,2 @@
 import type { FieldExtractionConfig } from '../generic.js';
-/**
- * Dart field extraction config.
- *
- * Dart class fields appear as declaration nodes inside class_body.
- * Visibility is convention-based: underscore prefix = private.
- */
 export declare const dartConfig: FieldExtractionConfig;

package/dist/core/ingestion/field-extractors/configs/dart.js

@@ -5,41 +5,68 @@ import { extractSimpleTypeName } from '../../type-extractors/shared.js';
 /**
  * Dart field extraction config.
  *
- * Dart class fields appear as declaration nodes inside class_body.
+ * Dart class fields appear as `declaration` nodes inside `class_body`.
+ * Two shapes carry the field name(s):
+ *   - instance / plain fields → `initialized_identifier_list`
+ *     (`int z = 0;`, `int a = 1, b = 2;`)
+ *   - `static const` / `static final` / `const` fields → `static_final_declaration_list`
+ *     (`static const a = 1;`, `static final String b = 'x', c = 'y';`)
+ * Both shapes may declare SEVERAL fields in one declaration, so name extraction
+ * is multi-name (`extractNames`). The structure query (`DART_QUERIES`) emits one
+ * `@definition.property` per name for both shapes; this config enriches each.
+ *
  * Visibility is convention-based: underscore prefix = private.
  */
+/** All field names declared by a `declaration` node, across both Dart shapes. */
+function extractDartFieldNames(node) {
+    const names = [];
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (!child)
+            continue;
+        // instance / plain fields: initialized_identifier_list > initialized_identifier > identifier
+        if (child.type === 'initialized_identifier_list') {
+            for (let j = 0; j < child.namedChildCount; j++) {
+                const init = child.namedChild(j);
+                if (init?.type === 'initialized_identifier') {
+                    const ident = init.firstNamedChild;
+                    if (ident?.type === 'identifier')
+                        names.push(ident.text);
+                }
+            }
+        }
+        // static const / final fields: static_final_declaration_list > static_final_declaration > identifier
+        if (child.type === 'static_final_declaration_list') {
+            for (let j = 0; j < child.namedChildCount; j++) {
+                const decl = child.namedChild(j);
+                if (decl?.type === 'static_final_declaration') {
+                    const ident = decl.firstNamedChild;
+                    if (ident?.type === 'identifier')
+                        names.push(ident.text);
+                }
+            }
+        }
+    }
+    return names;
+}
 export const dartConfig = {
     language: SupportedLanguages.Dart,
     typeDeclarationNodes: ['class_definition'],
     fieldNodeTypes: ['declaration'],
     bodyNodeTypes: ['class_body'],
     defaultVisibility: 'public',
+    // One AST `declaration` node may declare several fields (`int a, b;`,
+    // `static final String b = 'x', c = 'y';`), so use the multi-name path.
     extractName(node) {
-        // declaration > initialized_identifier_list > initialized_identifier > identifier
-        for (let i = 0; i < node.namedChildCount; i++) {
-            const child = node.namedChild(i);
-            if (child?.type === 'initialized_identifier_list') {
-                for (let j = 0; j < child.namedChildCount; j++) {
-                    const init = child.namedChild(j);
-                    if (init?.type === 'initialized_identifier') {
-                        const ident = init.firstNamedChild;
-                        if (ident?.type === 'identifier')
-                            return ident.text;
-                    }
-                }
-            }
-            if (child?.type === 'initialized_identifier') {
-                const ident = child.firstNamedChild;
-                if (ident?.type === 'identifier')
-                    return ident.text;
-            }
-        }
-        // fallback: look for direct identifier
-        const name = node.childForFieldName('name');
-        return name?.text;
+        return extractDartFieldNames(node)[0];
+    },
+    extractNames(node) {
+        return extractDartFieldNames(node);
     },
     extractType(node) {
-        // declaration > type_identifier (first named child usually)
+        // declaration > type_identifier (the type annotation, present for both the
+        // instance-field shape and `static final String b = …`). `static const a = 1;`
+        // has no annotation → undefined (untyped).
         for (let i = 0; i < node.namedChildCount; i++) {
             const child = node.namedChild(i);
             if (child && (child.type === 'type_identifier' || child.type === 'function_type')) {
@@ -48,28 +75,22 @@ export const dartConfig = {
         }
         return undefined;
     },
+    // Per-name: Dart convention is underscore-prefixed = private. A single
+    // declaration can mix visibilities (`static const _p = 1, q = 2;`), so the
+    // decision is keyed on the individual field name.
+    extractVisibilityForName(_node, name) {
+        return name.startsWith('_') ? 'private' : 'public';
+    },
     extractVisibility(node) {
-        // Dart uses _ prefix for private
-        // Walk to find the identifier name
-        for (let i = 0; i < node.namedChildCount; i++) {
-            const child = node.namedChild(i);
-            if (child?.type === 'initialized_identifier_list') {
-                for (let j = 0; j < child.namedChildCount; j++) {
-                    const init = child.namedChild(j);
-                    if (init?.type === 'initialized_identifier') {
-                        const ident = init.firstNamedChild;
-                        if (ident?.text?.startsWith('_'))
-                            return 'private';
-                    }
-                }
-            }
-        }
-        return 'public';
+        const first = extractDartFieldNames(node)[0];
+        return first?.startsWith('_') ? 'private' : 'public';
     },
     isStatic(node) {
         return hasKeyword(node, 'static');
     },
     isReadonly(node) {
+        // `final` / `const` (both `final_builtin`/`const_builtin` nodes whose text
+        // is `final`/`const`) are read-only.
         return hasKeyword(node, 'final') || hasKeyword(node, 'const');
     },
 };

package/dist/core/ingestion/field-extractors/configs/jvm.js

@@ -60,12 +60,49 @@ export const javaConfig = {
 // Kotlin
 // ---------------------------------------------------------------------------
 const KOTLIN_VIS = new Set(['public', 'private', 'protected', 'internal']);
+/** A property_declaration is a companion-object member when its nearest
+ *  class-body ancestor is the body of a companion_object (F52, issue #1919).
+ *  Companion members are addressed statically through the enclosing class
+ *  (`C.TAG`), so they are marked static. */
+function isInsideKotlinCompanion(node) {
+    for (let cur = node.parent; cur !== null; cur = cur.parent) {
+        if (cur.type === 'class_body')
+            return cur.parent?.type === 'companion_object';
+        if (cur.type === 'companion_object')
+            return true;
+    }
+    return false;
+}
 export const kotlinConfig = {
     language: SupportedLanguages.Kotlin,
-    typeDeclarationNodes: ['class_declaration', 'object_declaration'],
+    // F52: include companion_object so a companion property's innermost
+    // class-container owner (findEnclosingClassNode returns the companion_object)
+    // is recognized as a type declaration and its nested class_body is walked.
+    // The structure query already creates the Property node and owns it on the
+    // ENCLOSING class for anonymous companions / on the named companion Class —
+    // this entry only drives field-metadata enrichment, so it does NOT change
+    // ownership or emit a second node (no double-count).
+    typeDeclarationNodes: ['class_declaration', 'object_declaration', 'companion_object'],
     fieldNodeTypes: ['property_declaration'],
     bodyNodeTypes: ['class_body'],
     defaultVisibility: 'public',
+    // F52: an anonymous `companion object { ... }` has no name child, so the
+    // generic factory's `childForFieldName('name')` owner lookup is empty and
+    // `extract()` would bail before walking the body. Supply a stable owner
+    // name (the named companion's identifier, else "Companion") so the body IS
+    // walked; the resulting FieldInfo map is keyed by field NAME only, so the
+    // owner name does not affect which Property node gets enriched.
+    extractOwnerName(node) {
+        const typeIdentifierText = node.namedChildren.find((c) => c.type === 'type_identifier')?.text;
+        if (node.type === 'companion_object') {
+            // Anonymous companions have no type_identifier — fall back to "Companion".
+            return typeIdentifierText ?? 'Companion';
+        }
+        const name = node.childForFieldName('name');
+        if (name)
+            return name.text;
+        return typeIdentifierText;
+    },
     extractName(node) {
         // property_declaration > variable_declaration > simple_identifier
         for (let i = 0; i < node.namedChildCount; i++) {
@@ -107,9 +144,11 @@ export const kotlinConfig = {
     extractVisibility(node) {
         return findVisibility(node, KOTLIN_VIS, 'public', 'modifiers');
     },
-    isStatic(_node) {
-        // Kotlin doesn't have static; companion object members are handled separately
-        return false;
+    isStatic(node) {
+        // Kotlin has no `static`, but companion-object members are accessed
+        // statically through the enclosing class (`C.TAG`) — mark them static
+        // so the field metadata reflects that (F52).
+        return isInsideKotlinCompanion(node);
     },
     isReadonly(node) {
         // 'val' = readonly, 'var' = mutable

package/dist/core/ingestion/field-extractors/configs/swift.d.ts

@@ -2,7 +2,18 @@ import type { FieldExtractionConfig } from '../generic.js';
 /**
  * Swift field extraction config.
  *
- * Handles property_declaration inside class_body / protocol_body.
+ * Handles property_declaration inside class_body / protocol_body and
+ * protocol_property_declaration inside protocol_body (F75 — protocol property
+ * requirements like "var title: String { get }").
+ *
  * tree-sitter-swift uses property_declaration for stored/computed properties.
+ * A protocol property requirement parses to its own node type,
+ * protocol_property_declaration, whose name lives in a "name:" pattern field
+ * (pattern > value_binding_pattern + simple_identifier(bound_identifier)), its
+ * type in a sibling type_annotation, and its "{ get }" / "{ get set }" in a
+ * protocol_property_requirements child. Note: Swift reuses the "name:" field
+ * across many positions (func name, every parameter label, parameter/return
+ * type), so the name is synthesized from the simple_identifier inside the
+ * pattern rather than read blindly off "name:".
  */
 export declare const swiftConfig: FieldExtractionConfig;

package/dist/core/ingestion/field-extractors/configs/swift.js

@@ -1,6 +1,6 @@
 // gitnexus/src/core/ingestion/field-extractors/configs/swift.ts
 import { SupportedLanguages } from '../../../../_shared/index.js';
-import { hasKeyword, findVisibility } from './helpers.js';
+import { hasKeyword, hasModifier, findVisibility } from './helpers.js';
 import { extractSimpleTypeName } from '../../type-extractors/shared.js';
 const SWIFT_VIS = new Set([
     'public',
@@ -12,17 +12,32 @@ const SWIFT_VIS = new Set([
 /**
  * Swift field extraction config.
  *
- * Handles property_declaration inside class_body / protocol_body.
+ * Handles property_declaration inside class_body / protocol_body and
+ * protocol_property_declaration inside protocol_body (F75 — protocol property
+ * requirements like "var title: String { get }").
+ *
  * tree-sitter-swift uses property_declaration for stored/computed properties.
+ * A protocol property requirement parses to its own node type,
+ * protocol_property_declaration, whose name lives in a "name:" pattern field
+ * (pattern > value_binding_pattern + simple_identifier(bound_identifier)), its
+ * type in a sibling type_annotation, and its "{ get }" / "{ get set }" in a
+ * protocol_property_requirements child. Note: Swift reuses the "name:" field
+ * across many positions (func name, every parameter label, parameter/return
+ * type), so the name is synthesized from the simple_identifier inside the
+ * pattern rather than read blindly off "name:".
  */
 export const swiftConfig = {
     language: SupportedLanguages.Swift,
     typeDeclarationNodes: ['class_declaration', 'protocol_declaration'],
-    fieldNodeTypes: ['property_declaration'],
+    fieldNodeTypes: ['property_declaration', 'protocol_property_declaration'],
     bodyNodeTypes: ['class_body', 'protocol_body'],
     defaultVisibility: 'internal',
     extractName(node) {
-        // property_declaration > pattern > simple_identifier
+        // property_declaration > pattern > simple_identifier, and
+        // protocol_property_declaration > name: (pattern ... simple_identifier).
+        // For protocol_property_declaration the pattern wraps a leading
+        // value_binding_pattern ("var") plus the simple_identifier — the loop
+        // below skips the binding keyword and returns the identifier.
         for (let i = 0; i < node.namedChildCount; i++) {
             const child = node.namedChild(i);
             if (child?.type === 'pattern') {
@@ -56,7 +71,17 @@ export const swiftConfig = {
         return findVisibility(node, SWIFT_VIS, 'internal', 'modifiers');
     },
     isStatic(node) {
-        return hasKeyword(node, 'static') || hasKeyword(node, 'class');
+        // `static`/`class` (type-level) modifiers live inside a `modifiers`
+        // wrapper for both property_declaration and protocol_property_declaration
+        // (e.g. `static var shared: P { get }`), so check the wrapper too.
+        // `hasKeyword` compares each direct child by `.text` equality: it matches a
+        // single-modifier wrapper (`modifiers.text === 'static'`) but fails for a
+        // multi-modifier wrapper (`private static` → `modifiers.text === 'private static'`),
+        // which `hasModifier` handles by descending into the wrapper's children.
+        return (hasKeyword(node, 'static') ||
+            hasKeyword(node, 'class') ||
+            hasModifier(node, 'modifiers', 'static') ||
+            hasModifier(node, 'modifiers', 'class'));
     },
     isReadonly(node) {
         // 'let' = constant/readonly, 'var' = variable

package/dist/core/ingestion/languages/c/import-decomposer.d.ts

@@ -4,5 +4,14 @@ import { type SyntaxNode } from '../../utils/ast-helpers.js';
  * Decompose a `preproc_include` node into a CaptureMatch with structured
  * import captures. C #include maps to a wildcard import (all symbols
  * from the header are visible).
+ *
+ * Only literal include paths are emitted as import sources:
+ *   #include <stdio.h>   → system_lib_string
+ *   #include "local.h"   → string_literal
+ * A computed include like `#include HEADER_MACRO` carries an `identifier`
+ * path node (the macro name, not a header path). Emitting it as an import
+ * source produces a garbage literal edge, so we skip it entirely — matching
+ * the convention in interpretCImport, which drops imports with no resolvable
+ * source (issue #1919 F5).
  */
 export declare function splitCInclude(node: SyntaxNode): CaptureMatch | null;

package/dist/core/ingestion/languages/c/import-decomposer.js

@@ -3,10 +3,20 @@ import { nodeToCapture, syntheticCapture } from '../../utils/ast-helpers.js';
  * Decompose a `preproc_include` node into a CaptureMatch with structured
  * import captures. C #include maps to a wildcard import (all symbols
  * from the header are visible).
+ *
+ * Only literal include paths are emitted as import sources:
+ *   #include <stdio.h>   → system_lib_string
+ *   #include "local.h"   → string_literal
+ * A computed include like `#include HEADER_MACRO` carries an `identifier`
+ * path node (the macro name, not a header path). Emitting it as an import
+ * source produces a garbage literal edge, so we skip it entirely — matching
+ * the convention in interpretCImport, which drops imports with no resolvable
+ * source (issue #1919 F5).
  */
 export function splitCInclude(node) {
     // node.type === 'preproc_include'
     // path field: (string_literal (string_content)) | (system_lib_string)
+    //             | (identifier)  ← computed macro include, NOT a header path
     const pathNode = node.childForFieldName?.('path') ?? null;
     if (pathNode === null) {
         // Fallback: scan children
@@ -23,6 +33,11 @@ export function splitCInclude(node) {
     return buildIncludeCapture(node, pathNode);
 }
 function buildIncludeCapture(node, pathNode) {
+    // Skip computed includes (`#include MACRO`) — the path is an `identifier`,
+    // not a literal header path. Emitting it would create a garbage import.
+    if (pathNode.type !== 'string_literal' && pathNode.type !== 'system_lib_string') {
+        return null;
+    }
     let raw;
     if (pathNode.type === 'string_literal') {
         // string_literal has children: `"`, string_content, `"`

package/dist/core/ingestion/languages/cpp/import-decomposer.d.ts

@@ -4,6 +4,13 @@ import { type SyntaxNode } from '../../utils/ast-helpers.js';
  * Decompose a `preproc_include` node into a CaptureMatch with structured
  * import captures. C++ #include maps to a wildcard import (all symbols
  * from the header are visible). Identical to C's splitCInclude.
+ *
+ * Only literal include paths are emitted as import sources:
+ *   #include <map>      → system_lib_string
+ *   #include "User.h"   → string_literal
+ * A computed include like `#include HEADER_MACRO` carries an `identifier`
+ * path node (the macro name, not a header path); we skip it so it never
+ * becomes a garbage literal import source (issue #1919 F5).
  */
 export declare function splitCppInclude(node: SyntaxNode): CaptureMatch | null;
 /**

package/dist/core/ingestion/languages/cpp/import-decomposer.js

@@ -3,6 +3,13 @@ import { nodeToCapture, syntheticCapture } from '../../utils/ast-helpers.js';
  * Decompose a `preproc_include` node into a CaptureMatch with structured
  * import captures. C++ #include maps to a wildcard import (all symbols
  * from the header are visible). Identical to C's splitCInclude.
+ *
+ * Only literal include paths are emitted as import sources:
+ *   #include <map>      → system_lib_string
+ *   #include "User.h"   → string_literal
+ * A computed include like `#include HEADER_MACRO` carries an `identifier`
+ * path node (the macro name, not a header path); we skip it so it never
+ * becomes a garbage literal import source (issue #1919 F5).
  */
 export function splitCppInclude(node) {
     const pathNode = node.childForFieldName?.('path') ?? null;
@@ -20,6 +27,11 @@ export function splitCppInclude(node) {
     return buildIncludeCapture(node, pathNode);
 }
 function buildIncludeCapture(node, pathNode) {
+    // Skip computed includes (`#include MACRO`) — the path is an `identifier`,
+    // not a literal header path. Emitting it would create a garbage import.
+    if (pathNode.type !== 'string_literal' && pathNode.type !== 'system_lib_string') {
+        return null;
+    }
     let raw;
     if (pathNode.type === 'string_literal') {
         const content = pathNode.namedChildren.find((c) => c.type === 'string_content');

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

@@ -37,6 +37,46 @@ const DART_SCOPE_QUERY = `
 (extension_declaration name: (identifier) @declaration.name) @declaration.class
 (enum_declaration name: (identifier) @declaration.name) @declaration.enum
 
+; ── Declarations — type aliases (old-style + new-style function typedefs) ────
+; Both forms parse as type_alias; the name position differs, and a generic
+; <T> parameter list intervenes for the generic variants. Per #1919 review CF2,
+; a generic type_parameters node sits between the name and the next anchor, so
+; the non-generic adjacency patterns silently drop the generic forms. Four
+; standalone patterns (NOT one alternation — the tree-sitter 0.21 hazard drops
+; sibling branches) keep the name capture unambiguous and single-match per form:
+;   non-generic old-style  typedef int Cmp(int a, int b);
+;       children: return-type, NAME, formal_parameter_list
+;   generic old-style      typedef int Cmp<T>(T a, T b);          (CF2)
+;       children: return-type, NAME, type_parameters, formal_parameter_list
+;   non-generic new-style  typedef Pred = bool Function(int);
+;       children: NAME, "=", function_type
+;   generic new-style      typedef Mapper<T> = T Function(T);
+;       children: NAME, type_parameters, "=", function_type
+; The alias name is the type_identifier immediately before the param list (old)
+; or before "=" (new); for the generic forms it is the one immediately before
+; the intervening type_parameters. Mirrors Kotlin's @declaration.type_alias
+; rule; the generic scope-extractor maps "type_alias" → TypeAlias.
+(type_alias
+  (type_identifier) @declaration.name
+  .
+  (formal_parameter_list)) @declaration.type_alias
+(type_alias
+  (type_identifier) @declaration.name
+  .
+  (type_parameters)
+  .
+  (formal_parameter_list)) @declaration.type_alias
+(type_alias
+  (type_identifier) @declaration.name
+  .
+  "=") @declaration.type_alias
+(type_alias
+  (type_identifier) @declaration.name
+  .
+  (type_parameters)
+  .
+  "=") @declaration.type_alias
+
 ; ── Declarations — top-level functions (parent is program, not method) ───────
 (program
   (function_signature

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

@@ -28,6 +28,7 @@ export function emitKotlinScopeCaptures(sourceText, filePath, cachedTree) {
     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
@@ -73,6 +74,40 @@ 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;
@@ -207,6 +242,76 @@ function synthesizeKotlinInheritanceReferences(rootNode) {
     }
     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`)

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/method-extractors/configs/jvm.js

@@ -166,9 +166,31 @@ function kotlinParameterHasDefaultValue(param) {
     }
     return false;
 }
+/**
+ * Member name for a Kotlin method node. A `secondary_constructor`
+ * (`constructor(...) { }`) has no name child — its only identity token is
+ * the anonymous `constructor` keyword — so it is named "constructor" (F48,
+ * issue #1919), matching the @name the KOTLIN_QUERIES structure rule captures
+ * off that keyword so method-extractor enrichment keys (`name:line`) align.
+ * Multiple secondary constructors collide on this name but are disambiguated
+ * downstream by the `#<arity>` ID suffix the worker appends to Constructors.
+ */
+function extractKotlinMethodName(node) {
+    if (node.type === 'secondary_constructor')
+        return 'constructor';
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type === 'simple_identifier')
+            return child.text;
+    }
+    return undefined;
+}
 function extractKotlinParameters(node) {
     const params = [];
-    // Kotlin: function_declaration > function_value_parameters > parameter
+    // Kotlin: function_declaration / secondary_constructor >
+    // function_value_parameters > parameter. Both node types nest the
+    // parameter list the same way, so the same walk extracts a secondary
+    // constructor's parameters (F48).
     for (let i = 0; i < node.namedChildCount; i++) {
         const child = node.namedChild(i);
         if (child && child.type === 'function_value_parameters') {
@@ -248,17 +270,10 @@ function extractKotlinReturnType(node) {
 export const kotlinMethodConfig = {
     language: SupportedLanguages.Kotlin,
     typeDeclarationNodes: ['class_declaration', 'object_declaration', 'companion_object'],
-    methodNodeTypes: ['function_declaration'],
+    methodNodeTypes: ['function_declaration', 'secondary_constructor'],
     bodyNodeTypes: ['class_body'],
     staticOwnerTypes: new Set(['companion_object', 'object_declaration']),
-    extractName(node) {
-        for (let i = 0; i < node.namedChildCount; i++) {
-            const child = node.namedChild(i);
-            if (child?.type === 'simple_identifier')
-                return child.text;
-        }
-        return undefined;
-    },
+    extractName: extractKotlinMethodName,
     extractReturnType: extractKotlinReturnType,
     extractParameters: extractKotlinParameters,
     extractVisibility(node) {