ucn 3.8.26 → 4.0.1

package/languages/java.js

@@ -10,7 +10,8 @@ const {
     traverseTreeCached,
     nodeToLocation,
     parseStructuredParams,
-    extractJavaDocstring
+    extractJavaDocstring,
+    visitNameNodes,
 } = require('./utils');
 const { PARSE_OPTIONS, safeParse } = require('./index');
 
@@ -704,6 +705,29 @@ function extractClassMembers(classNode, codeOrLines) {
         // (one for class, one for constructor), forcing users to disambiguate.
         // Constructor signature info (params, line) remains accessible by reading
         // the class body when needed (e.g. via verify's AST walk).
+
+        // Field declarations: declared types drive receiver disambiguation
+        // (fix #202) — Rust/Go already emit field members with fieldType.
+        if (child.type === 'field_declaration') {
+            const typeNode = child.childForFieldName('type');
+            const fieldTypeText = typeNode ? typeNode.text : null;
+            for (let j = 0; j < child.namedChildCount; j++) {
+                const decl = child.namedChild(j);
+                if (decl.type === 'variable_declarator') {
+                    const nameNode = decl.childForFieldName('name');
+                    if (nameNode && fieldTypeText) {
+                        const { startLine, endLine } = nodeToLocation(child, code);
+                        members.push({
+                            name: nameNode.text,
+                            startLine,
+                            endLine,
+                            memberType: 'field',
+                            fieldType: fieldTypeText
+                        });
+                    }
+                }
+            }
+        }
     }
 
     return members;
@@ -899,6 +923,135 @@ function findCallsInCode(code, parser) {
         return undefined;
     };
 
+    // Variable receiving this call's result (fix #207 return-type flow):
+    // `var x = find();` / `x = find();` → 'x'. Declared-type locals are
+    // already typed directly above — this covers `var` and reassignment,
+    // letting findCallers type x from the producer's declared return type.
+    const assignmentTargetOf = (callNode) => {
+        const p = callNode.parent;
+        if (p?.type === 'variable_declarator') {
+            const value = p.childForFieldName('value');
+            const nameNode = p.childForFieldName('name');
+            if (value && value.id === callNode.id && nameNode?.type === 'identifier') return nameNode.text;
+        }
+        if (p?.type === 'assignment_expression') {
+            const right = p.childForFieldName('right');
+            const left = p.childForFieldName('left');
+            if (right && right.id === callNode.id && left?.type === 'identifier') return left.text;
+        }
+        return undefined;
+    };
+
+    // All names declared anywhere in a function body (locals, for/catch/lambda
+    // params). Guard for fix #202: a bare identifier receiver is only treated
+    // as an implicit-this field when NO local of that name is declared —
+    // mistyping a shadowed local could wrongly exclude a true caller.
+    const scopeDeclared = new Map();
+    const collectDeclaredNames = (fnNode) => {
+        const declared = new Set();
+        const walk = (n) => {
+            for (let i = 0; i < n.namedChildCount; i++) {
+                const c = n.namedChild(i);
+                if (c.type === 'variable_declarator' ||
+                    c.type === 'enhanced_for_statement' ||
+                    c.type === 'catch_formal_parameter') {
+                    const nn = c.childForFieldName('name');
+                    if (nn) declared.add(nn.text);
+                } else if (c.type === 'lambda_expression') {
+                    const params = c.childForFieldName('parameters');
+                    if (params?.type === 'identifier') declared.add(params.text);
+                    else if (params) {
+                        for (let j = 0; j < params.namedChildCount; j++) {
+                            const pc = params.namedChild(j);
+                            if (pc.type === 'identifier') declared.add(pc.text);
+                            else {
+                                const pn = pc.childForFieldName('name');
+                                if (pn) declared.add(pn.text);
+                            }
+                        }
+                    }
+                }
+                walk(c);
+            }
+        };
+        walk(fnNode);
+        return declared;
+    };
+    const isDeclaredLocal = (varName) => {
+        for (let i = functionStack.length - 1; i >= 0; i--) {
+            const declared = scopeDeclared.get(functionStack[i].startLine);
+            if (declared?.has(varName)) return true;
+        }
+        return false;
+    };
+
+    // Nearest enclosing class/interface/enum/record name (for implicit-this fields)
+    const findEnclosingClassName = (n) => {
+        for (let p = n.parent; p; p = p.parent) {
+            if (p.type === 'class_declaration' || p.type === 'interface_declaration' ||
+                p.type === 'enum_declaration' || p.type === 'record_declaration') {
+                return p.childForFieldName('name')?.text;
+            }
+        }
+        return undefined;
+    };
+
+    // Call-site argument shape: count + per-arg static kind. Kinds feed the
+    // overload discipline in findCallers (Java is the only supported language
+    // with arity/type overloading): literal kinds can prove a call binds a
+    // DIFFERENT same-class overload than the pinned one. Unknown args are
+    // 'expr' — never evidence.
+    const bareTypeName = (text) => {
+        let t = text;
+        const g = t.indexOf('<');
+        if (g > 0) t = t.substring(0, g);
+        const d = t.lastIndexOf('.');
+        if (d >= 0) t = t.substring(d + 1);
+        return t.trim();
+    };
+    const argKindOf = (arg) => {
+        switch (arg.type) {
+            case 'string_literal': return 'string';
+            case 'character_literal': return 'char';
+            case 'decimal_integer_literal':
+            case 'hex_integer_literal':
+            case 'octal_integer_literal':
+            case 'binary_integer_literal':
+                return /[lL]$/.test(arg.text) ? 'long' : 'int';
+            case 'decimal_floating_point_literal':
+            case 'hex_floating_point_literal':
+                return /[fF]$/.test(arg.text) ? 'float' : 'double';
+            case 'true':
+            case 'false': return 'boolean';
+            case 'null_literal': return 'null';
+            case 'object_creation_expression': {
+                const tn = arg.childForFieldName('type');
+                return tn ? `new:${bareTypeName(tn.text)}` : 'expr';
+            }
+            case 'cast_expression': {
+                const tn = arg.childForFieldName('type');
+                return tn ? `cast:${bareTypeName(tn.text)}` : 'expr';
+            }
+            case 'lambda_expression':
+            case 'method_reference': return 'lambda';
+            case 'unary_expression':
+                // -1, -2.5 — numeric literal kinds survive negation
+                return arg.namedChildCount === 1 ? argKindOf(arg.namedChild(0)) : 'expr';
+            default: return 'expr';
+        }
+    };
+    const getCallArgs = (callNode) => {
+        const argsNode = callNode.childForFieldName('arguments');
+        if (!argsNode) return { argCount: 0, argKinds: null };
+        const kinds = [];
+        for (let i = 0; i < argsNode.namedChildCount; i++) {
+            const arg = argsNode.namedChild(i);
+            if (arg.type === 'comment') continue;
+            kinds.push(argKindOf(arg));
+        }
+        return { argCount: kinds.length, argKinds: kinds.some(k => k !== 'expr') ? kinds : null };
+    };
+
     traverseTree(tree.rootNode, (node) => {
         // Track function entry
         if (isFunctionNode(node)) {
@@ -909,6 +1062,7 @@ function findCallsInCode(code, parser) {
             };
             functionStack.push(entry);
             scopeTypes.set(entry.startLine, buildScopeTypeMap(node));
+            scopeDeclared.set(entry.startLine, collectDeclaredNames(node));
         }
 
         // Handle method invocations: foo(), obj.foo(), this.foo()
@@ -920,13 +1074,68 @@ function findCallsInCode(code, parser) {
                 const enclosingFunction = getCurrentEnclosingFunction();
                 const receiver = (objNode?.type === 'identifier' || objNode?.type === 'this') ? objNode.text : undefined;
                 const receiverType = (receiver && receiver !== 'this') ? getReceiverType(receiver) : undefined;
+                // fix #202: one-hop declared-field receivers —
+                // this.service.execute(), svc.client.run(), and bare
+                // service.execute() where service is a class field (only when
+                // no same-named local is declared anywhere in the method).
+                let receiverRoot, receiverFieldName, receiverRootType;
+                if (objNode && !receiverType) {
+                    if (objNode.type === 'field_access') {
+                        const rootNode = objNode.childForFieldName('object');
+                        const fldNode = objNode.childForFieldName('field');
+                        if (fldNode?.type === 'identifier' && rootNode) {
+                            if (rootNode.type === 'this') {
+                                receiverRoot = 'this';
+                                receiverFieldName = fldNode.text;
+                                receiverRootType = findEnclosingClassName(node);
+                            } else if (rootNode.type === 'identifier') {
+                                const rootType = getReceiverType(rootNode.text);
+                                if (rootType) {
+                                    receiverRoot = rootNode.text;
+                                    receiverFieldName = fldNode.text;
+                                    receiverRootType = rootType;
+                                }
+                            }
+                        }
+                    } else if (objNode.type === 'identifier' && receiver &&
+                        !isDeclaredLocal(receiver)) {
+                        // Implicit-this field (or a class name — the field-type
+                        // hop in findCallers simply finds no field and no-ops).
+                        receiverRoot = 'this';
+                        receiverFieldName = receiver;
+                        receiverRootType = findEnclosingClassName(node);
+                    }
+                }
+                // Chained receiver (fix #220): the receiver IS a call —
+                // getConfig().validate() — record the producer so findCallers
+                // can type it from the declared return annotation.
+                let receiverCall, receiverCallIsMethod;
+                if (!receiver && !receiverFieldName && objNode?.type === 'method_invocation') {
+                    const prodName = objNode.childForFieldName('name');
+                    if (prodName) {
+                        receiverCall = prodName.text;
+                        if (objNode.childForFieldName('object')) receiverCallIsMethod = true;
+                    }
+                }
                 const firstArg = getFirstStringArg(node);
+                const callArgs = getCallArgs(node);
+                const assignedTo = assignmentTargetOf(node);
                 calls.push({
                     name: nameNode.text,
-                    line: node.startPosition.row + 1,
+                    // Multi-line chains (builder.x()\n.y()) must report each
+                    // method's OWN name line, not the chain-start line — the
+                    // account's ground set is keyed by the name's line
+                    line: nameNode.startPosition.row + 1,
                     isMethod: !!objNode,
                     receiver,
                     ...(receiverType && { receiverType }),
+                    ...(receiverFieldName && { receiverRoot, receiverField: receiverFieldName }),
+                    ...(receiverFieldName && receiverRootType && { receiverRootType }),
+                    ...(receiverCall && { receiverCall }),
+                    ...(receiverCallIsMethod && { receiverCallIsMethod: true }),
+                    argCount: callArgs.argCount,
+                    ...(callArgs.argKinds && { argKinds: callArgs.argKinds }),
+                    ...(assignedTo && { assignedTo }),
                     enclosingFunction,
                     ...(firstArg && { firstStringArg: firstArg.value, firstStringArgInterp: firstArg.interp })
                 });
@@ -944,18 +1153,27 @@ function findCallsInCode(code, parser) {
                 if (genericIdx > 0) {
                     typeName = typeName.substring(0, genericIdx);
                 }
-                // Handle qualified names like pkg.Class
+                // Handle qualified names like pkg.Class — keep the qualifier
+                // as receiver (fix #206): a qualified type must not resolve to
+                // a same-file binding of an unrelated same-name symbol.
+                let typeQualifier = null;
                 const dotIdx = typeName.lastIndexOf('.');
                 if (dotIdx > 0) {
+                    const qualParts = typeName.substring(0, dotIdx).split('.');
+                    typeQualifier = qualParts[qualParts.length - 1] || null;
                     typeName = typeName.substring(dotIdx + 1);
                 }
 
                 const enclosingFunction = getCurrentEnclosingFunction();
+                const ctorArgs = getCallArgs(node);
                 calls.push({
                     name: typeName,
                     line: node.startPosition.row + 1,
                     isMethod: false,
                     isConstructor: true,
+                    ...(typeQualifier && { receiver: typeQualifier }),
+                    argCount: ctorArgs.argCount,
+                    ...(ctorArgs.argKinds && { argKinds: ctorArgs.argKinds }),
                     enclosingFunction
                 });
             }
@@ -984,22 +1202,29 @@ function findCallsInCode(code, parser) {
             return true;
         }
 
-        // Track local variable types from new Type() assignments
-        // e.g., Foo f = new Foo(); or var f = new Foo();
+        // Track local variable types from declarations (fix #207 extends #202-era
+        // new-Type() inference): the DECLARED type is compiler-checked evidence —
+        // `Service s = lookup();` types s as Service regardless of the value
+        // expression. `var` declarations fall back to new Type() value inference.
         if (node.type === 'local_variable_declaration' && functionStack.length > 0) {
+            const declTypeNode = node.childForFieldName('type');
+            const declaredType = declTypeNode && declTypeNode.text !== 'var'
+                ? extractTypeName(declTypeNode) : null;
             for (let i = 0; i < node.namedChildCount; i++) {
                 const child = node.namedChild(i);
                 if (child.type === 'variable_declarator') {
                     const nameNode = child.childForFieldName('name');
                     const valueNode = child.childForFieldName('value');
-                    if (nameNode && valueNode && valueNode.type === 'object_creation_expression') {
-                        const typeNode = valueNode.childForFieldName('type');
-                        const typeName = extractTypeName(typeNode);
-                        if (typeName) {
-                            const scopeKey = functionStack[functionStack.length - 1].startLine;
-                            const typeMap = scopeTypes.get(scopeKey);
-                            if (typeMap) typeMap.set(nameNode.text, typeName);
-                        }
+                    // new Type() is the DYNAMIC type — more precise than the
+                    // declared static type (Foo f = new Bar() dispatches to Bar)
+                    let typeName = valueNode?.type === 'object_creation_expression'
+                        ? extractTypeName(valueNode.childForFieldName('type'))
+                        : null;
+                    if (!typeName) typeName = declaredType;
+                    if (nameNode && typeName) {
+                        const scopeKey = functionStack[functionStack.length - 1].startLine;
+                        const typeMap = scopeTypes.get(scopeKey);
+                        if (typeMap) typeMap.set(nameNode.text, typeName);
                     }
                 }
             }
@@ -1156,7 +1381,7 @@ function findUsagesInCode(code, name, parser) {
     const tree = parseTree(parser, code);
     const usages = [];
 
-    traverseTreeCached(tree.rootNode, (node) => {
+    visitNameNodes(tree, code, name, (node) => {
         // Look for identifiers and type_identifiers with the matching name
         // type_identifier is used in Java for type references: new ClassName(), extends ClassName, field types
         if ((node.type !== 'identifier' && node.type !== 'type_identifier') || node.text !== name) {
@@ -1243,10 +1468,12 @@ function findUsagesInCode(code, name, parser) {
                     usageType = 'call';
                 }
             }
-            // Static method call: ClassName.staticMethod() — ClassName is the object
+            // Object position of a method call: x.method() — x is a receiver
+            // (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) {
-                usageType = 'call';
+                usageType = 'reference';
             }
             // Field access: obj.field
             else if (parent.type === 'field_access' &&