ucn 3.8.10 → 3.8.12

package/languages/java.js

@@ -7,6 +7,7 @@
 
 const {
     traverseTree,
+    traverseTreeCached,
     nodeToLocation,
     parseStructuredParams,
     extractJavaDocstring
@@ -120,96 +121,106 @@ function extractGenerics(node) {
 }
 
 /**
- * Find all methods/constructors in Java code using tree-sitter
+ * Process a node for function/method 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();
-
-    traverseTree(tree.rootNode, (node) => {
+function _processFunction(node, functions, processedRanges, lines, code) {
+    // Method declarations
+    if (node.type === 'method_declaration') {
         const rangeKey = `${node.startIndex}-${node.endIndex}`;
+        if (processedRanges.has(rangeKey)) return true;
+        processedRanges.add(rangeKey);
 
-        // Method declarations
-        if (node.type === 'method_declaration') {
-            if (processedRanges.has(rangeKey)) return true;
-            processedRanges.add(rangeKey);
+        // Skip methods inside a class/interface/enum body (they're extracted as class members)
+        let parent = node.parent;
+        if (parent && (parent.type === 'class_body' || parent.type === 'interface_body' || parent.type === 'enum_body' || parent.type === 'enum_body_declarations')) {
+            return true;  // Skip - this is a class/interface/enum method
+        }
 
-            // Skip methods inside a class/interface/enum body (they're extracted as class members)
-            let parent = node.parent;
-            if (parent && (parent.type === 'class_body' || parent.type === 'interface_body' || parent.type === 'enum_body' || parent.type === 'enum_body_declarations')) {
-                return true;  // Skip - this is a class/interface/enum method
-            }
+        const nameNode = node.childForFieldName('name');
+        const paramsNode = node.childForFieldName('parameters');
 
-            const nameNode = node.childForFieldName('name');
-            const paramsNode = node.childForFieldName('parameters');
+        if (nameNode) {
+            const { startLine, endLine, indent } = nodeToLocation(node, lines);
+            const modifiers = extractModifiers(node);
+            const annotations = extractAnnotations(node);
+            const returnType = extractReturnType(node);
+            const generics = extractGenerics(node);
+            const docstring = extractJavaDocstring(lines, startLine);
+            // nameLine: where the name identifier lives (differs from startLine when annotations are present)
+            const nameLine = nameNode.startPosition.row + 1;
+
+            functions.push({
+                name: nameNode.text,
+                params: extractJavaParams(paramsNode),
+                paramsStructured: parseStructuredParams(paramsNode, 'java'),
+                startLine,
+                endLine,
+                indent,
+                modifiers,
+                ...(returnType && { returnType }),
+                ...(generics && { generics }),
+                ...(docstring && { docstring }),
+                ...(annotations.length > 0 && { annotations }),
+                ...(nameLine !== startLine && { nameLine })
+            });
+        }
+        return true;
+    }
 
-            if (nameNode) {
-                const { startLine, endLine, indent } = nodeToLocation(node, code);
-                const modifiers = extractModifiers(node);
-                const annotations = extractAnnotations(node);
-                const returnType = extractReturnType(node);
-                const generics = extractGenerics(node);
-                const docstring = extractJavaDocstring(code, startLine);
-                // nameLine: where the name identifier lives (differs from startLine when annotations are present)
-                const nameLine = nameNode.startPosition.row + 1;
+    // Constructor declarations
+    if (node.type === 'constructor_declaration') {
+        const rangeKey = `${node.startIndex}-${node.endIndex}`;
+        if (processedRanges.has(rangeKey)) return true;
+        processedRanges.add(rangeKey);
 
-                functions.push({
-                    name: nameNode.text,
-                    params: extractJavaParams(paramsNode),
-                    paramsStructured: parseStructuredParams(paramsNode, 'java'),
-                    startLine,
-                    endLine,
-                    indent,
-                    modifiers,
-                    ...(returnType && { returnType }),
-                    ...(generics && { generics }),
-                    ...(docstring && { docstring }),
-                    ...(annotations.length > 0 && { annotations }),
-                    ...(nameLine !== startLine && { nameLine })
-                });
-            }
-            return true;
+        // Skip constructors inside a class/enum body (they're extracted as class members)
+        let parent = node.parent;
+        if (parent && (parent.type === 'class_body' || parent.type === 'enum_body' || parent.type === 'enum_body_declarations')) {
+            return true;  // Skip - this is a class/enum constructor
         }
 
-        // Constructor declarations
-        if (node.type === 'constructor_declaration') {
-            if (processedRanges.has(rangeKey)) return true;
-            processedRanges.add(rangeKey);
-
-            // Skip constructors inside a class/enum body (they're extracted as class members)
-            let parent = node.parent;
-            if (parent && (parent.type === 'class_body' || parent.type === 'enum_body' || parent.type === 'enum_body_declarations')) {
-                return true;  // Skip - this is a class/enum constructor
-            }
+        const nameNode = node.childForFieldName('name');
+        const paramsNode = node.childForFieldName('parameters');
 
-            const nameNode = node.childForFieldName('name');
-            const paramsNode = node.childForFieldName('parameters');
+        if (nameNode) {
+            const { startLine, endLine, indent } = nodeToLocation(node, lines);
+            const modifiers = extractModifiers(node);
+            const annotations = extractAnnotations(node);
+            const docstring = extractJavaDocstring(lines, startLine);
+            const nameLine = nameNode.startPosition.row + 1;
+
+            functions.push({
+                name: nameNode.text,
+                params: extractJavaParams(paramsNode),
+                paramsStructured: parseStructuredParams(paramsNode, 'java'),
+                startLine,
+                endLine,
+                indent,
+                modifiers,
+                isConstructor: true,
+                ...(docstring && { docstring }),
+                ...(annotations.length > 0 && { annotations }),
+                ...(nameLine !== startLine && { nameLine })
+            });
+        }
+        return true;
+    }
 
-            if (nameNode) {
-                const { startLine, endLine, indent } = nodeToLocation(node, code);
-                const modifiers = extractModifiers(node);
-                const annotations = extractAnnotations(node);
-                const docstring = extractJavaDocstring(code, startLine);
-                const nameLine = nameNode.startPosition.row + 1;
+    return false;
+}
 
-                functions.push({
-                    name: nameNode.text,
-                    params: extractJavaParams(paramsNode),
-                    paramsStructured: parseStructuredParams(paramsNode, 'java'),
-                    startLine,
-                    endLine,
-                    indent,
-                    modifiers,
-                    isConstructor: true,
-                    ...(docstring && { docstring }),
-                    ...(annotations.length > 0 && { annotations }),
-                    ...(nameLine !== startLine && { nameLine })
-                });
-            }
-            return true;
-        }
+/**
+ * Find all methods/constructors in Java 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, code);
         return true;
     });
 
@@ -218,165 +229,176 @@ function findFunctions(code, parser) {
 }
 
 /**
- * Find all classes, interfaces, enums, records in Java code
+ * Process a node for class/interface/enum/record extraction (single-pass helper)
+ * Returns true if node was matched, false otherwise
  */
-function findClasses(code, parser) {
-    const tree = parseTree(parser, code);
-    const classes = [];
-    const processedRanges = new Set();
-
-    traverseTree(tree.rootNode, (node) => {
+function _processClass(node, classes, processedRanges, lines, code) {
+    // Class declarations
+    if (node.type === 'class_declaration') {
         const rangeKey = `${node.startIndex}-${node.endIndex}`;
+        if (processedRanges.has(rangeKey)) return true;
+        processedRanges.add(rangeKey);
 
-        // Class declarations
-        if (node.type === 'class_declaration') {
-            if (processedRanges.has(rangeKey)) return true;
-            processedRanges.add(rangeKey);
-
-            const nameNode = node.childForFieldName('name');
-            if (nameNode) {
-                const { startLine, endLine } = nodeToLocation(node, code);
-                const members = extractClassMembers(node, code);
-                const modifiers = extractModifiers(node);
-                const annotations = extractAnnotations(node);
-                const docstring = extractJavaDocstring(code, startLine);
-                const generics = extractGenerics(node);
-                const extendsInfo = extractExtends(node);
-                const implementsInfo = extractImplements(node);
-
-                // Check if this is a nested/inner class
-                let parentNode = node.parent;
-                const isNested = parentNode && parentNode.type === 'class_body';
-
-                classes.push({
-                    name: nameNode.text,
-                    startLine,
-                    endLine,
-                    type: 'class',
-                    members,
-                    modifiers,
-                    ...(isNested && { isNested: true }),
-                    ...(docstring && { docstring }),
-                    ...(generics && { generics }),
-                    ...(annotations.length > 0 && { annotations }),
-                    ...(extendsInfo && { extends: extendsInfo }),
-                    ...(implementsInfo.length > 0 && { implements: implementsInfo })
-                });
-            }
-            // Continue traversal to find inner classes, but members are already extracted
-            return true;
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) {
+            const { startLine, endLine } = nodeToLocation(node, lines);
+            const members = extractClassMembers(node, lines);
+            const modifiers = extractModifiers(node);
+            const annotations = extractAnnotations(node);
+            const docstring = extractJavaDocstring(lines, startLine);
+            const generics = extractGenerics(node);
+            const extendsInfo = extractExtends(node);
+            const implementsInfo = extractImplements(node);
+
+            // Check if this is a nested/inner class
+            let parentNode = node.parent;
+            const isNested = parentNode && parentNode.type === 'class_body';
+
+            classes.push({
+                name: nameNode.text,
+                startLine,
+                endLine,
+                type: 'class',
+                members,
+                modifiers,
+                ...(isNested && { isNested: true }),
+                ...(docstring && { docstring }),
+                ...(generics && { generics }),
+                ...(annotations.length > 0 && { annotations }),
+                ...(extendsInfo && { extends: extendsInfo }),
+                ...(implementsInfo.length > 0 && { implements: implementsInfo })
+            });
         }
+        return true;
+    }
 
-        // Interface declarations
-        if (node.type === 'interface_declaration') {
-            if (processedRanges.has(rangeKey)) return true;
-            processedRanges.add(rangeKey);
-
-            const nameNode = node.childForFieldName('name');
-            if (nameNode) {
-                const { startLine, endLine } = nodeToLocation(node, code);
-                const modifiers = extractModifiers(node);
-                const annotations = extractAnnotations(node);
-                const docstring = extractJavaDocstring(code, startLine);
-                const generics = extractGenerics(node);
-                const extendsInfo = extractInterfaceExtends(node);
+    // Interface declarations
+    if (node.type === 'interface_declaration') {
+        const rangeKey = `${node.startIndex}-${node.endIndex}`;
+        if (processedRanges.has(rangeKey)) return true;
+        processedRanges.add(rangeKey);
 
-                classes.push({
-                    name: nameNode.text,
-                    startLine,
-                    endLine,
-                    type: 'interface',
-                    members: extractClassMembers(node, code),
-                    modifiers,
-                    ...(docstring && { docstring }),
-                    ...(generics && { generics }),
-                    ...(annotations.length > 0 && { annotations }),
-                    ...(extendsInfo.length > 0 && { extends: extendsInfo.join(', ') })
-                });
-            }
-            return false;
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) {
+            const { startLine, endLine } = nodeToLocation(node, lines);
+            const modifiers = extractModifiers(node);
+            const annotations = extractAnnotations(node);
+            const docstring = extractJavaDocstring(lines, startLine);
+            const generics = extractGenerics(node);
+            const extendsInfo = extractInterfaceExtends(node);
+
+            classes.push({
+                name: nameNode.text,
+                startLine,
+                endLine,
+                type: 'interface',
+                members: extractClassMembers(node, lines),
+                modifiers,
+                ...(docstring && { docstring }),
+                ...(generics && { generics }),
+                ...(annotations.length > 0 && { annotations }),
+                ...(extendsInfo.length > 0 && { extends: extendsInfo.join(', ') })
+            });
         }
+        return true;
+    }
 
-        // Enum declarations
-        if (node.type === 'enum_declaration') {
-            if (processedRanges.has(rangeKey)) return true;
-            processedRanges.add(rangeKey);
-
-            const nameNode = node.childForFieldName('name');
-            if (nameNode) {
-                const { startLine, endLine } = nodeToLocation(node, code);
-                const modifiers = extractModifiers(node);
-                const annotations = extractAnnotations(node);
-                const docstring = extractJavaDocstring(code, startLine);
+    // Enum declarations
+    if (node.type === 'enum_declaration') {
+        const rangeKey = `${node.startIndex}-${node.endIndex}`;
+        if (processedRanges.has(rangeKey)) return true;
+        processedRanges.add(rangeKey);
 
-                classes.push({
-                    name: nameNode.text,
-                    startLine,
-                    endLine,
-                    type: 'enum',
-                    members: extractEnumConstants(node, code),
-                    modifiers,
-                    ...(docstring && { docstring }),
-                    ...(annotations.length > 0 && { annotations })
-                });
-            }
-            return false;
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) {
+            const { startLine, endLine } = nodeToLocation(node, lines);
+            const modifiers = extractModifiers(node);
+            const annotations = extractAnnotations(node);
+            const docstring = extractJavaDocstring(lines, startLine);
+
+            classes.push({
+                name: nameNode.text,
+                startLine,
+                endLine,
+                type: 'enum',
+                members: extractEnumConstants(node, lines),
+                modifiers,
+                ...(docstring && { docstring }),
+                ...(annotations.length > 0 && { annotations })
+            });
         }
+        return true;
+    }
 
-        // Record declarations (Java 14+)
-        if (node.type === 'record_declaration') {
-            if (processedRanges.has(rangeKey)) return true;
-            processedRanges.add(rangeKey);
+    // Record declarations (Java 14+)
+    if (node.type === 'record_declaration') {
+        const rangeKey = `${node.startIndex}-${node.endIndex}`;
+        if (processedRanges.has(rangeKey)) return true;
+        processedRanges.add(rangeKey);
 
-            const nameNode = node.childForFieldName('name');
-            if (nameNode) {
-                const { startLine, endLine } = nodeToLocation(node, code);
-                const modifiers = extractModifiers(node);
-                const annotations = extractAnnotations(node);
-                const docstring = extractJavaDocstring(code, startLine);
-                const generics = extractGenerics(node);
-                const implementsInfo = extractImplements(node);
-
-                // Extract record components as members
-                const members = extractClassMembers(node, code);
-                // Also extract record components from formal_parameters
-                const paramsNode = node.childForFieldName('parameters');
-                if (paramsNode) {
-                    for (let pi = 0; pi < paramsNode.namedChildCount; pi++) {
-                        const param = paramsNode.namedChild(pi);
-                        if (param.type === 'formal_parameter' || param.type === 'spread_parameter') {
-                            const pName = param.childForFieldName('name');
-                            const pType = param.childForFieldName('type');
-                            if (pName) {
-                                const { startLine: pLine, endLine: pEnd } = nodeToLocation(param, code);
-                                members.push({
-                                    name: pName.text,
-                                    startLine: pLine,
-                                    endLine: pEnd,
-                                    memberType: 'field',
-                                    ...(pType && { fieldType: pType.text })
-                                });
-                            }
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) {
+            const { startLine, endLine } = nodeToLocation(node, lines);
+            const modifiers = extractModifiers(node);
+            const annotations = extractAnnotations(node);
+            const docstring = extractJavaDocstring(lines, startLine);
+            const generics = extractGenerics(node);
+            const implementsInfo = extractImplements(node);
+
+            // Extract record components as members
+            const members = extractClassMembers(node, lines);
+            // Also extract record components from formal_parameters
+            const paramsNode = node.childForFieldName('parameters');
+            if (paramsNode) {
+                for (let pi = 0; pi < paramsNode.namedChildCount; pi++) {
+                    const param = paramsNode.namedChild(pi);
+                    if (param.type === 'formal_parameter' || param.type === 'spread_parameter') {
+                        const pName = param.childForFieldName('name');
+                        const pType = param.childForFieldName('type');
+                        if (pName) {
+                            const { startLine: pLine, endLine: pEnd } = nodeToLocation(param, lines);
+                            members.push({
+                                name: pName.text,
+                                startLine: pLine,
+                                endLine: pEnd,
+                                memberType: 'field',
+                                ...(pType && { fieldType: pType.text })
+                            });
                         }
                     }
                 }
-
-                classes.push({
-                    name: nameNode.text,
-                    startLine,
-                    endLine,
-                    type: 'record',
-                    members,
-                    modifiers,
-                    ...(docstring && { docstring }),
-                    ...(generics && { generics }),
-                    ...(annotations.length > 0 && { annotations }),
-                    ...(implementsInfo.length > 0 && { implements: implementsInfo })
-                });
             }
-            return false;
+
+            classes.push({
+                name: nameNode.text,
+                startLine,
+                endLine,
+                type: 'record',
+                members,
+                modifiers,
+                ...(docstring && { docstring }),
+                ...(generics && { generics }),
+                ...(annotations.length > 0 && { annotations }),
+                ...(implementsInfo.length > 0 && { implements: implementsInfo })
+            });
         }
+        return true;
+    }
+
+    return false;
+}
+
+/**
+ * Find all classes, interfaces, enums, records in Java code
+ */
+function findClasses(code, parser) {
+    const tree = parseTree(parser, code);
+    const lines = code.split('\n');
+    const classes = [];
+    const processedRanges = new Set();
 
+    traverseTreeCached(tree.rootNode, (node) => {
+        _processClass(node, classes, processedRanges, lines, code);
         return true;
     });
 
@@ -449,7 +471,8 @@ function extractInterfaceExtends(interfaceNode) {
 /**
  * Extract enum constants from enum body
  */
-function extractEnumConstants(enumNode, code) {
+function extractEnumConstants(enumNode, codeOrLines) {
+    const code = codeOrLines;
     const constants = [];
     const bodyNode = enumNode.childForFieldName('body');
     if (!bodyNode) return constants;
@@ -525,7 +548,8 @@ function extractEnumConstants(enumNode, code) {
 /**
  * Extract class members (methods, constructors)
  */
-function extractClassMembers(classNode, code) {
+function extractClassMembers(classNode, codeOrLines) {
+    const code = codeOrLines;
     const members = [];
     const bodyNode = classNode.childForFieldName('body');
     if (!bodyNode) return members;
@@ -606,38 +630,48 @@ function extractClassMembers(classNode, code) {
     return members;
 }
 
+const _statePattern = /^([A-Z][A-Z0-9_]+|[A-Z][a-zA-Z]*(?:CONFIG|SETTINGS|OPTIONS))$/;
+
 /**
- * Find state objects (static final constants) in Java code
+ * Process a node for state object extraction (single-pass helper)
+ * Returns true if node was matched, false otherwise
  */
-function findStateObjects(code, parser) {
-    const tree = parseTree(parser, code);
-    const objects = [];
-
-    const statePattern = /^([A-Z][A-Z0-9_]+|[A-Z][a-zA-Z]*(?:CONFIG|SETTINGS|OPTIONS))$/;
+function _processState(node, objects, lines, code) {
+    if (node.type === 'field_declaration') {
+        const modifiers = extractModifiers(node);
+        if (modifiers.includes('static') && modifiers.includes('final')) {
+            for (let i = 0; i < node.namedChildCount; i++) {
+                const child = node.namedChild(i);
+                if (child.type === 'variable_declarator') {
+                    const nameNode = child.childForFieldName('name');
+                    const valueNode = child.childForFieldName('value');
 
-    traverseTree(tree.rootNode, (node) => {
-        if (node.type === 'field_declaration') {
-            const modifiers = extractModifiers(node);
-            if (modifiers.includes('static') && modifiers.includes('final')) {
-                for (let i = 0; i < node.namedChildCount; i++) {
-                    const child = node.namedChild(i);
-                    if (child.type === 'variable_declarator') {
-                        const nameNode = child.childForFieldName('name');
-                        const valueNode = child.childForFieldName('value');
-
-                        if (nameNode && valueNode) {
-                            const name = nameNode.text;
-                            if (statePattern.test(name)) {
-                                const { startLine, endLine } = nodeToLocation(node, code);
-                                objects.push({ name, startLine, endLine, modifiers });
-                            }
+                    if (nameNode && valueNode) {
+                        const name = nameNode.text;
+                        if (_statePattern.test(name)) {
+                            const { startLine, endLine } = nodeToLocation(node, lines);
+                            objects.push({ name, startLine, endLine, modifiers });
                         }
                     }
                 }
             }
-            return true;
         }
+        return true;
+    }
+
+    return false;
+}
+
+/**
+ * Find state objects (static final constants) in Java code
+ */
+function findStateObjects(code, parser) {
+    const tree = parseTree(parser, code);
+    const lines = code.split('\n');
+    const objects = [];
 
+    traverseTreeCached(tree.rootNode, (node) => {
+        _processState(node, objects, lines, code);
         return true;
     });
 
@@ -649,12 +683,31 @@ function findStateObjects(code, parser) {
  * Parse a Java 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, code);
+        _processClass(node, classes, processedCls, lines, code);
+        _processState(node, stateObjects, lines, code);
+        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: 'java',
-        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: []
     };
@@ -882,7 +935,7 @@ function findImportsInCode(code, parser) {
     const tree = parseTree(parser, code);
     const imports = [];
 
-    traverseTree(tree.rootNode, (node) => {
+    traverseTreeCached(tree.rootNode, (node) => {
         if (node.type === 'import_declaration') {
             const line = node.startPosition.row + 1;
             let modulePath = null;
@@ -938,7 +991,7 @@ function findExportsInCode(code, parser) {
         return false;
     }
 
-    traverseTree(tree.rootNode, (node) => {
+    traverseTreeCached(tree.rootNode, (node) => {
         // Public classes
         if (node.type === 'class_declaration' && isPublic(node)) {
             const nameNode = node.childForFieldName('name');
@@ -1008,7 +1061,7 @@ function findUsagesInCode(code, name, parser) {
     const tree = parseTree(parser, code);
     const usages = [];
 
-    traverseTree(tree.rootNode, (node) => {
+    traverseTreeCached(tree.rootNode, (node) => {
         // Look for identifiers and type_identifiers with the matching name
         // type_identifier is used in Java for type references: new ClassName(), extends ClassName, field types
         if ((node.type !== 'identifier' && node.type !== 'type_identifier') || node.text !== name) {