cgraphx 2.0.2 → 2.0.6

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

@@ -0,0 +1,319 @@
+"use strict";
+/**
+ * Tree-sitter query for Java scope captures (RFC §5.1).
+ *
+ * Captures the structural skeleton the generic scope-resolution
+ * pipeline consumes: scopes (module/class/function), declarations
+ * (class-likes, method-likes, fields, variables), imports (import
+ * declarations), type bindings (parameter annotations, variable
+ * annotations, constructor inference), and references (call sites,
+ * member writes/reads).
+ *
+ * Java specifics that shape this query:
+ *
+ *   - Java uses `program` as the root node (not `compilation_unit`).
+ *   - `import_declaration` nodes carry `scoped_identifier` children
+ *     and optional `asterisk` for wildcard imports.
+ *   - `static` imports are detected by an anonymous `static` token
+ *     child within `import_declaration`.
+ *   - `var` (Java 10+ local variable type inference) parses as a
+ *     `type_identifier` with text `"var"`, not a dedicated node type.
+ *   - Modifiers (`public`, `static`, etc.) are grouped under a
+ *     `modifiers` named child with anonymous keyword tokens.
+ *   - Superclass inheritance uses a `superclass:` field containing
+ *     a `superclass` node wrapping a `type_identifier`.
+ *
+ * Exposes lazy `Parser` and `Query` singletons so callers don't pay
+ * tree-sitter init cost per file.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getJavaParser = getJavaParser;
+exports.getJavaScopeQuery = getJavaScopeQuery;
+const tree_sitter_1 = __importDefault(require("tree-sitter"));
+const tree_sitter_java_1 = __importDefault(require("tree-sitter-java"));
+const JAVA_SCOPE_QUERY = `
+;; Scopes
+(program) @scope.module
+
+(class_declaration) @scope.class
+(interface_declaration) @scope.class
+(enum_declaration) @scope.class
+(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
+  type_parameters: (type_parameters)? @declaration.type-parameters) @declaration.class
+
+(interface_declaration
+  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
+  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
+(method_declaration
+  name: (identifier) @declaration.name) @declaration.method
+
+(constructor_declaration
+  name: (identifier) @declaration.name) @declaration.constructor
+
+;; Declarations — fields
+(field_declaration
+  declarator: (variable_declarator
+    name: (identifier) @declaration.name)) @declaration.variable
+
+;; Declarations — local variables
+(local_variable_declaration
+  declarator: (variable_declarator
+    name: (identifier) @declaration.name)) @declaration.variable
+
+;; Imports — single anchor per import_declaration
+(import_declaration) @import.statement
+
+;; Type bindings — parameter annotations: void f(User u)
+(formal_parameter
+  type: (type_identifier) @type-binding.type
+  name: (identifier) @type-binding.name) @type-binding.parameter
+
+(formal_parameter
+  type: (generic_type) @type-binding.type
+  name: (identifier) @type-binding.name) @type-binding.parameter
+
+(formal_parameter
+  type: (scoped_type_identifier) @type-binding.type
+  name: (identifier) @type-binding.name) @type-binding.parameter
+
+;; Type bindings — local variable annotations: User u = new User();
+(local_variable_declaration
+  type: (type_identifier) @type-binding.type
+  declarator: (variable_declarator
+    name: (identifier) @type-binding.name)) @type-binding.annotation
+
+(local_variable_declaration
+  type: (generic_type) @type-binding.type
+  declarator: (variable_declarator
+    name: (identifier) @type-binding.name)) @type-binding.annotation
+
+;; Type bindings — var u = svc.getUser(); (Java 10+ call-result inference)
+(local_variable_declaration
+  type: (type_identifier) @_var_type
+  (#eq? @_var_type "var")
+  declarator: (variable_declarator
+    name: (identifier) @type-binding.name
+    value: (method_invocation
+      name: (identifier) @type-binding.type))) @type-binding.call-result
+
+;; Type bindings — var alias = u; (Java 10+ alias inference)
+(local_variable_declaration
+  type: (type_identifier) @_var_type
+  (#eq? @_var_type "var")
+  declarator: (variable_declarator
+    name: (identifier) @type-binding.name
+    value: (identifier) @type-binding.type)) @type-binding.alias
+
+;; Type bindings — var addr = user.address; (Java 10+ field-access alias)
+(local_variable_declaration
+  type: (type_identifier) @_var_type
+  (#eq? @_var_type "var")
+  declarator: (variable_declarator
+    name: (identifier) @type-binding.name
+    value: (field_access
+      field: (identifier) @type-binding.type))) @type-binding.alias
+
+;; Type bindings — enhanced-for with var: for (var user : users)
+(enhanced_for_statement
+  (type_identifier) @_var_type
+  (#eq? @_var_type "var")
+  (identifier) @type-binding.name
+  (identifier) @type-binding.type) @type-binding.alias
+
+;; Enhanced-for with var + method iterable: for (var user : data.values())
+(enhanced_for_statement
+  (type_identifier) @_var_type
+  (#eq? @_var_type "var")
+  (identifier) @type-binding.name
+  (method_invocation
+    object: (identifier) @type-binding.type)) @type-binding.alias
+
+;; Type bindings — var u = new User(); (Java 10+ local variable type inference)
+;; tree-sitter-java parses \`var\` as a \`type_identifier\` with text "var".
+;; The type-binding.constructor anchor fires when the rhs is an
+;; object_creation_expression so interpretJavaTypeBinding can infer
+;; the concrete type from the constructor call.
+(local_variable_declaration
+  type: (type_identifier) @_var_type
+  declarator: (variable_declarator
+    name: (identifier) @type-binding.name
+    value: (object_creation_expression
+      type: (type_identifier) @type-binding.type))) @type-binding.constructor
+
+;; Type bindings — field declarations: private User user;
+(field_declaration
+  type: (type_identifier) @type-binding.type
+  declarator: (variable_declarator
+    name: (identifier) @type-binding.name)) @type-binding.annotation
+
+(field_declaration
+  type: (generic_type) @type-binding.type
+  declarator: (variable_declarator
+    name: (identifier) @type-binding.name)) @type-binding.annotation
+
+;; Type bindings — method return type: public User getUser() { }
+(method_declaration
+  type: (type_identifier) @type-binding.type
+  name: (identifier) @type-binding.name) @type-binding.return
+
+(method_declaration
+  type: (generic_type) @type-binding.type
+  name: (identifier) @type-binding.name) @type-binding.return
+
+;; Type bindings — enhanced for: for (User u : list)
+(enhanced_for_statement
+  type: (type_identifier) @type-binding.type
+  name: (identifier) @type-binding.name) @type-binding.annotation
+
+(enhanced_for_statement
+  type: (generic_type) @type-binding.type
+  name: (identifier) @type-binding.name) @type-binding.annotation
+
+;; Type bindings — instanceof pattern (Java 16+): if (obj instanceof User user)
+(instanceof_expression
+  (type_identifier) @type-binding.type
+  (identifier) @type-binding.name) @type-binding.pattern
+
+;; Type bindings — switch case pattern (Java 21+): case User user ->
+(type_pattern
+  (type_identifier) @type-binding.type
+  (identifier) @type-binding.name) @type-binding.pattern
+
+;; References — all method calls: foo() and obj.method()
+;; tree-sitter-java's query engine drops negation-based \`!object\`
+;; patterns when a positive \`object:\` pattern exists for the same
+;; node type, so we match all calls here and classify free vs
+;; member in captures.ts based on the presence of @reference.receiver.
+(method_invocation
+  object: (_) @reference.receiver
+  name: (identifier) @reference.name) @reference.call.member
+
+(method_invocation
+  name: (identifier) @reference.name) @reference.call.free
+
+;; References — constructor calls: new User(...)
+(object_creation_expression
+  type: (type_identifier) @reference.name) @reference.call.constructor
+
+(object_creation_expression
+  type: (generic_type
+    (type_identifier) @reference.name)) @reference.call.constructor
+
+;; References — qualified constructor calls: new pkg.Foo(), new a.b.Foo() (F35 #1928)
+;; tree-sitter-java parses \`pkg.Foo\` as a scoped_type_identifier whose final
+;; child is the simple type. Bind that tail as @reference.name (trailing \`.\`
+;; anchor = last child) so resolution targets \`Foo\`, not the raw \`pkg.Foo\` text.
+;; Mirrors the TS/JS new-expression qualified-constructor capture.
+(object_creation_expression
+  type: (scoped_type_identifier
+    (type_identifier) @reference.name .) @reference.call.constructor.qualified) @reference.call.constructor
+
+;; References — qualified + generic constructor calls: new pkg.Box<T>() (F35 #1928)
+;; The base is a generic_type whose first child is a scoped_type_identifier, so
+;; neither the simple-generic nor the plain-scoped arm above matches it. Bind the
+;; scoped tail as @reference.name.
+(object_creation_expression
+  type: (generic_type
+    (scoped_type_identifier
+      (type_identifier) @reference.name .) @reference.call.constructor.qualified)) @reference.call.constructor
+
+;; References — method references: User::getName, obj::method
+(method_reference
+  (identifier) @reference.receiver
+  (identifier) @reference.name) @reference.call.member
+
+;; References — this::method and super::method
+(method_reference
+  (this) @reference.receiver
+  (identifier) @reference.name) @reference.call.member
+
+(method_reference
+  (super) @reference.receiver
+  (identifier) @reference.name) @reference.call.member
+
+;; References — field_access::method: responseBuilder::buildResponse
+(method_reference
+  (field_access) @reference.receiver
+  (identifier) @reference.name) @reference.call.member
+
+;; References — constructor references: User::new
+(method_reference
+  (identifier) @reference.name
+  "new") @reference.call.constructor
+
+;; References — field/property writes: obj.name = "x"
+(assignment_expression
+  left: (field_access
+    object: (_) @reference.receiver
+    field: (identifier) @reference.name)) @reference.write.member
+
+;; References — field/property reads: obj.name
+(field_access
+  object: (_) @reference.receiver
+  field: (identifier) @reference.name) @reference.read.member
+`;
+let _parser = null;
+let _query = null;
+function getJavaParser() {
+    if (_parser === null) {
+        _parser = new tree_sitter_1.default();
+        _parser.setLanguage(tree_sitter_java_1.default);
+    }
+    return _parser;
+}
+function getJavaScopeQuery() {
+    if (_query === null) {
+        _query = new tree_sitter_1.default.Query(tree_sitter_java_1.default, JAVA_SCOPE_QUERY);
+    }
+    return _query;
+}

package/dist/core/code/engine/core/ingestion/languages/java/receiver-binding.js

@@ -0,0 +1,98 @@
+"use strict";
+/**
+ * Synthesize `@type-binding.self` captures for Java instance methods —
+ * one for `this` (always on non-static methods inside a type
+ * declaration) and optionally one for `super` (only on class methods
+ * when the enclosing class has a `superclass`).
+ *
+ * Mirrors `languages/csharp/receiver-binding.ts` in structure.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.synthesizeJavaReceiverBinding = synthesizeJavaReceiverBinding;
+const ast_helpers_js_1 = require("../../utils/ast-helpers.js");
+const TYPE_DECL_NODE_TYPES = new Set([
+    'class_declaration',
+    'interface_declaration',
+    'enum_declaration',
+    'record_declaration',
+]);
+const FUNCTION_NODE_TYPES = new Set(['method_declaration', 'constructor_declaration']);
+/** Walk up to the enclosing type declaration. */
+function findEnclosingTypeDeclaration(node) {
+    let cur = node.parent;
+    while (cur !== null) {
+        if (TYPE_DECL_NODE_TYPES.has(cur.type))
+            return cur;
+        cur = cur.parent;
+    }
+    return null;
+}
+function typeName(typeNode) {
+    return typeNode.childForFieldName('name')?.text ?? null;
+}
+/** First superclass text. tree-sitter-java uses a `superclass` field
+ *  containing a `superclass` node wrapping a `type_identifier`. */
+function firstSuperclassText(typeNode) {
+    const superclass = typeNode.childForFieldName('superclass');
+    if (superclass === null)
+        return null;
+    // The superclass node wraps the type_identifier
+    for (let i = 0; i < superclass.namedChildCount; i++) {
+        const child = superclass.namedChild(i);
+        if (child !== null && (child.type === 'type_identifier' || child.type === 'generic_type')) {
+            return child.text;
+        }
+    }
+    return null;
+}
+/** Check if a method has the `static` modifier. In tree-sitter-java,
+ *  modifiers are grouped under a `modifiers` named child with anonymous
+ *  keyword tokens. */
+function isStaticMethod(fnNode) {
+    for (let i = 0; i < fnNode.namedChildCount; i++) {
+        const child = fnNode.namedChild(i);
+        if (child !== null && child.type === 'modifiers') {
+            for (let j = 0; j < child.childCount; j++) {
+                const mod = child.child(j);
+                if (mod !== null && mod.text.trim() === 'static')
+                    return true;
+            }
+        }
+    }
+    return false;
+}
+function synthesizeJavaReceiverBinding(fnNode) {
+    if (!FUNCTION_NODE_TYPES.has(fnNode.type))
+        return [];
+    if (isStaticMethod(fnNode))
+        return [];
+    const enclosingType = findEnclosingTypeDeclaration(fnNode);
+    if (enclosingType === null)
+        return [];
+    const enclosingName = typeName(enclosingType);
+    if (enclosingName === null)
+        return [];
+    // Anchor to the method body so the synthesized captures are inside
+    // the function scope.
+    const anchorNode = fnNode.childForFieldName('body');
+    if (anchorNode === null)
+        return [];
+    const out = [];
+    out.push(buildReceiverMatch(anchorNode, 'this', enclosingName));
+    // `super` applies only to class/record methods with an explicit superclass.
+    if (enclosingType.type === 'class_declaration' || enclosingType.type === 'record_declaration') {
+        const superText = firstSuperclassText(enclosingType);
+        if (superText !== null) {
+            out.push(buildReceiverMatch(anchorNode, 'super', superText));
+        }
+    }
+    return out;
+}
+function buildReceiverMatch(anchorNode, name, typeText) {
+    const m = {
+        '@type-binding.self': (0, ast_helpers_js_1.nodeToCapture)('@type-binding.self', anchorNode),
+        '@type-binding.name': (0, ast_helpers_js_1.syntheticCapture)('@type-binding.name', anchorNode, name),
+        '@type-binding.type': (0, ast_helpers_js_1.syntheticCapture)('@type-binding.type', anchorNode, typeText),
+    };
+    return m;
+}

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

@@ -0,0 +1,213 @@
+"use strict";
+/**
+ * Java `ScopeResolver` registered in `SCOPE_RESOLVERS` and consumed by
+ * the generic `runScopeResolution` orchestrator (RFC #909 Ring 3).
+ *
+ * Java resolves via the scope-resolution registry — the sole
+ * call-resolution path.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.javaScopeResolver = void 0;
+const index_js_1 = require("../../../../../shared/index.js");
+const mro_js_1 = require("../../scope-resolution/passes/mro.js");
+const ids_js_1 = require("../../scope-resolution/graph-bridge/ids.js");
+const walkers_js_1 = require("../../scope-resolution/scope/walkers.js");
+const imported_return_types_js_1 = require("../../scope-resolution/passes/imported-return-types.js");
+const java_js_1 = require("../java.js");
+const index_js_2 = require("./index.js");
+const package_siblings_js_1 = require("./package-siblings.js");
+const spring_bean_metadata_js_1 = require("./spring-bean-metadata.js");
+const spring_aop_js_1 = require("./spring-aop.js");
+const spring_config_bindings_js_1 = require("./spring-config-bindings.js");
+const spring_conditionals_js_1 = require("./spring-conditionals.js");
+const spring_di_js_1 = require("./spring-di.js");
+const capture_side_channel_js_1 = require("./capture-side-channel.js");
+const package_facts_js_1 = require("./package-facts.js");
+const javaScopeResolver = {
+    language: index_js_1.SupportedLanguages.Java,
+    languageProvider: java_js_1.javaProvider,
+    importEdgeReason: 'java-scope: import',
+    loadResolutionConfig: () => {
+        // Worker capture facts are process-local and outlive a single analysis in
+        // server mode. This hook runs once before each Java workspace pass, before
+        // ParsedFile side channels are restored for the current files.
+        (0, capture_side_channel_js_1.clearJavaClassAnnotationFacts)();
+        (0, package_facts_js_1.clearJavaPackageFacts)();
+        return undefined;
+    },
+    resolveImportTarget: (targetRaw, fromFile, allFilePaths) => {
+        const ws = { fromFile, allFilePaths };
+        return (0, index_js_2.resolveJavaImportTarget)({ kind: 'named', localName: '_', importedName: '_', targetRaw }, ws);
+    },
+    mergeBindings: (existing, incoming) => [...(0, index_js_2.javaMergeBindings)([...existing, ...incoming])],
+    arityCompatibility: (callsite, def) => (0, index_js_2.javaArityCompatibility)(def, callsite),
+    buildMro: buildJavaMro,
+    populateOwners: (parsed) => (0, walkers_js_1.populateClassOwnedMembers)(parsed),
+    applyCaptureSideChannel: capture_side_channel_js_1.applyJavaCaptureSideChannel,
+    isSuperReceiver: (text) => text.trim() === 'super',
+    fieldFallbackOnMethodLookup: false,
+    propagatesReturnTypesAcrossImports: true,
+    collapseMemberCallsByCallerTarget: true,
+    hoistTypeBindingsToModule: true,
+    stripReceiverCastExpressions: true,
+    // #2550: every Java method belongs to a class instance — a free call may
+    // resolve to a Method only when the caller's enclosing class chain
+    // (self + MRO) contains the method's owner. Closes the finalize-bucket
+    // leak (unqualified `run()` matching an unrelated same-file anonymous
+    // class's method). C# is the intended next adopter.
+    freeCallsRequireInstanceOwnership: true,
+    populateNamespaceSiblings: package_siblings_js_1.populateJavaPackageSiblings,
+    populateRangeBindings: populateJavaCrossFileReturnTypes,
+    emitPostResolutionEdges: (graph, parsedFiles, nodeLookup, indexes, ctx) => {
+        (0, spring_bean_metadata_js_1.attachSpringBeanCandidateMetadata)(graph, parsedFiles, nodeLookup, indexes);
+        (0, spring_aop_js_1.attachJavaSpringAopMetadata)(graph, parsedFiles, nodeLookup, indexes);
+        (0, spring_conditionals_js_1.attachJavaSpringConditionalMetadata)(graph, parsedFiles, nodeLookup, indexes);
+        (0, spring_di_js_1.attachJavaSpringDiMetadata)(graph, parsedFiles, nodeLookup, indexes);
+        (0, spring_config_bindings_js_1.attachJavaSpringConfigBindings)(graph, parsedFiles, nodeLookup, indexes, ctx);
+    },
+};
+exports.javaScopeResolver = javaScopeResolver;
+function populateJavaCrossFileReturnTypes(parsedFiles, indexes) {
+    const moduleScopeByFile = new Map();
+    const classScopesByFile = new Map();
+    for (const parsed of parsedFiles) {
+        const ms = parsed.scopes.find((s) => s.kind === 'Module');
+        if (ms !== undefined)
+            moduleScopeByFile.set(parsed.filePath, ms);
+        const cs = parsed.scopes.filter((s) => s.kind === 'Class');
+        if (cs.length > 0)
+            classScopesByFile.set(parsed.filePath, cs);
+    }
+    for (const parsed of parsedFiles) {
+        const importerModule = moduleScopeByFile.get(parsed.filePath);
+        if (importerModule === undefined)
+            continue;
+        const ambiguousMirrors = new Set();
+        for (const name of (0, walkers_js_1.namesAtScope)(importerModule.id, indexes)) {
+            const refs = (0, walkers_js_1.lookupBindingsAt)(importerModule.id, name, indexes);
+            for (const ref of refs) {
+                if (ref.origin !== 'import' && ref.origin !== 'reexport')
+                    continue;
+                if (!(0, walkers_js_1.isClassLike)(ref.def.type))
+                    continue;
+                const sourceModule = moduleScopeByFile.get(ref.def.filePath);
+                if (sourceModule === undefined)
+                    continue;
+                const tb = importerModule.typeBindings;
+                for (const [srcName, srcRef] of sourceModule.typeBindings) {
+                    if (srcRef.source !== 'return-annotation')
+                        continue;
+                    if (ambiguousMirrors.has(srcName))
+                        continue;
+                    const existing = tb.get(srcName);
+                    if (existing !== undefined && existing.rawName !== srcRef.rawName) {
+                        ambiguousMirrors.add(srcName);
+                        tb.delete(srcName);
+                        continue;
+                    }
+                    if (existing === undefined)
+                        tb.set(srcName, srcRef);
+                }
+                for (const classScope of classScopesByFile.get(ref.def.filePath) ?? []) {
+                    for (const [srcName, srcRef] of classScope.typeBindings) {
+                        if (srcRef.source === 'self' || srcRef.source === 'parameter-annotation')
+                            continue;
+                        if (ambiguousMirrors.has(srcName))
+                            continue;
+                        const existing = tb.get(srcName);
+                        if (existing !== undefined && existing.rawName !== srcRef.rawName) {
+                            ambiguousMirrors.add(srcName);
+                            tb.delete(srcName);
+                            continue;
+                        }
+                        if (existing === undefined)
+                            tb.set(srcName, srcRef);
+                    }
+                }
+            }
+        }
+        for (const [name, ref] of importerModule.typeBindings) {
+            const resolved = (0, imported_return_types_js_1.followChainPostFinalize)(ref, importerModule.id, indexes);
+            if (resolved !== ref) {
+                importerModule.typeBindings.set(name, resolved);
+            }
+        }
+    }
+    for (const parsed of parsedFiles) {
+        const moduleScopeId = moduleScopeByFile.get(parsed.filePath)?.id;
+        for (const scope of parsed.scopes) {
+            if (scope.id === moduleScopeId)
+                continue;
+            for (const [name, ref] of scope.typeBindings) {
+                const resolved = (0, imported_return_types_js_1.followChainPostFinalize)(ref, scope.id, indexes);
+                if (resolved !== ref) {
+                    scope.typeBindings.set(name, resolved);
+                }
+            }
+        }
+    }
+}
+function buildJavaMro(graph, parsedFiles, nodeLookup) {
+    const mro = (0, mro_js_1.buildMro)(graph, parsedFiles, nodeLookup, mro_js_1.defaultLinearize);
+    const defIdByGraphId = new Map();
+    for (const parsed of parsedFiles) {
+        for (const def of parsed.localDefs) {
+            if (!(0, walkers_js_1.isClassLike)(def.type))
+                continue;
+            const graphId = (0, ids_js_1.resolveDefGraphId)(parsed.filePath, def, nodeLookup);
+            if (graphId !== undefined)
+                defIdByGraphId.set(graphId, def.nodeId);
+        }
+    }
+    const directImpls = new Map();
+    for (const rel of graph.iterRelationshipsByType('IMPLEMENTS')) {
+        const source = defIdByGraphId.get(rel.sourceId);
+        const target = defIdByGraphId.get(rel.targetId);
+        if (source === undefined || target === undefined)
+            continue;
+        let list = directImpls.get(source);
+        if (list === undefined) {
+            list = [];
+            directImpls.set(source, list);
+        }
+        if (!list.includes(target))
+            list.push(target);
+    }
+    for (const [classDefId, extendsMro] of mro) {
+        const ancestorChain = [classDefId, ...extendsMro];
+        const seeds = [];
+        for (const ancestorId of ancestorChain) {
+            for (const ifaceId of directImpls.get(ancestorId) ?? []) {
+                seeds.push(ifaceId);
+            }
+        }
+        if (seeds.length === 0)
+            continue;
+        const interfaces = closeInterfaces(seeds, directImpls);
+        mro.set(classDefId, [...extendsMro, ...interfaces.filter((i) => !extendsMro.includes(i))]);
+    }
+    for (const [classDefId, ifaces] of directImpls) {
+        if (mro.has(classDefId))
+            continue;
+        mro.set(classDefId, closeInterfaces([...ifaces], directImpls));
+    }
+    return mro;
+}
+function closeInterfaces(seeds, directImpls) {
+    const out = [];
+    const seen = new Set();
+    const queue = [...seeds];
+    let head = 0;
+    while (head < queue.length) {
+        const cur = queue[head++];
+        if (seen.has(cur))
+            continue;
+        seen.add(cur);
+        out.push(cur);
+        for (const next of directImpls.get(cur) ?? []) {
+            if (!seen.has(next))
+                queue.push(next);
+        }
+    }
+    return out;
+}

package/dist/core/code/engine/core/ingestion/languages/java/simple-hooks.js

@@ -0,0 +1,39 @@
+"use strict";
+/**
+ * Small hooks for the Java provider. Each is a few lines; they make
+ * the provider's choice explicit rather than relying on defaults.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.javaBindingScopeFor = javaBindingScopeFor;
+exports.javaImportOwningScope = javaImportOwningScope;
+exports.javaReceiverBinding = javaReceiverBinding;
+// ─── bindingScopeFor ──────────────────────────────────────────────────────
+/** Method return-type bindings hoist to Module scope so cross-file
+ *  `propagateImportedReturnTypes` and chain-follow can find them. */
+function javaBindingScopeFor(decl, innermost, tree) {
+    if (decl['@type-binding.return'] !== undefined) {
+        let cur = innermost;
+        while (cur !== undefined && cur.kind !== 'Module') {
+            const parentId = cur.parent ?? null;
+            if (parentId === null)
+                break;
+            cur = tree.getScope(parentId);
+        }
+        if (cur !== undefined && cur.kind === 'Module')
+            return cur.id;
+    }
+    return null;
+}
+// ─── importOwningScope ────────────────────────────────────────────────────
+/** Java imports are always at compilation-unit (Module) level (JLS §7.5).
+ *  Return `null` unconditionally so the default Module scope is used. */
+function javaImportOwningScope(_imp, _innermost, _tree) {
+    return null;
+}
+// ─── receiverBinding ──────────────────────────────────────────────────────
+/** Look up `this` or `super` in the function scope's type bindings. */
+function javaReceiverBinding(functionScope) {
+    if (functionScope.kind !== 'Function')
+        return null;
+    return functionScope.typeBindings.get('this') ?? functionScope.typeBindings.get('super') ?? null;
+}