ucn 3.7.46 → 3.7.47

package/core/stacktrace.js

@@ -293,7 +293,8 @@ function parseStackTrace(index, stackText) {
         // Go: "file.go:line" or "package/file.go:line +0x..."
         { regex: /^\s*([^\s:]+\.go):(\d+)(?:\s|$)/, extract: (m) => ({ file: m[1], line: parseInt(m[2]), funcName: null, col: null }) },
         // Go with function: "package.FunctionName()\n\tfile.go:line"
-        { regex: /^\s*([^\s(]+)\(\)$/, extract: null }, // Skip function-only lines
+        // Also handles method syntax: "package.(*Type).Method(...)"
+        { regex: /^\s*((?:[^\s(]|\([^)]*\))+)\(.*\)$/, extract: null }, // Skip function-only lines
         // Java: "at package.Class.method(File.java:line)"
         { regex: /at\s+([^\(]+)\(([^:]+):(\d+)\)/, extract: (m) => ({ funcName: m[1].split('.').pop(), file: m[2], line: parseInt(m[3]), col: null }) },
         // Rust: "at src/main.rs:line:col" or panic location
@@ -302,16 +303,40 @@ function parseStackTrace(index, stackText) {
         { regex: /([^\s:]+\.\w+):(\d+)(?::(\d+))?/, extract: (m) => ({ file: m[1], line: parseInt(m[2]), col: m[3] ? parseInt(m[3]) : null, funcName: null }) }
     ];
 
+    // Track Go function names that appear on a line before the file:line
+    let pendingGoFuncName = null;
+
     for (const line of lines) {
         const trimmed = line.trim();
         if (!trimmed) continue;
 
         // Try each pattern until one matches
+        let matched = false;
         for (const pattern of patterns) {
             const match = pattern.regex.exec(trimmed);
-            if (match && pattern.extract) {
+            if (match) {
+                if (pattern.extract === null) {
+                    // Go function-only line (e.g. "package.FunctionName()")
+                    // Extract the function name and carry it forward to the next file:line
+                    const fullName = match[1];
+                    // Go uses fully-qualified names: pkg/path.FuncName or pkg/path.(*Type).Method
+                    const lastDot = fullName.lastIndexOf('.');
+                    pendingGoFuncName = lastDot >= 0 ? fullName.slice(lastDot + 1) : fullName;
+                    // Strip Go method receiver syntax: (*Type).Method → Method
+                    if (pendingGoFuncName.startsWith('(*')) {
+                        const parenClose = pendingGoFuncName.indexOf(').');
+                        if (parenClose >= 0) pendingGoFuncName = pendingGoFuncName.slice(parenClose + 2);
+                    }
+                    matched = true;
+                    break;
+                }
                 const extracted = pattern.extract(match);
                 if (extracted && extracted.file && extracted.line) {
+                    // Use pending Go function name if no function name extracted
+                    if (!extracted.funcName && pendingGoFuncName) {
+                        extracted.funcName = pendingGoFuncName;
+                    }
+                    pendingGoFuncName = null;
                     frames.push(createStackFrame(
                         index,
                         extracted.file,
@@ -320,10 +345,14 @@ function parseStackTrace(index, stackText) {
                         extracted.col,
                         trimmed
                     ));
+                    matched = true;
                     break; // Move to next line
                 }
             }
         }
+        if (!matched) {
+            pendingGoFuncName = null; // Reset if line doesn't match any pattern
+        }
     }
 
     return {

package/core/verify.js

@@ -301,6 +301,8 @@ function verify(index, name, options = {}) {
     // and the function lives in jobs.py).
     const defIsMethod = !!(def.isMethod || def.type === 'method' || def.className);
     const targetBasename = path.basename(def.file, path.extname(def.file));
+    const defFileEntry = index.files.get(def.file);
+    const defLang = defFileEntry?.language;
 
     // Build import-name lookup for receiver checking (module.func() vs dict.get())
     const importNameCache = new Map();
@@ -337,6 +339,15 @@ function verify(index, name, options = {}) {
                 const importedNames = getImportedNames(call.file);
                 if (!importedNames.has(callReceiver)) continue;
                 // Receiver matches target module and is imported — keep it
+            } else if (callReceiver && defLang === 'go') {
+                // Go: receiver is package alias (last segment of import path, e.g., "controller"
+                // from "k8s.io/.../pkg/controller"), not the filename ("controller_utils").
+                // Check if receiver matches the directory name of the target file.
+                const targetDir = path.basename(path.dirname(def.file));
+                if (callReceiver !== targetDir) {
+                    continue;
+                }
+                // Receiver matches package directory — keep it
             } else {
                 continue;
             }

package/languages/go.js

@@ -247,6 +247,23 @@ function extractStructFields(structNode, code) {
                     memberType: 'field',
                     ...(typeNode && { fieldType: typeNode.text })
                 });
+            } else if (typeNode) {
+                // Embedded field: has type but no name (e.g., `Base` in `type Child struct { Base; Name string }`)
+                // Use the type name as the field name
+                let embeddedName = typeNode.text;
+                // Strip pointer prefix: *Base → Base
+                if (embeddedName.startsWith('*')) embeddedName = embeddedName.slice(1);
+                // Strip package prefix: pkg.Base → Base
+                const dotIdx = embeddedName.indexOf('.');
+                if (dotIdx >= 0) embeddedName = embeddedName.slice(dotIdx + 1);
+                fields.push({
+                    name: embeddedName,
+                    startLine,
+                    endLine,
+                    memberType: 'field',
+                    embedded: true,
+                    fieldType: typeNode.text
+                });
             }
         }
     }
@@ -268,11 +285,13 @@ function extractInterfaceMembers(interfaceNode, code) {
             let nameText = null;
             let paramsText = null;
             let returnType = null;
+            let hasParams = false;
             for (let j = 0; j < child.namedChildCount; j++) {
                 const sub = child.namedChild(j);
                 if (sub.type === 'field_identifier' || sub.type === 'type_identifier') {
                     if (!nameText) nameText = sub.text;
                 } else if (sub.type === 'parameter_list') {
+                    hasParams = true;
                     if (!paramsText) {
                         paramsText = sub.text.slice(1, -1); // strip parens
                     } else {
@@ -296,14 +315,63 @@ function extractInterfaceMembers(interfaceNode, code) {
                 }
             }
             if (nameText) {
-                members.push({
-                    name: nameText,
-                    startLine,
-                    endLine,
-                    memberType: 'method',
-                    ...(paramsText !== null && { params: paramsText }),
-                    ...(returnType && { returnType })
-                });
+                // Distinguish between method signatures and embedded interfaces:
+                // method_elem with parameter_list → method
+                // method_elem with only type_identifier → embedded interface
+                if (!hasParams && child.namedChildCount === 1 && child.namedChild(0).type === 'type_identifier') {
+                    // Embedded interface
+                    members.push({
+                        name: nameText,
+                        startLine,
+                        endLine,
+                        memberType: 'field',
+                        embedded: true,
+                        fieldType: nameText
+                    });
+                } else {
+                    members.push({
+                        name: nameText,
+                        startLine,
+                        endLine,
+                        memberType: 'method',
+                        ...(paramsText !== null && { params: paramsText }),
+                        ...(returnType && { returnType })
+                    });
+                }
+            }
+        } else if (child.type === 'type_identifier' || child.type === 'qualified_type') {
+            // Standalone type identifier inside interface body — embedded interface
+            const { startLine, endLine } = nodeToLocation(child, code);
+            let embName = child.text;
+            const dotIdx = embName.indexOf('.');
+            if (dotIdx >= 0) embName = embName.slice(dotIdx + 1);
+            members.push({
+                name: embName,
+                startLine,
+                endLine,
+                memberType: 'field',
+                embedded: true,
+                fieldType: child.text
+            });
+        } else if (child.type === 'type_elem') {
+            // type_elem wrapping a type_identifier — embedded interface
+            // e.g., `Reader` in `type ReadWriter interface { Reader; Write(...) }`
+            for (let j = 0; j < child.namedChildCount; j++) {
+                const sub = child.namedChild(j);
+                if (sub.type === 'type_identifier' || sub.type === 'qualified_type') {
+                    const { startLine, endLine } = nodeToLocation(sub, code);
+                    let embName = sub.text;
+                    const dotIdx = embName.indexOf('.');
+                    if (dotIdx >= 0) embName = embName.slice(dotIdx + 1);
+                    members.push({
+                        name: embName,
+                        startLine,
+                        endLine,
+                        memberType: 'field',
+                        embedded: true,
+                        fieldType: sub.text
+                    });
+                }
             }
         }
     }
@@ -318,6 +386,8 @@ function findStateObjects(code, parser) {
     const objects = [];
 
     const statePattern = /^(CONFIG|SETTINGS|[A-Z][A-Z0-9_]+|Default[A-Z][a-zA-Z]*|[A-Z][a-zA-Z]*(?:Config|Settings|Options))$/;
+    // All exported (^[A-Z]) package-level const/var are indexed as state objects
+    const isExportedName = (name) => /^[A-Z]/.test(name);
 
     // Check if a value node is a composite literal
     function isCompositeLiteral(valueNode) {
@@ -329,21 +399,51 @@ function findStateObjects(code, parser) {
         return false;
     }
 
+    // Check if a const block uses iota (enum-like pattern)
+    function blockHasIota(constDecl) {
+        for (let i = 0; i < constDecl.namedChildCount; i++) {
+            const spec = constDecl.namedChild(i);
+            if (spec.type === 'const_spec') {
+                const valueNode = spec.childForFieldName('value');
+                if (valueNode) {
+                    // Check if any child is 'iota'
+                    const checkIota = (n) => {
+                        if (n.type === 'iota') return true;
+                        for (let j = 0; j < n.childCount; j++) {
+                            if (checkIota(n.child(j))) return true;
+                        }
+                        return false;
+                    };
+                    if (checkIota(valueNode)) return true;
+                }
+            }
+        }
+        return false;
+    }
+
     traverseTree(tree.rootNode, (node) => {
         // Handle const declarations
         if (node.type === 'const_declaration') {
+            const isIotaBlock = blockHasIota(node);
             for (let i = 0; i < node.namedChildCount; i++) {
                 const spec = node.namedChild(i);
                 if (spec.type === 'const_spec') {
                     const nameNode = spec.childForFieldName('name');
                     const valueNode = spec.childForFieldName('value');
-
-                    if (nameNode && valueNode && isCompositeLiteral(valueNode)) {
-                        const name = nameNode.text;
-                        if (statePattern.test(name)) {
-                            const { startLine, endLine } = nodeToLocation(spec, code);
-                            objects.push({ name, startLine, endLine });
-                        }
+                    if (!nameNode) continue;
+                    const name = nameNode.text;
+
+                    // Include if: composite literal matching state pattern, OR exported const in iota block,
+                    // OR any exported (^[A-Z]) package-level const
+                    if (valueNode && isCompositeLiteral(valueNode) && statePattern.test(name)) {
+                        const { startLine, endLine } = nodeToLocation(spec, code);
+                        objects.push({ name, startLine, endLine });
+                    } else if (isIotaBlock && /^[A-Z]/.test(name)) {
+                        const { startLine, endLine } = nodeToLocation(spec, code);
+                        objects.push({ name, startLine, endLine, isConst: true });
+                    } else if (isExportedName(name)) {
+                        const { startLine, endLine } = nodeToLocation(spec, code);
+                        objects.push({ name, startLine, endLine, isConst: true });
                     }
                 }
             }
@@ -358,9 +458,12 @@ function findStateObjects(code, parser) {
                     const nameNode = spec.childForFieldName('name');
                     const valueNode = spec.childForFieldName('value');
 
-                    if (nameNode && valueNode && isCompositeLiteral(valueNode)) {
+                    if (nameNode) {
                         const name = nameNode.text;
-                        if (statePattern.test(name)) {
+                        if (valueNode && isCompositeLiteral(valueNode) && statePattern.test(name)) {
+                            const { startLine, endLine } = nodeToLocation(spec, code);
+                            objects.push({ name, startLine, endLine });
+                        } else if (isExportedName(name)) {
                             const { startLine, endLine } = nodeToLocation(spec, code);
                             objects.push({ name, startLine, endLine });
                         }
@@ -405,18 +508,108 @@ const GO_BUILTINS = new Set([
     'println', 'real', 'recover'
 ]);
 
-function findCallsInCode(code, parser) {
+function findCallsInCode(code, parser, options = {}) {
     const tree = parseTree(parser, code);
     const calls = [];
     const functionStack = [];  // Stack of { name, startLine, endLine }
     // Track local closure names per function scope (scopeStartLine -> Set<name>)
     const closureScopes = new Map();
+    // Track variable -> type mappings per function scope (scopeStartLine -> Map<varName, typeName>)
+    const scopeTypes = new Map();
+    // Track function-typed parameter names per scope (scopeStartLine -> Set<name>)
+    const funcParamScopes = new Map();
+
+    // Build set of import aliases for distinguishing pkg.Func() from obj.Method()
+    // options.imports contains resolved alias names (e.g., 'utilversion' for renamed imports,
+    // 'fmt' for standard imports). These come from fileEntry.importNames.
+    const importAliases = new Set();
+    if (options.imports) {
+        for (const name of options.imports) {
+            if (name && name !== '_' && name !== '.') importAliases.add(name);
+        }
+    }
 
     // Helper to check if a node creates a function scope
     const isFunctionNode = (node) => {
         return ['function_declaration', 'method_declaration', 'func_literal'].includes(node.type);
     };
 
+    // Extract the base type name from a type node (strips pointer, qualified, etc.)
+    const extractTypeName = (typeNode) => {
+        if (!typeNode) return null;
+        if (typeNode.type === 'type_identifier') return typeNode.text;
+        if (typeNode.type === 'pointer_type') {
+            // *Framework -> Framework
+            for (let i = 0; i < typeNode.namedChildCount; i++) {
+                const r = extractTypeName(typeNode.namedChild(i));
+                if (r) return r;
+            }
+        }
+        if (typeNode.type === 'qualified_type') {
+            // pkg.Type -> Type
+            const tn = typeNode.childForFieldName('name');
+            if (tn) return tn.text;
+        }
+        return null;
+    };
+
+    // Build type map from function/method parameters and receiver.
+    // Also returns funcParamNames: parameter names with function types (func(...) ...)
+    // so calls to them can be skipped (they're local parameter calls, not global function calls).
+    const buildScopeTypeMap = (node) => {
+        const typeMap = new Map();
+        const funcParamNames = new Set();
+
+        // Method receiver: func (f *Framework) Method()
+        if (node.type === 'method_declaration') {
+            const receiverNode = node.childForFieldName('receiver');
+            if (receiverNode) {
+                for (let i = 0; i < receiverNode.namedChildCount; i++) {
+                    const param = receiverNode.namedChild(i);
+                    if (param.type === 'parameter_declaration') {
+                        const nameNode = param.childForFieldName('name');
+                        const typeNode = param.childForFieldName('type');
+                        const typeName = extractTypeName(typeNode);
+                        if (nameNode && typeName) {
+                            typeMap.set(nameNode.text, typeName);
+                        }
+                    }
+                }
+            }
+        }
+
+        // Function/method parameters
+        // Go allows shared-type declarations: (adopt, release func(...) error)
+        // childForFieldName('name') returns only the first name — iterate all identifier children
+        const paramsNode = node.childForFieldName('parameters');
+        if (paramsNode) {
+            for (let i = 0; i < paramsNode.namedChildCount; i++) {
+                const param = paramsNode.namedChild(i);
+                if (param.type === 'parameter_declaration') {
+                    const typeNode = param.childForFieldName('type');
+                    if (!typeNode) continue;
+                    // Collect all name identifiers in this declaration
+                    const nameNodes = [];
+                    for (let j = 0; j < param.namedChildCount; j++) {
+                        const child = param.namedChild(j);
+                        if (child.type === 'identifier') nameNodes.push(child);
+                    }
+                    if (nameNodes.length === 0) continue;
+                    if (typeNode.type === 'function_type') {
+                        for (const nn of nameNodes) funcParamNames.add(nn.text);
+                    } else {
+                        const typeName = extractTypeName(typeNode);
+                        if (typeName) {
+                            for (const nn of nameNodes) typeMap.set(nn.text, typeName);
+                        }
+                    }
+                }
+            }
+        }
+
+        return { typeMap, funcParamNames };
+    };
+
     // Helper to extract function name from a function node
     const extractFunctionName = (node) => {
         if (node.type === 'function_declaration') {
@@ -449,14 +642,91 @@ function findCallsInCode(code, parser) {
         return false;
     };
 
+    // Check if name is a function-typed parameter (e.g., match func(Object) bool)
+    // Calls to these are local parameter invocations, not global function calls
+    const isFuncTypedParam = (name) => {
+        for (let i = functionStack.length - 1; i >= 0; i--) {
+            const scope = funcParamScopes.get(functionStack[i].startLine);
+            if (scope?.has(name)) return true;
+        }
+        return false;
+    };
+
+    // Look up variable type from scope chain
+    const getReceiverType = (varName) => {
+        for (let i = functionStack.length - 1; i >= 0; i--) {
+            const typeMap = scopeTypes.get(functionStack[i].startLine);
+            if (typeMap?.has(varName)) return typeMap.get(varName);
+        }
+        return undefined;
+    };
+
     traverseTree(tree.rootNode, (node) => {
         // Track function entry
         if (isFunctionNode(node)) {
-            functionStack.push({
+            const entry = {
                 name: extractFunctionName(node),
                 startLine: node.startPosition.row + 1,
                 endLine: node.endPosition.row + 1
-            });
+            };
+            functionStack.push(entry);
+            const { typeMap, funcParamNames } = buildScopeTypeMap(node);
+            scopeTypes.set(entry.startLine, typeMap);
+            if (funcParamNames.size > 0) {
+                funcParamScopes.set(entry.startLine, funcParamNames);
+            }
+        }
+
+        // Track local variable types from composite literals and typed assignments
+        // e.g., s := &Status{...} → s has type Status
+        //        registry := Registry{...} → registry has type Registry
+        if (node.type === 'short_var_declaration' && functionStack.length > 0) {
+            const left = node.childForFieldName('left');
+            const right = node.childForFieldName('right');
+            if (left && right) {
+                const 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 values = right.type === 'expression_list'
+                    ? Array.from({ length: right.namedChildCount }, (_, i) => right.namedChild(i))
+                    : [right];
+                const scopeKey = functionStack[functionStack.length - 1].startLine;
+                const typeMap = scopeTypes.get(scopeKey);
+                if (typeMap && names.length > 0 && values.length > 0) {
+                    for (let vi = 0; vi < Math.min(names.length, values.length); vi++) {
+                        const val = values[vi];
+                        let typeName = null;
+                        // &Type{...} or Type{...}
+                        if (val.type === 'composite_literal') {
+                            typeName = extractTypeName(val.childForFieldName('type'));
+                        } else if (val.type === 'unary_expression' && val.childCount > 0) {
+                            for (let ci = 0; ci < val.namedChildCount; ci++) {
+                                const ch = val.namedChild(ci);
+                                if (ch.type === 'composite_literal') {
+                                    typeName = extractTypeName(ch.childForFieldName('type'));
+                                    break;
+                                }
+                            }
+                        } else if (val.type === 'call_expression') {
+                            // NewFoo() or pkg.NewFoo() → infer type as Foo
+                            const callFuncNode = val.childForFieldName('function');
+                            if (callFuncNode) {
+                                const callName = callFuncNode.type === 'identifier'
+                                    ? callFuncNode.text
+                                    : callFuncNode.type === 'selector_expression'
+                                        ? callFuncNode.childForFieldName('field')?.text
+                                        : null;
+                                if (callName && /^New[A-Z]/.test(callName)) {
+                                    typeName = callName.slice(3);
+                                    if (!typeName || !/^[A-Z]/.test(typeName)) typeName = null;
+                                }
+                            }
+                        }
+                        if (typeName) typeMap.set(names[vi], typeName);
+                    }
+                }
+            }
         }
 
         // Track local closures: atoi := func(...) { ... } or var handler = func(...) { ... }
@@ -522,6 +792,9 @@ function findCallsInCode(code, parser) {
                 if (GO_BUILTINS.has(callName)) return true;
                 // Skip calls to local closures (they shadow package-level functions)
                 if (isLocalClosure(callName)) 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;
 
                 // Direct call: foo()
                 calls.push({
@@ -537,11 +810,17 @@ function findCallsInCode(code, parser) {
                 const operandNode = funcNode.childForFieldName('operand');
 
                 if (fieldNode) {
+                    const receiver = operandNode?.type === 'identifier' ? operandNode.text : undefined;
+                    // 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) ? getReceiverType(receiver) : undefined;
                     calls.push({
                         name: fieldNode.text,
                         line: node.startPosition.row + 1,
-                        isMethod: true,
-                        receiver: operandNode?.type === 'identifier' ? operandNode.text : undefined,
+                        isMethod: !isPkgCall,
+                        receiver,
+                        ...(receiverType && { receiverType }),
                         enclosingFunction,
                         uncertain
                     });
@@ -550,12 +829,41 @@ function findCallsInCode(code, parser) {
             return true;
         }
 
+        // Detect function references passed as arguments: dc.worker passed to UntilWithContext(ctx, dc.worker, ...)
+        // selector_expression inside argument_list (not inside call_expression as the function)
+        if (node.type === 'selector_expression' && node.parent?.type === 'argument_list') {
+            // Only if this selector_expression is NOT the function being called
+            const grandparent = node.parent?.parent;
+            if (!grandparent || grandparent.type !== 'call_expression' || grandparent.childForFieldName('function') !== node) {
+                const fieldNode = node.childForFieldName('field');
+                const operandNode = node.childForFieldName('operand');
+                if (fieldNode && operandNode) {
+                    const receiver = operandNode.type === 'identifier' ? operandNode.text : undefined;
+                    const receiverType = receiver ? getReceiverType(receiver) : undefined;
+                    const enclosingFunction = getCurrentEnclosingFunction();
+                    calls.push({
+                        name: fieldNode.text,
+                        line: node.startPosition.row + 1,
+                        isMethod: true,
+                        receiver,
+                        ...(receiverType && { receiverType }),
+                        enclosingFunction,
+                        isPotentialCallback: true,
+                        uncertain: false
+                    });
+                }
+            }
+        }
+
         return true;
     }, {
         onLeave: (node) => {
             if (isFunctionNode(node)) {
                 const leaving = functionStack.pop();
-                if (leaving) closureScopes.delete(leaving.startLine);
+                if (leaving) {
+                    closureScopes.delete(leaving.startLine);
+                    scopeTypes.delete(leaving.startLine);
+                }
             }
         }
     });

package/languages/index.js

@@ -228,7 +228,19 @@ function getParseOptions(contentLength = 0) {
  * @param {object} options - Additional parse options
  * @returns {object} Parsed tree
  */
+// Single-entry parse cache: during indexFile(), the same (parser, content) is parsed
+// 5 times (findFunctions + findClasses + findStateObjects + findImports + findExports).
+// Caching the last result eliminates 4 out of 5 parses per file (80% reduction).
+let _lastParseParser = null;
+let _lastParseContent = null;
+let _lastParseTree = null;
+
 function safeParse(parser, content, oldTree = undefined, options = {}) {
+    // Fast path: return cached tree if same parser and content (no oldTree override)
+    if (!oldTree && parser === _lastParseParser && content === _lastParseContent && _lastParseTree) {
+        return _lastParseTree;
+    }
+
     const contentLength = content.length;
 
     // Try with escalating buffer sizes
@@ -243,7 +255,14 @@ function safeParse(parser, content, oldTree = undefined, options = {}) {
     let lastError;
     for (const bufferSize of bufferSizes) {
         try {
-            return parser.parse(content, oldTree, { ...options, bufferSize });
+            const tree = parser.parse(content, oldTree, { ...options, bufferSize });
+            // Cache the result for same-(parser, content) reuse
+            if (!oldTree) {
+                _lastParseParser = parser;
+                _lastParseContent = content;
+                _lastParseTree = tree;
+            }
+            return tree;
         } catch (e) {
             lastError = e;
             // Only retry on buffer-related errors