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

package/dist/core/ingestion/languages/java/import-target.js

@@ -1,100 +1,80 @@
 /**
- * Adapter from `(ParsedImport, WorkspaceIndex)` → concrete file path.
+ * Adapter from `(ParsedImport, WorkspaceIndex)` → the file(s) an import names.
  *
- * Converts Java package paths (dots → slashes) and tries:
- *   1. Exact file match: `com/example/User.java`
- *   2. Suffix match for nested layouts
- *   3. Directory match (wildcard imports)
- *   4. Progressive prefix stripping for non-standard layouts
+ * Delegates to `module-resolution.ts`, which resolves a Java import the way
+ * Java defines it: a fully-qualified type name looked up against the packages
+ * the workspace's files DECLARE.
  *
- * Returns `null` for unresolvable / JDK imports.
+ * ## What #2953 replaced, and why path shape could not work
+ *
+ * This resolver used to turn dots into slashes and hunt for a file whose path
+ * ended that way — exact whole path, then any segment-suffix, then the first
+ * `.java` directly inside a matching directory — retrying the whole cascade
+ * with each leading segment stripped. Four legs, all describing where a file
+ * SITS rather than what it DECLARES.
+ *
+ * Path shape is a convention, so it mostly worked, and failed hardest on the
+ * case that matters: it had no way to 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` anywhere in the tree — a fabricated
+ * IMPORTS edge at full confidence, for an import naming a JDK class. Every JDK
+ * and third-party import in a repository was a candidate.
+ *
+ * Two secondary defects went with it, both consequences of resolving by shape:
+ *
+ *  - a wildcard `import com.example.*;` answered with ONE arbitrary file — the
+ *    first `.java` in the package directory in `allFilePaths` iteration order,
+ *    which the previous header documented at length as being decided by "a
+ *    property of the file list, not of the import". It now answers with every
+ *    file declaring that package, which is what the import actually names.
+ *  - a file's location and its package were assumed to agree. They need not:
+ *    `weird/path/User.java` declaring `package com.example;` is importable as
+ *    `com.example.User`, and `com/example/User.java` declaring nothing is in
+ *    the default package and importable as nothing at all. Both now resolve
+ *    correctly, because the declaration is what is read.
+ *
+ * The package declaration was already being extracted during the parse pass and
+ * has been reachable here through `getJavaPackageFact` the whole time; nothing
+ * read it. So this costs no new I/O — no `pom.xml`, no `build.gradle`, no
+ * source-root inference. The workspace describes itself.
+ */
+import { perFileSet } from '../../import-resolvers/per-file-set.js';
+import { getJavaPackageFact } from './package-facts.js';
+import { buildJavaPackageIndex, resolveJavaModule, } from './module-resolution.js';
+/**
+ * The package index, built once per pass and read by every import.
+ *
+ * Keyed on the `parsedFiles` array the orchestrator already threads through the
+ * pass, like PHP's `filesByDirectory` and Python's `parsedFileByPath`. The
+ * instrument that can see this memo fail counts element reads on that array —
+ * `countedParsedFiles` in `test/helpers/counting-file-set.ts`, asserted for
+ * every language by `import-target-index-reuse.contract.test.ts`.
  */
+const getJavaPackageIndex = perFileSet((parsedFiles) => buildJavaPackageIndex(parsedFiles, getJavaPackageFact));
 export function resolveJavaImportTarget(parsedImport, workspaceIndex) {
-    const ctx = workspaceIndex;
-    if (ctx === undefined ||
-        typeof ctx.fromFile !== 'string' ||
-        !(ctx.allFilePaths instanceof Set)) {
+    const ctx = narrowContext(workspaceIndex);
+    if (ctx === null)
         return null;
-    }
     if (parsedImport.kind === 'dynamic-unresolved')
         return null;
     if (parsedImport.targetRaw === null || parsedImport.targetRaw === '')
         return null;
-    // Strip trailing `.*` for wildcard imports: `com.example.*` → `com.example`
-    let target = parsedImport.targetRaw;
-    if (target.endsWith('.*')) {
-        target = target.slice(0, -2);
-    }
-    // Package path: `com.example.User` → `com/example/User`
-    const pathLike = target.replace(/\./g, '/');
-    const suffix = `/${pathLike}`;
-    let exactFile = null;
-    let suffixFile = null;
-    let directoryChild = null;
-    const dirPrefix = `${pathLike}/`;
-    const suffixDirPrefix = `/${dirPrefix}`;
-    for (const raw of ctx.allFilePaths) {
-        const f = raw.replace(/\\/g, '/');
-        if (!f.endsWith('.java'))
-            continue;
-        if (f === `${pathLike}.java`) {
-            exactFile = raw;
-            break;
-        }
-        if (suffixFile === null && f.endsWith(`${suffix}.java`)) {
-            suffixFile = raw;
-        }
-        if (directoryChild === null) {
-            const atRoot = f.startsWith(dirPrefix);
-            const atNested = f.includes(suffixDirPrefix);
-            if (atRoot || atNested) {
-                const idx = atRoot ? 0 : f.indexOf(suffixDirPrefix) + 1;
-                const after = f.slice(idx + dirPrefix.length);
-                if (after.length > 0 && !after.includes('/')) {
-                    directoryChild = raw;
-                }
-            }
-        }
-    }
-    if (exactFile !== null)
-        return exactFile;
-    if (suffixFile !== null)
-        return suffixFile;
-    if (directoryChild !== null)
-        return directoryChild;
-    // Progressive prefix stripping — handles `import com.example.User;`
-    // in a repo laid out `User.java` (no `com/example/` prefix).
-    const segments = pathLike.split('/').filter(Boolean);
-    for (let skip = 1; skip < segments.length; skip++) {
-        const tail = segments.slice(skip).join('/');
-        if (tail === '')
-            continue;
-        const tailFile = `${tail}.java`;
-        const tailSuffix = `/${tailFile}`;
-        const tailDir = `${tail}/`;
-        const tailSuffixDir = `/${tailDir}`;
-        let tailDirectChild = null;
-        for (const raw of ctx.allFilePaths) {
-            const f = raw.replace(/\\/g, '/');
-            if (!f.endsWith('.java'))
-                continue;
-            if (f === tailFile)
-                return raw;
-            if (f.endsWith(tailSuffix))
-                return raw;
-            if (tailDirectChild === null) {
-                const atRoot = f.startsWith(tailDir);
-                const atNested = f.includes(tailSuffixDir);
-                if (atRoot || atNested) {
-                    const idx = atRoot ? 0 : f.indexOf(tailSuffixDir) + 1;
-                    const after = f.slice(idx + tailDir.length);
-                    if (after.length > 0 && !after.includes('/'))
-                        tailDirectChild = raw;
-                }
-            }
-        }
-        if (tailDirectChild !== null)
-            return tailDirectChild;
+    const parsedFiles = ctx.parsedFiles;
+    if (parsedFiles === undefined || parsedFiles.length === 0)
+        return null;
+    return resolveJavaModule(parsedImport.targetRaw, getJavaPackageIndex(parsedFiles));
+}
+/**
+ * `WorkspaceIndex` is an opaque `unknown` placeholder in the shared contract;
+ * the orchestrator hands us a `JavaResolveContext`-shaped object. Narrow
+ * structurally rather than via a cast chain so unexpected shapes fail cleanly.
+ */
+function narrowContext(workspaceIndex) {
+    const ctx = workspaceIndex;
+    if (ctx === undefined ||
+        typeof ctx.fromFile !== 'string' ||
+        !(ctx.allFilePaths instanceof Set)) {
+        return null;
     }
-    return null;
+    return ctx;
 }

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

@@ -52,10 +52,11 @@ export function interpretJavaImport(captures) {
             // `import static com.example.Utils.*;`
             // The source is the class path (e.g. `com.example.Utils`).
             // Resolution should target the class file, not a wildcard directory
-            // scan — `Utils.java` is the file that contains the static members.
+            // scan — keeping the type path unstarred also distinguishes it from a
+            // package wildcard when a same-named package exists.
             return {
                 kind: 'wildcard',
-                targetRaw: sourceCap.text + '.*',
+                targetRaw: sourceCap.text,
             };
         }
         default:

package/dist/core/ingestion/languages/java/module-resolution.d.ts

@@ -0,0 +1,62 @@
+/**
+ * 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.
+ */
+import type { ParsedFile } from '../../../../_shared/index.js';
+import type { JvmPackageFact } from '../jvm/package-facts.js';
+export interface JavaPackageIndex {
+    /** Declared package -> importable type name -> the file declaring it. */
+    readonly typesByPackage: ReadonlyMap<string, ReadonlyMap<string, string>>;
+    /** Declared package -> every file declaring it, for wildcard imports. */
+    readonly filesByPackage: ReadonlyMap<string, readonly string[]>;
+    /**
+     * Files whose `package` header could not be read (a malformed header — see
+     * `extractJvmPackageFact`). They are in no package, so nothing can import
+     * them; counted so the gap is observable rather than silent.
+     */
+    readonly unreadablePackageFiles: number;
+}
+/**
+ * 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 declare function buildJavaPackageIndex(parsedFiles: readonly ParsedFile[], packageOf: (filePath: string) => JvmPackageFact | undefined): JavaPackageIndex;
+/**
+ * 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 declare function resolveJavaModule(targetRaw: string, index: JavaPackageIndex): string | readonly string[] | null;

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/package-facts.d.ts

@@ -0,0 +1,5 @@
+import { type JvmPackageFact, type JvmPackageSyntaxNode } from '../jvm/package-facts.js';
+export declare const clearJavaPackageFacts: () => void;
+export declare const captureJavaPackageFact: (filePath: string, root: JvmPackageSyntaxNode) => void;
+export declare const setJavaPackageFact: (filePath: string, fact: JvmPackageFact) => void;
+export declare const getJavaPackageFact: (filePath: string) => JvmPackageFact | undefined;

package/dist/core/ingestion/languages/java/package-facts.js

@@ -0,0 +1,9 @@
+import { createJvmPackageFactStore, } from '../jvm/package-facts.js';
+const javaPackageFacts = createJvmPackageFactStore({
+    packageNodeType: 'package_declaration',
+    packageNameNodeTypes: ['scoped_identifier', 'identifier'],
+});
+export const clearJavaPackageFacts = () => javaPackageFacts.clear();
+export const captureJavaPackageFact = (filePath, root) => javaPackageFacts.capture(filePath, root);
+export const setJavaPackageFact = (filePath, fact) => javaPackageFacts.set(filePath, fact);
+export const getJavaPackageFact = (filePath) => javaPackageFacts.get(filePath);

package/dist/core/ingestion/languages/java/package-siblings.d.ts

@@ -1,17 +1,4 @@
-/**
- * Java package-scope implicit visibility.
- *
- * Classes in the same Java package see each other without explicit
- * `import` statements.  This hook groups files by `package` declaration,
- * then injects cross-file class defs into each file's module-scope
- * `bindingAugmentations` and mirrors type-bindings across same-package
- * files — the Java equivalent of C#'s `populateNamespaceSiblings`.
- */
-import type { ParsedFile } from '../../../../_shared/index.js';
-import type { ScopeResolutionIndexes } from '../../model/scope-resolution-indexes.js';
-export declare function populateJavaPackageSiblings(parsedFiles: readonly ParsedFile[], indexes: ScopeResolutionIndexes, ctx: {
+export declare const populateJavaPackageSiblings: (parsedFiles: readonly import('../../../../_shared/index.js').ParsedFile[], indexes: import("../../model/scope-resolution-indexes.js").ScopeResolutionIndexes, ctx: {
     readonly fileContents: ReadonlyMap<string, string>;
-    readonly treeCache?: {
-        get(filePath: string): unknown;
-    };
-}): void;
+}) => void;
+export declare const isJavaPackageSiblingVisibilityIncomplete: (filePath: string) => boolean;

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

@@ -1,147 +1,8 @@
-/**
- * Java package-scope implicit visibility.
- *
- * Classes in the same Java package see each other without explicit
- * `import` statements.  This hook groups files by `package` declaration,
- * then injects cross-file class defs into each file's module-scope
- * `bindingAugmentations` and mirrors type-bindings across same-package
- * files — the Java equivalent of C#'s `populateNamespaceSiblings`.
- */
-import { isClassLike } from '../../scope-resolution/scope/walkers.js';
-import { getJavaParser } from './query.js';
-import { parseSourceSafe, ParseTimeoutError } from '../../../tree-sitter/safe-parse.js';
-import { logger } from '../../../logger.js';
-function extractPackageName(content, filePath, cachedTree) {
-    let tree = cachedTree;
-    if (tree === undefined) {
-        try {
-            tree = parseSourceSafe(getJavaParser(), content);
-        }
-        catch (err) {
-            if (err instanceof ParseTimeoutError) {
-                // Degrade to "no package" so a single pathological file doesn't abort
-                // same-package sibling injection for the whole run.
-                logger.warn({ file: filePath }, 'java package-siblings: parse timed out, treating as no package');
-                return '';
-            }
-            throw err;
-        }
-    }
-    for (const child of tree.rootNode.namedChildren) {
-        if (child.type === 'package_declaration') {
-            const scoped = child.namedChildren.find((c) => c.type === 'scoped_identifier' || c.type === 'identifier');
-            return scoped?.text ?? '';
-        }
-    }
-    return '';
-}
-export function populateJavaPackageSiblings(parsedFiles, indexes, ctx) {
-    const buckets = new Map();
-    for (const parsed of parsedFiles) {
-        const content = ctx.fileContents.get(parsed.filePath);
-        if (content === undefined)
-            continue;
-        const pkg = extractPackageName(content, parsed.filePath, ctx.treeCache?.get(parsed.filePath));
-        let bucket = buckets.get(pkg);
-        if (bucket === undefined) {
-            bucket = { parsed: [], moduleScopes: [] };
-            buckets.set(pkg, bucket);
-        }
-        bucket.parsed.push(parsed);
-        const ms = parsed.scopes.find((s) => s.kind === 'Module');
-        if (ms !== undefined) {
-            bucket.moduleScopes.push({ filePath: parsed.filePath, scope: ms });
-        }
-    }
-    const augmentations = indexes.bindingAugmentations;
-    const MAX_PACKAGE_FILES = 500;
-    for (const bucket of buckets.values()) {
-        if (bucket.moduleScopes.length < 2)
-            continue;
-        if (bucket.moduleScopes.length > MAX_PACKAGE_FILES) {
-            logger.warn(`[java-package-siblings] skipping package with ${bucket.moduleScopes.length} files (cap=${MAX_PACKAGE_FILES}); same-package implicit visibility disabled for this package`);
-            continue;
-        }
-        const classDefs = [];
-        for (const parsed of bucket.parsed) {
-            const moduleScope = parsed.scopes.find((s) => s.kind === 'Module');
-            const moduleScopeId = moduleScope?.id;
-            for (const scope of parsed.scopes) {
-                if (scope.kind !== 'Class')
-                    continue;
-                if (scope.parent !== moduleScopeId)
-                    continue;
-                for (const def of scope.ownedDefs) {
-                    if (isClassLike(def.type)) {
-                        classDefs.push({ def, filePath: parsed.filePath });
-                        break;
-                    }
-                }
-            }
-        }
-        for (const { filePath, scope } of bucket.moduleScopes) {
-            let scopeAug = augmentations.get(scope.id);
-            if (scopeAug === undefined) {
-                scopeAug = new Map();
-                augmentations.set(scope.id, scopeAug);
-            }
-            const candidates = classDefs.filter((d) => d.filePath !== filePath);
-            const proximityCache = new Map();
-            for (const c of candidates) {
-                if (!proximityCache.has(c.filePath)) {
-                    proximityCache.set(c.filePath, sharedSegmentCount(c.filePath, filePath));
-                }
-            }
-            const sorted = candidates.sort((a, b) => (proximityCache.get(b.filePath) ?? 0) - (proximityCache.get(a.filePath) ?? 0));
-            const injectedIds = new Set();
-            for (const { def } of sorted) {
-                if (injectedIds.has(def.nodeId))
-                    continue;
-                const qn = def.qualifiedName;
-                if (qn === undefined)
-                    continue;
-                injectedIds.add(def.nodeId);
-                const simpleName = qn.includes('.') ? qn.slice(qn.lastIndexOf('.') + 1) : qn;
-                let list = scopeAug.get(simpleName);
-                if (list === undefined) {
-                    list = [];
-                    scopeAug.set(simpleName, list);
-                }
-                list.push({ def, origin: 'namespace' });
-            }
-            const tb = scope.typeBindings;
-            for (const sibling of bucket.moduleScopes) {
-                if (sibling.filePath === filePath)
-                    continue;
-                for (const [name, ref] of sibling.scope.typeBindings) {
-                    if (tb.has(name))
-                        continue;
-                    tb.set(name, ref);
-                }
-            }
-            for (const sibParsed of bucket.parsed) {
-                if (sibParsed.filePath === filePath)
-                    continue;
-                for (const sibScope of sibParsed.scopes) {
-                    if (sibScope.kind !== 'Class')
-                        continue;
-                    for (const [name, ref] of sibScope.typeBindings) {
-                        if (ref.source === 'self')
-                            continue;
-                        if (tb.has(name))
-                            continue;
-                        tb.set(name, ref);
-                    }
-                }
-            }
-        }
-    }
-}
-function sharedSegmentCount(a, b) {
-    const sa = a.replace(/\\/g, '/').split('/');
-    const sb = b.replace(/\\/g, '/').split('/');
-    let i = 0;
-    while (i < sa.length && i < sb.length && sa[i] === sb[i])
-        i++;
-    return i;
-}
+import { createJvmPackageSiblingVisibility } from '../jvm/package-siblings.js';
+import { getJavaPackageFact } from './package-facts.js';
+const javaPackageSiblingVisibility = createJvmPackageSiblingVisibility({
+    languageLabel: 'java',
+    getPackageFact: getJavaPackageFact,
+});
+export const populateJavaPackageSiblings = javaPackageSiblingVisibility.populateNamespaceSiblings;
+export const isJavaPackageSiblingVisibilityIncomplete = javaPackageSiblingVisibility.isVisibilityIncomplete;

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

@@ -37,27 +37,63 @@ const JAVA_SCOPE_QUERY = `
 (record_declaration) @scope.class
 (annotation_type_declaration) @scope.class
 
+;; Anonymous class body: \`new Runnable() { public void run() {} }\`.
+;; Without its own scope, a method's auto-hoist (scope-extractor.ts) has
+;; nowhere to stop and leaks the name past the anonymous class into the
+;; enclosing scope -- the same failure mode fixed for TS/JS object
+;; literals (#2545).
+(object_creation_expression
+  (class_body) @scope.class)
+
+;; Enum constant body: \`enum E { A { public void hook() {} } }\` --
+;; javac's other anonymous-class shape (E$N), same scope-boundary need
+;; and same class_body anchor (#2555).
+(enum_constant
+  body: (class_body) @scope.class)
+
 (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
 
+;; Class annotation syntax is carried to post-resolution enrichment. Keeping
+;; this in the existing scope query avoids a second AST build/traversal.
+(class_declaration
+  (modifiers
+    [
+      (marker_annotation name: (_) @class-annotation.name)
+      (annotation name: (_) @class-annotation.name)
+    ])) @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