gitnexus 1.6.10-rc.49 → 1.6.10-rc.50

package/dist/core/ingestion/class-extractors/configs/jvm.js

@@ -17,6 +17,9 @@ export const javaClassConfig = {
         // any other shape, so plain `new Foo()` constructor calls never
         // produce a Class node (#2550).
         'object_creation_expression',
+        // Enum constant bodies (`enum E { A { ... } }`) — javac's other
+        // anonymous shape, named E$N by the same authority (#2555).
+        'enum_constant',
     ],
     fileScopeNodeTypes: ['package_declaration'],
     ancestorScopeNodeTypes: [
@@ -26,20 +29,22 @@ export const javaClassConfig = {
         'record_declaration',
     ],
     extractName(node) {
-        if (node.type === 'object_creation_expression') {
+        if (node.type === 'object_creation_expression' || node.type === 'enum_constant') {
             return synthesizeJavaAnonymousClassName(node);
         }
         return undefined;
     },
-    // An anonymous body whose name CANNOT be synthesized (no supported host
-    // type declaration) must not become a Class node at all. Without this
-    // skip, `extract()`'s `extractTypeNameFromNode` fallback names the node
-    // after the CONSTRUCTED type — emitting a phantom `Class:...:Runnable`
-    // for `new Runnable() { ... }` (empirically caught in review).
+    // An anonymous body whose name CANNOT be synthesized must not become a
+    // Class node at all. Without this skip, `extract()`'s
+    // `extractTypeNameFromNode` fallback fabricates a name — the CONSTRUCTED
+    // type for `new Runnable() { ... }` (phantom `Class:...:Runnable`,
+    // empirically caught in review) or the constant's own identifier for an
+    // `enum_constant` (`Class:...:A`).
     shouldSkipClassCapture({ definitionNode }) {
         return (definitionNode !== null &&
             definitionNode !== undefined &&
-            definitionNode.type === 'object_creation_expression' &&
+            (definitionNode.type === 'object_creation_expression' ||
+                definitionNode.type === 'enum_constant') &&
             synthesizeJavaAnonymousClassName(definitionNode) === undefined);
     },
 };

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

@@ -255,8 +255,47 @@ function synthesizeJavaAnonymousClassDeclarations(rootNode) {
             }
         }
     }
+    // Enum constant bodies (`enum E { A { ... } }`) — javac's other
+    // anonymous shape (#2555). Same synthesis, same body anchor; the
+    // constant's class extends its HOST ENUM (javac semantics), so the
+    // inherits reference names the enum — giving `mroFor(E$N) ∋ E` and
+    // keeping bare calls from the body to the enum's own helpers alive
+    // through the ownership gate's MRO arm. No receiver typeBinding piece:
+    // constants are not variable initializers; `E.A.hook()` dispatch rides
+    // the existing enum receiver machinery.
+    for (const constant of rootNode.descendantsOfType('enum_constant')) {
+        const name = synthesizeJavaAnonymousClassName(constant);
+        if (name === undefined)
+            continue;
+        const body = constant.childForFieldName?.('body');
+        if (body === null || body === undefined || body.type !== 'class_body')
+            continue;
+        out.push({
+            '@declaration.class': nodeToCapture('@declaration.class', body),
+            '@declaration.name': syntheticCapture('@declaration.name', body, name),
+        });
+        const hostEnum = javaEnclosingEnumNameOf(constant);
+        if (hostEnum !== undefined) {
+            out.push({
+                '@reference.inherits': nodeToCapture('@reference.inherits', body),
+                '@reference.name': syntheticCapture('@reference.name', body, hostEnum),
+            });
+        }
+    }
     return out;
 }
+/** Simple name of the enum_declaration enclosing an enum_constant, or
+ *  undefined (grammar guarantees one exists in well-formed source). */
+function javaEnclosingEnumNameOf(constant) {
+    let cursor = constant.parent;
+    while (cursor !== null) {
+        if (cursor.type === 'enum_declaration') {
+            return cursor.childForFieldName?.('name')?.text ?? undefined;
+        }
+        cursor = cursor.parent;
+    }
+    return undefined;
+}
 /**
  * Synthesize `@reference.call.constructor` captures for explicit constructor
  * invocations — `super(...)` and `this(...)` (F38 #1928). tree-sitter-java

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

@@ -45,6 +45,12 @@ const JAVA_SCOPE_QUERY = `
 (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
 

package/dist/core/ingestion/scope-resolution/scope/walkers.js

@@ -763,6 +763,16 @@ export function populateClassOwnedMembers(parsed) {
             return;
         if (q.includes('.'))
             return; // already qualified (dotted)
+        // A synthesized anonymous-class def (Java `$`-chain binary name,
+        // #2550/#2555 — `M3$2`, `EnumWrap$Mode$1`) already carries its
+        // COMPLETE name. Prefixing it (`M3.M3$2`) desyncs from the
+        // structure-phase node id (`M3$2.hook`), so same-named methods
+        // across sibling enum-constant bodies collapse onto the first
+        // body's node via the simple-name fallback (empirically caught in
+        // review). Class-like only: `$`-named MEMBERS (legal in JS/TS)
+        // still qualify normally against their class.
+        if (isClassLike(def.type) && q.includes('$'))
+            return;
         const classQ = classDef.qualifiedName;
         if (classQ === undefined || classQ.length === 0)
             return;

package/dist/core/ingestion/tree-sitter-queries.d.ts

@@ -1,7 +1,7 @@
 export declare const TYPESCRIPT_QUERIES: string;
 export declare const JAVASCRIPT_QUERIES: string;
 export declare const PYTHON_QUERIES = "\n(class_definition\n  name: (identifier) @name) @definition.class\n\n(function_definition\n  name: (identifier) @name) @definition.function\n\n(import_statement\n  name: (dotted_name) @import.source) @import\n\n; import numpy as np  \u2192  aliased_import captures the module name so the\n; import path is resolved and named-binding extraction stores \"np\" \u2192 \"numpy\".\n(import_statement\n  name: (aliased_import\n    name: (dotted_name) @import.source)) @import\n\n(import_from_statement\n  module_name: (dotted_name) @import.source) @import\n\n(import_from_statement\n  module_name: (relative_import) @import.source) @import\n\n(call\n  function: (identifier) @call.name) @call\n\n(call\n  function: (attribute\n    attribute: (identifier) @call.name)) @call\n\n; Class attribute type annotations \u2014 PEP 526: address: Address or address: Address = Address()\n; Both bare annotations (address: Address) and annotated assignments (name: str = \"test\")\n; are parsed as (assignment left: ... type: ...) in tree-sitter-python.\n(expression_statement\n  (assignment\n    left: (identifier) @name\n    type: (type)) @definition.property)\n\n; Plain variable assignments without type annotation: x = 5, MAX_SIZE = 100\n; Overlap with @definition.property (typed) is handled by parse-worker dedup.\n(expression_statement\n  (assignment\n    left: (identifier) @name)) @definition.variable\n\n; Write access: obj.field = value\n(assignment\n  left: (attribute\n    object: (_) @assignment.receiver\n    attribute: (identifier) @assignment.property)\n  right: (_)) @assignment\n\n; Write access: obj.field += value (compound assignment)\n(augmented_assignment\n  left: (attribute\n    object: (_) @assignment.receiver\n    attribute: (identifier) @assignment.property)\n  right: (_)) @assignment\n\n; Python HTTP clients: requests.get('/path'), httpx.post('/path'), session.get('/path')\n(call\n  function: (attribute\n    attribute: (identifier) @http_client.method)\n  arguments: (argument_list\n    (string (string_content) @http_client.url))) @http_client\n\n; Python decorators: @app.route, @router.get, etc.\n; The first positional argument is captured three ways (#2391): a string literal\n; path via @decorator.arg (quote-free, the fast path); a bare constant name or a\n; plus-concatenation via @decorator.arg_expr (resolved cross-file by the constant\n; resolver). The anchored optional alternation pins to the FIRST arg and stays\n; optional, so no-arg decorators (@app.tool(), etc.) and non-path first args still\n; match.\n(decorator\n  (call\n    function: (attribute\n      object: (identifier) @decorator.receiver\n      attribute: (identifier) @decorator.name)\n    arguments: (argument_list\n      .\n      [\n        (string (string_content)? @decorator.arg) @decorator.arg_str\n        (identifier) @decorator.arg_expr\n        (binary_operator) @decorator.arg_expr\n      ]?))) @decorator\n";
-export declare const JAVA_QUERIES = "\n; Classes, Interfaces, Enums, Annotations\n(class_declaration name: (identifier) @name) @definition.class\n(interface_declaration name: (identifier) @name) @definition.interface\n(enum_declaration name: (identifier) @name) @definition.enum\n(annotation_type_declaration name: (identifier) @name) @definition.annotation\n\n; Anonymous class bodies: new Runnable() { ... } \u2014 no @name capture; the\n; class extractor synthesizes the javac-style Worker$N name (#2550)\n(object_creation_expression (class_body)) @definition.class\n\n; Methods & Constructors\n(method_declaration name: (identifier) @name) @definition.method\n(constructor_declaration name: (identifier) @name) @definition.constructor\n\n; Fields \u2014 typed field declarations inside class bodies\n(field_declaration\n  declarator: (variable_declarator\n    name: (identifier) @name)) @definition.property\n\n; Imports - capture any import declaration child as source\n(import_declaration (_) @import.source) @import\n\n; Calls\n(method_invocation name: (identifier) @call.name) @call\n(method_invocation object: (_) name: (identifier) @call.name) @call\n(method_reference) @call\n\n; Constructor calls: new Foo()\n(object_creation_expression type: (type_identifier) @call.name) @call\n\n; Local variable declarations inside method bodies\n(local_variable_declaration\n  declarator: (variable_declarator\n    name: (identifier) @name)) @definition.variable\n\n; Write access: obj.field = value\n(assignment_expression\n  left: (field_access\n    object: (_) @assignment.receiver\n    field: (identifier) @assignment.property)\n  right: (_)) @assignment\n";
+export declare const JAVA_QUERIES = "\n; Classes, Interfaces, Enums, Annotations\n(class_declaration name: (identifier) @name) @definition.class\n(interface_declaration name: (identifier) @name) @definition.interface\n(enum_declaration name: (identifier) @name) @definition.enum\n(annotation_type_declaration name: (identifier) @name) @definition.annotation\n\n; Anonymous class bodies: new Runnable() { ... } \u2014 no @name capture; the\n; class extractor synthesizes the javac-style Worker$N name (#2550)\n(object_creation_expression (class_body)) @definition.class\n\n; Enum constant bodies: enum E { A { ... } } \u2014 javac's other anonymous\n; shape, synthesized as E$N by the same naming authority (#2555)\n(enum_constant body: (class_body)) @definition.class\n\n; Methods & Constructors\n(method_declaration name: (identifier) @name) @definition.method\n(constructor_declaration name: (identifier) @name) @definition.constructor\n\n; Fields \u2014 typed field declarations inside class bodies\n(field_declaration\n  declarator: (variable_declarator\n    name: (identifier) @name)) @definition.property\n\n; Imports - capture any import declaration child as source\n(import_declaration (_) @import.source) @import\n\n; Calls\n(method_invocation name: (identifier) @call.name) @call\n(method_invocation object: (_) name: (identifier) @call.name) @call\n(method_reference) @call\n\n; Constructor calls: new Foo()\n(object_creation_expression type: (type_identifier) @call.name) @call\n\n; Local variable declarations inside method bodies\n(local_variable_declaration\n  declarator: (variable_declarator\n    name: (identifier) @name)) @definition.variable\n\n; Write access: obj.field = value\n(assignment_expression\n  left: (field_access\n    object: (_) @assignment.receiver\n    field: (identifier) @assignment.property)\n  right: (_)) @assignment\n";
 export declare const C_QUERIES = "\n; Functions (direct declarator)\n(function_definition declarator: (function_declarator declarator: (identifier) @name)) @definition.function\n(declaration declarator: (function_declarator declarator: (identifier) @name)) @definition.function\n\n; Functions returning pointers (pointer_declarator wraps function_declarator)\n(function_definition declarator: (pointer_declarator declarator: (function_declarator declarator: (identifier) @name))) @definition.function\n(declaration declarator: (pointer_declarator declarator: (function_declarator declarator: (identifier) @name))) @definition.function\n\n; Functions returning double pointers (nested pointer_declarator)\n(function_definition declarator: (pointer_declarator declarator: (pointer_declarator declarator: (function_declarator declarator: (identifier) @name)))) @definition.function\n\n; Structs, Unions, Enums, Typedefs\n(struct_specifier name: (type_identifier) @name) @definition.struct\n(type_definition\n  type: (struct_specifier\n    body: (field_declaration_list))\n  declarator: (type_identifier) @name) @definition.struct\n(union_specifier name: (type_identifier) @name) @definition.union\n(enum_specifier name: (type_identifier) @name) @definition.enum\n(type_definition\n  type: (enum_specifier\n    body: (enumerator_list))\n  declarator: (type_identifier) @name) @definition.enum\n(enumerator name: (identifier) @name) @definition.const\n(type_definition declarator: (type_identifier) @name) @definition.typedef\n\n; Macros\n(preproc_function_def name: (identifier) @name) @definition.macro\n(preproc_def name: (identifier) @name) @definition.macro\n\n; Includes\n(preproc_include path: (_) @import.source) @import\n\n; Calls\n(call_expression function: (identifier) @call.name) @call\n(call_expression function: (field_expression field: (field_identifier) @call.name)) @call\n\n; Variable declarations: int x = 5; or int x;\n(declaration\n  declarator: (init_declarator\n    declarator: (identifier) @name)) @definition.variable\n";
 export declare const GO_QUERIES = "\n; Functions & Methods\n(function_declaration name: (identifier) @name) @definition.function\n(method_declaration name: (field_identifier) @name) @definition.method\n(method_elem name: (field_identifier) @name) @definition.method\n\n; Types\n(type_declaration (type_spec name: (type_identifier) @name type: (struct_type))) @definition.struct\n(type_declaration (type_spec name: (type_identifier) @name type: (interface_type))) @definition.interface\n\n; Imports\n(import_declaration (import_spec path: (interpreted_string_literal) @import.source)) @import\n(import_declaration (import_spec_list (import_spec path: (interpreted_string_literal) @import.source))) @import\n\n; Struct fields \u2014 named field declarations inside struct types\n(field_declaration_list\n  (field_declaration\n    name: (field_identifier) @name) @definition.property)\n\n; Calls\n(call_expression function: (identifier) @call.name) @call\n(call_expression function: (selector_expression field: (field_identifier) @call.name)) @call\n\n; Const/var declarations\n(const_declaration (const_spec (identifier) @name)) @definition.const\n(var_declaration (var_spec (identifier) @name)) @definition.variable\n(var_declaration (var_spec_list (var_spec (identifier) @name))) @definition.variable\n\n; Short variable declaration: x := 5\n(short_var_declaration left: (expression_list (identifier) @name)) @definition.variable\n\n; Struct literal construction: User{Name: \"Alice\"}\n(composite_literal type: (type_identifier) @call.name) @call\n\n; Write access: obj.field = value\n(assignment_statement\n  left: (expression_list\n    (selector_expression\n      operand: (_) @assignment.receiver\n      field: (field_identifier) @assignment.property))\n  right: (_)) @assignment\n\n; Write access: obj.field++ / obj.field--\n(inc_statement\n  (selector_expression\n    operand: (_) @assignment.receiver\n    field: (field_identifier) @assignment.property)) @assignment\n(dec_statement\n  (selector_expression\n    operand: (_) @assignment.receiver\n    field: (field_identifier) @assignment.property)) @assignment\n";
 export declare const CPP_QUERIES = "\n; Classes, Structs, Namespaces\n(class_specifier name: (type_identifier) @name) @definition.class\n(class_specifier\n  name: (template_type\n    (type_identifier) @name\n    (template_argument_list) @template-arguments)) @definition.class\n; Out-of-line nested definition: class Outer::Inner { ... } / struct Outer::Inner { ... }.\n; Key the node by the full qualified_identifier text so the def materializes a\n; node that matches the HAS_METHOD owner id (also the full qualified text) and\n; stays distinct from a same-tail type in another scope (#1975, #1978).\n(class_specifier name: (qualified_identifier) @name) @definition.class\n(struct_specifier name: (qualified_identifier) @name) @definition.struct\n(struct_specifier name: (type_identifier) @name) @definition.struct\n(struct_specifier\n  name: (template_type\n    (type_identifier) @name\n    (template_argument_list) @template-arguments)) @definition.struct\n(namespace_definition name: (namespace_identifier) @name) @definition.namespace\n(enum_specifier name: (type_identifier) @name) @definition.enum\n\n; Typedefs and unions (common in C-style headers and mixed C/C++ code)\n(type_definition\n  type: (struct_specifier\n    body: (field_declaration_list))\n  declarator: (type_identifier) @name) @definition.struct\n(type_definition\n  type: (enum_specifier\n    body: (enumerator_list))\n  declarator: (type_identifier) @name) @definition.enum\n(enumerator name: (identifier) @name) @definition.const\n(type_definition declarator: (type_identifier) @name) @definition.typedef\n(union_specifier name: (type_identifier) @name) @definition.union\n\n; Macros\n(preproc_function_def name: (identifier) @name) @definition.macro\n(preproc_def name: (identifier) @name) @definition.macro\n\n; Functions & Methods (direct declarator)\n(function_definition declarator: (function_declarator declarator: (identifier) @name)) @definition.function\n(function_definition declarator: (function_declarator declarator: (operator_name) @name)) @definition.function\n(function_definition declarator: (function_declarator declarator: (qualified_identifier name: (identifier) @name))) @definition.method\n(function_definition declarator: (function_declarator declarator: (qualified_identifier name: (operator_name) @name))) @definition.method\n\n; Functions/methods returning pointers (pointer_declarator wraps function_declarator)\n(function_definition declarator: (pointer_declarator declarator: (function_declarator declarator: (identifier) @name))) @definition.function\n(function_definition declarator: (pointer_declarator declarator: (function_declarator declarator: (qualified_identifier name: (identifier) @name)))) @definition.method\n\n; Functions/methods returning double pointers (nested pointer_declarator)\n(function_definition declarator: (pointer_declarator declarator: (pointer_declarator declarator: (function_declarator declarator: (identifier) @name)))) @definition.function\n(function_definition declarator: (pointer_declarator declarator: (pointer_declarator declarator: (function_declarator declarator: (qualified_identifier name: (identifier) @name))))) @definition.method\n\n; Functions/methods returning references (reference_declarator wraps function_declarator)\n(function_definition declarator: (reference_declarator (function_declarator declarator: (identifier) @name))) @definition.function\n(function_definition declarator: (reference_declarator (function_declarator declarator: (operator_name) @name))) @definition.function\n(function_definition declarator: (reference_declarator (function_declarator declarator: (qualified_identifier name: (identifier) @name)))) @definition.method\n(function_definition declarator: (reference_declarator (function_declarator declarator: (qualified_identifier name: (operator_name) @name)))) @definition.method\n\n; Destructors (destructor_name is distinct from identifier in tree-sitter-cpp)\n(function_definition declarator: (function_declarator declarator: (qualified_identifier name: (destructor_name) @name))) @definition.method\n\n; Function declarations / prototypes (common in headers)\n(declaration declarator: (function_declarator declarator: (identifier) @name)) @definition.function\n(declaration declarator: (function_declarator declarator: (operator_name) @name)) @definition.function\n(declaration declarator: (pointer_declarator declarator: (function_declarator declarator: (identifier) @name))) @definition.function\n(declaration declarator: (reference_declarator (function_declarator declarator: (operator_name) @name))) @definition.function\n\n; Class/struct data member fields (Address address; int count;)\n; Uses field_identifier to exclude method declarations (which use function_declarator)\n(field_declaration\n  declarator: (field_identifier) @name) @definition.property\n\n; Pointer member fields (Address* address;)\n(field_declaration\n  declarator: (pointer_declarator\n    declarator: (field_identifier) @name)) @definition.property\n\n; Reference member fields (Address& address;)\n(field_declaration\n  declarator: (reference_declarator\n    (field_identifier) @name)) @definition.property\n\n; Inline class method declarations (inside class body, no body: void save();)\n; tree-sitter-cpp uses field_identifier (not identifier) for names inside class bodies\n(field_declaration declarator: (function_declarator declarator: [(field_identifier) (identifier) (operator_name)] @name)) @definition.method\n\n; Inline class method declarations returning a pointer (User* lookup();)\n(field_declaration declarator: (pointer_declarator declarator: (function_declarator declarator: [(field_identifier) (identifier)] @name))) @definition.method\n\n; Inline class method declarations returning a reference (User& lookup();)\n(field_declaration declarator: (reference_declarator (function_declarator declarator: [(field_identifier) (identifier) (operator_name)] @name))) @definition.method\n\n; Inline class method definitions (inside class body, with body: void Foo() { ... })\n(field_declaration_list\n  (function_definition\n    declarator: (function_declarator\n      declarator: [(field_identifier) (identifier) (operator_name) (destructor_name)] @name)) @definition.method)\n\n; Inline class methods returning a pointer type (User* lookup(int id) { ... })\n(field_declaration_list\n  (function_definition\n    declarator: (pointer_declarator\n      declarator: (function_declarator\n        declarator: [(field_identifier) (identifier) (operator_name)] @name))) @definition.method)\n\n; Inline class methods returning a reference type (User& lookup(int id) { ... })\n(field_declaration_list\n  (function_definition\n    declarator: (reference_declarator\n      (function_declarator\n        declarator: [(field_identifier) (identifier) (operator_name)] @name))) @definition.method)\n\n; Templates\n(template_declaration (class_specifier name: (type_identifier) @name)) @definition.template\n(template_declaration\n  (class_specifier\n    name: (template_type\n      (type_identifier) @name\n      (template_argument_list) @template-arguments))) @definition.template\n(template_declaration (function_definition declarator: (function_declarator declarator: (identifier) @name))) @definition.template\n\n; Includes\n(preproc_include path: (_) @import.source) @import\n\n; Calls\n(call_expression function: (identifier) @call.name) @call\n(call_expression function: (field_expression field: (field_identifier) @call.name)) @call\n(call_expression function: (qualified_identifier name: (identifier) @call.name)) @call\n(call_expression function: (template_function name: (identifier) @call.name)) @call\n(binary_expression operator: \"+\" @call.name) @call\n(binary_expression operator: \"<<\" @call.name) @call\n\n; Constructor calls: new User()\n(new_expression type: (type_identifier) @call.name) @call\n\n; Variable declarations: int x = 5; or auto x = 5;\n(declaration\n  declarator: (init_declarator\n    declarator: (identifier) @name)) @definition.variable\n\n; Structured bindings: auto [a, b] = makePair();  (one @name per bound identifier)\n(declaration\n  declarator: (init_declarator\n    declarator: (structured_binding_declarator\n      (identifier) @name))) @definition.variable\n\n; Structured bindings, reference form: auto& [x, y] = tup;\n(declaration\n  declarator: (init_declarator\n    declarator: (reference_declarator\n      (structured_binding_declarator\n        (identifier) @name)))) @definition.variable\n\n; Write access: obj.field = value\n(assignment_expression\n  left: (field_expression\n    argument: (_) @assignment.receiver\n    field: (field_identifier) @assignment.property)\n  right: (_)) @assignment\n\n";

package/dist/core/ingestion/tree-sitter-queries.js

@@ -748,6 +748,10 @@ export const JAVA_QUERIES = `
 ; class extractor synthesizes the javac-style Worker$N name (#2550)
 (object_creation_expression (class_body)) @definition.class
 
+; Enum constant bodies: enum E { A { ... } } — javac's other anonymous
+; shape, synthesized as E$N by the same naming authority (#2555)
+(enum_constant body: (class_body)) @definition.class
+
 ; Methods & Constructors
 (method_declaration name: (identifier) @name) @definition.method
 (constructor_declaration name: (identifier) @name) @definition.constructor

package/dist/core/ingestion/utils/ast-helpers.js

@@ -375,15 +375,39 @@ const MAX_ENCLOSING_WALK_ITERATIONS = 4096;
  * this one helper.
  */
 /** Type-declaration node types that can host (and name) a Java anonymous
- *  class body — javac numbers `$N` per top-level type of any of these
- *  kinds. Enum constant bodies (`A { ... }`) are a different node shape
- *  and remain unmodeled. */
+ *  class body. Naming follows JLS 13.1: the binary name is the
+ *  IMMEDIATELY enclosing type's binary name + `$N`, so the synthesized
+ *  name is the `$`-joined chain of enclosing host names
+ *  (`EnumWrap$Mode$1`), numbered per immediate host in source order. */
 const JAVA_ANON_HOST_TYPES = new Set([
     'class_declaration',
     'enum_declaration',
     'interface_declaration',
     'record_declaration',
 ]);
+/** The two Java anonymous-class-body shapes (#2550/#2555): an
+ *  `object_creation_expression` with a `class_body` child
+ *  (`new Runnable() { ... }`), and an `enum_constant` with a `body:`
+ *  field (`enum E { A { ... } }` — javac's other `E$N` shape). */
+const isJavaAnonymousBodyNode = (node) => (node.type === 'object_creation_expression' &&
+    node.namedChildren?.some((c) => c.type === 'class_body') === true) ||
+    (node.type === 'enum_constant' && node.childForFieldName?.('body')?.type === 'class_body');
+/** Nearest ancestor of `node` that is an enclosing TYPE per JLS 13.1 —
+ *  a named host declaration OR another anonymous body (both shapes).
+ *  Anonymous ancestors chain through: an anon inside an anon is
+ *  `Host$1$1`, and an anon inside an enum constant body is `E$1$1`. */
+const nearestJavaEnclosingType = (node) => {
+    let cursor = node.parent;
+    let iterations = 0;
+    while (cursor) {
+        if (++iterations > MAX_ENCLOSING_WALK_ITERATIONS)
+            return null;
+        if (JAVA_ANON_HOST_TYPES.has(cursor.type) || isJavaAnonymousBodyNode(cursor))
+            return cursor;
+        cursor = cursor.parent;
+    }
+    return null;
+};
 /** Per-parse-tree memo of anonymous-body numbering: tree → (startIndex →
  *  synthesized name). Keyed by the tree OBJECT via WeakMap so entries die
  *  with the parse; without it every call re-scans the host subtree
@@ -392,10 +416,7 @@ const JAVA_ANON_HOST_TYPES = new Set([
  *  listener-per-widget Java). */
 const javaAnonNameMemo = new WeakMap();
 export const synthesizeJavaAnonymousClassName = (node) => {
-    if (node.type !== 'object_creation_expression')
-        return undefined;
-    const hasClassBody = node.namedChildren?.some((c) => c.type === 'class_body');
-    if (hasClassBody !== true)
+    if (!isJavaAnonymousBodyNode(node))
         return undefined;
     const tree = node.tree;
     if (tree !== undefined) {
@@ -403,38 +424,68 @@ export const synthesizeJavaAnonymousClassName = (node) => {
         if (cached !== undefined)
             return cached;
     }
-    // Topmost enclosing host type declaration — javac numbers per top-level type.
-    let topHost = null;
-    let cursor = node.parent;
-    let iterations = 0;
-    while (cursor) {
-        if (++iterations > MAX_ENCLOSING_WALK_ITERATIONS)
+    // JLS 13.1: the binary name is the IMMEDIATELY ENCLOSING TYPE's binary
+    // name + `$N`. The enclosing type may itself be anonymous — then its
+    // own synthesized name is the prefix (recursion, memo-bounded):
+    // `NestHost$1$1` for an anon inside an anon, `E$1$1` for an anon
+    // inside an enum constant body. For a named enclosing type the prefix
+    // is the `$`-joined chain of named hosts (`EnumWrap$Mode`).
+    const enclosing = nearestJavaEnclosingType(node);
+    if (enclosing === null)
+        return undefined;
+    let prefix;
+    if (isJavaAnonymousBodyNode(enclosing)) {
+        const enclosingName = synthesizeJavaAnonymousClassName(enclosing);
+        if (enclosingName === undefined)
             return undefined;
-        if (JAVA_ANON_HOST_TYPES.has(cursor.type))
-            topHost = cursor;
-        cursor = cursor.parent;
+        prefix = enclosingName;
     }
-    if (topHost === null)
-        return undefined;
-    const topName = topHost.childForFieldName?.('name')?.text;
-    if (topName === undefined || topName.length === 0)
-        return undefined;
-    const anonBodies = (topHost.descendantsOfType?.('object_creation_expression') ?? []).filter((c) => c.namedChildren?.some((n) => n.type === 'class_body'));
+    else {
+        const hostNames = [];
+        let cursor = enclosing;
+        let iterations = 0;
+        while (cursor) {
+            if (++iterations > MAX_ENCLOSING_WALK_ITERATIONS)
+                return undefined;
+            if (JAVA_ANON_HOST_TYPES.has(cursor.type)) {
+                const hostName = cursor.childForFieldName?.('name')?.text;
+                if (hostName === undefined || hostName.length === 0)
+                    return undefined;
+                hostNames.unshift(hostName);
+            }
+            cursor = cursor.parent;
+        }
+        prefix = hostNames.join('$');
+    }
+    // All anonymous bodies (both shapes) whose immediately enclosing TYPE
+    // is THIS one, in source order. `descendantsOfType` over the subtree
+    // also finds bodies belonging to nested enclosing types — filter them
+    // out by re-deriving each candidate's own enclosing type.
+    const candidates = [
+        ...(enclosing.descendantsOfType?.('object_creation_expression') ?? []),
+        ...(enclosing.descendantsOfType?.('enum_constant') ?? []),
+    ]
+        .filter(isJavaAnonymousBodyNode)
+        .filter((c) => {
+        const host = nearestJavaEnclosingType(c);
+        return (host !== null && host.startIndex === enclosing.startIndex && host.type === enclosing.type);
+    })
+        .sort((a, b) => a.startIndex - b.startIndex);
     if (tree !== undefined) {
         let byStart = javaAnonNameMemo.get(tree);
         if (byStart === undefined) {
             byStart = new Map();
             javaAnonNameMemo.set(tree, byStart);
         }
-        for (let i = 0; i < anonBodies.length; i++) {
-            byStart.set(anonBodies[i].startIndex, `${topName}$${i + 1}`);
+        for (let i = 0; i < candidates.length; i++) {
+            byStart.set(candidates[i].startIndex, `${prefix}$${i + 1}`);
         }
         return byStart.get(node.startIndex);
     }
-    const index = anonBodies.findIndex((c) => c.startIndex === node.startIndex);
+    const index = candidates.findIndex((c) => c.startIndex === node.startIndex);
     if (index === -1)
         return undefined;
-    return `${topName}$${index + 1}`;
+    return `${prefix}$${index + 1}`;
 };
 export const findEnclosingClassInfo = (node, filePath, resolveEnclosingOwner, 
 /**
@@ -494,13 +545,15 @@ getQualifiedOwnerName) => {
                 }
             }
         }
-        // Java: an anonymous class body (`new Runnable() { ... }`) owns its
-        // members — attribute to the synthesized `Worker$N` class, not the
-        // lexically enclosing named class (#2550). `synthesizeJavaAnonymousClassName`
-        // returns undefined for `object_creation_expression` without a
-        // `class_body` (plain `new Foo()`, and every C# shape), so the walk
-        // continues unchanged for those.
-        if (current.type === 'object_creation_expression') {
+        // Java: an anonymous class body owns its members — attribute to the
+        // synthesized `Worker$N`/`E$N` class, not the lexically enclosing
+        // named type (#2550/#2555). Covers both shapes: `new Runnable() { ... }`
+        // and enum constant bodies (`enum E { A { ... } }`). The synthesis
+        // returns undefined for shape-less nodes (plain `new Foo()`, a body-less
+        // enum constant, and every C# `object_creation_expression`), so the
+        // walk continues unchanged for those — including on to
+        // `enum_declaration`, which sits in CLASS_CONTAINER_TYPES below.
+        if (current.type === 'object_creation_expression' || current.type === 'enum_constant') {
             const anonName = synthesizeJavaAnonymousClassName(current);
             if (anonName !== undefined) {
                 return {

package/dist/storage/parse-cache.js

@@ -52,7 +52,7 @@ import { fileURLToPath } from 'url';
 // the main thread (the #1983 OOM). Because the two stores share this version,
 // any future change to the `ParsedFile` serialization shape MUST bump
 // SCHEMA_BUMP so both invalidate in lockstep.
-const SCHEMA_BUMP = 18; // Java anonymous class bodies emit synthesized Worker$N Class nodes and re-keyed methods (#2550). (17 = callable-value-flow operand identity; 16 = direct callee identity; 15 = always-on callableFlowSites.)
+const SCHEMA_BUMP = 19; // Java enum constant bodies emit E$N Class nodes; anonymous naming switched to JLS 13.1 immediate-host chains (#2555). (18 = Worker$N anonymous bodies; 17 = callable-value-flow operand identity; 16 = direct callee identity.)
 const GITNEXUS_PKG_VERSION = (() => {
     try {
         // package.json sits at gitnexus/package.json — two levels up from

package/dist/storage/repo-manager.d.ts

@@ -341,8 +341,14 @@ export interface RepoMeta {
  * unchanged files — a top-up against a pre-v8 index would strand the old
  * `Worker.run`-keyed Method nodes alongside the new ones (the v5 Route
  * precedent); force a full re-analyze instead.
- */
-export declare const INCREMENTAL_SCHEMA_VERSION = 8;
+ * v9: Java enum constant bodies joined the instance model and anonymous
+ * naming switched to JLS 13.1 immediately-enclosing-type chains (#2555): `enum E { A {
+ * hook(){} } }` now emits `Class:...:E$1` with methods re-keyed from
+ * `E.hook` to `E$1.hook`, and nested-host anonymous names re-key
+ * (`EnumWrap$1` → `EnumWrap$Mode$1`). Same contract as v8: identities move
+ * on unchanged files; force a full re-analyze.
+ */
+export declare const INCREMENTAL_SCHEMA_VERSION = 9;
 export interface IndexedRepo {
     repoPath: string;
     storagePath: string;

package/dist/storage/repo-manager.js

@@ -118,8 +118,14 @@ export const cloneDirBelongsToEntry = (cloneDir, entryPath) => registryPathEqual
  * unchanged files — a top-up against a pre-v8 index would strand the old
  * `Worker.run`-keyed Method nodes alongside the new ones (the v5 Route
  * precedent); force a full re-analyze instead.
+ * v9: Java enum constant bodies joined the instance model and anonymous
+ * naming switched to JLS 13.1 immediately-enclosing-type chains (#2555): `enum E { A {
+ * hook(){} } }` now emits `Class:...:E$1` with methods re-keyed from
+ * `E.hook` to `E$1.hook`, and nested-host anonymous names re-key
+ * (`EnumWrap$1` → `EnumWrap$Mode$1`). Same contract as v8: identities move
+ * on unchanged files; force a full re-analyze.
  */
-export const INCREMENTAL_SCHEMA_VERSION = 8;
+export const INCREMENTAL_SCHEMA_VERSION = 9;
 const GITNEXUS_DIR = '.gitnexus';
 const GITNEXUS_EXCLUDE_ENTRY = `${GITNEXUS_DIR}/`;
 export const INDEX_METADATA_FILE = 'gitnexus.json';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.10-rc.49",
+  "version": "1.6.10-rc.50",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",