gitnexus 1.6.10-rc.98 → 1.6.10

package/dist/core/ingestion/languages/java/module-resolution.js

@@ -0,0 +1,142 @@
+/**
+ * Java import resolution against DECLARED packages (#2953).
+ *
+ * A Java import is a fully-qualified type name, not a path. `com.example.model.User`
+ * names the type `User` in the package `com.example.model`, and what places a
+ * file in that package is its own `package` declaration — not where it sits on
+ * disk. A file at `weird/path/User.java` declaring `package com.example.model;`
+ * IS `com.example.model.User`; a file at `com/example/model/User.java` declaring
+ * nothing is in the DEFAULT package and cannot be imported at all.
+ *
+ * The previous resolver worked the other way round: it turned dots into slashes
+ * and looked for a file whose path ended that way, retrying with each leading
+ * segment stripped. Path shape is a convention, so that mostly worked — and
+ * failed in the one case that matters most, because it could not tell an import
+ * of something outside the repository from one inside it. `java.util.List`
+ * became `util/List`, then `List`, and bound to any `List.java` in the tree.
+ * Every JDK and third-party import in a repo was a candidate for a fabricated
+ * IMPORTS edge at full confidence.
+ *
+ * The fix needs no new I/O. Every Java file's `package` declaration is already
+ * extracted during the parse pass and available here through
+ * `getJavaPackageFact` — the resolver simply never read it. So resolution
+ * becomes a lookup in an index the workspace already knows how to describe:
+ *
+ *   `com.example.model.User`  ->  package `com.example.model` declares `User`
+ *   `java.util.List`          ->  no file declares package `java.util` -> null
+ *
+ * `null` for the second is the complete and correct answer: the JDK is not in
+ * this repository, so there is no in-repo file the import could name.
+ */
+const EMPTY_INDEX = {
+    typesByPackage: new Map(),
+    filesByPackage: new Map(),
+    unreadablePackageFiles: 0,
+};
+/**
+ * Index the workspace by what each file DECLARES.
+ *
+ * The importable type name is the file's base name, which is not a convention
+ * being relied on but the rule the language enforces: a type importable from
+ * another package must be `public`, and a public type must live in a file named
+ * after it. Additional package-private top-level types in the same file are
+ * deliberately not indexed — they are unimportable from elsewhere, so an import
+ * naming one is not a resolution this should find.
+ */
+export function buildJavaPackageIndex(parsedFiles, packageOf) {
+    if (parsedFiles.length === 0)
+        return EMPTY_INDEX;
+    const typesByPackage = new Map();
+    const filesByPackage = new Map();
+    let unreadablePackageFiles = 0;
+    for (const parsed of parsedFiles) {
+        const filePath = parsed.filePath;
+        const fact = packageOf(filePath);
+        if (fact === undefined)
+            continue;
+        if (fact.status !== 'known') {
+            unreadablePackageFiles++;
+            continue;
+        }
+        // The default package (`''`) is indexed like any other so a workspace of
+        // package-less files still answers its own wildcards, but Java forbids
+        // importing FROM it, which `resolveJavaModule` enforces rather than
+        // pretending here that the entry does not exist.
+        const packageName = fact.packageName;
+        const typeName = baseTypeName(filePath);
+        if (typeName !== null) {
+            let types = typesByPackage.get(packageName);
+            if (types === undefined) {
+                types = new Map();
+                typesByPackage.set(packageName, types);
+            }
+            // First declaration wins. Two files claiming the same package+type is not
+            // legal Java; picking either is as correct as the input allows.
+            if (!types.has(typeName))
+                types.set(typeName, filePath);
+        }
+        const files = filesByPackage.get(packageName);
+        if (files === undefined)
+            filesByPackage.set(packageName, [filePath]);
+        else
+            files.push(filePath);
+    }
+    return { typesByPackage, filesByPackage, unreadablePackageFiles };
+}
+/**
+ * Resolve one import specifier to the file(s) it names, or `null`.
+ *
+ * A wildcard answers with every file in the package; a type import answers with
+ * one file. Anything the workspace does not declare answers `null`.
+ */
+export function resolveJavaModule(targetRaw, index) {
+    if (targetRaw === '')
+        return null;
+    if (targetRaw.endsWith('.*')) {
+        const stem = targetRaw.slice(0, -2);
+        const inPackage = index.filesByPackage.get(stem);
+        // Only package wildcards retain `.*`. Static wildcards are interpreted with
+        // the owning type path so a same-named package cannot capture the import.
+        return inPackage !== undefined && stem !== '' ? inPackage : null;
+    }
+    return resolveTypeName(targetRaw, index);
+}
+/**
+ * Split a qualified name into the longest DECLARED package prefix and the type
+ * that follows it.
+ *
+ * Longest-first is what makes both of these land correctly without a rule about
+ * capitalization, which Java does not actually enforce:
+ *
+ *   `com.example.model.User`   -> package `com.example.model`, type `User`
+ *   `com.example.Utils.method` -> package `com.example`,       type `Utils`
+ *
+ * The second is a static member import; its trailing segments name members
+ * inside the type, and the file the import binds to is the type's.
+ */
+function resolveTypeName(qualified, index) {
+    const parts = qualified.split('.').filter((part) => part !== '');
+    // A single bare segment names a type in the default package, which Java
+    // forbids importing. Nothing to resolve, and nothing to guess at.
+    if (parts.length < 2)
+        return null;
+    for (let split = parts.length - 1; split >= 1; split--) {
+        const packageName = parts.slice(0, split).join('.');
+        const types = index.typesByPackage.get(packageName);
+        if (types === undefined)
+            continue;
+        const file = types.get(parts[split]);
+        if (file !== undefined)
+            return file;
+    }
+    return null;
+}
+/** `src/main/java/com/example/User.java` -> `User`. */
+function baseTypeName(filePath) {
+    const slash = filePath.replace(/\\/g, '/').lastIndexOf('/');
+    const base = slash === -1 ? filePath : filePath.slice(slash + 1);
+    if (!base.endsWith('.java'))
+        return null;
+    const name = base.slice(0, -'.java'.length);
+    return name === '' ? null : name;
+}

package/dist/core/ingestion/languages/java/query.js

@@ -53,19 +53,26 @@ const JAVA_SCOPE_QUERY = `
 
 (method_declaration) @scope.function
 (constructor_declaration) @scope.function
+(compact_constructor_declaration) @scope.function
 
 ;; Declarations — types
+;; Optional-quantifier capture rather than a second pattern: a separate rule
+;; would make every GENERIC declaration match twice under one def id, leaving
+;; match order to decide which twin kept the parameters.
 (class_declaration
-  name: (identifier) @declaration.name) @declaration.class
+  name: (identifier) @declaration.name
+  type_parameters: (type_parameters)? @declaration.type-parameters) @declaration.class
 
 (interface_declaration
-  name: (identifier) @declaration.name) @declaration.interface
+  name: (identifier) @declaration.name
+  type_parameters: (type_parameters)? @declaration.type-parameters) @declaration.interface
 
 (enum_declaration
   name: (identifier) @declaration.name) @declaration.enum
 
 (record_declaration
-  name: (identifier) @declaration.name) @declaration.record
+  name: (identifier) @declaration.name
+  type_parameters: (type_parameters)? @declaration.type-parameters) @declaration.record
 
 (annotation_type_declaration
   name: (identifier) @declaration.name) @declaration.class
@@ -80,7 +87,13 @@ const JAVA_SCOPE_QUERY = `
     ])) @class-annotation.class
 
 ;; Declarations — methods / constructors
+;;
+;; A generic METHOD's parameters are read for the same reason a generic type's
+;; are (#2912 review): \`<T> boolean runAny(Validator<T> v)\` writes a receiver
+;; whose argument is a type VARIABLE, and a pass that cannot tell that from a
+;; concrete type prunes every implementor from the call's dispatch fan-out.
 (method_declaration
+  type_parameters: (type_parameters)? @declaration.type-parameters
   name: (identifier) @declaration.name) @declaration.method
 
 (constructor_declaration

package/dist/core/ingestion/languages/java/record-components.d.ts

@@ -0,0 +1,14 @@
+import { type CaptureMatch } from '../../../../_shared/index.js';
+import type { CaptureMap } from '../../language-provider.js';
+import type { MethodExtractor } from '../../method-types.js';
+import { type SyntaxNode } from '../../utils/ast-helpers.js';
+/** Java records synthesize one public, zero-argument accessor per component. */
+export declare const javaRecordMethodExtractor: MethodExtractor;
+/** Scope declarations matching the structure-phase synthetic accessor nodes. */
+export declare function synthesizeJavaRecordComponentAccessorCaptures(rootNode: SyntaxNode): CaptureMatch[];
+/**
+ * The structure query sees every record component. Suppress that synthetic
+ * definition when the record body provides the canonical zero-argument
+ * accessor explicitly, leaving the explicit method as the single authority.
+ */
+export declare function shouldSkipJavaRecordComponentDefinition(captureMap: CaptureMap): boolean;

package/dist/core/ingestion/languages/java/record-components.js

@@ -0,0 +1,185 @@
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { createMethodExtractor } from '../../method-extractors/generic.js';
+import { javaMethodConfig } from '../../method-extractors/configs/jvm.js';
+import { extractAnnotations } from '../../field-extractors/configs/helpers.js';
+import { nodeToCapture, syntheticCapture } from '../../utils/ast-helpers.js';
+const javaExplicitMethodExtractor = createMethodExtractor(javaMethodConfig);
+function recordComponents(recordNode) {
+    const parameters = recordNode.childForFieldName('parameters');
+    if (parameters === null)
+        return [];
+    return parameters.namedChildren.filter((node) => node !== null && (node.type === 'formal_parameter' || node.type === 'spread_parameter'));
+}
+/**
+ * A record component is named by a real `identifier` and nothing else.
+ *
+ * Two node shapes reach this that are not one, and both would mint a graph node
+ * for source that does not compile:
+ *
+ *  - `record M(int x, y) {}` — a dropped type. tree-sitter recovers by
+ *    synthesizing `name: (MISSING identifier)`, a zero-width node whose text is
+ *    `''`. It still satisfies the query's `name: (identifier)`, so testing the
+ *    node TYPE alone does not reject it.
+ *  - `record R(int _) {}` — the grammar declares both `formal_parameter.name`
+ *    and `variable_declarator.name` as `identifier | underscore_pattern`, and
+ *    `_` parses with no error at all. `_` is illegal as a component name, and
+ *    admitting it here while the query rejects it is what let the structure and
+ *    scope paths disagree.
+ *
+ * Same degenerate-node shape as `javaBaseLookupNameNode` in captures.ts (#2935).
+ */
+function isRecordComponentName(node) {
+    return (node !== null &&
+        node !== undefined &&
+        node.type === 'identifier' &&
+        !node.isMissing &&
+        node.text.length > 0);
+}
+function recordComponentNameNode(component) {
+    const name = component.type === 'formal_parameter'
+        ? component.childForFieldName('name')
+        : (component.namedChildren
+            .find((node) => node?.type === 'variable_declarator')
+            ?.childForFieldName('name') ?? null);
+    return isRecordComponentName(name) ? name : null;
+}
+/**
+ * Memoised per record node. `shouldSkipJavaRecordComponentDefinition` is called
+ * once per component capture, so recomputing this would rescan the whole record
+ * body per component — O(components x body members) for a single record. The
+ * scope-capture path hoists the call out of its own loop instead; this cache is
+ * what gives the structure path the same cost. Keyed weakly on the AST node, so
+ * it drops with the tree at the end of the file's parse.
+ */
+const explicitZeroArgAccessorNamesCache = new WeakMap();
+function explicitZeroArgAccessorNames(recordNode) {
+    const memoized = explicitZeroArgAccessorNamesCache.get(recordNode);
+    if (memoized !== undefined)
+        return memoized;
+    const names = computeExplicitZeroArgAccessorNames(recordNode);
+    explicitZeroArgAccessorNamesCache.set(recordNode, names);
+    return names;
+}
+function computeExplicitZeroArgAccessorNames(recordNode) {
+    const names = new Set();
+    const body = recordNode.childForFieldName('body');
+    if (body === null)
+        return names;
+    for (const node of body.namedChildren) {
+        if (node === null || node.type !== 'method_declaration')
+            continue;
+        const name = node.childForFieldName('name')?.text;
+        const parameters = node.childForFieldName('parameters');
+        const parameterCount = parameters?.namedChildren.filter((parameter) => parameter !== null &&
+            (parameter.type === 'formal_parameter' || parameter.type === 'spread_parameter')).length ?? 0;
+        if (name !== undefined && parameterCount === 0)
+            names.add(name);
+    }
+    return names;
+}
+function recordComponentReturnType(component) {
+    const typeNode = component.childForFieldName('type') ??
+        (component.type === 'spread_parameter'
+            ? component.namedChildren.find((node) => node?.type !== 'modifiers' && node?.type !== 'variable_declarator')
+            : undefined);
+    const type = typeNode?.text;
+    if (type === undefined)
+        return null;
+    return component.type === 'spread_parameter' ? `${type}[]` : type;
+}
+function implicitAccessorInfo(component, context) {
+    const name = recordComponentNameNode(component)?.text;
+    if (name === undefined)
+        return null;
+    return {
+        name,
+        receiverType: null,
+        returnType: recordComponentReturnType(component),
+        parameters: [],
+        visibility: 'public',
+        isStatic: false,
+        isAbstract: false,
+        isFinal: false,
+        // JLS 8.10.3 / 9.7.4: a component annotation reaches the generated accessor
+        // when its @Target admits METHOD (or TYPE_USE, in the return-type position).
+        // ponytail: over-approximate — we propagate every component annotation,
+        // because @Target lives in another file and parsing is per-file, so the
+        // target set is not knowable here. Nothing reads Method annotations today:
+        // `annotations` is not a column in METHOD_SCHEMA/FUNCTION_SCHEMA
+        // (src/core/lbug/schema.ts), so it lives only in the in-memory graph for one
+        // analyze run, and the sole in-memory reader (springDiFieldMatcher) is gated
+        // to `Property` nodes. If that column is ever added, revisit this: the set
+        // would then become an agent-visible claim that may over-state the target.
+        annotations: extractAnnotations(component, 'modifiers'),
+        sourceFile: context.filePath,
+        line: component.startPosition.row + 1,
+        column: component.startPosition.column,
+    };
+}
+/** Java records synthesize one public, zero-argument accessor per component. */
+export const javaRecordMethodExtractor = {
+    ...javaExplicitMethodExtractor,
+    language: SupportedLanguages.Java,
+    extract(node, context) {
+        const extracted = javaExplicitMethodExtractor.extract(node, context);
+        if (extracted === null || node.type !== 'record_declaration')
+            return extracted;
+        const explicitAccessors = explicitZeroArgAccessorNames(node);
+        const implicitAccessors = recordComponents(node)
+            .filter((component) => {
+            const name = recordComponentNameNode(component)?.text;
+            return name !== undefined && !explicitAccessors.has(name);
+        })
+            .map((component) => implicitAccessorInfo(component, context))
+            .filter((method) => method !== null);
+        return { ...extracted, methods: [...extracted.methods, ...implicitAccessors] };
+    },
+};
+/** Scope declarations matching the structure-phase synthetic accessor nodes. */
+export function synthesizeJavaRecordComponentAccessorCaptures(rootNode) {
+    const captures = [];
+    for (const recordNode of rootNode.descendantsOfType('record_declaration')) {
+        const explicitAccessors = explicitZeroArgAccessorNames(recordNode);
+        for (const component of recordComponents(recordNode)) {
+            const nameNode = recordComponentNameNode(component);
+            const returnType = recordComponentReturnType(component);
+            if (nameNode === null || returnType === null || explicitAccessors.has(nameNode.text))
+                continue;
+            captures.push({
+                '@scope.function': nodeToCapture('@scope.function', component),
+            });
+            captures.push({
+                '@declaration.method': nodeToCapture('@declaration.method', component),
+                '@declaration.name': nodeToCapture('@declaration.name', nameNode),
+                '@declaration.parameter-count': syntheticCapture('@declaration.parameter-count', component, '0'),
+                '@declaration.required-parameter-count': syntheticCapture('@declaration.required-parameter-count', component, '0'),
+                '@declaration.return-type': syntheticCapture('@declaration.return-type', component, returnType),
+            });
+        }
+    }
+    return captures;
+}
+/**
+ * The structure query sees every record component. Suppress that synthetic
+ * definition when the record body provides the canonical zero-argument
+ * accessor explicitly, leaving the explicit method as the single authority.
+ */
+export function shouldSkipJavaRecordComponentDefinition(captureMap) {
+    const component = captureMap['definition.method'];
+    if (component?.type !== 'formal_parameter' && component?.type !== 'spread_parameter') {
+        return false;
+    }
+    const parameters = component.parent;
+    const recordNode = parameters?.parent;
+    if (parameters?.type !== 'formal_parameters' || recordNode?.type !== 'record_declaration') {
+        return false;
+    }
+    // Same predicate the scope path applies, so the two can never disagree about
+    // which components have an accessor. The query's `name: (identifier)` is
+    // satisfied by tree-sitter's zero-width MISSING recovery token, so the
+    // structure path has to re-check what the query cannot express.
+    const nameNode = captureMap['name'];
+    if (!isRecordComponentName(nameNode))
+        return true;
+    return explicitZeroArgAccessorNames(recordNode).has(nameNode.text);
+}

package/dist/core/ingestion/languages/java/scope-resolver.js

@@ -14,8 +14,11 @@ import { javaProvider } from '../java.js';
 import { javaArityCompatibility, javaMergeBindings, resolveJavaImportTarget, } from './index.js';
 import { populateJavaPackageSiblings } from './package-siblings.js';
 import { attachSpringBeanCandidateMetadata } from './spring-bean-metadata.js';
+import { attachJavaSpringAopMetadata } from './spring-aop.js';
 import { attachJavaSpringConfigBindings } from './spring-config-bindings.js';
+import { attachJavaSpringConditionalMetadata } from './spring-conditionals.js';
 import { attachJavaSpringDiMetadata } from './spring-di.js';
+import { attachJavaSpringNonHttpHandlerMetadata } from './spring-non-http-handlers.js';
 import { applyJavaCaptureSideChannel, clearJavaClassAnnotationFacts, } from './capture-side-channel.js';
 import { clearJavaPackageFacts } from './package-facts.js';
 const javaScopeResolver = {
@@ -30,8 +33,10 @@ const javaScopeResolver = {
         clearJavaPackageFacts();
         return undefined;
     },
-    resolveImportTarget: (targetRaw, fromFile, allFilePaths) => {
-        const ws = { fromFile, allFilePaths };
+    resolveImportTarget: (targetRaw, fromFile, allFilePaths, _resolutionConfig, context) => {
+        // `context.parsedFiles` is the whole input now: a Java import names a type
+        // in a DECLARED package, and the declarations live on those files (#2953).
+        const ws = { fromFile, allFilePaths, parsedFiles: context?.parsedFiles };
         return resolveJavaImportTarget({ kind: 'named', localName: '_', importedName: '_', targetRaw }, ws);
     },
     mergeBindings: (existing, incoming) => [...javaMergeBindings([...existing, ...incoming])],
@@ -55,7 +60,10 @@ const javaScopeResolver = {
     populateRangeBindings: populateJavaCrossFileReturnTypes,
     emitPostResolutionEdges: (graph, parsedFiles, nodeLookup, indexes, ctx) => {
         attachSpringBeanCandidateMetadata(graph, parsedFiles, nodeLookup, indexes);
+        attachJavaSpringAopMetadata(graph, parsedFiles, nodeLookup, indexes);
+        attachJavaSpringConditionalMetadata(graph, parsedFiles, nodeLookup, indexes);
         attachJavaSpringDiMetadata(graph, parsedFiles, nodeLookup, indexes);
+        attachJavaSpringNonHttpHandlerMetadata(graph, parsedFiles, nodeLookup, indexes);
         attachJavaSpringConfigBindings(graph, parsedFiles, nodeLookup, indexes, ctx);
     },
 };

package/dist/core/ingestion/languages/java/spring-aop.d.ts

@@ -0,0 +1,12 @@
+import { type SpringAopOwnerFact } from '../../frameworks/spring/aop.js';
+import { type SyntaxNode } from '../../utils/ast-helpers.js';
+import { type JavaAnnotationSyntaxFact } from './spring-di.js';
+export type JavaSpringAopAnnotationFact = JavaAnnotationSyntaxFact;
+export type JavaSpringAopFact = SpringAopOwnerFact<JavaSpringAopAnnotationFact>;
+/**
+ * Capture Spring AOP syntax while Java's existing class traversal already has
+ * the AST node in hand. Import/FQN resolution and pointcut matching remain in
+ * the shared post-resolution layer.
+ */
+export declare function captureJavaSpringAopFacts(classNode: SyntaxNode, filePath: string): JavaSpringAopFact[];
+export declare const attachJavaSpringAopMetadata: (graph: import("../../../graph/types.js").KnowledgeGraph, parsedFiles: readonly import('../../../../_shared/index.js').ParsedFile[], nodeLookup: import("../../scope-resolution/graph-bridge/node-lookup.js").GraphNodeLookup, indexes: import("../../model/scope-resolution-indexes.js").ScopeResolutionIndexes) => void;

package/dist/core/ingestion/languages/java/spring-aop.js

@@ -0,0 +1,49 @@
+import { makeScopeId } from '../../../../_shared/index.js';
+import { createSpringAopMetadataAttacher, hasSpringAopRelevantAnnotation, } from '../../frameworks/spring/aop.js';
+import { nodeToCapture } from '../../utils/ast-helpers.js';
+import { getJavaSpringAopFacts } from './capture-side-channel.js';
+import { isJavaPackageSiblingVisibilityIncomplete } from './package-siblings.js';
+import { javaSpringAnnotationFacts } from './spring-di.js';
+function scopeId(filePath, node, kind) {
+    return makeScopeId({
+        filePath,
+        range: nodeToCapture('@spring-aop.owner', node).range,
+        kind,
+    });
+}
+/**
+ * Capture Spring AOP syntax while Java's existing class traversal already has
+ * the AST node in hand. Import/FQN resolution and pointcut matching remain in
+ * the shared post-resolution layer.
+ */
+export function captureJavaSpringAopFacts(classNode, filePath) {
+    const facts = [];
+    const classAnnotations = javaSpringAnnotationFacts(classNode);
+    if (hasSpringAopRelevantAnnotation(classAnnotations)) {
+        facts.push({
+            ownerScopeId: scopeId(filePath, classNode, 'Class'),
+            ownerKind: 'class',
+            annotations: classAnnotations,
+        });
+    }
+    const body = classNode.childForFieldName('body');
+    if (body === null)
+        return facts;
+    for (const member of body.namedChildren) {
+        if (member.type !== 'method_declaration')
+            continue;
+        const annotations = javaSpringAnnotationFacts(member);
+        if (!hasSpringAopRelevantAnnotation(annotations))
+            continue;
+        facts.push({
+            ownerScopeId: scopeId(filePath, member, 'Function'),
+            ownerKind: 'callable',
+            annotations,
+        });
+    }
+    return facts;
+}
+export const attachJavaSpringAopMetadata = createSpringAopMetadataAttacher({
+    getFacts: getJavaSpringAopFacts,
+    isPackageVisibilityIncomplete: isJavaPackageSiblingVisibilityIncomplete,
+});

package/dist/core/ingestion/languages/java/spring-conditionals.d.ts

@@ -0,0 +1,11 @@
+import { type SpringConditionalOwnerFact } from '../../frameworks/spring/conditionals.js';
+import { type SyntaxNode } from '../../utils/ast-helpers.js';
+import { type JavaAnnotationSyntaxFact } from './spring-di.js';
+export type JavaSpringConditionalAnnotationFact = JavaAnnotationSyntaxFact;
+export type JavaSpringConditionalFact = SpringConditionalOwnerFact<JavaSpringConditionalAnnotationFact>;
+/**
+ * Capture Spring condition syntax while Java's existing class traversal already
+ * has the AST node in hand. Framework/FQN semantics are resolved later.
+ */
+export declare function captureJavaSpringConditionalFacts(classNode: SyntaxNode, filePath: string): JavaSpringConditionalFact[];
+export declare const attachJavaSpringConditionalMetadata: (graph: import("../../../graph/types.js").KnowledgeGraph, parsedFiles: readonly import('../../../../_shared/index.js').ParsedFile[], nodeLookup: import("../../scope-resolution/graph-bridge/node-lookup.js").GraphNodeLookup, indexes: import("../../model/scope-resolution-indexes.js").ScopeResolutionIndexes) => void;

package/dist/core/ingestion/languages/java/spring-conditionals.js

@@ -0,0 +1,48 @@
+import { makeScopeId } from '../../../../_shared/index.js';
+import { createSpringConditionalMetadataAttacher, hasSpringConditionalRelevantAnnotation, } from '../../frameworks/spring/conditionals.js';
+import { nodeToCapture } from '../../utils/ast-helpers.js';
+import { getJavaSpringConditionalFacts } from './capture-side-channel.js';
+import { isJavaPackageSiblingVisibilityIncomplete } from './package-siblings.js';
+import { javaSpringAnnotationFacts } from './spring-di.js';
+function scopeId(filePath, node, kind) {
+    return makeScopeId({
+        filePath,
+        range: nodeToCapture('@spring-condition.owner', node).range,
+        kind,
+    });
+}
+/**
+ * Capture Spring condition syntax while Java's existing class traversal already
+ * has the AST node in hand. Framework/FQN semantics are resolved later.
+ */
+export function captureJavaSpringConditionalFacts(classNode, filePath) {
+    const facts = [];
+    const classAnnotations = javaSpringAnnotationFacts(classNode);
+    if (hasSpringConditionalRelevantAnnotation(classAnnotations)) {
+        facts.push({
+            ownerScopeId: scopeId(filePath, classNode, 'Class'),
+            ownerKind: 'class',
+            annotations: classAnnotations,
+        });
+    }
+    const body = classNode.childForFieldName('body');
+    if (body === null)
+        return facts;
+    for (const member of body.namedChildren) {
+        if (member.type !== 'method_declaration')
+            continue;
+        const annotations = javaSpringAnnotationFacts(member);
+        if (!hasSpringConditionalRelevantAnnotation(annotations))
+            continue;
+        facts.push({
+            ownerScopeId: scopeId(filePath, member, 'Function'),
+            ownerKind: 'callable',
+            annotations,
+        });
+    }
+    return facts;
+}
+export const attachJavaSpringConditionalMetadata = createSpringConditionalMetadataAttacher({
+    getFacts: getJavaSpringConditionalFacts,
+    isPackageVisibilityIncomplete: isJavaPackageSiblingVisibilityIncomplete,
+});

package/dist/core/ingestion/languages/java/spring-di.d.ts

@@ -1,10 +1,13 @@
 import { type SpringDiAnnotationFact, type SpringDiClassFact, type SpringDiDependencyFact, type SpringDiInjectionSiteFact } from '../../frameworks/spring/di-metadata.js';
 import { type SyntaxNode } from '../../utils/ast-helpers.js';
-export type JavaAnnotationSyntaxFact = SpringDiAnnotationFact;
+export interface JavaAnnotationSyntaxFact extends SpringDiAnnotationFact {
+    readonly line: number;
+}
 export type JavaSpringDependencyFact = SpringDiDependencyFact<JavaAnnotationSyntaxFact>;
 type JavaSpringInjectionSiteKind = 'field' | 'constructor' | 'method';
 export type JavaSpringInjectionSiteFact = SpringDiInjectionSiteFact<JavaAnnotationSyntaxFact, JavaSpringInjectionSiteKind>;
 export type JavaSpringDiClassFact = SpringDiClassFact<JavaAnnotationSyntaxFact, JavaSpringInjectionSiteKind>;
+export declare function javaSpringAnnotationFacts(node: SyntaxNode): JavaAnnotationSyntaxFact[];
 /**
  * Capture one class already surfaced by Java's scope query.
  *