ucn 4.1.1 → 4.1.2

package/core/deadcode.js

@@ -161,17 +161,52 @@ function nameOnlySelfRecursive(index, name) {
     return true;
 }
 
-/** Check if a position in a line is inside a string literal (quotes/backticks) */
-function isInsideString(line, pos) {
+/** Check if a position in a line is inside a string literal (quotes/backticks).
+ *  Language-aware (fix #259, clap-measured): a Rust apostrophe is a LIFETIME
+ *  unless it closes as a char literal within a few chars — `impl<E: Send +
+ *  'static> MyTrait` read everything after 'static as "inside a string" and
+ *  dropped the line's only reference to MyTrait (FALSE-DEAD on clap's
+ *  autoref-specialization traits). */
+function isInsideString(line, pos, language) {
     let inSingle = false, inDouble = false, inBacktick = false;
+    // Template-literal interpolations are CODE (fix #267, hono-measured:
+    // `${this.activeRouter.name}` was the getter's ONLY read — masked as
+    // string interior, the symbol claimed FALSE-DEAD). JS family only: Go
+    // backtick strings are raw, no interpolation. Brace-depth tracked so
+    // `${ {a: 1} }` closes at the right brace; quotes inside interpolations
+    // are not tracked — the misjudgment direction is UNMASK (counting a
+    // usage keeps the symbol alive), never masking code (#253 rule).
+    let interpDepth = 0;
+    const jsTemplates = language === 'javascript' || language === 'typescript' ||
+        language === 'tsx' || language === 'html';
     for (let j = 0; j < pos; j++) {
         const ch = line[j];
         if (ch === '\\') { j++; continue; }
+        if (inBacktick && jsTemplates) {
+            if (interpDepth === 0) {
+                if (ch === '$' && line[j + 1] === '{') { interpDepth = 1; j++; }
+                else if (ch === '`') inBacktick = false;
+                continue;
+            }
+            if (ch === '{') interpDepth++;
+            else if (ch === '}') interpDepth--;
+            continue;
+        }
         if (ch === '"' && !inSingle && !inBacktick) inDouble = !inDouble;
-        if (ch === "'" && !inDouble && !inBacktick) inSingle = !inSingle;
+        if (ch === "'" && !inDouble && !inBacktick) {
+            if (language === 'rust') {
+                // Char literal ('x', '\n', '\u{1F600}') — skip past it; a
+                // non-closing apostrophe is a lifetime and never opens a
+                // string (Rust strings are double-quoted only).
+                const m = line.slice(j).match(/^'(?:\\u\{[0-9a-fA-F_]+\}|\\.|[^'\\])'/);
+                if (m) j += m[0].length - 1;
+            } else {
+                inSingle = !inSingle;
+            }
+        }
         if (ch === '`' && !inDouble && !inSingle) inBacktick = !inBacktick;
     }
-    return inSingle || inDouble || inBacktick;
+    return inSingle || inDouble || (inBacktick && interpDepth === 0);
 }
 
 /**
@@ -591,9 +626,16 @@ function deadcode(index, options = {}) {
                     for (let i = 0; i < lines.length; i++) {
                         const line = lines[i];
                         if (!line.includes(name)) continue;
-                        // Skip line if entirely inside a line comment (// or #)
-                        const commentIdx = line.indexOf('//');
-                        const hashIdx = line.indexOf('#');
+                        // Skip line if entirely inside a line comment — the
+                        // markers are language-shaped (fix #259, clap-measured):
+                        // `#` comments PYTHON ONLY (a Rust attribute line
+                        // `#[arg(value_parser = helper)]` is code, and the old
+                        // skip dropped every reference on it — clap's derive-
+                        // attribute callbacks claimed FALSE-DEAD); `//` comments
+                        // everywhere EXCEPT Python, where it is floor division.
+                        const isPython = fileEntry.language === 'python';
+                        const commentIdx = isPython ? -1 : line.indexOf('//');
+                        const hashIdx = isPython ? line.indexOf('#') : -1;
                         let searchFrom = 0;
                         while (searchFrom < line.length) {
                             const pos = line.indexOf(name, searchFrom);
@@ -611,7 +653,7 @@ function deadcode(index, options = {}) {
                             // Skip if inside a string literal — EXCEPT class-
                             // kind names in Python (fix #253a): `x: "Foo"`
                             // forward references are real type references.
-                            if (isInsideString(line, pos) &&
+                            if (isInsideString(line, pos, fileEntry.language) &&
                                 !(fileEntry.language === 'python' && classKindNames.has(name))) continue;
                             // Property/field access (preceded by '.'), not a
                             // call: resolve the RECEIVER (fix #216, express-
@@ -778,6 +820,15 @@ function deadcode(index, options = {}) {
 
             const mods = symbol.modifiers || [];
 
+            // Ambient declaration files are never dead CODE (fix #267,
+            // zustand-measured: `interface ImportMeta` in src/types.d.ts —
+            // global lib merging UCN cannot see): .d.ts content is erased at
+            // compile time and describes external/global shapes — nothing in
+            // it is deletable code, so nothing in it is claimable.
+            if (symbol.relativePath.endsWith('.d.ts')) {
+                continue;
+            }
+
             // Language-specific entry points (called by runtime/test runner, not user code)
             // Each language module declares its own isEntryPoint() rules.
             const langModule = getLanguageModule(lang);

package/core/entrypoints.js

@@ -1104,6 +1104,12 @@ function computeReachability(index) {
         }
     }
 
+    // The BFS runs thousands of findCallees calls — the per-operation caches
+    // (call counts, usage totals, content) halve its cost. Wrap so callers
+    // outside a command op (evals, direct API use) get the same warm path;
+    // _beginOp nests, so command-op callers are unaffected.
+    index._beginOp?.();
+    try {
     const reachable = new Set();
     const entryPoints = detectEntrypoints(index);
 
@@ -1208,8 +1214,10 @@ function computeReachability(index) {
 
     // BFS: walk callees of every reachable symbol.
     // findCallees returns full symbol objects for every callee with file/startLine.
-    while (queue.length > 0) {
-        const sym = queue.shift();
+    // Index-based traversal — queue.shift() is O(n) per dequeue and the
+    // queue reaches thousands of entries; same FIFO order.
+    for (let qi = 0; qi < queue.length; qi++) {
+        const sym = queue[qi];
         if (!sym.file || sym.startLine == null) continue;
 
         let callees;
@@ -1242,6 +1250,9 @@ function computeReachability(index) {
     // Cleared in saveCache after a successful write.
     index.reachabilityDirty = true;
     return reachable;
+    } finally {
+        index._endOp?.();
+    }
 }
 
 /**

package/core/imports.js

@@ -145,6 +145,15 @@ function resolveImport(importPath, fromFile, config = {}) {
             const fullPath = path.join(config.root, modulePath);
             const resolved = resolveFilePath(fullPath, getExtensions('python'));
             if (resolved) return resolved;
+            // PEP-517 src layout (fix #269, click-measured): the installed
+            // package lives under src/ — `import click` from tests/ resolves
+            // to src/click/__init__.py. Without this, the module-ownership
+            // discipline judged the project's OWN package provably external
+            // (excluded every `click.get_binary_stream(...)` test caller —
+            // a false zero-caller answer).
+            const srcPath = path.join(config.root, 'src', modulePath);
+            const srcResolved = resolveFilePath(srcPath, getExtensions('python'));
+            if (srcResolved) return srcResolved;
         }
 
         return null;  // External package
@@ -289,6 +298,42 @@ function resolveGoImport(importPath, fromFile, projectRoot) {
 // Cache for Rust crate roots (Cargo.toml locations)
 const cargoCache = new Map();
 
+// Workspace crate registry (fix #258): Cargo [package] name → crate source
+// root for EVERY crate in the project tree, so cross-crate workspace imports
+// (`use clap::Command` from clap_bench/) resolve like own-package imports.
+// One bounded scan per project root, cached.
+const workspaceCrateCache = new Map();
+const _WORKSPACE_SCAN_PRUNE = new Set([
+    'node_modules', '.git', 'target', 'vendor', 'dist', 'build', '.ucn-cache',
+]);
+
+function workspaceCrateRegistry(projectRoot) {
+    if (workspaceCrateCache.has(projectRoot)) {
+        return workspaceCrateCache.get(projectRoot);
+    }
+    const registry = new Map();
+    const walk = (dir, depth) => {
+        if (depth > 6) return;
+        let entries;
+        try { entries = fs.readdirSync(dir, { withFileTypes: true }); }
+        catch { return; }
+        for (const e of entries) {
+            if (e.isDirectory()) {
+                if (_WORKSPACE_SCAN_PRUNE.has(e.name) || e.name.startsWith('.')) continue;
+                walk(path.join(dir, e.name), depth + 1);
+            } else if (e.name === 'Cargo.toml') {
+                const info = findCargoRoot(dir);
+                if (info && info.packageName && !registry.has(info.packageName)) {
+                    registry.set(info.packageName, info);
+                }
+            }
+        }
+    };
+    walk(projectRoot, 0);
+    workspaceCrateCache.set(projectRoot, registry);
+    return registry;
+}
+
 /**
  * Find the nearest Cargo.toml and return the crate's source root
  * @param {string} startDir - Directory to start searching from
@@ -311,13 +356,24 @@ function findCargoRoot(startDir) {
             // integration tests/benches/examples (`use mypkg::...` in
             // tests/*.rs — fix #246); `-` normalizes to `_` in code.
             let packageName = null;
+            const targetDirs = [];
             try {
                 const toml = fs.readFileSync(cargoPath, 'utf-8');
                 const pkgSection = toml.split(/^\s*\[/m).find(s => s.startsWith('package]'));
                 const m = pkgSection && pkgSection.match(/^\s*name\s*=\s*"([^"]+)"/m);
                 if (m) packageName = m[1].replace(/-/g, '_');
+                // Explicit target roots (fix #260b, ripgrep-measured): a
+                // manifest may root its targets OUTSIDE src/ — ripgrep's
+                // `[[bin]] path = "crates/core/main.rs"` puts the whole bin
+                // module tree under crates/core, so `crate::messages` from
+                // crates/core/flags/parse.rs resolves THERE, never at src/.
+                // Collect every declared .rs target path's directory.
+                for (const tm of toml.matchAll(/^\s*path\s*=\s*"([^"]+\.rs)"/gm)) {
+                    const tDir = path.dirname(path.resolve(dir, tm[1]));
+                    if (!targetDirs.includes(tDir)) targetDirs.push(tDir);
+                }
             } catch { /* unreadable Cargo.toml — no package identity */ }
-            const result = { root: dir, srcDir: fs.existsSync(srcDir) ? srcDir : dir, packageName };
+            const result = { root: dir, srcDir: fs.existsSync(srcDir) ? srcDir : dir, packageName, targetDirs };
             cargoCache.set(startDir, result);
             return result;
         }
@@ -389,17 +445,30 @@ function resolveRustModulePath(dir, segments) {
 function resolveRustImport(importPath, fromFile, projectRoot) {
     const fromDir = path.dirname(fromFile);
 
-    // crate:: paths - resolve from the crate's src/ directory
+    // crate:: paths - resolve from the crate's src/ directory, or from a
+    // manifest-declared target root (fix #260b): a `[[bin]] path =
+    // "crates/core/main.rs"` roots the module tree at crates/core — the
+    // importing file's crate root dir is the DEEPEST declared target dir
+    // that is an ancestor of the file (module files live under their crate
+    // root; integration tests are separate crates and can't use crate::).
     if (importPath.startsWith('crate::')) {
         const cargo = findCargoRoot(fromDir);
         if (!cargo) return null;
 
         const rest = importPath.slice('crate::'.length);
         const segments = rest.split('::');
-        // `use crate::ITEM` where ITEM is declared in the crate root file has
-        // no ITEM.rs — the import points at lib.rs/main.rs itself.
-        return resolveRustModulePath(cargo.srcDir, segments) ||
-            rustModuleOwnFile(cargo.srcDir, fromFile);
+        const candidates = [cargo.srcDir, ...(cargo.targetDirs || [])]
+            .filter(d => fromDir === d || fromDir.startsWith(d + path.sep))
+            .sort((a, b) => b.length - a.length);
+        if (candidates.length === 0) candidates.push(cargo.srcDir);
+        for (const cand of candidates) {
+            // `use crate::ITEM` where ITEM is declared in the crate root file
+            // has no ITEM.rs — the import points at lib.rs/main.rs itself.
+            const hit = resolveRustModulePath(cand, segments) ||
+                rustModuleOwnFile(cand, fromFile);
+            if (hit) return hit;
+        }
+        return null;
     }
 
     // Own-package-name paths (fix #246): integration tests, benches, and
@@ -424,6 +493,28 @@ function resolveRustImport(importPath, fromFile, projectRoot) {
                 if (fallback) return fallback;
             }
         }
+        // Cross-crate WORKSPACE imports (fix #258, clap-measured): a sibling
+        // workspace member's [package] name resolves into that crate's source
+        // tree (`use clap::Command` from clap_bench/, ripgrep's grep-* crates
+        // importing each other). Own-package and 2015-edition child-module
+        // cases are handled above; a name matching this crate's own package
+        // inside src/ never reaches here as a workspace lookup.
+        if (firstSeg && (!cargo || firstSeg !== cargo.packageName)) {
+            // A local child module of the same name wins over a workspace
+            // crate (mod declarations resolve in the plain branch below).
+            const localChild = fs.existsSync(path.join(fromDir, firstSeg + '.rs')) ||
+                fs.existsSync(path.join(fromDir, firstSeg, 'mod.rs'));
+            if (!localChild) {
+                const registry = workspaceCrateRegistry(projectRoot);
+                const member = registry.get(firstSeg);
+                if (member && (!cargo || member.root !== cargo.root)) {
+                    const restSegs = importPath.split('::').slice(1);
+                    const resolved = restSegs.length > 0 ? resolveRustModulePath(member.srcDir, restSegs) : null;
+                    const fallback = resolved || rustModuleOwnFile(member.srcDir, fromFile);
+                    if (fallback) return fallback;
+                }
+            }
+        }
     }
 
     // super:: paths - resolve relative to parent module
@@ -819,5 +910,6 @@ module.exports = {
     extractExports,
     resolveImport,
     resolveFilePath,
+    resolveRustImport,
     findGoModule
 };

package/core/project.js

@@ -79,6 +79,7 @@ class ProjectIndex {
             this._opContentCache = new Map();
             this._opUsagesCache = new Map();
             this._opCallsCountCache = new Map();
+            this._opUsageTotalsCache = new Map();
             this._opEnclosingFnCache = new Map();
             this._opTreeCache = new Map();
             this._opLinesCache = new Map();
@@ -94,6 +95,7 @@ class ProjectIndex {
             this._opContentCache = null;
             this._opUsagesCache = null;
             this._opCallsCountCache = null;
+            this._opUsageTotalsCache = null;
             this._opEnclosingFnCache = null;
             this._opTreeCache = null;
             this._opLinesCache = null;
@@ -314,7 +316,7 @@ class ProjectIndex {
         const disableParallel = workersSetting === 0 || envWorkers === 0;
         let usedParallel = false;
 
-        if (!disableParallel && files.length > 500) {
+        if (!disableParallel && files.length > 150) {
             try {
                 const { parallelBuild } = require('./parallel-build');
                 const result = parallelBuild(this, files, {
@@ -482,7 +484,13 @@ class ProjectIndex {
             // the bare name for the whole file).
             importBindings: imports.flatMap(i => (i.names || [])
                 .filter(n => n && n !== '*' && n !== '_' && n !== '.')
-                .map(n => ({ name: n, module: i.module }))),
+                .map(n => {
+                    // Rename pairing (fix #269): `{ validate: validateSchema }
+                    // = require('./validation')` — the record's local alias
+                    // pins to ITS module, not any module exporting the name.
+                    const rn = (i.renames || []).find(r => r.original === n);
+                    return { name: n, module: i.module, ...(rn && { alias: rn.local }) };
+                })),
             exports: exports.map(e => e.name),
             exportDetails: exports,
             symbols: [],
@@ -541,15 +549,22 @@ class ProjectIndex {
                 // members) — external-contract detection needs the NAME, not
                 // just the traitImpl flag (fix #210).
                 ...(item.traitName && { traitName: item.traitName }),
-                ...(item.isSignature && { isSignature: true })
+                ...(item.isSignature && { isSignature: true }),
+                ...(item.memberAssigned && { memberAssigned: true })
             };
             fileEntry.symbols.push(symbol);
-            fileEntry.bindings.push({
-                id: symbol.bindingId,
-                name: symbol.name,
-                type: symbol.type,
-                startLine: symbol.startLine
-            });
+            // Property-assignment defs (fix #269: Reply.prototype.serialize
+            // = function) declare no lexical name — a bare reference in the
+            // file can never bind them, so they never enter the bindings
+            // table (the symbol stays indexed and method-reachable).
+            if (!item.memberAssigned) {
+                fileEntry.bindings.push({
+                    id: symbol.bindingId,
+                    name: symbol.name,
+                    type: symbol.type,
+                    startLine: symbol.startLine
+                });
+            }
 
             if (!this.symbols.has(item.name)) {
                 this.symbols.set(item.name, []);
@@ -1158,6 +1173,17 @@ class ProjectIndex {
             if (!this.calleeIndex) this.buildCalleeIndex();
             const hasFilters = options.exclude && options.exclude.length > 0;
 
+            // Per-operation memo of the whole fast-path result: the callee
+            // tiebreaker (findCallees priority 6) and reachability BFS ask
+            // for the same (name, defFile) totals thousands of times per
+            // walk. Result objects are read-only by contract.
+            const memoKey = !hasFilters && this._opUsageTotalsCache
+                ? `${name}\0${defFile}` : null;
+            if (memoKey) {
+                const hit = this._opUsageTotalsCache.get(memoKey);
+                if (hit) return hit;
+            }
+
             // Pre-compute which files can reference THIS specific definition
             const importersSet = this.exportGraph.get(defFile) || new Set();
             const defEntry = this.files.get(defFile);
@@ -1231,11 +1257,15 @@ class ProjectIndex {
                     imports++;
                 }
             }
-            // Same-package: files in same directory don't need imports to reference symbols
+            // Same-package: files in same directory don't need imports to
+            // reference symbols. dirToFiles is canonical-ordered — same
+            // iteration order as the full index scan it replaces.
             if (isDirectoryScope) {
                 const pkgDir = defDir;
-                for (const [fp, fe] of this.files) {
-                    if (fp === defFile || !fp.endsWith('.go') || path.dirname(fp) !== pkgDir) continue;
+                for (const fp of this.dirToFiles?.get(pkgDir) || []) {
+                    if (fp === defFile || !fp.endsWith('.go')) continue;
+                    const fe = this.files.get(fp);
+                    if (!fe) continue;
                     if (hasFilters && !this.matchesFilters(fe.relativePath, { exclude: options.exclude })) continue;
                     // Check if already counted as importer
                     if (importersSet.has(fp)) continue;
@@ -1252,7 +1282,9 @@ class ProjectIndex {
             }
 
             const total = calls + definitions + imports;
-            return { total, calls, definitions, imports, references: 0 };
+            const result = { total, calls, definitions, imports, references: 0 };
+            if (memoKey) this._opUsageTotalsCache.set(memoKey, result);
+            return result;
         }
 
         // Detailed path: full AST-based counting (original algorithm)

package/languages/go.js

@@ -678,6 +678,8 @@ function findCallsInCode(code, parser, options = {}) {
     const closureScopes = new Map();
     // Track variable -> type mappings per function scope (scopeStartLine -> Map<varName, typeName>)
     const scopeTypes = new Map();
+    // Names whose scope type is a New*-prefix GUESS (fix #266) — per scope
+    const scopeGuesses = new Map();
     // Track function-typed parameter names per scope (scopeStartLine -> Set<name>)
     const funcParamScopes = new Map();
 
@@ -822,6 +824,21 @@ function findCallsInCode(code, parser, options = {}) {
         }
         return undefined;
     };
+    // Is the FIRST scope-chain hit for this variable a New*-prefix GUESS
+    // (fix #266, viper-measured)? `registry := NewCodecRegistry()` types
+    // registry as 'CodecRegistry' by NAME CONVENTION — the actual return
+    // annotation says *DefaultCodecRegistry. Guess-grade types help
+    // resolution but must never be exclusion evidence; findCallers lets
+    // the compiler-checked return-type flow map override them.
+    const isGuessedType = (varName) => {
+        for (let i = functionStack.length - 1; i >= 0; i--) {
+            const typeMap = scopeTypes.get(functionStack[i].startLine);
+            if (typeMap?.has(varName)) {
+                return !!scopeGuesses.get(functionStack[i].startLine)?.has(varName);
+            }
+        }
+        return false;
+    };
 
     // fix #203 (Go): is a bare-identifier function REFERENCE shadowed by an
     // enclosing func-literal/function parameter, method receiver, range/init
@@ -957,6 +974,7 @@ function findCallsInCode(code, parser, options = {}) {
                     for (let vi = 0; vi < Math.min(names.length, values.length); vi++) {
                         const val = values[vi];
                         let typeName = null;
+                        let typeGuessed = false;
                         // &Type{...} or Type{...}
                         if (val.type === 'composite_literal') {
                             typeName = extractTypeName(val.childForFieldName('type'));
@@ -978,8 +996,14 @@ function findCallsInCode(code, parser, options = {}) {
                                         ? callFuncNode.childForFieldName('field')?.text
                                         : null;
                                 if (callName && /^New[A-Z]/.test(callName)) {
+                                    // NAME CONVENTION, not compiler truth (fix
+                                    // #266): NewCodecRegistry() returns
+                                    // *DefaultCodecRegistry. Marked a guess so
+                                    // the return-type flow map can override it
+                                    // and exclusions never trust it.
                                     typeName = callName.slice(3);
                                     if (!typeName || !/^[A-Z]/.test(typeName)) typeName = null;
+                                    if (typeName) typeGuessed = true;
                                 } else if (callFuncNode.type === 'identifier' &&
                                     callFuncNode.text === 'new') {
                                     // buf := new(bytes.Buffer) — the builtin
@@ -1000,7 +1024,16 @@ function findCallsInCode(code, parser, options = {}) {
                                 }
                             }
                         }
-                        if (typeName) typeMap.set(names[vi], typeName);
+                        if (typeName) {
+                            typeMap.set(names[vi], typeName);
+                            let gset = scopeGuesses.get(scopeKey);
+                            if (typeGuessed) {
+                                if (!gset) { gset = new Set(); scopeGuesses.set(scopeKey, gset); }
+                                gset.add(names[vi]);
+                            } else if (gset) {
+                                gset.delete(names[vi]); // compiler-true retype clears the guess
+                            }
+                        }
                     }
                 }
             }
@@ -1021,7 +1054,10 @@ function findCallsInCode(code, parser, options = {}) {
                     if (!typeName) return;
                     for (let j = 0; j < spec.namedChildCount; j++) {
                         const id = spec.namedChild(j);
-                        if (id.type === 'identifier') varTypeMap.set(id.text, typeName);
+                        if (id.type === 'identifier') {
+                            varTypeMap.set(id.text, typeName);
+                            scopeGuesses.get(scopeKey)?.delete(id.text); // declared type clears any guess
+                        }
                     }
                 };
                 for (let i = 0; i < node.namedChildCount; i++) {
@@ -1150,7 +1186,7 @@ function findCallsInCode(code, parser, options = {}) {
                     // fix #202: one-hop declared-field receivers — h.inner.Run().
                     // receiverRoot/Field/RootType let findCallers hop to the
                     // field's declared struct-field type cross-file.
-                    let receiverRoot, receiverFieldName, receiverRootType;
+                    let receiverRoot, receiverFieldName, receiverRootType, receiverRootTypeGuessed;
                     if (!receiver && operandNode?.type === 'selector_expression') {
                         const rootNode = operandNode.childForFieldName('operand');
                         const fldNode = operandNode.childForFieldName('field');
@@ -1159,6 +1195,9 @@ function findCallsInCode(code, parser, options = {}) {
                             receiverRoot = rootNode.text;
                             receiverFieldName = fldNode.text;
                             receiverRootType = getReceiverType(rootNode.text);
+                            if (receiverRootType && isGuessedType(rootNode.text)) {
+                                receiverRootTypeGuessed = true;
+                            }
                         }
                     }
                     // Chained receiver (fix #220, cobra-measured): the receiver
@@ -1167,16 +1206,22 @@ function findCallsInCode(code, parser, options = {}) {
                     // declared return (*pflag.FlagSet → external → routed).
                     // Package-qualified producers (os.CreateTemp().Name())
                     // carry the qualifier for strict import-package resolution.
-                    let receiverCall, receiverCallIsMethod, receiverCallReceiver;
+                    let receiverCall, receiverCallIsMethod, receiverCallReceiver, receiverCallLine;
                     if (!receiver && !receiverFieldName && operandNode?.type === 'call_expression') {
                         const prodFunc = operandNode.childForFieldName('function');
                         if (prodFunc?.type === 'identifier') {
                             receiverCall = prodFunc.text;
+                            // Producer link (fix #258): plain-call records carry
+                            // the call node's start line
+                            receiverCallLine = operandNode.startPosition.row + 1;
                         } else if (prodFunc?.type === 'selector_expression') {
                             const pf = prodFunc.childForFieldName('field');
                             const po = prodFunc.childForFieldName('operand');
                             if (pf) {
                                 receiverCall = pf.text;
+                                // Selector records report the FIELD's own line
+                                // (fix #223 name-node convention)
+                                receiverCallLine = pf.startPosition.row + 1;
                                 if (po?.type === 'identifier' && importAliases.has(po.text)) {
                                     receiverCallReceiver = po.text;
                                 } else {
@@ -1198,11 +1243,14 @@ function findCallsInCode(code, parser, options = {}) {
                         isMethod: !isPkgCall,
                         receiver,
                         ...(receiverType && { receiverType }),
+                        ...(receiverType && isGuessedType(receiver) && { receiverTypeGuessed: true }),
                         ...(receiverFieldName && { receiverRoot, receiverField: receiverFieldName }),
                         ...(receiverFieldName && receiverRootType && { receiverRootType }),
+                        ...(receiverFieldName && receiverRootType && receiverRootTypeGuessed && { receiverRootTypeGuessed: true }),
                         ...(receiverCall && { receiverCall }),
                         ...(receiverCallIsMethod && { receiverCallIsMethod: true }),
                         ...(receiverCallReceiver && { receiverCallReceiver }),
+                        ...(receiverCallLine && { receiverCallLine }),
                         argCount,
                         ...(argSpread && { argSpread: true }),
                         ...(assigned && { assignedTo: assigned.assignedTo }),
@@ -1282,6 +1330,7 @@ function findCallsInCode(code, parser, options = {}) {
                         isMethod: true,
                         receiver,
                         ...(receiverType && { receiverType }),
+                        ...(receiverType && isGuessedType(receiver) && { receiverTypeGuessed: true }),
                         enclosingFunction,
                         isPotentialCallback: true,
                         uncertain: false
@@ -1337,6 +1386,7 @@ function findCallsInCode(code, parser, options = {}) {
                                 isMethod: true,
                                 receiver,
                                 ...(receiverType && { receiverType }),
+                                ...(receiverType && isGuessedType(receiver) && { receiverTypeGuessed: true }),
                                 enclosingFunction,
                                 isPotentialCallback: true,
                                 uncertain: false
@@ -1431,6 +1481,7 @@ function findCallsInCode(code, parser, options = {}) {
                             isMethod: true,
                             receiver,
                             ...(receiverType && { receiverType }),
+                            ...(receiverType && isGuessedType(receiver) && { receiverTypeGuessed: true }),
                             enclosingFunction,
                             isPotentialCallback: true,
                             uncertain: false,
@@ -1469,6 +1520,7 @@ function findCallsInCode(code, parser, options = {}) {
                 if (leaving) {
                     closureScopes.delete(leaving.startLine);
                     scopeTypes.delete(leaving.startLine);
+                    scopeGuesses.delete(leaving.startLine);
                 }
             }
         }

package/languages/java.js

@@ -1131,11 +1131,14 @@ function findCallsInCode(code, parser) {
                 // 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;
+                let receiverCall, receiverCallIsMethod, receiverCallLine;
                 if (!receiver && !receiverFieldName && objNode?.type === 'method_invocation') {
                     const prodName = objNode.childForFieldName('name');
                     if (prodName) {
                         receiverCall = prodName.text;
+                        // Producer link (fix #258): records report the name
+                        // node's own line
+                        receiverCallLine = prodName.startPosition.row + 1;
                         if (objNode.childForFieldName('object')) receiverCallIsMethod = true;
                     }
                 }
@@ -1155,6 +1158,7 @@ function findCallsInCode(code, parser) {
                     ...(receiverFieldName && receiverRootType && { receiverRootType }),
                     ...(receiverCall && { receiverCall }),
                     ...(receiverCallIsMethod && { receiverCallIsMethod: true }),
+                    ...(receiverCallLine && { receiverCallLine }),
                     argCount: callArgs.argCount,
                     ...(callArgs.argKinds && { argKinds: callArgs.argKinds }),
                     ...(assignedTo && { assignedTo }),