ucn 3.8.23 → 3.8.26

package/languages/javascript.js

@@ -11,7 +11,8 @@ const {
     nodeToLocation,
     extractParams,
     parseStructuredParams,
-    extractJSDocstring
+    extractJSDocstring,
+    buildTypeAnnotations
 } = require('./utils');
 const { PARSE_OPTIONS, safeParse } = require('./index');
 
@@ -95,19 +96,138 @@ function extractModifiers(text) {
  */
 function extractDecorators(node) {
     const decorators = [];
+    const consume = (n) => {
+        if (n.type !== 'decorator') return;
+        let text = n.text.replace(/^@/, '');
+        const parenIdx = text.indexOf('(');
+        if (parenIdx > 0) text = text.substring(0, parenIdx);
+        decorators.push(text);
+    };
+
+    // 1. Direct children — covers most class/method decorators.
     for (let i = 0; i < node.namedChildCount; i++) {
-        const child = node.namedChild(i);
-        if (child.type === 'decorator') {
-            let text = child.text.replace(/^@/, '');
-            // Strip arguments: @Component({...}) → Component
-            const parenIdx = text.indexOf('(');
-            if (parenIdx > 0) text = text.substring(0, parenIdx);
-            decorators.push(text);
+        consume(node.namedChild(i));
+    }
+
+    // 2. When a class/function is wrapped in `export class …`, tree-sitter
+    //    wraps it in an `export_statement`. The decorator becomes a sibling
+    //    of the inner declaration *inside* that export_statement. Walk the
+    //    wrapper's children for any decorator preceding the inner node.
+    if (node.parent && node.parent.type === 'export_statement') {
+        const wrapper = node.parent;
+        let myIdx = -1;
+        for (let i = 0; i < wrapper.namedChildCount; i++) {
+            if (wrapper.namedChild(i).id === node.id) { myIdx = i; break; }
+        }
+        for (let i = myIdx - 1; i >= 0; i--) {
+            const sib = wrapper.namedChild(i);
+            if (sib.type === 'decorator') consume(sib);
+            else break;
+        }
+    }
+
+    // 3. Some grammars place decorators as preceding siblings of the
+    //    declaration itself (rather than wrapping in export_statement).
+    //    Walk back from this node within its parent.
+    if (node.parent && node.parent.type !== 'export_statement') {
+        const parent = node.parent;
+        let myIdx = -1;
+        for (let i = 0; i < parent.namedChildCount; i++) {
+            if (parent.namedChild(i).id === node.id) { myIdx = i; break; }
+        }
+        for (let i = myIdx - 1; i >= 0; i--) {
+            const sib = parent.namedChild(i);
+            if (sib.type === 'decorator') consume(sib);
+            else break;
         }
     }
     return decorators;
 }
 
+/**
+ * Extract decorators along with their string-literal first argument.
+ * Returns array of { name, args, firstStringArg } where:
+ *   - name is the decorator name (no @)
+ *   - args is the raw argument text (without outer parens), or null
+ *   - firstStringArg is the literal value of the first string-literal argument, or null
+ *
+ *   @Get(':id')               → { name: 'Get', args: "':id'", firstStringArg: ':id' }
+ *   @Controller('/api/users') → { name: 'Controller', args: "'/api/users'", firstStringArg: '/api/users' }
+ *   @Injectable               → { name: 'Injectable', args: null, firstStringArg: null }
+ *
+ * Used by route extraction (NestJS, etc.) — only the firstStringArg is currently
+ * consumed by core/bridge.js, but `args` is preserved for future structural-search use.
+ */
+function extractDecoratorsWithArgs(node) {
+    const result = [];
+    const { extractStringArg } = require('./utils');
+
+    const consume = (n) => {
+        if (n.type !== 'decorator') return;
+        // tree-sitter-javascript: decorator has a single 'expression' child.
+        // Look for call_expression vs identifier vs member_expression.
+        let inner = null;
+        for (let i = 0; i < n.namedChildCount; i++) {
+            const c = n.namedChild(i);
+            if (c.type !== 'comment') { inner = c; break; }
+        }
+        if (!inner) return;
+
+        if (inner.type === 'call_expression') {
+            const fn = inner.childForFieldName('function');
+            const argsNode = inner.childForFieldName('arguments');
+            if (!fn || !argsNode) return;
+            const name = fn.text;
+            // Get raw arg text without the surrounding parens
+            const argsText = argsNode.text.replace(/^\(|\)$/g, '');
+            // Find first string-literal arg
+            let firstStringArg = null;
+            for (let j = 0; j < argsNode.namedChildCount; j++) {
+                const arg = argsNode.namedChild(j);
+                if (arg.type === 'comment') continue;
+                const s = extractStringArg(arg);
+                if (s && !s.interp) { firstStringArg = s.value; break; }
+                if (s) { firstStringArg = s.value; break; }
+                break;
+            }
+            result.push({ name, args: argsText, firstStringArg });
+        } else if (inner.type === 'identifier' || inner.type === 'member_expression') {
+            // Plain decorator: @Injectable
+            result.push({ name: inner.text, args: null, firstStringArg: null });
+        }
+    };
+
+    // Same traversal as extractDecorators
+    for (let i = 0; i < node.namedChildCount; i++) {
+        consume(node.namedChild(i));
+    }
+    if (node.parent && node.parent.type === 'export_statement') {
+        const wrapper = node.parent;
+        let myIdx = -1;
+        for (let i = 0; i < wrapper.namedChildCount; i++) {
+            if (wrapper.namedChild(i).id === node.id) { myIdx = i; break; }
+        }
+        for (let i = myIdx - 1; i >= 0; i--) {
+            const sib = wrapper.namedChild(i);
+            if (sib.type === 'decorator') consume(sib);
+            else break;
+        }
+    }
+    if (node.parent && node.parent.type !== 'export_statement') {
+        const parent = node.parent;
+        let myIdx = -1;
+        for (let i = 0; i < parent.namedChildCount; i++) {
+            if (parent.namedChild(i).id === node.id) { myIdx = i; break; }
+        }
+        for (let i = myIdx - 1; i >= 0; i--) {
+            const sib = parent.namedChild(i);
+            if (sib.type === 'decorator') consume(sib);
+            else break;
+        }
+    }
+    return result;
+}
+
 // --- Single-pass helpers: extracted from find* callbacks ---
 
 /**
@@ -131,22 +251,28 @@ function _processFunction(node, functions, processedRanges, lines) {
             const generics = extractGenerics(node);
             const docstring = extractJSDocstring(lines, startLine);
             const isGen = isGenerator(node);
+            const paramsStructured = parseStructuredParams(paramsNode, 'javascript');
+            const typeAnno = buildTypeAnnotations(paramsStructured, returnType, lines, startLine, true);
             // Check parent for export status (function_declaration inside export_statement)
             const modifiers = node.parent && node.parent.type === 'export_statement'
                 ? extractModifiers(node.parent.text)
                 : extractModifiers(node.text);
+            // Feature B: explicit isAsync flag (auditAsync needs to know whether
+            // the fn was declared `async function`).
+            const isAsync = modifiers.includes('async');
 
             functions.push({
                 name: nameNode.text,
                 params: extractParams(paramsNode),
-                paramsStructured: parseStructuredParams(paramsNode, 'javascript'),
+                paramsStructured,
                 startLine,
                 endLine,
                 indent,
                 isArrow: false,
                 isGenerator: isGen,
+                isAsync,
                 modifiers,
-                ...(returnType && { returnType }),
+                ...typeAnno,
                 ...(generics && { generics }),
                 ...(docstring && { docstring })
             });
@@ -167,11 +293,13 @@ function _processFunction(node, functions, processedRanges, lines) {
             const returnType = extractReturnType(node);
             const generics = extractGenerics(node);
             const docstring = extractJSDocstring(lines, startLine);
+            const paramsStructured = parseStructuredParams(paramsNode, 'typescript');
+            const typeAnno = buildTypeAnnotations(paramsStructured, returnType, lines, startLine, true);
 
             functions.push({
                 name: nameNode.text,
                 params: extractParams(paramsNode),
-                paramsStructured: parseStructuredParams(paramsNode, 'typescript'),
+                paramsStructured,
                 startLine,
                 endLine,
                 indent,
@@ -179,7 +307,7 @@ function _processFunction(node, functions, processedRanges, lines) {
                 isGenerator: false,
                 isSignature: true,
                 modifiers: [],
-                ...(returnType && { returnType }),
+                ...typeAnno,
                 ...(generics && { generics }),
                 ...(docstring && { docstring })
             });
@@ -210,22 +338,31 @@ function _processFunction(node, functions, processedRanges, lines) {
                         const generics = extractGenerics(valueNode);
                         const docstring = extractJSDocstring(lines, startLine);
                         const isGen = isGenerator(valueNode);
+                        const paramsStructured = parseStructuredParams(paramsNode, 'javascript');
+                        const typeAnno = buildTypeAnnotations(paramsStructured, returnType, lines, startLine, true);
                         // Check parent for export status (lexical_declaration inside export_statement)
                         const modifiers = node.parent && node.parent.type === 'export_statement'
                             ? extractModifiers(node.parent.text)
                             : extractModifiers(node.text);
+                        // Feature B: detect async — for arrow/fn-expressions the `async`
+                        // keyword precedes the parameter list on the value node, NOT on
+                        // the lexical_declaration text. extractModifiers walked the full
+                        // declaration text, so we double-check the value node directly.
+                        const valueIsAsync = valueNode.text.trimStart().startsWith('async ');
+                        const isAsync = valueIsAsync || modifiers.includes('async');
 
                         functions.push({
                             name: nameNode.text,
                             params: extractParams(paramsNode),
-                            paramsStructured: parseStructuredParams(paramsNode, 'javascript'),
+                            paramsStructured,
                             startLine,
                             endLine,
                             indent,
                             isArrow,
                             isGenerator: isGen,
+                            isAsync,
                             modifiers,
-                            ...(returnType && { returnType }),
+                            ...typeAnno,
                             ...(generics && { generics }),
                             ...(docstring && { docstring })
                         });
@@ -255,6 +392,8 @@ function _processFunction(node, functions, processedRanges, lines) {
                                         const returnType = extractReturnType(innerFn);
                                         const generics = extractGenerics(innerFn);
                                         const docstring = extractJSDocstring(lines, startLine);
+                                        const paramsStructured = parseStructuredParams(paramsNode, 'javascript');
+                                        const typeAnno = buildTypeAnnotations(paramsStructured, returnType, lines, startLine, true);
                                         const modifiers = node.parent && node.parent.type === 'export_statement'
                                             ? extractModifiers(node.parent.text)
                                             : extractModifiers(node.text);
@@ -262,14 +401,14 @@ function _processFunction(node, functions, processedRanges, lines) {
                                         functions.push({
                                             name: nameNode.text,
                                             params: extractParams(paramsNode),
-                                            paramsStructured: parseStructuredParams(paramsNode, 'javascript'),
+                                            paramsStructured,
                                             startLine,
                                             endLine,
                                             indent,
                                             isArrow: innerFn.type === 'arrow_function',
                                             isGenerator: false,
                                             modifiers,
-                                            ...(returnType && { returnType }),
+                                            ...typeAnno,
                                             ...(generics && { generics }),
                                             ...(docstring && { docstring })
                                         });
@@ -330,18 +469,20 @@ function _processFunction(node, functions, processedRanges, lines) {
                     const generics = extractGenerics(rightNode);
                     const docstring = extractJSDocstring(lines, startLine);
                     const isGen = isGenerator(rightNode);
+                    const paramsStructured = parseStructuredParams(paramsNode, 'javascript');
+                    const typeAnno = buildTypeAnnotations(paramsStructured, returnType, lines, startLine, true);
 
                     functions.push({
                         name,
                         params: extractParams(paramsNode),
-                        paramsStructured: parseStructuredParams(paramsNode, 'javascript'),
+                        paramsStructured,
                         startLine,
                         endLine,
                         indent,
                         isArrow,
                         isGenerator: isGen,
                         modifiers: [],
-                        ...(returnType && { returnType }),
+                        ...typeAnno,
                         ...(generics && { generics }),
                         ...(docstring && { docstring })
                     });
@@ -368,18 +509,20 @@ function _processFunction(node, functions, processedRanges, lines) {
                     const generics = extractGenerics(child);
                     const docstring = extractJSDocstring(lines, startLine);
                     const isGen = isGenerator(child);
+                    const paramsStructured = parseStructuredParams(paramsNode, 'javascript');
+                    const typeAnno = buildTypeAnnotations(paramsStructured, returnType, lines, startLine, true);
 
                     functions.push({
                         name: 'default',
                         params: extractParams(paramsNode),
-                        paramsStructured: parseStructuredParams(paramsNode, 'javascript'),
+                        paramsStructured,
                         startLine,
                         endLine,
                         indent,
                         isArrow: child.type === 'arrow_function',
                         isGenerator: isGen,
                         modifiers: ['export', 'default'],
-                        ...(returnType && { returnType }),
+                        ...typeAnno,
                         ...(generics && { generics }),
                         ...(docstring && { docstring })
                     });
@@ -428,6 +571,7 @@ function _processClass(node, classes, processedRanges, lines) {
             const extendsInfo = extractExtends(node);
             const implementsInfo = extractImplements(node);
             const decorators = extractDecorators(node);
+            const decoratorsWithArgs = extractDecoratorsWithArgs(node);
 
             const isAbstract = node.type === 'abstract_class_declaration';
             classes.push({
@@ -441,7 +585,8 @@ function _processClass(node, classes, processedRanges, lines) {
                 ...(generics && { generics }),
                 ...(extendsInfo && { extends: extendsInfo }),
                 ...(implementsInfo.length > 0 && { implements: implementsInfo }),
-                ...(decorators.length > 0 && { decorators })
+                ...(decorators.length > 0 && { decorators }),
+                ...(decoratorsWithArgs.some(d => d.firstStringArg) && { decoratorsWithArgs })
             });
         }
         return true;
@@ -656,15 +801,17 @@ function extractInterfaceMembers(interfaceNode, code) {
             if (nameNode) {
                 const { startLine, endLine } = nodeToLocation(child, code);
                 const returnType = extractReturnType(child);
+                const paramsStructured = parseStructuredParams(paramsNode, 'javascript');
+                const typeAnno = buildTypeAnnotations(paramsStructured, returnType, code, startLine, true);
                 members.push({
                     name: nameNode.text,
                     params: extractParams(paramsNode),
-                    paramsStructured: parseStructuredParams(paramsNode, 'javascript'),
+                    paramsStructured,
                     startLine,
                     endLine,
                     memberType: 'method',
                     isMethod: true,
-                    ...(returnType && { returnType })
+                    ...typeAnno
                 });
             }
         } else if (child.type === 'property_signature') {
@@ -773,20 +920,24 @@ function extractClassMembers(classNode, codeOrLines) {
                 const isAsync = text.match(/^\s*(?:(?:public|private|protected)\s+)?(?:static\s+)?(?:override\s+)?async\s/) !== null;
                 const returnType = extractReturnType(child);
                 const docstring = extractJSDocstring(code, startLine);
+                const paramsStructured = parseStructuredParams(paramsNode, 'javascript');
+                const typeAnno = buildTypeAnnotations(paramsStructured, returnType, code, startLine, true);
 
+                const decoratorsWithArgs = extractDecoratorsWithArgs(child);
                 members.push({
                     name,
                     params: extractParams(paramsNode),
-                    paramsStructured: parseStructuredParams(paramsNode, 'javascript'),
+                    paramsStructured,
                     startLine,
                     endLine,
                     memberType,
                     isAsync,
                     isGenerator: isGen,
                     isMethod: true,  // Mark as method for context() lookups
-                    ...(returnType && { returnType }),
+                    ...typeAnno,
                     ...(docstring && { docstring }),
-                    ...(decorators.length > 0 && { decorators })
+                    ...(decorators.length > 0 && { decorators }),
+                    ...(decoratorsWithArgs.length > 0 && { decoratorsWithArgs })
                 });
             }
         }
@@ -799,6 +950,8 @@ function extractClassMembers(classNode, codeOrLines) {
                 const { startLine, endLine } = nodeToLocation(child, code);
                 const returnType = extractReturnType(child);
                 const docstring = extractJSDocstring(code, startLine);
+                const paramsStructured = parseStructuredParams(paramsNode, 'javascript');
+                const typeAnno = buildTypeAnnotations(paramsStructured, returnType, code, startLine, true);
                 // Collect decorators from preceding siblings
                 const decorators = [];
                 for (let j = i - 1; j >= 0; j--) {
@@ -813,12 +966,12 @@ function extractClassMembers(classNode, codeOrLines) {
                 members.push({
                     name: nameNode.text,
                     params: extractParams(paramsNode),
-                    paramsStructured: parseStructuredParams(paramsNode, 'javascript'),
+                    paramsStructured,
                     startLine,
                     endLine,
                     memberType: 'abstract',
                     isMethod: true,
-                    ...(returnType && { returnType }),
+                    ...typeAnno,
                     ...(docstring && { docstring }),
                     ...(decorators.length > 0 && { decorators })
                 });
@@ -862,16 +1015,18 @@ function extractClassMembers(classNode, codeOrLines) {
                 if (isArrow) {
                     const paramsNode = valueNode.childForFieldName('parameters');
                     const returnType = extractReturnType(valueNode);
+                    const paramsStructured = parseStructuredParams(paramsNode, 'javascript');
+                    const typeAnno = buildTypeAnnotations(paramsStructured, returnType, code, startLine, true);
                     members.push({
                         name,
                         params: extractParams(paramsNode),
-                        paramsStructured: parseStructuredParams(paramsNode, 'javascript'),
+                        paramsStructured,
                         startLine,
                         endLine,
                         memberType: name.startsWith('#') ? 'private' : 'field',
                         isArrow: true,
                         isMethod: true,  // Arrow fields are callable like methods
-                        ...(returnType && { returnType }),
+                        ...typeAnno,
                         ...(fieldDecorators.length > 0 && { decorators: fieldDecorators })
                     });
                 } else {
@@ -1003,6 +1158,76 @@ function findCallsInCode(code, parser) {
     const localVarTypes = new Map();  // Track local variable types: varName -> typeName (for receiverType inference)
     const localVarTypesStack = [];  // Stack for function-scoped save/restore of localVarTypes
 
+    // Helper: extract first string-arg literal from a call_expression node.
+    // Used by route extraction to capture path arg of fetch('/path'), app.get('/path', handler) etc.
+    const { extractStringArg: _extractStringArg } = require('./utils');
+    const getFirstStringArg = (callNode) => {
+        const argsNode = callNode.childForFieldName('arguments');
+        if (!argsNode) return null;
+        for (let i = 0; i < argsNode.namedChildCount; i++) {
+            const arg = argsNode.namedChild(i);
+            if (arg.type === 'comment') continue;
+            return _extractStringArg(arg);
+        }
+        return null;
+    };
+
+    // Helper: count the number of (non-comment) arguments in a call_expression.
+    // Used to disambiguate dual-purpose Express APIs (BUG M5):
+    //   app.get('/users', handler)  → 2 args → route registration
+    //   app.get('env')              → 1 arg  → config getter, NOT a route
+    const getArgCount = (callNode) => {
+        const argsNode = callNode.childForFieldName('arguments');
+        if (!argsNode) return 0;
+        let count = 0;
+        for (let i = 0; i < argsNode.namedChildCount; i++) {
+            const arg = argsNode.namedChild(i);
+            if (arg.type === 'comment') continue;
+            count++;
+        }
+        return count;
+    };
+
+    // MEDIUM-5: extract HTTP method from `fetch(url, { method: 'POST' })`
+    // and similar XHR/Request-init shapes. Returns the upper-cased method
+    // string or null. Looks at argument index `argIdx` (default 1, the
+    // options object after the URL).
+    const getOptionsMethod = (callNode, argIdx = 1) => {
+        const argsNode = callNode.childForFieldName('arguments');
+        if (!argsNode) return null;
+        // Walk named children and pick the argIdx-th non-comment node.
+        let idx = 0;
+        let target = null;
+        for (let i = 0; i < argsNode.namedChildCount; i++) {
+            const arg = argsNode.namedChild(i);
+            if (arg.type === 'comment') continue;
+            if (idx === argIdx) { target = arg; break; }
+            idx++;
+        }
+        if (!target || target.type !== 'object') return null;
+        for (let i = 0; i < target.namedChildCount; i++) {
+            const prop = target.namedChild(i);
+            if (prop.type !== 'pair') continue;
+            const keyNode = prop.childForFieldName('key');
+            const valNode = prop.childForFieldName('value');
+            if (!keyNode || !valNode) continue;
+            // Key may be `method`, `'method'`, or `"method"`.
+            let keyName = keyNode.text;
+            if (keyNode.type === 'string' || keyNode.type === 'property_identifier') {
+                keyName = keyName.replace(/^['"`]|['"`]$/g, '');
+            }
+            if (keyName !== 'method') continue;
+            // Value must be a literal string. Skip variables / expressions
+            // (we can't statically resolve those).
+            const v = _extractStringArg(valNode);
+            if (v && !v.interp && typeof v.value === 'string' && v.value.length > 0) {
+                return v.value.toUpperCase();
+            }
+            return null;
+        }
+        return null;
+    };
+
     // Helper to check if a node is a non-callable literal
     const isNonCallableInit = (node) => {
         // Primitive literals
@@ -1219,6 +1444,11 @@ function findCallsInCode(code, parser) {
                 const alias = aliases.get(funcNode.text);
                 const resolvedName = typeof alias === 'string' ? alias : undefined;
                 const resolvedNames = Array.isArray(alias) ? alias : undefined;
+                const firstArg = getFirstStringArg(node);
+                // MEDIUM-5: capture explicit method for fetch(url, { method }).
+                const optionsMethod = funcNode.text === 'fetch'
+                    ? getOptionsMethod(node, 1)
+                    : null;
                 calls.push({
                     name: funcNode.text,
                     ...(resolvedName && { resolvedName }),
@@ -1226,7 +1456,9 @@ function findCallsInCode(code, parser) {
                     line: node.startPosition.row + 1,
                     isMethod: false,
                     enclosingFunction,
-                    uncertain
+                    uncertain,
+                    ...(firstArg && { firstStringArg: firstArg.value, firstStringArgInterp: firstArg.interp }),
+                    ...(optionsMethod && { optionsMethod })
                 });
             } else if (funcNode.type === 'member_expression') {
                 // Method call: obj.foo() or foo.call/apply/bind()
@@ -1271,6 +1503,8 @@ function findCallsInCode(code, parser) {
                             }
                         }
                         const receiverType = receiver ? localVarTypes.get(receiver) : undefined;
+                        const firstArg = getFirstStringArg(node);
+                        const argCount = getArgCount(node);
                         calls.push({
                             name: propName,
                             line: node.startPosition.row + 1,
@@ -1278,7 +1512,9 @@ function findCallsInCode(code, parser) {
                             receiver,
                             ...(receiverType && { receiverType }),
                             enclosingFunction,
-                            uncertain
+                            uncertain,
+                            ...(firstArg && { firstStringArg: firstArg.value, firstStringArgInterp: firstArg.interp }),
+                            argCount
                         });
                     }
                 }
@@ -2165,12 +2401,32 @@ const _JS_LIFECYCLE_METHODS = new Set([
     'connectedCallback', 'disconnectedCallback', 'attributeChangedCallback', 'adoptedCallback'
 ]);
 
+/**
+ * Classify a JS/TS symbol as a runtime entry point of a specific kind.
+ * Returns 'framework' | null.
+ *
+ * - 'framework': React lifecycle methods (componentDidMount, etc.) and Web
+ *                Components callbacks (connectedCallback, etc.) — invoked by
+ *                the framework, not user code.
+ *
+ * Note: in JS/TS, test cases are framework calls (`it`, `test`, `describe`)
+ * not function definitions, so they aren't classified as test entry points
+ * here — `_addAffectedTestCases` in core/tracing.js handles them via call
+ * detection rather than this predicate.
+ *
+ * Used by tracing/search so `affectedTests` only tags genuine test cases.
+ */
+function getEntryPointKind(symbol) {
+    if (symbol.isMethod && _JS_LIFECYCLE_METHODS.has(symbol.name)) return 'framework';
+    return null;
+}
+
 /**
  * Check if a symbol is a JS/TS-convention entry point.
  * These are framework lifecycle methods invoked by React or Web Components.
  */
 function isEntryPoint(symbol) {
-    return !!(symbol.isMethod && _JS_LIFECYCLE_METHODS.has(symbol.name));
+    return getEntryPointKind(symbol) !== null;
 }
 
 module.exports = {
@@ -2184,5 +2440,6 @@ module.exports = {
     findExportsInCode,
     findUsagesInCode,
     isEntryPoint,
+    getEntryPointKind,
     parse
 };