ucn 3.8.11 → 3.8.13

package/languages/go.js

@@ -7,6 +7,7 @@
 
 const {
     traverseTree,
+    traverseTreeCached,
     nodeToLocation,
     parseStructuredParams,
     extractGoDocstring
@@ -54,88 +55,242 @@ function extractReceiver(receiverNode) {
     return text.replace(/^\(|\)$/g, '').trim();
 }
 
+// --- Single-pass helpers: extracted from find* callbacks ---
+
 /**
- * Find all functions in Go code using tree-sitter
+ * Process a node for function extraction (single-pass helper)
+ * Returns true if node was matched, false otherwise
  */
-function findFunctions(code, parser) {
-    const tree = parseTree(parser, code);
-    const functions = [];
-    const processedRanges = new Set();
+function _processFunction(node, functions, processedRanges, lines) {
+    if (node.type === 'function_declaration') {
+        const rangeKey = `${node.startIndex}-${node.endIndex}`;
+        if (processedRanges.has(rangeKey)) return false;
+        processedRanges.add(rangeKey);
 
-    traverseTree(tree.rootNode, (node) => {
+        const nameNode = node.childForFieldName('name');
+        const paramsNode = node.childForFieldName('parameters');
+
+        if (nameNode) {
+            const { startLine, endLine, indent } = nodeToLocation(node, lines);
+            const returnType = extractReturnType(node);
+            const docstring = extractGoDocstring(lines, startLine);
+            const typeParams = extractTypeParams(node);
+            const isExported = /^[A-Z]/.test(nameNode.text);
+
+            functions.push({
+                name: nameNode.text,
+                params: extractGoParams(paramsNode),
+                paramsStructured: parseStructuredParams(paramsNode, 'go'),
+                startLine,
+                endLine,
+                indent,
+                modifiers: isExported ? ['export'] : [],
+                ...(returnType && { returnType }),
+                ...(docstring && { docstring }),
+                ...(typeParams && { generics: typeParams })
+            });
+        }
+        return true;
+    }
+
+    if (node.type === 'method_declaration') {
         const rangeKey = `${node.startIndex}-${node.endIndex}`;
+        if (processedRanges.has(rangeKey)) return false;
+        processedRanges.add(rangeKey);
 
-        // Function declarations
-        if (node.type === 'function_declaration') {
-            if (processedRanges.has(rangeKey)) return true;
-            processedRanges.add(rangeKey);
+        const nameNode = node.childForFieldName('name');
+        const paramsNode = node.childForFieldName('parameters');
+        const receiverNode = node.childForFieldName('receiver');
+
+        if (nameNode) {
+            const { startLine, endLine, indent } = nodeToLocation(node, lines);
+            const receiver = extractReceiver(receiverNode);
+            const returnType = extractReturnType(node);
+            const docstring = extractGoDocstring(lines, startLine);
+            const isExported = /^[A-Z]/.test(nameNode.text);
+
+            functions.push({
+                name: nameNode.text,
+                params: extractGoParams(paramsNode),
+                paramsStructured: parseStructuredParams(paramsNode, 'go'),
+                startLine,
+                endLine,
+                indent,
+                isMethod: true,
+                receiver,
+                modifiers: isExported ? ['export'] : [],
+                ...(returnType && { returnType }),
+                ...(docstring && { docstring })
+            });
+        }
+        return true;
+    }
 
-            const nameNode = node.childForFieldName('name');
-            const paramsNode = node.childForFieldName('parameters');
+    return false;
+}
 
-            if (nameNode) {
-                const { startLine, endLine, indent } = nodeToLocation(node, code);
-                const returnType = extractReturnType(node);
-                const docstring = extractGoDocstring(code, startLine);
-                const typeParams = extractTypeParams(node);
+/**
+ * Process a node for type/class extraction (single-pass helper)
+ * Returns true if node was matched, false otherwise
+ */
+function _processClass(node, types, processedRanges, lines) {
+    if (node.type !== 'type_declaration') return false;
+
+    const rangeKey = `${node.startIndex}-${node.endIndex}`;
+    if (processedRanges.has(rangeKey)) return false;
+    processedRanges.add(rangeKey);
+
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const spec = node.namedChild(i);
+        if (spec.type === 'type_spec') {
+            const nameNode = spec.childForFieldName('name');
+            const typeNode = spec.childForFieldName('type');
+
+            if (nameNode && typeNode) {
+                const { startLine, endLine } = nodeToLocation(node, lines);
+                const name = nameNode.text;
+                const docstring = extractGoDocstring(lines, startLine);
+                const typeParams = extractTypeParams(spec);
+
+                let typeKind = 'type';
+                if (typeNode.type === 'struct_type') {
+                    typeKind = 'struct';
+                } else if (typeNode.type === 'interface_type') {
+                    typeKind = 'interface';
+                }
 
-                // Check if exported (capitalized)
-                const isExported = /^[A-Z]/.test(nameNode.text);
+                const isExported = /^[A-Z]/.test(name);
 
-                functions.push({
-                    name: nameNode.text,
-                    params: extractGoParams(paramsNode),
-                    paramsStructured: parseStructuredParams(paramsNode, 'go'),
+                const members = typeKind === 'struct' ? extractStructFields(typeNode, lines)
+                    : typeKind === 'interface' ? extractInterfaceMembers(typeNode, lines)
+                    : [];
+
+                const embeddedBases = members
+                    .filter(m => m.embedded)
+                    .map(m => m.name);
+
+                types.push({
+                    name,
                     startLine,
                     endLine,
-                    indent,
+                    type: typeKind,
+                    members,
                     modifiers: isExported ? ['export'] : [],
-                    ...(returnType && { returnType }),
                     ...(docstring && { docstring }),
-                    ...(typeParams && { generics: typeParams })
+                    ...(typeParams && { generics: typeParams }),
+                    ...(embeddedBases.length > 0 && { extends: embeddedBases.join(', ') })
                 });
             }
-            return true;
         }
+    }
+    return true;
+}
 
-        // Method declarations (with receivers)
-        if (node.type === 'method_declaration') {
-            if (processedRanges.has(rangeKey)) return true;
-            processedRanges.add(rangeKey);
+// Module-level state detection helpers
+const GO_STATE_PATTERN = /^(CONFIG|SETTINGS|[A-Z][A-Z0-9_]+|Default[A-Z][a-zA-Z]*|[A-Z][a-zA-Z]*(?:Config|Settings|Options))$/;
 
-            const nameNode = node.childForFieldName('name');
-            const paramsNode = node.childForFieldName('parameters');
-            const receiverNode = node.childForFieldName('receiver');
+function _isGoExportedName(name) {
+    return /^[A-Z]/.test(name);
+}
 
-            if (nameNode) {
-                const { startLine, endLine, indent } = nodeToLocation(node, code);
-                const receiver = extractReceiver(receiverNode);
-                const returnType = extractReturnType(node);
-                const docstring = extractGoDocstring(code, startLine);
+function _isCompositeLiteral(valueNode) {
+    if (!valueNode) return false;
+    if (valueNode.type === 'composite_literal') return true;
+    for (let i = 0; i < valueNode.namedChildCount; i++) {
+        if (valueNode.namedChild(i).type === 'composite_literal') return true;
+    }
+    return false;
+}
 
-                // Check if exported
-                const isExported = /^[A-Z]/.test(nameNode.text);
+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) {
+                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;
+}
 
-                functions.push({
-                    name: nameNode.text,
-                    params: extractGoParams(paramsNode),
-                    paramsStructured: parseStructuredParams(paramsNode, 'go'),
-                    startLine,
-                    endLine,
-                    indent,
-                    isMethod: true,
-                    receiver,
-                    modifiers: isExported ? ['export'] : [],
-                    ...(returnType && { returnType }),
-                    ...(docstring && { docstring })
-                });
+/**
+ * Process a node for state object extraction (single-pass helper)
+ * Returns true if node was matched, false otherwise
+ */
+function _processState(node, objects, lines) {
+    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) continue;
+                const name = nameNode.text;
+
+                if (valueNode && _isCompositeLiteral(valueNode) && GO_STATE_PATTERN.test(name)) {
+                    const { startLine, endLine } = nodeToLocation(spec, lines);
+                    objects.push({ name, startLine, endLine });
+                } else if (isIotaBlock && /^[A-Z]/.test(name)) {
+                    const { startLine, endLine } = nodeToLocation(spec, lines);
+                    objects.push({ name, startLine, endLine, isConst: true });
+                } else if (_isGoExportedName(name)) {
+                    const { startLine, endLine } = nodeToLocation(spec, lines);
+                    objects.push({ name, startLine, endLine, isConst: true });
+                }
             }
-            return true;
         }
+        return true;
+    }
+
+    if (node.type === 'var_declaration') {
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const spec = node.namedChild(i);
+            if (spec.type === 'var_spec') {
+                const nameNode = spec.childForFieldName('name');
+                const valueNode = spec.childForFieldName('value');
 
+                if (nameNode) {
+                    const name = nameNode.text;
+                    if (valueNode && _isCompositeLiteral(valueNode) && GO_STATE_PATTERN.test(name)) {
+                        const { startLine, endLine } = nodeToLocation(spec, lines);
+                        objects.push({ name, startLine, endLine });
+                    } else if (_isGoExportedName(name)) {
+                        const { startLine, endLine } = nodeToLocation(spec, lines);
+                        objects.push({ name, startLine, endLine });
+                    }
+                }
+            }
+        }
         return true;
-    });
+    }
 
+    return false;
+}
+
+// --- End single-pass helpers ---
+
+/**
+ * Find all functions in Go code using tree-sitter
+ */
+function findFunctions(code, parser) {
+    const tree = parseTree(parser, code);
+    const lines = code.split('\n');
+    const functions = [];
+    const processedRanges = new Set();
+    traverseTreeCached(tree.rootNode, (node) => {
+        _processFunction(node, functions, processedRanges, lines);
+        return true;
+    });
     functions.sort((a, b) => a.startLine - b.startLine);
     return functions;
 }
@@ -156,67 +311,13 @@ function extractTypeParams(node) {
  */
 function findClasses(code, parser) {
     const tree = parseTree(parser, code);
+    const lines = code.split('\n');
     const types = [];
     const processedRanges = new Set();
-
-    traverseTree(tree.rootNode, (node) => {
-        const rangeKey = `${node.startIndex}-${node.endIndex}`;
-
-        if (node.type === 'type_declaration') {
-            if (processedRanges.has(rangeKey)) return true;
-            processedRanges.add(rangeKey);
-
-            for (let i = 0; i < node.namedChildCount; i++) {
-                const spec = node.namedChild(i);
-                if (spec.type === 'type_spec') {
-                    const nameNode = spec.childForFieldName('name');
-                    const typeNode = spec.childForFieldName('type');
-
-                    if (nameNode && typeNode) {
-                        const { startLine, endLine } = nodeToLocation(node, code);
-                        const name = nameNode.text;
-                        const docstring = extractGoDocstring(code, startLine);
-                        const typeParams = extractTypeParams(spec);
-
-                        let typeKind = 'type';
-                        if (typeNode.type === 'struct_type') {
-                            typeKind = 'struct';
-                        } else if (typeNode.type === 'interface_type') {
-                            typeKind = 'interface';
-                        }
-
-                        // Check if exported
-                        const isExported = /^[A-Z]/.test(name);
-
-                        const members = typeKind === 'struct' ? extractStructFields(typeNode, code)
-                            : typeKind === 'interface' ? extractInterfaceMembers(typeNode, code)
-                            : [];
-
-                        // Extract embedded field names as extends (Go composition)
-                        const embeddedBases = members
-                            .filter(m => m.embedded)
-                            .map(m => m.name);
-
-                        types.push({
-                            name,
-                            startLine,
-                            endLine,
-                            type: typeKind,
-                            members,
-                            modifiers: isExported ? ['export'] : [],
-                            ...(docstring && { docstring }),
-                            ...(typeParams && { generics: typeParams }),
-                            ...(embeddedBases.length > 0 && { extends: embeddedBases.join(', ') })
-                        });
-                    }
-                }
-            }
-            return true;
-        }
-
+    traverseTreeCached(tree.rootNode, (node) => {
+        _processClass(node, types, processedRanges, lines);
         return true;
     });
-
     types.sort((a, b) => a.startLine - b.startLine);
     return types;
 }
@@ -224,7 +325,7 @@ function findClasses(code, parser) {
 /**
  * Extract struct fields
  */
-function extractStructFields(structNode, code) {
+function extractStructFields(structNode, codeOrLines) {
     const fields = [];
     // struct_type contains a field_declaration_list child (not a 'body' field)
     let fieldListNode = structNode.childForFieldName('body');
@@ -241,7 +342,7 @@ function extractStructFields(structNode, code) {
     for (let i = 0; i < fieldListNode.namedChildCount; i++) {
         const field = fieldListNode.namedChild(i);
         if (field.type === 'field_declaration') {
-            const { startLine, endLine } = nodeToLocation(field, code);
+            const { startLine, endLine } = nodeToLocation(field, codeOrLines);
             const nameNode = field.childForFieldName('name');
             const typeNode = field.childForFieldName('type');
 
@@ -280,13 +381,13 @@ function extractStructFields(structNode, code) {
 /**
  * Extract interface method signatures
  */
-function extractInterfaceMembers(interfaceNode, code) {
+function extractInterfaceMembers(interfaceNode, codeOrLines) {
     const members = [];
     for (let i = 0; i < interfaceNode.namedChildCount; i++) {
         const child = interfaceNode.namedChild(i);
         // tree-sitter Go uses method_elem (or method_spec in older versions)
         if (child.type === 'method_elem' || child.type === 'method_spec') {
-            const { startLine, endLine } = nodeToLocation(child, code);
+            const { startLine, endLine } = nodeToLocation(child, codeOrLines);
             // Name is in a field_identifier child
             let nameText = null;
             let paramsText = null;
@@ -355,7 +456,7 @@ function extractInterfaceMembers(interfaceNode, code) {
             }
         } else if (child.type === 'type_identifier' || child.type === 'qualified_type') {
             // Standalone type identifier inside interface body — embedded interface
-            const { startLine, endLine } = nodeToLocation(child, code);
+            const { startLine, endLine } = nodeToLocation(child, codeOrLines);
             let embName = child.text;
             const dotIdx = embName.indexOf('.');
             if (dotIdx >= 0) embName = embName.slice(dotIdx + 1);
@@ -373,7 +474,7 @@ function extractInterfaceMembers(interfaceNode, code) {
             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);
+                    const { startLine, endLine } = nodeToLocation(sub, codeOrLines);
                     let embName = sub.text;
                     const dotIdx = embName.indexOf('.');
                     if (dotIdx >= 0) embName = embName.slice(dotIdx + 1);
@@ -397,99 +498,12 @@ function extractInterfaceMembers(interfaceNode, code) {
  */
 function findStateObjects(code, parser) {
     const tree = parseTree(parser, code);
+    const lines = code.split('\n');
     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) {
-        if (!valueNode) return false;
-        if (valueNode.type === 'composite_literal') return true;
-        for (let i = 0; i < valueNode.namedChildCount; i++) {
-            if (valueNode.namedChild(i).type === 'composite_literal') return true;
-        }
-        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) 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 });
-                    }
-                }
-            }
-            return true;
-        }
-
-        // Handle var declarations
-        if (node.type === 'var_declaration') {
-            for (let i = 0; i < node.namedChildCount; i++) {
-                const spec = node.namedChild(i);
-                if (spec.type === 'var_spec') {
-                    const nameNode = spec.childForFieldName('name');
-                    const valueNode = spec.childForFieldName('value');
-
-                    if (nameNode) {
-                        const name = nameNode.text;
-                        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 });
-                        }
-                    }
-                }
-            }
-            return true;
-        }
-
+    traverseTreeCached(tree.rootNode, (node) => {
+        _processState(node, objects, lines);
         return true;
     });
-
     objects.sort((a, b) => a.startLine - b.startLine);
     return objects;
 }
@@ -498,12 +512,31 @@ function findStateObjects(code, parser) {
  * Parse a Go file completely
  */
 function parse(code, parser) {
+    const tree = parseTree(parser, code);
+    const lines = code.split('\n');
+    const functions = [];
+    const classes = [];
+    const stateObjects = [];
+    const processedFn = new Set();
+    const processedCls = new Set();
+
+    traverseTreeCached(tree.rootNode, (node) => {
+        _processFunction(node, functions, processedFn, lines);
+        _processClass(node, classes, processedCls, lines);
+        _processState(node, stateObjects, lines);
+        return true;
+    });
+
+    functions.sort((a, b) => a.startLine - b.startLine);
+    classes.sort((a, b) => a.startLine - b.startLine);
+    stateObjects.sort((a, b) => a.startLine - b.startLine);
+
     return {
         language: 'go',
-        totalLines: code.split('\n').length,
-        functions: findFunctions(code, parser),
-        classes: findClasses(code, parser),
-        stateObjects: findStateObjects(code, parser),
+        totalLines: lines.length,
+        functions,
+        classes,
+        stateObjects,
         imports: [],
         exports: []
     };
@@ -1103,7 +1136,7 @@ function findImportsInCode(code, parser) {
         }
     }
 
-    traverseTree(tree.rootNode, (node) => {
+    traverseTreeCached(tree.rootNode, (node) => {
         if (node.type === 'import_declaration') {
             for (let i = 0; i < node.namedChildCount; i++) {
                 const child = node.namedChild(i);
@@ -1138,7 +1171,7 @@ function findExportsInCode(code, parser) {
     const tree = parseTree(parser, code);
     const exports = [];
 
-    traverseTree(tree.rootNode, (node) => {
+    traverseTreeCached(tree.rootNode, (node) => {
         // Exported functions
         if (node.type === 'function_declaration') {
             const nameNode = node.childForFieldName('name');
@@ -1218,7 +1251,7 @@ function findUsagesInCode(code, name, parser) {
     const tree = parseTree(parser, code);
     const usages = [];
 
-    traverseTree(tree.rootNode, (node) => {
+    traverseTreeCached(tree.rootNode, (node) => {
         // Look for identifier, field_identifier (method names in selector expressions),
         // and type_identifier (type references in params, return types, composite literals, etc.)
         const isIdentifier = node.type === 'identifier' || node.type === 'field_identifier' || node.type === 'type_identifier';