gitnexus 1.6.10-rc.99 → 1.6.10

package/dist/core/ingestion/languages/go/interpret.d.ts

@@ -1,6 +1,8 @@
 import type { CaptureMatch, ParsedImport, ParsedTypeBinding } from '../../../../_shared/index.js';
 export declare function interpretGoImport(captures: CaptureMatch): ParsedImport | null;
 export declare function interpretGoTypeBinding(captures: CaptureMatch): ParsedTypeBinding | null;
+/** `map[K]V` → `V`, trimmed. `undefined` when `text` is not a map spelling. */
+export declare function goMapValueType(text: string): string | undefined;
 export declare function normalizeGoTypeName(text: string): string;
 /**
  * Like `normalizeGoTypeName` but preserves dotted package-prefix

package/dist/core/ingestion/languages/go/interpret.js

@@ -29,8 +29,12 @@ export function interpretGoTypeBinding(captures) {
     if (captures['@type-binding.self'] !== undefined) {
         source = 'self';
         // Preserve pointer shape on receiver self-bindings (`*T` vs `T`).
-        // Method-owner enrichment consumes that raw shape to model Go value and
-        // pointer receiver method sets conservatively.
+        // Method-owner enrichment consumes that raw shape to stamp `goReceiverKind`
+        // on each method. Since #2813 that stamp is metadata, NOT a filter:
+        // structural interface satisfaction counts pointer-receiver methods, because
+        // `*T`'s method set is what an interface-typed field actually holds. The
+        // preserved distinction is the hook a future value/pointer-aware model would
+        // read — do not reintroduce it as an exclusion.
         normalizedType = type.trim();
     }
     else if (captures['@type-binding.constructor'] !== undefined) {
@@ -91,12 +95,22 @@ export function interpretGoTypeBinding(captures) {
     }
     return { boundName: name, rawTypeName: normalizedType, source };
 }
+/** Shallow `map[K]V` spelling match — the key is anything up to the first `]`,
+ *  so a nested map key (`map[map[a]b]V`) is deliberately NOT recognised. Held
+ *  in one place so the capture-side normalizers and the resolver's element-type
+ *  hook cannot drift on what counts as a map spelling. */
+const GO_MAP_VALUE_RE = /^map\[[^\]]+\]\s*(.+)$/;
+/** `map[K]V` → `V`, trimmed. `undefined` when `text` is not a map spelling. */
+export function goMapValueType(text) {
+    const match = GO_MAP_VALUE_RE.exec(text);
+    return match === null ? undefined : match[1].trim();
+}
 export function normalizeGoTypeName(text) {
     let t = text.trim();
     t = stripGoOuterTypePrefixes(t);
-    const mapMatch = t.match(/^map\[[^\]]+\]\s*(.+)$/);
-    if (mapMatch)
-        t = mapMatch[1].trim();
+    const mapValue = goMapValueType(t);
+    if (mapValue !== undefined)
+        t = mapValue;
     t = stripGoOuterTypePrefixes(t.replace(/^(?:<-)?chan(?:<-)?\s+/, ''));
     if (t.startsWith('func(')) {
         const retMatch = t.match(/^func\([^)]*\)\s*(.*)$/);
@@ -126,9 +140,9 @@ export function normalizeGoReturnType(text) {
         t = t.slice(1, closeIdx).trim();
     }
     t = stripGoOuterTypePrefixes(t);
-    const mapMatch = t.match(/^map\[[^\]]+\]\s*(.+)$/);
-    if (mapMatch)
-        t = mapMatch[1].trim();
+    const mapValue = goMapValueType(t);
+    if (mapValue !== undefined)
+        t = mapValue;
     t = stripGoOuterTypePrefixes(t.replace(/^(?:<-)?chan(?:<-)?\s+/, ''));
     if (t.startsWith('func(')) {
         const retMatch = t.match(/^func\([^)]*\)\s*(.*)$/);

package/dist/core/ingestion/languages/go/method-owners.js

@@ -1,4 +1,9 @@
+import { logger } from '../../../logger.js';
 import { isClassLike, populateClassOwnedMembers } from '../../scope-resolution/scope/walkers.js';
+import { goPackageDir, inferGoPackageName } from './package-clause.js';
+import { stampGoInterfaceTypeParameters } from './generic-type-parameters.js';
+/** Bound on the sample of no-package-clause paths named in the warning. */
+const SKIPPED_SAMPLE_CAP = 5;
 /**
  * Populate `ownerId` on Go Method defs by matching receiver types
  * extracted from `@type-binding.self` captures against struct defs in
@@ -19,16 +24,39 @@ export function populateGoOwners(parsed) {
     populateGoOwnersInPackage([parsed]);
 }
 export function populateGoWorkspaceOwners(parsedFiles, ctx) {
+    // Generic interfaces get their type-parameter list stamped here rather than at
+    // capture time, because this is the first main-thread hook that sees BOTH the
+    // parsed scopes and the file text (it already reads `fileContents` for the
+    // package clause). `detectGoInterfaceImplementations` runs later in the same
+    // pass and is the only reader. See `stampGoInterfaceTypeParameters`.
+    stampGoInterfaceTypeParameters(parsedFiles, ctx.fileContents);
     const filesByPackage = new Map();
+    // A file with no resolvable package clause is dropped from ownership
+    // resolution entirely — its methods never attach to a struct declared in a
+    // sibling file. That used to be a bare `continue` with no trace, which is the
+    // same false-safe silence #2813 was filed about. Report it once, bounded
+    // (mirrors the fan-out-cap warning in scope-resolution/pipeline/run.ts).
+    let skippedCount = 0;
+    const skippedSample = [];
     for (const parsed of parsedFiles) {
-        const pkgName = inferPackageName(ctx.fileContents.get(parsed.filePath) ?? '');
-        if (pkgName === null)
+        const pkgName = inferGoPackageName(ctx.fileContents.get(parsed.filePath) ?? '');
+        if (pkgName === null) {
+            // Count everything, retain only the sample — a misrouted vendored tree
+            // would otherwise accumulate one path reference per file to print five.
+            skippedCount += 1;
+            if (skippedSample.length < SKIPPED_SAMPLE_CAP)
+                skippedSample.push(parsed.filePath);
             continue;
-        const key = `${packageDir(parsed.filePath)}\0${pkgName}`;
+        }
+        const key = `${goPackageDir(parsed.filePath)}\0${pkgName}`;
         const bucket = filesByPackage.get(key) ?? [];
         bucket.push(parsed);
         filesByPackage.set(key, bucket);
     }
+    if (skippedCount > 0) {
+        logger.warn({ skippedFiles: skippedCount, sample: skippedSample }, 'go: files with no resolvable package clause were excluded from method-owner ' +
+            'resolution (their methods cannot attach to structs declared in sibling files)');
+    }
     for (const bucket of filesByPackage.values()) {
         populateGoOwnersInPackage(bucket);
     }
@@ -97,12 +125,3 @@ function populateGoOwnersInPackage(parsedFiles) {
         }
     }
 }
-function inferPackageName(sourceText) {
-    const match = sourceText.match(/^\s*package\s+([A-Za-z_][A-Za-z0-9_]*)/m);
-    return match?.[1] ?? null;
-}
-function packageDir(filePath) {
-    const normalized = filePath.replace(/\\/g, '/');
-    const idx = normalized.lastIndexOf('/');
-    return idx === -1 ? '' : normalized.slice(0, idx);
-}

package/dist/core/ingestion/languages/go/package-clause.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Go package-clause resolution — the single derivation of a file's package
+ * identity (#2837).
+ *
+ * Both Go passes that bucket files by package (`populateGoWorkspaceOwners` and
+ * `populateGoPackageSiblings`) previously carried their own byte-identical copy
+ * of this, spelled as one unanchored multiline regex:
+ *
+ *     sourceText.match(/^\s*package\s+([A-Za-z_][A-Za-z0-9_]*)/m)
+ *
+ * With the `m` flag that matches the first line ANYWHERE in the file starting
+ * with `package <ident>` — comment bodies included. Measured against that exact
+ * expression: a header comment containing `package legacy_notes kept for
+ * history` yields `legacy_notes`, and an indented `  package helper old name`
+ * yields `helper`. A file that mis-infers its own package gets a bucket key no
+ * sibling shares, so it is isolated in BOTH passes: its methods never attach to
+ * structs declared in sibling files, and it exchanges no same-package bindings.
+ * Every field-receiver call in it then resolves to nothing, silently — the same
+ * per-file signature #2837 reported.
+ *
+ * The Go spec makes the correct rule exact rather than heuristic: a source
+ * file's first non-comment, non-blank token is `package`. So skip the leading
+ * run of whitespace and comments, then require the very next token to be the
+ * clause. Anything else is `null` — a truncated read, a misrouted non-Go file,
+ * an unparseable header — reported by the caller rather than guessed at.
+ *
+ * ONE rule governs every leniency below (the `\s+` separator, the shebang skip,
+ * CR-only line endings): a file this returns `null` for is dropped from BOTH
+ * passes, so refusing a shape the previous regex accepted is a silent
+ * regression, not a principled tightening. Be no stricter than the grammar.
+ */
+/**
+ * The package name declared by this Go source text, or `null` when its first
+ * real token is not a package clause.
+ *
+ * Only the leading run before the clause is skipped — deliberately NOT a
+ * whole-file comment strip, which would be O(file) on every Go file and would
+ * also have to model string literals to stay correct.
+ */
+export declare function inferGoPackageName(sourceText: string): string | null;
+/**
+ * The directory half of a Go package key. Go package identity is
+ * directory-scoped, so repeated `package main` directories must not see each
+ * other's unqualified names.
+ */
+export declare function goPackageDir(filePath: string): string;

package/dist/core/ingestion/languages/go/package-clause.js

@@ -0,0 +1,75 @@
+/**
+ * Go package-clause resolution — the single derivation of a file's package
+ * identity (#2837).
+ *
+ * Both Go passes that bucket files by package (`populateGoWorkspaceOwners` and
+ * `populateGoPackageSiblings`) previously carried their own byte-identical copy
+ * of this, spelled as one unanchored multiline regex:
+ *
+ *     sourceText.match(/^\s*package\s+([A-Za-z_][A-Za-z0-9_]*)/m)
+ *
+ * With the `m` flag that matches the first line ANYWHERE in the file starting
+ * with `package <ident>` — comment bodies included. Measured against that exact
+ * expression: a header comment containing `package legacy_notes kept for
+ * history` yields `legacy_notes`, and an indented `  package helper old name`
+ * yields `helper`. A file that mis-infers its own package gets a bucket key no
+ * sibling shares, so it is isolated in BOTH passes: its methods never attach to
+ * structs declared in sibling files, and it exchanges no same-package bindings.
+ * Every field-receiver call in it then resolves to nothing, silently — the same
+ * per-file signature #2837 reported.
+ *
+ * The Go spec makes the correct rule exact rather than heuristic: a source
+ * file's first non-comment, non-blank token is `package`. So skip the leading
+ * run of whitespace and comments, then require the very next token to be the
+ * clause. Anything else is `null` — a truncated read, a misrouted non-Go file,
+ * an unparseable header — reported by the caller rather than guessed at.
+ *
+ * ONE rule governs every leniency below (the `\s+` separator, the shebang skip,
+ * CR-only line endings): a file this returns `null` for is dropped from BOTH
+ * passes, so refusing a shape the previous regex accepted is a silent
+ * regression, not a principled tightening. Be no stricter than the grammar.
+ */
+/** Leading trivia: whitespace, `//` lines, block comments. Sticky. */
+const LEADING_TRIVIA = /(?:\s+|\/\/[^\n\r]*|\/\*[\s\S]*?\*\/)*/y;
+/** The clause itself, anchored at the first non-trivia byte. `\s+` (not
+ *  `[ \t]+`) because Go separates tokens by any whitespace: `package\nmain` is
+ *  legal and tree-sitter parses it without error. */
+const PACKAGE_CLAUSE = /package\s+([A-Za-z_][A-Za-z0-9_]*)/y;
+/**
+ * The package name declared by this Go source text, or `null` when its first
+ * real token is not a package clause.
+ *
+ * Only the leading run before the clause is skipped — deliberately NOT a
+ * whole-file comment strip, which would be O(file) on every Go file and would
+ * also have to model string literals to stay correct.
+ */
+export function inferGoPackageName(sourceText) {
+    let i = 0;
+    // A leading `#!` line: `gorun`-style scripts carry one. Only a FIRST-line
+    // `#!` is skipped; a `#` anywhere else still ends the scan.
+    if (sourceText.startsWith('#!')) {
+        const eol = sourceText.search(/[\n\r]/);
+        if (eol === -1)
+            return null;
+        i = eol + 1;
+    }
+    // Whitespace (`\s` covers the BOM and every line ending), `//` lines and block
+    // comments — the run a Go file may carry before its clause. Sticky, so the
+    // header is skipped in place without slicing a copy of the file. An
+    // unterminated `/*` or a `//` running to EOF simply leaves `lastIndex` where
+    // the clause cannot match, so neither needs its own early return.
+    LEADING_TRIVIA.lastIndex = i;
+    LEADING_TRIVIA.exec(sourceText);
+    PACKAGE_CLAUSE.lastIndex = LEADING_TRIVIA.lastIndex;
+    return PACKAGE_CLAUSE.exec(sourceText)?.[1] ?? null;
+}
+/**
+ * The directory half of a Go package key. Go package identity is
+ * directory-scoped, so repeated `package main` directories must not see each
+ * other's unqualified names.
+ */
+export function goPackageDir(filePath) {
+    const normalized = filePath.replace(/\\/g, '/');
+    const idx = normalized.lastIndexOf('/');
+    return idx === -1 ? '' : normalized.slice(0, idx);
+}

package/dist/core/ingestion/languages/go/package-siblings.js

@@ -1,4 +1,5 @@
 import { expandGoDotImports } from './expand-wildcards.js';
+import { goPackageDir, inferGoPackageName } from './package-clause.js';
 /**
  * O(n²×d) where n = files per package, d = defs per file.
  * Acceptable for V1 since Go packages are typically small (< 20 files).
@@ -17,9 +18,13 @@ export function populateGoPackageSiblings(parsedFiles, indexes, ctx) {
     //    must not see each other's unqualified names.
     const packageByFile = new Map();
     for (const parsed of nonTestFiles) {
-        const pkgName = inferPackageName(ctx.fileContents.get(parsed.filePath) ?? '');
+        // Same derivation as `populateGoWorkspaceOwners` — one shared resolver, so
+        // the two passes cannot disagree about a file's package (#2837). The
+        // no-clause case is reported there; warning twice for one fact would be
+        // noise.
+        const pkgName = inferGoPackageName(ctx.fileContents.get(parsed.filePath) ?? '');
         if (pkgName !== null) {
-            packageByFile.set(parsed.filePath, `${packageDir(parsed.filePath)}\0${pkgName}`);
+            packageByFile.set(parsed.filePath, `${goPackageDir(parsed.filePath)}\0${pkgName}`);
         }
     }
     const filesByPackage = new Map();
@@ -60,15 +65,6 @@ export function populateGoPackageSiblings(parsedFiles, indexes, ctx) {
         }
     }
 }
-function inferPackageName(sourceText) {
-    const match = sourceText.match(/^\s*package\s+([A-Za-z_][A-Za-z0-9_]*)/m);
-    return match?.[1] ?? null;
-}
-function packageDir(filePath) {
-    const normalized = filePath.replace(/\\/g, '/');
-    const idx = normalized.lastIndexOf('/');
-    return idx === -1 ? '' : normalized.slice(0, idx);
-}
 function getAugmentationBucket(augmentations, scopeId, name) {
     let scopeBindings = augmentations.get(scopeId);
     if (scopeBindings === undefined) {

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

@@ -3,9 +3,33 @@ import Go from 'tree-sitter-go';
 const GO_SCOPE_QUERY = `
 ;; Scopes
 (source_file) @scope.module
+;; One Class scope per DECLARED TYPE, not per declaration (#2837).
+;;
+;; Capturing the type_declaration made a grouped declaration
+;;   type (
+;;     Decoy       struct { ... }
+;;     PickService struct { ... }
+;;   )
+;; a SINGLE Class scope owning every struct in the block. Downstream that scope
+;; can name only one owner -- buildWorkspaceResolutionIndex keeps the first
+;; class-like def it finds -- so the block's structs lost their field type
+;; bindings, typeOfMemberOnClass found no scope, the compound-receiver fold
+;; declined, and every s.field.Method() site in the file emitted nothing at
+;; all. Silent, per-file, and independent of file size: exactly the split
+;; reported in #2837 that #2829's global fixes could not explain. Measured on
+;; the go-grouped-type-decl fixture: EVERY struct in a grouped block lost its
+;; edges, the first one included, and grouped interface blocks produced no
+;; IMPLEMENTS edges at all.
+;;
+;; type_spec is the node Go's own grammar gives one declared type, so one
+;; capture per type_spec is the granularity the rest of the pipeline already
+;; assumes. A plain single-type declaration is unaffected in count -- only its
+;; scope range narrows, from the type keyword to the name.
+;;
+;; NOTE: this string is a JS template literal. Backticks are a syntax error.
 (type_declaration
   (type_spec
-    type: [(struct_type) (interface_type)])) @scope.class
+    type: [(struct_type) (interface_type)]) @scope.class)
 (function_declaration) @scope.function
 (method_declaration) @scope.function
 (func_literal) @scope.function
@@ -21,19 +45,48 @@ const GO_SCOPE_QUERY = `
 (communication_case) @scope.block
 
 ;; Declarations — struct
+;;
+;; Anchored on the type_spec, in lockstep with @scope.class above (#2837). Both
+;; captures MUST name the same node: the def node and the class-scope node are
+;; paired by range, so anchoring the def on the enclosing type_declaration while
+;; the scope sits on the type_spec leaves the def strictly larger than its own
+;; scope and NOTHING is owned -- measured as every Go field-receiver edge in the
+;; fixture disappearing, plain declarations included. Keeping both on
+;; type_declaration is the original bug: a grouped block gave both structs the
+;; same capture node, so one silently displaced the other.
 (type_declaration
   (type_spec name: (type_identifier) @declaration.name
-    type: (struct_type))) @declaration.struct
+    type: (struct_type)) @declaration.struct)
 
 ;; Declarations — interface
+;; Same lockstep requirement as @declaration.struct above (#2837).
 (type_declaration
   (type_spec name: (type_identifier) @declaration.name
-    type: (interface_type))) @declaration.interface
+    type: (interface_type)) @declaration.interface)
 
 ;; Declarations — function
 (function_declaration
   name: (identifier) @declaration.name) @declaration.function
 
+;; Declarations — closure bindings (\`var f = func(){}\`, \`f := func(){}\`).
+;; The \`@declaration.function\` anchor sits on the INNER func_literal so its
+;; range aligns with the \`(func_literal) @scope.function\` scope above —
+;; without that alignment pass2AttachDeclarations owns the def by the module
+;; scope and calls inside the closure lose caller attribution. Mirrors the
+;; TypeScript \`const f = () => {}\` patterns (#2687).
+(var_declaration
+  (var_spec
+    name: (identifier) @declaration.name
+    value: (expression_list (func_literal) @declaration.function)))
+(var_declaration
+  (var_spec_list
+    (var_spec
+      name: (identifier) @declaration.name
+      value: (expression_list (func_literal) @declaration.function))))
+(short_var_declaration
+  left: (expression_list (identifier) @declaration.name)
+  right: (expression_list (func_literal) @declaration.function))
+
 ;; Declarations — method
 (method_declaration
   name: (field_identifier) @declaration.name) @declaration.method

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

@@ -7,6 +7,10 @@ import { goArityCompatibility, goMergeBindings, populateGoPackageSiblings, resol
 import { detectGoInterfaceImplementations } from './interface-impls.js';
 import { populateGoRangeBindings } from './range-binding.js';
 import { expandGoWildcardNames } from './expand-wildcards.js';
+import { goMapValueType } from './interpret.js';
+/** Slice `[]T` and array `[N]T` / `[...]T` → the element spelling. Hoisted —
+ *  a literal inside the hook would mint a fresh RegExp per folded subscript. */
+const GO_SLICE_ELEMENT_RE = /^\[[^\]]*\]\s*(.+)$/;
 export const goScopeResolver = {
     language: SupportedLanguages.Go,
     languageProvider: goProvider,
@@ -16,6 +20,41 @@ export const goScopeResolver = {
     expandsWildcardTo: (targetModuleScope, parsedFiles) => expandGoWildcardNames(targetModuleScope, parsedFiles),
     mergeBindings: (existing, incoming, scopeId) => goMergeBindings(existing, incoming, scopeId),
     arityCompatibility: (callsite, def) => goArityCompatibility(def, callsite),
+    // Only `*` — a pointer leaves the method set reachable by selector unchanged,
+    // so `*Host` and `Host` name the same class for receiver typing. `[]` and
+    // `map[…]` are deliberately NOT stripped here: they are containers whose
+    // member set differs from the element's, and unwrapping them belongs to the
+    // index step that consumed a subscript. (Field bindings never reach this
+    // anyway — `normalizeGoTypeName` already strips them at capture. The one
+    // binding that arrives decorated is the receiver self-binding, kept raw on
+    // purpose for `method-owners.ts`.)
+    stripTypePreservingDecoration: (typeName) => typeName.startsWith('*') ? typeName.slice(1).trim() : undefined,
+    // The subscript counterpart of the stripper above, and the reason the two are
+    // separate hooks: `*` is safe to strip at any class lookup, `[]` / `map[K]`
+    // only where the source actually indexed. Answers the `index` route only —
+    // Go has no property-style collection view.
+    //
+    // Reads the AS-WRITTEN spelling (`[]*User`), not the capture-normalized name:
+    // `normalizeGoTypeName` already collapsed that to `User`, which is exactly the
+    // ambiguity that made an unanswered index step fold onto the container. The
+    // element is returned STILL DECORATED (`*User`) — the index step looks it up
+    // through `stripTypePreservingDecoration` above, so the pointer resolves.
+    elementTypeOf: (containerType, via) => {
+        if (via.kind !== 'index')
+            return undefined;
+        const t = containerType.trim();
+        // `map[K]V` — a subscript yields V. Literally the same matcher
+        // `normalizeGoTypeName` uses, so the two cannot disagree on what a map
+        // spelling is.
+        const mapValue = goMapValueType(t);
+        if (mapValue !== undefined)
+            return mapValue;
+        // Slice `[]T` and array `[N]T` / `[...]T`.
+        const sliceMatch = GO_SLICE_ELEMENT_RE.exec(t);
+        if (sliceMatch !== null)
+            return sliceMatch[1].trim();
+        return undefined;
+    },
     buildMro: (graph, parsedFiles, nodeLookup) => buildMro(graph, parsedFiles, nodeLookup, defaultLinearize),
     populateOwners: (parsed) => populateGoOwners(parsed),
     populateWorkspaceOwners: (parsedFiles, ctx) => populateGoWorkspaceOwners(parsedFiles, ctx),

package/dist/core/ingestion/languages/go.js

@@ -132,6 +132,15 @@ export const goProvider = defineLanguage({
     descriptionExtractor: createLeadingDocDescriptionExtractor({
         lineCommentPrefixes: ['//'],
         lineDirectivePrefixes: ['//go:', '// +build', '//nolint', '//line'],
+        // #2837: Go type declarations anchor on the `type_spec`, whose
+        // `previousNamedSibling` is null for the ordinary `type T struct{…}` form —
+        // the godoc comment is a sibling of the enclosing `type_declaration`, one
+        // level up. Without this the doc silently vanished for EVERY Go struct and
+        // interface (measured: pre-#2837 `desc=YES`, post `none`), taking #2270's
+        // description out of both the embedding header and the FTS column.
+        // Functions/methods are unaffected — they anchor on their own declaration
+        // node, which does carry the comment as a previous sibling.
+        wrapperNodeTypes: ['type_declaration'],
     }),
     builtInNames: GO_BUILT_INS,
     // ── RFC #909 Ring 3: scope-based resolution hooks ──────────

package/dist/core/ingestion/languages/java/analysis-features.d.ts

@@ -1,3 +1,7 @@
 import type { AnalysisFeatureDescriptor } from '../../../analysis-features.js';
 /** Durable completeness contract for Java Spring configuration bindings. */
 export declare const SPRING_CONFIG_BINDINGS_FEATURE: AnalysisFeatureDescriptor;
+/** Durable completeness contract for implicit Java record-component accessors. */
+export declare const JAVA_RECORD_COMPONENT_ACCESSORS_FEATURE: AnalysisFeatureDescriptor;
+/** Durable completeness contract for Java heritage captures. */
+export declare const JAVA_ENUM_INTERFACE_HERITAGE_FEATURE: AnalysisFeatureDescriptor;

package/dist/core/ingestion/languages/java/analysis-features.js

@@ -11,3 +11,15 @@ export const SPRING_CONFIG_BINDINGS_FEATURE = {
     // need a one-time rebuild to backfill language-agnostic Property nodes.
     appliesTo: (filePaths) => filePaths.some((filePath) => filePath.toLowerCase().endsWith('.java') || isSpringApplicationConfig(filePath)),
 };
+/** Durable completeness contract for implicit Java record-component accessors. */
+export const JAVA_RECORD_COMPONENT_ACCESSORS_FEATURE = {
+    id: 'java.record-component-accessors',
+    version: 1,
+    appliesTo: (filePaths) => filePaths.some((filePath) => filePath.toLowerCase().endsWith('.java')),
+};
+/** Durable completeness contract for Java heritage captures. */
+export const JAVA_ENUM_INTERFACE_HERITAGE_FEATURE = {
+    id: 'java.heritage-captures',
+    version: 1,
+    appliesTo: (filePaths) => filePaths.some((filePath) => filePath.toLowerCase().endsWith('.java')),
+};

package/dist/core/ingestion/languages/java/capture-side-channel.d.ts

@@ -2,23 +2,35 @@ import type { ParsedFile } from '../../../../_shared/index.js';
 import { type ClassAnnotationFact } from '../../frameworks/spring/bean-candidates.js';
 import { type JvmPackageFact } from '../jvm/package-facts.js';
 import type { JavaSpringConfigConsumerFact } from './spring-config-bindings.js';
+import type { JavaSpringAopFact } from './spring-aop.js';
+import type { JavaSpringConditionalFact } from './spring-conditionals.js';
 import type { JavaSpringDiClassFact } from './spring-di.js';
+import type { JavaSpringNonHttpHandlerFact } from './spring-non-http-handlers.js';
 export type JavaClassAnnotationFact = ClassAnnotationFact;
 export interface JavaCaptureSideChannel {
     readonly kind: 'java';
     readonly packageFact: JvmPackageFact;
     readonly classAnnotations: readonly JavaClassAnnotationFact[];
+    readonly springAopFacts?: readonly JavaSpringAopFact[];
     readonly springConfigConsumers?: readonly JavaSpringConfigConsumerFact[];
+    readonly springConditionalFacts?: readonly JavaSpringConditionalFact[];
     readonly springDiFacts?: readonly JavaSpringDiClassFact[];
+    readonly springNonHttpHandlerFacts?: readonly JavaSpringNonHttpHandlerFact[];
 }
 /** Clear facts retained by a prior workspace pass in a long-lived process. */
 export declare function clearJavaClassAnnotationFacts(): void;
+export declare function setJavaSpringAopFacts(filePath: string, facts: readonly JavaSpringAopFact[]): void;
+export declare function getJavaSpringAopFacts(filePath: string): readonly JavaSpringAopFact[];
 /** Store the annotation syntax collected by Java's existing scope-query traversal. */
 export declare function setJavaClassAnnotationFacts(filePath: string, facts: readonly JavaClassAnnotationFact[]): void;
 export declare function setJavaSpringConfigConsumerFacts(filePath: string, facts: readonly JavaSpringConfigConsumerFact[]): void;
 export declare function getJavaSpringConfigConsumerFacts(filePath: string): readonly JavaSpringConfigConsumerFact[];
+export declare function setJavaSpringConditionalFacts(filePath: string, facts: readonly JavaSpringConditionalFact[]): void;
+export declare function getJavaSpringConditionalFacts(filePath: string): readonly JavaSpringConditionalFact[];
 export declare function setJavaSpringDiFacts(filePath: string, facts: readonly JavaSpringDiClassFact[]): void;
 export declare function getJavaSpringDiFacts(filePath: string): readonly JavaSpringDiClassFact[];
+export declare function setJavaSpringNonHttpHandlerFacts(filePath: string, facts: readonly JavaSpringNonHttpHandlerFact[]): void;
+export declare function getJavaSpringNonHttpHandlerFacts(filePath: string): readonly JavaSpringNonHttpHandlerFact[];
 /** Snapshot worker-local Java annotation facts for ParsedFile serialization. */
 export declare function collectJavaCaptureSideChannel(filePath: string): JavaCaptureSideChannel | undefined;
 export declare function getJavaClassAnnotationFacts(filePath: string): readonly JavaClassAnnotationFact[];

package/dist/core/ingestion/languages/java/capture-side-channel.js

@@ -2,13 +2,28 @@ import { createClassAnnotationFactStore, } from '../../frameworks/spring/bean-ca
 import { isJvmPackageFact, UNKNOWN_JVM_PACKAGE_FACT, } from '../jvm/package-facts.js';
 import { getJavaPackageFact, setJavaPackageFact } from './package-facts.js';
 const classAnnotations = createClassAnnotationFactStore();
+const springAopFacts = new Map();
 const springConfigConsumers = new Map();
+const springConditionalFacts = new Map();
 const springDiFacts = new Map();
+const springNonHttpHandlerFacts = new Map();
 /** Clear facts retained by a prior workspace pass in a long-lived process. */
 export function clearJavaClassAnnotationFacts() {
     classAnnotations.clear();
+    springAopFacts.clear();
     springConfigConsumers.clear();
+    springConditionalFacts.clear();
     springDiFacts.clear();
+    springNonHttpHandlerFacts.clear();
+}
+export function setJavaSpringAopFacts(filePath, facts) {
+    if (facts.length === 0)
+        springAopFacts.delete(filePath);
+    else
+        springAopFacts.set(filePath, facts);
+}
+export function getJavaSpringAopFacts(filePath) {
+    return springAopFacts.get(filePath) ?? [];
 }
 /** Store the annotation syntax collected by Java's existing scope-query traversal. */
 export function setJavaClassAnnotationFacts(filePath, facts) {
@@ -23,6 +38,15 @@ export function setJavaSpringConfigConsumerFacts(filePath, facts) {
 export function getJavaSpringConfigConsumerFacts(filePath) {
     return springConfigConsumers.get(filePath) ?? [];
 }
+export function setJavaSpringConditionalFacts(filePath, facts) {
+    if (facts.length === 0)
+        springConditionalFacts.delete(filePath);
+    else
+        springConditionalFacts.set(filePath, facts);
+}
+export function getJavaSpringConditionalFacts(filePath) {
+    return springConditionalFacts.get(filePath) ?? [];
+}
 export function setJavaSpringDiFacts(filePath, facts) {
     if (facts.length === 0)
         springDiFacts.delete(filePath);
@@ -32,15 +56,30 @@ export function setJavaSpringDiFacts(filePath, facts) {
 export function getJavaSpringDiFacts(filePath) {
     return springDiFacts.get(filePath) ?? [];
 }
+export function setJavaSpringNonHttpHandlerFacts(filePath, facts) {
+    if (facts.length === 0)
+        springNonHttpHandlerFacts.delete(filePath);
+    else
+        springNonHttpHandlerFacts.set(filePath, facts);
+}
+export function getJavaSpringNonHttpHandlerFacts(filePath) {
+    return springNonHttpHandlerFacts.get(filePath) ?? [];
+}
 /** Snapshot worker-local Java annotation facts for ParsedFile serialization. */
 export function collectJavaCaptureSideChannel(filePath) {
     const facts = classAnnotations.get(filePath);
+    const aopFacts = springAopFacts.get(filePath) ?? [];
     const configConsumers = springConfigConsumers.get(filePath) ?? [];
+    const conditionFacts = springConditionalFacts.get(filePath) ?? [];
     const diFacts = springDiFacts.get(filePath) ?? [];
+    const nonHttpHandlerFacts = springNonHttpHandlerFacts.get(filePath) ?? [];
     const packageFact = getJavaPackageFact(filePath);
     if (facts.length === 0 &&
+        aopFacts.length === 0 &&
         configConsumers.length === 0 &&
+        conditionFacts.length === 0 &&
         diFacts.length === 0 &&
+        nonHttpHandlerFacts.length === 0 &&
         packageFact === undefined) {
         return undefined;
     }
@@ -48,8 +87,11 @@ export function collectJavaCaptureSideChannel(filePath) {
         kind: 'java',
         packageFact: packageFact ?? UNKNOWN_JVM_PACKAGE_FACT,
         classAnnotations: facts,
+        ...(aopFacts.length > 0 ? { springAopFacts: aopFacts } : {}),
         ...(configConsumers.length > 0 ? { springConfigConsumers: configConsumers } : {}),
+        ...(conditionFacts.length > 0 ? { springConditionalFacts: conditionFacts } : {}),
         ...(diFacts.length > 0 ? { springDiFacts: diFacts } : {}),
+        ...(nonHttpHandlerFacts.length > 0 ? { springNonHttpHandlerFacts: nonHttpHandlerFacts } : {}),
     };
 }
 export function getJavaClassAnnotationFacts(filePath) {
@@ -64,13 +106,19 @@ export function applyJavaCaptureSideChannel(parsed) {
         data.kind !== 'java' ||
         !Array.isArray(data.classAnnotations)) {
         setJavaClassAnnotationFacts(parsed.filePath, []);
+        setJavaSpringAopFacts(parsed.filePath, []);
         setJavaSpringConfigConsumerFacts(parsed.filePath, []);
+        setJavaSpringConditionalFacts(parsed.filePath, []);
         setJavaSpringDiFacts(parsed.filePath, []);
+        setJavaSpringNonHttpHandlerFacts(parsed.filePath, []);
         setJavaPackageFact(parsed.filePath, UNKNOWN_JVM_PACKAGE_FACT);
         return;
     }
     setJavaClassAnnotationFacts(parsed.filePath, data.classAnnotations);
+    setJavaSpringAopFacts(parsed.filePath, Array.isArray(data.springAopFacts) ? data.springAopFacts : []);
     setJavaSpringConfigConsumerFacts(parsed.filePath, Array.isArray(data.springConfigConsumers) ? data.springConfigConsumers : []);
+    setJavaSpringConditionalFacts(parsed.filePath, Array.isArray(data.springConditionalFacts) ? data.springConditionalFacts : []);
     setJavaSpringDiFacts(parsed.filePath, Array.isArray(data.springDiFacts) ? data.springDiFacts : []);
+    setJavaSpringNonHttpHandlerFacts(parsed.filePath, Array.isArray(data.springNonHttpHandlerFacts) ? data.springNonHttpHandlerFacts : []);
     setJavaPackageFact(parsed.filePath, isJvmPackageFact(data.packageFact) ? data.packageFact : UNKNOWN_JVM_PACKAGE_FACT);
 }