ucn 4.2.2 → 4.2.3

package/languages/python.js

@@ -671,7 +671,7 @@ function constructorTypeInfo(funcNode) {
         const attr = funcNode.childForFieldName('attribute');
         const object = funcNode.childForFieldName('object');
         return attr && /^[A-Z]/.test(attr.text)
-            ? { type: attr.text, qualifier: object?.type === 'identifier' ? object.text : undefined }
+            ? { type: attr.text, qualifier: object?.text || undefined }
             : undefined;
     }
     return undefined;
@@ -685,6 +685,8 @@ function findCallsInCode(code, parser) {
     const nonCallableNames = new Set();  // Track names assigned non-callable values
     const localVarTypes = new Map();  // Track local variable types: varName -> typeName (for receiverType inference)
     const localVarTypeQualifiers = new Map(); // varName -> imported module alias that owns the inferred type
+    const constructedReceiverVars = new Set(); // exact constructor-result bindings
+    const withBindingVars = new Set(); // names produced by a context-manager as-target
     // Member-access aliases (fix #218): `append = output.append` makes a later
     // bare `append(part)` a METHOD call on `output` — it must carry the
     // receiver's evidence, never bind by bare name to a same-file def
@@ -697,6 +699,8 @@ function findCallsInCode(code, parser) {
     const moduleAliases = new Set();  // Names bound to MODULES (import httpx / import numpy as np)
     const localVarTypesStack = [];  // Stack for function-scoped save/restore of localVarTypes
     const localVarTypeQualifiersStack = [];
+    const constructedReceiverVarsStack = [];
+    const withBindingVarsStack = [];
 
     // Helper: extract first string-arg literal from a call node.
     // Used by route extraction to capture path arg of requests.get('/users'), httpx.get('/users') etc.
@@ -848,6 +852,16 @@ function findCallsInCode(code, parser) {
                 }
             }
             if (p.type === 'function_definition' || p.type === 'async_function_definition') {
+                const params = p.childForFieldName('parameters');
+                if (params) {
+                    for (let i = 0; i < params.namedChildCount; i++) {
+                        const prm = params.namedChild(i);
+                        const prmName = prm.type === 'identifier'
+                            ? prm
+                            : (prm.childForFieldName('name') || prm.namedChild(0));
+                        if (prmName?.type === 'identifier' && prmName.text === name) return true;
+                    }
+                }
                 const body = p.childForFieldName('body');
                 return body ? _bindsNameInScope(body, name) : false;
             }
@@ -888,6 +902,8 @@ function findCallsInCode(code, parser) {
             // Save localVarTypes so inner declarations don't leak to sibling functions
             localVarTypesStack.push(new Map(localVarTypes));
             localVarTypeQualifiersStack.push(new Map(localVarTypeQualifiers));
+            constructedReceiverVarsStack.push(new Set(constructedReceiverVars));
+            withBindingVarsStack.push(new Set(withBindingVars));
             memberAliasesStack.push(new Map(memberAliases));
         }
 
@@ -912,11 +928,18 @@ function findCallsInCode(code, parser) {
                 const ctx = value.namedChild(0);
                 const target = value.namedChildCount > 1 ? value.namedChild(value.namedChildCount - 1) : null;
                 const targetId = target?.type === 'as_pattern_target' ? target.namedChild(0) : null;
+                const recordWithTargets = n => {
+                    if (!n) return;
+                    if (n.type === 'identifier') withBindingVars.add(n.text);
+                    for (let i = 0; i < n.namedChildCount; i++) recordWithTargets(n.namedChild(i));
+                };
+                recordWithTargets(targetId || target);
                 if (ctx?.type === 'call' && targetId?.type === 'identifier') {
                     const ctor = constructorTypeInfo(ctx.childForFieldName('function'));
                     if (ctor) {
                         localVarTypes.set(targetId.text, ctor.type);
-                        if (ctor.qualifier && moduleAliases.has(ctor.qualifier)) {
+                        constructedReceiverVars.add(targetId.text);
+                        if (ctor.qualifier && moduleAliases.has(ctor.qualifier.split('.')[0])) {
                             localVarTypeQualifiers.set(targetId.text, ctor.qualifier);
                         } else {
                             localVarTypeQualifiers.delete(targetId.text);
@@ -940,6 +963,8 @@ function findCallsInCode(code, parser) {
                     }
                 }
                 memberAliases.delete(left.text); // any assignment rebinds the name
+                constructedReceiverVars.delete(left.text);
+                withBindingVars.delete(left.text);
                 // Rebinding without a known type makes any previously inferred
                 // type stale — nearest-preceding-assignment semantics (#199's
                 // documented rule). Without this, `x = ""; x = render(); x.m()`
@@ -1017,7 +1042,8 @@ function findCallsInCode(code, parser) {
                     const ctor = constructorTypeInfo(right.childForFieldName('function'));
                     if (ctor) {
                         localVarTypes.set(left.text, ctor.type);
-                        if (ctor.qualifier && moduleAliases.has(ctor.qualifier)) {
+                        constructedReceiverVars.add(left.text);
+                        if (ctor.qualifier && moduleAliases.has(ctor.qualifier.split('.')[0])) {
                             localVarTypeQualifiers.set(left.text, ctor.qualifier);
                         } else {
                             localVarTypeQualifiers.delete(left.text);
@@ -1101,6 +1127,7 @@ function findCallsInCode(code, parser) {
                         ...(argSpread && { argSpread: true }),
                         enclosingFunction,
                         uncertain,
+                        ...(isShadowedByLocal(funcNode, funcNode.text) && { localShadow: true }),
                         ...(firstArg && { firstStringArg: firstArg.value, firstStringArgInterp: firstArg.interp })
                     });
                 }
@@ -1190,7 +1217,11 @@ function findCallsInCode(code, parser) {
                         receiver,
                         ...(receiverType && { receiverType }),
                         ...(receiverTypeQualifier && { receiverTypeQualifier }),
+                        ...(receiver && constructedReceiverVars.has(receiver) && { receiverConstructed: true }),
+                        ...(receiver && withBindingVars.has(receiver) && { receiverWithBinding: true }),
                         ...(receiverIsModule && { receiverIsModule: true }),
+                        ...(receiver && objNode?.type === 'identifier' &&
+                            isShadowedByLocal(objNode, receiver) && { receiverLocalBinding: true }),
                         ...(selfAttribute && { selfAttribute }),
                         ...(receiverCall && { receiverCall }),
                         ...(receiverCallIsMethod && { receiverCallIsMethod: true }),
@@ -1273,6 +1304,12 @@ function findCallsInCode(code, parser) {
                     localVarTypeQualifiers.clear();
                     for (const [k, v] of savedQualifiers) localVarTypeQualifiers.set(k, v);
                 }
+                const savedConstructed = constructedReceiverVarsStack.pop();
+                constructedReceiverVars.clear();
+                if (savedConstructed) for (const name of savedConstructed) constructedReceiverVars.add(name);
+                const savedWithBindings = withBindingVarsStack.pop();
+                withBindingVars.clear();
+                if (savedWithBindings) for (const name of savedWithBindings) withBindingVars.add(name);
                 const savedAliases = memberAliasesStack.pop();
                 if (savedAliases) {
                     memberAliases.clear();
@@ -1304,13 +1341,33 @@ function findImportsInCode(code, parser) {
             for (let i = 0; i < node.namedChildCount; i++) {
                 const child = node.namedChild(i);
                 if (child.type === 'dotted_name') {
-                    // import os
-                    imports.push({
-                        module: child.text,
-                        names: [child.text.split('.').pop()],
-                        type: 'import',
-                        line
-                    });
+                    // `import pkg.submodule` binds `pkg`, while also loading
+                    // the complete submodule. Record both ownership edges so
+                    // `pkg.public_api()` can resolve through pkg/__init__.py
+                    // and `pkg.submodule.member` can still resolve to the
+                    // imported child module.
+                    const parts = child.text.split('.');
+                    if (parts.length > 1) {
+                        imports.push({
+                            module: parts[0],
+                            names: [parts[0]],
+                            type: 'import',
+                            line
+                        });
+                        imports.push({
+                            module: child.text,
+                            names: [],
+                            type: 'import-submodule',
+                            line
+                        });
+                    } else {
+                        imports.push({
+                            module: child.text,
+                            names: [child.text],
+                            type: 'import',
+                            line
+                        });
+                    }
                 } else if (child.type === 'aliased_import') {
                     // import sys as system
                     const nameNode = child.namedChild(0);
@@ -1537,6 +1594,16 @@ function findUsagesInCode(code, name, parser, tree) {
                     usages.push({ line, column, usageType, receiver: object.text });
                     return true;
                 }
+                // Constructed receiver: ColorTriplet(...).normalized is a
+                // class-associated property reference, not an unowned bare
+                // name. This matters to class-scoped `tests` queries.
+                if (object && object.type === 'call') {
+                    const ctor = object.childForFieldName('function');
+                    if (ctor?.type === 'identifier') {
+                        usages.push({ line, column, usageType, receiver: ctor.text });
+                        return true;
+                    }
+                }
                 // self.attr receiver (unittest setUp idiom: self.w = Widget(3);
                 // self.w.render()) — record the ATTR name so the instance-type
                 // map built from the assignment line ('w' → Widget) matches

package/languages/rust.js

@@ -432,6 +432,7 @@ function _processClass(node, types, processedRanges, lines, code) {
         const { startLine, endLine } = nodeToLocation(node, lines);
         const implInfo = extractImplInfo(node);
         const docstring = extractRustDocstring(lines, startLine);
+        const derefTarget = extractDerefTarget(node, implInfo.traitName);
 
         types.push({
             name: implInfo.name,
@@ -442,6 +443,7 @@ function _processClass(node, types, processedRanges, lines, code) {
             typeName: implInfo.typeName,
             members: extractImplMembers(node, lines, implInfo.typeName),
             modifiers: [],
+            ...(derefTarget && { derefTarget }),
             ...(docstring && { docstring })
         });
         return true;  // matched
@@ -548,19 +550,41 @@ function _processClass(node, types, processedRanges, lines, code) {
  */
 function _postProcessTraitImpls(types) {
     const implTraits = new Map(); // typeName → [traitName, ...]
+    const derefTargets = new Map(); // typeName -> Set<Target>
     for (const t of types) {
         if (t.type === 'impl' && t.traitName && t.typeName) {
             if (!implTraits.has(t.typeName)) implTraits.set(t.typeName, []);
             implTraits.get(t.typeName).push(t.traitName);
+            if (t.derefTarget) {
+                if (!derefTargets.has(t.typeName)) derefTargets.set(t.typeName, new Set());
+                derefTargets.get(t.typeName).add(t.derefTarget);
+            }
         }
     }
     for (const t of types) {
         if ((t.type === 'struct' || t.type === 'enum') && implTraits.has(t.name)) {
             t.implements = implTraits.get(t.name);
+            const targets = derefTargets.get(t.name);
+            if (targets?.size === 1) t.derefTarget = [...targets][0];
         }
     }
 }
 
+function extractDerefTarget(implNode, traitName) {
+    if (!traitName || !/(^|::)Deref(?:Mut)?$/.test(traitName)) return null;
+    let found = null;
+    const walk = node => {
+        if (found) return;
+        if (node.type === 'type_item' && node.childForFieldName('name')?.text === 'Target') {
+            found = aliasBaseTypeName(node.childForFieldName('type'));
+            return;
+        }
+        for (let i = 0; i < node.namedChildCount; i++) walk(node.namedChild(i));
+    };
+    walk(implNode);
+    return found;
+}
+
 /**
  * Process a node for state object extraction (single-pass helper)
  * Returns true if node was matched, false otherwise
@@ -654,6 +678,28 @@ function extractStructFields(structNode, codeOrLines) {
     const bodyNode = structNode.childForFieldName('body');
     if (!bodyNode) return fields;
 
+    if (bodyNode.type === 'ordered_field_declaration_list') {
+        let position = 0;
+        for (let i = 0; i < bodyNode.namedChildCount; i++) {
+            const field = bodyNode.namedChild(i);
+            // Visibility modifiers and field attributes (`#[serde(..)] u32`)
+            // are separate children; the type node owns the tuple position.
+            // Numeric member names let the shared declared-field hop resolve
+            // `self.0.method()` exactly.
+            if (field.type === 'visibility_modifier' ||
+                field.type === 'attribute_item') continue;
+            const { startLine, endLine } = nodeToLocation(field, code);
+            fields.push({
+                name: String(position++),
+                startLine,
+                endLine,
+                memberType: 'field',
+                fieldType: field.text,
+            });
+        }
+        return fields;
+    }
+
     for (let i = 0; i < bodyNode.namedChildCount; i++) {
         const field = bodyNode.namedChild(i);
         if (field.type === 'field_declaration') {
@@ -1474,7 +1520,7 @@ function findCallsInCode(code, parser) {
                         if (obj?.type === 'field_expression') {
                             const rootNode = obj.childForFieldName('value');
                             const fldNode = obj.childForFieldName('field');
-                            if (fldNode?.type === 'field_identifier' && rootNode &&
+                            if ((fldNode?.type === 'field_identifier' || fldNode?.type === 'integer_literal') && rootNode &&
                                 (rootNode.type === 'identifier' || rootNode.type === 'self')) {
                                 receiverRoot = rootNode.text;
                                 receiverField = fldNode.text;
@@ -2139,6 +2185,30 @@ function _indexInParent(node, parent) {
 function findUsagesInCode(code, name, parser, tree) {
     tree = tree || parseTree(parser, code);
     const usages = [];
+    // Lazy same-file enum→variants map: built only when a paren-less
+    // `Type::name` reference needs the enum-variant check.
+    let _enumVariants = null;
+    const sameFileEnumVariant = (enumName, variantName) => {
+        if (_enumVariants === null) {
+            _enumVariants = new Map();
+            traverseTreeCached(tree.rootNode, (n) => {
+                if (n.type !== 'enum_item') return;
+                const enName = n.childForFieldName('name')?.text;
+                const body = n.childForFieldName('body');
+                if (!enName || !body) return;
+                let set = _enumVariants.get(enName);
+                if (!set) { set = new Set(); _enumVariants.set(enName, set); }
+                for (let i = 0; i < body.namedChildCount; i++) {
+                    const child = body.namedChild(i);
+                    if (child.type === 'enum_variant') {
+                        const vn = child.childForFieldName('name')?.text;
+                        if (vn) set.add(vn);
+                    }
+                }
+            });
+        }
+        return _enumVariants.get(enumName)?.has(variantName) || false;
+    };
 
     visitNameNodes(tree, code, name, (node) => {
         // Look for identifier, field_identifier (method names in obj.method() calls),
@@ -2201,6 +2271,34 @@ function findUsagesInCode(code, name, parser, tree) {
                             return true;
                         }
                     }
+                } else if (sameNode(parent.childForFieldName('name'), node)) {
+                    // Associated method value: `Cursive::quit` is a reference
+                    // to the method even though no call_expression wraps it.
+                    // Preserve its type receiver so the project-aware usage
+                    // layer can distinguish it from `Enum::Variant`.
+                    const pathNode = parent.childForFieldName('path');
+                    if (pathNode) {
+                        const segs = pathNode.text.split('::');
+                        const receiver = segs[segs.length - 1];
+                        // A same-file `enum Receiver { Name }` proves this is
+                        // the variant, not an associated item of the queried
+                        // symbol — provable without the index, so filtered
+                        // here; cross-file receivers stay for the project
+                        // layer's owner check.
+                        if (receiver && sameFileEnumVariant(receiver, name)) {
+                            return true;
+                        }
+                        if (receiver) {
+                            usages.push({
+                                line,
+                                column,
+                                usageType: 'reference',
+                                receiver,
+                                scopedReference: true,
+                            });
+                            return true;
+                        }
+                    }
                 }
             }
             // Turbofish call on a bare name: f::<T>() — the identifier's parent

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ucn",
-  "version": "4.2.2",
+  "version": "4.2.3",
   "mcpName": "io.github.mleoca/ucn",
   "description": "Code intelligence toolkit for AI agents: extract functions, trace call chains, find callers, and 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",
@@ -18,9 +18,9 @@
     "eval:performance": "node --expose-gc eval/run-performance-gate.js",
     "lint": "eslint core/ cli/ mcp/ languages/ eval/run-*.js eval/*-gate-policy.js",
     "verify": "npm run lint && npm test",
-    "trust:gate:semantic": "node eval/run-oracle-eval.js --repo preact-signals,httpx,cobra,clap,javapoet --min-precision 0.98 --max-unscored-ratio 0.10",
-    "trust:gate:deadcode": "node eval/run-deadcode-eval.js --repo preact-signals,httpx,cobra,clap,javapoet --sample 100 --arm default",
-    "trust:gate:performance": "node --expose-gc eval/run-performance-gate.js --repo preact-signals,httpx,cobra,clap,javapoet --queries 40",
+    "trust:gate:semantic": "node eval/run-oracle-eval.js --release --min-precision 0.98 --max-unscored-ratio 0.10",
+    "trust:gate:deadcode": "node eval/run-deadcode-eval.js --release --sample 100 --arm default",
+    "trust:gate:performance": "node --expose-gc eval/run-performance-gate.js --release --queries 40",
     "trust:gate:fast": "node eval/run-oracle-eval.js --repo preact-signals,httpx --min-precision 0.98 && node --expose-gc eval/run-performance-gate.js --repo preact-signals,httpx --queries 20",
     "trust:gate": "npm run trust:gate:semantic && npm run trust:gate:deadcode && npm run trust:gate:performance"
   },