arkanalyzer 1.0.90 → 1.0.91

package/lib/frontend/FrontendBuilder.d.ts

@@ -1,5 +1,8 @@
+import { Language } from '../core/model/ArkFile';
 import { ModuleScene, Scene } from '../Scene';
 import { ArkFile } from '../core/model/ArkFile';
+import { ArkModule } from '../core/model/ArkModule';
+import { ModuleDepthLevel } from './common/ModuleDepth';
 export interface FrontendParseFailure {
     filePath: string;
     reason: unknown;
@@ -22,5 +25,118 @@ export declare class FrontendBuilder {
      * Builds a single project file into a pre-allocated {@link ArkFile} (the former `if (CXX) … else …` in `Scene`).
      */
     static buildProjectFileIntoArkFile(scene: Scene, filePath: string, arkFile: ArkFile): void;
+    /**
+     * Build all source files of an {@link ArkModule} up to the given {@link ModuleDepthLevel}.
+     *
+     * Scans the module directory for source files using scene options
+     * (supportFileExts / ignoreFileNames), creates an {@link ArkFile} for each file, registers it
+     * with the module and scene, and builds it to the requested level. Errors on individual files
+     * are logged and do not abort the loop.
+     *
+     * @param scene - The owning {@link Scene}.
+     * @param module - The module whose files are built.
+     * @param level - The target depth level.
+     */
+    static buildModuleFilesToLevel(scene: Scene, module: ArkModule, level: ModuleDepthLevel): void;
+    /**
+     * Scan the module directory and create path-only {@link ArkFile} shells (no content parsed),
+     * registering each with the module and scene.
+     *
+     * Each shell has language, filePath, projectDir, and fileSignature set, but no ImportInfo /
+     * ExportInfo / ArkClass / ArkMethod. This is the META-level baseline; callers subsequently
+     * build content via {@link buildArkFileToLevel} (IMPORTS) or {@link upgradeArkFileToLevel}
+     * (SIGNATURES / BODIES).
+     *
+     * @param scene - The owning {@link Scene}.
+     * @param module - The module whose directory is scanned.
+     * @returns Array of created (and registered) ArkFile shells.
+     */
+    static createModuleFileShells(scene: Scene, module: ArkModule): ArkFile[];
+    /**
+     * Dispatch level-aware building to the appropriate frontend.
+     *
+     * - META: no content is built (only the ArkFile path/basic info created by the caller).
+     * - IMPORTS: lightweight import/export parsing only.
+     * - SIGNATURES: full namespace/class/method signatures are built (parameters, return types)
+     *   without method bodies, reusing {@link buildProjectFileIntoArkFile}. The mounted
+     *   BodyBuilders are released here so the ArkFile holds signatures only (no ArkBody/CFG).
+     * - BODIES: same as SIGNATURES but the mounted BodyBuilders are **retained** (not released)
+     *   so that {@link buildModuleMethodBody} can build method bodies in a subsequent phase.
+     */
+    private static buildArkFileToLevel;
+    /**
+     * IMPORTS level: lightweight import/export parsing only.
+     */
+    static buildImports(arkFile: ArkFile, language: Language): void;
+    /**
+     * Upgrade an existing ArkFile (whose ImportInfo/ExportInfo were already populated at IMPORTS
+     * level) to SIGNATURES or BODIES by building class/method/namespace signatures on top.
+     *
+     * For ArkTS files, this calls {@link ArktsFrontend.buildProjectFileForSignatures} which builds
+     * signatures with `skipImportExport = true`, preserving existing import/export data and
+     * avoiding duplication of `export *` re-export entries (whose temp clause keys are
+     * process-level auto-increment and cannot be overwritten by `Map.set`).
+     *
+     * For C++ files, {@link CppFrontend.buildProjectFile} is safe to re-call: C++ ImportInfo uses
+     * stable clause keys (`#include "..."` / namespace names) that are overwritten by `Map.set`,
+     * and C++ ExportInfo is not produced during the IMPORTS-only phase, so no duplication occurs.
+     *
+     * After signature building, BodyBuilders are released when the target level is SIGNATURES
+     * (no ArkBody/CFG retained). For BODIES, BodyBuilders are retained so that
+     * {@link buildModuleMethodBody} can build method bodies in a subsequent phase.
+     *
+     * @param scene - The owning {@link Scene}.
+     * @param arkFile - The ArkFile to upgrade (must already have ImportInfo/ExportInfo).
+     * @param language - The language of the file.
+     * @param targetLevel - The target depth level (must be > IMPORTS).
+     */
+    static upgradeArkFileToLevel(scene: Scene, arkFile: ArkFile, language: Language, targetLevel: ModuleDepthLevel): void;
+    /**
+     * Release the BodyBuilder (or CxxBodyBuilder) mounted on a method, freeing the AST/build
+     * context.
+     */
+    private static freeMethodBodyBuilder;
+    /**
+     * Release the BodyBuilders mounted during signature building so the ArkFile retains only
+     * signatures (no ArkBody/CFG) and does not retain AST/build context in memory. Mirrors the
+     * release pattern in {@link Scene.parseAndRegisterSdkFile}.
+     */
+    private static freeBodyBuildersInFile;
+    /**
+     * Build method bodies (ArkBody/CFG/Stmt/Expr) for all ArkFiles in the given module, then
+     * run default-constructor post-processing. This is the module-scoped equivalent of
+     * {@link Scene.buildAllMethodBody} + {@link Scene.updateOrAddDefaultConstructors}, following
+     * the same two-phase pattern as {@link Scene.genArkFiles}.
+     *
+     * Phase 1 (signatures + mounted BodyBuilders) is performed earlier by
+     * {@link buildModuleFilesToLevel} at {@link ModuleDepthLevel.BODIES}, which retains the
+     * mounted BodyBuilders. This method performs phase 2:
+     *
+     * 1. Set {@link Scene.buildStage} to {@link SceneBuildStage.CLASS_DONE} (opening the
+     *    {@link Scene.buildClassDone} gate) so that when BodyBuilder encounters nested/anonymous
+     *    methods during body construction, their {@link ArkMethod.setBodyBuilder} calls
+     *    immediately trigger {@link ArkMethod.buildBody} — recursively building nested method
+     *    bodies. The previous buildStage is restored afterwards so that subsequent SIGNATURES-
+     *    level module loading is unaffected.
+     * 2. Collect all methods in the module's files.
+     * 3. Call {@link ArkMethod.buildBody} on each (executes the retained BodyBuilder), then free
+     *    the BodyBuilder to release AST/build context.
+     * 4. Run {@link buildDefaultConstructor} / {@link replaceSuper2Constructor} /
+     *    {@link addInitInConstructor} on the module's files (gate still open).
+     *
+     * Calls {@link ModelUtils.dispose} after each module's method bodies are built to release
+     * global caches (implicitArkUIBuilderMethods, popMethodSignatureCache) that accumulate during
+     * body building.
+     *
+     * @param module - The module whose files' method bodies are to be built.
+     */
+    static buildModuleMethodBody(module: ArkModule): void;
+    /**
+     * Run {@link buildDefaultConstructor} / {@link replaceSuper2Constructor} /
+     * {@link addInitInConstructor} on all classes in a file. These create/modify constructors;
+     * {@link buildDefaultConstructor} builds bodies directly (without BodyBuilder), and the
+     * other two only modify already-built bodies.
+     */
+    private static processDefaultConstructors;
 }
 //# sourceMappingURL=FrontendBuilder.d.ts.map

package/lib/frontend/FrontendBuilder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FrontendBuilder.d.ts","sourceRoot":"","sources":["../../src/frontend/FrontendBuilder.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAG9C,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAMhD,MAAM,WAAW,oBAAoB;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,mBAAmB;IAChC,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,WAAW,EAAE,oBAAoB,EAAE,CAAC;CACvC;AAED;;;;GAIG;AACH,qBAAa,eAAe;IACxB,OAAO,CAAC,MAAM,CAAC,kBAAkB;IAajC,OAAO,CAAC,MAAM,CAAC,sBAAsB;WAOvB,sBAAsB,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,IAAI;WAW/D,4BAA4B,CAAC,WAAW,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,IAAI;IAe/F;;OAEG;WACW,2BAA2B,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI;CAOpG"}
+{"version":3,"file":"FrontendBuilder.d.ts","sourceRoot":"","sources":["../../src/frontend/FrontendBuilder.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACjD,OAAO,EAAE,WAAW,EAAE,KAAK,EAAmB,MAAM,UAAU,CAAC;AAG/D,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAChD,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAOpD,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAQxD,MAAM,WAAW,oBAAoB;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,mBAAmB;IAChC,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,WAAW,EAAE,oBAAoB,EAAE,CAAC;CACvC;AAED;;;;GAIG;AACH,qBAAa,eAAe;IACxB,OAAO,CAAC,MAAM,CAAC,kBAAkB;IAajC,OAAO,CAAC,MAAM,CAAC,sBAAsB;WAOvB,sBAAsB,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,IAAI;WAW/D,4BAA4B,CAAC,WAAW,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,IAAI;IAe/F;;OAEG;WACW,2BAA2B,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI;IAQjG;;;;;;;;;;;OAWG;WACW,uBAAuB,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,gBAAgB,GAAG,IAAI;IAWrG;;;;;;;;;;;;OAYG;WACW,sBAAsB,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,GAAG,OAAO,EAAE;IA+BhF;;;;;;;;;;OAUG;IACH,OAAO,CAAC,MAAM,CAAC,mBAAmB;IAkBlC;;OAEG;WACW,YAAY,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAQ,GAAG,IAAI;IAQtE;;;;;;;;;;;;;;;;;;;;;OAqBG;WACW,qBAAqB,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,WAAW,EAAE,gBAAgB,GAAG,IAAI;IAW5H;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,qBAAqB;IASpC;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,sBAAsB;IAMrC;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;WACW,qBAAqB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI;IA8B5D;;;;;OAKG;IACH,OAAO,CAAC,MAAM,CAAC,0BAA0B;CAc5C"}

package/lib/frontend/FrontendBuilder.js

@@ -36,13 +36,27 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __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.FrontendBuilder = void 0;
+const path_1 = __importDefault(require("path"));
 const ArkFile_1 = require("../core/model/ArkFile");
+const Scene_1 = require("../Scene");
 const ArktsFrontend_1 = require("./arktsFrontend/ArktsFrontend");
 const CppFrontend_1 = require("./cppFrontend/CppFrontend");
+const ArkFile_2 = require("../core/model/ArkFile");
+const ArkSignature_1 = require("../core/model/ArkSignature");
+const ModelUtils_1 = require("../core/common/ModelUtils");
 const FileUtils_1 = require("../utils/FileUtils");
+const getAllFiles_1 = require("../utils/getAllFiles");
 const logger_1 = __importStar(require("../utils/logger"));
+const ModuleDepth_1 = require("./common/ModuleDepth");
+const ArkMethodBuilder_1 = require("../core/model/builder/ArkMethodBuilder");
+const ArkMethodBuilder_2 = require("./cppFrontend/model/builder/ArkMethodBuilder");
+const TSConst_1 = require("../core/common/TSConst");
+const EtsConst_1 = require("../core/common/EtsConst");
 const logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'FrontendBuilder');
 /**
  * Dispatches language front-ends and exposes a single build entry for {@link Scene} so the scene no longer
@@ -104,5 +118,247 @@ class FrontendBuilder {
             new ArktsFrontend_1.ArktsFrontend().buildProjectFile(scene, filePath, arkFile);
         }
     }
+    /**
+     * Build all source files of an {@link ArkModule} up to the given {@link ModuleDepthLevel}.
+     *
+     * Scans the module directory for source files using scene options
+     * (supportFileExts / ignoreFileNames), creates an {@link ArkFile} for each file, registers it
+     * with the module and scene, and builds it to the requested level. Errors on individual files
+     * are logged and do not abort the loop.
+     *
+     * @param scene - The owning {@link Scene}.
+     * @param module - The module whose files are built.
+     * @param level - The target depth level.
+     */
+    static buildModuleFilesToLevel(scene, module, level) {
+        const arkFiles = FrontendBuilder.createModuleFileShells(scene, module);
+        for (const arkFile of arkFiles) {
+            try {
+                FrontendBuilder.buildArkFileToLevel(scene, arkFile.getFilePath(), arkFile, arkFile.getLanguage(), level);
+            }
+            catch (error) {
+                logger.error(`Error building ArkFile for ${arkFile.getFilePath()}: ${error}`);
+            }
+        }
+    }
+    /**
+     * Scan the module directory and create path-only {@link ArkFile} shells (no content parsed),
+     * registering each with the module and scene.
+     *
+     * Each shell has language, filePath, projectDir, and fileSignature set, but no ImportInfo /
+     * ExportInfo / ArkClass / ArkMethod. This is the META-level baseline; callers subsequently
+     * build content via {@link buildArkFileToLevel} (IMPORTS) or {@link upgradeArkFileToLevel}
+     * (SIGNATURES / BODIES).
+     *
+     * @param scene - The owning {@link Scene}.
+     * @param module - The module whose directory is scanned.
+     * @returns Array of created (and registered) ArkFile shells.
+     */
+    static createModuleFileShells(scene, module) {
+        var _a, _b;
+        const modulePath = module.getModulePath();
+        const options = scene.getOptions();
+        const supportFileExts = (_a = options === null || options === void 0 ? void 0 : options.supportFileExts) !== null && _a !== void 0 ? _a : ['.ets', '.ts'];
+        // Always skip 'oh_modules' subdirectories within a module to avoid duplicate scanning
+        // via symlinks: oh_modules packages are registered as separate modules by
+        // registerOhModulesModules (which uses fs.readdirSync directly, not getAllFiles).
+        const ignoreFileNames = [...((_b = options === null || options === void 0 ? void 0 : options.ignoreFileNames) !== null && _b !== void 0 ? _b : []), EtsConst_1.OH_MODULES];
+        const filePaths = (0, getAllFiles_1.getAllFiles)(modulePath, supportFileExts, ignoreFileNames);
+        const arkFiles = [];
+        for (const filePath of filePaths) {
+            try {
+                const language = FileUtils_1.FileUtils.getFileLanguage(filePath, scene.getFileLanguages());
+                const arkFile = new ArkFile_2.ArkFile(language);
+                arkFile.setScene(scene);
+                arkFile.setFilePath(filePath);
+                arkFile.setProjectDir(scene.getRealProjectDir());
+                const fileSignature = new ArkSignature_1.FileSignature(scene.getProjectName(), path_1.default.relative(scene.getRealProjectDir(), filePath));
+                arkFile.setFileSignature(fileSignature);
+                module.addFile(arkFile);
+                arkFile.setArkModule(module);
+                scene.setFile(arkFile);
+                arkFiles.push(arkFile);
+            }
+            catch (error) {
+                logger.error(`Error creating ArkFile shell for ${filePath}: ${error}`);
+            }
+        }
+        return arkFiles;
+    }
+    /**
+     * Dispatch level-aware building to the appropriate frontend.
+     *
+     * - META: no content is built (only the ArkFile path/basic info created by the caller).
+     * - IMPORTS: lightweight import/export parsing only.
+     * - SIGNATURES: full namespace/class/method signatures are built (parameters, return types)
+     *   without method bodies, reusing {@link buildProjectFileIntoArkFile}. The mounted
+     *   BodyBuilders are released here so the ArkFile holds signatures only (no ArkBody/CFG).
+     * - BODIES: same as SIGNATURES but the mounted BodyBuilders are **retained** (not released)
+     *   so that {@link buildModuleMethodBody} can build method bodies in a subsequent phase.
+     */
+    static buildArkFileToLevel(scene, filePath, arkFile, language, level) {
+        if (level <= ModuleDepth_1.ModuleDepthLevel.META) {
+            return;
+        }
+        if (level === ModuleDepth_1.ModuleDepthLevel.IMPORTS) {
+            FrontendBuilder.buildImports(arkFile, language);
+            return;
+        }
+        // SIGNATURES and BODIES: reuse the full file builder to build signatures and mount
+        // BodyBuilders on each method implementation.
+        FrontendBuilder.buildProjectFileIntoArkFile(scene, filePath, arkFile);
+        if (level < ModuleDepth_1.ModuleDepthLevel.BODIES) {
+            // SIGNATURES: release BodyBuilders so only signatures remain (no ArkBody/CFG).
+            FrontendBuilder.freeBodyBuildersInFile(arkFile);
+        }
+        // BODIES: keep BodyBuilders mounted for phase 2 (body building in buildModuleMethodBody).
+    }
+    /**
+     * IMPORTS level: lightweight import/export parsing only.
+     */
+    static buildImports(arkFile, language) {
+        if (language === ArkFile_1.Language.CXX) {
+            new CppFrontend_1.CppFrontend().buildProjectFileForImports(arkFile);
+        }
+        else {
+            new ArktsFrontend_1.ArktsFrontend().buildProjectFileForImports(arkFile);
+        }
+    }
+    /**
+     * Upgrade an existing ArkFile (whose ImportInfo/ExportInfo were already populated at IMPORTS
+     * level) to SIGNATURES or BODIES by building class/method/namespace signatures on top.
+     *
+     * For ArkTS files, this calls {@link ArktsFrontend.buildProjectFileForSignatures} which builds
+     * signatures with `skipImportExport = true`, preserving existing import/export data and
+     * avoiding duplication of `export *` re-export entries (whose temp clause keys are
+     * process-level auto-increment and cannot be overwritten by `Map.set`).
+     *
+     * For C++ files, {@link CppFrontend.buildProjectFile} is safe to re-call: C++ ImportInfo uses
+     * stable clause keys (`#include "..."` / namespace names) that are overwritten by `Map.set`,
+     * and C++ ExportInfo is not produced during the IMPORTS-only phase, so no duplication occurs.
+     *
+     * After signature building, BodyBuilders are released when the target level is SIGNATURES
+     * (no ArkBody/CFG retained). For BODIES, BodyBuilders are retained so that
+     * {@link buildModuleMethodBody} can build method bodies in a subsequent phase.
+     *
+     * @param scene - The owning {@link Scene}.
+     * @param arkFile - The ArkFile to upgrade (must already have ImportInfo/ExportInfo).
+     * @param language - The language of the file.
+     * @param targetLevel - The target depth level (must be > IMPORTS).
+     */
+    static upgradeArkFileToLevel(scene, arkFile, language, targetLevel) {
+        if (language === ArkFile_1.Language.CXX) {
+            new CppFrontend_1.CppFrontend().buildProjectFile(scene, arkFile.getFilePath(), arkFile);
+        }
+        else {
+            new ArktsFrontend_1.ArktsFrontend().buildProjectFileForSignatures(arkFile);
+        }
+        if (targetLevel < ModuleDepth_1.ModuleDepthLevel.BODIES) {
+            FrontendBuilder.freeBodyBuildersInFile(arkFile);
+        }
+    }
+    /**
+     * Release the BodyBuilder (or CxxBodyBuilder) mounted on a method, freeing the AST/build
+     * context.
+     */
+    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();
+        }
+    }
+    /**
+     * Release the BodyBuilders mounted during signature building so the ArkFile retains only
+     * signatures (no ArkBody/CFG) and does not retain AST/build context in memory. Mirrors the
+     * release pattern in {@link Scene.parseAndRegisterSdkFile}.
+     */
+    static freeBodyBuildersInFile(arkFile) {
+        for (const method of ModelUtils_1.ModelUtils.getAllMethodsInFile(arkFile)) {
+            FrontendBuilder.freeMethodBodyBuilder(method);
+        }
+    }
+    /**
+     * Build method bodies (ArkBody/CFG/Stmt/Expr) for all ArkFiles in the given module, then
+     * run default-constructor post-processing. This is the module-scoped equivalent of
+     * {@link Scene.buildAllMethodBody} + {@link Scene.updateOrAddDefaultConstructors}, following
+     * the same two-phase pattern as {@link Scene.genArkFiles}.
+     *
+     * Phase 1 (signatures + mounted BodyBuilders) is performed earlier by
+     * {@link buildModuleFilesToLevel} at {@link ModuleDepthLevel.BODIES}, which retains the
+     * mounted BodyBuilders. This method performs phase 2:
+     *
+     * 1. Set {@link Scene.buildStage} to {@link SceneBuildStage.CLASS_DONE} (opening the
+     *    {@link Scene.buildClassDone} gate) so that when BodyBuilder encounters nested/anonymous
+     *    methods during body construction, their {@link ArkMethod.setBodyBuilder} calls
+     *    immediately trigger {@link ArkMethod.buildBody} — recursively building nested method
+     *    bodies. The previous buildStage is restored afterwards so that subsequent SIGNATURES-
+     *    level module loading is unaffected.
+     * 2. Collect all methods in the module's files.
+     * 3. Call {@link ArkMethod.buildBody} on each (executes the retained BodyBuilder), then free
+     *    the BodyBuilder to release AST/build context.
+     * 4. Run {@link buildDefaultConstructor} / {@link replaceSuper2Constructor} /
+     *    {@link addInitInConstructor} on the module's files (gate still open).
+     *
+     * Calls {@link ModelUtils.dispose} after each module's method bodies are built to release
+     * global caches (implicitArkUIBuilderMethods, popMethodSignatureCache) that accumulate during
+     * body building.
+     *
+     * @param module - The module whose files' method bodies are to be built.
+     */
+    static buildModuleMethodBody(module) {
+        const scene = module.getScene();
+        const prevStage = scene.getStage();
+        scene.setBuildStage(Scene_1.SceneBuildStage.CLASS_DONE);
+        try {
+            // Phase 2a: build method bodies for all methods in the module's files.
+            const methods = [];
+            for (const arkFile of module.getFilesMap().values()) {
+                methods.push(...ModelUtils_1.ModelUtils.getAllMethodsInFile(arkFile));
+            }
+            for (const method of methods) {
+                try {
+                    method.buildBody();
+                }
+                catch (error) {
+                    logger.error('Error building body:', method.getSignature(), error);
+                }
+                finally {
+                    FrontendBuilder.freeMethodBodyBuilder(method);
+                }
+            }
+            // Phase 2b: default-constructor post-processing for the module's files.
+            for (const arkFile of module.getFilesMap().values()) {
+                FrontendBuilder.processDefaultConstructors(arkFile);
+            }
+        }
+        finally {
+            scene.setBuildStage(prevStage);
+            ModelUtils_1.ModelUtils.dispose();
+        }
+    }
+    /**
+     * Run {@link buildDefaultConstructor} / {@link replaceSuper2Constructor} /
+     * {@link addInitInConstructor} on all classes in a file. These create/modify constructors;
+     * {@link buildDefaultConstructor} builds bodies directly (without BodyBuilder), and the
+     * other two only modify already-built bodies.
+     */
+    static processDefaultConstructors(arkFile) {
+        const initInConstructorFn = arkFile.getLanguage() === ArkFile_1.Language.CXX ? ArkMethodBuilder_2.addInitInConstructor : ArkMethodBuilder_1.addInitInConstructor;
+        for (const cls of ModelUtils_1.ModelUtils.getAllClassesInFile(arkFile)) {
+            (0, ArkMethodBuilder_1.buildDefaultConstructor)(cls);
+            if (cls.isDefaultArkClass()) {
+                continue;
+            }
+            const constructors = cls.getAllMethodsWithName(TSConst_1.CONSTRUCTOR_NAME);
+            constructors.forEach(constructor => {
+                (0, ArkMethodBuilder_1.replaceSuper2Constructor)(constructor);
+                initInConstructorFn(constructor);
+            });
+        }
+    }
 }
 exports.FrontendBuilder = FrontendBuilder;

package/lib/frontend/arktsFrontend/ArktsFrontend.d.ts

@@ -7,6 +7,17 @@ import { FrontendParseResult } from '../FrontendBuilder';
 export declare class ArktsFrontend {
     /** Fills a project {@link ArkFile} from a source file; delegates to {@link buildArkFileFromFile}. */
     buildProjectFile(scene: Scene, filePath: string, arkFile: ArkFile): void;
+    /**
+     * Imports-only build for a single ArkTS file: fills ImportInfo/ExportInfo
+     * without building ArkClass/ArkMethod/ArkBody.
+     */
+    buildProjectFileForImports(arkFile: ArkFile): void;
+    /**
+     * Signatures-only upgrade for a single ArkTS file whose ImportInfo/ExportInfo were already
+     * populated by {@link buildProjectFileForImports}. Builds ArkClass/ArkMethod/ArkNamespace
+     * signatures on top, skipping the import/export branches to avoid duplicating `export *`.
+     */
+    buildProjectFileForSignatures(arkFile: ArkFile): void;
     /**
      * Non-project SDK file load (e.g. OpenHarmony SDK sources); mirrors the former {@link Scene} path for SDK files.
      */

package/lib/frontend/arktsFrontend/ArktsFrontend.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ArktsFrontend.d.ts","sourceRoot":"","sources":["../../../src/frontend/arktsFrontend/ArktsFrontend.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAEnD,OAAO,EAAwB,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAI/E;;GAEG;AACH,qBAAa,aAAa;IAEtB,qGAAqG;IAC9F,gBAAgB,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI;IAI/E;;OAEG;WACW,uBAAuB,CAAC,gBAAgB,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI;IAIlH,iBAAiB,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,mBAAmB;CAenF"}
+{"version":3,"file":"ArktsFrontend.d.ts","sourceRoot":"","sources":["../../../src/frontend/arktsFrontend/ArktsFrontend.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAEnD,OAAO,EAAwB,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAG/E;;GAEG;AACH,qBAAa,aAAa;IACtB,qGAAqG;IAC9F,gBAAgB,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI;IAI/E;;;OAGG;IACI,0BAA0B,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAIzD;;;;OAIG;IACI,6BAA6B,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAI5D;;OAEG;WACW,uBAAuB,CAAC,gBAAgB,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI;IAIlH,iBAAiB,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,mBAAmB;CAenF"}

package/lib/frontend/arktsFrontend/ArktsFrontend.js

@@ -26,6 +26,21 @@ class ArktsFrontend {
     buildProjectFile(scene, filePath, arkFile) {
         (0, ArkFileBuilder_1.buildArkFileFromFile)(filePath, scene.getRealProjectDir(), arkFile, scene.getProjectName());
     }
+    /**
+     * Imports-only build for a single ArkTS file: fills ImportInfo/ExportInfo
+     * without building ArkClass/ArkMethod/ArkBody.
+     */
+    buildProjectFileForImports(arkFile) {
+        (0, ArkFileBuilder_1.buildImportExportInfoFromFile)(arkFile);
+    }
+    /**
+     * Signatures-only upgrade for a single ArkTS file whose ImportInfo/ExportInfo were already
+     * populated by {@link buildProjectFileForImports}. Builds ArkClass/ArkMethod/ArkNamespace
+     * signatures on top, skipping the import/export branches to avoid duplicating `export *`.
+     */
+    buildProjectFileForSignatures(arkFile) {
+        (0, ArkFileBuilder_1.buildArkFileSignaturesFromFile)(arkFile);
+    }
     /**
      * Non-project SDK file load (e.g. OpenHarmony SDK sources); mirrors the former {@link Scene} path for SDK files.
      */

package/lib/frontend/common/MemoryMonitor.d.ts

@@ -0,0 +1,62 @@
+import type { SceneOptions } from '../../Config';
+/**
+ * Monitors process memory usage (heapUsed) and determines whether the memory limit has been exceeded.
+ *
+ * Uses heapUsed (V8 heap used) as the memory metric for cache management. The configured RSS limit
+ * ({@link SceneOptions.memoryLimitMB}) is converted to a heapUsed limit via {@link RSS_TO_HEAPUSED_RATIO}.
+ *
+ * Sampling is throttled: if the last sample was taken less than {@link THROTTLE_MS}
+ * milliseconds ago, the cached result is reused to avoid excessive
+ * `process.memoryUsage()` calls during rapid module loading.
+ *
+ * Configuration is read from {@link SceneOptions}:
+ * - `memoryLimitMB`: max process memory (RSS) in MB; 0 or undefined disables monitoring.
+ *   Internally converted to a heapUsed limit: `heapUsedLimit = memoryLimitMB * 1024 * 1024 * RSS_TO_HEAPUSED_RATIO`.
+ *
+ * @category frontend/common
+ */
+export declare class MemoryMonitor {
+    private readonly heapUsedLimitBytes;
+    private lastSampleTime;
+    private cachedUsage;
+    /** Minimum interval between consecutive memory samples, in milliseconds. */
+    private static readonly THROTTLE_MS;
+    /**
+     * Ratio for converting an RSS-based memory limit to a heapUsed-based limit.
+     * Calibrated from scene_board_ext BODIES-level run (no eviction, no GC):
+     * P50 of heapUsed/RSS = 0.911, rounded down to 0.85 for extra safety margin
+     * to reduce OOM risk when node --max-old-space-size is close to memoryLimitMB.
+     */
+    private static readonly RSS_TO_HEAPUSED_RATIO;
+    constructor(options?: SceneOptions);
+    /** Whether memory monitoring is enabled (memoryLimitMB > 0). */
+    isEnabled(): boolean;
+    /** Returns the heapUsed limit in bytes (converted from the RSS-based memoryLimitMB). */
+    getHeapUsedLimitBytes(): number;
+    /**
+     * Check whether the current heapUsed exceeds the memory limit.
+     *
+     * Sampling is throttled: calls within {@link THROTTLE_MS} of the last sample
+     * return the cached result.
+     */
+    isHeapUsedOverLimit(): boolean;
+    /**
+     * Check whether the current heapUsed exceeds the given target value.
+     *
+     * Sampling is throttled: calls within {@link THROTTLE_MS} of the last sample
+     * return the cached result.
+     */
+    isHeapUsedOverTarget(targetBytes: number): boolean;
+    /**
+     * Get the current heapUsed in bytes, bypassing the throttle for one-shot measurements.
+     *
+     * Unlike {@link isHeapUsedOverTarget} / {@link isHeapUsedOverLimit} (which use throttled sampling),
+     * this method always calls `process.memoryUsage()` directly. It is intended for
+     * one-shot measurements such as heapUsed recording before/after module loading and
+     * real-time heapUsed checks during eviction (each unload/downgrade calls this to
+     * decide whether more eviction is needed).
+     */
+    getCurrentHeapUsed(): number;
+    private getUsage;
+}
+//# sourceMappingURL=MemoryMonitor.d.ts.map

package/lib/frontend/common/MemoryMonitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MemoryMonitor.d.ts","sourceRoot":"","sources":["../../../src/frontend/common/MemoryMonitor.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAEjD;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,aAAa;IACtB,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAS;IAC5C,OAAO,CAAC,cAAc,CAAa;IACnC,OAAO,CAAC,WAAW,CAAkD;IAErE,4EAA4E;IAC5E,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,WAAW,CAAM;IAEzC;;;;;OAKG;IACH,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,qBAAqB,CAAQ;gBAEzC,OAAO,CAAC,EAAE,YAAY;IAOlC,gEAAgE;IACzD,SAAS,IAAI,OAAO;IAI3B,wFAAwF;IACjF,qBAAqB,IAAI,MAAM;IAItC;;;;;OAKG;IACI,mBAAmB,IAAI,OAAO;IAOrC;;;;;OAKG;IACI,oBAAoB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO;IAOzD;;;;;;;;OAQG;IACI,kBAAkB,IAAI,MAAM;IAInC,OAAO,CAAC,QAAQ;CAUnB"}

package/lib/frontend/common/MemoryMonitor.js

@@ -0,0 +1,108 @@
+"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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryMonitor = void 0;
+/**
+ * Monitors process memory usage (heapUsed) and determines whether the memory limit has been exceeded.
+ *
+ * Uses heapUsed (V8 heap used) as the memory metric for cache management. The configured RSS limit
+ * ({@link SceneOptions.memoryLimitMB}) is converted to a heapUsed limit via {@link RSS_TO_HEAPUSED_RATIO}.
+ *
+ * Sampling is throttled: if the last sample was taken less than {@link THROTTLE_MS}
+ * milliseconds ago, the cached result is reused to avoid excessive
+ * `process.memoryUsage()` calls during rapid module loading.
+ *
+ * Configuration is read from {@link SceneOptions}:
+ * - `memoryLimitMB`: max process memory (RSS) in MB; 0 or undefined disables monitoring.
+ *   Internally converted to a heapUsed limit: `heapUsedLimit = memoryLimitMB * 1024 * 1024 * RSS_TO_HEAPUSED_RATIO`.
+ *
+ * @category frontend/common
+ */
+class MemoryMonitor {
+    constructor(options) {
+        var _a;
+        this.lastSampleTime = 0;
+        this.cachedUsage = null;
+        const limitMB = (_a = options === null || options === void 0 ? void 0 : options.memoryLimitMB) !== null && _a !== void 0 ? _a : 0;
+        this.heapUsedLimitBytes = limitMB > 0
+            ? Math.floor(limitMB * 1024 * 1024 * MemoryMonitor.RSS_TO_HEAPUSED_RATIO)
+            : 0;
+    }
+    /** Whether memory monitoring is enabled (memoryLimitMB > 0). */
+    isEnabled() {
+        return this.heapUsedLimitBytes > 0;
+    }
+    /** Returns the heapUsed limit in bytes (converted from the RSS-based memoryLimitMB). */
+    getHeapUsedLimitBytes() {
+        return this.heapUsedLimitBytes;
+    }
+    /**
+     * Check whether the current heapUsed exceeds the memory limit.
+     *
+     * Sampling is throttled: calls within {@link THROTTLE_MS} of the last sample
+     * return the cached result.
+     */
+    isHeapUsedOverLimit() {
+        if (!this.isEnabled()) {
+            return false;
+        }
+        return this.getUsage().heapUsed >= this.heapUsedLimitBytes;
+    }
+    /**
+     * Check whether the current heapUsed exceeds the given target value.
+     *
+     * Sampling is throttled: calls within {@link THROTTLE_MS} of the last sample
+     * return the cached result.
+     */
+    isHeapUsedOverTarget(targetBytes) {
+        if (!this.isEnabled()) {
+            return false;
+        }
+        return this.getUsage().heapUsed >= targetBytes;
+    }
+    /**
+     * Get the current heapUsed in bytes, bypassing the throttle for one-shot measurements.
+     *
+     * Unlike {@link isHeapUsedOverTarget} / {@link isHeapUsedOverLimit} (which use throttled sampling),
+     * this method always calls `process.memoryUsage()` directly. It is intended for
+     * one-shot measurements such as heapUsed recording before/after module loading and
+     * real-time heapUsed checks during eviction (each unload/downgrade calls this to
+     * decide whether more eviction is needed).
+     */
+    getCurrentHeapUsed() {
+        return process.memoryUsage().heapUsed;
+    }
+    getUsage() {
+        const now = Date.now();
+        if (this.cachedUsage && now - this.lastSampleTime < MemoryMonitor.THROTTLE_MS) {
+            return this.cachedUsage;
+        }
+        this.lastSampleTime = now;
+        const usage = process.memoryUsage();
+        this.cachedUsage = { rss: usage.rss, heapUsed: usage.heapUsed };
+        return this.cachedUsage;
+    }
+}
+exports.MemoryMonitor = MemoryMonitor;
+/** Minimum interval between consecutive memory samples, in milliseconds. */
+MemoryMonitor.THROTTLE_MS = 50;
+/**
+ * Ratio for converting an RSS-based memory limit to a heapUsed-based limit.
+ * Calibrated from scene_board_ext BODIES-level run (no eviction, no GC):
+ * P50 of heapUsed/RSS = 0.911, rounded down to 0.85 for extra safety margin
+ * to reduce OOM risk when node --max-old-space-size is close to memoryLimitMB.
+ */
+MemoryMonitor.RSS_TO_HEAPUSED_RATIO = 0.85;