spectra-cli 4.1.1 → 4.2.0

package/dist/core/query-mappers/java-mapper.js

@@ -1,4 +1,53 @@
 // ============================================================
+// Feature 154 — callSites 抽取常量
+// 集合内容与 scripts/lib/java-call-extractor.mjs 同名集合保持完全一致；
+// java-mapper-callsite.test.ts 在常量同源 describe 块中通过 import extractor
+// 侧 export 做集合相等断言，CI 全集校验，任一侧扩展时另一侧必失败提示。
+// ============================================================
+/** 大文件兜底阈值（FR-006）— 1 MB 字节数（非字符数） */
+export const CALLSITES_MAX_FILE_BYTES = 1_048_576;
+/**
+ * 反射方法名集合（FR-005）— 与 java-call-extractor.mjs:REFLECTION_METHOD_NAMES 同源。
+ * receiver 检查之前优先短路：callee 名命中此集合 → calleeKind: 'unresolved'。
+ */
+export const JAVA_REFLECTION_METHOD_NAMES = new Set([
+    'forName',
+    'invoke',
+    'newInstance',
+    'getDeclaredMethod',
+    'getMethod',
+    'getDeclaredField',
+    'getField',
+    'getConstructor',
+    'getDeclaredConstructor',
+    'getConstructors',
+    'getDeclaredConstructors',
+    'newProxyInstance',
+]);
+/**
+ * Java 标准库 acronym 类型白名单 — 与 java-call-extractor.mjs:JAVA_ACRONYM_TYPE_NAMES 同源。
+ * 全大写但属于 Java 标准库类型（如 java.util.UUID, java.net.URL）；用于 _isJavaTypeName。
+ */
+export const JAVA_ACRONYM_TYPE_NAMES = new Set([
+    'URL', 'URI', 'UUID',
+    'XML', 'JSON', 'CSV',
+    'API', 'JDBC', 'JNDI',
+    'AWS', 'TCP', 'UDP',
+    'SQL', 'JPA',
+    'IO',
+]);
+/**
+ * Java 包根名白名单 — 与 java-call-extractor.mjs:JAVA_PACKAGE_ROOT_NAMES 同源。
+ * 仅在 _looksLikePackageQualifiedType 内使用，用于判定 FQN 类型路径
+ * （如 java.util.UUID）；**不在 _isJavaTypeName 内使用**，避免 `com` / `org`
+ * 单独被误判为类型（Codex P1 WARNING W-2）。
+ */
+export const JAVA_PACKAGE_ROOT_NAMES = new Set([
+    'java', 'javax', 'jakarta',
+    'com', 'org', 'net',
+    'io', 'edu', 'gov', 'mil',
+]);
+// ============================================================
 // 辅助工具
 // ============================================================
 /** 获取节点的命名字段文本 */
@@ -161,6 +210,46 @@ export class JavaMapper {
         this._collectErrors(tree.rootNode, errors);
         return errors;
     }
+    /**
+     * Feature 154 — 抽取 Java 函数调用点（FR-001 ~ FR-013）。
+     *
+     * 节点覆盖（FR-001）：
+     * - method_invocation：实例 / 静态方法调用
+     * - object_creation_expression：构造器调用 (new ClassName())
+     * - explicit_constructor_invocation：super(...) / this(...)
+     * - lambda_expression 内部上述三类调用
+     *
+     * 大文件兜底（FR-006，Codex P1 WARNING W-1 修订：用字节数而非字符数）：
+     * - Buffer.byteLength(source, 'utf8') > CALLSITES_MAX_FILE_BYTES → 直接返回 []
+     *
+     * Parse 异常兜底：
+     * - 任何异常被外层 try-catch 捕获 → 返回 [] + warn 日志，不污染 CodeSkeleton
+     *
+     * 详细 kind 映射规则见 spec FR-003 + plan _classifyMethodInvocation 优先级 dispatch。
+     */
+    extractCallSites(tree, source) {
+        const byteLength = Buffer.byteLength(source, 'utf8');
+        if (byteLength > CALLSITES_MAX_FILE_BYTES) {
+            // FR-006：大文件兜底必须 warn（Codex T-1 review CRITICAL B 修订）
+            console.warn(`[java-mapper] extractCallSites 大文件跳过：byteLength=${byteLength} > ${CALLSITES_MAX_FILE_BYTES}`);
+            return [];
+        }
+        try {
+            const out = [];
+            this._walkCallSites(tree.rootNode, out);
+            return out;
+        }
+        catch (err) {
+            // 异常兜底：保留诊断上下文（root node type + byteLength + stack）
+            // 便于排错而非静默吞掉真实 bug（Codex T-1 review WARNING C 修订）
+            const message = err instanceof Error ? err.message : String(err);
+            const stack = err instanceof Error ? err.stack : undefined;
+            console.warn(`[java-mapper] extractCallSites 异常兜底：` +
+                `rootType=${tree.rootNode.type} byteLength=${byteLength} message=${message}` +
+                (stack ? `\n${stack}` : ''));
+            return [];
+        }
+    }
     // ============================================================
     // 内部方法 — 顶层声明提取
     // ============================================================
@@ -401,5 +490,516 @@ export class JavaMapper {
             }
         }
     }
+    // ============================================================
+    // Feature 154 — call sites walker（T-3.1 阶段填充逻辑）
+    // ============================================================
+    /**
+     * 迭代式 DFS walker（手工栈，避免大文件递归爆栈）。
+     *
+     * 节点类型 dispatch（FR-001）：
+     *   - method_invocation                    → _handleMethodInvocation
+     *   - object_creation_expression           → _handleObjectCreation
+     *   - explicit_constructor_invocation      → _handleExplicitConstructorInvocation
+     *
+     * ERROR / MISSING 跳过策略（FR-007）：
+     *   - node.type === 'ERROR' 或 node.isMissing === true → 跳过该节点 + 不入栈子节点
+     *   - 非 ERROR/MISSING 节点正常入栈 namedChildren
+     */
+    _walkCallSites(root, out) {
+        const stack = [root];
+        while (stack.length > 0) {
+            const node = stack.pop();
+            if (!node)
+                continue;
+            // ERROR / MISSING 子树整体跳过（不抽取本节点 + 不入栈子节点）
+            if (node.type === 'ERROR' || node.isMissing === true) {
+                continue;
+            }
+            switch (node.type) {
+                case 'method_invocation':
+                    this._handleMethodInvocation(node, out);
+                    break;
+                case 'object_creation_expression':
+                    this._handleObjectCreation(node, out);
+                    break;
+                case 'explicit_constructor_invocation':
+                    this._handleExplicitConstructorInvocation(node, out);
+                    break;
+                default:
+                    break;
+            }
+            // 入栈所有 namedChildren（继续 DFS）
+            const children = node.namedChildren;
+            if (children && children.length > 0) {
+                for (let i = children.length - 1; i >= 0; i--) {
+                    const child = children[i];
+                    if (child)
+                        stack.push(child);
+                }
+            }
+        }
+    }
+    // ============================================================
+    // Feature 154 — callerContext 解析（T-3.2）
+    // ============================================================
+    /**
+     * 向上 walk 找最近一层 function-like enclosing scope，输出 callerContext 字符串。
+     *
+     * 与 scripts/lib/java-call-extractor.mjs 的 _resolveJavaCaller 嵌套优先策略一致：
+     *   - method_declaration            → "{TypeName}.{methodName}"
+     *   - constructor_declaration       → "{TypeName}.<init>"
+     *   - compact_constructor_declaration → "{TypeName}.<init>"  (Java 14+ record)
+     *   - lambda_expression             → "<lambda:{startLine}:{startColumn}>"
+     *   - 顶层（无 enclosing scope）    → "<top-level>"
+     *
+     * 嵌套优先：第一个匹配立即 return，不继续向上 walk。
+     */
+    _resolveCallerContext(node) {
+        let cursor = node.parent;
+        while (cursor) {
+            const t = cursor.type;
+            if (t === 'method_declaration') {
+                const nameNode = cursor.childForFieldName('name');
+                const methodName = nameNode && typeof nameNode.text === 'string' ? nameNode.text : '<anon-method>';
+                const typeName = this._findEnclosingTypeName(cursor.parent);
+                return `${typeName}.${methodName}`;
+            }
+            if (t === 'constructor_declaration' || t === 'compact_constructor_declaration') {
+                const typeName = this._findEnclosingTypeName(cursor.parent);
+                return `${typeName}.<init>`;
+            }
+            if (t === 'lambda_expression') {
+                const line = (cursor.startPosition?.row ?? 0) + 1;
+                const col = cursor.startPosition?.column ?? 0;
+                return `<lambda:${line}:${col}>`;
+            }
+            cursor = cursor.parent;
+        }
+        return '<top-level>';
+    }
+    /**
+     * 从给定节点向上找最近的类型容器，返回类型名或特殊标记。
+     *
+     * 支持的类型节点（Codex P1 CRITICAL C-7 修订：5 类全覆盖）：
+     *   - class_declaration / interface_declaration / enum_declaration
+     *   - record_declaration（Java 14+）
+     *   - annotation_type_declaration（@interface）
+     *
+     * 特殊：遇 object_creation_expression 内层 class_body → 返回 '<anon-class>'。
+     * 找不到容器 → '<top-level>'。
+     */
+    _findEnclosingTypeName(node) {
+        let cursor = node;
+        while (cursor) {
+            const t = cursor.type;
+            if (t === 'class_declaration' ||
+                t === 'interface_declaration' ||
+                t === 'enum_declaration' ||
+                t === 'record_declaration' ||
+                t === 'annotation_type_declaration') {
+                const nameNode = cursor.childForFieldName('name');
+                if (nameNode && typeof nameNode.text === 'string') {
+                    return nameNode.text;
+                }
+                return '<anon-class>';
+            }
+            // 匿名类：method_declaration 父 class_body 父是 object_creation_expression
+            if (t === 'object_creation_expression') {
+                return '<anon-class>';
+            }
+            cursor = cursor.parent;
+        }
+        return '<top-level>';
+    }
+    // ============================================================
+    // Feature 154 — phantom call 防护 + CallSite 构造（T-3.3 + T-3.4）
+    // ============================================================
+    /**
+     * 判断 method_invocation / object_creation_expression / explicit_constructor_invocation
+     * 是否是 phantom call（受 parse error 影响但本节点 type 仍非 ERROR）。
+     *
+     * Codex P1 CRITICAL C-6 修订：判定为 OR（不是 AND）：
+     *   - 关键 callee 字段子树 hasError === true，OR
+     *   - direct children 中含 ERROR / MISSING
+     *
+     * phantom 命中时调用方仅跳过当前 call 的抽取（不 push out），但 walker 继续
+     * 入栈 namedChildren，避免内层真实 call 被误杀。
+     */
+    _isPhantomCall(node, kind) {
+        let calleeForCheck = null;
+        if (typeof node.childForFieldName === 'function') {
+            if (kind === 'method-invocation') {
+                calleeForCheck = node.childForFieldName('name');
+            }
+            else if (kind === 'object-creation') {
+                calleeForCheck = node.childForFieldName('type');
+            }
+            else if (kind === 'explicit-constructor') {
+                calleeForCheck = node.childForFieldName('constructor');
+            }
+        }
+        if (calleeForCheck && calleeForCheck.hasError === true) {
+            return true;
+        }
+        const allChildren = Array.isArray(node.children) ? node.children : [];
+        return allChildren.some((c) => c && (c.type === 'ERROR' || c.isMissing === true));
+    }
+    /** 构造单个 CallSite 记录（按 CallSiteSchema，可选字段仅在非 undefined 时写入） */
+    _mkCallSite(calleeName, calleeKind, line, column, callerContext, calleeQualifier) {
+        // column 由调用方传入（来自 startPosition.column ?? 0），始终为 number，
+        // 不需要 if (column !== undefined) 判断（Codex quality-review WARN 修订）
+        const cs = {
+            calleeName,
+            calleeKind,
+            line,
+            column,
+        };
+        if (callerContext !== undefined)
+            cs.callerContext = callerContext;
+        if (calleeQualifier !== undefined)
+            cs.calleeQualifier = calleeQualifier;
+        return cs;
+    }
+    // ============================================================
+    // Feature 154 — receiver 类型探测辅助（T-2.1）
+    // 设计与 scripts/lib/java-call-extractor.mjs 同源（语义对齐 truth-set）
+    // ============================================================
+    /**
+     * 判断 identifier text 是否符合 Java 类型命名约定。
+     *
+     * Java 命名约定：
+     *   - PascalCase（首字母大写 + 含至少一个小写字母）：Math, Logger, FileInputStream
+     *   - 全大写 Acronym（≥ 2 字符且属于白名单）：URL, UUID, JSON
+     *   - 常量 SCREAMING_SNAKE_CASE：LOGGER, MAX_SIZE — **不**视为类型名
+     *
+     * Codex P1 WARNING W-2 修订：**不在此函数内**判定 JAVA_PACKAGE_ROOT_NAMES。
+     * 包根判定只在 _looksLikePackageQualifiedType 内对完整 field_access 链使用，
+     * 避免 `com` / `org` 单独被误归为类型。
+     */
+    _isJavaTypeName(text) {
+        if (typeof text !== 'string' || text.length === 0)
+            return false;
+        if (!/^[A-Z]/.test(text))
+            return false;
+        // PascalCase（含小写字母）
+        if (/[a-z]/.test(text))
+            return true;
+        // Acronym 白名单（全大写）
+        if (JAVA_ACRONYM_TYPE_NAMES.has(text))
+            return true;
+        return false;
+    }
+    /**
+     * 判断 field_access 节点的末段 field 是否是类型名。
+     *
+     * 三层判定（Codex T-2 review CRITICAL C-1 修订：必须先要求整条链可拆为 segments，
+     * 避免 `foo().bar.Baz.call()` 这种 leftmost 是 method_invocation 的链被误判为
+     * 类型路径）：
+     *   0. _fieldAccessSegments 拆链失败（leftmost 不是 simple identifier）→ false
+     *   1. 末段 field 是 PascalCase / acronym → 类型路径（Outer.Inner）
+     *   2. 末段 field 全大写但首字母大写 + 整条链是已知 Java 包路径 → FQN
+     *      类型路径（java.util.UUID）
+     */
+    _fieldAccessTerminalIsType(node) {
+        // 必须能拆为 [leftmost identifier, ..., field] segment 列表
+        const segments = this._fieldAccessSegments(node);
+        if (!segments)
+            return false;
+        const fieldNameNode = node.childForFieldName('field');
+        if (!fieldNameNode || typeof fieldNameNode.text !== 'string')
+            return false;
+        // 局部命名 terminalFieldName 避免与模块顶层 fieldText 工具函数遮蔽
+        const terminalFieldName = fieldNameNode.text;
+        // Path 1+2: PascalCase 或 acronym 白名单
+        if (this._isJavaTypeName(terminalFieldName))
+            return true;
+        // Path 3: 全大写 field + 整条链是已知 Java 包路径 → FQN type
+        if (/^[A-Z]/.test(terminalFieldName)) {
+            if (this._looksLikePackageQualifiedType(node))
+                return true;
+        }
+        return false;
+    }
+    /**
+     * 把 field_access 链拆为 [leftmost, ..., field] 的 segment 数组。
+     *
+     * 例如 `java.util.UUID` 树形：
+     *   field_access(field='UUID')
+     *     └ field_access(field='util')
+     *         └ identifier 'java'
+     * 返回 ['java', 'util', 'UUID']。
+     *
+     * 任一节点缺 'object'/'field' 字段或 leftmost 非 identifier → 返回 null。
+     */
+    _fieldAccessSegments(node) {
+        const reversed = [];
+        let cursor = node;
+        while (cursor &&
+            cursor.type === 'field_access' &&
+            typeof cursor.childForFieldName === 'function') {
+            const fieldNode = cursor.childForFieldName('field');
+            if (!fieldNode || typeof fieldNode.text !== 'string')
+                return null;
+            reversed.push(fieldNode.text);
+            cursor = cursor.childForFieldName('object');
+        }
+        if (!cursor || cursor.type !== 'identifier' || typeof cursor.text !== 'string') {
+            return null;
+        }
+        reversed.push(cursor.text);
+        return reversed.reverse();
+    }
+    /**
+     * 判断 field_access 链是否是"包路径.类型"形态。
+     *
+     * 三个条件全满足才返回 true：
+     *   1. 链至少 3 段（leftmost + ≥ 1 中间 + 末段类型）
+     *   2. leftmost 在 JAVA_PACKAGE_ROOT_NAMES（仅在此函数内使用）
+     *   3. 末段之外每段都是 lowercase package segment 形态（^[a-z][a-z0-9_]*$）
+     */
+    _looksLikePackageQualifiedType(node) {
+        const segments = this._fieldAccessSegments(node);
+        if (!segments || segments.length < 3)
+            return false;
+        // Codex T-2 review WARNING W-2 修订：合同自洽 — 末段必须 PascalCase
+        const terminal = segments[segments.length - 1];
+        if (!terminal || !/^[A-Z]/.test(terminal))
+            return false;
+        const packageSegments = segments.slice(0, -1);
+        const leftmost = packageSegments[0];
+        if (leftmost === undefined || !JAVA_PACKAGE_ROOT_NAMES.has(leftmost))
+            return false;
+        return packageSegments.every((s) => /^[a-z][a-z0-9_]*$/.test(s));
+    }
+    /**
+     * 把 scoped type name normalize 到末段（label-only 对齐 truth-set）。
+     * 例如 `Outer.Inner` → `Inner`；`com.foo.Bar` → `Bar`。
+     */
+    _normalizeJavaTypeName(name) {
+        if (typeof name !== 'string' || name.length === 0)
+            return name;
+        const lastDot = name.lastIndexOf('.');
+        return lastDot === -1 ? name : name.slice(lastDot + 1);
+    }
+    /**
+     * 剥离 generic_type.text 中的 type arguments。
+     *
+     * Codex T-2 review WARNING W-1 修订：用 depth-based 解析处理嵌套泛型，
+     * 避免 `Outer<T>.Inner<K>` 被首个 `<` 截断为 `Outer`（应保留 `Outer.Inner`）。
+     *
+     * 例如：
+     *   `ArrayList<String>`         → `ArrayList`
+     *   `Outer.Inner<T,K>`          → `Outer.Inner`
+     *   `Outer<T>.Inner<K>`         → `Outer.Inner`
+     *   `Map<K, List<V>>`           → `Map`
+     */
+    _stripTypeArgs(text) {
+        if (typeof text !== 'string' || text.length === 0)
+            return text;
+        let depth = 0;
+        let out = '';
+        for (const ch of text) {
+            if (ch === '<') {
+                depth += 1;
+                continue;
+            }
+            if (ch === '>') {
+                depth = Math.max(0, depth - 1);
+                continue;
+            }
+            if (depth === 0)
+                out += ch;
+        }
+        return out;
+    }
+    // ============================================================
+    // Feature 154 — classify methods（T-2.2 + T-2.3）
+    // 优先级 dispatch 详见 spec FR-003 + plan 修订版伪代码
+    // ============================================================
+    /**
+     * 分类 method_invocation 节点 → CallSite 元数据。
+     *
+     * 优先级 dispatch（spec FR-003 + Codex CRITICAL E 修订）：
+     *   1. objectNode.type === 'super'                 → super
+     *   2. callee 名 ∈ JAVA_REFLECTION_METHOD_NAMES    → unresolved
+     *   3. objectNode.type === 'this'                  → member + undefined
+     *   4. type_identifier / scoped_type_identifier    → member + 末段类名
+     *   5. identifier (PascalCase / acronym)           → member + identifier 文本
+     *   6. identifier (lowercase 变量名)               → cross-module + identifier 文本
+     *   7. field_access 末段 type                      → member + 末段类名
+     *   8. field_access 末段非 type                    → cross-module + undefined
+     *   9. 其它带 receiver                             → cross-module + undefined
+     *  10. 无 receiver                                 → member + undefined
+     */
+    _classifyMethodInvocation(node) {
+        if (typeof node.childForFieldName !== 'function') {
+            return { calleeName: '<unknown>', calleeKind: 'unresolved' };
+        }
+        const nameNode = node.childForFieldName('name');
+        if (!nameNode || typeof nameNode.text !== 'string') {
+            return { calleeName: '<unknown>', calleeKind: 'unresolved' };
+        }
+        const calleeName = nameNode.text;
+        const objectNode = node.childForFieldName('object');
+        // 1. super.method() → super（super() / this() 由 _handleExplicitConstructorInvocation 处理）
+        if (objectNode && objectNode.type === 'super') {
+            return { calleeName, calleeKind: 'super' };
+        }
+        // 2. 反射方法名 short-circuit
+        if (JAVA_REFLECTION_METHOD_NAMES.has(calleeName)) {
+            return { calleeName, calleeKind: 'unresolved' };
+        }
+        // 3. this.method() — Codex CRITICAL E：tree-sitter 把 'this' 解析为独立 node type
+        if (objectNode && objectNode.type === 'this') {
+            return { calleeName, calleeKind: 'member' };
+        }
+        if (objectNode) {
+            // 4. type_identifier / scoped_type_identifier
+            if (objectNode.type === 'type_identifier' ||
+                objectNode.type === 'scoped_type_identifier') {
+                return {
+                    calleeName,
+                    calleeKind: 'member',
+                    calleeQualifier: this._normalizeJavaTypeName(objectNode.text),
+                };
+            }
+            // 5/6. identifier
+            if (objectNode.type === 'identifier' && typeof objectNode.text === 'string') {
+                if (this._isJavaTypeName(objectNode.text)) {
+                    // PascalCase / acronym → static member
+                    return {
+                        calleeName,
+                        calleeKind: 'member',
+                        calleeQualifier: objectNode.text,
+                    };
+                }
+                // lowercase variable → instance method
+                return {
+                    calleeName,
+                    calleeKind: 'cross-module',
+                    calleeQualifier: objectNode.text,
+                };
+            }
+            // 7/8. field_access — Codex T-2 review CRITICAL C-1 修订：
+            // _fieldAccessTerminalIsType 内已强制要求 _fieldAccessSegments 非空，
+            // 此处 segs 必非空，直接取末段做 qualifier
+            if (objectNode.type === 'field_access') {
+                if (this._fieldAccessTerminalIsType(objectNode)) {
+                    const segs = this._fieldAccessSegments(objectNode);
+                    // _fieldAccessTerminalIsType 已验证 segs 非空，但 TS 类型仍需 narrowing
+                    const qualifier = segs && segs.length > 0
+                        ? segs[segs.length - 1]
+                        : this._normalizeJavaTypeName(objectNode.text);
+                    return { calleeName, calleeKind: 'member', calleeQualifier: qualifier };
+                }
+                return { calleeName, calleeKind: 'cross-module' };
+            }
+            // 9. 其它 receiver（method_invocation 链 / array_access / parenthesized 等）
+            return { calleeName, calleeKind: 'cross-module' };
+        }
+        // 10. 无 receiver（含 static import 展开 free function）→ 统一归 member
+        // spec FR-003 deferred 决策：不输出 free，与 truth-set kind=method 对齐
+        return { calleeName, calleeKind: 'member' };
+    }
+    /**
+     * 分类 object_creation_expression 节点（new ClassName()）→ CallSite 元数据。
+     *
+     * type 字段三种形态：
+     *   - type_identifier (`new Foo()`)
+     *   - generic_type (`new ArrayList<Integer>()`，内层 type_identifier 或 scoped_type_identifier)
+     *   - scoped_type_identifier (`new Outer.Inner()`)
+     *
+     * 输出统一 calleeName = calleeQualifier = normalized 末段类名。
+     */
+    _classifyObjectCreation(node) {
+        if (typeof node.childForFieldName !== 'function') {
+            return { calleeName: '<unknown>', calleeKind: 'unresolved' };
+        }
+        const typeNode = node.childForFieldName('type');
+        if (!typeNode) {
+            return { calleeName: '<unknown>', calleeKind: 'unresolved' };
+        }
+        let rawName;
+        if (typeNode.type === 'type_identifier' && typeof typeNode.text === 'string') {
+            rawName = typeNode.text;
+        }
+        else if (typeNode.type === 'scoped_type_identifier' && typeof typeNode.text === 'string') {
+            rawName = typeNode.text;
+        }
+        else if (typeNode.type === 'generic_type') {
+            // 内层 type_identifier / scoped_type_identifier 优先
+            const named = Array.isArray(typeNode.namedChildren) ? typeNode.namedChildren : [];
+            const inner = named.find((c) => c && (c.type === 'type_identifier' || c.type === 'scoped_type_identifier'));
+            if (inner && typeof inner.text === 'string') {
+                rawName = inner.text;
+            }
+            else if (typeof typeNode.text === 'string') {
+                rawName = this._stripTypeArgs(typeNode.text);
+            }
+        }
+        else if (typeof typeNode.text === 'string' && typeNode.text.length > 0) {
+            rawName = this._stripTypeArgs(typeNode.text);
+        }
+        if (!rawName) {
+            return { calleeName: '<unknown>', calleeKind: 'unresolved' };
+        }
+        const className = this._normalizeJavaTypeName(rawName);
+        return {
+            calleeName: className,
+            calleeKind: 'member',
+            calleeQualifier: className,
+        };
+    }
+    /**
+     * 分类 explicit_constructor_invocation 节点（构造器内 super(...) / this(...)）。
+     *
+     * constructor 字段 type === 'super' / 'this' → kind=super，calleeName 为字面值。
+     * 其它形态 → unresolved。
+     */
+    _classifyExplicitConstructorInvocation(node) {
+        if (typeof node.childForFieldName !== 'function') {
+            return { calleeName: '<unknown>', calleeKind: 'unresolved' };
+        }
+        const ctorNode = node.childForFieldName('constructor');
+        if (!ctorNode) {
+            return { calleeName: '<unknown>', calleeKind: 'unresolved' };
+        }
+        if (ctorNode.type === 'super' || ctorNode.type === 'this') {
+            return { calleeName: ctorNode.type, calleeKind: 'super' };
+        }
+        if (typeof ctorNode.text === 'string') {
+            return { calleeName: ctorNode.text, calleeKind: 'unresolved' };
+        }
+        return { calleeName: '<unknown>', calleeKind: 'unresolved' };
+    }
+    // ============================================================
+    // Feature 154 — handler 接通完整链路（T-3.4）
+    // 流程：phantom 检查 → classify → callerContext → push out
+    //
+    // Codex T-3 review WARNING F 修订：3 个 handler 共用 _emitCallSite helper，
+    // 避免 line/column/callerContext/push 写入逻辑在多处漂移。
+    // ============================================================
+    /** 共用 emit 流程：phantom check → classify → callerContext → push */
+    _emitCallSite(node, out, phantomKind, classifier) {
+        if (this._isPhantomCall(node, phantomKind))
+            return;
+        const cls = classifier(node);
+        const callerCtx = this._resolveCallerContext(node);
+        const line = (node.startPosition?.row ?? 0) + 1;
+        const col = node.startPosition?.column ?? 0;
+        out.push(this._mkCallSite(cls.calleeName, cls.calleeKind, line, col, callerCtx, cls.calleeQualifier));
+    }
+    /** method_invocation handler */
+    _handleMethodInvocation(node, out) {
+        this._emitCallSite(node, out, 'method-invocation', (n) => this._classifyMethodInvocation(n));
+    }
+    /** object_creation_expression handler */
+    _handleObjectCreation(node, out) {
+        this._emitCallSite(node, out, 'object-creation', (n) => this._classifyObjectCreation(n));
+    }
+    /** explicit_constructor_invocation handler */
+    _handleExplicitConstructorInvocation(node, out) {
+        this._emitCallSite(node, out, 'explicit-constructor', (n) => this._classifyExplicitConstructorInvocation(n));
+    }
 }
 //# sourceMappingURL=java-mapper.js.map