ucn 4.1.1 → 4.1.2

package/languages/javascript.js

@@ -528,6 +528,18 @@ function _processFunction(node, functions, processedRanges, lines) {
                         isArrow,
                         isGenerator: isGen,
                         modifiers: [],
+                        // A property-assignment def (Reply.prototype.serialize
+                        // = function, exports.h = () => ...) creates NO
+                        // lexical name — a bare call in the file can never
+                        // bind it (fix #269, fastify-measured: the prototype
+                        // def stole the module-scope binding from the free
+                        // `function serialize(...)` below it). Prototype
+                        // assignments carry their class so typed-receiver
+                        // method resolution reaches them.
+                        ...(leftNode.type === 'member_expression' && { memberAssigned: true }),
+                        ...(leftNode.type === 'member_expression' &&
+                            /^([A-Za-z_$][\w$]*)\.prototype\.[A-Za-z_$][\w$]*$/.test(leftNode.text) &&
+                            { className: leftNode.text.split('.')[0], isMethod: true }),
                         ...typeAnno,
                         ...(generics && { generics }),
                         ...(docstring && { docstring })
@@ -752,7 +764,14 @@ function _processClass(node, classes, processedRanges, lines) {
     // TypeScript namespace/module declarations
     if (node.type === 'internal_module' || node.type === 'module') {
         const nameNode = node.childForFieldName('name');
-        if (nameNode) {
+        // A STRING-named module declaration (`declare module '../vanilla'`)
+        // is a module AUGMENTATION/shape declaration, not a nameable symbol
+        // (fix #267, zustand-measured): it declares no identifier project
+        // code can reference, so indexing it as a namespace made deadcode
+        // claim every augmentation block dead (5 FALSE-DEADs on zustand's
+        // StoreMutators augmentations). The compiler merges it into the
+        // TARGET module — never claimable, never importable by this "name".
+        if (nameNode && nameNode.type !== 'string') {
             const { startLine, endLine } = nodeToLocation(node, lines);
             const docstring = extractJSDocstring(lines, startLine);
 
@@ -1280,6 +1299,21 @@ const JS_LITERAL_RECEIVER_TYPES = {
     number: 'Number',
 };
 
+// Literal ASSIGNMENTS type the variable (fix #262, the #218d Python rule):
+// `const lines = []` → lines is Array, so lines.push() is Array.push. Object
+// literals are deliberately absent — `const obj = {}` is the mutable
+// property-bag / namespace idiom (obj.render = fn happens later), so typing
+// it 'Object' would falsely externalize its assigned methods. A DIRECT
+// literal receiver (`{}.hasOwnProperty()`) has no such future, hence the
+// separate map above.
+const JS_LITERAL_ASSIGN_TYPES = {
+    array: 'Array',
+    string: 'String',
+    template_string: 'String',
+    regex: 'RegExp',
+    number: 'Number',
+};
+
 // Predefined TS types that pin a receiver; any/unknown/object say nothing.
 const TS_PREDEFINED_RECEIVER_TYPES = new Set(['string', 'number', 'boolean', 'bigint', 'symbol']);
 
@@ -1367,6 +1401,12 @@ function findCallsInCode(code, parser) {
     const aliases = new Map();  // Track local aliases: aliasName -> originalName (string or string[])
     const nonCallableNames = new Set();  // Track names assigned non-callable values
     const localVarTypes = new Map();  // Track local variable types: varName -> typeName (for receiverType inference)
+    // Names whose type came from a DECLARED annotation (TS `x: Foo` / typed
+    // params). The compiler enforces assignability for these, so reassignment
+    // never stales them; inferred types (literal/new) DO stale and are
+    // deleted on untyped reassignment (fix #262, #218d semantics).
+    const declaredTypeVars = new Set();
+    const declaredTypeVarsStack = [];
     const moduleAliases = new Set();  // Names bound to MODULES (import * as ns / const pkg = require(...))
     const localVarTypesStack = [];  // Stack for function-scoped save/restore of localVarTypes
 
@@ -1642,6 +1682,7 @@ function findCallsInCode(code, parser) {
             });
             // Save localVarTypes so inner declarations don't leak to sibling functions
             localVarTypesStack.push(new Map(localVarTypes));
+            declaredTypeVarsStack.push(new Set(declaredTypeVars));
         }
 
         // Track local aliases: const myParse = parse, const { parse: csvParse } = ...
@@ -1706,7 +1747,13 @@ function findCallsInCode(code, parser) {
                     const typeName = tsTypeName(typeId);
                     if (typeName) {
                         localVarTypes.set(nameNode.text, typeName);
+                        declaredTypeVars.add(nameNode.text);
                     }
+                } else if (initNode && JS_LITERAL_ASSIGN_TYPES[initNode.type]) {
+                    // Literal declaration types the variable (fix #262):
+                    // `const lines = []` → Array. Annotation, when present,
+                    // wins (the branch above).
+                    localVarTypes.set(nameNode.text, JS_LITERAL_ASSIGN_TYPES[initNode.type]);
                 }
             }
         }
@@ -1720,6 +1767,7 @@ function findCallsInCode(code, parser) {
                 const typeName = tsTypeName(inner);
                 if (typeName) {
                     localVarTypes.set(pat.text, typeName);
+                    declaredTypeVars.add(pat.text);
                 }
             }
         }
@@ -1728,11 +1776,26 @@ function findCallsInCode(code, parser) {
         if (node.type === 'assignment_expression') {
             const left = node.childForFieldName('left');
             const right = node.childForFieldName('right');
-            if (left?.type === 'identifier' && right?.type === 'new_expression') {
-                nonCallableNames.add(left.text);
-                const ctorName = jsConstructorTypeName(right.childForFieldName('constructor'));
-                if (ctorName) {
-                    localVarTypes.set(left.text, ctorName);
+            if (left?.type === 'identifier') {
+                if (right?.type === 'new_expression') {
+                    nonCallableNames.add(left.text);
+                    const ctorName = jsConstructorTypeName(right.childForFieldName('constructor'));
+                    if (ctorName) {
+                        localVarTypes.set(left.text, ctorName);
+                    } else if (!declaredTypeVars.has(left.text)) {
+                        localVarTypes.delete(left.text);
+                    }
+                } else if (right && JS_LITERAL_ASSIGN_TYPES[right.type]) {
+                    // Literal reassignment re-types the variable (fix #262)
+                    if (!declaredTypeVars.has(left.text)) {
+                        localVarTypes.set(left.text, JS_LITERAL_ASSIGN_TYPES[right.type]);
+                    }
+                } else if (localVarTypes.has(left.text) && !declaredTypeVars.has(left.text)) {
+                    // Rebinding without a known type makes any previously
+                    // INFERRED type stale — nearest-preceding-assignment
+                    // semantics (#218d). Annotation-declared types survive:
+                    // the TS compiler enforces assignability for those.
+                    localVarTypes.delete(left.text);
                 }
             }
             // Handler-registration references (fix #252, the #221 family's
@@ -1878,7 +1941,7 @@ function findCallsInCode(code, parser) {
                         // parseAsync(args).catch(...) — record the producer so
                         // findCallers can type the receiver from its declared
                         // return annotation (Promise<...> → Promise).
-                        let receiverCall, receiverCallIsMethod, receiverCallAwaited;
+                        let receiverCall, receiverCallIsMethod, receiverCallAwaited, receiverCallLine;
                         {
                             let recvNode = objNode;
                             if (recvNode && recvNode.type === 'parenthesized_expression') {
@@ -1892,11 +1955,17 @@ function findCallsInCode(code, parser) {
                                 const prodFunc = recvNode.childForFieldName('function');
                                 if (prodFunc?.type === 'identifier') {
                                     receiverCall = prodFunc.text;
+                                    // Producer link (fix #258): plain-call
+                                    // records carry the call node's start line
+                                    receiverCallLine = recvNode.startPosition.row + 1;
                                 } else if (prodFunc?.type === 'member_expression') {
                                     const prodProp = prodFunc.childForFieldName('property');
                                     if (prodProp) {
                                         receiverCall = prodProp.text;
                                         receiverCallIsMethod = true;
+                                        // Method records report the property
+                                        // node's own line
+                                        receiverCallLine = prodProp.startPosition.row + 1;
                                     }
                                 }
                             }
@@ -1930,6 +1999,7 @@ function findCallsInCode(code, parser) {
                             ...(receiverCall && { receiverCall }),
                             ...(receiverCallIsMethod && { receiverCallIsMethod: true }),
                             ...(receiverCallAwaited && { receiverCallAwaited: true }),
+                            ...(receiverCallLine && { receiverCallLine }),
                             ...(assignedTo && { assignedTo }),
                             enclosingFunction,
                             uncertain,
@@ -2165,6 +2235,11 @@ function findCallsInCode(code, parser) {
                     localVarTypes.clear();
                     for (const [k, v] of saved) localVarTypes.set(k, v);
                 }
+                const savedDeclared = declaredTypeVarsStack.pop();
+                if (savedDeclared) {
+                    declaredTypeVars.clear();
+                    for (const k of savedDeclared) declaredTypeVars.add(k);
+                }
             }
         }
     });
@@ -2340,6 +2415,7 @@ function findImportsInCode(code, parser) {
             const line = node.startPosition.row + 1;
             let modulePath = null;
             const names = [];
+            const esmRenames = [];
             let importType = 'named';
 
             // Find the module path (string node)
@@ -2385,6 +2461,7 @@ function findImportsInCode(code, parser) {
                                     if (nameNode && aliasNode && aliasNode.text !== nameNode.text) {
                                         if (!importAliases) importAliases = [];
                                         importAliases.push({ original: nameNode.text, local: aliasNode.text });
+                                        esmRenames.push({ original: nameNode.text, local: aliasNode.text });
                                     }
                                 }
                             }
@@ -2405,7 +2482,8 @@ function findImportsInCode(code, parser) {
                     // Side-effect import: import 'x'
                     importType = 'side-effect';
                 }
-                imports.push({ module: modulePath, names, type: importType, line });
+                imports.push({ module: modulePath, names, type: importType, line,
+                    ...(esmRenames.length > 0 && { renames: esmRenames }) });
             }
             return true;
         }
@@ -2451,6 +2529,7 @@ function findImportsInCode(code, parser) {
                     const firstArg = argsNode.namedChild(0);
                     const line = node.startPosition.row + 1;
                     const names = [];
+                    const renames = [];
                     let modulePath;
                     let dynamic = false;
 
@@ -2482,6 +2561,7 @@ function findImportsInCode(code, parser) {
                                         if (key && val && val.text !== key.text) {
                                             if (!importAliases) importAliases = [];
                                             importAliases.push({ original: key.text, local: val.text });
+                                            renames.push({ original: key.text, local: val.text });
                                         }
                                     }
                                 }
@@ -2490,7 +2570,13 @@ function findImportsInCode(code, parser) {
                     }
 
                     if (modulePath) {
-                        imports.push({ module: modulePath, names, type: 'require', line, dynamic });
+                        imports.push({ module: modulePath, names, type: 'require', line, dynamic,
+                            // Per-import rename pairing (fix #269): the flat
+                            // importAliases list loses WHICH module a renamed
+                            // name came from — `{ validate: validateSchema }`
+                            // must pin to its own require, not any module
+                            // exporting the source name.
+                            ...(renames.length > 0 && { renames }) });
                     }
                 }
             }

package/languages/python.js

@@ -138,6 +138,7 @@ function _processFunction(node, functions, processedRanges, lines, code) {
                 ...(paramTypes && { paramTypes }),
                 ...(docstring && { docstring }),
                 ...(decorators.length > 0 && { decorators }),
+                ...(isOverloadDecorated(decorators) && { isSignature: true }),
                 ...(nameLine !== decoratorStartLine && { nameLine })
             });
         }
@@ -285,6 +286,19 @@ function findFunctions(code, parser) {
     return functions;
 }
 
+/**
+ * A typing @overload-decorated def is a SIGNATURE of the implementation that
+ * follows, not a callable of its own (fix #265 — TS overload parity): the
+ * runtime discards the stub bodies, so pin identity must close over the
+ * group and resolution must prefer the implementation.
+ */
+function isOverloadDecorated(decorators) {
+    return decorators.some(d => {
+        const head = d.split('(')[0].trim();
+        return head === 'overload' || head.endsWith('.overload');
+    });
+}
+
 /**
  * Extract decorators from a function/class node
  */
@@ -472,6 +486,7 @@ function extractClassMembers(classNode, code) {
                     ...(paramTypes && { paramTypes }),
                     ...(docstring && { docstring }),
                     ...(memberDecorators.length > 0 && { decorators: memberDecorators }),
+                    ...(isOverloadDecorated(memberDecorators) && { isSignature: true }),
                     ...(nameLine !== startLine && { nameLine })
                 });
             }
@@ -1073,7 +1088,7 @@ function findCallsInCode(code, parser) {
                     // annotation. `(await f()).m()` unwraps to the call and
                     // marks awaited (an un-awaited async producer's value is a
                     // coroutine, not the annotation's type).
-                    let receiverCall, receiverCallIsMethod, receiverCallAwaited;
+                    let receiverCall, receiverCallIsMethod, receiverCallAwaited, receiverCallLine;
 
                     // Detect super().method() pattern
                     if (objNode?.type === 'call') {
@@ -1093,11 +1108,17 @@ function findCallsInCode(code, parser) {
                             const prodFunc = recvNode.childForFieldName('function');
                             if (prodFunc?.type === 'identifier') {
                                 receiverCall = prodFunc.text;
+                                // Producer link (fix #258): plain-call records
+                                // carry the call node's start line
+                                receiverCallLine = recvNode.startPosition.row + 1;
                             } else if (prodFunc?.type === 'attribute') {
                                 const prodAttr = prodFunc.childForFieldName('attribute');
                                 if (prodAttr) {
                                     receiverCall = prodAttr.text;
                                     receiverCallIsMethod = true;
+                                    // Method records report the attribute
+                                    // node's own line
+                                    receiverCallLine = prodAttr.startPosition.row + 1;
                                 }
                             }
                         }
@@ -1140,6 +1161,7 @@ function findCallsInCode(code, parser) {
                         ...(receiverCall && { receiverCall }),
                         ...(receiverCallIsMethod && { receiverCallIsMethod: true }),
                         ...(receiverCallAwaited && { receiverCallAwaited: true }),
+                        ...(receiverCallLine && { receiverCallLine }),
                         ...(assignedTo && { assignedTo }),
                         argCount,
                         ...(argSpread && { argSpread: true }),

package/languages/rust.js

@@ -1311,13 +1311,18 @@ function findCallsInCode(code, parser) {
                     // chain to its root: if the chain originates at Router::new() or
                     // any Router-typed call, set a synthetic receiver string so the
                     // bridge layer can recognize this as a Router method invocation.
+                    let receiverIsChainRoot;
                     if (!receiver && valueNode?.type === 'call_expression') {
                         const rootType = _findRustChainRootType(valueNode);
                         if (rootType) {
                             // Synthetic marker — ROUTER_CHAIN:<RootTypeName>. The
                             // <RootTypeName> portion lets the bridge match
-                            // /^router/i case-insensitively.
+                            // /^router/i case-insensitively. receiverIsChainRoot
+                            // tells caller physics this is NOT an identifier in
+                            // the code (fix #258) — the chain fold types it from
+                            // the producer link instead.
                             receiver = rootType;
+                            receiverIsChainRoot = true;
                         }
                     }
                     // fix #202: one-hop declared-field receivers — self.dent.path(),
@@ -1354,16 +1359,43 @@ function findCallsInCode(code, parser) {
                     // Chained receiver (fix #220): the receiver IS a call —
                     // self.as_u8().as_color() — record the producer so
                     // findCallers can type it from the declared return.
-                    // Path producers (Config::load().x()) stay uncaptured
-                    // until a measured family justifies the path branch.
-                    let receiverCall, receiverCallIsMethod;
-                    if (!receiver && !receiverField && valueNode?.type === 'call_expression') {
-                        const prodFunc = valueNode.childForFieldName('function');
+                    // Fix #258 (clap-measured): receiverCallLine links to the
+                    // producer's OWN record (per-record line convention:
+                    // field identifier for method producers, call-node start
+                    // for plain/path producers) so the chain fold can walk
+                    // Command::new("x").a(...).b(...) hop by hop; path
+                    // producers (Config::load().x()) are captured now, and
+                    // rooted chains keep their synthetic receiver marker for
+                    // the bridge but get the link too.
+                    let receiverCall, receiverCallIsMethod, receiverCallLine;
+                    if ((!receiver || receiverIsChainRoot) && !receiverField &&
+                        valueNode?.type === 'call_expression') {
+                        let prodFunc = valueNode.childForFieldName('function');
+                        if (prodFunc?.type === 'generic_function') {
+                            prodFunc = prodFunc.childForFieldName('function') || prodFunc;
+                        }
                         if (prodFunc?.type === 'identifier') {
                             receiverCall = prodFunc.text;
+                            receiverCallLine = valueNode.startPosition.row + 1;
                         } else if (prodFunc?.type === 'field_expression') {
                             const pf = prodFunc.childForFieldName('field');
-                            if (pf) { receiverCall = pf.text; receiverCallIsMethod = true; }
+                            if (pf) {
+                                receiverCall = pf.text;
+                                receiverCallIsMethod = true;
+                                receiverCallLine = pf.startPosition.row + 1;
+                            }
+                        } else if (prodFunc?.type === 'scoped_identifier') {
+                            // Path producer: Command::new(...).arg(...) — the
+                            // producer record's name is the last path segment
+                            // (turbofish segments dropped, matching the path
+                            // record's own derivation) at the call node's line.
+                            const segs = prodFunc.text.split('::');
+                            const prodName = segs[segs.length - 1];
+                            if (prodName && !prodName.startsWith('<')) {
+                                receiverCall = prodName;
+                                receiverCallIsMethod = true;
+                                receiverCallLine = valueNode.startPosition.row + 1;
+                            }
                         }
                     }
                     // Literal receivers carry their builtin type (fix #220,
@@ -1374,7 +1406,7 @@ function findCallsInCode(code, parser) {
                         ? ({ string_literal: 'str', raw_string_literal: 'str',
                             char_literal: 'char', boolean_literal: 'bool' })[valueNode.type]
                         : undefined;
-                    const receiverType = (receiver && receiver !== 'self')
+                    const receiverType = (receiver && receiver !== 'self' && !receiverIsChainRoot)
                         ? getReceiverType(receiver)
                         : literalReceiverType;
                     const firstArg = getFirstStringArg(node);
@@ -1389,10 +1421,12 @@ function findCallsInCode(code, parser) {
                         isMethod: true,
                         receiver,
                         ...(receiverType && { receiverType }),
+                        ...(receiverIsChainRoot && { receiverIsChainRoot: true }),
                         ...(receiverField && { receiverRoot, receiverField }),
                         ...(receiverField && receiverRootType && { receiverRootType }),
                         ...(receiverCall && { receiverCall }),
                         ...(receiverCallIsMethod && { receiverCallIsMethod: true }),
+                        ...(receiverCallLine && { receiverCallLine }),
                         argCount,
                         ...(assigned && { assignedTo: assigned.assignedTo }),
                         ...(assigned?.unwrapped && { assignedUnwrap: true }),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ucn",
-  "version": "4.1.1",
+  "version": "4.1.2",
   "mcpName": "io.github.mleoca/ucn",
   "description": "Code intelligence toolkit for AI agents — extract functions, trace call chains, find callers, detect dead code without reading entire files. Works as MCP server, CLI, or agent skill. Supports JS/TS, Python, Go, Rust, Java.",
   "main": "index.js",