ucn 5.1.1 → 5.2.0

package/languages/go.js

@@ -227,6 +227,11 @@ function _processClass(node, types, processedRanges, lines) {
 
                 const embeddedBases = members
                     .filter(m => m.embedded)
+                    // The inheritance graph is keyed by project type names.
+                    // Keep the historical bare name here so promoted methods
+                    // remain connected; the field symbol separately retains
+                    // the qualified authored type (`io.Reader`) for consumers
+                    // which must distinguish an open external method set.
                     .map(m => m.name);
 
                 types.push({
@@ -641,9 +646,11 @@ const GO_BUILTINS = new Set([
 /**
  * Variable receiving this call's result (fix #207 return-type flow):
  *   bb := balancer.Get(n)  → { assignedTo: 'bb' }
- *   x, err := pkg.Make()   → { assignedTo: 'x', assignedTuple: true }
- *                            (tuple unpack — the flow map pairs the first
- *                             return element with the first variable)
+ *   x, err := pkg.Make()   → { assignedTo: 'x', assignedTuple: true,
+ *                              assignedTupleTargets: [{name:'x', index:0},
+ *                                                     {name:'err', index:1}] }
+ *                            (tuple unpack — the flow map pairs every named
+ *                             target with its declared return position)
  *   y = q()                → { assignedTo: 'y' } (plain `=` only — `+=` etc.
  *                            don't bind the call's type to the variable)
  *   a, b := g(), h()       → parallel assignment: each call pairs with its
@@ -679,19 +686,24 @@ function goAssignmentTargetOf(callNode) {
         return target?.type === 'identifier' && target.text !== '_'
             ? { assignedTo: target.text } : undefined;
     }
-    const target = names[0];
-    if (target?.type !== 'identifier' || target.text === '_') return undefined;
     if (names.length > 1) {
-        // All LHS names (fix #220): an EXTERNAL producer decides every tuple
-        // element's type, not just the first — `tmpFile, err := os.CreateTemp`
-        // marks err external-flow too. The TYPED flow keeps pairing only
-        // element 0 with the producer's return tuple (#207).
-        const rest = names.slice(1)
-            .filter(t => t.type === 'identifier' && t.text !== '_')
-            .map(t => t.text);
-        return { assignedTo: target.text, assignedTuple: true,
-            ...(rest.length > 0 && { assignedTupleRest: rest }) };
+        const targets = names
+            .map((item, index) => ({ item, index }))
+            .filter(({ item }) => item.type === 'identifier' && item.text !== '_')
+            .map(({ item, index }) => ({ name: item.text, index }));
+        if (targets.length === 0) return undefined;
+        const [target, ...restTargets] = targets;
+        const rest = restTargets.map(item => item.name);
+        return {
+            assignedTo: target.name,
+            assignedTuple: true,
+            assignedTupleIndex: target.index,
+            assignedTupleTargets: targets,
+            ...(rest.length > 0 && { assignedTupleRest: rest }),
+        };
     }
+    const target = names[0];
+    if (target?.type !== 'identifier' || target.text === '_') return undefined;
     return { assignedTo: target.text };
 }
 
@@ -727,7 +739,10 @@ function findCallsInCode(code, parser, options = {}) {
     };
     // Skip common non-function identifiers when detecting callback arguments
     const GO_SKIP_IDENTS = new Set(['nil', 'true', 'false', 'err', 'ctx', 'context', 'iota']);
-    // Track local closure names per function scope (scopeStartLine -> Set<name>)
+    // Track local closures per function scope. The declared result belongs
+    // to the lexical value (not to a package-level function with the same
+    // name), but it is still compiler-grade assignment-flow evidence.
+    // scopeStartLine -> Map<name, { returnType?: string }>
     const closureScopes = new Map();
     // Track variable -> type mappings per function scope (scopeStartLine -> Map<varName, typeName>)
     const scopeTypes = new Map();
@@ -741,6 +756,12 @@ function findCallsInCode(code, parser, options = {}) {
     const packageTypeQualifiers = new Map();
     // Names whose scope type is a New*-prefix GUESS (fix #266) — per scope
     const scopeGuesses = new Map();
+    // Container-typed variables (slice/map/array declared TYPE TEXT) for
+    // range-element typing (fix #300, mux-measured): `for _, route := range
+    // r.routes` types route from the field's declared []*Route. Element
+    // types are compiler-true — Go range yields the container's element.
+    const scopeContainerTypes = new Map();   // scopeStartLine -> Map<name, typeText>
+    const packageContainerTypes = new Map();
     // Track function-typed parameter names per scope (scopeStartLine -> Set<name>)
     const funcParamScopes = new Map();
 
@@ -804,6 +825,7 @@ function findCallsInCode(code, parser, options = {}) {
         const typeMap = new Map();
         const typeQualifierMap = new Map();
         const funcParamNames = new Set();
+        const containerMap = new Map();
 
         // Method receiver: func (f *Framework) Method()
         if (node.type === 'method_declaration') {
@@ -844,6 +866,10 @@ function findCallsInCode(code, parser, options = {}) {
                     if (nameNodes.length === 0) continue;
                     if (typeNode.type === 'function_type') {
                         for (const nn of nameNodes) funcParamNames.add(nn.text);
+                    } else if (CONTAINER_TYPE_NODES.has(typeNode.type)) {
+                        // Container-typed parameter (fix #300): the range
+                        // VALUE var over it gets the element type.
+                        for (const nn of nameNodes) containerMap.set(nn.text, typeNode.text);
                     } else {
                         const typeName = extractTypeName(typeNode);
                         if (typeName) {
@@ -858,7 +884,7 @@ function findCallsInCode(code, parser, options = {}) {
             }
         }
 
-        return { typeMap, typeQualifierMap, funcParamNames };
+        return { typeMap, typeQualifierMap, funcParamNames, containerMap };
     };
 
     // Helper to extract function name from a function node
@@ -884,13 +910,13 @@ function findCallsInCode(code, parser, options = {}) {
             : null;
     };
 
-    // Check if current scope has a local closure with the given name
-    const isLocalClosure = (name) => {
+    // Resolve a local closure through the lexical function-scope chain.
+    const getLocalClosure = (name) => {
         for (let i = functionStack.length - 1; i >= 0; i--) {
             const scope = closureScopes.get(functionStack[i].startLine);
-            if (scope?.has(name)) return true;
+            if (scope?.has(name)) return scope.get(name);
         }
-        return false;
+        return null;
     };
 
     // Check if name is a function-typed parameter (e.g., match func(Object) bool)
@@ -920,6 +946,37 @@ function findCallsInCode(code, parser, options = {}) {
         return refNode && isShadowedByLocal(refNode, varName)
             ? undefined : packageTypeQualifiers.get(varName);
     };
+    // Compiler-true receiver type from a composite-literal receiver
+    // expression (fix #298, websocket-measured — the #220(7) typing-sources
+    // family): `(&Kit{...}).Run`, `(&net.Dialer{}).DialContext(...)`,
+    // `Kit{}.Walk(...)`. Unwraps parens and the & — the literal's TYPE is the
+    // receiver's dynamic type. Anonymous types (slice/map/array/struct
+    // literals) return null: they never receive project methods.
+    const literalReceiverInfo = (operandNode) => {
+        let n = operandNode;
+        if (n?.type === 'parenthesized_expression') {
+            n = n.namedChildCount > 0 ? n.namedChild(0) : null;
+        }
+        if (n?.type === 'unary_expression') {
+            n = n.namedChildCount > 0 ? n.namedChild(0) : null;
+        }
+        if (!n || n.type !== 'composite_literal') return null;
+        let typeNode = n.childForFieldName('type');
+        if (typeNode?.type === 'generic_type') {
+            typeNode = typeNode.namedChildCount > 0 ? typeNode.namedChild(0) : null;
+        }
+        if (typeNode?.type === 'qualified_type') {
+            const pkg = typeNode.childForFieldName('package')?.text;
+            const name = typeNode.childForFieldName('name')?.text;
+            return name
+                ? { receiverType: name, ...(pkg && { receiverTypeQualifier: pkg }) }
+                : null;
+        }
+        if (typeNode?.type === 'type_identifier') {
+            return { receiverType: typeNode.text };
+        }
+        return null;
+    };
     // 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
@@ -935,6 +992,66 @@ function findCallsInCode(code, parser, options = {}) {
         }
         return false;
     };
+    // Range-element typing helpers (fix #300). Container type TEXT for a
+    // variable declared as a slice/map/array; element extraction from that
+    // text; and a lazily built same-file struct→fields map so a selector
+    // iterable (`range r.routes`) resolves through the receiver's struct.
+    const lookupContainerType = (varName) => {
+        for (let i = functionStack.length - 1; i >= 0; i--) {
+            const m = scopeContainerTypes.get(functionStack[i].startLine);
+            if (m?.has(varName)) return m.get(varName);
+        }
+        return packageContainerTypes.get(varName);
+    };
+    const CONTAINER_TYPE_NODES = new Set(['slice_type', 'map_type', 'array_type']);
+    const containerElementType = (typeText) => {
+        if (!typeText) return null;
+        const t = String(typeText).trim();
+        let m = t.match(/^\[\d*\]\s*(.+)$/s);          // []T and [N]T
+        if (!m) m = t.match(/^map\[[^\]]+\]\s*(.+)$/s); // map[K]V → V
+        if (!m) return null;
+        const el = m[1].trim().replace(/^\*/, '').trim();
+        const qm = el.match(/^([A-Za-z_]\w*)\.([A-Za-z_]\w*)$/);
+        if (qm) return { type: qm[2], qualifier: qm[1] };
+        return /^[A-Za-z_]\w*$/.test(el) ? { type: el, qualifier: null } : null;
+    };
+    let structFieldsCache = null;
+    const getStructFields = () => {
+        if (structFieldsCache) return structFieldsCache;
+        structFieldsCache = new Map();
+        const stack = [tree.rootNode];
+        while (stack.length > 0) {
+            const n = stack.pop();
+            if (n.type === 'type_declaration') {
+                for (let i = 0; i < n.namedChildCount; i++) {
+                    const spec = n.namedChild(i);
+                    if (spec.type !== 'type_spec') continue;
+                    const nameNode = spec.childForFieldName('name');
+                    const typeNode = spec.childForFieldName('type');
+                    if (!nameNode || typeNode?.type !== 'struct_type') continue;
+                    const fields = new Map();
+                    for (let j = 0; j < typeNode.namedChildCount; j++) {
+                        const list = typeNode.namedChild(j);
+                        if (list.type !== 'field_declaration_list') continue;
+                        for (let k = 0; k < list.namedChildCount; k++) {
+                            const fd = list.namedChild(k);
+                            if (fd.type !== 'field_declaration') continue;
+                            const ftype = fd.childForFieldName('type');
+                            if (!ftype) continue;
+                            for (let x = 0; x < fd.namedChildCount; x++) {
+                                const fn = fd.namedChild(x);
+                                if (fn.type === 'field_identifier') fields.set(fn.text, ftype.text);
+                            }
+                        }
+                    }
+                    structFieldsCache.set(nameNode.text, fields);
+                }
+                continue;
+            }
+            for (let i = 0; i < n.namedChildCount; i++) stack.push(n.namedChild(i));
+        }
+        return structFieldsCache;
+    };
 
     // fix #203 (Go): is a bare-identifier function REFERENCE shadowed by an
     // enclosing func-literal/function parameter, method receiver, range/init
@@ -1043,14 +1160,61 @@ function findCallsInCode(code, parser, options = {}) {
                 endLine: node.endPosition.row + 1
             };
             functionStack.push(entry);
-            const { typeMap, typeQualifierMap, funcParamNames } = buildScopeTypeMap(node);
+            const { typeMap, typeQualifierMap, funcParamNames, containerMap } = buildScopeTypeMap(node);
             scopeTypes.set(entry.startLine, typeMap);
             scopeTypeQualifiers.set(entry.startLine, typeQualifierMap);
+            scopeContainerTypes.set(entry.startLine, containerMap || new Map());
             if (funcParamNames.size > 0) {
                 funcParamScopes.set(entry.startLine, funcParamNames);
             }
         }
 
+        // Range-element typing (fix #300, mux-measured): `for _, route :=
+        // range r.routes` — the VALUE variable's compile-time type is the
+        // container's element type. Sources: a selector iterable whose root
+        // is a typed var and whose field's declaring struct lives in this
+        // file (declared field text `[]*Route`), or an identifier iterable
+        // declared/parameterized with a container type. Only the two-var
+        // form's SECOND variable is typed (single-var range yields the
+        // index/key); untypeable shapes stay untyped — never guessed.
+        if (node.type === 'range_clause' && functionStack.length > 0) {
+            const left = node.childForFieldName('left');
+            const right = node.childForFieldName('right');
+            const vars = left && left.type === 'expression_list'
+                ? Array.from({ length: left.namedChildCount }, (_, i) => left.namedChild(i))
+                : [];
+            const valueVar = vars.length === 2 && vars[1].type === 'identifier' &&
+                vars[1].text !== '_' ? vars[1].text : null;
+            if (valueVar && right) {
+                let containerText = null;
+                if (right.type === 'selector_expression') {
+                    const operand = right.childForFieldName('operand');
+                    const fieldN = right.childForFieldName('field');
+                    if (operand?.type === 'identifier' && fieldN &&
+                        !isGuessedType(operand.text)) {
+                        const rootType = getReceiverType(operand.text, operand);
+                        if (rootType) {
+                            containerText = getStructFields().get(rootType)?.get(fieldN.text) || null;
+                        }
+                    }
+                } else if (right.type === 'identifier') {
+                    containerText = lookupContainerType(right.text);
+                }
+                const el = containerElementType(containerText);
+                if (el) {
+                    const scopeKey = functionStack[functionStack.length - 1].startLine;
+                    const typeMap = scopeTypes.get(scopeKey);
+                    if (typeMap) {
+                        typeMap.set(valueVar, el.type);
+                        const qualifiers = scopeTypeQualifiers.get(scopeKey);
+                        if (el.qualifier) qualifiers?.set(valueVar, el.qualifier);
+                        else qualifiers?.delete(valueVar);
+                        scopeGuesses.get(scopeKey)?.delete(valueVar);
+                    }
+                }
+            }
+        }
+
         // Track local variable types from composite literals and typed assignments
         // e.g., s := &Status{...} → s has type Status
         //        registry := Registry{...} → registry has type Registry
@@ -1076,6 +1240,13 @@ function findCallsInCode(code, parser, options = {}) {
                         // &Type{...} or Type{...}
                         if (val.type === 'composite_literal') {
                             const typeNode = val.childForFieldName('type');
+                            if (typeNode && CONTAINER_TYPE_NODES.has(typeNode.type)) {
+                                // xs := []*Route{...} — container literal
+                                // feeds range-element typing (fix #300).
+                                scopeContainerTypes.get(scopeKey)
+                                    ?.set(names[vi], typeNode.text);
+                                continue;
+                            }
                             typeName = extractTypeName(typeNode);
                             typeQualifier = extractTypeQualifier(typeNode);
                         } else if (val.type === 'unary_expression' && val.childCount > 0) {
@@ -1130,6 +1301,24 @@ function findCallsInCode(code, parser, options = {}) {
                                     }
                                 }
                             }
+                        } else if (val.type === 'type_assertion_expression') {
+                            // d, ok := dialer.(proxy.ContextDialer) — the
+                            // asserted type IS d's static type (fix #298,
+                            // websocket-measured: `return d.DialContext, nil`
+                            // through the assertion). Compiler-true.
+                            const typeNode = val.childForFieldName('type');
+                            typeName = extractTypeName(typeNode);
+                            typeQualifier = extractTypeQualifier(typeNode);
+                        } else if (val.type === 'identifier') {
+                            // Var-copy: d := cstDialer — Go is statically
+                            // typed, so the copy shares the source variable's
+                            // type (fix #298; guess-ness propagates).
+                            typeName = getReceiverType(val.text, val) || null;
+                            if (typeName) {
+                                typeQualifier =
+                                    getReceiverTypeQualifier(val.text, val) || null;
+                                typeGuessed = isGuessedType(val.text);
+                            }
                         }
                         if (typeName) {
                             typeMap.set(names[vi], typeName);
@@ -1161,11 +1350,46 @@ function findCallsInCode(code, parser, options = {}) {
             const varQualifierMap = scopeKey == null
                 ? packageTypeQualifiers : scopeTypeQualifiers.get(scopeKey);
             if (varTypeMap) {
+                const varContainerMap = scopeKey == null
+                    ? packageContainerTypes : scopeContainerTypes.get(scopeKey);
                 const recordSpec = (spec) => {
                     if (spec.type !== 'var_spec') return;
-                    const typeName = extractTypeName(spec.childForFieldName('type'));
-                    if (!typeName) return;
-                    const qualifier = extractTypeQualifier(spec.childForFieldName('type'));
+                    const declaredType = spec.childForFieldName('type');
+                    // Container-typed declaration (fix #300): `var routes
+                    // []*Route` feeds range-element typing.
+                    if (declaredType && CONTAINER_TYPE_NODES.has(declaredType.type) &&
+                        varContainerMap) {
+                        for (let j = 0; j < spec.namedChildCount; j++) {
+                            const id = spec.namedChild(j);
+                            if (id.type === 'identifier') {
+                                varContainerMap.set(id.text, declaredType.text);
+                            }
+                        }
+                        return;
+                    }
+                    let typeName = extractTypeName(spec.childForFieldName('type'));
+                    let qualifier = typeName
+                        ? extractTypeQualifier(spec.childForFieldName('type')) : null;
+                    if (!typeName) {
+                        // var cstDialer = Dialer{...} — the initializer's
+                        // composite-literal type IS the variable's type
+                        // (fix #298, websocket-measured: `d := cstDialer`
+                        // copies then call DialContext). Single-value specs
+                        // only; multi-value pairing stays untyped.
+                        const valueNode = spec.childForFieldName('value');
+                        let init = valueNode?.type === 'expression_list' &&
+                            valueNode.namedChildCount === 1
+                            ? valueNode.namedChild(0) : null;
+                        if (init?.type === 'unary_expression') {
+                            init = init.namedChildCount > 0 ? init.namedChild(0) : null;
+                        }
+                        if (init?.type === 'composite_literal') {
+                            const tn = init.childForFieldName('type');
+                            typeName = extractTypeName(tn);
+                            qualifier = extractTypeQualifier(tn);
+                        }
+                        if (!typeName) return;
+                    }
                     for (let j = 0; j < spec.namedChildCount; j++) {
                         const id = spec.namedChild(j);
                         if (id.type === 'identifier') {
@@ -1188,52 +1412,66 @@ function findCallsInCode(code, parser, options = {}) {
             }
         }
 
-        // Track local closures: atoi := func(...) { ... } or var handler = func(...) { ... }
+        // Track local closures: atoi := func(...) { ... } or
+        // var handler = func(...) { ... }. Pair each lexical name with the
+        // literal's declared result so an invocation can type its assignment
+        // without pretending it calls a same-named package symbol.
         if (node.type === 'short_var_declaration' || node.type === 'var_declaration') {
-            // Check if a subtree contains a func_literal
-            const hasFunc = (n) => {
+            const firstFuncLiteral = (n) => {
                 if (!n) return false;
-                if (n.type === 'func_literal') return true;
+                if (n.type === 'func_literal') return n;
                 for (let i = 0; i < n.childCount; i++) {
-                    if (hasFunc(n.child(i))) return true;
+                    const found = firstFuncLiteral(n.child(i));
+                    if (found) return found;
                 }
-                return false;
+                return null;
             };
-            let names = [];
-            if (node.type === 'short_var_declaration') {
-                // short_var_declaration checks the whole RHS
-                if (hasFunc(node)) {
-                    const left = node.childForFieldName('left');
-                    if (left) {
-                        names = left.type === 'expression_list'
-                            ? Array.from({ length: left.namedChildCount }, (_, i) => left.namedChild(i))
-                                  .filter(n => n.type === 'identifier').map(n => n.text)
-                            : left.type === 'identifier' ? [left.text] : [];
-                    }
+            const entries = [];
+            const pairNamesWithValues = (left, right) => {
+                if (!left || !right) return;
+                const names = left.type === 'expression_list'
+                    ? left.namedChildren.filter(child => child.type === 'identifier')
+                    : left.type === 'identifier' ? [left] : [];
+                const values = right.type === 'expression_list'
+                    ? right.namedChildren : [right];
+                for (let i = 0; i < names.length; i++) {
+                    const literal = firstFuncLiteral(values[i] ||
+                        (values.length === 1 ? values[0] : null));
+                    if (literal) entries.push({
+                        name: names[i].text,
+                        returnType: extractReturnType(literal),
+                    });
                 }
+            };
+            if (node.type === 'short_var_declaration') {
+                pairNamesWithValues(
+                    node.childForFieldName('left'),
+                    node.childForFieldName('right'));
             } else {
-                // var_declaration: check per-spec so only names with func_literal values are tracked
+                // var_declaration: check per-spec so only names paired with
+                // func_literal values are tracked.
                 // Handle both: var x = func(){} (var_declaration > var_spec)
                 //          and: var (\n x = func(){} \n) (var_declaration > var_spec_list > var_spec)
-                const collectClosureNames = (parent) => {
+                const collectClosureEntries = (parent) => {
                     for (let i = 0; i < parent.namedChildCount; i++) {
                         const child = parent.namedChild(i);
-                        if (child.type === 'var_spec' && hasFunc(child)) {
-                            const nameNode = child.childForFieldName('name');
-                            if (nameNode && nameNode.type === 'identifier') {
-                                names.push(nameNode.text);
-                            }
+                        if (child.type === 'var_spec') {
+                            pairNamesWithValues(
+                                child.childForFieldName('name'),
+                                child.childForFieldName('value'));
                         } else if (child.type === 'var_spec_list') {
-                            collectClosureNames(child);
+                            collectClosureEntries(child);
                         }
                     }
                 };
-                collectClosureNames(node);
+                collectClosureEntries(node);
             }
-            if (names.length > 0 && functionStack.length > 0) {
+            if (entries.length > 0 && functionStack.length > 0) {
                 const scopeKey = functionStack[functionStack.length - 1].startLine;
-                if (!closureScopes.has(scopeKey)) closureScopes.set(scopeKey, new Set());
-                for (const n of names) closureScopes.get(scopeKey).add(n);
+                if (!closureScopes.has(scopeKey)) closureScopes.set(scopeKey, new Map());
+                for (const entry of entries) {
+                    closureScopes.get(scopeKey).set(entry.name, entry);
+                }
             }
         }
 
@@ -1269,8 +1507,42 @@ function findCallsInCode(code, parser, options = {}) {
                 const callName = funcNode.text;
                 // Skip Go built-in function calls
                 if (GO_BUILTINS.has(callName)) return true;
-                // Skip calls to local closures (they shadow package-level functions)
-                if (isLocalClosure(callName)) return true;
+                // Local closures shadow package-level functions. Keep an
+                // internal-only call record when their declared result can
+                // type an assignment; the sentinel name prevents semantic
+                // caller matching against a package symbol of the same name.
+                const localClosure = getLocalClosure(callName);
+                if (localClosure) {
+                    if (assigned && localClosure.returnType) {
+                        calls.push({
+                            name: '<local-closure>',
+                            localCallName: callName,
+                            localValueCall: true,
+                            returnTypeHint: localClosure.returnType,
+                            line: node.startPosition.row + 1,
+                            column: funcNode.startPosition.column,
+                            callStart: node.startIndex,
+                            callEnd: node.endIndex,
+                            isMethod: false,
+                            argCount,
+                            ...(argSpread && { argSpread: true }),
+                            assignedTo: assigned.assignedTo,
+                            ...(assigned.assignedTuple && { assignedTuple: true }),
+                            ...(assigned.assignedTupleIndex != null && {
+                                assignedTupleIndex: assigned.assignedTupleIndex,
+                            }),
+                            ...(assigned.assignedTupleTargets && {
+                                assignedTupleTargets: assigned.assignedTupleTargets,
+                            }),
+                            ...(assigned.assignedTupleRest && {
+                                assignedTupleRest: assigned.assignedTupleRest,
+                            }),
+                            enclosingFunction,
+                            uncertain: false,
+                        });
+                    }
+                    return true;
+                }
                 // Skip calls to function-typed parameters (e.g., match func(Object) bool)
                 // These are local parameter invocations, not calls to global functions
                 if (isFuncTypedParam(callName)) return true;
@@ -1280,12 +1552,21 @@ function findCallsInCode(code, parser, options = {}) {
                 calls.push({
                     name: callName,
                     line: node.startPosition.row + 1,
+                    column: funcNode.startPosition.column,
+                    callStart: node.startIndex,
+                    callEnd: node.endIndex,
                     isMethod: false,
                     argCount,
                     ...(argSpread && { argSpread: true }),
                     ...(assigned && { assignedTo: assigned.assignedTo }),
                     ...(assigned?.assignedTuple && { assignedTuple: true }),
-                        ...(assigned?.assignedTupleRest && { assignedTupleRest: assigned.assignedTupleRest }),
+                    ...(assigned?.assignedTupleIndex != null && {
+                        assignedTupleIndex: assigned.assignedTupleIndex,
+                    }),
+                    ...(assigned?.assignedTupleTargets && {
+                        assignedTupleTargets: assigned.assignedTupleTargets,
+                    }),
+                    ...(assigned?.assignedTupleRest && { assignedTupleRest: assigned.assignedTupleRest }),
                     enclosingFunction,
                     uncertain,
                     ...(firstArg && { firstStringArg: firstArg.value, firstStringArgInterp: firstArg.interp })
@@ -1300,10 +1581,19 @@ function findCallsInCode(code, parser, options = {}) {
                     // Distinguish pkg.Func() (package-qualified) from obj.Method()
                     // If receiver is a known import alias, this is a package call, not a method call
                     const isPkgCall = receiver && importAliases.has(receiver);
-                    const receiverType = (!isPkgCall && receiver)
+                    let receiverType = (!isPkgCall && receiver)
                         ? getReceiverType(receiver, operandNode) : undefined;
-                    const receiverTypeQualifier = receiverType
+                    let receiverTypeQualifier = receiverType
                         ? getReceiverTypeQualifier(receiver, operandNode) : undefined;
+                    // Composite-literal receiver (fix #298):
+                    // (&Kit{...}).Run(...) — compiler-true type, never guessed.
+                    if (!receiver && !receiverType) {
+                        const lit = literalReceiverInfo(operandNode);
+                        if (lit) {
+                            receiverType = lit.receiverType;
+                            receiverTypeQualifier = lit.receiverTypeQualifier;
+                        }
+                    }
                     // 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.
@@ -1338,14 +1628,34 @@ 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, receiverCallLine;
+                    let receiverCall, receiverCallIsMethod, receiverCallReceiver,
+                        receiverCallLine, receiverCallStart, receiverCallEnd,
+                        receiverCallResultType, receiverCallResultTypeQualifier;
                     if (!receiver && !receiverFieldName && operandNode?.type === 'call_expression') {
                         const prodFunc = operandNode.childForFieldName('function');
+                        receiverCallStart = operandNode.startIndex;
+                        receiverCallEnd = operandNode.endIndex;
                         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;
+                            // Go's builtin new has an exact static result:
+                            // `new(Route)` is `*Route`. The builtin itself is
+                            // intentionally absent from the semantic call
+                            // index, so carry the result type on its consumer.
+                            if (receiverCall === 'new') {
+                                const prodArgs = operandNode.childForFieldName('arguments');
+                                const typeArg = prodArgs?.namedChild(0);
+                                if (typeArg) {
+                                    const authored = typeArg.text.replace(/^\*+/, '').trim();
+                                    const parts = authored.split('.');
+                                    receiverCallResultType = parts.pop();
+                                    if (parts.length > 0) {
+                                        receiverCallResultTypeQualifier = parts.join('.');
+                                    }
+                                }
+                            }
                         } else if (prodFunc?.type === 'selector_expression') {
                             const pf = prodFunc.childForFieldName('field');
                             const po = prodFunc.childForFieldName('operand');
@@ -1372,6 +1682,9 @@ function findCallsInCode(code, parser, options = {}) {
                         // set and the oracles key by the name's line; Go was
                         // the only parser still using the call node's start.
                         line: fieldNode.startPosition.row + 1,
+                        column: fieldNode.startPosition.column,
+                        callStart: node.startIndex,
+                        callEnd: node.endIndex,
                         isMethod: !isPkgCall,
                         receiver,
                         ...(receiverType && { receiverType }),
@@ -1386,10 +1699,22 @@ function findCallsInCode(code, parser, options = {}) {
                         ...(receiverCallIsMethod && { receiverCallIsMethod: true }),
                         ...(receiverCallReceiver && { receiverCallReceiver }),
                         ...(receiverCallLine && { receiverCallLine }),
+                        ...(receiverCallStart != null && { receiverCallStart }),
+                        ...(receiverCallEnd != null && { receiverCallEnd }),
+                        ...(receiverCallResultType && { receiverCallResultType }),
+                        ...(receiverCallResultTypeQualifier && {
+                            receiverCallResultTypeQualifier,
+                        }),
                         argCount,
                         ...(argSpread && { argSpread: true }),
                         ...(assigned && { assignedTo: assigned.assignedTo }),
                         ...(assigned?.assignedTuple && { assignedTuple: true }),
+                        ...(assigned?.assignedTupleIndex != null && {
+                            assignedTupleIndex: assigned.assignedTupleIndex,
+                        }),
+                        ...(assigned?.assignedTupleTargets && {
+                            assignedTupleTargets: assigned.assignedTupleTargets,
+                        }),
                         ...(assigned?.assignedTupleRest && { assignedTupleRest: assigned.assignedTupleRest }),
                         enclosingFunction,
                         uncertain,
@@ -1437,6 +1762,7 @@ function findCallsInCode(code, parser, options = {}) {
                     calls.push({
                         name: typeName,
                         line: node.startPosition.row + 1,
+                        column: (typeNode.childForFieldName?.('name') || typeNode).startPosition.column,
                         isMethod: false,
                         isConstructor: true,
                         ...(typeQualifier && { receiver: typeQualifier }),
@@ -1457,19 +1783,29 @@ function findCallsInCode(code, parser, options = {}) {
                 const operandNode = node.childForFieldName('operand');
                 if (fieldNode && operandNode) {
                     const receiver = operandNode.type === 'identifier' ? operandNode.text : undefined;
-                    const receiverType = receiver
+                    let receiverType = receiver
                         ? getReceiverType(receiver, operandNode) : undefined;
-                    const receiverTypeQualifier = receiverType
+                    let receiverTypeQualifier = receiverType
                         ? getReceiverTypeQualifier(receiver, operandNode) : undefined;
+                    // Composite-literal receiver (fix #298): the literal's
+                    // type is compiler-true, never guessed.
+                    if (!receiver && !receiverType) {
+                        const lit = literalReceiverInfo(operandNode);
+                        if (lit) {
+                            receiverType = lit.receiverType;
+                            receiverTypeQualifier = lit.receiverTypeQualifier;
+                        }
+                    }
                     const enclosingFunction = getCurrentEnclosingFunction();
                     calls.push({
                         name: fieldNode.text,
-                        line: node.startPosition.row + 1,
+                        line: fieldNode.startPosition.row + 1,
+                        column: fieldNode.startPosition.column,
                         isMethod: true,
                         receiver,
                         ...(receiverType && { receiverType }),
                         ...(receiverTypeQualifier && { receiverTypeQualifier }),
-                        ...(receiverType && isGuessedType(receiver) && { receiverTypeGuessed: true }),
+                        ...(receiverType && receiver && isGuessedType(receiver) && { receiverTypeGuessed: true }),
                         enclosingFunction,
                         isPotentialCallback: true,
                         uncertain: false
@@ -1487,6 +1823,7 @@ function findCallsInCode(code, parser, options = {}) {
                 calls.push({
                     name,
                     line: node.startPosition.row + 1,
+                    column: node.startPosition.column,
                     isMethod: false,
                     isFunctionReference: true,
                     isPotentialCallback: true,
@@ -1517,19 +1854,28 @@ function findCallsInCode(code, parser, options = {}) {
                         const operandNode = rhs.childForFieldName('operand');
                         if (fieldNode && operandNode) {
                             const receiver = operandNode.type === 'identifier' ? operandNode.text : undefined;
-                            const receiverType = receiver
+                            let receiverType = receiver
                                 ? getReceiverType(receiver, operandNode) : undefined;
-                            const receiverTypeQualifier = receiverType
+                            let receiverTypeQualifier = receiverType
                                 ? getReceiverTypeQualifier(receiver, operandNode) : undefined;
+                            // Composite-literal receiver (fix #298).
+                            if (!receiver && !receiverType) {
+                                const lit = literalReceiverInfo(operandNode);
+                                if (lit) {
+                                    receiverType = lit.receiverType;
+                                    receiverTypeQualifier = lit.receiverTypeQualifier;
+                                }
+                            }
                             const enclosingFunction = getCurrentEnclosingFunction();
                             calls.push({
                                 name: fieldNode.text,
-                                line: rhs.startPosition.row + 1,
+                                line: fieldNode.startPosition.row + 1,
+                                column: fieldNode.startPosition.column,
                                 isMethod: true,
                                 receiver,
                                 ...(receiverType && { receiverType }),
                                 ...(receiverTypeQualifier && { receiverTypeQualifier }),
-                                ...(receiverType && isGuessedType(receiver) && { receiverTypeGuessed: true }),
+                                ...(receiverType && receiver && isGuessedType(receiver) && { receiverTypeGuessed: true }),
                                 enclosingFunction,
                                 isPotentialCallback: true,
                                 uncertain: false
@@ -1544,6 +1890,7 @@ function findCallsInCode(code, parser, options = {}) {
                             calls.push({
                                 name,
                                 line: rhs.startPosition.row + 1,
+                                column: rhs.startPosition.column,
                                 isMethod: false,
                                 isFunctionReference: true,
                                 isPotentialCallback: true,
@@ -1557,6 +1904,51 @@ function findCallsInCode(code, parser, options = {}) {
             }
         }
 
+        // Method values in RETURN position (fix #298, websocket-measured):
+        // `return (&httpProxyDialer{...}).DialContext, nil` is the
+        // compile-breaking reference a rename sweep must see — it was
+        // invisible (no record at all). Selector values only; plain
+        // identifier returns (`return err`) stay unemitted — every returned
+        // variable would join the calls cache (classified-deferred).
+        if (node.type === 'return_statement') {
+            const exprList = node.namedChildCount > 0 ? node.namedChild(0) : null;
+            const values = exprList?.type === 'expression_list'
+                ? exprList.namedChildren
+                : (exprList ? [exprList] : []);
+            for (const val of values) {
+                if (val.type !== 'selector_expression') continue;
+                const fieldNode = val.childForFieldName('field');
+                const operandNode = val.childForFieldName('operand');
+                if (!fieldNode || !operandNode) continue;
+                const receiver = operandNode.type === 'identifier' ? operandNode.text : undefined;
+                let receiverType = receiver
+                    ? getReceiverType(receiver, operandNode) : undefined;
+                let receiverTypeQualifier = receiverType
+                    ? getReceiverTypeQualifier(receiver, operandNode) : undefined;
+                if (!receiver && !receiverType) {
+                    const lit = literalReceiverInfo(operandNode);
+                    if (lit) {
+                        receiverType = lit.receiverType;
+                        receiverTypeQualifier = lit.receiverTypeQualifier;
+                    }
+                }
+                calls.push({
+                    name: fieldNode.text,
+                    // #223 name-node convention: the field's own line.
+                    line: fieldNode.startPosition.row + 1,
+                    column: fieldNode.startPosition.column,
+                    isMethod: true,
+                    receiver,
+                    ...(receiverType && { receiverType }),
+                    ...(receiverTypeQualifier && { receiverTypeQualifier }),
+                    ...(receiverType && receiver && isGuessedType(receiver) && { receiverTypeGuessed: true }),
+                    enclosingFunction: getCurrentEnclosingFunction(),
+                    isPotentialCallback: true,
+                    uncertain: false
+                });
+            }
+        }
+
         // Detect function references in composite literal fields:
         // ResourceEventHandlerFuncs{AddFunc: addNodeToCache, UpdateFunc: updateNode}
         // keyed_element → literal_element(key) ":" literal_element(value)
@@ -1600,6 +1992,7 @@ function findCallsInCode(code, parser, options = {}) {
                         calls.push({
                             name,
                             line: valueNode.startPosition.row + 1,
+                            column: valueNode.startPosition.column,
                             isMethod: false,
                             isFunctionReference: true,
                             isPotentialCallback: true,
@@ -1616,19 +2009,28 @@ function findCallsInCode(code, parser, options = {}) {
                     const operandNode = valueNode.childForFieldName('operand');
                     if (fieldNode && operandNode) {
                         const receiver = operandNode.type === 'identifier' ? operandNode.text : undefined;
-                        const receiverType = receiver
+                        let receiverType = receiver
                             ? getReceiverType(receiver, operandNode) : undefined;
-                        const receiverTypeQualifier = receiverType
+                        let receiverTypeQualifier = receiverType
                             ? getReceiverTypeQualifier(receiver, operandNode) : undefined;
+                        // Composite-literal receiver (fix #298).
+                        if (!receiver && !receiverType) {
+                            const lit = literalReceiverInfo(operandNode);
+                            if (lit) {
+                                receiverType = lit.receiverType;
+                                receiverTypeQualifier = lit.receiverTypeQualifier;
+                            }
+                        }
                         const enclosingFunction = getCurrentEnclosingFunction();
                         calls.push({
                             name: fieldNode.text,
-                            line: valueNode.startPosition.row + 1,
+                            line: fieldNode.startPosition.row + 1,
+                            column: fieldNode.startPosition.column,
                             isMethod: true,
                             receiver,
                             ...(receiverType && { receiverType }),
                             ...(receiverTypeQualifier && { receiverTypeQualifier }),
-                            ...(receiverType && isGuessedType(receiver) && { receiverTypeGuessed: true }),
+                            ...(receiverType && receiver && isGuessedType(receiver) && { receiverTypeGuessed: true }),
                             enclosingFunction,
                             isPotentialCallback: true,
                             uncertain: false,