ucn 5.2.1 → 5.2.2

package/languages/go.js

@@ -653,6 +653,8 @@ const GO_BUILTINS = new Set([
  *                             target with its declared return position)
  *   y = q()                → { assignedTo: 'y' } (plain `=` only — `+=` etc.
  *                            don't bind the call's type to the variable)
+ *   var z = q()            → { assignedTo: 'z' } (`var` declarations use
+ *                            repeated AST `name` fields plus a `value` list)
  *   a, b := g(), h()       → parallel assignment: each call pairs with its
  *                            own LHS position, single-value semantics
  * Identifier targets only; blank (`_`) targets return undefined.
@@ -669,18 +671,25 @@ function goAssignmentTargetOf(callNode) {
         }
         n = p; p = n.parent;
     }
-    if (!p || (p.type !== 'short_var_declaration' && p.type !== 'assignment_statement')) return undefined;
+    if (!p || (p.type !== 'short_var_declaration' &&
+        p.type !== 'assignment_statement' && p.type !== 'var_spec')) return undefined;
     if (p.type === 'assignment_statement') {
         const op = p.childForFieldName('operator');
         if (op && op.text !== '=') return undefined;
     }
-    const right = p.childForFieldName('right');
+    const isVarSpec = p.type === 'var_spec';
+    const right = p.childForFieldName(isVarSpec ? 'value' : 'right');
     if (!right || right.id !== n.id) return undefined;
-    const left = p.childForFieldName('left');
-    if (!left) return undefined;
-    const names = left.type === 'expression_list'
-        ? Array.from({ length: left.namedChildCount }, (_, i) => left.namedChild(i))
-        : [left];
+    const left = isVarSpec ? null : p.childForFieldName('left');
+    if (!isVarSpec && !left) return undefined;
+    const names = isVarSpec
+        ? Array.from({ length: p.childCount }, (_, i) => ({
+            child: p.child(i),
+            field: p.fieldNameForChild(i),
+        })).filter(({ field }) => field === 'name').map(({ child }) => child)
+        : left.type === 'expression_list'
+            ? Array.from({ length: left.namedChildCount }, (_, i) => left.namedChild(i))
+            : [left];
     if (rhsCount > 1) {
         const target = names[rhsIndex];
         return target?.type === 'identifier' && target.text !== '_'
@@ -762,6 +771,10 @@ function findCallsInCode(code, parser, options = {}) {
     // types are compiler-true — Go range yields the container's element.
     const scopeContainerTypes = new Map();   // scopeStartLine -> Map<name, typeText>
     const packageContainerTypes = new Map();
+    // Local values bound from an indexed declared field. The file parser may
+    // not own the receiver struct declaration, so preserve its exact root +
+    // field provenance for project-index resolution after all files exist.
+    const scopeIndexedSources = new Map();
     // Track function-typed parameter names per scope (scopeStartLine -> Set<name>)
     const funcParamScopes = new Map();
 
@@ -903,11 +916,24 @@ function findCallsInCode(code, parser, options = {}) {
         return '<anonymous>';
     };
 
-    // Helper to get current enclosing function
-    const getCurrentEnclosingFunction = () => {
-        return functionStack.length > 0
-            ? { ...functionStack[functionStack.length - 1] }
-            : null;
+    // Helper to get current enclosing function. Return-flow assignments are
+    // keyed by function scope, so a captured receiver needs the complete
+    // lexical path back to the scope that binds it. Start at the binding
+    // scope (rather than every outer function) so a parameter/local that
+    // shadows the same name cannot inherit an unrelated outer flow entry.
+    const getCurrentEnclosingFunction = (refNode = null, name = null) => {
+        if (functionStack.length === 0) return null;
+        const allScopes = functionStack.map(scope => scope.startLine);
+        let scopeChain = [allScopes[allScopes.length - 1]];
+        if (refNode && name) {
+            const bindingScope = lexicalBindingScopeStart(refNode, name);
+            const bindingIndex = allScopes.lastIndexOf(bindingScope);
+            if (bindingIndex >= 0) scopeChain = allScopes.slice(bindingIndex);
+        }
+        return {
+            ...functionStack[functionStack.length - 1],
+            scopeChain,
+        };
     };
 
     // Resolve a local closure through the lexical function-scope chain.
@@ -931,21 +957,40 @@ function findCallsInCode(code, parser, options = {}) {
 
     // Look up variable type from scope chain
     const getReceiverType = (varName, refNode) => {
+        const bindingScope = refNode
+            ? lexicalBindingScopeStart(refNode, varName) : null;
         for (let i = functionStack.length - 1; i >= 0; i--) {
-            const typeMap = scopeTypes.get(functionStack[i].startLine);
+            const scopeStart = functionStack[i].startLine;
+            const typeMap = scopeTypes.get(scopeStart);
             if (typeMap?.has(varName)) return typeMap.get(varName);
+            if (bindingScope === scopeStart) return undefined;
         }
         return refNode && isShadowedByLocal(refNode, varName)
             ? undefined : packageTypes.get(varName);
     };
     const getReceiverTypeQualifier = (varName, refNode) => {
+        const bindingScope = refNode
+            ? lexicalBindingScopeStart(refNode, varName) : null;
         for (let i = functionStack.length - 1; i >= 0; i--) {
-            const qualifiers = scopeTypeQualifiers.get(functionStack[i].startLine);
+            const scopeStart = functionStack[i].startLine;
+            const qualifiers = scopeTypeQualifiers.get(scopeStart);
             if (qualifiers?.has(varName)) return qualifiers.get(varName);
+            if (bindingScope === scopeStart) return undefined;
         }
         return refNode && isShadowedByLocal(refNode, varName)
             ? undefined : packageTypeQualifiers.get(varName);
     };
+    const getIndexedSource = (varName, refNode) => {
+        const bindingScope = refNode
+            ? lexicalBindingScopeStart(refNode, varName) : null;
+        for (let i = functionStack.length - 1; i >= 0; i--) {
+            const scopeStart = functionStack[i].startLine;
+            const sources = scopeIndexedSources.get(scopeStart);
+            if (sources?.has(varName)) return sources.get(varName);
+            if (bindingScope === scopeStart) return undefined;
+        }
+        return undefined;
+    };
     // 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(...)`,
@@ -1052,6 +1097,22 @@ function findCallsInCode(code, parser, options = {}) {
         }
         return structFieldsCache;
     };
+    const containerTypeOf = (node) => {
+        if (node?.type === 'selector_expression') {
+            const operand = node.childForFieldName('operand');
+            const field = node.childForFieldName('field');
+            if (operand?.type === 'identifier' && field &&
+                !isGuessedType(operand.text)) {
+                const rootType = getReceiverType(operand.text, operand);
+                if (rootType) {
+                    return getStructFields().get(rootType)?.get(field.text) || null;
+                }
+            }
+        } else if (node?.type === 'identifier') {
+            return lookupContainerType(node.text);
+        }
+        return null;
+    };
 
     // fix #203 (Go): is a bare-identifier function REFERENCE shadowed by an
     // enclosing func-literal/function parameter, method receiver, range/init
@@ -1102,13 +1163,23 @@ function findCallsInCode(code, parser, options = {}) {
         }
         return false;
     };
-    const isShadowedByLocal = (refNode, name) => {
+    const lexicalBindingScopeStart = (refNode, name) => {
+        const owningFunctionStart = (node) => {
+            for (let current = node; current; current = current.parent) {
+                if (isFunctionNode(current)) {
+                    return current.startPosition.row + 1;
+                }
+            }
+            return null;
+        };
         for (let p = refNode.parent; p; p = p.parent) {
             if (p.type === 'block') {
                 for (let i = 0; i < p.namedChildCount; i++) {
                     const stmt = p.namedChild(i);
                     if (stmt.startIndex >= refNode.startIndex) break; // declaration-before-use
-                    if (_declaresLocal(stmt, name, refNode)) return true;
+                    if (_declaresLocal(stmt, name, refNode)) {
+                        return owningFunctionStart(p);
+                    }
                 }
             } else if (p.type === 'for_statement') {
                 for (let i = 0; i < p.namedChildCount; i++) {
@@ -1118,38 +1189,55 @@ function findCallsInCode(code, parser, options = {}) {
                         if (left) {
                             for (let j = 0; j < left.namedChildCount; j++) {
                                 const id = left.namedChild(j);
-                                if (id.type === 'identifier' && id.text === name) return true;
+                                if (id.type === 'identifier' && id.text === name) {
+                                    return owningFunctionStart(p);
+                                }
                             }
                         }
                     } else if (c.type === 'for_clause') {
-                        if (_declaresLocal(c.childForFieldName('initializer'), name, refNode)) return true;
+                        if (_declaresLocal(c.childForFieldName('initializer'), name, refNode)) {
+                            return owningFunctionStart(p);
+                        }
                     }
                 }
             } else if (p.type === 'if_statement' || p.type === 'expression_switch_statement' ||
                 p.type === 'type_switch_statement') {
-                if (_declaresLocal(p.childForFieldName('initializer'), name, refNode)) return true;
+                if (_declaresLocal(p.childForFieldName('initializer'), name, refNode)) {
+                    return owningFunctionStart(p);
+                }
                 // if/switch initializers are plain named children in some
                 // grammar versions; type switches bind `v := x.(type)`
                 for (let i = 0; i < p.namedChildCount; i++) {
                     const c = p.namedChild(i);
-                    if (c.type === 'short_var_declaration' && _declaresLocal(c, name, refNode)) return true;
+                    if (c.type === 'short_var_declaration' &&
+                        _declaresLocal(c, name, refNode)) {
+                        return owningFunctionStart(p);
+                    }
                     if (p.type === 'type_switch_statement' && c.type === 'expression_list' &&
                         c.nextSibling?.type === ':=') {
                         for (let j = 0; j < c.namedChildCount; j++) {
                             const id = c.namedChild(j);
-                            if (id.type === 'identifier' && id.text === name) return true;
+                            if (id.type === 'identifier' && id.text === name) {
+                                return owningFunctionStart(p);
+                            }
                         }
                     }
                 }
             } else if (p.type === 'func_literal' || p.type === 'function_declaration' ||
                 p.type === 'method_declaration') {
-                if (_paramListDeclares(p.childForFieldName('parameters'), name)) return true;
+                if (_paramListDeclares(p.childForFieldName('parameters'), name)) {
+                    return p.startPosition.row + 1;
+                }
                 if (p.type === 'method_declaration' &&
-                    _paramListDeclares(p.childForFieldName('receiver'), name)) return true;
+                    _paramListDeclares(p.childForFieldName('receiver'), name)) {
+                    return p.startPosition.row + 1;
+                }
             }
         }
-        return false;
+        return null;
     };
+    const isShadowedByLocal = (refNode, name) =>
+        lexicalBindingScopeStart(refNode, name) != null;
 
     traverseTree(tree.rootNode, (node) => {
         // Track function entry
@@ -1164,6 +1252,7 @@ function findCallsInCode(code, parser, options = {}) {
             scopeTypes.set(entry.startLine, typeMap);
             scopeTypeQualifiers.set(entry.startLine, typeQualifierMap);
             scopeContainerTypes.set(entry.startLine, containerMap || new Map());
+            scopeIndexedSources.set(entry.startLine, new Map());
             if (funcParamNames.size > 0) {
                 funcParamScopes.set(entry.startLine, funcParamNames);
             }
@@ -1186,21 +1275,7 @@ function findCallsInCode(code, parser, options = {}) {
             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);
+                const el = containerElementType(containerTypeOf(right));
                 if (el) {
                     const scopeKey = functionStack[functionStack.length - 1].startLine;
                     const typeMap = scopeTypes.get(scopeKey);
@@ -1237,6 +1312,7 @@ function findCallsInCode(code, parser, options = {}) {
                         let typeName = null;
                         let typeQualifier = null;
                         let typeGuessed = false;
+                        let indexedSource = null;
                         // &Type{...} or Type{...}
                         if (val.type === 'composite_literal') {
                             const typeNode = val.childForFieldName('type');
@@ -1301,6 +1377,34 @@ function findCallsInCode(code, parser, options = {}) {
                                     }
                                 }
                             }
+                        } else if (val.type === 'index_expression') {
+                            // child, ok := holder.children[key] — map lookup
+                            // and slice/array indexing yield the container's
+                            // declared element type. In a comma-ok lookup the
+                            // first LHS receives the value; the existing
+                            // single-RHS pairing already selects that target.
+                            const container = val.childForFieldName('operand');
+                            const element = containerElementType(containerTypeOf(container));
+                            if (element) {
+                                typeName = element.type;
+                                typeQualifier = element.qualifier;
+                            }
+                            if (container?.type === 'selector_expression') {
+                                const root = container.childForFieldName('operand');
+                                const field = container.childForFieldName('field');
+                                if (root?.type === 'identifier' && field &&
+                                    !isGuessedType(root.text)) {
+                                    const rootType = getReceiverType(root.text, root);
+                                    if (rootType) {
+                                        indexedSource = {
+                                            rootType,
+                                            rootTypeQualifier:
+                                                getReceiverTypeQualifier(root.text, root) || null,
+                                            field: field.text,
+                                        };
+                                    }
+                                }
+                            }
                         } else if (val.type === 'type_assertion_expression') {
                             // d, ok := dialer.(proxy.ContextDialer) — the
                             // asserted type IS d's static type (fix #298,
@@ -1333,6 +1437,9 @@ function findCallsInCode(code, parser, options = {}) {
                                 gset.delete(names[vi]); // compiler-true retype clears the guess
                             }
                         }
+                        const indexedSources = scopeIndexedSources.get(scopeKey);
+                        if (indexedSource) indexedSources?.set(names[vi], indexedSource);
+                        else indexedSources?.delete(names[vi]);
                     }
                 }
             }
@@ -1585,6 +1692,8 @@ function findCallsInCode(code, parser, options = {}) {
                         ? getReceiverType(receiver, operandNode) : undefined;
                     let receiverTypeQualifier = receiverType
                         ? getReceiverTypeQualifier(receiver, operandNode) : undefined;
+                    const receiverIndexedSource = !isPkgCall && receiver && !receiverType
+                        ? getIndexedSource(receiver, operandNode) : undefined;
                     // Composite-literal receiver (fix #298):
                     // (&Kit{...}).Run(...) — compiler-true type, never guessed.
                     if (!receiver && !receiverType) {
@@ -1597,7 +1706,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, receiverRootNode, receiverFieldName, receiverRootType,
                         receiverRootTypeQualifier, receiverRootTypeGuessed,
                         receiverRootIsModule;
                     if (!receiver && operandNode?.type === 'selector_expression') {
@@ -1605,6 +1714,7 @@ function findCallsInCode(code, parser, options = {}) {
                         const fldNode = operandNode.childForFieldName('field');
                         if (rootNode?.type === 'identifier' && fldNode) {
                             receiverRoot = rootNode.text;
+                            receiverRootNode = rootNode;
                             receiverFieldName = fldNode.text;
                             if (importAliases.has(rootNode.text)) {
                                 // Package-owned value receiver:
@@ -1673,6 +1783,13 @@ function findCallsInCode(code, parser, options = {}) {
                         }
                     }
                     const firstArg = getFirstStringArg(node);
+                    const receiverBindingNode = receiver ? operandNode : receiverRootNode;
+                    const receiverBindingName = receiver || receiverRoot;
+                    const methodEnclosingFunction = !isPkgCall &&
+                        receiverBindingNode && receiverBindingName
+                        ? getCurrentEnclosingFunction(
+                            receiverBindingNode, receiverBindingName)
+                        : enclosingFunction;
                     calls.push({
                         name: fieldNode.text,
                         // Name-node line convention (#201/RUST-2, fix #223):
@@ -1690,6 +1807,14 @@ function findCallsInCode(code, parser, options = {}) {
                         ...(receiverType && { receiverType }),
                         ...(receiverTypeQualifier && { receiverTypeQualifier }),
                         ...(receiverType && isGuessedType(receiver) && { receiverTypeGuessed: true }),
+                        ...(receiverIndexedSource && {
+                            receiverIndexRootType: receiverIndexedSource.rootType,
+                            receiverIndexField: receiverIndexedSource.field,
+                            ...(receiverIndexedSource.rootTypeQualifier && {
+                                receiverIndexRootTypeQualifier:
+                                    receiverIndexedSource.rootTypeQualifier,
+                            }),
+                        }),
                         ...(receiverFieldName && { receiverRoot, receiverField: receiverFieldName }),
                         ...(receiverRootIsModule && { receiverRootIsModule: true }),
                         ...(receiverFieldName && receiverRootType && { receiverRootType }),
@@ -1716,7 +1841,7 @@ function findCallsInCode(code, parser, options = {}) {
                             assignedTupleTargets: assigned.assignedTupleTargets,
                         }),
                         ...(assigned?.assignedTupleRest && { assignedTupleRest: assigned.assignedTupleRest }),
-                        enclosingFunction,
+                        enclosingFunction: methodEnclosingFunction,
                         uncertain,
                         ...(firstArg && { firstStringArg: firstArg.value, firstStringArgInterp: firstArg.interp })
                     });
@@ -1796,7 +1921,9 @@ function findCallsInCode(code, parser, options = {}) {
                             receiverTypeQualifier = lit.receiverTypeQualifier;
                         }
                     }
-                    const enclosingFunction = getCurrentEnclosingFunction();
+                    const enclosingFunction = receiver
+                        ? getCurrentEnclosingFunction(operandNode, receiver)
+                        : getCurrentEnclosingFunction();
                     calls.push({
                         name: fieldNode.text,
                         line: fieldNode.startPosition.row + 1,
@@ -2070,6 +2197,7 @@ function findCallsInCode(code, parser, options = {}) {
                     closureScopes.delete(leaving.startLine);
                     scopeTypes.delete(leaving.startLine);
                     scopeGuesses.delete(leaving.startLine);
+                    scopeIndexedSources.delete(leaving.startLine);
                 }
             }
         }