gitnexus 1.6.6-rc.144 → 1.6.6-rc.145

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

@@ -161,7 +161,101 @@ export function emitJavaScopeCaptures(sourceText, _filePath, cachedTree) {
         }
         out.push(grouped);
     }
-    return [...resolveVarTypeBindings(out), ...synthesizeJavaInheritanceReferences(tree.rootNode)];
+    return [
+        ...resolveVarTypeBindings(out),
+        ...synthesizeJavaInheritanceReferences(tree.rootNode),
+        ...synthesizeJavaExplicitConstructorReferences(tree.rootNode),
+    ];
+}
+/**
+ * Synthesize `@reference.call.constructor` captures for explicit constructor
+ * invocations — `super(...)` and `this(...)` (F38 #1928). tree-sitter-java
+ * models these as `explicit_constructor_invocation` nodes, which the scope
+ * query does not match, so the chained-constructor CALLS edges (subclass ctor →
+ * superclass ctor; ctor → sibling overload) were silently dropped.
+ *
+ * The grammar gives no constructor *name* at the call site (the child is a bare
+ * `(super)` / `(this)` token), so the target name is resolved structurally:
+ *   - `this(...)`  → the enclosing type's own simple name (constructor symbols
+ *                    are keyed by the declaring class name).
+ *   - `super(...)` → the enclosing class's superclass simple-name tail (reusing
+ *                    `javaBaseLookupNameNode` so qualified/generic supers reduce
+ *                    to the bare class name, matching the EXTENDS synth). An
+ *                    implicit `Object` super (no `superclass` field) has no
+ *                    in-graph symbol, so it is skipped rather than emitting a
+ *                    dangling reference.
+ * Arity is attached so overloaded constructors disambiguate downstream, mirroring
+ * the call-site arity synthesized for `new X(...)`.
+ */
+function synthesizeJavaExplicitConstructorReferences(root) {
+    const out = [];
+    const stack = [root];
+    while (stack.length > 0) {
+        const node = stack.pop();
+        if (node.type === 'explicit_constructor_invocation') {
+            emitJavaExplicitConstructorRef(out, node);
+        }
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child !== null)
+                stack.push(child);
+        }
+    }
+    return out;
+}
+const TYPE_DECL_NODE_TYPES = new Set([
+    'class_declaration',
+    'enum_declaration',
+    'record_declaration',
+]);
+function emitJavaExplicitConstructorRef(out, node) {
+    const ctor = node.childForFieldName('constructor');
+    if (ctor === null)
+        return;
+    const enclosingType = findEnclosingTypeDeclaration(node);
+    if (enclosingType === null)
+        return;
+    let targetNameNode = null;
+    if (ctor.type === 'this') {
+        targetNameNode = enclosingType.childForFieldName('name');
+    }
+    else if (ctor.type === 'super') {
+        // Only class_declaration carries a `superclass` field; enum/record cannot
+        // declare an explicit superclass, so `super(...)` there has no resolvable
+        // target symbol.
+        const superclass = enclosingType.childForFieldName('superclass');
+        if (superclass === null)
+            return;
+        for (const base of superclass.namedChildren) {
+            if (base === null)
+                continue;
+            const nameNode = javaBaseLookupNameNode(base);
+            if (nameNode !== null) {
+                targetNameNode = nameNode;
+                break;
+            }
+        }
+    }
+    if (targetNameNode === null)
+        return;
+    const argList = node.childForFieldName('arguments');
+    const args = argList === null
+        ? []
+        : argList.namedChildren.filter((c) => c !== null && c.type !== 'block_comment' && c.type !== 'line_comment');
+    out.push({
+        '@reference.call.constructor': nodeToCapture('@reference.call.constructor', node),
+        '@reference.name': nodeToCapture('@reference.name', targetNameNode),
+        '@reference.arity': syntheticCapture('@reference.arity', node, String(args.length)),
+    });
+}
+function findEnclosingTypeDeclaration(node) {
+    let cur = node.parent;
+    while (cur !== null) {
+        if (TYPE_DECL_NODE_TYPES.has(cur.type))
+            return cur;
+        cur = cur.parent;
+    }
+    return null;
 }
 /**
  * Synthesize `@reference.inherits` captures from Java class heritage so the

package/dist/core/ingestion/languages/java/interpret.js

@@ -67,10 +67,14 @@ export function interpretJavaTypeBinding(captures) {
     const typeCap = captures['@type-binding.type'];
     if (nameCap === undefined || typeCap === undefined)
         return null;
-    // Strip qualifier first so that `com.example.BaseModel<T>` becomes
-    // `BaseModel<T>` before stripGeneric — the JVM-erasure fallback pattern
-    // requires an unqualified identifier at the start of the string.
-    const rawType = stripGeneric(stripQualifier(typeCap.text.trim()));
+    // Strip generics BEFORE the qualifier (F41 #1928). Stripping the qualifier
+    // first uses `lastIndexOf('.')`, which for a qualified *type argument*
+    // (`Map<String, com.example.User>`) cuts inside the generic and yields a
+    // corrupted `User>`. Unwrapping generics first reduces the string to a single
+    // (possibly qualified) class name, then the qualifier strip leaves the bare
+    // simple name. `stripGeneric`'s erasure fallback is qualifier-tolerant so a
+    // qualified generic base (`com.example.BaseModel<T>`) still reduces correctly.
+    const rawType = stripQualifier(stripGeneric(typeCap.text.trim()));
     // Skip `var` — tree-sitter-java parses `var` as type_identifier with
     // text "var". When used without a constructor initializer, there's no
     // concrete type to bind.
@@ -120,8 +124,10 @@ function stripGeneric(text) {
     // `BaseModel<T>` → `BaseModel`, `Builder<Self>` → `Builder`.
     // This mirrors JVM type erasure — the raw class name is the resolvable symbol.
     // The pattern matches up to the first `<` to handle nested generics safely
-    // (e.g. `BaseModel<List<String>>` → `BaseModel`).
-    const fallback = text.match(/^([A-Za-z_$][A-Za-z0-9_$]*)<.+>$/s);
+    // (e.g. `BaseModel<List<String>>` → `BaseModel`). The base is allowed to be
+    // qualified (`com.example.BaseModel<T>` → `com.example.BaseModel`) since the
+    // caller strips the qualifier afterwards (F41 #1928).
+    const fallback = text.match(/^((?:[A-Za-z_$][A-Za-z0-9_$]*\.)*[A-Za-z_$][A-Za-z0-9_$]*)<.+>$/s);
     if (fallback !== null)
         return fallback[1].trim();
     return text;

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

@@ -212,8 +212,23 @@ const JAVA_SCOPE_QUERY = `
   type: (generic_type
     (type_identifier) @reference.name)) @reference.call.constructor
 
+;; References — qualified constructor calls: new pkg.Foo(), new a.b.Foo() (F35 #1928)
+;; tree-sitter-java parses \`pkg.Foo\` as a scoped_type_identifier whose final
+;; child is the simple type. Bind that tail as @reference.name (trailing \`.\`
+;; anchor = last child) so resolution targets \`Foo\`, not the raw \`pkg.Foo\` text.
+;; Mirrors the TS/JS new-expression qualified-constructor capture.
 (object_creation_expression
-  type: (scoped_type_identifier) @reference.call.constructor.qualified) @reference.call.constructor
+  type: (scoped_type_identifier
+    (type_identifier) @reference.name .) @reference.call.constructor.qualified) @reference.call.constructor
+
+;; References — qualified + generic constructor calls: new pkg.Box<T>() (F35 #1928)
+;; The base is a generic_type whose first child is a scoped_type_identifier, so
+;; neither the simple-generic nor the plain-scoped arm above matches it. Bind the
+;; scoped tail as @reference.name.
+(object_creation_expression
+  type: (generic_type
+    (scoped_type_identifier
+      (type_identifier) @reference.name .) @reference.call.constructor.qualified)) @reference.call.constructor
 
 ;; References — method references: User::getName, obj::method
 (method_reference

package/dist/core/ingestion/scope-resolution/graph-bridge/ids.js

@@ -48,6 +48,15 @@ function isCallerAnchorLabel(label) {
         label === 'Struct' ||
         label === 'Enum');
 }
+/**
+ * Callables whose same-name overloads occupy distinct graph nodes keyed by
+ * parameter types / shape. Must mirror `isOverloadableCallable` in
+ * `node-lookup.ts` so registration and lookup agree (Constructor included —
+ * #1928 F38).
+ */
+function isOverloadableCallable(label) {
+    return label === 'Function' || label === 'Method' || label === 'Constructor';
+}
 /**
  * Look up a `SymbolDefinition` in the graph node lookup.
  *
@@ -83,7 +92,7 @@ export function resolveDefGraphId(filePath, def, nodeLookup) {
             if (cHit !== undefined)
                 return cHit;
         }
-        if ((def.type === 'Function' || def.type === 'Method') &&
+        if (isOverloadableCallable(def.type) &&
             def.parameterTypes !== undefined &&
             def.parameterTypeClasses !== undefined) {
             const shapeTag = parameterShapeIdTag(def.parameterTypes, def.parameterTypeClasses);
@@ -96,8 +105,11 @@ export function resolveDefGraphId(filePath, def, nodeLookup) {
         }
         // Overload disambiguation: when the def carries parameter types,
         // try the parameter-typed key first so same-name same-arity
-        // overloads route to their distinct graph nodes.
-        if ((def.type === 'Function' || def.type === 'Method') &&
+        // overloads route to their distinct graph nodes. Constructors are
+        // included so a `this(int)`/`super(int)` chain or `new Foo(int)`
+        // resolves to the matching ctor overload instead of first-wins
+        // collapsing onto another `Foo` ctor (a self-loop) — #1928 F38.
+        if (isOverloadableCallable(def.type) &&
             def.parameterTypes !== undefined &&
             def.parameterTypes.length > 0) {
             const pKey = qualifiedKey(filePath, def.type, `${qn}~${def.parameterTypes.join(',')}`);

package/dist/core/ingestion/scope-resolution/graph-bridge/node-lookup.js

@@ -87,9 +87,7 @@ export function buildGraphNodeLookup(graph) {
             // a parameter-types-suffixed key so resolveDefGraphId can find
             // the right overload by matching its def's parameterTypes.
             const pTypes = props.parameterTypes;
-            if (pTypes !== undefined &&
-                pTypes.length > 0 &&
-                (node.label === 'Function' || node.label === 'Method')) {
+            if (pTypes !== undefined && pTypes.length > 0 && isOverloadableCallable(node.label)) {
                 const pKey = qualifiedKey(props.filePath, node.label, `${keyQualified}~${pTypes.join(',')}`);
                 // Each overload is unique — set unconditionally.
                 if (!lookup.has(pKey))
@@ -98,7 +96,7 @@ export function buildGraphNodeLookup(graph) {
             const pClasses = props
                 .parameterTypeClasses;
             const shapeTag = parameterShapeIdTag(pTypes, pClasses);
-            if (shapeTag !== '' && (node.label === 'Function' || node.label === 'Method')) {
+            if (shapeTag !== '' && isOverloadableCallable(node.label)) {
                 const shapeKey = qualifiedKey(props.filePath, node.label, `${keyQualified}${shapeTag}`);
                 if (!lookup.has(shapeKey))
                     lookup.set(shapeKey, node.id);
@@ -136,6 +134,17 @@ export function buildGraphNodeLookup(graph) {
     }
     return lookup;
 }
+/**
+ * Callables whose same-name overloads must route to distinct graph nodes via
+ * the parameter-types / shape key. Constructors belong here too: a class with
+ * `Foo()` and `Foo(int)` mints distinct `#0`/`#1` Constructor nodes, and a
+ * `this(...)`/`super(...)` edge (or any `new Foo(args)`) must reach the right
+ * one. Without the overload key both ctor nodes collapse onto the first-wins
+ * qualified/simple key, turning a `this()` chain into a self-loop (#1928 F38).
+ */
+function isOverloadableCallable(label) {
+    return label === 'Function' || label === 'Method' || label === 'Constructor';
+}
 export function isLinkableLabel(label) {
     return (label === 'Function' ||
         label === 'Method' ||

package/package.json

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