gitnexus 1.6.10-rc.21 → 1.6.10-rc.211

package/dist/core/ingestion/route-extractors/spring-shared.d.ts

@@ -25,6 +25,17 @@ import type Parser from 'tree-sitter';
  * separately.
  */
 export declare const METHOD_ANNOTATION_TO_HTTP: Record<string, string>;
+/**
+ * Resolve a method-level Spring mapping annotation to its HTTP method(s).
+ *
+ * Shortcut annotations have one implicit verb. `@RequestMapping` may declare
+ * one or more static `RequestMethod.X` values; when its `method` member is
+ * absent or an empty array, `'*'` preserves Spring's method-agnostic semantics.
+ * A present but non-static method expression yields no methods (fail closed).
+ */
+export declare function springAnnotationHttpMethods(annotationName: string, annotationText: string): readonly string[];
+/** Intersect class- and method-level Spring mapping constraints. */
+export declare function intersectSpringHttpMethods(classMethods: readonly string[], methodMethods: readonly string[]): readonly string[];
 /**
  * A named annotation argument contributes a route only when its member key is
  * `path` or `value`; a positional argument (no key node) always qualifies.

package/dist/core/ingestion/route-extractors/spring-shared.js

@@ -15,6 +15,7 @@
  * `ingestion/import-resolvers/utils.ts`). It MUST NOT import anything from
  * `group/` to avoid a dependency cycle.
  */
+import { parseSpringAnnotationArguments } from '../frameworks/spring/annotation-arguments.js';
 /**
  * Spring shortcut method-annotation → HTTP verb.
  *
@@ -30,6 +31,94 @@ export const METHOD_ANNOTATION_TO_HTTP = {
     DeleteMapping: 'DELETE',
     PatchMapping: 'PATCH',
 };
+/**
+ * Parse one `RequestMethod.X` literal or a Java annotation array of literals.
+ * An empty array is valid and means Spring's unrestricted/default method set.
+ * Runtime expressions fail closed instead of producing a guessed route.
+ */
+function parseRequestMethodValues(value) {
+    let trimmed = '';
+    for (let index = 0; index < value.length; index += 1) {
+        const char = value[index];
+        const next = value[index + 1];
+        if (/\s/.test(char))
+            continue;
+        if (char === '/' && next === '*') {
+            const commentEnd = value.indexOf('*/', index + 2);
+            if (commentEnd < 0)
+                return null;
+            index = commentEnd + 1;
+            continue;
+        }
+        if (char === '/' && next === '/') {
+            const lineEnd = value.slice(index + 2).search(/[\r\n]/);
+            if (lineEnd < 0)
+                return null;
+            index += lineEnd + 1;
+            continue;
+        }
+        trimmed += char;
+    }
+    const hasOpeningBrace = trimmed.startsWith('{');
+    const hasClosingBrace = trimmed.endsWith('}');
+    if (hasOpeningBrace !== hasClosingBrace)
+        return null;
+    const body = hasOpeningBrace ? trimmed.slice(1, -1).trim() : trimmed;
+    if (body.length === 0)
+        return [];
+    if (!hasOpeningBrace && body.includes(','))
+        return null;
+    const methods = [];
+    const parts = body.split(',');
+    if (hasOpeningBrace && parts[parts.length - 1].trim() === '')
+        parts.pop();
+    for (const rawPart of parts) {
+        const part = rawPart.trim();
+        const match = /^(?:(?:[A-Za-z_$][A-Za-z0-9_$]*\.)*RequestMethod\.)?(GET|HEAD|POST|PUT|PATCH|DELETE|OPTIONS|TRACE)$/.exec(part);
+        if (!match)
+            return null;
+        if (!methods.includes(match[1]))
+            methods.push(match[1]);
+    }
+    return methods;
+}
+/**
+ * Resolve a method-level Spring mapping annotation to its HTTP method(s).
+ *
+ * Shortcut annotations have one implicit verb. `@RequestMapping` may declare
+ * one or more static `RequestMethod.X` values; when its `method` member is
+ * absent or an empty array, `'*'` preserves Spring's method-agnostic semantics.
+ * A present but non-static method expression yields no methods (fail closed).
+ */
+export function springAnnotationHttpMethods(annotationName, annotationText) {
+    const shortcut = METHOD_ANNOTATION_TO_HTTP[annotationName];
+    if (shortcut)
+        return [shortcut];
+    if (annotationName !== 'RequestMapping')
+        return [];
+    const args = parseSpringAnnotationArguments(annotationText);
+    if (args === null)
+        return [];
+    const methodArgs = args.filter((arg) => arg.name === 'method');
+    if (methodArgs.length === 0)
+        return ['*'];
+    if (methodArgs.length !== 1)
+        return [];
+    const methods = parseRequestMethodValues(methodArgs[0].value);
+    if (methods === null)
+        return [];
+    return methods.length > 0 ? methods : ['*'];
+}
+/** Intersect class- and method-level Spring mapping constraints. */
+export function intersectSpringHttpMethods(classMethods, methodMethods) {
+    if (classMethods.length === 0 || methodMethods.length === 0)
+        return [];
+    if (classMethods.includes('*'))
+        return methodMethods;
+    if (methodMethods.includes('*'))
+        return classMethods;
+    return methodMethods.filter((method) => classMethods.includes(method));
+}
 /**
  * A named annotation argument contributes a route only when its member key is
  * `path` or `value`; a positional argument (no key node) always qualifies.

package/dist/core/ingestion/route-extractors/spring.js

@@ -20,7 +20,7 @@
  */
 import Parser from 'tree-sitter';
 import Java from 'tree-sitter-java';
-import { METHOD_ANNOTATION_TO_HTTP, isRouteMemberKey, findEnclosingType, unquoteSpringLiteral, } from './spring-shared.js';
+import { intersectSpringHttpMethods, springAnnotationHttpMethods, isRouteMemberKey, findEnclosingType, unquoteSpringLiteral, } from './spring-shared.js';
 /**
  * Single predicate-free tree-sitter query that captures all route annotations
  * on classes and methods. Discrimination by annotation name and node type
@@ -49,14 +49,14 @@ const ROUTE_ANNOTATION_QUERY = new Parser.Query(Java, `
     (class_declaration
       (modifiers
         (annotation
-          name: (identifier) @ann
+          name: [(identifier) (scoped_identifier)] @ann
           arguments: (annotation_argument_list
             [(string_literal) @value
              (element_value_array_initializer (string_literal) @value)])))) @node
     (class_declaration
       (modifiers
         (annotation
-          name: (identifier) @ann
+          name: [(identifier) (scoped_identifier)] @ann
           arguments: (annotation_argument_list
             (element_value_pair
               key: (identifier) @key
@@ -65,14 +65,14 @@ const ROUTE_ANNOTATION_QUERY = new Parser.Query(Java, `
     (method_declaration
       (modifiers
         (annotation
-          name: (identifier) @ann
+          name: [(identifier) (scoped_identifier)] @ann
           arguments: (annotation_argument_list
             [(string_literal) @value
              (element_value_array_initializer (string_literal) @value)])))) @node
     (method_declaration
       (modifiers
         (annotation
-          name: (identifier) @ann
+          name: [(identifier) (scoped_identifier)] @ann
           arguments: (annotation_argument_list
             (element_value_pair
               key: (identifier) @key
@@ -103,6 +103,13 @@ export function extractSpringRoutes(tree, filePath, lineOffset = 0) {
     // class-array cross-product support is out of scope here.
     const prefixByClassId = new Map();
     const classesWithArrayPrefix = new Set();
+    const classHttpMethodsById = new Map();
+    for (const match of TYPE_DECLARATION_QUERY.matches(tree.rootNode)) {
+        const typeNode = match.captures.find((capture) => capture.name === 'type')?.node;
+        if (typeNode?.type === 'class_declaration') {
+            classHttpMethodsById.set(typeNode.id, typeRequestMethods(typeNode));
+        }
+    }
     for (const match of matches) {
         const caps = {};
         for (const { name, node } of match.captures) {
@@ -114,7 +121,8 @@ export function extractSpringRoutes(tree, filePath, lineOffset = 0) {
         const keyNode = caps['key'];
         if (!annNode || !node || !valueNode)
             continue;
-        if (node.type === 'class_declaration' && annNode.text === 'RequestMapping') {
+        const capturedAnnotationName = annNode.text.split('.').pop() ?? annNode.text;
+        if (node.type === 'class_declaration' && capturedAnnotationName === 'RequestMapping') {
             if (!isRouteMemberKey(keyNode))
                 continue;
             if (valueNode.parent?.type === 'element_value_array_initializer') {
@@ -128,6 +136,7 @@ export function extractSpringRoutes(tree, filePath, lineOffset = 0) {
     }
     // Phase 2: collect method-level routes and resolve their class prefix
     const routes = [];
+    const httpMethodsByAnnotationId = new Map();
     for (const match of matches) {
         const caps = {};
         for (const { name, node } of match.captures) {
@@ -141,10 +150,17 @@ export function extractSpringRoutes(tree, filePath, lineOffset = 0) {
             continue;
         if (node.type !== 'method_declaration')
             continue;
-        const ann = annNode.text;
-        const httpMethod = METHOD_ANNOTATION_TO_HTTP[ann];
-        if (!httpMethod)
-            continue; // skip @RequestMapping on methods (ambiguous verb)
+        const ann = annNode.text.split('.').pop() ?? annNode.text;
+        const annotationNode = annNode.parent;
+        if (!annotationNode)
+            continue;
+        let methodMethods = httpMethodsByAnnotationId.get(annotationNode.id);
+        if (!methodMethods) {
+            methodMethods = springAnnotationHttpMethods(ann, annotationNode.text);
+            httpMethodsByAnnotationId.set(annotationNode.id, methodMethods);
+        }
+        if (methodMethods.length === 0)
+            continue;
         if (!isRouteMemberKey(keyNode))
             continue;
         const routePath = unquoteSpringLiteral(valueNode.text);
@@ -159,6 +175,9 @@ export function extractSpringRoutes(tree, filePath, lineOffset = 0) {
         if (enclosingType?.kind === 'interface')
             continue;
         const enclosingClass = enclosingType?.kind === 'class' ? enclosingType.node : null;
+        const httpMethods = intersectSpringHttpMethods(enclosingClass ? (classHttpMethodsById.get(enclosingClass.id) ?? ['*']) : ['*'], methodMethods);
+        if (httpMethods.length === 0)
+            continue;
         // Suppress a method-level *array-form* route nested under a class-level
         // array-form @RequestMapping. The class prefix is one of several values that
         // cannot be resolved to a single string here, so emitting the route would
@@ -175,15 +194,50 @@ export function extractSpringRoutes(tree, filePath, lineOffset = 0) {
         // `node` is the annotated `method_declaration`; its name field is the
         // handler method name (resolved to a symbol UID later by the routes phase).
         const handlerName = node.childForFieldName('name')?.text;
-        routes.push({
-            filePath,
-            routePath,
-            httpMethod,
-            decoratorName: ann,
-            lineNumber: annNode.startPosition.row + lineOffset,
-            ...(classPrefix ? { prefix: classPrefix } : {}),
-            ...(handlerName ? { handlerName } : {}),
-        });
+        for (const httpMethod of httpMethods) {
+            routes.push({
+                filePath,
+                routePath,
+                httpMethod,
+                decoratorName: ann,
+                lineNumber: annNode.startPosition.row + lineOffset,
+                ...(classPrefix ? { prefix: classPrefix } : {}),
+                ...(handlerName ? { handlerName } : {}),
+            });
+        }
+    }
+    // Mapping annotations without a path bind to the enclosing class prefix.
+    for (const match of TYPE_DECLARATION_QUERY.matches(tree.rootNode)) {
+        const typeNode = match.captures.find((capture) => capture.name === 'type')?.node;
+        if (typeNode?.type !== 'class_declaration')
+            continue;
+        const classPrefix = prefixByClassId.get(typeNode.id) ?? '';
+        const classMethods = classHttpMethodsById.get(typeNode.id) ?? ['*'];
+        for (const methodNode of directMethods(typeNode)) {
+            const handlerName = methodNode.childForFieldName('name')?.text;
+            if (!handlerName)
+                continue;
+            for (const annotationNode of declarationAnnotations(methodNode)) {
+                const ann = annotationName(annotationNode) ?? '';
+                if (annotationHasRouteMember(annotationNode))
+                    continue;
+                const methodMethods = springAnnotationHttpMethods(ann, annotationNode.text);
+                const httpMethods = intersectSpringHttpMethods(classMethods, methodMethods);
+                if (httpMethods.length === 0)
+                    continue;
+                for (const httpMethod of httpMethods) {
+                    routes.push({
+                        filePath,
+                        routePath: '',
+                        httpMethod,
+                        decoratorName: ann,
+                        lineNumber: annotationNode.startPosition.row + lineOffset,
+                        ...(classPrefix ? { prefix: classPrefix } : {}),
+                        handlerName,
+                    });
+                }
+            }
+        }
     }
     return routes;
 }
@@ -250,6 +304,35 @@ function annotationRoutePaths(ann) {
     }
     return out;
 }
+/** Whether an annotation explicitly supplies a positional or path/value member. */
+function annotationHasRouteMember(ann) {
+    const args = ann.childForFieldName('arguments');
+    if (!args)
+        return false;
+    for (const child of args.namedChildren) {
+        if (child.type !== 'element_value_pair')
+            return true;
+        const key = child.childForFieldName('key');
+        if (isRouteMemberKey(key ?? undefined))
+            return true;
+    }
+    return false;
+}
+/** Static class/interface-level RequestMapping method constraint, or wildcard by default. */
+function typeRequestMethods(typeNode) {
+    const mappings = declarationAnnotations(typeNode).filter((ann) => annotationName(ann) === 'RequestMapping');
+    if (mappings.length === 0)
+        return ['*'];
+    if (mappings.length !== 1)
+        return [];
+    return springAnnotationHttpMethods('RequestMapping', mappings[0].text);
+}
+function annotationRoutePathsOrDefault(ann) {
+    const paths = annotationRoutePaths(ann);
+    if (paths.length > 0)
+        return paths;
+    return annotationHasRouteMember(ann) ? [] : [''];
+}
 /** Class-level `@RequestMapping` prefixes for a type (array-aware; may be []). */
 function typeClassPrefixes(typeNode) {
     const prefixes = [];
@@ -319,6 +402,7 @@ export function extractSpringTypes(tree, filePath) {
         const kind = typeNode.type === 'interface_declaration' ? 'interface' : 'class';
         const annNames = declarationAnnotations(typeNode).map(annotationName);
         const isController = kind === 'class' && (annNames.includes('RestController') || annNames.includes('Controller'));
+        const classMethods = typeRequestMethods(typeNode);
         const methods = directMethods(typeNode)
             .map((methodNode) => {
             const methodName = methodNode.childForFieldName('name')?.text;
@@ -326,11 +410,12 @@ export function extractSpringTypes(tree, filePath) {
                 return null;
             const routes = [];
             for (const ann of declarationAnnotations(methodNode)) {
-                const verb = METHOD_ANNOTATION_TO_HTTP[annotationName(ann) ?? ''];
-                if (!verb)
-                    continue;
-                for (const path of annotationRoutePaths(ann))
-                    routes.push({ method: verb, path });
+                const methodMethods = springAnnotationHttpMethods(annotationName(ann) ?? '', ann.text);
+                const verbs = intersectSpringHttpMethods(classMethods, methodMethods);
+                for (const verb of verbs) {
+                    for (const path of annotationRoutePathsOrDefault(ann))
+                        routes.push({ method: verb, path });
+                }
             }
             return { name: methodName, routes };
         })

package/dist/core/ingestion/scope-extractor-bridge.js

@@ -36,7 +36,15 @@ export function extractParsedFile(provider, sourceText, filePath, onWarn, cached
     if (sourceText.trim().length === 0)
         return undefined;
     try {
-        const captures = provider.emitScopeCaptures(sourceText, filePath, cachedTree, { sourceKind });
+        // A provider that rewrites source before parsing must see the same text
+        // here that the parse worker fed tree-sitter, or the two halves of the
+        // pipeline analyze different programs. Only the cache-miss path re-parses;
+        // with a cached tree the emitter ignores the text. The transform is
+        // length-preserving, so every offset still indexes the original.
+        const parseText = cachedTree === undefined
+            ? (provider.preprocessSource?.(sourceText, filePath) ?? sourceText)
+            : sourceText;
+        const captures = provider.emitScopeCaptures(parseText, filePath, cachedTree, { sourceKind });
         return extractScope(captures, filePath, provider);
     }
     catch (err) {

package/dist/core/ingestion/scope-extractor.d.ts

@@ -34,9 +34,24 @@
  *      as `ownedDefs` + a local `BindingRef { origin: 'local' }`.
  *   3. **Collect raw imports.** Walk `@import.*` matches. Call
  *      `provider.interpretImport` per match; attach the returned
- *      `ParsedImport` to the ParsedFile (not to any `Scope` — finalize
- *      reconstructs the owning scope via `provider.importOwningScope`
- *      during Phase 2).
+ *      `ParsedImport` to the ParsedFile — not to any `Scope`.
+ *      `provider.importOwningScope` is declared on `LanguageProvider` and
+ *      implemented by a dozen providers, but has no call site anywhere; this
+ *      step's output is a flat per-file list.
+ *
+ *      One scope fact is read before that list flattens it away:
+ *      `runsOnlyWhenCalled`, set when the statement sits anywhere inside a
+ *      `Function`. It is decided here because here is the last stage that can
+ *      — finalize receives the flat list, and its consumer receives a map
+ *      keyed by the file's Module scope only (see
+ *      `ParsedImport.runsOnlyWhenCalled`). This is a position fact, not a
+ *      syntax one, so it is decided centrally for every language rather than
+ *      per provider — with one capability a provider may declare to opt out
+ *      of it entirely, `importsExecuteWhereWritten: false`, because position
+ *      cannot defer an import that never executes (C/C++ `#include`, Rust
+ *      `use`, COBOL `COPY`). Providers still decide their own *syntactic* nesting
+ *      facts in their capture emitters, where the node is in hand (see
+ *      `languages/python/import-decomposer.ts`).
  *   4. **Collect type bindings.** Walk `@type-binding.*` matches. Call
  *      `provider.interpretTypeBinding` per match. Attach the resulting
  *      `TypeRef` to the innermost containing scope's `typeBindings`
@@ -61,10 +76,10 @@
 import type { CaptureMatch, ParsedFile, SymbolDefinition } from '../../_shared/index.js';
 import type { LanguageProvider } from './language-provider.js';
 /**
- * The subset of `LanguageProvider` hooks that `extract()` reads. Declared
- * as its own type so:
+ * The subset of `LanguageProvider` members that `extract()` reads — the hooks
+ * it calls plus the capability flags it consults. Declared as its own type so:
  *
- *   - Tests can implement just these six hooks without faking the whole
+ *   - Tests can implement just these members without faking the whole
  *     `LanguageProvider` interface (which is ~40 fields including the
  *     legacy-DAG surface).
  *   - The extractor's dependency contract stays explicit — adding a new
@@ -73,7 +88,7 @@ import type { LanguageProvider } from './language-provider.js';
  * Real callers pass a full `LanguageProvider` — structural typing makes it
  * a `ScopeExtractorHooks` for free.
  */
-export type ScopeExtractorHooks = Pick<LanguageProvider, 'resolveScopeKind' | 'bindingScopeFor' | 'interpretImport' | 'interpretTypeBinding' | 'classifyCallForm'>;
+export type ScopeExtractorHooks = Pick<LanguageProvider, 'resolveScopeKind' | 'scopeOwnsReceivers' | 'bindingScopeFor' | 'interpretImport' | 'importsExecuteWhereWritten' | 'interpretTypeBinding' | 'classifyCallForm'>;
 /**
  * Drive the five extraction passes and return a `ParsedFile`.
  *