gitnexus 1.6.9 → 1.6.10-aptos.0

package/dist/core/ingestion/type-extractors/jvm.js

@@ -1,10 +1,20 @@
-import { findChild } from '../utils/ast-helpers.js';
+import { findChild, synthesizeJavaAnonymousClassName, } from '../utils/ast-helpers.js';
 import { extractSimpleTypeName, extractVarName, extractGenericTypeArgs, resolveIterableElementType, methodToTypeArgPosition, extractElementTypeFromString, } from './shared.js';
 // ── Java ──────────────────────────────────────────────────────────────────
 const JAVA_DECLARATION_NODE_TYPES = new Set([
     'local_variable_declaration',
     'field_declaration',
 ]);
+/** `Runnable handler = new Runnable() { ... }` — the variable's effective
+ *  type is the ANONYMOUS class (`Worker$1`), not the declared interface;
+ *  that is the instance `handler.run()` dispatches into (#2550). Returns
+ *  undefined for declarators without an anonymous-body initializer. */
+const anonymousInitializerTypeName = (declarator) => {
+    const valueNode = declarator.childForFieldName('value');
+    if (!valueNode || valueNode.type !== 'object_creation_expression')
+        return undefined;
+    return synthesizeJavaAnonymousClassName(valueNode);
+};
 /** Java: Type x = ...; Type x; */
 const extractJavaDeclaration = (node, env) => {
     const typeNode = node.childForFieldName('type');
@@ -22,7 +32,7 @@ const extractJavaDeclaration = (node, env) => {
         if (nameNode) {
             const varName = extractVarName(nameNode);
             if (varName)
-                env.set(varName, typeName);
+                env.set(varName, anonymousInitializerTypeName(child) ?? typeName);
         }
     }
 };
@@ -42,6 +52,11 @@ const extractJavaInitializer = (node, env, _classNames) => {
             continue;
         if (valueNode.type !== 'object_creation_expression')
             continue;
+        const anonName = anonymousInitializerTypeName(child);
+        if (anonName) {
+            env.set(varName, anonName);
+            continue;
+        }
         const ctorType = valueNode.childForFieldName('type');
         if (!ctorType)
             continue;

package/dist/core/ingestion/utils/ast-helpers.d.ts

@@ -102,6 +102,7 @@ export interface EnclosingClassInfo {
      */
     qualifiedClassId?: string;
 }
+export declare const synthesizeJavaAnonymousClassName: (node: SyntaxNode) => string | undefined;
 export declare const findEnclosingClassInfo: (node: SyntaxNode, filePath: string, resolveEnclosingOwner?: (node: SyntaxNode) => SyntaxNode | null, 
 /**
  * Optional (#1978): returns the enclosing type's fully-qualified name

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

@@ -209,7 +209,7 @@ export const CONTAINER_TYPE_TO_LABEL = {
     record_declaration: 'Record',
     protocol_declaration: 'Interface',
     mixin_declaration: 'Mixin',
-    extension_declaration: 'Extension',
+    extension_declaration: 'Class',
     class: 'Class',
     // Ruby `module` declarations map to `Trait` so they participate in the
     // class-like type registry used by `lookupClassByName` / inheritance
@@ -270,7 +270,14 @@ export function getLabelFromCaptures(captureMap, provider) {
         return null;
     const hasDefaultExportHocNameSeed = captureMap['definition.function'] !== undefined &&
         (captureMap['hoc'] !== undefined || captureMap['callee'] !== undefined);
-    if (!captureMap['name'] && !captureMap['definition.constructor'] && !hasDefaultExportHocNameSeed)
+    // Nameless `definition.class` passes through: a class extractor may
+    // synthesize the name (Java anonymous class bodies → `Worker$N`, #2550).
+    // Downstream stays safe — parse-worker skips any nameless definition the
+    // extractor could not name (its `!nameNode && !extractedClassSymbol` gate).
+    if (!captureMap['name'] &&
+        !captureMap['definition.constructor'] &&
+        !captureMap['definition.class'] &&
+        !hasDefaultExportHocNameSeed)
         return null;
     if (captureMap['definition.function']) {
         if (provider.labelOverride) {
@@ -353,6 +360,133 @@ export function getLabelFromCaptures(captureMap, provider) {
  *    `MAX_ENCLOSING_WALK_ITERATIONS` defense-in-depth guard below prevents
  *    pathological hooks from creating an infinite loop. */
 const MAX_ENCLOSING_WALK_ITERATIONS = 4096;
+/**
+ * Synthesize a javac-style name for a Java anonymous class body:
+ * `new Runnable() { ... }` inside top-level class `Worker` becomes
+ * `Worker$1` (`$N` = 1-based source order of anonymous bodies within the
+ * top-level class). Returns undefined when the node is not an
+ * `object_creation_expression` carrying a `class_body` child — which also
+ * keeps this a no-op for C#, whose `object_creation_expression` uses
+ * `initializer_expression`, never `class_body` (#2550).
+ *
+ * The SAME name must be produced by every layer that keys the anonymous
+ * class (structure-phase node id, enclosing-owner walk, scope-side
+ * declaration synthesis, receiver typeBinding) — they agree by all calling
+ * this one helper.
+ */
+/** Type-declaration node types that can host (and name) a Java anonymous
+ *  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
+ *  (`descendantsOfType`), and the helper is called from four independent
+ *  layers per anonymous body — quadratic on anon-heavy files (old-style
+ *  listener-per-widget Java). */
+const javaAnonNameMemo = new WeakMap();
+export const synthesizeJavaAnonymousClassName = (node) => {
+    if (!isJavaAnonymousBodyNode(node))
+        return undefined;
+    const tree = node.tree;
+    if (tree !== undefined) {
+        const cached = javaAnonNameMemo.get(tree)?.get(node.startIndex);
+        if (cached !== undefined)
+            return cached;
+    }
+    // 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;
+        prefix = enclosingName;
+    }
+    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 < candidates.length; i++) {
+            byStart.set(candidates[i].startIndex, `${prefix}$${i + 1}`);
+        }
+        return byStart.get(node.startIndex);
+    }
+    const index = candidates.findIndex((c) => c.startIndex === node.startIndex);
+    if (index === -1)
+        return undefined;
+    return `${prefix}$${index + 1}`;
+};
 export const findEnclosingClassInfo = (node, filePath, resolveEnclosingOwner, 
 /**
  * Optional (#1978): returns the enclosing type's fully-qualified name
@@ -411,6 +545,23 @@ getQualifiedOwnerName) => {
                 }
             }
         }
+        // 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 {
+                    classId: generateId('Class', `${filePath}:${anonName}`),
+                    className: anonName,
+                };
+            }
+        }
         if (CLASS_CONTAINER_TYPES.has(current.type)) {
             // Delegate language-specific container remapping to the provider hook.
             if (resolveEnclosingOwner) {

package/dist/core/ingestion/utils/callable-flow-captures.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Configurable AST-to-`@callable-flow.*` capture synthesis.
+ *
+ * The traversal is language-neutral: providers supply their grammar's node
+ * vocabulary and the small semantic callbacks (true-reference bindings,
+ * callable signatures, protocol invocation names). The central extractor
+ * never sees a parser node and shared ingestion code never branches on a
+ * language name.
+ */
+import type { CaptureMatch, ParameterTypeClass } from '../../../_shared/index.js';
+import { type SyntaxNode } from './ast-helpers.js';
+export interface CallableCaptureSignature {
+    readonly parameterCount?: number;
+    readonly parameterTypes?: readonly string[];
+    readonly parameterTypeClasses?: readonly ParameterTypeClass[];
+    readonly isConst?: boolean;
+}
+export interface CallableFlowCaptureOptions {
+    readonly functionNodeTypes: ReadonlySet<string>;
+    readonly callNodeTypes: ReadonlySet<string>;
+    readonly parameterListNodeTypes: ReadonlySet<string>;
+    readonly parameterNodeTypes: ReadonlySet<string>;
+    readonly bindingNodeTypes: ReadonlySet<string>;
+    readonly assignmentNodeTypes: ReadonlySet<string>;
+    readonly identifierNodeTypes: ReadonlySet<string>;
+    /** Control-flow blocks do not introduce a new local-variable scope. */
+    readonly functionScopedValueBindings?: boolean;
+    /**
+     * Declaration nodes whose callable type can contextually select an overload
+     * at a later assignment (for example `void (*fp)(int); fp = target;`).
+     */
+    readonly callableSignatureDeclarationNodeTypes?: ReadonlySet<string>;
+    /** Nodes that denote a named callable reference rather than a value read. */
+    readonly callableReferenceNodeTypes?: ReadonlySet<string>;
+    /** Member methods whose receiver itself is the callable object. */
+    readonly callableProtocolMethods?: ReadonlySet<string>;
+    /** Operators used for receiver-bound member-pointer invocation. */
+    readonly memberPointerOperators?: ReadonlySet<string>;
+    /** Provider fallback for member-pointer syntax a grammar recovers as ERROR nodes. */
+    readonly memberPointerParts?: (node: SyntaxNode) => {
+        readonly receiver: SyntaxNode;
+        readonly member: SyntaxNode;
+        readonly operator: string;
+    } | undefined;
+    readonly functionName?: (node: SyntaxNode) => string | undefined;
+    /** Map grammar-specific split signature/body shapes to one lexical owner. */
+    readonly lexicalFunctionOwner?: (node: SyntaxNode) => SyntaxNode | undefined;
+    readonly parameterPassingMode?: (parameter: SyntaxNode) => 'value' | 'reference' | 'pointer' | 'callable-object';
+    readonly isTrueReferenceBinding?: (container: SyntaxNode, destination: SyntaxNode) => boolean;
+    readonly expectedSignature?: (container: SyntaxNode, destination: SyntaxNode) => CallableCaptureSignature | undefined;
+    readonly normalizeQualifiedName?: (raw: string) => string;
+    /**
+     * Provider-owned assignment decomposition. May return MULTIPLE pairs for
+     * one node — Go's multi-value `a, b := f, g` pairs positionally; the
+     * shared field fallback would cross-wire first-LHS with last-RHS (#2522
+     * review). Returning an empty array means "recognized, but emit nothing"
+     * (e.g. a multi-return call RHS with mismatched arity).
+     */
+    readonly extractAssignment?: (node: SyntaxNode) => {
+        readonly destination: SyntaxNode;
+        readonly source: SyntaxNode;
+    } | readonly {
+        readonly destination: SyntaxNode;
+        readonly source: SyntaxNode;
+    }[] | undefined;
+    readonly extractFunctionParameters?: (node: SyntaxNode) => readonly SyntaxNode[] | undefined;
+    readonly extractCallCallee?: (node: SyntaxNode) => SyntaxNode | undefined;
+    readonly isCallNode?: (node: SyntaxNode) => boolean;
+    /**
+     * Languages where a bare, receiver-less, paren-less name in value position
+     * is a CALL, not a reference (Ruby: `action = process` invokes `process`
+     * and stores its return). When true, a bare name that is not a provably
+     * local value binding and not an explicit reference form (`method(:x)`,
+     * lambda/proc) emits NO flow fact — treating it as a callable minted CALLS
+     * edges to methods that were merely invoked (#2522 review).
+     */
+    readonly bareNamesAreCalls?: boolean;
+    readonly callSiteNode?: (node: SyntaxNode) => SyntaxNode | undefined;
+    /** Emit a canonical call ReferenceSite when the provider query omits variable calls. */
+    readonly emitCanonicalInvokeReference?: boolean;
+    readonly extractCallableReference?: (node: SyntaxNode) => {
+        readonly name: string;
+        readonly anchor: SyntaxNode;
+        readonly qualifiedName?: string;
+    } | undefined;
+}
+/**
+ * Emit normalized flow captures in deterministic source order.
+ *
+ * One explicit DFS supplies all phases below. Query-backed emitters may still
+ * perform their existing query walk; this helper never reparses and remains
+ * linear in AST size (the scope-capture benchmark guards the scaling ratio).
+ */
+export declare function synthesizeCallableFlowCaptures(root: SyntaxNode, options: CallableFlowCaptureOptions): readonly CaptureMatch[];