ucn 3.8.23 → 3.8.25

package/languages/go.js

@@ -559,6 +559,32 @@ function findCallsInCode(code, parser, options = {}) {
     const tree = parseTree(parser, code);
     const calls = [];
     const functionStack = [];  // Stack of { name, startLine, endLine }
+
+    // Helper: extract first string-arg literal from a call_expression node.
+    // Used by route extraction to capture path arg of http.HandleFunc("/p", h),
+    // r.GET("/users", listUsers), and detect fmt.Sprintf("/users/%d", id).
+    const { extractStringArg: _extractStringArg, extractSprintfPrefix: _extractSprintfPrefix } = 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;
+            // fmt.Sprintf interpolation
+            if (arg.type === 'call_expression') {
+                const inner = arg.childForFieldName('function');
+                if (inner?.type === 'selector_expression') {
+                    const operand = inner.childForFieldName('operand');
+                    const field = inner.childForFieldName('field');
+                    if (operand?.text === 'fmt' && field && /^Sprintf$/.test(field.text)) {
+                        return _extractSprintfPrefix(arg);
+                    }
+                }
+            }
+            return _extractStringArg(arg);
+        }
+        return null;
+    };
     // Skip common non-function identifiers when detecting callback arguments
     const GO_SKIP_IDENTS = new Set(['nil', 'true', 'false', 'err', 'ctx', 'context', 'iota']);
     // Track local closure names per function scope (scopeStartLine -> Set<name>)
@@ -846,12 +872,14 @@ function findCallsInCode(code, parser, options = {}) {
                 if (isFuncTypedParam(callName)) return true;
 
                 // Direct call: foo()
+                const firstArg = getFirstStringArg(node);
                 calls.push({
                     name: callName,
                     line: node.startPosition.row + 1,
                     isMethod: false,
                     enclosingFunction,
-                    uncertain
+                    uncertain,
+                    ...(firstArg && { firstStringArg: firstArg.value, firstStringArgInterp: firstArg.interp })
                 });
             } else if (funcNode.type === 'selector_expression') {
                 // Method or package call: obj.Method() or pkg.Func()
@@ -864,6 +892,7 @@ function findCallsInCode(code, parser, options = {}) {
                     // 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;
+                    const firstArg = getFirstStringArg(node);
                     calls.push({
                         name: fieldNode.text,
                         line: node.startPosition.row + 1,
@@ -871,13 +900,55 @@ function findCallsInCode(code, parser, options = {}) {
                         receiver,
                         ...(receiverType && { receiverType }),
                         enclosingFunction,
-                        uncertain
+                        uncertain,
+                        ...(firstArg && { firstStringArg: firstArg.value, firstStringArgInterp: firstArg.interp })
                     });
                 }
             }
             return true;
         }
 
+        // R3-NEW-3: Detect Go struct composite literals as constructor calls.
+        //   Foo{x: 1}        → call(name='Foo', isConstructor:true)
+        //   pkg.Foo{...}     → call(name='Foo', isConstructor:true) — strip package
+        //   &Foo{...}        → composite_literal nested inside unary_expression;
+        //                       handled because we visit the inner composite_literal node.
+        // Skipped: anonymous types (slices/maps/arrays/struct types):
+        //   []int{...}, map[string]int{...}, struct{...}{...}, [3]int{...}
+        // These have non-identifier type children — only type_identifier and
+        // qualified_type produce a real type name.
+        if (node.type === 'composite_literal') {
+            // Skip composite literals that are nested inside another composite_literal's
+            // value position — those are inner field initializers like
+            // `Outer{ field: Inner{...} }`. Both the outer and inner are real
+            // constructors, so we DO emit each, but we must not emit the same
+            // node twice. Tree-sitter visits each node once, so this is fine.
+            const typeNode = node.childForFieldName('type');
+            if (typeNode) {
+                let typeName = null;
+                if (typeNode.type === 'type_identifier') {
+                    // Foo{...}
+                    typeName = typeNode.text;
+                } else if (typeNode.type === 'qualified_type') {
+                    // pkg.Foo{...}
+                    const tn = typeNode.childForFieldName('name');
+                    if (tn) typeName = tn.text;
+                }
+                // Skip anonymous types (slice_type, map_type, array_type, struct_type, etc.)
+                if (typeName) {
+                    const enclosingFunction = getCurrentEnclosingFunction();
+                    calls.push({
+                        name: typeName,
+                        line: node.startPosition.row + 1,
+                        isMethod: false,
+                        isConstructor: true,
+                        enclosingFunction,
+                        uncertain: false
+                    });
+                }
+            }
+        }
+
         // 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') {
@@ -1352,15 +1423,28 @@ function findUsagesInCode(code, name, parser) {
     return usages;
 }
 
+/**
+ * Classify a Go symbol as a runtime entry point of a specific kind.
+ * Returns 'test' | 'main' | null.
+ *
+ * - 'test': functions named Test*, Benchmark*, Example*, Fuzz* — invoked by `go test`.
+ * - 'main': fn main / fn init — invoked by the Go runtime.
+ *
+ * Used by tracing/search so `affectedTests` only tags genuine test functions.
+ */
+function getEntryPointKind(symbol) {
+    const { name } = symbol;
+    if (/^(Test|Benchmark|Example|Fuzz)[A-Z_]/.test(name)) return 'test';
+    if (name === 'main' || name === 'init') return 'main';
+    return null;
+}
+
 /**
  * Check if a symbol is a Go-convention entry point.
  * These are invoked by the Go runtime or test runner, not user code.
  */
 function isEntryPoint(symbol) {
-    const { name } = symbol;
-    if (name === 'main' || name === 'init') return true;
-    if (/^(Test|Benchmark|Example|Fuzz)[A-Z_]/.test(name)) return true;
-    return false;
+    return getEntryPointKind(symbol) !== null;
 }
 
 module.exports = {
@@ -1372,5 +1456,6 @@ module.exports = {
     findExportsInCode,
     findUsagesInCode,
     isEntryPoint,
+    getEntryPointKind,
     parse
 };

package/languages/html.js

@@ -311,6 +311,15 @@ function findUsagesInCode(code, name, parser) {
     return jsUsages.concat(handlerUsages);
 }
 
+/**
+ * Classify an HTML symbol as a runtime entry point.
+ * HTML has no entry points of its own — JS extracted from <script> blocks
+ * is classified by the JS predicate.
+ */
+function getEntryPointKind() {
+    return null;
+}
+
 /**
  * HTML has no entry points of its own.
  */
@@ -330,6 +339,7 @@ module.exports = {
     findExportsInCode,
     findUsagesInCode,
     isEntryPoint,
+    getEntryPointKind,
     // Exported for testing
     extractScriptBlocks,
     buildVirtualJSContent,

package/languages/java.js

@@ -63,12 +63,24 @@ function extractModifiers(node) {
         }
     }
 
-    // Also check text before parameter list for modifiers (avoid matching keywords in params)
-    // Use the parameters node position to find the real paren (not annotation parens)
+    // Also check text before the parameter list (methods) or the class body
+    // opening brace (classes/interfaces). Without this scope, the fallback
+    // would scan into field declarations and leak `private`/`final` from the
+    // body up onto the class signature.
     const text = node.text;
     const paramsNode = node.childForFieldName('parameters');
-    const paramOffset = paramsNode ? paramsNode.startIndex - node.startIndex : -1;
-    const preParams = paramOffset >= 0 ? text.substring(0, paramOffset) : text.split('\n').slice(0, 3).join(' ');
+    const bodyNode = node.childForFieldName('body');
+    let preParams;
+    if (paramsNode) {
+        preParams = text.substring(0, paramsNode.startIndex - node.startIndex);
+    } else if (bodyNode) {
+        preParams = text.substring(0, bodyNode.startIndex - node.startIndex);
+    } else {
+        // Last-resort fallback: only the first line. Class bodies start on
+        // their own line nearly always, so this avoids leaking field modifiers.
+        const firstLine = text.split('\n')[0] || '';
+        preParams = firstLine;
+    }
     const keywords = ['public', 'private', 'protected', 'static', 'final', 'abstract', 'synchronized', 'native', 'default'];
     for (const kw of keywords) {
         if (preParams.includes(kw + ' ') && !modifiers.includes(kw)) {
@@ -98,6 +110,80 @@ function extractAnnotations(node) {
     return annotations;
 }
 
+/**
+ * Extract annotations along with their string-literal first argument.
+ * Returns array of { name, args: string|null, firstStringArg: string|null }.
+ *   @GetMapping("/users/{id}")  →  { name: 'GetMapping', args: '"/users/{id}"', firstStringArg: '/users/{id}' }
+ *   @Override                   →  { name: 'Override', args: null, firstStringArg: null }
+ *   @RequestMapping(value = "/api", method = RequestMethod.GET)
+ *                               →  { name: 'RequestMapping', args: 'value = "/api", method = RequestMethod.GET',
+ *                                    firstStringArg: '/api' }
+ *
+ * @param {Node} node - Method/class node
+ * @returns {Array<{name: string, args: string|null, firstStringArg: string|null}>}
+ */
+function extractAnnotationsWithArgs(node) {
+    const result = [];
+    const modifiersNode = node.childForFieldName('modifiers') || (() => {
+        for (let i = 0; i < node.namedChildCount; i++) {
+            if (node.namedChild(i).type === 'modifiers') return node.namedChild(i);
+        }
+        return null;
+    })();
+    if (!modifiersNode) return result;
+
+    for (let i = 0; i < modifiersNode.namedChildCount; i++) {
+        const mod = modifiersNode.namedChild(i);
+        if (mod.type === 'marker_annotation') {
+            // @Override (no args)
+            const nameNode = mod.childForFieldName('name');
+            if (nameNode) {
+                result.push({ name: nameNode.text, args: null, firstStringArg: null });
+            }
+        } else if (mod.type === 'annotation') {
+            const nameNode = mod.childForFieldName('name');
+            const argsNode = mod.childForFieldName('arguments');
+            const name = nameNode ? nameNode.text : null;
+            const argsRaw = argsNode ? argsNode.text.replace(/^\(|\)$/g, '') : null;
+            // Find first string-literal arg (handles positional and value=... patterns)
+            let firstStringArg = null;
+            if (argsNode) {
+                // Walk children: positional string_literal OR element_value_pair with key 'value'
+                for (let j = 0; j < argsNode.namedChildCount; j++) {
+                    const child = argsNode.namedChild(j);
+                    if (child.type === 'string_literal') {
+                        firstStringArg = stripJavaString(child.text);
+                        break;
+                    }
+                    if (child.type === 'element_value_pair') {
+                        const key = child.childForFieldName('key');
+                        const value = child.childForFieldName('value');
+                        if (key?.text === 'value' && value?.type === 'string_literal') {
+                            firstStringArg = stripJavaString(value.text);
+                            break;
+                        }
+                    }
+                }
+                // Fallback: first string_literal anywhere in subtree (handles path = "/x")
+                if (!firstStringArg) {
+                    const m = argsNode.text.match(/"([^"\\]|\\.)*"/);
+                    if (m) firstStringArg = m[0].slice(1, -1);
+                }
+            }
+            if (name) {
+                result.push({ name, args: argsRaw, firstStringArg });
+            }
+        }
+    }
+    return result;
+}
+
+function stripJavaString(text) {
+    if (!text) return text;
+    if (text.startsWith('"') && text.endsWith('"')) return text.slice(1, -1);
+    return text;
+}
+
 /**
  * Extract return type from method
  */
@@ -144,6 +230,7 @@ function _processFunction(node, functions, processedRanges, lines, code) {
             const { startLine, endLine, indent } = nodeToLocation(node, lines);
             const modifiers = extractModifiers(node);
             const annotations = extractAnnotations(node);
+            const annotationsWithArgs = extractAnnotationsWithArgs(node);
             const returnType = extractReturnType(node);
             const generics = extractGenerics(node);
             const docstring = extractJavaDocstring(lines, startLine);
@@ -162,6 +249,7 @@ function _processFunction(node, functions, processedRanges, lines, code) {
                 ...(generics && { generics }),
                 ...(docstring && { docstring }),
                 ...(annotations.length > 0 && { annotations }),
+                ...(annotationsWithArgs.length > 0 && { annotationsWithArgs }),
                 ...(nameLine !== startLine && { nameLine })
             });
         }
@@ -187,6 +275,7 @@ function _processFunction(node, functions, processedRanges, lines, code) {
             const { startLine, endLine, indent } = nodeToLocation(node, lines);
             const modifiers = extractModifiers(node);
             const annotations = extractAnnotations(node);
+            const annotationsWithArgs = extractAnnotationsWithArgs(node);
             const docstring = extractJavaDocstring(lines, startLine);
             const nameLine = nameNode.startPosition.row + 1;
 
@@ -245,6 +334,7 @@ function _processClass(node, classes, processedRanges, lines, code) {
             const members = extractClassMembers(node, lines);
             const modifiers = extractModifiers(node);
             const annotations = extractAnnotations(node);
+            const annotationsWithArgs = extractAnnotationsWithArgs(node);
             const docstring = extractJavaDocstring(lines, startLine);
             const generics = extractGenerics(node);
             const extendsInfo = extractExtends(node);
@@ -265,6 +355,7 @@ function _processClass(node, classes, processedRanges, lines, code) {
                 ...(docstring && { docstring }),
                 ...(generics && { generics }),
                 ...(annotations.length > 0 && { annotations }),
+                ...(annotationsWithArgs.length > 0 && { annotationsWithArgs }),
                 ...(extendsInfo && { extends: extendsInfo }),
                 ...(implementsInfo.length > 0 && { implements: implementsInfo })
             });
@@ -283,6 +374,7 @@ function _processClass(node, classes, processedRanges, lines, code) {
             const { startLine, endLine } = nodeToLocation(node, lines);
             const modifiers = extractModifiers(node);
             const annotations = extractAnnotations(node);
+            const annotationsWithArgs = extractAnnotationsWithArgs(node);
             const docstring = extractJavaDocstring(lines, startLine);
             const generics = extractGenerics(node);
             const extendsInfo = extractInterfaceExtends(node);
@@ -297,6 +389,7 @@ function _processClass(node, classes, processedRanges, lines, code) {
                 ...(docstring && { docstring }),
                 ...(generics && { generics }),
                 ...(annotations.length > 0 && { annotations }),
+                ...(annotationsWithArgs.length > 0 && { annotationsWithArgs }),
                 ...(extendsInfo.length > 0 && { extends: extendsInfo.join(', ') })
             });
         }
@@ -314,6 +407,7 @@ function _processClass(node, classes, processedRanges, lines, code) {
             const { startLine, endLine } = nodeToLocation(node, lines);
             const modifiers = extractModifiers(node);
             const annotations = extractAnnotations(node);
+            const annotationsWithArgs = extractAnnotationsWithArgs(node);
             const docstring = extractJavaDocstring(lines, startLine);
 
             classes.push({
@@ -341,6 +435,7 @@ function _processClass(node, classes, processedRanges, lines, code) {
             const { startLine, endLine } = nodeToLocation(node, lines);
             const modifiers = extractModifiers(node);
             const annotations = extractAnnotations(node);
+            const annotationsWithArgs = extractAnnotationsWithArgs(node);
             const docstring = extractJavaDocstring(lines, startLine);
             const generics = extractGenerics(node);
             const implementsInfo = extractImplements(node);
@@ -566,6 +661,7 @@ function extractClassMembers(classNode, codeOrLines) {
             if (nameNode) {
                 const { startLine, endLine } = nodeToLocation(child, code);
                 const modifiers = extractModifiers(child);
+                const annotationsWithArgs = extractAnnotationsWithArgs(child);
                 // Interface methods are implicitly public and abstract in Java
                 if (isInterface) {
                     if (!modifiers.includes('public')) modifiers.push('public');
@@ -595,36 +691,19 @@ function extractClassMembers(classNode, codeOrLines) {
                     isMethod: true,  // Mark as method for context() lookups
                     ...(returnType && { returnType }),
                     ...(docstring && { docstring }),
+                    ...(annotationsWithArgs.length > 0 && { annotationsWithArgs }),
                     ...(nameLine !== startLine && { nameLine })
                 });
             }
         }
 
-        // Constructor declarations
-        if (child.type === 'constructor_declaration') {
-            const nameNode = child.childForFieldName('name');
-            const paramsNode = child.childForFieldName('parameters');
-
-            if (nameNode) {
-                const { startLine, endLine } = nodeToLocation(child, code);
-                const modifiers = extractModifiers(child);
-                const docstring = extractJavaDocstring(code, startLine);
-                const nameLine = nameNode.startPosition.row + 1;
-
-                members.push({
-                    name: nameNode.text,
-                    params: extractJavaParams(paramsNode),
-                    paramsStructured: parseStructuredParams(paramsNode, 'java'),
-                    startLine,
-                    endLine,
-                    memberType: 'constructor',
-                    modifiers,
-                    isMethod: true,  // Mark as method for context() lookups
-                    ...(docstring && { docstring }),
-                    ...(nameLine !== startLine && { nameLine })
-                });
-            }
-        }
+        // Constructor declarations: intentionally NOT emitted as separate class
+        // members. The class itself is the symbol; `new Foo(...)` calls resolve
+        // to the class via `isConstructor: true` on the call. Emitting the
+        // constructor as a member would create duplicate `find Foo` results
+        // (one for class, one for constructor), forcing users to disambiguate.
+        // Constructor signature info (params, line) remains accessible by reading
+        // the class body when needed (e.g. via verify's AST walk).
     }
 
     return members;
@@ -726,6 +805,20 @@ function findCallsInCode(code, parser) {
     // Track variable -> type mappings per function scope (scopeStartLine -> Map<varName, typeName>)
     const scopeTypes = new Map();
 
+    // Helper: extract first string-arg literal from a method_invocation node.
+    // Used by route extraction to capture path arg of webClient.uri("/users") 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 to check if a node creates a function scope
     const isFunctionNode = (node) => {
         return ['method_declaration', 'constructor_declaration', 'lambda_expression'].includes(node.type);
@@ -827,13 +920,15 @@ function findCallsInCode(code, parser) {
                 const enclosingFunction = getCurrentEnclosingFunction();
                 const receiver = (objNode?.type === 'identifier' || objNode?.type === 'this') ? objNode.text : undefined;
                 const receiverType = (receiver && receiver !== 'this') ? getReceiverType(receiver) : undefined;
+                const firstArg = getFirstStringArg(node);
                 calls.push({
                     name: nameNode.text,
                     line: node.startPosition.row + 1,
                     isMethod: !!objNode,
                     receiver,
                     ...(receiverType && { receiverType }),
-                    enclosingFunction
+                    enclosingFunction,
+                    ...(firstArg && { firstStringArg: firstArg.value, firstStringArgInterp: firstArg.interp })
                 });
             }
             return true;
@@ -1173,16 +1268,36 @@ function findUsagesInCode(code, name, parser) {
     return usages;
 }
 
+/**
+ * Classify a Java symbol as a runtime entry point of a specific kind.
+ * Returns 'test' | 'main' | 'framework' | null.
+ *
+ * - 'test': JUnit @Test family (Test, ParameterizedTest, RepeatedTest,
+ *           TestFactory, TestTemplate) and JUnit lifecycle hooks
+ *           (BeforeEach, AfterEach, BeforeAll, AfterAll).
+ * - 'main': public static void main() — invoked by the JVM.
+ * - 'framework': @Override methods (invoked by the type-system contract).
+ *
+ * Used by tracing/search so `affectedTests` only tags genuine test methods.
+ */
+function getEntryPointKind(symbol) {
+    const m = symbol.modifiers || [];
+    // JUnit @Test family — full lowercase set so deadcode/test detection treats
+    // ParameterizedTest, RepeatedTest, TestFactory, TestTemplate as test entry points.
+    const TEST_ANNOTATIONS = ['test', 'parameterizedtest', 'repeatedtest', 'testfactory', 'testtemplate',
+        'beforeeach', 'aftereach', 'beforeall', 'afterall', 'before', 'after'];
+    if (m.some(x => TEST_ANNOTATIONS.includes(x))) return 'test';
+    if (symbol.name === 'main' && m.includes('public') && m.includes('static')) return 'main';
+    if (m.includes('override')) return 'framework';
+    return null;
+}
+
 /**
  * Check if a symbol is a Java-convention entry point.
  * These are invoked by the JVM runtime, test runners, or required by type system.
  */
 function isEntryPoint(symbol) {
-    const m = symbol.modifiers || [];
-    if (symbol.name === 'main' && m.includes('public') && m.includes('static')) return true;
-    if (m.includes('test')) return true;
-    if (m.includes('override')) return true;
-    return false;
+    return getEntryPointKind(symbol) !== null;
 }
 
 module.exports = {
@@ -1194,5 +1309,6 @@ module.exports = {
     findExportsInCode,
     findUsagesInCode,
     isEntryPoint,
+    getEntryPointKind,
     parse
 };