gitnexus 1.6.10-rc.216 → 1.6.10-rc.218

package/dist/core/group/extractors/http-patterns/java.js

@@ -2,6 +2,7 @@ import Java from 'tree-sitter-java';
 import { compilePatterns, runCompiledPatterns, unquoteLiteral, } from '../tree-sitter-scanner.js';
 import { springAnnotationHttpMethods, intersectSpringHttpMethods, isRouteMemberKey, findEnclosingClass, joinPath, } from '../../../ingestion/route-extractors/spring-shared.js';
 import { REST_TEMPLATE_TO_HTTP, WEB_CLIENT_SHORT_TO_HTTP, WEB_CLIENT_LONG_VERB_RE, EXCHANGE_ANNOTATION_TO_HTTP, parseRequestLine, pushPrefix, scanSpringInheritanceProject, OPENFEIGN_FRAMEWORK, HTTP_INTERFACE_FRAMEWORK, FEIGN_CONFIDENCE, REQUEST_LINE_CONFIDENCE, EXCHANGE_CONFIDENCE, } from './spring-consumer-shared.js';
+import { extractJavaModuleConstants, foldJavaOperands, isJavaConstantFile, parseJavaConstOperands, } from '../../../ingestion/route-extractors/java-const-resolver.js';
 import { extractStaticPathExpression, inferOkHttpMethod, inferHttpClientMethod, okHttpUrlRootsAtBuilder, httpClientUriRootsAtNewBuilder, httpClientChainHasUriCall, } from './java-static-path.js';
 /**
  * Java HTTP plugin. Handles:
@@ -123,6 +124,34 @@ const JAVA_ROUTE_ANNOTATION_PATTERNS = compilePatterns({
                     key: (identifier) @key
                     value: [(string_literal) @value (element_value_array_initializer (string_literal) @value)]))))
             name: (identifier) @member) @node
+          (class_declaration
+            (modifiers
+              (annotation
+                name: [(identifier) (scoped_identifier)] @ann
+                arguments: (annotation_argument_list [(identifier) @value_expr (field_access) @value_expr (binary_expression) @value_expr])))) @node
+          (class_declaration
+            (modifiers
+              (annotation
+                name: [(identifier) (scoped_identifier)] @ann
+                arguments: (annotation_argument_list
+                  (element_value_pair
+                    key: (identifier) @key
+                    value: [(identifier) @value_expr (field_access) @value_expr (binary_expression) @value_expr]))))) @node
+          (method_declaration
+            (modifiers
+              (annotation
+                name: [(identifier) (scoped_identifier)] @ann
+                arguments: (annotation_argument_list [(identifier) @value_expr (field_access) @value_expr (binary_expression) @value_expr])))
+            name: (identifier) @member) @node
+          (method_declaration
+            (modifiers
+              (annotation
+                name: [(identifier) (scoped_identifier)] @ann
+                arguments: (annotation_argument_list
+                  (element_value_pair
+                    key: (identifier) @key
+                    value: [(identifier) @value_expr (field_access) @value_expr (binary_expression) @value_expr]))))
+            name: (identifier) @member) @node
         ]
       `,
         },
@@ -407,6 +436,7 @@ function scanRouteAnnotations(tree) {
     // feeds the OpenFeign *consumer* path in scan(). An interface carrying both
     // `@RequestMapping` and `@FeignClient(path)` lands a different value in each.
     const prefixByTypeId = new Map();
+    const typesWithUnfoldablePrefix = new Set();
     const feignPrefixByInterfaceId = new Map();
     const httpExchangePrefixByTypeId = new Map();
     const methodRoutes = [];
@@ -422,7 +452,10 @@ function scanRouteAnnotations(tree) {
         const annNode = captures.ann;
         const node = captures.node;
         const valueNode = captures.value;
-        if (!annNode || !node || !valueNode)
+        // A non-literal annotation value (constant ref / `+`-concat) is captured
+        // as @value_expr instead of @value — one of the two must be present.
+        const valueExprNode = captures.value_expr;
+        if (!annNode || !node || (!valueNode && !valueExprNode))
             continue;
         // Discrimination is on the trailing segment only (`simpleName`), so a
         // non-Spring annotation whose last segment collides with a route annotation
@@ -446,7 +479,7 @@ function scanRouteAnnotations(tree) {
                 const feignHttpMethod = httpMethods.length === 1 ? (httpMethods[0] === '*' ? 'GET' : httpMethods[0]) : null;
                 if (!isRouteMemberKey(keyNode))
                     continue;
-                const rawPath = unquoteLiteral(valueNode.text);
+                const rawPath = valueNode ? unquoteLiteral(valueNode.text) : null;
                 if (rawPath !== null) {
                     for (const httpMethod of httpMethods) {
                         methodRoutes.push({
@@ -458,11 +491,36 @@ function scanRouteAnnotations(tree) {
                         });
                     }
                 }
+                else {
+                    // Non-literal path (a constant reference or `+`-concatenation).
+                    // Defer to scan(): the fold needs the repo-wide constant map built
+                    // by prepareRepo. Capture the operand list now; resolution happens
+                    // in scan() against JavaRepoContext, and an unresolvable operand
+                    // list leaves the route skipped (KTD5 skip floor).
+                    const operands = parseJavaConstOperands(valueExprNode);
+                    if (operands !== null) {
+                        for (const httpMethod of httpMethods) {
+                            methodRoutes.push({
+                                methodNode: node,
+                                methodName: captures.member?.text ?? null,
+                                httpMethod,
+                                rawPath: '',
+                                feignHttpMethod,
+                                pathOperands: operands,
+                            });
+                        }
+                    }
+                }
             }
             else if (ann === 'RequestLine') {
                 // Feign packs verb + path in one literal; its only named argument is `value`.
                 if (keyNode && keyNode.text !== 'value')
                     continue;
+                // A constant-valued `@RequestLine` arrives as @value_expr, not @value —
+                // `valueNode` is undefined in that shape. Skip rather than dereference
+                // (constant folding for Feign verb+path literals is out of scope here).
+                if (!valueNode)
+                    continue;
                 const raw = unquoteLiteral(valueNode.text);
                 const parsed = raw !== null ? parseRequestLine(raw) : null;
                 if (parsed) {
@@ -479,7 +537,7 @@ function scanRouteAnnotations(tree) {
                 // (`accept`, `contentType`, …) are not routes.
                 if (keyNode && keyNode.text !== 'url' && keyNode.text !== 'value')
                     continue;
-                const rawPath = unquoteLiteral(valueNode.text);
+                const rawPath = valueNode ? unquoteLiteral(valueNode.text) : null;
                 if (rawPath !== null) {
                     exchangeRoutes.push({
                         methodNode: node,
@@ -496,6 +554,11 @@ function scanRouteAnnotations(tree) {
         if (ann === 'RequestMapping') {
             if (!isRouteMemberKey(keyNode))
                 continue;
+            if (!valueNode) {
+                // Constant-valued class prefix — see `typesWithUnfoldablePrefix`.
+                typesWithUnfoldablePrefix.add(node.id);
+                continue;
+            }
             const prefix = unquoteLiteral(valueNode.text);
             if (prefix !== null) {
                 pushPrefix(prefixByTypeId, node.id, prefix);
@@ -508,7 +571,7 @@ function scanRouteAnnotations(tree) {
             // Feign's `name`/`value` identify a service, not a path — only `path` is a prefix.
             if (!keyNode || keyNode.text !== 'path')
                 continue;
-            const prefix = unquoteLiteral(valueNode.text);
+            const prefix = valueNode ? unquoteLiteral(valueNode.text) : null;
             if (prefix !== null)
                 pushPrefix(feignPrefixByInterfaceId, node.id, prefix);
         }
@@ -517,7 +580,7 @@ function scanRouteAnnotations(tree) {
             // (or positionally). Applies to its `@(Get|...)Exchange` consumer methods.
             if (keyNode && keyNode.text !== 'url' && keyNode.text !== 'value')
                 continue;
-            const prefix = unquoteLiteral(valueNode.text);
+            const prefix = valueNode ? unquoteLiteral(valueNode.text) : null;
             if (prefix !== null)
                 pushPrefix(httpExchangePrefixByTypeId, node.id, prefix);
         }
@@ -566,6 +629,7 @@ function scanRouteAnnotations(tree) {
     }
     return {
         prefixByTypeId,
+        typesWithUnfoldablePrefix,
         feignPrefixByInterfaceId,
         httpExchangePrefixByTypeId,
         methodRoutes: constrainedMethodRoutes,
@@ -608,9 +672,22 @@ function collectImplementedInterfaces(typeNode) {
     return out;
 }
 function collectSpringTypes(filePath, tree) {
-    const { prefixByTypeId, methodRoutes } = scanRouteAnnotations(tree);
+    const { prefixByTypeId, typesWithUnfoldablePrefix, methodRoutes } = scanRouteAnnotations(tree);
     const routesByMethodId = new Map();
     for (const route of methodRoutes) {
+        // Constant-valued class prefix: no single prefix string exists here, so the
+        // inheritance view would publish this route unprefixed. Skip — same rule as
+        // scan() and as ingestion (R4 parity).
+        const owner = findEnclosingClass(route.methodNode);
+        if (owner && typesWithUnfoldablePrefix.has(owner.id))
+            continue;
+        // A constant-referencing route still carries `rawPath: ''` here — folding
+        // happens in scan() against the repo constant map, which this
+        // inheritance-view collector has no access to. Emitting it as an empty
+        // path would publish `POST /`-shaped noise into the shared type view;
+        // skip instead (ingestion keeps the same skip floor — R4 parity).
+        if (route.pathOperands)
+            continue;
         const routes = routesByMethodId.get(route.methodNode.id) ?? [];
         routes.push({ method: route.httpMethod, path: route.rawPath });
         routesByMethodId.set(route.methodNode.id, routes);
@@ -671,19 +748,121 @@ export const JAVA_HTTP_PLUGIN = {
     hasConsumerSignals(content) {
         return /\brestTemplate\b|\bwebClient\b|Request\.Builder|HttpRequest|HttpMethod\.|new\s+Http(Get|Post|Put|Delete|Patch)\b|@RequestLine|@FeignClient|Exchange/.test(content);
     },
-    scan(tree) {
+    prepareRepo(args) {
+        // Build the repo-wide Java string-constant map once per extract() run
+        // (mirrors the Python binding's cost-gated pre-pass). A cheap content
+        // gate keeps literal-only repos at zero parses: only files containing a
+        // `static final String` declaration are parsed for constants.
+        try {
+            // The orchestrator hands over a bare Parser (no language set yet);
+            // bind Java explicitly — Python's prepareRepo does the same — otherwise
+            // parseSourceSafe spins to its 15 s budget per file.
+            args.parser.setLanguage(Java);
+        }
+        catch {
+            // fall through: a parser that rejects binding cannot produce a constant
+            // map; per-file try/catch below then skips everything harmlessly.
+        }
+        const constants = new Map();
+        for (const rel of args.files) {
+            if (!rel.endsWith('.java'))
+                continue;
+            try {
+                const src = args.readFile(rel);
+                // Cheap content gate: only constant-DEFINITION candidates get parsed
+                // here (~hundreds of files). Import-only files (every controller)
+                // are deliberately NOT parsed in this pass — scan() lazily extracts
+                // the importing file's own import table from the tree it already
+                // holds when a constant-referencing route actually needs the fold.
+                // A gate that also matched `import ...;` would parse the entire
+                // repository here (tens of thousands of files) just to build import
+                // tables the fold can derive per-file on demand.
+                //
+                // The predicate is the SHARED one the ingestion provider uses, so the
+                // two subsystems agree on which files define constants. Its previous
+                // local spelling missed `final static String` and lowercase interface
+                // names, and admitted an interface that ingestion's gate rejected.
+                if (!src || !isJavaConstantFile(src)) {
+                    continue;
+                }
+                const tree = args.parseSource(args.parser, src);
+                if (!tree)
+                    continue;
+                const mc = extractJavaModuleConstants(tree);
+                if (mc.literals.size > 0 || mc.exprs.size > 0 || mc.imports.size > 0) {
+                    constants.set(rel, mc);
+                }
+            }
+            catch {
+                // Per-file resilience: one unreadable/oversized/ill-formed file must
+                // not forfeit the whole repo's constant map (a missing constants
+                // class only degrades refs that pointed at it).
+                continue;
+            }
+        }
+        return { constants };
+    },
+    scan(tree, repoContext, fileRel) {
         const out = [];
+        const javaCtx = repoContext;
         // ─── Spring providers + OpenFeign consumers (one query pass) ────
         // `scanRouteAnnotations` resolves every route-defining annotation —
         // class/interface prefixes, method shortcut/`@RequestMapping`s and native
         // `@RequestLine`s — from a single `matches()` pass over the tree.
-        const { prefixByTypeId, feignPrefixByInterfaceId, httpExchangePrefixByTypeId, methodRoutes, requestLines, exchangeRoutes, } = scanRouteAnnotations(tree);
+        const { prefixByTypeId, typesWithUnfoldablePrefix, feignPrefixByInterfaceId, httpExchangePrefixByTypeId, methodRoutes, requestLines, exchangeRoutes, } = scanRouteAnnotations(tree);
         // A `@(Get|...)Mapping` inside a `@FeignClient` interface is an OpenFeign
         // *consumer* (it describes a remote call); the same annotation inside a
         // class is a Spring *provider*. A mapping on a non-Feign interface has no
         // enclosing class and is dropped here — interface→controller inheritance is
         // handled by `scanProject`.
+        // Lazy per-file constants view. prepareRepo only indexes constant-
+        // DEFINING files (cheap gate); an importing controller is absent from
+        // that map. When a route actually references a constant, extract THIS
+        // file's import table from the tree scan() already holds (zero extra
+        // parses) and overlay it for the fold. Files whose routes are all
+        // literal — the overwhelming majority — never pay this cost.
+        let foldConstants;
+        const getFoldConstants = () => {
+            if (foldConstants !== undefined)
+                return foldConstants;
+            foldConstants = javaCtx?.constants;
+            if (!javaCtx?.constants || !fileRel)
+                return foldConstants;
+            if (javaCtx.constants.has(fileRel))
+                return foldConstants;
+            try {
+                const mc = extractJavaModuleConstants(tree);
+                if (mc.imports.size > 0) {
+                    const merged = new Map(javaCtx.constants);
+                    merged.set(fileRel, mc);
+                    foldConstants = merged;
+                }
+            }
+            catch {
+                // fold falls back to the repo-wide map (imports stay unresolved)
+            }
+            return foldConstants;
+        };
         for (const route of methodRoutes) {
+            // A constant-valued CLASS prefix cannot be folded here, so every method
+            // route under such a class is suppressed rather than emitted at a wrong
+            // (unprefixed) path — the same rule `classesWithArrayPrefix` already
+            // encodes for the array form, and the same rule ingestion applies.
+            const owner = findEnclosingClass(route.methodNode);
+            if (owner && typesWithUnfoldablePrefix.has(owner.id))
+                continue;
+            // Non-literal route path: fold the operand list against the repo-wide
+            // constant map. Skip (never a guessed path) when the fold fails or the
+            // repo context is absent (context-less fallback scanning).
+            if (route.pathOperands && javaCtx && fileRel) {
+                const resolved = foldJavaOperands(fileRel, route.pathOperands, getFoldConstants());
+                if (resolved === null)
+                    continue;
+                route.rawPath = resolved;
+            }
+            else if (route.pathOperands) {
+                continue;
+            }
             const enclosingInterface = findEnclosingInterface(route.methodNode);
             if (enclosingInterface && hasAnnotation(enclosingInterface, 'FeignClient')) {
                 if (!route.feignHttpMethod)