arkanalyzer 1.0.5

package/lib/Scene.js

@@ -0,0 +1,762 @@
+"use strict";
+/*
+ * Copyright (c) 2024 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.ModuleScene = exports.Scene = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const ModelUtils_1 = require("./core/common/ModelUtils");
+const TypeInference_1 = require("./core/common/TypeInference");
+const VisibleValue_1 = require("./core/common/VisibleValue");
+const ArkFile_1 = require("./core/model/ArkFile");
+const ArkNamespace_1 = require("./core/model/ArkNamespace");
+const logger_1 = __importStar(require("./utils/logger"));
+const ArkFileBuilder_1 = require("./core/model/builder/ArkFileBuilder");
+const json5parser_1 = require("./utils/json5parser");
+const getAllFiles_1 = require("./utils/getAllFiles");
+const FileUtils_1 = require("./utils/FileUtils");
+const ArkExport_1 = require("./core/model/ArkExport");
+const ArkMethodBuilder_1 = require("./core/model/builder/ArkMethodBuilder");
+const Const_1 = require("./core/common/Const");
+const CallGraph_1 = require("./callgraph/model/CallGraph");
+const CallGraphBuilder_1 = require("./callgraph/model/builder/CallGraphBuilder");
+const logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'Scene');
+var SceneBuildStage;
+(function (SceneBuildStage) {
+    SceneBuildStage[SceneBuildStage["BUILD_INIT"] = 0] = "BUILD_INIT";
+    SceneBuildStage[SceneBuildStage["CLASS_DONE"] = 1] = "CLASS_DONE";
+    SceneBuildStage[SceneBuildStage["METHOD_DONE"] = 2] = "METHOD_DONE";
+})(SceneBuildStage || (SceneBuildStage = {}));
+;
+/**
+ * The Scene class includes everything in the analyzed project.
+ * We should be able to re-generate the project's code based on this class.
+ */
+class Scene {
+    constructor() {
+        this.projectName = '';
+        this.projectFiles = [];
+        this.realProjectDir = '';
+        this.moduleScenesMap = new Map();
+        this.modulePath2NameMap = new Map();
+        this.globalImportInfos = [];
+        this.moduleSdkMap = new Map();
+        this.projectSdkMap = new Map();
+        // values that are visible in curr scope
+        this.visibleValue = new VisibleValue_1.VisibleValue();
+        // signature string to model
+        this.filesMap = new Map();
+        this.namespacesMap = new Map();
+        this.classesMap = new Map();
+        this.methodsMap = new Map();
+        // TODO: type of key should be signature object
+        this.sdkArkFilesMap = new Map();
+        this.sdkGlobalMap = new Map();
+        this.ohPkgContentMap = new Map();
+        this.ohPkgFilePath = '';
+        this.ohPkgContent = {};
+        this.buildStage = SceneBuildStage.BUILD_INIT;
+    }
+    getStage() {
+        return this.buildStage;
+    }
+    buildSceneFromProjectDir(sceneConfig) {
+        this.buildBasicInfo(sceneConfig);
+        this.genArkFiles();
+        this.collectProjectImportInfos();
+    }
+    buildBasicInfo(sceneConfig) {
+        var _a;
+        this.projectName = sceneConfig.getTargetProjectName();
+        this.realProjectDir = fs_1.default.realpathSync(sceneConfig.getTargetProjectDirectory());
+        this.projectFiles = sceneConfig.getProjectFiles();
+        const buildProfile = path_1.default.join(this.realProjectDir, './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);
+            const modules = buildProfileJson.modules;
+            if (modules instanceof Array) {
+                modules.forEach((module) => {
+                    this.modulePath2NameMap.set(path_1.default.resolve(this.realProjectDir, path_1.default.join(module.srcPath)), module.name);
+                });
+            }
+        }
+        else {
+            logger.warn('There is no build-profile.json5 for this project.');
+        }
+        const OhPkgFilePath = path_1.default.join(this.realProjectDir, './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);
+        }
+        else {
+            logger.warn('This project has no oh-package.json5!');
+        }
+        // handle sdks
+        (_a = sceneConfig.getSdksObj()) === null || _a === void 0 ? void 0 : _a.forEach((sdk) => {
+            if (!sdk.moduleName) {
+                this.buildSdk(sdk.name, sdk.path);
+                this.projectSdkMap.set(sdk.name, sdk);
+            }
+            else {
+                let moduleSdks = this.moduleSdkMap.get(sdk.moduleName);
+                if (moduleSdks) {
+                    moduleSdks.push(sdk);
+                }
+                else {
+                    this.moduleSdkMap.set(sdk.moduleName, [sdk]);
+                }
+            }
+        });
+    }
+    addDefaultConstructors() {
+        for (const file of this.getFiles()) {
+            for (const cls of ModelUtils_1.ModelUtils.getAllClassesInFile(file)) {
+                (0, ArkMethodBuilder_1.buildDefaultConstructor)(cls);
+                (0, ArkMethodBuilder_1.addInitInConstructor)(cls);
+            }
+        }
+    }
+    buildAllMethodBody() {
+        this.buildStage = SceneBuildStage.CLASS_DONE;
+        for (const file of this.getFiles()) {
+            for (const cls of file.getClasses()) {
+                for (const method of cls.getMethods(true)) {
+                    method.buildBody();
+                }
+            }
+        }
+        for (const namespace of this.getNamespacesMap().values()) {
+            for (const cls of namespace.getClasses()) {
+                for (const method of cls.getMethods(true)) {
+                    method.buildBody();
+                }
+            }
+        }
+        this.buildStage = SceneBuildStage.METHOD_DONE;
+    }
+    genArkFiles() {
+        this.projectFiles.forEach((file) => {
+            logger.info('=== parse file:', file);
+            let arkFile = new ArkFile_1.ArkFile();
+            arkFile.setScene(this);
+            (0, ArkFileBuilder_1.buildArkFileFromFile)(file, this.realProjectDir, arkFile, this.projectName);
+            this.filesMap.set(arkFile.getFileSignature().toString(), arkFile);
+        });
+        this.buildAllMethodBody();
+        this.addDefaultConstructors();
+    }
+    buildSdk(sdkName, sdkPath) {
+        const allFiles = (0, getAllFiles_1.getAllFiles)(sdkPath, ['.ets', '.ts']);
+        allFiles.forEach((file) => {
+            logger.info('=== parse sdk file:', file);
+            let arkFile = new ArkFile_1.ArkFile();
+            arkFile.setScene(this);
+            (0, ArkFileBuilder_1.buildArkFileFromFile)(file, path_1.default.normalize(sdkPath), arkFile, sdkName);
+            ModelUtils_1.ModelUtils.getAllClassesInFile(arkFile).forEach(cls => { var _a; return (_a = cls.getDefaultArkMethod()) === null || _a === void 0 ? void 0 : _a.buildBody(); });
+            const fileSig = arkFile.getFileSignature().toString();
+            this.sdkArkFilesMap.set(fileSig, arkFile);
+        });
+    }
+    buildScene4HarmonyProject() {
+        this.modulePath2NameMap.forEach((value, key) => {
+            const moduleOhPkgFilePath = path_1.default.resolve(key, './oh-package.json5');
+            if (fs_1.default.existsSync(moduleOhPkgFilePath)) {
+                const moduleOhPkgContent = (0, json5parser_1.fetchDependenciesFromFile)(moduleOhPkgFilePath);
+                this.ohPkgContentMap.set(moduleOhPkgFilePath, moduleOhPkgContent);
+            }
+        });
+        this.modulePath2NameMap.forEach((value, key) => {
+            let moduleScene = new ModuleScene();
+            moduleScene.ModuleScenBuilder(value, key, this);
+            this.moduleScenesMap.set(value, moduleScene);
+        });
+        this.buildAllMethodBody();
+        this.addDefaultConstructors();
+    }
+    buildModuleScene(moduleName, modulePath) {
+        if (this.moduleScenesMap.get(moduleName)) {
+            return;
+        }
+        // get oh-package.json5
+        const moduleOhPkgFilePath = path_1.default.resolve(this.realProjectDir, path_1.default.join(modulePath, './oh-package.json5'));
+        if (fs_1.default.existsSync(moduleOhPkgFilePath)) {
+            const moduleOhPkgContent = (0, json5parser_1.fetchDependenciesFromFile)(moduleOhPkgFilePath);
+            this.ohPkgContentMap.set(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) {
+                Object.entries(moduleOhPkgContent.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), 'oh-package.json5');
+                            dependencyModulePath = path_1.default.dirname(dependencyOhPkgPath);
+                        }
+                        logger.info('Dependency path: ', dependencyModulePath);
+                        const dependencyModuleName = this.modulePath2NameMap.get(dependencyModulePath);
+                        if (dependencyModuleName) {
+                            this.buildModuleScene(dependencyModuleName, dependencyModulePath);
+                        }
+                    }
+                });
+            }
+        }
+        let moduleScene = new ModuleScene();
+        moduleScene.ModuleScenBuilder(moduleName, modulePath, this);
+        this.moduleScenesMap.set(moduleName, moduleScene);
+        this.buildAllMethodBody();
+    }
+    getRealProjectDir() {
+        return this.realProjectDir;
+    }
+    getProjectName() {
+        return this.projectName;
+    }
+    getProjectFiles() {
+        return this.projectFiles;
+    }
+    getSdkGlobal(globalName) {
+        return this.sdkGlobalMap.get(globalName) || null;
+    }
+    getFile(fileSignature) {
+        if (this.projectName === fileSignature.getProjectName()) {
+            return this.filesMap.get(fileSignature.toString()) || null;
+        }
+        else {
+            return this.sdkArkFilesMap.get(fileSignature.toString()) || null;
+        }
+    }
+    getFiles() {
+        return Array.from(this.filesMap.values());
+    }
+    getSdkArkFilesMap() {
+        return this.sdkArkFilesMap;
+    }
+    getModuleSdkMap() {
+        return this.moduleSdkMap;
+    }
+    getProjectSdkMap() {
+        return this.projectSdkMap;
+    }
+    getFilesMap() {
+        return this.filesMap;
+    }
+    getNamespace(namespaceSignature) {
+        if (this.projectName === namespaceSignature.getDeclaringFileSignature().getProjectName()) {
+            return this.getNamespacesMap().get(namespaceSignature.toString()) || null;
+        }
+        else {
+            const arkFile = this.sdkArkFilesMap.get(namespaceSignature.getDeclaringFileSignature().toString());
+            return (arkFile === null || arkFile === void 0 ? void 0 : arkFile.getNamespace(namespaceSignature)) || null;
+        }
+    }
+    getNamespacesMap() {
+        if (this.namespacesMap.size == 0) {
+            for (const file of this.getFiles()) {
+                ModelUtils_1.ModelUtils.getAllNamespacesInFile(file).forEach((namespace) => {
+                    this.namespacesMap.set(namespace.getNamespaceSignature().toString(), namespace);
+                });
+            }
+        }
+        return this.namespacesMap;
+    }
+    getNamespaces() {
+        return Array.from(this.getNamespacesMap().values());
+    }
+    getClass(classSignature, refresh) {
+        var _a;
+        if (this.projectName === classSignature.getDeclaringFileSignature().getProjectName()) {
+            return this.getClassesMap(refresh).get(classSignature.toString()) || null;
+        }
+        else {
+            const arkFile = this.sdkArkFilesMap.get(classSignature.getDeclaringFileSignature().toString());
+            const namespaceSignature = classSignature.getDeclaringNamespaceSignature();
+            if (namespaceSignature) {
+                return ((_a = arkFile === null || arkFile === void 0 ? void 0 : arkFile.getNamespace(namespaceSignature)) === null || _a === void 0 ? void 0 : _a.getClass(classSignature)) || null;
+            }
+            return (arkFile === null || arkFile === void 0 ? void 0 : arkFile.getClass(classSignature)) || null;
+        }
+    }
+    getClassesMap(refresh) {
+        if (refresh || (this.classesMap.size === 0 && this.buildStage >= SceneBuildStage.CLASS_DONE)) {
+            this.classesMap.clear();
+            for (const file of this.getFiles()) {
+                for (const cls of file.getClasses()) {
+                    this.classesMap.set(cls.getSignature().toString(), cls);
+                }
+            }
+            for (const namespace of this.getNamespacesMap().values()) {
+                for (const cls of namespace.getClasses()) {
+                    this.classesMap.set(cls.getSignature().toString(), cls);
+                }
+            }
+        }
+        return this.classesMap;
+    }
+    getClasses(refresh) {
+        return Array.from(this.getClassesMap(refresh).values());
+    }
+    getMethod(methodSignature, refresh) {
+        var _a;
+        if (this.projectName === methodSignature.getDeclaringClassSignature().getDeclaringFileSignature().getProjectName()) {
+            return this.getMethodsMap(refresh).get(methodSignature.toString()) || null;
+        }
+        else {
+            return ((_a = this.getClass(methodSignature.getDeclaringClassSignature())) === null || _a === void 0 ? void 0 : _a.getMethod(methodSignature)) || null;
+        }
+    }
+    getMethodsMap(refresh) {
+        if (refresh || (this.methodsMap.size === 0 && this.buildStage >= SceneBuildStage.METHOD_DONE)) {
+            this.methodsMap.clear();
+            for (const cls of this.getClassesMap().values()) {
+                for (const method of cls.getMethods(true)) {
+                    this.methodsMap.set(method.getSignature().toString(), method);
+                }
+            }
+        }
+        return this.methodsMap;
+    }
+    getMethods(refresh) {
+        return Array.from(this.getMethodsMap(refresh).values());
+    }
+    addToMethodsMap(method) {
+        this.methodsMap.set(method.getSignature().toString(), method);
+    }
+    hasMainMethod() {
+        return false;
+    }
+    //Get the set of entry points that are used to build the call graph.
+    getEntryPoints() {
+        return [];
+    }
+    /** get values that is visible in curr scope */
+    getVisibleValue() {
+        return this.visibleValue;
+    }
+    getOhPkgContent() {
+        return this.ohPkgContent;
+    }
+    getOhPkgContentMap() {
+        return this.ohPkgContentMap;
+    }
+    getOhPkgFilePath() {
+        return this.ohPkgFilePath;
+    }
+    makeCallGraphCHA(entryPoints) {
+        let callGraph = new CallGraph_1.CallGraph(this);
+        let callGraphBuilder = new CallGraphBuilder_1.CallGraphBuilder(callGraph, this);
+        callGraphBuilder.buildClassHierarchyCallGraph(entryPoints);
+        return callGraph;
+    }
+    makeCallGraphRTA(entryPoints) {
+        let callGraph = new CallGraph_1.CallGraph(this);
+        let callGraphBuilder = new CallGraphBuilder_1.CallGraphBuilder(callGraph, this);
+        callGraphBuilder.buildRapidTypeCallGraph(entryPoints);
+        return callGraph;
+    }
+    /**
+     * inference type for each non-default method
+     * because default and generated method was finished
+     */
+    inferTypes() {
+        this.sdkArkFilesMap.forEach(file => {
+            ModelUtils_1.ModelUtils.buildGlobalMap(file, this.sdkGlobalMap);
+        });
+        this.filesMap.forEach(file => {
+            ModelUtils_1.ModelUtils.getAllClassesInFile(file).forEach(arkClass => {
+                TypeInference_1.TypeInference.inferGenericType(arkClass.getGenericsTypes(), arkClass);
+                arkClass.getFields().forEach(arkField => TypeInference_1.TypeInference.inferTypeInArkField(arkField));
+                const defaultArkMethod = arkClass.getDefaultArkMethod();
+                if (defaultArkMethod) {
+                    TypeInference_1.TypeInference.inferTypeInMethod(defaultArkMethod);
+                }
+                arkClass.getMethods().forEach(arkMethod => TypeInference_1.TypeInference.inferTypeInMethod(arkMethod));
+            });
+        });
+        this.getClassesMap(true);
+        this.getMethodsMap(true);
+    }
+    /**
+     * @Deprecated
+     */
+    inferSimpleTypes() {
+        for (let arkFile of this.getFiles()) {
+            for (let arkClass of arkFile.getClasses()) {
+                for (let arkMethod of arkClass.getMethods()) {
+                    TypeInference_1.TypeInference.inferSimpleTypeInMethod(arkMethod);
+                }
+            }
+        }
+    }
+    collectProjectImportInfos() {
+        this.getFiles().forEach((arkFile) => {
+            arkFile.getImportInfos().forEach((importInfo) => {
+                this.globalImportInfos.push(importInfo);
+            });
+        });
+    }
+    getClassMap() {
+        var _a, _b, _c, _d;
+        const classMap = new Map();
+        for (const file of this.getFiles()) {
+            const fileClass = [];
+            const namespaceStack = [];
+            const parentMap = new Map();
+            const finalNamespaces = [];
+            for (const arkClass of file.getClasses()) {
+                fileClass.push(arkClass);
+            }
+            for (const ns of file.getNamespaces()) {
+                namespaceStack.push(ns);
+                parentMap.set(ns, file);
+            }
+            classMap.set(file.getFileSignature(), fileClass);
+            // 第一轮遍历，加上每个namespace自己的class
+            while (namespaceStack.length > 0) {
+                const ns = namespaceStack.shift();
+                const nsClass = [];
+                for (const arkClass of ns.getClasses()) {
+                    nsClass.push(arkClass);
+                }
+                classMap.set(ns.getNamespaceSignature(), nsClass);
+                if (ns.getNamespaces().length == 0) {
+                    finalNamespaces.push(ns);
+                }
+                else {
+                    for (const nsns of ns.getNamespaces()) {
+                        namespaceStack.push(nsns);
+                        parentMap.set(nsns, ns);
+                    }
+                }
+            }
+            // 第二轮遍历，父节点加上子节点的export的class
+            while (finalNamespaces.length > 0) {
+                const finalNS = finalNamespaces.shift();
+                const exportClass = [];
+                for (const arkClass of finalNS.getClasses()) {
+                    if (arkClass.isExported()) {
+                        exportClass.push(arkClass);
+                    }
+                }
+                const parent = parentMap.get(finalNS);
+                if (parent instanceof ArkNamespace_1.ArkNamespace) {
+                    (_a = classMap.get(parent.getNamespaceSignature())) === null || _a === void 0 ? void 0 : _a.push(...exportClass);
+                }
+                else if (parent instanceof ArkFile_1.ArkFile) {
+                    (_b = classMap.get(parent.getFileSignature())) === null || _b === void 0 ? void 0 : _b.push(...exportClass);
+                }
+                let p = finalNS;
+                while (!(parentMap.get(p) instanceof ArkFile_1.ArkFile) && p.isExported()) {
+                    const grandParent = parentMap.get(parentMap.get(p));
+                    if (grandParent instanceof ArkNamespace_1.ArkNamespace) {
+                        (_c = classMap.get(grandParent.getNamespaceSignature())) === null || _c === void 0 ? void 0 : _c.push(...exportClass);
+                        p = parentMap.get(p);
+                    }
+                    else if (grandParent instanceof ArkFile_1.ArkFile) {
+                        (_d = classMap.get(grandParent.getFileSignature())) === null || _d === void 0 ? void 0 : _d.push(...exportClass);
+                        break;
+                    }
+                }
+                if (parent instanceof ArkNamespace_1.ArkNamespace && !finalNamespaces.includes(parent)) {
+                    finalNamespaces.push(parent);
+                }
+            }
+        }
+        for (const file of this.getFiles()) {
+            // 文件加上import的class，包括ns的
+            const importClasses = [];
+            const importNameSpaces = [];
+            for (const importInfo of file.getImportInfos()) {
+                const importClass = ModelUtils_1.ModelUtils.getClassInImportInfoWithName(importInfo.getImportClauseName(), file);
+                if (importClass && !importClasses.includes(importClass)) {
+                    importClasses.push(importClass);
+                    continue;
+                }
+                const importNameSpace = ModelUtils_1.ModelUtils.getNamespaceInImportInfoWithName(importInfo.getImportClauseName(), file);
+                if (importNameSpace && !importNameSpaces.includes(importNameSpace)) {
+                    try {
+                        // 遗留问题：只统计了项目文件的namespace，没统计sdk文件内部的引入
+                        const importNameSpaceClasses = classMap.get(importNameSpace.getNamespaceSignature());
+                        importClasses.push(...importNameSpaceClasses.filter(c => !importClasses.includes(c) && c.getName() != '_DEFAULT_ARK_CLASS'));
+                    }
+                    catch (_e) {
+                    }
+                }
+            }
+            const fileClasses = classMap.get(file.getFileSignature());
+            fileClasses.push(...importClasses.filter(c => !fileClasses.includes(c)));
+            // 子节点加上父节点的class
+            const namespaceStack = [...file.getNamespaces()];
+            for (const ns of namespaceStack) {
+                const nsClasses = classMap.get(ns.getNamespaceSignature());
+                nsClasses.push(...fileClasses.filter(c => !nsClasses.includes(c) && c.getName() != '_DEFAULT_ARK_CLASS'));
+            }
+            while (namespaceStack.length > 0) {
+                const ns = namespaceStack.shift();
+                const nsClasses = classMap.get(ns.getNamespaceSignature());
+                for (const nsns of ns.getNamespaces()) {
+                    const nsnsClasses = classMap.get(nsns.getNamespaceSignature());
+                    nsnsClasses.push(...nsClasses.filter(c => !nsnsClasses.includes(c) && c.getName() != '_DEFAULT_ARK_CLASS'));
+                    namespaceStack.push(nsns);
+                }
+            }
+        }
+        return classMap;
+    }
+    getGlobalVariableMap() {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const globalVariableMap = new Map();
+        for (const file of this.getFiles()) {
+            const namespaceStack = [];
+            const parentMap = new Map();
+            const finalNamespaces = [];
+            const globalLocals = [];
+            (_b = (_a = file.getDefaultClass()) === null || _a === void 0 ? void 0 : _a.getDefaultArkMethod().getBody()) === null || _b === void 0 ? void 0 : _b.getLocals().forEach(local => {
+                if (local.getDeclaringStmt() && local.getName() != 'this' && local.getName()[0] != '$') {
+                    globalLocals.push(local);
+                }
+            });
+            globalVariableMap.set(file.getFileSignature(), globalLocals);
+            for (const ns of file.getNamespaces()) {
+                namespaceStack.push(ns);
+                parentMap.set(ns, file);
+            }
+            // 第一轮遍历，加上每个namespace自己的local
+            while (namespaceStack.length > 0) {
+                const ns = namespaceStack.shift();
+                const nsGlobalLocals = [];
+                (_c = ns.getDefaultClass().getDefaultArkMethod().getBody()) === null || _c === void 0 ? void 0 : _c.getLocals().forEach(local => {
+                    if (local.getDeclaringStmt() && local.getName() != 'this' && local.getName()[0] != '$') {
+                        nsGlobalLocals.push(local);
+                    }
+                });
+                globalVariableMap.set(ns.getNamespaceSignature(), nsGlobalLocals);
+                if (ns.getNamespaces().length == 0) {
+                    finalNamespaces.push(ns);
+                }
+                else {
+                    for (const nsns of ns.getNamespaces()) {
+                        namespaceStack.push(nsns);
+                        parentMap.set(nsns, ns);
+                    }
+                }
+            }
+            // 第二轮遍历，父节点加上子节点的export的local
+            while (finalNamespaces.length > 0) {
+                const finalNS = finalNamespaces.shift();
+                const exportLocal = [];
+                for (const exportInfo of finalNS.getExportInfos()) {
+                    if (exportInfo.getExportClauseType() === ArkExport_1.ExportType.LOCAL && exportInfo.getArkExport()) {
+                        exportLocal.push(exportInfo.getArkExport());
+                    }
+                }
+                const parent = parentMap.get(finalNS);
+                if (parent instanceof ArkNamespace_1.ArkNamespace) {
+                    (_d = globalVariableMap.get(parent.getNamespaceSignature())) === null || _d === void 0 ? void 0 : _d.push(...exportLocal);
+                }
+                else if (parent instanceof ArkFile_1.ArkFile) {
+                    (_e = globalVariableMap.get(parent.getFileSignature())) === null || _e === void 0 ? void 0 : _e.push(...exportLocal);
+                }
+                let p = finalNS;
+                while (!(parentMap.get(p) instanceof ArkFile_1.ArkFile) && p.isExported()) {
+                    const grandParent = parentMap.get(parentMap.get(p));
+                    if (grandParent instanceof ArkNamespace_1.ArkNamespace) {
+                        (_f = globalVariableMap.get(grandParent.getNamespaceSignature())) === null || _f === void 0 ? void 0 : _f.push(...exportLocal);
+                        p = parentMap.get(p);
+                    }
+                    else if (grandParent instanceof ArkFile_1.ArkFile) {
+                        (_g = globalVariableMap.get(grandParent.getFileSignature())) === null || _g === void 0 ? void 0 : _g.push(...exportLocal);
+                        break;
+                    }
+                }
+                if (parent instanceof ArkNamespace_1.ArkNamespace && !finalNamespaces.includes(parent)) {
+                    finalNamespaces.push(parent);
+                }
+            }
+        }
+        for (const file of this.getFiles()) {
+            // 文件加上import的local，包括ns的
+            const importLocals = [];
+            const importNameSpaces = [];
+            for (const importInfo of file.getImportInfos()) {
+                const importLocal = ModelUtils_1.ModelUtils.getLocalInImportInfoWithName(importInfo.getImportClauseName(), file);
+                if (importLocal && !importLocals.includes(importLocal)) {
+                    importLocals.push(importLocal);
+                }
+                const importNameSpace = ModelUtils_1.ModelUtils.getNamespaceInImportInfoWithName(importInfo.getImportClauseName(), file);
+                if (importNameSpace && !importNameSpaces.includes(importNameSpace)) {
+                    try {
+                        // 遗留问题：只统计了项目文件，没统计sdk文件内部的引入
+                        const importNameSpaceClasses = globalVariableMap.get(importNameSpace.getNamespaceSignature());
+                        importLocals.push(...importNameSpaceClasses.filter(c => !importLocals.includes(c) && c.getName() != '_DEFAULT_ARK_CLASS'));
+                    }
+                    catch (_h) {
+                    }
+                }
+            }
+            const fileLocals = globalVariableMap.get(file.getFileSignature());
+            fileLocals.push(...importLocals.filter(c => !fileLocals.includes(c)));
+            // 子节点加上父节点的local
+            const namespaceStack = [...file.getNamespaces()];
+            for (const ns of namespaceStack) {
+                const nsLocals = globalVariableMap.get(ns.getNamespaceSignature());
+                const nsLocalNameSet = new Set(nsLocals.map(item => item.getName()));
+                for (const local of fileLocals) {
+                    if (!nsLocalNameSet.has(local.getName())) {
+                        nsLocals.push(local);
+                    }
+                }
+            }
+            while (namespaceStack.length > 0) {
+                const ns = namespaceStack.shift();
+                const nsLocals = globalVariableMap.get(ns.getNamespaceSignature());
+                for (const nsns of ns.getNamespaces()) {
+                    const nsnsLocals = globalVariableMap.get(nsns.getNamespaceSignature());
+                    const nsnsLocalNameSet = new Set(nsnsLocals.map(item => item.getName()));
+                    for (const local of nsLocals) {
+                        if (!nsnsLocalNameSet.has(local.getName())) {
+                            nsnsLocals.push(local);
+                        }
+                    }
+                    namespaceStack.push(nsns);
+                }
+            }
+        }
+        return globalVariableMap;
+    }
+    getStaticInitMethods() {
+        const staticInitMethods = [];
+        for (const method of Array.from(this.getMethodsMap(true).values())) {
+            if (method.getName() == Const_1.STATIC_INIT_METHOD_NAME) {
+                staticInitMethods.push(method);
+            }
+        }
+        return staticInitMethods;
+    }
+    buildClassDone() {
+        return this.buildStage >= SceneBuildStage.CLASS_DONE;
+    }
+    getModuleScene(moduleName) {
+        return this.moduleScenesMap.get(moduleName);
+    }
+    getModuleSceneMap() {
+        return this.moduleScenesMap;
+    }
+}
+exports.Scene = Scene;
+class ModuleScene {
+    constructor() {
+        this.projectScene = new Scene();
+        this.moduleName = '';
+        this.modulePath = '';
+        this.moduleOhPkgFilePath = '';
+        this.ohPkgContent = {};
+    }
+    ModuleScenBuilder(moduleName, modulePath, projectScene, recursively = false) {
+        this.moduleName = moduleName;
+        this.modulePath = modulePath;
+        this.projectScene = projectScene;
+        this.getModuleOhPkgFilePath();
+        if (this.moduleOhPkgFilePath) {
+            this.ohPkgContent = (0, json5parser_1.fetchDependenciesFromFile)(this.moduleOhPkgFilePath);
+        }
+        else {
+            logger.warn('This module has no oh-package.json5!');
+        }
+        this.genArkFiles();
+    }
+    /**
+     * get oh-package.json5
+     */
+    getModuleOhPkgFilePath() {
+        const moduleOhPkgFilePath = path_1.default.resolve(this.projectScene.getRealProjectDir(), path_1.default.join(this.modulePath, './oh-package.json5'));
+        if (fs_1.default.existsSync(moduleOhPkgFilePath)) {
+            this.moduleOhPkgFilePath = moduleOhPkgFilePath;
+        }
+    }
+    /**
+     * get nodule name
+     * @returns return module name
+     */
+    getModuleName() {
+        return this.moduleName;
+    }
+    getModulePath() {
+        return this.modulePath;
+    }
+    getOhPkgFilePath() {
+        return this.moduleOhPkgFilePath;
+    }
+    getOhPkgContent() {
+        return this.ohPkgContent;
+    }
+    genArkFiles() {
+        (0, getAllFiles_1.getAllFiles)(this.modulePath, ['.ets', '.ts']).forEach((file) => {
+            logger.info('=== parse file:', file);
+            let arkFile = new ArkFile_1.ArkFile();
+            arkFile.setScene(this.projectScene);
+            arkFile.setModuleScene(this);
+            (0, ArkFileBuilder_1.buildArkFileFromFile)(file, this.projectScene.getRealProjectDir(), arkFile, this.projectScene.getProjectName());
+            const fileSig = arkFile.getFileSignature().toString();
+            this.projectScene.getFilesMap().set(fileSig, arkFile);
+        });
+    }
+}
+exports.ModuleScene = ModuleScene;