ucn 4.0.2 → 4.1.0

package/languages/go.js

@@ -12,6 +12,7 @@ const {
     parseStructuredParams,
     extractGoDocstring,
     visitNameNodes,
+    sameNode,
 } = require('./utils');
 const { PARSE_OPTIONS, safeParse } = require('./index');
 
@@ -34,11 +35,13 @@ function extractReturnType(node) {
  * Extract Go parameters
  */
 function extractGoParams(paramsNode) {
+    // Distinguish "we have no node" (genuinely unknown) from "node is empty".
+    // Returning '...' for empty parens conflated zero-param functions with
+    // unknown signatures in JSON output (fix #238; the shared
+    // utils.extractParams already had this fix).
     if (!paramsNode) return '...';
     const text = paramsNode.text;
-    let params = text.replace(/^\(|\)$/g, '').trim();
-    if (!params) return '...';
-    return params;
+    return text.replace(/^\(|\)$/g, '').trim();
 }
 
 /**
@@ -49,11 +52,15 @@ function extractReceiver(receiverNode) {
     // receiverNode is a parameter_list: (r *Router)
     // Find the parameter_declaration child
     const param = receiverNode.namedChildren.find(c => c.type === 'parameter_declaration');
-    if (!param) return receiverNode.text.replace(/^\(|\)$/g, '').trim();
+    if (!param) return receiverNode.text.replace(/^\(|\)$/g, '').trim().replace(/\[.*\]$/, '');
     // The type is the last named child (name is first for named receivers)
     const typeNode = param.namedChildren[param.namedChildren.length - 1];
     if (!typeNode) return null;
-    return typeNode.text;
+    // Strip generic type parameters: `(p *Pair[K, V])` receives on the TYPE
+    // Pair — the bracket spelling made fn Pair.First/--class-name/
+    // findMethodsForType all miss (fix #248; Rust/Java already normalize,
+    // and a Go receiver type is a defined type, never a slice/map literal).
+    return typeNode.text.replace(/\[.*\]$/, '');
 }
 
 // --- Single-pass helpers: extracted from find* callbacks ---
@@ -1634,10 +1641,11 @@ function findExportsInCode(code, parser) {
  * @param {string} code - Source code
  * @param {string} name - Symbol name to find
  * @param {object} parser - Tree-sitter parser instance
+ * @param {object} [tree] - Pre-parsed tree (per-operation cache); parsed here when absent
  * @returns {Array<{line: number, column: number, usageType: string}>}
  */
-function findUsagesInCode(code, name, parser) {
-    const tree = parseTree(parser, code);
+function findUsagesInCode(code, name, parser, tree) {
+    tree = tree || parseTree(parser, code);
     const usages = [];
 
     visitNameNodes(tree, code, name, (node) => {
@@ -1662,52 +1670,52 @@ function findUsagesInCode(code, name, parser) {
             }
             // Call: identifier is function in call_expression
             else if (parent.type === 'call_expression' &&
-                     parent.childForFieldName('function') === node) {
+                     sameNode(parent.childForFieldName('function'), node)) {
                 usageType = 'call';
             }
             // Definition: function name
             else if (parent.type === 'function_declaration' &&
-                     parent.childForFieldName('name') === node) {
+                     sameNode(parent.childForFieldName('name'), node)) {
                 usageType = 'definition';
             }
             // Definition: method name
             else if (parent.type === 'method_declaration' &&
-                     parent.childForFieldName('name') === node) {
+                     sameNode(parent.childForFieldName('name'), node)) {
                 usageType = 'definition';
             }
             // Definition: type name
             else if (parent.type === 'type_spec' &&
-                     parent.childForFieldName('name') === node) {
+                     sameNode(parent.childForFieldName('name'), node)) {
                 usageType = 'definition';
             }
             // Definition: variable name in short var declaration
             else if (parent.type === 'short_var_declaration') {
                 const left = parent.childForFieldName('left');
-                if (left && (left === node || left.namedChildren?.some(c => c === node))) {
+                if (left && (sameNode(left, node) || left.namedChildren?.some(c => sameNode(c, node)))) {
                     usageType = 'definition';
                 }
             }
             // Multi-var: x, err := foo() — identifier parent is expression_list
             else if (parent.type === 'expression_list' &&
                      parent.parent?.type === 'short_var_declaration' &&
-                     parent.parent.childForFieldName('left') === parent) {
+                     sameNode(parent.parent.childForFieldName('left'), parent)) {
                 usageType = 'definition';
             }
             // Definition: const/var spec
             else if (parent.type === 'const_spec' || parent.type === 'var_spec') {
                 const nameNode = parent.childForFieldName('name');
-                if (nameNode === node) {
+                if (sameNode(nameNode, node)) {
                     usageType = 'definition';
                 }
             }
             // Definition: parameter name (not the type)
             else if (parent.type === 'parameter_declaration' &&
-                     parent.childForFieldName('name') === node) {
+                     sameNode(parent.childForFieldName('name'), node)) {
                 usageType = 'definition';
             }
             // Composite literal: Type{} — type_identifier is the type of composite_literal
             else if (parent.type === 'composite_literal' &&
-                     parent.childForFieldName('type') === node) {
+                     sameNode(parent.childForFieldName('type'), node)) {
                 usageType = 'call';
             }
             // Method call: selector_expression followed by call (field_identifier case)
@@ -1745,8 +1753,12 @@ function findUsagesInCode(code, name, parser) {
  */
 function getEntryPointKind(symbol) {
     const { name } = symbol;
+    // Test* stays receiver-agnostic — testify suite METHODS (func (s *Suite)
+    // TestFoo) are genuinely harness-invoked.
     if (/^(Test|Benchmark|Example|Fuzz)[A-Z_]/.test(name)) return 'test';
-    if (name === 'main' || name === 'init') return 'main';
+    // Only FREE functions main/init are runtime entries — a method named
+    // main/init on a receiver is an ordinary method (fix #243).
+    if ((name === 'main' || name === 'init') && !symbol.className && !symbol.receiver) return 'main';
     return null;
 }
 

package/languages/index.js

@@ -21,8 +21,18 @@ const STRUCTURAL_TRAITS = {
     exportVisibility: 'keyword',
     hasDynamicImports: true,
     testDirs: [],
+    // Whether the language supports default parameter values in function
+    // signatures (JS/TS/Python: yes). Drives plan --add-param --default:
+    // without them, every call site needs the new argument and the rendered
+    // signature must not use `= value` syntax (Go/Java/Rust).
+    hasDefaultParams: true,
     allMethodsVirtual: false,
     hasArityOverloads: false,
+    // Whether `from pkg import name` can bind a SUBMODULE file as a plain
+    // name (fix #224). Python sets true: graph-build resolves the composed
+    // dotted specifier and records it in moduleResolved, making the receiver
+    // a module receiver at query time. JS from-imports bind values only.
+    submoduleImports: false,
     // Class members are public unless marked otherwise (#name, _name,
     // `private`). An exported class therefore exposes its non-private methods
     // as public API — deadcode treats them as exported (fix #211). Languages
@@ -49,6 +59,8 @@ const NOMINAL_TRAITS = {
     exportVisibility: 'keyword',
     hasDynamicImports: true,
     testDirs: [],
+    // Go/Java/Rust have no default parameter values — see STRUCTURAL_TRAITS.
+    hasDefaultParams: false,
     // Whether ANY instance method call can dynamically dispatch to a subtype
     // override (Java: all instance methods are virtual). Go struct method
     // sets and Rust inherent methods bind statically — only interface/trait
@@ -153,6 +165,11 @@ const LANGUAGES = {
         traits: {
             ...STRUCTURAL_TRAITS,
             selfParam: ['self', 'cls'],
+            // fix #224: `from pkg import name` may bind a SUBMODULE file, not
+            // a symbol — graph-build resolves the composed dotted specifier
+            // and query code treats such receivers as module receivers. JS
+            // from-imports bind values only (`import * as ns` is parser-marked).
+            submoduleImports: true,
             testFileCandidates: (base, ext) => [`test_${base}.py`, `${base}_test.py`],
             testDirs: ['tests'],
         },
@@ -244,10 +261,49 @@ function loadTreeSitter() {
                 { cause: e }
             );
         }
+        _installNodeTypeCache(TreeSitter);
     }
     return TreeSitter;
 }
 
+/**
+ * Make SyntaxNode#type a cheap data-property read.
+ *
+ * The binding generates one node subclass per grammar type id and intends
+ * `nodeSubclass.prototype.type = typeName` to shadow the base getter — but
+ * SyntaxNode.prototype.type is a getter-only accessor, so that plain
+ * assignment silently no-ops and EVERY `.type` read marshals into native
+ * code. Hot walks read `.type` many times per node; on a ~300-file build
+ * this getter alone costs seconds.
+ *
+ * A node's type is immutable and each generated subclass maps to exactly
+ * one grammar type, so the first native read per CLASS plants the string as
+ * a data property on that class's prototype — all later reads on any node
+ * of that type are plain property hits. Nodes using the base class itself
+ * (anonymous tokens, ERROR) keep the native getter.
+ */
+function _installNodeTypeCache(TS) {
+    try {
+        const base = TS?.SyntaxNode?.prototype;
+        const desc = base && Object.getOwnPropertyDescriptor(base, 'type');
+        if (!desc?.get || desc.set) return; // shape changed upstream — leave it alone
+        const nativeGet = desc.get;
+        Object.defineProperty(base, 'type', {
+            configurable: true,
+            get() {
+                const t = nativeGet.call(this);
+                const ctor = this.constructor;
+                if (ctor && ctor !== TS.SyntaxNode && ctor.prototype instanceof TS.SyntaxNode) {
+                    Object.defineProperty(ctor.prototype, 'type', {
+                        value: t, configurable: true
+                    });
+                }
+                return t;
+            }
+        });
+    } catch { /* stock getter keeps working */ }
+}
+
 /**
  * Get or create parser for a language
  * @param {string} language - Language name

package/languages/java.js

@@ -12,6 +12,7 @@ const {
     parseStructuredParams,
     extractJavaDocstring,
     visitNameNodes,
+    sameNode,
 } = require('./utils');
 const { PARSE_OPTIONS, safeParse } = require('./index');
 
@@ -23,10 +24,13 @@ function parseTree(parser, code) {
  * Extract Java parameters
  */
 function extractJavaParams(paramsNode) {
+    // Distinguish "we have no node" (genuinely unknown) from "node is empty".
+    // Returning '...' for empty parens conflated zero-param methods with
+    // unknown signatures in JSON output (fix #241; go/rust got this in #238,
+    // the shared utils.extractParams already had it).
     if (!paramsNode) return '...';
     const text = paramsNode.text;
     let params = text.replace(/^\(|\)$/g, '').trim();
-    if (!params) return '...';
     return params;
 }
 
@@ -585,6 +589,9 @@ function extractEnumConstants(enumNode, codeOrLines) {
                     startLine,
                     endLine,
                     memberType: 'constant',
+                    // JLS: enum constants are implicitly public static final
+                    // (fix #251 — api omitted them for lack of a modifier).
+                    modifiers: ['public', 'static', 'final'],
                     ...(argsNode && { params: argsNode.text.slice(1, -1) })
                 });
             }
@@ -608,6 +615,7 @@ function extractEnumConstants(enumNode, codeOrLines) {
                             constants.push({
                                 name: nameNode.text,
                                 params: extractJavaParams(paramsNode),
+                                paramsStructured: parseStructuredParams(paramsNode, 'java'),
                                 startLine,
                                 endLine,
                                 memberType: modifiers.includes('static') ? 'static' : 'method',
@@ -625,6 +633,10 @@ function extractEnumConstants(enumNode, codeOrLines) {
                             constants.push({
                                 name: nameNode.text,
                                 params: extractJavaParams(paramsNode),
+                                // paramsStructured drives verify's arg-check
+                                // (fix #230 — enum constant args LOW(1) were
+                                // checked against an empty list).
+                                paramsStructured: parseStructuredParams(paramsNode, 'java'),
                                 startLine,
                                 endLine,
                                 memberType: 'constructor',
@@ -681,6 +693,7 @@ function extractClassMembers(classNode, codeOrLines) {
                     memberType = 'abstract';
                 }
 
+                const memberGenerics = extractGenerics(child);
                 members.push({
                     name: nameNode.text,
                     params: extractJavaParams(paramsNode),
@@ -693,7 +706,10 @@ function extractClassMembers(classNode, codeOrLines) {
                     ...(returnType && { returnType }),
                     ...(docstring && { docstring }),
                     ...(annotationsWithArgs.length > 0 && { annotationsWithArgs }),
-                    ...(nameLine !== startLine && { nameLine })
+                    ...(nameLine !== startLine && { nameLine }),
+                    // Method-level type params (fix #229): generic-param receiver
+                    // types inside the method resolve against this declaration.
+                    ...(memberGenerics && { generics: memberGenerics })
                 });
             }
         }
@@ -711,6 +727,11 @@ function extractClassMembers(classNode, codeOrLines) {
         if (child.type === 'field_declaration') {
             const typeNode = child.childForFieldName('type');
             const fieldTypeText = typeNode ? typeNode.text : null;
+            // Visibility travels with the member (fix #251 — public
+            // instance fields were invisible to api/fileExports because
+            // the member had no modifiers for the #240 discipline to read;
+            // the #241 Rust-field twin).
+            const fieldModifiers = extractModifiers(child);
             for (let j = 0; j < child.namedChildCount; j++) {
                 const decl = child.namedChild(j);
                 if (decl.type === 'variable_declarator') {
@@ -722,6 +743,7 @@ function extractClassMembers(classNode, codeOrLines) {
                             startLine,
                             endLine,
                             memberType: 'field',
+                            ...(fieldModifiers.length > 0 && { modifiers: fieldModifiers }),
                             fieldType: fieldTypeText
                         });
                     }
@@ -1144,6 +1166,80 @@ function findCallsInCode(code, parser) {
         }
 
         // Handle constructor calls: new Foo(), new pkg.Bar()
+        // super(x) / this(x) — constructor delegation (fix #238: these
+        // sites were invisible to every command). Resolve to the parent
+        // class's constructor (super) or a same-class overload (this);
+        // Java constructors are indexed under the CLASS name, so the
+        // record carries the target class as its name.
+        if (node.type === 'explicit_constructor_invocation') {
+            let cls = node.parent;
+            while (cls && cls.type !== 'class_declaration' && cls.type !== 'enum_declaration') {
+                cls = cls.parent;
+            }
+            const isSuperCall = node.children.some(c => c.type === 'super');
+            let targetClass = null;
+            if (cls) {
+                if (isSuperCall) {
+                    const sup = cls.childForFieldName('superclass');
+                    targetClass = sup?.namedChild(0)?.text || null;
+                } else {
+                    targetClass = cls.childForFieldName('name')?.text || null;
+                }
+            }
+            if (targetClass) {
+                const genericIdx = targetClass.indexOf('<');
+                if (genericIdx > 0) targetClass = targetClass.substring(0, genericIdx);
+                const dotIdx = targetClass.lastIndexOf('.');
+                if (dotIdx > 0) targetClass = targetClass.substring(dotIdx + 1);
+                const enclosingFunction = getCurrentEnclosingFunction();
+                const ctorArgs = getCallArgs(node);
+                calls.push({
+                    name: targetClass,
+                    line: node.startPosition.row + 1,
+                    isMethod: false,
+                    isConstructor: true,
+                    // 'this' delegation names the ENCLOSING class by
+                    // construction — an intra-class mechanism, never a
+                    // caller edge for the class (jdtls-measured, fix #238).
+                    ctorDelegation: isSuperCall ? 'super' : 'this',
+                    argCount: ctorArgs.argCount,
+                    ...(ctorArgs.argKinds && { argKinds: ctorArgs.argKinds }),
+                    enclosingFunction
+                });
+            }
+            return true;
+        }
+
+        // Enum constants with arguments (RED(1)) invoke the enum's own
+        // constructor (fix #238: the constructor had no call records, so
+        // search --unused / deadcode flagged it dead in every enum).
+        // Argument-less constants still construct — they call the implicit
+        // or 0-arg constructor.
+        if (node.type === 'enum_constant') {
+            let enclosingEnum = node.parent;
+            while (enclosingEnum && enclosingEnum.type !== 'enum_declaration') {
+                enclosingEnum = enclosingEnum.parent;
+            }
+            const enumName = enclosingEnum?.childForFieldName('name')?.text;
+            if (enumName) {
+                const ctorArgs = getCallArgs(node);
+                calls.push({
+                    name: enumName,
+                    line: node.startPosition.row + 1,
+                    isMethod: false,
+                    isConstructor: true,
+                    // Part of the enum's own declaration — keeps the
+                    // constructor alive for deadcode/--unused, but never a
+                    // caller edge for the enum (jdtls-measured, fix #238).
+                    enumConstant: true,
+                    argCount: ctorArgs.argCount,
+                    ...(ctorArgs.argKinds && { argKinds: ctorArgs.argKinds }),
+                    enclosingFunction: getCurrentEnclosingFunction()
+                });
+            }
+            return true;
+        }
+
         if (node.type === 'object_creation_expression') {
             const typeNode = node.childForFieldName('type');
             if (typeNode) {
@@ -1230,6 +1326,26 @@ function findCallsInCode(code, parser) {
             }
         }
 
+        // Try-with-resources declarations are declared-type locals too (fix
+        // #231): `try (Res r = new Res())` types r exactly like `Res r = ...`
+        // — the resource node carries type/name/value fields directly.
+        if (node.type === 'resource' && functionStack.length > 0) {
+            const resTypeNode = node.childForFieldName('type');
+            const resNameNode = node.childForFieldName('name');
+            const resValueNode = node.childForFieldName('value');
+            let typeName = resValueNode?.type === 'object_creation_expression'
+                ? extractTypeName(resValueNode.childForFieldName('type'))
+                : null;
+            if (!typeName && resTypeNode && resTypeNode.text !== 'var') {
+                typeName = extractTypeName(resTypeNode);
+            }
+            if (resNameNode && typeName) {
+                const scopeKey = functionStack[functionStack.length - 1].startLine;
+                const typeMap = scopeTypes.get(scopeKey);
+                if (typeMap) typeMap.set(resNameNode.text, typeName);
+            }
+        }
+
         return true;
     }, {
         onLeave: (node) => {
@@ -1375,10 +1491,11 @@ function findExportsInCode(code, parser) {
  * @param {string} code - Source code
  * @param {string} name - Symbol name to find
  * @param {object} parser - Tree-sitter parser instance
+ * @param {object} [tree] - Pre-parsed tree (per-operation cache); parsed here when absent
  * @returns {Array<{line: number, column: number, usageType: string}>}
  */
-function findUsagesInCode(code, name, parser) {
-    const tree = parseTree(parser, code);
+function findUsagesInCode(code, name, parser, tree) {
+    tree = tree || parseTree(parser, code);
     const usages = [];
 
     visitNameNodes(tree, code, name, (node) => {
@@ -1410,7 +1527,7 @@ function findUsagesInCode(code, name, parser) {
             }
             // Call: method_invocation with name field
             else if (parent.type === 'method_invocation' &&
-                     parent.childForFieldName('name') === node) {
+                     sameNode(parent.childForFieldName('name'), node)) {
                 usageType = 'call';
                 // Track receiver for method invocations (obj.name() → receiver = 'obj')
                 const object = parent.childForFieldName('object');
@@ -1421,50 +1538,50 @@ function findUsagesInCode(code, name, parser) {
             }
             // Definition: method name
             else if (parent.type === 'method_declaration' &&
-                     parent.childForFieldName('name') === node) {
+                     sameNode(parent.childForFieldName('name'), node)) {
                 usageType = 'definition';
             }
             // Definition: class name
             else if (parent.type === 'class_declaration' &&
-                     parent.childForFieldName('name') === node) {
+                     sameNode(parent.childForFieldName('name'), node)) {
                 usageType = 'definition';
             }
             // Definition: interface name
             else if (parent.type === 'interface_declaration' &&
-                     parent.childForFieldName('name') === node) {
+                     sameNode(parent.childForFieldName('name'), node)) {
                 usageType = 'definition';
             }
             // Definition: enum name
             else if (parent.type === 'enum_declaration' &&
-                     parent.childForFieldName('name') === node) {
+                     sameNode(parent.childForFieldName('name'), node)) {
                 usageType = 'definition';
             }
             // Definition: constructor
             else if (parent.type === 'constructor_declaration' &&
-                     parent.childForFieldName('name') === node) {
+                     sameNode(parent.childForFieldName('name'), node)) {
                 usageType = 'definition';
             }
             // Definition: local variable
             else if (parent.type === 'variable_declarator' &&
-                     parent.childForFieldName('name') === node) {
+                     sameNode(parent.childForFieldName('name'), node)) {
                 usageType = 'definition';
             }
             // Definition: parameter (name field only, not the type)
             else if ((parent.type === 'formal_parameter' ||
                      parent.type === 'spread_parameter') &&
-                     parent.childForFieldName('name') === node) {
+                     sameNode(parent.childForFieldName('name'), node)) {
                 usageType = 'definition';
             }
             // Definition: field (declarator name only, not the type)
             else if (parent.type === 'field_declaration' &&
                      node.type === 'identifier' &&
-                     parent.descendantsOfType('variable_declarator').some(d => d.childForFieldName('name') === node)) {
+                     parent.descendantsOfType('variable_declarator').some(d => sameNode(d.childForFieldName('name'), node))) {
                 usageType = 'definition';
             }
             // Object creation: new ClassName()
             else if (parent.type === 'object_creation_expression') {
                 const typeNode = parent.childForFieldName('type');
-                if (typeNode === node || typeNode?.text === name) {
+                if (sameNode(typeNode, node) || typeNode?.text === name) {
                     usageType = 'call';
                 }
             }
@@ -1472,12 +1589,12 @@ function findUsagesInCode(code, name, parser) {
             // (variable or ClassName), referenced, not called. The call belongs
             // to the name field, handled above.
             else if (parent.type === 'method_invocation' &&
-                     parent.childForFieldName('object') === node) {
+                     sameNode(parent.childForFieldName('object'), node)) {
                 usageType = 'reference';
             }
             // Field access: obj.field
             else if (parent.type === 'field_access' &&
-                     parent.childForFieldName('field') === node) {
+                     sameNode(parent.childForFieldName('field'), node)) {
                 usageType = 'reference';
                 // Track receiver for field access (obj.field → receiver = 'obj')
                 const object = parent.childForFieldName('object');