arkanalyzer 1.0.90 → 1.0.91

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

@@ -0,0 +1,119 @@
+import type { ModuleID } from '../../core/model/ArkModule';
+import type { MemoryMonitor } from './MemoryMonitor';
+import { ModuleDepthLevel } from './ModuleDepth';
+/**
+ * Mutable heapUsed estimate tracking state used during eviction.
+ *
+ * `estimate` starts at the actual heapUsed measured before eviction and is
+ * decremented by the heapUsed table value of each unloaded/downgraded module.
+ * Eviction stops when `estimate` falls to or below `limit`.
+ */
+export interface HeapUsedEstimateState {
+    estimate: number;
+    limit: number;
+}
+/**
+ * Maintains the set of currently-loaded modules and evicts them when memory pressure
+ * exceeds the threshold.
+ *
+ * This class performs Phase 1 only: evicting modules that are neither in the hard nor soft
+ * protected set (not depended on by the current or subsequent modules), in LRU order. The
+ * caller ({@link ModuleBuilder.evictIfNeeded}) handles the subsequent phases:
+ * - **Phase 2** — downgrade protected dependencies to dependencyLoadLevel (release method
+ *   bodies/AST, keep signatures), in reverse-topo order.
+ * - **Phase 3** — if still over threshold, evict the protected dependencies (full unload),
+ *   in reverse-topo order.
+ *
+ * The hard protected set contains modules that must never be evicted (the current target
+ * module and its dependency closure). The soft protected set contains modules that are
+ * directly depended on by not-yet-loaded modules (evicting them causes reload overhead
+ * but is safe).
+ *
+ * SCC groups: if a module belongs to a cyclic dependency group (size > 1), the entire
+ * group is treated as a unit — either all members are evictable or none is evicted.
+ *
+ * ## heapUsed Table
+ *
+ * A heapUsed table ({@link heapUsedTable}) records the heapUsed increment observed during
+ * the first load of each module at each depth level. This table is:
+ * - Populated on first load only (subsequent reloads do not update it).
+ * - Not cleared on module unload (persists across load/unload cycles).
+ * - Cleared only on full cache reset ({@link clear}).
+ *
+ * During eviction, the table provides estimated heapUsed decreases for unload/downgrade
+ * via the `getHeapUsedDecrease` callback — only one actual heapUsed measurement is taken
+ * at the start of eviction, and all subsequent tracking uses table values.
+ *
+ * @category frontend/common
+ */
+export declare class ModuleCache {
+    private loadedModules;
+    private accessOrder;
+    /**
+     * Per-module heapUsed table, indexed by depth level.
+     * Records the heapUsed increment (bytes) from the first load of each module at each level.
+     * Persists across unload/load cycles; cleared only by {@link clear}.
+     */
+    private heapUsedTable;
+    /** Register a module as loaded. */
+    register(moduleId: ModuleID): void;
+    /** Unregister a module (called after it has been unloaded). Does NOT clear the heapUsed table. */
+    unregister(moduleId: ModuleID): void;
+    /** Whether the given module is currently loaded. */
+    has(moduleId: ModuleID): boolean;
+    /** Number of currently loaded modules. */
+    size(): number;
+    /** All currently loaded module IDs. */
+    getLoadedModules(): ModuleID[];
+    /** Remove all entries from the cache, including the heapUsed table. */
+    clear(): void;
+    /**
+     * Record the heapUsed increment for a module at the given depth level.
+     *
+     * Only records on the first load (when no entry exists for this module+level pair).
+     * Subsequent reloads do not update the value. Module unload does not erase it.
+     *
+     * @param moduleId - The module ID.
+     * @param level - The depth level at which the module was loaded.
+     * @param heapUsedBytes - The heapUsed increment (bytes) observed during loading.
+     */
+    recordHeapUsed(moduleId: ModuleID, level: ModuleDepthLevel, heapUsedBytes: number): void;
+    /**
+     * Get the recorded heapUsed for a module at the given depth level.
+     *
+     * @returns The recorded heapUsed in bytes, or `undefined` if not yet recorded.
+     */
+    getHeapUsed(moduleId: ModuleID, level: ModuleDepthLevel): number | undefined;
+    /**
+     * Evict loaded modules until the heapUsed estimate is below the limit (or no more candidates remain).
+     *
+     * This performs Phase 1 only: evicting modules that are neither in the hard nor soft protected
+     * set. Downgrading (Phase 2) and evicting protected dependencies (Phase 3) are handled by
+     * the caller (ModuleBuilder.evictIfNeeded).
+     *
+     * Instead of calling `process.memoryUsage()` after each unload, this method uses the
+     * {@link HeapUsedEstimateState} to track the estimated heapUsed. The `getHeapUsedDecrease`
+     * callback provides the estimated heapUsed decrease for each module (from the heapUsed table
+     * or fallback).
+     *
+     * @param hardProtectedSet - Modules that must never be evicted.
+     * @param softProtectedSet - Modules that should not be evicted in Phase 1.
+     * @param monitor - The memory monitor (used only for `isEnabled()` guard).
+     * @param unloadFn - Callback to unload a module by ID.
+     * @param sccGroups - Optional SCC group map; members of the same group are evicted together.
+     * @param heapUsedState - Mutable heapUsed estimate state; `estimate` is decremented as modules are evicted.
+     * @param getHeapUsedDecrease - Callback returning the estimated heapUsed decrease (bytes) for a module.
+     */
+    evict(hardProtectedSet: Set<ModuleID>, softProtectedSet: Set<ModuleID>, monitor: MemoryMonitor, unloadFn: (moduleId: ModuleID) => void, sccGroups: Map<ModuleID, ModuleID[]> | undefined, heapUsedState: HeapUsedEstimateState, getHeapUsedDecrease: (moduleId: ModuleID) => number): void;
+    private evictFromList;
+    /**
+     * Try to evict an SCC group as a unit. Returns true if the module belongs to an SCC group
+     * (size > 1) and the group was handled (either evicted or skipped due to protected members).
+     * Returns false if the module is not part of a multi-member SCC group.
+     *
+     * When evicting, the heapUsed decrease for each group member is obtained from
+     * `getHeapUsedDecrease` and subtracted from `heapUsedState.estimate`.
+     */
+    private tryEvictSCCGroup;
+}
+//# sourceMappingURL=ModuleCache.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ModuleCache.d.ts","sourceRoot":"","sources":["../../../src/frontend/common/ModuleCache.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEjD;;;;;;GAMG;AACH,MAAM,WAAW,qBAAqB;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,qBAAa,WAAW;IACpB,OAAO,CAAC,aAAa,CAA4B;IACjD,OAAO,CAAC,WAAW,CAAkB;IAErC;;;;OAIG;IACH,OAAO,CAAC,aAAa,CAA2D;IAEhF,mCAAmC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI;IAOzC,kGAAkG;IAC3F,UAAU,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI;IAS3C,oDAAoD;IAC7C,GAAG,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO;IAIvC,0CAA0C;IACnC,IAAI,IAAI,MAAM;IAIrB,uCAAuC;IAChC,gBAAgB,IAAI,QAAQ,EAAE;IAIrC,uEAAuE;IAChE,KAAK,IAAI,IAAI;IAMpB;;;;;;;;;OASG;IACI,cAAc,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,GAAG,IAAI;IAW/F;;;;OAIG;IACI,WAAW,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,gBAAgB,GAAG,MAAM,GAAG,SAAS;IAInF;;;;;;;;;;;;;;;;;;;OAmBG;IACI,KAAK,CACR,gBAAgB,EAAE,GAAG,CAAC,QAAQ,CAAC,EAC/B,gBAAgB,EAAE,GAAG,CAAC,QAAQ,CAAC,EAC/B,OAAO,EAAE,aAAa,EACtB,QAAQ,EAAE,CAAC,QAAQ,EAAE,QAAQ,KAAK,IAAI,EACtC,SAAS,EAAE,GAAG,CAAC,QAAQ,EAAE,QAAQ,EAAE,CAAC,GAAG,SAAS,EAChD,aAAa,EAAE,qBAAqB,EACpC,mBAAmB,EAAE,CAAC,QAAQ,EAAE,QAAQ,KAAK,MAAM,GACpD,IAAI;IAUP,OAAO,CAAC,aAAa;IA2BrB;;;;;;;OAOG;IACH,OAAO,CAAC,gBAAgB;CAwB3B"}

package/lib/frontend/common/ModuleCache.js

@@ -0,0 +1,197 @@
+"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.ModuleCache = void 0;
+/**
+ * Maintains the set of currently-loaded modules and evicts them when memory pressure
+ * exceeds the threshold.
+ *
+ * This class performs Phase 1 only: evicting modules that are neither in the hard nor soft
+ * protected set (not depended on by the current or subsequent modules), in LRU order. The
+ * caller ({@link ModuleBuilder.evictIfNeeded}) handles the subsequent phases:
+ * - **Phase 2** — downgrade protected dependencies to dependencyLoadLevel (release method
+ *   bodies/AST, keep signatures), in reverse-topo order.
+ * - **Phase 3** — if still over threshold, evict the protected dependencies (full unload),
+ *   in reverse-topo order.
+ *
+ * The hard protected set contains modules that must never be evicted (the current target
+ * module and its dependency closure). The soft protected set contains modules that are
+ * directly depended on by not-yet-loaded modules (evicting them causes reload overhead
+ * but is safe).
+ *
+ * SCC groups: if a module belongs to a cyclic dependency group (size > 1), the entire
+ * group is treated as a unit — either all members are evictable or none is evicted.
+ *
+ * ## heapUsed Table
+ *
+ * A heapUsed table ({@link heapUsedTable}) records the heapUsed increment observed during
+ * the first load of each module at each depth level. This table is:
+ * - Populated on first load only (subsequent reloads do not update it).
+ * - Not cleared on module unload (persists across load/unload cycles).
+ * - Cleared only on full cache reset ({@link clear}).
+ *
+ * During eviction, the table provides estimated heapUsed decreases for unload/downgrade
+ * via the `getHeapUsedDecrease` callback — only one actual heapUsed measurement is taken
+ * at the start of eviction, and all subsequent tracking uses table values.
+ *
+ * @category frontend/common
+ */
+class ModuleCache {
+    constructor() {
+        this.loadedModules = new Set();
+        this.accessOrder = [];
+        /**
+         * Per-module heapUsed table, indexed by depth level.
+         * Records the heapUsed increment (bytes) from the first load of each module at each level.
+         * Persists across unload/load cycles; cleared only by {@link clear}.
+         */
+        this.heapUsedTable = new Map();
+    }
+    /** Register a module as loaded. */
+    register(moduleId) {
+        if (!this.loadedModules.has(moduleId)) {
+            this.loadedModules.add(moduleId);
+            this.accessOrder.push(moduleId);
+        }
+    }
+    /** Unregister a module (called after it has been unloaded). Does NOT clear the heapUsed table. */
+    unregister(moduleId) {
+        if (this.loadedModules.delete(moduleId)) {
+            const idx = this.accessOrder.indexOf(moduleId);
+            if (idx >= 0) {
+                this.accessOrder.splice(idx, 1);
+            }
+        }
+    }
+    /** Whether the given module is currently loaded. */
+    has(moduleId) {
+        return this.loadedModules.has(moduleId);
+    }
+    /** Number of currently loaded modules. */
+    size() {
+        return this.loadedModules.size;
+    }
+    /** All currently loaded module IDs. */
+    getLoadedModules() {
+        return Array.from(this.loadedModules);
+    }
+    /** Remove all entries from the cache, including the heapUsed table. */
+    clear() {
+        this.loadedModules.clear();
+        this.accessOrder.length = 0;
+        this.heapUsedTable.clear();
+    }
+    /**
+     * Record the heapUsed increment for a module at the given depth level.
+     *
+     * Only records on the first load (when no entry exists for this module+level pair).
+     * Subsequent reloads do not update the value. Module unload does not erase it.
+     *
+     * @param moduleId - The module ID.
+     * @param level - The depth level at which the module was loaded.
+     * @param heapUsedBytes - The heapUsed increment (bytes) observed during loading.
+     */
+    recordHeapUsed(moduleId, level, heapUsedBytes) {
+        let levelMap = this.heapUsedTable.get(moduleId);
+        if (!levelMap) {
+            levelMap = new Map();
+            this.heapUsedTable.set(moduleId, levelMap);
+        }
+        if (!levelMap.has(level)) {
+            levelMap.set(level, heapUsedBytes);
+        }
+    }
+    /**
+     * Get the recorded heapUsed for a module at the given depth level.
+     *
+     * @returns The recorded heapUsed in bytes, or `undefined` if not yet recorded.
+     */
+    getHeapUsed(moduleId, level) {
+        var _a;
+        return (_a = this.heapUsedTable.get(moduleId)) === null || _a === void 0 ? void 0 : _a.get(level);
+    }
+    /**
+     * Evict loaded modules until the heapUsed estimate is below the limit (or no more candidates remain).
+     *
+     * This performs Phase 1 only: evicting modules that are neither in the hard nor soft protected
+     * set. Downgrading (Phase 2) and evicting protected dependencies (Phase 3) are handled by
+     * the caller (ModuleBuilder.evictIfNeeded).
+     *
+     * Instead of calling `process.memoryUsage()` after each unload, this method uses the
+     * {@link HeapUsedEstimateState} to track the estimated heapUsed. The `getHeapUsedDecrease`
+     * callback provides the estimated heapUsed decrease for each module (from the heapUsed table
+     * or fallback).
+     *
+     * @param hardProtectedSet - Modules that must never be evicted.
+     * @param softProtectedSet - Modules that should not be evicted in Phase 1.
+     * @param monitor - The memory monitor (used only for `isEnabled()` guard).
+     * @param unloadFn - Callback to unload a module by ID.
+     * @param sccGroups - Optional SCC group map; members of the same group are evicted together.
+     * @param heapUsedState - Mutable heapUsed estimate state; `estimate` is decremented as modules are evicted.
+     * @param getHeapUsedDecrease - Callback returning the estimated heapUsed decrease (bytes) for a module.
+     */
+    evict(hardProtectedSet, softProtectedSet, monitor, unloadFn, sccGroups, heapUsedState, getHeapUsedDecrease) {
+        if (!monitor.isEnabled() || heapUsedState.estimate <= heapUsedState.limit) {
+            return;
+        }
+        // Phase 1: evict modules not in hard or soft protected set, in LRU order
+        const phase1Protected = new Set([...hardProtectedSet, ...softProtectedSet]);
+        this.evictFromList([...this.accessOrder], phase1Protected, unloadFn, sccGroups, heapUsedState, getHeapUsedDecrease);
+    }
+    evictFromList(list, protectedSet, unloadFn, sccGroups, heapUsedState, getHeapUsedDecrease) {
+        for (const moduleId of list) {
+            if (heapUsedState.estimate <= heapUsedState.limit) {
+                return;
+            }
+            if (!this.loadedModules.has(moduleId) || protectedSet.has(moduleId)) {
+                continue;
+            }
+            if (sccGroups && this.tryEvictSCCGroup(moduleId, protectedSet, unloadFn, sccGroups, heapUsedState, getHeapUsedDecrease)) {
+                continue;
+            }
+            const decrease = getHeapUsedDecrease(moduleId);
+            unloadFn(moduleId);
+            this.unregister(moduleId);
+            heapUsedState.estimate -= decrease;
+        }
+    }
+    /**
+     * Try to evict an SCC group as a unit. Returns true if the module belongs to an SCC group
+     * (size > 1) and the group was handled (either evicted or skipped due to protected members).
+     * Returns false if the module is not part of a multi-member SCC group.
+     *
+     * When evicting, the heapUsed decrease for each group member is obtained from
+     * `getHeapUsedDecrease` and subtracted from `heapUsedState.estimate`.
+     */
+    tryEvictSCCGroup(moduleId, protectedSet, unloadFn, sccGroups, heapUsedState, getHeapUsedDecrease) {
+        const group = sccGroups.get(moduleId);
+        if (!group || group.length <= 1) {
+            return false;
+        }
+        // All members must be evictable and currently loaded
+        const blocked = group.some(m => protectedSet.has(m) || !this.loadedModules.has(m));
+        if (!blocked) {
+            for (const m of group) {
+                const decrease = getHeapUsedDecrease(m);
+                unloadFn(m);
+                this.unregister(m);
+                heapUsedState.estimate -= decrease;
+            }
+        }
+        return true;
+    }
+}
+exports.ModuleCache = ModuleCache;

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

@@ -0,0 +1,28 @@
+/**
+ * Module data depth levels controlling how much data is built for ArkFile objects.
+ * Higher levels are supersets of lower levels (incremental relationship).
+ *
+ * @category core/model
+ */
+export declare enum ModuleDepthLevel {
+    /**
+     * Level 0: Module metadata + dependency topology + ArkFile (path-only basic info).
+     * Index files (index.ets/index.ts) are exceptions: their ArkFile includes export/import info.
+     * Other files are NOT read or parsed.
+     */
+    META = 0,
+    /**
+     * Level 1: META + export/import info for ALL ArkFiles + intra-module file dependencies.
+     */
+    IMPORTS = 1,
+    /**
+     * Level 2: IMPORTS + ArkFile content excluding method bodies
+     * (namespaces, classes, method signatures, parameters, return types).
+     */
+    SIGNATURES = 2,
+    /**
+     * Level 3: SIGNATURES + method bodies (ArkBody, CFG, Stmt/Expr).
+     */
+    BODIES = 3
+}
+//# sourceMappingURL=ModuleDepth.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ModuleDepth.d.ts","sourceRoot":"","sources":["../../../src/frontend/common/ModuleDepth.ts"],"names":[],"mappings":"AAeA;;;;;GAKG;AACH,oBAAY,gBAAgB;IACxB;;;;OAIG;IACH,IAAI,IAAI;IAER;;OAEG;IACH,OAAO,IAAI;IAEX;;;OAGG;IACH,UAAU,IAAI;IAEd;;OAEG;IACH,MAAM,IAAI;CACb"}

package/lib/frontend/common/ModuleDepth.js

@@ -0,0 +1,45 @@
+"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.ModuleDepthLevel = void 0;
+/**
+ * Module data depth levels controlling how much data is built for ArkFile objects.
+ * Higher levels are supersets of lower levels (incremental relationship).
+ *
+ * @category core/model
+ */
+var ModuleDepthLevel;
+(function (ModuleDepthLevel) {
+    /**
+     * Level 0: Module metadata + dependency topology + ArkFile (path-only basic info).
+     * Index files (index.ets/index.ts) are exceptions: their ArkFile includes export/import info.
+     * Other files are NOT read or parsed.
+     */
+    ModuleDepthLevel[ModuleDepthLevel["META"] = 0] = "META";
+    /**
+     * Level 1: META + export/import info for ALL ArkFiles + intra-module file dependencies.
+     */
+    ModuleDepthLevel[ModuleDepthLevel["IMPORTS"] = 1] = "IMPORTS";
+    /**
+     * Level 2: IMPORTS + ArkFile content excluding method bodies
+     * (namespaces, classes, method signatures, parameters, return types).
+     */
+    ModuleDepthLevel[ModuleDepthLevel["SIGNATURES"] = 2] = "SIGNATURES";
+    /**
+     * Level 3: SIGNATURES + method bodies (ArkBody, CFG, Stmt/Expr).
+     */
+    ModuleDepthLevel[ModuleDepthLevel["BODIES"] = 3] = "BODIES";
+})(ModuleDepthLevel = exports.ModuleDepthLevel || (exports.ModuleDepthLevel = {}));

package/lib/frontend/cppFrontend/CppFrontend.d.ts

@@ -8,6 +8,11 @@ export declare class CppFrontend {
     private static readonly AUTO_MAX_PARALLEL_PROCESSES;
     private static readonly AUTO_MAX_PENDING_AST_RESULTS;
     buildProjectFile(scene: Scene, filePath: string, arkFile: ArkFile): void;
+    /**
+     * Imports-only build for a single C++ file: parses #include directives and fills
+     * ImportInfo without building ArkClass/ArkMethod/ArkBody.
+     */
+    buildProjectFileForImports(arkFile: ArkFile): void;
     buildProjectFiles(scene: Scene, filePaths: string[]): FrontendParseResult;
     /** Returns true if astJsonDumper and cxx-ast-parser are available; otherwise logs a warning. */
     private requireAstJsonDumper;

package/lib/frontend/cppFrontend/CppFrontend.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CppFrontend.d.ts","sourceRoot":"","sources":["../../../src/frontend/cppFrontend/CppFrontend.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAGnD,OAAO,EAAwB,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAM/E;;GAEG;AACH,qBAAa,WAAW;IACpB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,2BAA2B,CAAM;IACzD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,4BAA4B,CAAM;IAEnD,gBAAgB,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI;IAOxE,iBAAiB,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,mBAAmB;IAYhF,gGAAgG;IAChG,OAAO,CAAC,oBAAoB;IAkB5B,OAAO,CAAC,2BAA2B;IAsBnC,OAAO,CAAC,2BAA2B;IAoBnC,OAAO,CAAC,iBAAiB;CAG5B"}
+{"version":3,"file":"CppFrontend.d.ts","sourceRoot":"","sources":["../../../src/frontend/cppFrontend/CppFrontend.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAGnD,OAAO,EAAwB,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAK/E;;GAEG;AACH,qBAAa,WAAW;IACpB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,2BAA2B,CAAM;IACzD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,4BAA4B,CAAM;IAEnD,gBAAgB,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI;IAO/E;;;OAGG;IACI,0BAA0B,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAOlD,iBAAiB,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,mBAAmB;IAYhF,gGAAgG;IAChG,OAAO,CAAC,oBAAoB;IAgB5B,OAAO,CAAC,2BAA2B;IAsBnC,OAAO,CAAC,2BAA2B;IAoBnC,OAAO,CAAC,iBAAiB;CAG5B"}

package/lib/frontend/cppFrontend/CppFrontend.js

@@ -41,10 +41,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CppFrontend = void 0;
+const os_1 = __importDefault(require("os"));
 const logger_1 = __importStar(require("../../utils/logger"));
 const ArkFileBuilder_1 = require("./model/builder/ArkFileBuilder");
 const cxxAstParserTypes_1 = require("./utils/cxxAstParserTypes");
-const os_1 = __importDefault(require("os"));
 const logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'CppFrontend');
 /**
  * C++ language frontend. Matches the former {@link Scene} branches for {@link Language#CXX}.
@@ -56,6 +56,16 @@ class CppFrontend {
         }
         (0, ArkFileBuilder_1.prepareArkFile)(scene, filePath, arkFile, this.resolveLogAstInfo(scene));
     }
+    /**
+     * Imports-only build for a single C++ file: parses #include directives and fills
+     * ImportInfo without building ArkClass/ArkMethod/ArkBody.
+     */
+    buildProjectFileForImports(arkFile) {
+        if (!this.requireAstJsonDumper()) {
+            return;
+        }
+        (0, ArkFileBuilder_1.buildImportExportInfoFromFile)(arkFile);
+    }
     buildProjectFiles(scene, filePaths) {
         if (!this.requireAstJsonDumper()) {
             return { arkFiles: [], failedFiles: [] };

package/lib/frontend/cppFrontend/model/builder/ArkFileBuilder.d.ts

@@ -12,6 +12,14 @@ export interface CppStreamBuildResult {
  */
 export declare function prepareArkFiles(scene: Scene, absoluteSourceFiles: string[], maxParallelProcesses?: number, maxPendingAstResults?: number, logAstInfo?: boolean): CppStreamBuildResult;
 export declare function prepareArkFile(scene: Scene, absoluteFilePath: string, targetArkFile: ArkFile, logAstInfo?: boolean): void;
+/**
+ * Imports-only variant of {@link prepareArkFile}. Parses the C++ AST for the given
+ * file and populates only basic file metadata and ImportInfo (#include directives
+ * and using-namespace declarations). Does NOT build ArkClass/ArkMethod/ArkNamespace/ArkBody.
+ *
+ * @param arkFile - Pre-allocated ArkFile to populate (must have scene and file path set).
+ */
+export declare function buildImportExportInfoFromFile(arkFile: ArkFile): void;
 export declare const classMap: Map<string, ArkClass>;
 export declare function buildArkClassFromCxxClass(classNode: CxxAstNode, arkFile: ArkFile, astRoot: CxxAstNode): void;
 //# sourceMappingURL=ArkFileBuilder.d.ts.map

package/lib/frontend/cppFrontend/model/builder/ArkFileBuilder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ArkFileBuilder.d.ts","sourceRoot":"","sources":["../../../../../src/frontend/cppFrontend/model/builder/ArkFileBuilder.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,OAAO,EAAY,MAAM,gCAAgC,CAAC;AAMnE,OAAO,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAS3D,OAAO,KAAK,EAAE,UAAU,EAAkB,MAAM,2BAA2B,CAAC;AAK5E,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAG1C,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAyBhE,MAAM,WAAW,oBAAoB;IACjC,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,WAAW,EAAE,oBAAoB,EAAE,CAAC;CACvC;AAED;;GAEG;AACH,wBAAgB,eAAe,CAC3B,KAAK,EAAE,KAAK,EACZ,mBAAmB,EAAE,MAAM,EAAE,EAC7B,oBAAoB,GAAE,MAAU,EAChC,oBAAoB,GAAE,MAAU,EAChC,UAAU,GAAE,OAAe,GAC5B,oBAAoB,CAkCtB;AAED,wBAAgB,cAAc,CAC1B,KAAK,EAAE,KAAK,EACZ,gBAAgB,EAAE,MAAM,EACxB,aAAa,EAAE,OAAO,EACtB,UAAU,GAAE,OAAe,GAC5B,IAAI,CA0BN;AAED,eAAO,MAAM,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAA+B,CAAC;AAE3E,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,UAAU,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,UAAU,GAAG,IAAI,CAU5G"}
+{"version":3,"file":"ArkFileBuilder.d.ts","sourceRoot":"","sources":["../../../../../src/frontend/cppFrontend/model/builder/ArkFileBuilder.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,OAAO,EAAY,MAAM,gCAAgC,CAAC;AAMnE,OAAO,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAS3D,OAAO,KAAK,EAAE,UAAU,EAAkB,MAAM,2BAA2B,CAAC;AAK5E,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAG1C,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAwFhE,MAAM,WAAW,oBAAoB;IACjC,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,WAAW,EAAE,oBAAoB,EAAE,CAAC;CACvC;AAED;;GAEG;AACH,wBAAgB,eAAe,CAC3B,KAAK,EAAE,KAAK,EACZ,mBAAmB,EAAE,MAAM,EAAE,EAC7B,oBAAoB,GAAE,MAAU,EAChC,oBAAoB,GAAE,MAAU,EAChC,UAAU,GAAE,OAAe,GAC5B,oBAAoB,CAkCtB;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,KAAK,EAAE,gBAAgB,EAAE,MAAM,EAAE,aAAa,EAAE,OAAO,EAAE,UAAU,GAAE,OAAe,GAAG,IAAI,CA0BhI;AAED;;;;;;GAMG;AACH,wBAAgB,6BAA6B,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CA4BpE;AAED,eAAO,MAAM,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAA+B,CAAC;AAE3E,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,UAAU,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,UAAU,GAAG,IAAI,CAU5G"}

package/lib/frontend/cppFrontend/model/builder/ArkFileBuilder.js

@@ -40,7 +40,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildArkClassFromCxxClass = exports.classMap = exports.prepareArkFile = exports.prepareArkFiles = void 0;
+exports.buildArkClassFromCxxClass = exports.classMap = exports.buildImportExportInfoFromFile = exports.prepareArkFile = exports.prepareArkFiles = void 0;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const ArkFile_1 = require("../../../../core/model/ArkFile");
@@ -83,13 +83,77 @@ function applyArkFile(arkFile, sourceFile, astRoot) {
     genDefaultArkClass(arkFile, astRoot);
     buildArkFile(arkFile, astRoot);
 }
+/**
+ * Lightweight variant of {@link applyArkFile} that only sets basic file metadata and
+ * fills ImportInfo from #include / using-namespace directives. It does NOT build
+ * ArkClass, ArkMethod, ArkNamespace, or ArkBody.
+ *
+ * @param arkFile - Target ArkFile to populate.
+ * @param sourceFile - Absolute path of the C++ source file.
+ * @param astRoot - Root AST node returned by the C++ AST parser.
+ */
+function applyArkFileForImports(arkFile, sourceFile, astRoot) {
+    var _a;
+    const scene = arkFile.getScene();
+    const projectDir = scene.getRealProjectDir();
+    const projectName = scene.getProjectName();
+    arkFile.setFilePath(sourceFile);
+    arkFile.setProjectDir(projectDir);
+    arkFile.setFileSignature(new ArkSignature_1.FileSignature(projectName, path_1.default.relative(projectDir, sourceFile)));
+    const sourceText = fs_1.default.readFileSync(arkFile.getFilePath(), 'utf8');
+    const options = scene.getOptions();
+    const eagerLoad = (_a = options.saveSourceCodeByDefault) !== null && _a !== void 0 ? _a : false;
+    if (eagerLoad && scene.getProjectName() === arkFile.getProjectName()) {
+        arkFile.setCode(sourceText);
+    }
+    buildImportsOnly(arkFile, astRoot);
+}
+/**
+ * Imports-only subset of {@link buildArkFile}. Processes #include directives from
+ * header units and using-namespace directives from the top-level statement list.
+ * Recurses into LinkageSpecDecl nodes which may contain their own includes/usings.
+ *
+ * @param arkFile - Target ArkFile to populate with ImportInfo.
+ * @param astRoot - Root AST node returned by the C++ AST parser.
+ */
+function buildImportsOnly(arkFile, astRoot) {
+    var _a, _b;
+    // handle header units - process #include directives
+    (_a = astRoot.headerUnits) === null || _a === void 0 ? void 0 : _a.forEach((child) => {
+        var _a;
+        if (!child.includes) {
+            return;
+        }
+        for (const includeInfo of child.includes) {
+            if (includeInfo.kind !== ArkCxxAstNode_1.AstKind.InclusionDirective) {
+                logger.trace('Unprocess kind of header unit: ', (_a = includeInfo.kind) !== null && _a !== void 0 ? _a : includeInfo.includeName);
+                continue;
+            }
+            buildImportInfoFromInclude(includeInfo, child, astRoot, arkFile);
+        }
+    });
+    // handle non-header unit - only import-related declarations
+    const statements = (_b = astRoot.inner) !== null && _b !== void 0 ? _b : [];
+    statements.forEach((child) => {
+        switch (child.kind) {
+            case ArkCxxAstNode_1.AstKind.UsingDirectiveDecl:
+                buildImportInfoFromUsing(child, astRoot, arkFile);
+                break;
+            case ArkCxxAstNode_1.AstKind.LinkageSpecDecl:
+                buildImportsOnly(arkFile, child);
+                break;
+            default:
+                break;
+        }
+    });
+}
 /**
  * C++ AST manifest pipeline: addon emits per-TU records, consumed synchronously per record.
  */
 function prepareArkFiles(scene, absoluteSourceFiles, maxParallelProcesses = 1, maxPendingAstResults = 2, logAstInfo = false) {
     const arkFiles = [];
     const failedFiles = [];
-    const sources = absoluteSourceFiles.map((f) => path_1.default.resolve(f));
+    const sources = absoluteSourceFiles.map(f => path_1.default.resolve(f));
     if (sources.length === 0) {
         return { arkFiles, failedFiles };
     }
@@ -150,6 +214,45 @@ function prepareArkFile(scene, absoluteFilePath, targetArkFile, logAstInfo = fal
     }
 }
 exports.prepareArkFile = prepareArkFile;
+/**
+ * Imports-only variant of {@link prepareArkFile}. Parses the C++ AST for the given
+ * file and populates only basic file metadata and ImportInfo (#include directives
+ * and using-namespace declarations). Does NOT build ArkClass/ArkMethod/ArkNamespace/ArkBody.
+ *
+ * @param arkFile - Pre-allocated ArkFile to populate (must have scene and file path set).
+ */
+function buildImportExportInfoFromFile(arkFile) {
+    var _a, _b;
+    const scene = arkFile.getScene();
+    const sourceFile = path_1.default.resolve(arkFile.getFilePath());
+    const projectDir = scene.getRealProjectDir();
+    const includeDirs = scene.getIncludeDirs();
+    const logAstInfo = ((_b = (_a = scene.getOptions().languages) === null || _a === void 0 ? void 0 : _a.cpp) === null || _b === void 0 ? void 0 : _b.logAstInfo) === true;
+    const result = getAstParser().runCppAst({
+        scene,
+        sources: [sourceFile],
+        projectDir,
+        includeDirs,
+        maxParallelProcesses: 1,
+        maxPendingAstResults: 2,
+        logAstInfo,
+        onSourceAst: (source, astRoot) => {
+            try {
+                applyArkFileForImports(arkFile, source, astRoot);
+            }
+            catch (err) {
+                logger.warn(`Failed to apply C++ AST (imports-only) to ArkFile: ${source}`, err);
+            }
+        },
+    });
+    for (const e of result.dumpErrors) {
+        logger.warn(`C++ AST dump error for ${e.filePath}`, e.reason);
+    }
+    if (result.exitCode !== 0) {
+        logger.warn(`C++ single-file AST parse not completed successfully: ${sourceFile}`);
+    }
+}
+exports.buildImportExportInfoFromFile = buildImportExportInfoFromFile;
 exports.classMap = new Map();
 function buildArkClassFromCxxClass(classNode, arkFile, astRoot) {
     let cls = new ArkClass_1.ArkClass();

package/lib/index.d.ts

@@ -42,8 +42,15 @@ export { ViewTree, ViewTreeNode } from './core/graph/ViewTree';
 export { DominanceFinder } from './core/graph/DominanceFinder';
 export { DominanceTree } from './core/graph/DominanceTree';
 export { NodeID, Kind, BaseEdge, BaseNode, BaseExplicitGraph } from './core/graph/BaseExplicitGraph';
+export { BaseImplicitGraph } from './core/graph/BaseImplicitGraph';
 export { SCCDetection } from './core/graph/Scc';
+export { ModuleDepGraph, DependencyType } from './core/graph/ModuleDepGraph';
+export { FileDepGraph } from './core/graph/FileDepGraph';
 export { ArkFile } from './core/model/ArkFile';
+export { ArkModule, ModuleLoadState, ModuleType, ModuleID } from './core/model/ArkModule';
+export { ModuleDepthLevel } from './frontend/common/ModuleDepth';
+export { ModuleAnalysisConfig, ModuleAnalysisCallback } from './frontend/common/ModuleAnalysisConfig';
+export { ModuleBuilder } from './frontend/common/ModuleBuilder';
 export { ArkNamespace } from './core/model/ArkNamespace';
 export { ArkClass } from './core/model/ArkClass';
 export { ArkMethod } from './core/model/ArkMethod';
@@ -53,7 +60,7 @@ export { ImportInfo } from './core/model/ArkImport';
 export { ArkBody } from './core/model/ArkBody';
 export * from './core/model/ArkSignature';
 export * from './core/model/builder/ArkSignatureBuilder';
-export { SceneConfig, SceneOptions, buildSceneConfigFromProject, LanguageOptions, SceneLanguagesOptions, } from './Config';
+export { SceneConfig, SceneOptions, buildSceneConfigFromProject, LanguageOptions, SceneLanguagesOptions } from './Config';
 export { Scene } from './Scene';
 export { FrontendBuilder, FrontendParseFailure, FrontendParseResult } from './frontend/FrontendBuilder';
 export { ArktsFrontend } from './frontend/arktsFrontend/ArktsFrontend';
@@ -82,6 +89,7 @@ export { default as Logger } from './utils/logger';
 export { IntMap } from './utils/IntMap';
 export { IntWorkList } from './utils/IntWorkList';
 export { PackedSparseMap } from './utils/PackedSparseMap';
+export { Canonicalizer } from './utils/Canonicalizer';
 import ts from 'ohos-typescript';
 export { ts };
 //# sourceMappingURL=index.d.ts.map