arkanalyzer 1.0.94 → 2.0.0-beta1

package/lib/frontend/SceneBuilder.js

@@ -0,0 +1,859 @@
+"use strict";
+/*
+ * Copyright (c) 2026 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SceneBuilder = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const ArkFile_1 = require("../core/model/ArkFile");
+const ArkSignature_1 = require("../core/model/ArkSignature");
+const ModuleScene_1 = require("./ModuleScene");
+const FrontendBuilder_1 = require("./FrontendBuilder");
+const ArktsFrontend_1 = require("./arktsFrontend/ArktsFrontend");
+const FileBodyRemount_1 = require("./arktsFrontend/FileBodyRemount");
+const ModuleUtils_1 = require("../utils/ModuleUtils");
+const json5parser_1 = require("../utils/json5parser");
+const getAllFiles_1 = require("../utils/getAllFiles");
+const FileUtils_1 = require("../utils/FileUtils");
+const TSConst_1 = require("../core/common/TSConst");
+const EtsConst_1 = require("../core/common/EtsConst");
+const SdkUtils_1 = require("../core/common/SdkUtils");
+const ModelUtils_1 = require("../core/common/ModelUtils");
+const Inference_1 = require("../core/inference/Inference");
+const ArkMethodBuilder_1 = require("../core/model/builder/ArkMethodBuilder");
+const ArkMethodBuilder_2 = require("./cppFrontend/model/builder/ArkMethodBuilder");
+const SignatureCanonicalizerRegistry_1 = require("../core/common/SignatureCanonicalizerRegistry");
+const SceneBuildStage_1 = require("./SceneBuildStage");
+const StageStatistics_1 = require("../statistics/StageStatistics");
+const logger_1 = __importStar(require("../utils/logger"));
+const logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'SceneBuilder');
+/**
+ * 完整构建路径的一次性构建上下文（BuildContext）。
+ *
+ * 承接构建机械与构建期工作态：配置解析族（build-profile / oh-package / tsconfig）与 project 文件 DFS 族（getDependencyFilesDeeply 及全部
+ * 依赖发现辅助）。
+ *
+ * 生命周期：由 Scene 在构建入口创建并持有（scene.activeBuilder），构建结束由入口方法释放（置 undefined）——工作态随本实例被 GC 回收，不驻留
+ * Scene。Scene 仅保留构建产物（builtFileOrder / moduleScenesMap / overRides / 失败文件摘要等）与查询侧状态。
+ *
+ * 注意：本类不承载模块化增量路径（analyseByModule/loadModule 走 ModuleBuilder，其构建态常驻 Scene，不受本上下文生命周期影响）。
+ */
+class SceneBuilder {
+    constructor(scene, sceneConfig) {
+        // --- 构建期工作态（构建结束随本实例回收，不回填 Scene）---
+        /** oh-package.json5 内容表（绝对路径 → 内容），依赖解析（parseFrom 族）的输入。 */
+        this.ohPkgContentMap = new Map();
+        this.ohPkgFilePath = '';
+        this.ohPkgContent = {};
+        /**
+         * from → 直接解析出的物理文件路径列表（性能缓存）。key 精确对齐
+         * {@link getOriginPath} 的解析语义：相对形式（`./`、`../`）带声明文件
+         * 所在目录前缀（`dirname + '\x00' + from`——同目录文件的相同相对 from 才允许共享）；模块名形式（`@ohos/xxx`、裸名）用 from 本身（解析只走
+         * ohPkgContentMap / projectDir / tsconfig 全局映射，与声明文件位置无关）。空数组也缓存（负缓存——避免失败 from 重复走全部分支）。
+         * **只缓存纯函数结果（from → paths），绝不缓存"文件要不要构建"的决策**——
+         * 后者依赖 filesMap/unhandledFilePaths 等可变状态，命中后必须逐个经
+         * {@link getDependencyFilesDeeply} 的三重防重入入口重新仲裁。
+         */
+        this.fromResolutionCache = new Map();
+        /**
+         * 解析产出收集栈（嵌套隔离）：parseFrom 未命中时 push 新槽，嵌套递归构建
+         * 触发的 parseFrom 各归各的槽；pop 时整槽写入 fromResolutionCache——
+         * 条目只含该 from 的"直接"产出，不含递归依赖自身的解析结果。
+         */
+        this.fromResolutionStack = [];
+        /**
+         * inner oh-package 内容缓存（兜底）：不同 from 首次解析触达同一 inner
+         * oh-package 的残余重复读盘。独立于 ohPkgContentMap——后者正被
+         * for...of 遍历，遍历中插入 key 会改变迭代行为（JS Map 迭代可见新增项）。
+         */
+        this.resolvedOhPkgCache = new Map();
+        this.scene = scene;
+        this.sceneConfig = sceneConfig;
+        this.registry = SignatureCanonicalizerRegistry_1.SignatureCanonicalizerRegistry.getInstance();
+        this.unhandledFilePaths = scene.getUnhandledFileSet();
+    }
+    // --- 配置解析族（原 Scene.parseBuildProfile / parseOhPackage / tsconfig 族 / buildOhPkgContentMap）---
+    /**
+     * 解析项目配置：build-profile.json5（ES 版本 + 模块表）、oh-package.json5
+     * （含 overrides）、tsconfig（paths/baseUrl，extends 链递归）、模块 oh-package 表，
+     * 最后生成模块映射（ModuleUtils.generateModuleMap）。
+     */
+    parseProjectConfigs() {
+        var _a, _b, _c;
+        (_a = this.scene.getStageStatisticsCollector()) === null || _a === void 0 ? void 0 : _a.startStage(StageStatistics_1.StageName.BuilderParseConfigs);
+        this.parseBuildProfile();
+        this.parseOhPackage();
+        const tsConfigOption = (_b = this.scene.getOptions().tsconfig) !== null && _b !== void 0 ? _b : TSConst_1.TSCONFIG_JSON;
+        const tsConfigFilePath = path_1.default.join(this.sceneConfig.getTargetProjectDirectory(), tsConfigOption);
+        if (fs_1.default.existsSync(tsConfigFilePath)) {
+            const tsConfigObj = (0, json5parser_1.fetchDependenciesFromFile)(tsConfigFilePath);
+            this.findTsConfigInfoDeeply(tsConfigObj, tsConfigFilePath);
+        }
+        else {
+            logger.warn('This project has no tsconfig.json!');
+        }
+        this.buildOhPkgContentMap();
+        ModuleUtils_1.ModuleUtils.generateModuleMap(this.ohPkgContentMap);
+        // 配置产物快照回填（tsconfig paths/baseUrl 构建后仍可查询）。
+        this.scene.setTsConfigSnapshot(this.globalModule2PathMapping, this.baseUrl);
+        (_c = this.scene.getStageStatisticsCollector()) === null || _c === void 0 ? void 0 : _c.endStage(StageStatistics_1.StageName.BuilderParseConfigs);
+    }
+    /** @internal 供 Scene.buildBasicInfo 的 SDK 阶段读取（P3 迁移后内化）。 */
+    getOhPkgContentMap() {
+        return this.ohPkgContentMap;
+    }
+    /** @internal 追加模块 oh-package 内容（Scene.buildModuleScene 的依赖解析输入，P3 迁移后内化）。 */
+    addOhPkgContent(ohPkgFilePath, content) {
+        this.ohPkgContentMap.set(ohPkgFilePath, content);
+    }
+    /** @internal tsconfig baseUrl（构建期值；仅在活跃构建上下文中可查）。 */
+    getBaseUrl() {
+        return this.baseUrl;
+    }
+    parseBuildProfile() {
+        const buildProfile = path_1.default.join(this.scene.getRealProjectDir(), EtsConst_1.BUILD_PROFILE_JSON5);
+        if (fs_1.default.existsSync(buildProfile)) {
+            let configurationsText;
+            try {
+                configurationsText = fs_1.default.readFileSync(buildProfile, 'utf-8');
+            }
+            catch (error) {
+                logger.error(`Error reading file: ${error}`);
+                return;
+            }
+            const buildProfileJson = (0, json5parser_1.parseJsonText)(configurationsText);
+            SdkUtils_1.SdkUtils.setEsVersion(buildProfileJson);
+            const modules = buildProfileJson.modules;
+            if (modules instanceof Array) {
+                modules.forEach(module => {
+                    this.scene.getModulePath2NameMap().set(path_1.default.resolve(this.scene.getRealProjectDir(), path_1.default.join(module.srcPath)), module.name);
+                });
+            }
+        }
+        else {
+            logger.warn('There is no build-profile.json5 for this project.');
+        }
+    }
+    parseOhPackage() {
+        const OhPkgFilePath = path_1.default.join(this.scene.getRealProjectDir(), EtsConst_1.OH_PACKAGE_JSON5);
+        if (fs_1.default.existsSync(OhPkgFilePath)) {
+            this.ohPkgFilePath = OhPkgFilePath;
+            this.ohPkgContent = (0, json5parser_1.fetchDependenciesFromFile)(this.ohPkgFilePath);
+            this.ohPkgContentMap.set(OhPkgFilePath, this.ohPkgContent);
+            if (this.ohPkgContent.overrides) {
+                let overRides = this.ohPkgContent.overrides;
+                for (const [key, value] of Object.entries(overRides)) {
+                    this.scene.getOverRides().set(key, value);
+                }
+            }
+            if (this.ohPkgContent.overrideDependencyMap) {
+                let globalOverRideDependencyMap = this.ohPkgContent.overrideDependencyMap;
+                for (const [key, value] of Object.entries(globalOverRideDependencyMap)) {
+                    let globalDependency = (0, json5parser_1.fetchDependenciesFromFile)(value);
+                    this.scene.getOverRideDependencyMap().set(key, globalDependency);
+                }
+            }
+        }
+        else {
+            logger.warn('This project has no oh-package.json5!');
+        }
+        // 配置产物快照回填（对齐 setTsConfigSnapshot 模式）：根 oh-package 内容在
+        // 构建结束后仍可经 Scene.getOhPkgContent() 查询（构建期上下文已释放）。
+        this.scene.setOhPkgContentSnapshot(this.ohPkgContent);
+    }
+    findTsConfigInfoDeeply(tsConfigObj, tsConfigFilePath) {
+        if (tsConfigObj.extends) {
+            const extTsConfigFilePath = path_1.default.join(path_1.default.dirname(tsConfigFilePath), tsConfigObj.extends);
+            const extTsConfigObj = (0, json5parser_1.fetchDependenciesFromFile)(extTsConfigFilePath);
+            this.findTsConfigInfoDeeply(extTsConfigObj, extTsConfigFilePath);
+            if (!this.baseUrl && !this.globalModule2PathMapping) {
+                this.addTsConfigInfo(extTsConfigObj);
+            }
+        }
+        if (!this.baseUrl && !this.globalModule2PathMapping) {
+            this.addTsConfigInfo(tsConfigObj);
+        }
+    }
+    addTsConfigInfo(tsConfigObj) {
+        if (tsConfigObj.compilerOptions && tsConfigObj.compilerOptions.paths) {
+            const paths = tsConfigObj.compilerOptions.paths;
+            if (paths) {
+                this.globalModule2PathMapping = paths;
+            }
+        }
+        if (tsConfigObj.compilerOptions && tsConfigObj.compilerOptions.baseUrl) {
+            this.baseUrl = tsConfigObj.compilerOptions.baseUrl;
+        }
+    }
+    buildOhPkgContentMap() {
+        this.scene.getModulePath2NameMap().forEach((value, key) => {
+            const moduleOhPkgFilePath = path_1.default.resolve(key, EtsConst_1.OH_PACKAGE_JSON5);
+            if (fs_1.default.existsSync(moduleOhPkgFilePath)) {
+                const moduleOhPkgContent = (0, json5parser_1.fetchDependenciesFromFile)(moduleOhPkgFilePath);
+                this.ohPkgContentMap.set(moduleOhPkgFilePath, moduleOhPkgContent);
+            }
+        });
+    }
+    // --- project 文件 DFS 族（原 Scene.getDependencyFilesDeeply 及依赖发现辅助）---
+    /**
+     * 对每个 projectFile 执行 {@link getDependencyFilesDeeply}（DFS）：
+     * 完整构建自己（intern FileSigID）→ 递归拉入 import/export 依赖 → 全部依赖
+     * 完成后 setFile。**setFile 后序 = 严格拓扑序**（被依赖者在前），由 Scene 的
+     * builtFileOrder 记录，推断期按其正序遍历即零排序。
+     */
+    buildProjectFiles() {
+        var _a, _b, _c;
+        (_a = this.scene.getStageStatisticsCollector()) === null || _a === void 0 ? void 0 : _a.startStage(StageStatistics_1.StageName.BuilderFiles);
+        for (const projectFile of this.sceneConfig.getProjectFiles()) {
+            this.getDependencyFilesDeeply(projectFile);
+            (_b = this.scene.getStageStatisticsCollector()) === null || _b === void 0 ? void 0 : _b.recordMemoryCheckpoint();
+        }
+        (_c = this.scene.getStageStatisticsCollector()) === null || _c === void 0 ? void 0 : _c.endStage(StageStatistics_1.StageName.BuilderFiles);
+    }
+    getDependencyFilesDeeply(projectFile) {
+        var _a;
+        if (!this.scene.getOptions().supportFileExts.includes(path_1.default.extname(projectFile))) {
+            return;
+        }
+        // 范围守卫：只构建/递归项目目录内的文件。越界文件（tsconfig paths、ohpkg
+        // 外部链等解析出的绝对路径）不属本 Scene 的 project 文件——其
+        // FileSignature 将产生 "../../../xxx" 畸形相对名，且目录扫描原生语义
+        // 本就只覆盖项目目录。
+        const relativeToProject = path_1.default.relative(this.scene.getRealProjectDir(), projectFile);
+        if (relativeToProject.startsWith('..') || path_1.default.isAbsolute(relativeToProject)) {
+            return;
+        }
+        const fileSignature = new ArkSignature_1.FileSignature(this.scene.getProjectName(), relativeToProject);
+        const existingId = this.registry.fileSigCanonicalizer.getExistingId(fileSignature);
+        // 注意：早退基于全局 registry model（单 Scene 单次构建生命周期下 registry
+        // 内条目均属本次构建）。共享 registry 的二次构建为不支持场景——不做
+        // 场景归属判定适配；遇该场景的测试应自行 dispose 隔离。
+        if ((existingId !== -1 && this.registry.fileSigCanonicalizer.getModel(existingId) !== undefined) ||
+            this.isRepeatBuildFile(projectFile) ||
+            this.unhandledFilePaths.has(projectFile)) {
+            return;
+        }
+        // Here use unhandledFilePaths to temporarily store current file until add it to fileMaps to avoid recursively import issue.
+        this.unhandledFilePaths.add(projectFile);
+        try {
+            const arkFile = new ArkFile_1.ArkFile(FileUtils_1.FileUtils.getFileLanguage(projectFile, this.scene.getFileLanguages()));
+            arkFile.setScene(this.scene);
+            FrontendBuilder_1.FrontendBuilder.buildProjectFileIntoArkFile(this.scene, projectFile, arkFile);
+            if (arkFile.getLanguage() !== ArkFile_1.Language.CXX) {
+                // %dflt's builder is mounted on a node a re-parse cannot address by position, so
+                // build it now; the remaining builders are rebuilt per file in the body phase.
+                if ((_a = this.scene.getOptions().enableMethodBodyBuild) !== null && _a !== void 0 ? _a : true) {
+                    FrontendBuilder_1.FrontendBuilder.buildDefaultMethodBodies(arkFile);
+                }
+                FrontendBuilder_1.FrontendBuilder.freeBodyBuildersInFile(arkFile);
+            }
+            for (const [modulePath, moduleName] of this.scene.getModulePath2NameMap()) {
+                if (arkFile.getFilePath().startsWith(modulePath)) {
+                    this.addArkFile2ModuleScene(modulePath, moduleName, arkFile);
+                    break;
+                }
+            }
+            const importInfos = arkFile.getImportInfos();
+            const repeatFroms = [];
+            this.findDependencyFiles(importInfos, arkFile, repeatFroms);
+            const exportInfos = arkFile.getExportInfos();
+            this.findDependencyFiles(exportInfos, arkFile, repeatFroms);
+            // add currently file to files map after adding all its dependencies, and remove it from unhandledFilePaths
+            this.scene.setFile(arkFile);
+            this.unhandledFilePaths.delete(projectFile);
+        }
+        catch (error) {
+            logger.error('Error parsing file:', projectFile, error);
+            return;
+        }
+    }
+    isRepeatBuildFile(projectFile) {
+        const relativePath = path_1.default.relative(this.scene.getRealProjectDir(), projectFile);
+        if (!relativePath.startsWith('..') && !path_1.default.isAbsolute(relativePath)) {
+            const fileSig = new ArkSignature_1.FileSignature(this.scene.getProjectName(), relativePath);
+            const id = this.registry.fileSigCanonicalizer.getExistingId(fileSig);
+            return id !== -1 && this.registry.fileSigCanonicalizer.getModel(id) !== undefined;
+        }
+        return false;
+    }
+    addArkFile2ModuleScene(modulePath, moduleName, arkFile) {
+        const moduleScenesMap = this.scene.getModuleSceneMap();
+        if (moduleScenesMap.has(moduleName)) {
+            let curModuleScene = moduleScenesMap.get(moduleName);
+            if (curModuleScene) {
+                curModuleScene.addArkFile(arkFile);
+                arkFile.setModuleScene(curModuleScene);
+            }
+        }
+        else {
+            let moduleScene = new ModuleScene_1.ModuleScene(this.scene);
+            moduleScene.ModuleScenePartiallyBuilder(moduleName, modulePath);
+            moduleScene.addArkFile(arkFile);
+            moduleScenesMap.set(moduleName, moduleScene);
+            arkFile.setModuleScene(moduleScene);
+        }
+    }
+    findDependencyFiles(importOrExportInfos, arkFile, repeatFroms) {
+        for (const importOrExportInfo of importOrExportInfos) {
+            const from = importOrExportInfo.getFrom();
+            if (from && !repeatFroms.includes(from)) {
+                this.parseFrom(from, arkFile);
+                repeatFroms.push(from);
+            }
+        }
+    }
+    parseFrom(from, arkFile) {
+        // from 解析缓存（性能优化，行为等价）：相同 (上下文, from) 的定位链
+        // （全量 ohPkgContentMap 遍历 + existsSync + 目录枚举 + 可能的 JSON5
+        // 读盘）只执行一次，重复 from 以 O(1) Map 查找复用解析结果。键设计
+        // 对齐 getOriginPath 的语义（相对 from 依赖声明文件目录，模块名形式
+        // 全项目一致）——勿改动该判定正则。命中后必须逐个经
+        // getDependencyFilesDeeply 重新仲裁（不缓存构建决策，防 disposeModule
+        // 等状态变化下静默丢构建）。
+        const isRelative = /^\.{1,2}\//.test(from);
+        const cacheKey = isRelative ? path_1.default.dirname(arkFile.getFilePath()) + '\x00' + from : from;
+        const cached = this.fromResolutionCache.get(cacheKey);
+        if (cached) {
+            for (const resolvedPath of cached) {
+                this.getDependencyFilesDeeply(resolvedPath);
+            }
+            return;
+        }
+        const resolvedPaths = [];
+        this.fromResolutionStack.push(resolvedPaths);
+        try {
+            // —— 以下为原有三分支逻辑，逐字保留，不做任何修改 ——
+            if (/^@[a-z|\-]+?\/?/.test(from) || /^[a-z][a-z0-9._-]*[a-z0-9]$/.test(from)) {
+                // TODO: if there are more than one modules with the same name e.g. @lib1, here may got the wrong dependency
+                // It is better to loop all oh pkg with priority rather than the map key order. But it should be very complicated.
+                // Currently it is ok because it's with low probability and order error only affects type accuracy but has no other impact.
+                for (const [ohPkgContentPath, ohPkgContent] of this.ohPkgContentMap) {
+                    this.findDependenciesByOhPkg(ohPkgContentPath, ohPkgContent, from);
+                }
+            }
+            else if (/^([^@]*\/)([^\/]*)$/.test(from) || /^[\.\./|\.\.]+$/.test(from)) {
+                this.findRelativeDependenciesByOhPkg(from, arkFile);
+            }
+            else if (/^[@a-zA-Z0-9]+(\/[a-zA-Z0-9]+)*$/.test(from)) {
+                this.findDependenciesByTsConfig(from);
+            }
+            // —— 原有逻辑结束 ——
+        }
+        finally {
+            this.fromResolutionStack.pop();
+        }
+        this.fromResolutionCache.set(cacheKey, resolvedPaths);
+    }
+    findDependenciesByTsConfig(from) {
+        if (this.globalModule2PathMapping) {
+            const paths = this.globalModule2PathMapping;
+            Object.keys(paths).forEach(key => this.parseTsConfigParms(paths, key, from));
+        }
+    }
+    parseTsConfigParms(paths, key, from) {
+        const module2pathMapping = paths[key];
+        if (key.includes(TSConst_1.ALL)) {
+            this.processFuzzyMapping(key, from, module2pathMapping);
+        }
+        else if (from.startsWith(key)) {
+            let tail = from.substring(key.length, from.length);
+            module2pathMapping.forEach(pathMapping => {
+                let originPath = path_1.default.join(this.scene.getRealProjectDir(), pathMapping, tail);
+                if (this.baseUrl) {
+                    originPath = path_1.default.resolve(this.baseUrl, originPath);
+                }
+                this.findDependenciesByRule(originPath);
+            });
+        }
+    }
+    processFuzzyMapping(key, from, module2pathMapping) {
+        key = key.substring(0, key.indexOf(TSConst_1.ALL) - 1);
+        if (from.substring(0, key.indexOf(TSConst_1.ALL) - 1) === key) {
+            let tail = from.substring(key.indexOf(TSConst_1.ALL) - 1, from.length);
+            module2pathMapping.forEach(pathMapping => {
+                pathMapping = pathMapping.substring(0, pathMapping.indexOf(TSConst_1.ALL) - 1);
+                let originPath = path_1.default.join(this.scene.getRealProjectDir(), pathMapping, tail);
+                if (this.baseUrl) {
+                    originPath = path_1.default.join(this.baseUrl, originPath);
+                }
+                this.findDependenciesByRule(originPath);
+            });
+        }
+    }
+    findDependenciesByRule(originPath) {
+        if (!this.findFilesByPathArray(originPath) && !this.findFilesByExtNameArray(originPath, this.scene.getOptions().supportFileExts)) {
+            logger.trace(originPath + 'module mapperInfo is not found!');
+        }
+    }
+    findFilesByPathArray(originPath) {
+        if (!fs_1.default.existsSync(originPath)) {
+            return false;
+        }
+        const dirname = path_1.default.dirname(originPath);
+        const indexFileName = FileUtils_1.FileUtils.getIndexFileName(dirname);
+        if (indexFileName === '') {
+            return false;
+        }
+        const curPath = path_1.default.join(dirname, indexFileName);
+        if (!this.isRepeatBuildFile(curPath)) {
+            this.addFileNode2DependencyGrap(curPath);
+            return true;
+        }
+        return false;
+    }
+    findFilesByExtNameArray(originPath, pathArray) {
+        for (const pathInfo of pathArray) {
+            const curPath = originPath + pathInfo;
+            if (fs_1.default.existsSync(curPath) && !this.isRepeatBuildFile(curPath)) {
+                this.addFileNode2DependencyGrap(curPath);
+                return true;
+            }
+        }
+        return false;
+    }
+    findRelativeDependenciesByOhPkg(from, arkFile) {
+        //relative path ../from  ./from
+        //order
+        //1. ../from/oh-package.json5 -> [[name]] -> overRides/overRideDependencyMap? ->
+        //[[main]] -> file path ->dependencies(priority)+devDependencies? dynamicDependencies(not support) ->
+        //key overRides/overRideDependencyMap?
+        //2. ../from/index.ets(ts)
+        //3. ../from/index.d.ets(ts)
+        //4. ../from.ets(ts)
+        //5. ../from.d.ets(ts)
+        //2.3.4.5 random order
+        let originPath = this.getOriginPath(from, arkFile);
+        if (fs_1.default.existsSync(path_1.default.join(originPath, EtsConst_1.OH_PACKAGE_JSON5))) {
+            for (const [ohPkgContentPath, ohPkgContent] of this.ohPkgContentMap) {
+                this.findDependenciesByOhPkg(ohPkgContentPath, ohPkgContent, from);
+            }
+        }
+        this.findDependenciesByRule(originPath);
+    }
+    findDependenciesByOhPkg(ohPkgContentPath, ohPkgContentInfo, from) {
+        //module name @ohos/from
+        const ohPkgContent = ohPkgContentInfo;
+        //module main name is must be
+        if (ohPkgContent && ohPkgContent.name && from.startsWith(ohPkgContent.name.toString())) {
+            let originPath = ohPkgContentPath.toString().replace(EtsConst_1.OH_PACKAGE_JSON5, '');
+            if (ohPkgContent.main) {
+                originPath = path_1.default.join(ohPkgContentPath.toString().replace(EtsConst_1.OH_PACKAGE_JSON5, ''), ohPkgContent.main.toString());
+                if (ohPkgContent.dependencies) {
+                    this.getDependenciesMapping(ohPkgContent.dependencies, ohPkgContentPath, from);
+                }
+                else if (ohPkgContent.devDependencies) {
+                    this.getDependenciesMapping(ohPkgContent.devDependencies, ohPkgContentPath, from);
+                }
+                else if (ohPkgContent.dynamicDependencies) {
+                    // dynamicDependencies not support
+                }
+                this.addFileNode2DependencyGrap(originPath);
+            }
+            if (!this.findFilesByPathArray(originPath)) {
+                logger.trace(originPath + 'module mapperInfo is not found!');
+            }
+        }
+    }
+    getDependenciesMapping(dependencies, ohPkgContentPath, from) {
+        for (let [moduleName, modulePath] of Object.entries(dependencies)) {
+            logger.debug('dependencies:' + moduleName);
+            if (modulePath.startsWith('file:')) {
+                modulePath = modulePath.replace(/^file:/, '');
+            }
+            const innerOhpackagePath = path_1.default.join(ohPkgContentPath.replace(EtsConst_1.OH_PACKAGE_JSON5, ''), modulePath.toString(), EtsConst_1.OH_PACKAGE_JSON5);
+            if (!this.ohPkgContentMap.has(innerOhpackagePath)) {
+                // inner oh-package 内容缓存（同步读盘 + JSON5 解析只做一次）。
+                // 特意不写回 ohPkgContentMap——parseFrom/findRelativeDependenciesByOhPkg
+                // 正在 for...of 遍历它，遍历中插入 key 会改变迭代行为；独立 Map 零风险。
+                let innerModuleOhPkgContent = this.resolvedOhPkgCache.get(innerOhpackagePath);
+                if (!innerModuleOhPkgContent) {
+                    innerModuleOhPkgContent = (0, json5parser_1.fetchDependenciesFromFile)(innerOhpackagePath);
+                    this.resolvedOhPkgCache.set(innerOhpackagePath, innerModuleOhPkgContent);
+                }
+                this.findDependenciesByOhPkg(innerOhpackagePath, innerModuleOhPkgContent, from);
+            }
+        }
+    }
+    getOriginPath(from, arkFile) {
+        const parentPath = /^\.{1,2}\//.test(from) ? path_1.default.dirname(arkFile.getFilePath()) : arkFile.getProjectDir();
+        return path_1.default.resolve(parentPath, from);
+    }
+    addFileNode2DependencyGrap(filePath) {
+        // 汇点收集：三个解析产出路径（findFilesByPathArray / findFilesByExtNameArray /
+        // findDependenciesByOhPkg）都经过本方法——当前 parseFrom 槽（若在解析中）
+        // 记录产出供缓存条目。getDependencyFilesDeeply 照常执行（构建决策与
+        // 缓存收集正交，命中路径在 parseFrom 内直接调用它）。
+        const current = this.fromResolutionStack[this.fromResolutionStack.length - 1];
+        if (current) {
+            current.push(filePath);
+        }
+        this.getDependencyFilesDeeply(filePath);
+    }
+    // --- SDK 构建族（原 Scene.buildBasicInfo 的 SDK 段 + buildSdk 族，P3 迁移）---
+    /**
+     * SDK 阶段：注册/构建全部 SDK 源、SDK 推断 + global API 合并、记录语言表、extendArkUI、标记 project/SDK ID 边界。
+     * 顺序语义：fileLanguages 在 SDK 构建之后才生效。
+     */
+    buildSdkStage() {
+        var _a, _b, _c, _d, _e, _f, _g;
+        (_a = this.scene.getStageStatisticsCollector()) === null || _a === void 0 ? void 0 : _a.startStage(StageStatistics_1.StageName.BuilderSdk);
+        const scene = this.scene;
+        const sceneConfig = this.sceneConfig;
+        // 子阶段 1：SDK 源文件注册构建（逐文件解析 + 注册 formal 空间）。
+        (_b = this.scene.getStageStatisticsCollector()) === null || _b === void 0 ? void 0 : _b.startStage(StageStatistics_1.StageName.BuilderSdkFiles);
+        // handle sdks
+        if (scene.getOptions().enableBuiltIn && !sceneConfig.getSdksObj().find(sdk => sdk.name === SdkUtils_1.SdkUtils.BUILT_IN_NAME)) {
+            sceneConfig.getSdksObj().unshift(SdkUtils_1.SdkUtils.getBuiltInSdk());
+        }
+        (_c = sceneConfig.getSdksObj()) === null || _c === void 0 ? void 0 : _c.forEach(sdk => {
+            if (!sdk.moduleName) {
+                this.buildSdk(sdk.name, path_1.default.normalize(sdk.path), sdk.name !== SdkUtils_1.SdkUtils.BUILT_IN_NAME);
+                scene.getProjectSdkMap().set(sdk.name, sdk);
+            }
+            else {
+                let moduleSdks = scene.getModuleSdkMap().get(sdk.moduleName);
+                if (moduleSdks) {
+                    moduleSdks.push(sdk);
+                }
+                else {
+                    scene.getModuleSdkMap().set(sdk.moduleName, [sdk]);
+                }
+            }
+        });
+        (_d = this.scene.getStageStatisticsCollector()) === null || _d === void 0 ? void 0 : _d.endStage(StageStatistics_1.StageName.BuilderSdkFiles);
+        // 子阶段 2：SDK 类型推导与 global API 合并。
+        (_e = this.scene.getStageStatisticsCollector()) === null || _e === void 0 ? void 0 : _e.startStage(StageStatistics_1.StageName.BuilderSdkInfer);
+        if (scene.getBuildStage() < SceneBuildStage_1.SceneBuildStage.SDK_INFERRED) {
+            this.registry.fileSigCanonicalizer
+                .getModels()
+                .filter(f => !f.isProjectFile())
+                .forEach(file => {
+                // CXXTodo: C++ does not handle SDK files.
+                if (file.getLanguage() === ArkFile_1.Language.CXX) {
+                    return;
+                }
+                Inference_1.InferenceManager.getInstance().getInference(file.getLanguage()).doInfer(file);
+                SdkUtils_1.SdkUtils.mergeGlobalAPI(file, SignatureCanonicalizerRegistry_1.SignatureCanonicalizerRegistry.getInstance().sdkGlobalMap);
+            });
+            this.registry.fileSigCanonicalizer
+                .getModels()
+                .filter(f => !f.isProjectFile())
+                .forEach(file => {
+                SdkUtils_1.SdkUtils.postInferredSdk(file, SignatureCanonicalizerRegistry_1.SignatureCanonicalizerRegistry.getInstance().sdkGlobalMap);
+            });
+            scene.setBuildStage(SceneBuildStage_1.SceneBuildStage.SDK_INFERRED);
+        }
+        (_f = this.scene.getStageStatisticsCollector()) === null || _f === void 0 ? void 0 : _f.endStage(StageStatistics_1.StageName.BuilderSdkInfer);
+        scene.setFileLanguages(sceneConfig.getFileLanguages());
+        SdkUtils_1.SdkUtils.extendArkUI(scene);
+        // SDK 阶段结束：标记 project/SDK FileSigID 边界，此后注册的文件均为 project 文件。
+        this.registry.markProjectFileBoundary();
+        (_g = this.scene.getStageStatisticsCollector()) === null || _g === void 0 ? void 0 : _g.endStage(StageStatistics_1.StageName.BuilderSdk);
+    }
+    /**
+     * Loads SDK sources into the scene. C++ SDK files are intentionally skipped: they are not parsed or registered
+     * here (only non-C++ SDK sources are processed).
+     *
+     * When {@link createDefaultConstructor} is set, default constructors are ensured for every
+     * class registered by this SDK batch right here — before the SDK/project ID boundary is
+     * marked — so their method formal IDs stay on the SDK side of the (future class/method-level)
+     * boundary invariant. The built-in lib (var-side XxxConstructor pattern + interface-only
+     * classes) is excluded by the caller for that reason; library classes must NOT receive
+     * models after the boundary (the project-stage batch pass keeps the isLibraryClass guard).
+     */
+    buildSdk(sdkName, sdkPath, createDefaultConstructor) {
+        const classIdBefore = this.registry.classSigCanonicalizer.size();
+        const allFiles = this.collectSdkFiles(sdkName, sdkPath);
+        allFiles.forEach(file => {
+            if (FileUtils_1.FileUtils.getFileLanguage(file, this.scene.getFileLanguages()) === ArkFile_1.Language.CXX) {
+                return;
+            }
+            this.parseAndRegisterSdkFile(file, sdkPath, sdkName);
+        });
+        if (createDefaultConstructor) {
+            const size = this.registry.classSigCanonicalizer.size();
+            for (let id = classIdBefore; id < size; id++) {
+                const cls = this.registry.classSigCanonicalizer.getModel(id);
+                if (cls) {
+                    (0, ArkMethodBuilder_1.ensureDefaultConstructor)(cls);
+                }
+            }
+        }
+    }
+    collectSdkFiles(sdkName, sdkPath) {
+        var _a;
+        if (sdkName === SdkUtils_1.SdkUtils.BUILT_IN_NAME) {
+            const builtInFiles = SdkUtils_1.SdkUtils.fetchBuiltInFiles(sdkPath);
+            if (builtInFiles.length > 0) {
+                (_a = this.scene.getOptions().sdkGlobalFolders) === null || _a === void 0 ? void 0 : _a.push(sdkPath);
+            }
+            return builtInFiles;
+        }
+        SdkUtils_1.SdkUtils.loadSystemComponentsFromSdk(sdkPath);
+        return (0, getAllFiles_1.getAllFiles)(sdkPath, this.scene.getOptions().supportFileExts, this.scene.getOptions().ignoreFileNames);
+    }
+    parseAndRegisterSdkFile(file, sdkPath, sdkName) {
+        var _a, _b;
+        logger.trace('=== parse sdk file:', file);
+        try {
+            const arkFile = new ArkFile_1.ArkFile(FileUtils_1.FileUtils.getFileLanguage(file, this.scene.getFileLanguages()));
+            arkFile.setScene(this.scene);
+            ArktsFrontend_1.ArktsFrontend.buildArkFileFromSdkPath(file, sdkPath, arkFile, sdkName);
+            const allClasses = ModelUtils_1.ModelUtils.getAllClassesInFile(arkFile);
+            for (let i = 0; i < allClasses.length; i++) {
+                const cls = allClasses[i];
+                (_a = cls.getDefaultArkMethod()) === null || _a === void 0 ? void 0 : _a.buildBody();
+                (_b = cls.getDefaultArkMethod()) === null || _b === void 0 ? void 0 : _b.freeBodyBuilder();
+            }
+            // Release all method builders in SDK file to avoid retaining AST/build context in memory.
+            ModelUtils_1.ModelUtils.getAllMethodsInFile(arkFile).forEach(method => {
+                var _a;
+                if (((_a = method.getDeclaringArkFile()) === null || _a === void 0 ? void 0 : _a.getLanguage()) === ArkFile_1.Language.CXX) {
+                    method.freeCxxBodyBuilder();
+                }
+                else {
+                    method.freeBodyBuilder();
+                }
+            });
+            arkFile.setProjectFile(false);
+            SdkUtils_1.SdkUtils.buildSdkImportMap(arkFile);
+            SdkUtils_1.SdkUtils.loadGlobalAPI(arkFile, SignatureCanonicalizerRegistry_1.SignatureCanonicalizerRegistry.getInstance().sdkGlobalMap);
+        }
+        catch (error) {
+            logger.error('Error parsing file:', file, error);
+            this.scene.getUnhandledSdkFilePaths().push(file);
+        }
+    }
+    // --- body 构建族（原 Scene.buildAllMethodBody 族，P3 迁移）---
+    /**
+     * 方法体构建段（原 genArkFiles 尾段）：enableMethodBodyBuild 分支——
+     * 全量 buildBody + 默认构造器补全，或仅释放 builder。
+     */
+    buildAllMethodBodies() {
+        var _a, _b, _c;
+        (_a = this.scene.getStageStatisticsCollector()) === null || _a === void 0 ? void 0 : _a.startStage(StageStatistics_1.StageName.BuilderBodies);
+        if ((_b = this.scene.getOptions().enableMethodBodyBuild) !== null && _b !== void 0 ? _b : true) {
+            this.buildAllMethodBody();
+            this.updateOrAddDefaultConstructors();
+        }
+        else {
+            this.freeAllBodyBuilders();
+            ModelUtils_1.ModelUtils.dispose();
+            this.scene.setBuildStage(SceneBuildStage_1.SceneBuildStage.METHOD_DONE);
+        }
+        (_c = this.scene.getStageStatisticsCollector()) === null || _c === void 0 ? void 0 : _c.endStage(StageStatistics_1.StageName.BuilderBodies);
+    }
+    /**
+     * Update or add default constructors for all classes in the scene.
+     */
+    updateOrAddDefaultConstructors() {
+        // 直接遍历 getClasses()（registry 平面遍历，project 类全量），语言判定随之
+        // 移到类级别（类可能来自不同语言的文件）。顺序从结构序变为 classSigID 升序。
+        for (const cls of this.scene.getClasses()) {
+            // CXXTodo: Select the appropriate initialization function based on file type
+            const initInConstructorFn = cls.getDeclaringArkFile().getLanguage() === ArkFile_1.Language.CXX ? ArkMethodBuilder_2.addInitInConstructor : ArkMethodBuilder_1.addInitInConstructor;
+            (0, ArkMethodBuilder_1.buildDefaultConstructor)(cls);
+            // CXXTodo: Use the interface 'getAllMethodsWithName' for obtaining all methods with the same name.
+            const constructors = cls.getAllMethodsWithName(TSConst_1.CONSTRUCTOR_NAME);
+            if (cls.isDefaultArkClass()) {
+                continue;
+            }
+            constructors.forEach(constructor => {
+                (0, ArkMethodBuilder_1.replaceSuper2Constructor)(constructor);
+                initInConstructorFn(constructor);
+            });
+        }
+    }
+    /**
+     * 遍历全部 project 文件的 ArkMethod（不含 SDK 方法），逐个回调处理。
+     *
+     * 直接平面遍历 methodSigCanonicalizer（registry 为事实源），过滤规则：
+     * ① getModel(id) 为 undefined 跳过——declare-only 方法（无 model）及
+     *    BodyBuilder/JsonSerialization 重签名产生的无 model 条目；
+     * ② 非 project 文件跳过（SDK 文件，按 file 的 projectFile 标志判定）；
+     * ③ !enableOhModulesBody 时，oh_modules 文件仅保留 defaultArkMethod。
+     * 处理顺序为 methodSigID 升序（buildBody 逐方法独立、无序敏感）。
+     */
+    forEachProjectMethod(callback) {
+        const size = this.registry.methodSigCanonicalizer.size();
+        for (let id = 1; id < size; id++) {
+            const method = this.registry.methodSigCanonicalizer.getModel(id);
+            if (method === undefined) {
+                continue;
+            }
+            const file = method.getDeclaringArkFile();
+            if (!file.isProjectFile()) {
+                continue;
+            }
+            if (!this.scene.getOptions().enableOhModulesBody && file.getName().includes(EtsConst_1.OH_MODULES)) {
+                if (method !== method.getDeclaringArkClass().getDefaultArkMethod()) {
+                    continue;
+                }
+            }
+            callback(method);
+        }
+    }
+    static freeMethodBodyBuilder(method) {
+        var _a;
+        const isCxxFile = ((_a = method.getDeclaringArkFile()) === null || _a === void 0 ? void 0 : _a.getLanguage()) === ArkFile_1.Language.CXX;
+        if (isCxxFile) {
+            method.freeCxxBodyBuilder();
+        }
+        else {
+            method.freeBodyBuilder();
+        }
+    }
+    buildAllMethodBody() {
+        var _a;
+        this.scene.setBuildStage(SceneBuildStage_1.SceneBuildStage.CLASS_DONE);
+        // C++ has no re-parse body path and keeps building from the signature round's builders.
+        this.forEachProjectMethod(method => {
+            var _a;
+            if (method.getDeclaringArkFile().getLanguage() !== ArkFile_1.Language.CXX) {
+                return;
+            }
+            try {
+                method.buildBody();
+                (_a = this.scene.getStageStatisticsCollector()) === null || _a === void 0 ? void 0 : _a.recordMemoryCheckpoint();
+            }
+            catch (error) {
+                logger.error('Error building body:', method.getSignature(), error);
+            }
+            finally {
+                SceneBuilder.freeMethodBodyBuilder(method);
+            }
+        });
+        // ArkTS/TS: rebuild each file's builders from a fresh parse so no file's AST outlives its
+        // own body build (the signature round released every builder it mounted).
+        for (const arkFile of this.scene.getFiles()) {
+            if (!arkFile.isProjectFile() || arkFile.getLanguage() === ArkFile_1.Language.CXX) {
+                continue;
+            }
+            if (!this.scene.getOptions().enableOhModulesBody && arkFile.getName().includes(EtsConst_1.OH_MODULES)) {
+                // OH module files contribute only their %dflt body, built with the signatures.
+                continue;
+            }
+            (0, FileBodyRemount_1.buildFileBodies)(arkFile);
+            (_a = this.scene.getStageStatisticsCollector()) === null || _a === void 0 ? void 0 : _a.recordMemoryCheckpoint();
+        }
+        ModelUtils_1.ModelUtils.dispose();
+        this.scene.setBuildStage(SceneBuildStage_1.SceneBuildStage.METHOD_DONE);
+    }
+    freeAllBodyBuilders() {
+        this.forEachProjectMethod(method => {
+            SceneBuilder.freeMethodBodyBuilder(method);
+        });
+    }
+    // --- harmony 模块构建族（原 Scene.buildScene4HarmonyProject / buildModuleScene，P3 迁移）---
+    /**
+     * harmony 项目构建（原 buildScene4HarmonyProject 主体）：逐模块注册
+     * ModuleScene（先注册后构建，保证 DFS 归属正确）→ 模块文件 DFS → body 构建。
+     */
+    buildScene4HarmonyProject() {
+        this.scene.getModulePath2NameMap().forEach((value, key) => {
+            // 先注册（复用其他模块 DFS 依赖递归期可能已创建的 partial 实例）：
+            // 构建期 addArkFile2ModuleScene 依据 moduleScenesMap 归属文件，
+            // 注册必须先于 genArkFiles 的 DFS，否则文件会归属到被覆盖的孤儿实例。
+            let moduleScene = this.scene.getModuleSceneMap().get(value);
+            if (!moduleScene) {
+                moduleScene = new ModuleScene_1.ModuleScene(this.scene);
+                this.scene.getModuleSceneMap().set(value, moduleScene);
+            }
+            moduleScene.ModuleSceneBuilder(value, key, this.scene.getOptions().supportFileExts);
+        });
+        this.buildAllMethodBodies();
+    }
+    /**
+     * 单模块构建（原 buildModuleScene 主体，增量式入口）：ohpkg 依赖递归 + 模块
+     * DFS + body 构建。可能被连续调用构建多个模块——不释放构建上下文（释放交给
+     * clear / 完整构建入口）。
+     */
+    buildModuleScene(moduleName, modulePath, supportFileExts) {
+        const moduleScenesMap = this.scene.getModuleSceneMap();
+        if (moduleScenesMap.get(moduleName)) {
+            return;
+        }
+        // 先注册：构建期 addArkFile2ModuleScene 依据 moduleScenesMap 归属文件，
+        // 注册必须先于 ModuleSceneBuilder 内的 DFS；同时兼作 ohpkg 依赖环的递归终止
+        // （构建中即已注册，环上重入直接命中上方守卫）。
+        const moduleScene = new ModuleScene_1.ModuleScene(this.scene);
+        moduleScenesMap.set(moduleName, moduleScene);
+        // get oh-package.json5
+        const moduleOhPkgFilePath = path_1.default.resolve(this.scene.getRealProjectDir(), path_1.default.join(modulePath, EtsConst_1.OH_PACKAGE_JSON5));
+        if (fs_1.default.existsSync(moduleOhPkgFilePath)) {
+            const moduleOhPkgContent = (0, json5parser_1.fetchDependenciesFromFile)(moduleOhPkgFilePath);
+            this.addOhPkgContent(moduleOhPkgFilePath, moduleOhPkgContent);
+        }
+        else {
+            logger.warn('Module: ', moduleName, 'has no oh-package.json5.');
+        }
+        // parse moduleOhPkgContent, get dependencies and build dependent module
+        const moduleOhPkgContent = this.ohPkgContentMap.get(moduleOhPkgFilePath);
+        if (moduleOhPkgContent) {
+            if (moduleOhPkgContent.dependencies instanceof Object) {
+                this.processModuleOhPkgContent(moduleOhPkgContent.dependencies, moduleOhPkgFilePath, supportFileExts);
+            }
+        }
+        moduleScene.ModuleSceneBuilder(moduleName, modulePath, supportFileExts);
+        this.buildAllMethodBodies();
+    }
+    processModuleOhPkgContent(dependencies, moduleOhPkgFilePath, supportFileExts) {
+        Object.entries(dependencies).forEach(([k, v]) => {
+            const pattern = new RegExp('^(\\.\\.\\/|\\.\\/)');
+            if (typeof v === 'string') {
+                let dependencyModulePath = '';
+                if (pattern.test(v)) {
+                    dependencyModulePath = path_1.default.join(moduleOhPkgFilePath, v);
+                }
+                else if (v.startsWith('file:')) {
+                    const dependencyFilePath = path_1.default.join(moduleOhPkgFilePath, v.replace(/^file:/, ''));
+                    const dependencyOhPkgPath = (0, FileUtils_1.getFileRecursively)(path_1.default.dirname(dependencyFilePath), EtsConst_1.OH_PACKAGE_JSON5);
+                    dependencyModulePath = path_1.default.dirname(dependencyOhPkgPath);
+                }
+                const dependencyModuleName = this.scene.getModulePath2NameMap().get(dependencyModulePath);
+                if (dependencyModuleName) {
+                    this.buildModuleScene(dependencyModuleName, dependencyModulePath, supportFileExts);
+                }
+            }
+        });
+    }
+}
+exports.SceneBuilder = SceneBuilder;