arkanalyzer 1.0.5

package/lib/core/common/ModelUtils.js

@@ -0,0 +1,628 @@
+"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.findArkExportInFile = exports.findExportInfo = exports.getArkFile = exports.ModelUtils = void 0;
+const Local_1 = require("../base/Local");
+const ArkClass_1 = require("../model/ArkClass");
+const ArkMethod_1 = require("../model/ArkMethod");
+const ArkNamespace_1 = require("../model/ArkNamespace");
+const ArkSignature_1 = require("../model/ArkSignature");
+const ArkExport_1 = require("../model/ArkExport");
+const logger_1 = __importStar(require("../../utils/logger"));
+const FileUtils_1 = require("../../utils/FileUtils");
+const path_1 = __importDefault(require("path"));
+const pathTransfer_1 = require("../../utils/pathTransfer");
+const TSConst_1 = require("./TSConst");
+const ArkExportBuilder_1 = require("../model/builder/ArkExportBuilder");
+const EtsConst_1 = require("./EtsConst");
+const Type_1 = require("../base/Type");
+class ModelUtils {
+    static getMethodSignatureFromArkClass(arkClass, methodName) {
+        for (const arkMethod of arkClass.getMethods()) {
+            if (arkMethod.getName() == methodName) {
+                return arkMethod.getSignature();
+            }
+        }
+        return null;
+    }
+    static getClassWithNameInNamespaceRecursively(className, ns) {
+        if (className == '') {
+            return null;
+        }
+        let res = null;
+        res = ns.getClassWithName(className);
+        if (res == null) {
+            let declaringNs = ns.getDeclaringArkNamespace();
+            if (declaringNs != null) {
+                res = this.getClassWithNameInNamespaceRecursively(className, declaringNs);
+            }
+            else {
+                res = this.getClassInFileWithName(className, ns.getDeclaringArkFile());
+            }
+        }
+        return res;
+    }
+    static getClassWithNameFromClass(className, startFrom) {
+        if (!className.includes('.')) {
+            let res = null;
+            const arkNamespace = startFrom.getDeclaringArkNamespace();
+            if (arkNamespace) {
+                res = this.getClassWithNameInNamespaceRecursively(className, arkNamespace);
+            }
+            else {
+                res = this.getClassInFileWithName(className, startFrom.getDeclaringArkFile());
+            }
+            return res;
+        }
+        else {
+            const names = className.split('.');
+            let nameSpace = this.getNamespaceWithNameFromClass(names[0], startFrom);
+            for (let i = 1; i < names.length - 1; i++) {
+                if (nameSpace)
+                    nameSpace = nameSpace.getNamespaceWithName(names[i]);
+            }
+            if (nameSpace) {
+                return nameSpace.getClassWithName(names[names.length - 1]);
+            }
+        }
+        return null;
+    }
+    /**
+     *  search class within the file that contain the given method
+     */
+    static getClassWithName(className, thisClass) {
+        var _a;
+        if (thisClass.getName() == className) {
+            return thisClass;
+        }
+        let classSearched = (_a = thisClass.getDeclaringArkNamespace()) === null || _a === void 0 ? void 0 : _a.getClassWithName(className);
+        if (!classSearched) {
+            classSearched = thisClass.getDeclaringArkFile().getClassWithName(className);
+        }
+        return classSearched;
+    }
+    /** search class within the given file */
+    static getClassInFileWithName(className, arkFile) {
+        let classSearched = arkFile.getClassWithName(className);
+        if (classSearched != null) {
+            return classSearched;
+        }
+        return null;
+    }
+    static getClassInImportInfoWithName(className, arkFile) {
+        let arkExport = this.getArkExportInImportInfoWithName(className, arkFile);
+        if (arkExport instanceof ArkClass_1.ArkClass) {
+            return arkExport;
+        }
+        return null;
+    }
+    /** search type within the given file import infos */
+    static getArkExportInImportInfoWithName(name, arkFile) {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = arkFile.getImportInfoBy(name)) === null || _a === void 0 ? void 0 : _a.getLazyExportInfo()) === null || _b === void 0 ? void 0 : _b.getArkExport()) !== null && _c !== void 0 ? _c : null;
+    }
+    /** search method within the file that contain the given method */
+    static getMethodWithName(methodName, startFrom) {
+        if (!methodName.includes('.')) {
+            if (startFrom.getName() == methodName) {
+                return startFrom;
+            }
+            const thisClass = startFrom.getDeclaringArkClass();
+            let methodSearched = thisClass.getMethodWithName(methodName);
+            if (!methodSearched) {
+                methodSearched = thisClass.getStaticMethodWithName(methodName);
+            }
+            return methodSearched;
+        }
+        else {
+            const names = methodName.split('.');
+            let nameSpace = this.getNamespaceWithName(names[0], startFrom.getDeclaringArkClass());
+            for (let i = 1; i < names.length - 1; i++) {
+                if (nameSpace) {
+                    nameSpace = nameSpace.getNamespaceWithName(names[i]);
+                }
+            }
+            if (nameSpace) {
+                return nameSpace.getDefaultClass().getMethodWithName(names[names.length - 1]);
+            }
+        }
+        return null;
+    }
+    static getNamespaceWithNameFromClass(namespaceName, startFrom) {
+        const thisNamespace = startFrom.getDeclaringArkNamespace();
+        let namespaceSearched = null;
+        if (thisNamespace) {
+            namespaceSearched = thisNamespace.getNamespaceWithName(namespaceName);
+            if (namespaceSearched) {
+                return namespaceSearched;
+            }
+        }
+        const thisFile = startFrom.getDeclaringArkFile();
+        namespaceSearched = this.getNamespaceInFileWithName(namespaceName, thisFile);
+        return namespaceSearched;
+    }
+    static getNamespaceWithName(namespaceName, thisClass) {
+        const thisNamespace = thisClass.getDeclaringArkNamespace();
+        let namespaceSearched = null;
+        if (thisNamespace) {
+            namespaceSearched = thisNamespace.getNamespaceWithName(namespaceName);
+        }
+        if (!namespaceSearched) {
+            namespaceSearched = thisClass.getDeclaringArkFile().getNamespaceWithName(namespaceName);
+        }
+        return namespaceSearched;
+    }
+    static getNamespaceInFileWithName(namespaceName, arkFile) {
+        let namespaceSearched = arkFile.getNamespaceWithName(namespaceName);
+        if (namespaceSearched) {
+            return namespaceSearched;
+        }
+        return null;
+    }
+    static getNamespaceInImportInfoWithName(namespaceName, arkFile) {
+        let arkExport = this.getArkExportInImportInfoWithName(namespaceName, arkFile);
+        if (arkExport instanceof ArkNamespace_1.ArkNamespace) {
+            return arkExport;
+        }
+        return null;
+    }
+    static getStaticMethodWithName(methodName, thisClass) {
+        const thisNamespace = thisClass.getDeclaringArkNamespace();
+        if (thisNamespace) {
+            const defaultClass = thisNamespace.getClassWithName('_DEFAULT_ARK_CLASS');
+            if (defaultClass) {
+                const method = defaultClass.getMethodWithName(methodName);
+                if (method) {
+                    return method;
+                }
+            }
+        }
+        return this.getStaticMethodInFileWithName(methodName, thisClass.getDeclaringArkFile());
+    }
+    static getStaticMethodInFileWithName(methodName, arkFile) {
+        const defaultClass = arkFile.getClasses().find(cls => cls.getName() == '_DEFAULT_ARK_CLASS') || null;
+        if (defaultClass) {
+            let method = defaultClass.getMethodWithName(methodName);
+            if (method) {
+                return method;
+            }
+        }
+        return null;
+    }
+    static getStaticMethodInImportInfoWithName(methodName, arkFile) {
+        let arkExport = this.getArkExportInImportInfoWithName(methodName, arkFile);
+        if (arkExport instanceof ArkMethod_1.ArkMethod) {
+            return arkExport;
+        }
+        return null;
+    }
+    static getLocalInImportInfoWithName(localName, arkFile) {
+        let arkExport = this.getArkExportInImportInfoWithName(localName, arkFile);
+        if (arkExport instanceof Local_1.Local) {
+            return arkExport;
+        }
+        return null;
+    }
+    /* get nested namespaces in a file */
+    static getAllNamespacesInFile(arkFile) {
+        const arkNamespaces = arkFile.getNamespaces();
+        for (const arkNamespace of arkFile.getNamespaces()) {
+            this.getAllNamespacesInNamespace(arkNamespace, arkNamespaces);
+        }
+        return arkNamespaces;
+    }
+    /* get nested namespaces in a namespace */
+    static getAllNamespacesInNamespace(arkNamespace, allNamespaces) {
+        allNamespaces.push(...arkNamespace.getNamespaces());
+        for (const nestedNamespace of arkNamespace.getNamespaces()) {
+            this.getAllNamespacesInNamespace(nestedNamespace, allNamespaces);
+        }
+    }
+    static getAllClassesInFile(arkFile) {
+        const allClasses = arkFile.getClasses();
+        this.getAllNamespacesInFile(arkFile).forEach((namespace) => {
+            allClasses.push(...namespace.getClasses());
+        });
+        return allClasses;
+    }
+    static getAllMethodsInFile(arkFile) {
+        const allMethods = [];
+        this.getAllClassesInFile(arkFile).forEach((cls) => {
+            allMethods.push(...cls.getMethods());
+        });
+        return allMethods;
+    }
+    static isArkUIBuilderMethod(arkMethod) {
+        let isArkUIBuilderMethod = arkMethod.hasBuilderDecorator() || this.implicitArkUIBuilderMethods.has(arkMethod);
+        if (!isArkUIBuilderMethod &&
+            arkMethod.getName() == 'build' &&
+            arkMethod.getDeclaringArkClass().hasComponentDecorator() &&
+            !arkMethod.containsModifier('StaticKeyword')) {
+            const fileName = arkMethod.getDeclaringArkClass().getDeclaringArkFile().getName();
+            if (fileName.endsWith('.ets')) {
+                isArkUIBuilderMethod = true;
+            }
+        }
+        return isArkUIBuilderMethod;
+    }
+    static getArkClassInBuild(scene, classType) {
+        var _a;
+        const classSignature = classType.getClassSignature();
+        const file = scene.getFile(classSignature.getDeclaringFileSignature());
+        const namespaceSignature = classSignature.getDeclaringNamespaceSignature();
+        if (namespaceSignature) {
+            return ((_a = file === null || file === void 0 ? void 0 : file.getNamespace(namespaceSignature)) === null || _a === void 0 ? void 0 : _a.getClass(classSignature)) || null;
+        }
+        return (file === null || file === void 0 ? void 0 : file.getClassWithName(classSignature.getClassName())) || null;
+    }
+    static getDefaultClass(arkClass) {
+        var _a, _b;
+        return (_b = (_a = arkClass.getDeclaringArkNamespace()) === null || _a === void 0 ? void 0 : _a.getDefaultClass()) !== null && _b !== void 0 ? _b : arkClass.getDeclaringArkFile().getDefaultClass();
+    }
+    static getClass(method, signature) {
+        var _a;
+        let cls = method.getDeclaringArkFile().getScene().getClass(signature);
+        if (cls) {
+            return cls;
+        }
+        let importInfo = method.getDeclaringArkFile().getImportInfoBy(signature.getClassName());
+        let exportInfo = importInfo ? findExportInfo(importInfo) : null;
+        let arkExport = exportInfo === null || exportInfo === void 0 ? void 0 : exportInfo.getArkExport();
+        if (arkExport instanceof ArkClass_1.ArkClass) {
+            return arkExport;
+        }
+        cls = (_a = method.getDeclaringArkClass().getDeclaringArkNamespace()) === null || _a === void 0 ? void 0 : _a.getClassWithName(signature.getClassName());
+        if (cls) {
+            return cls;
+        }
+        for (const ns of method.getDeclaringArkFile().getAllNamespacesUnderThisFile()) {
+            cls = ns.getClassWithName(signature.getClassName());
+            if (cls) {
+                return cls;
+            }
+        }
+        return method.getDeclaringArkFile().getClassWithName(signature.getClassName());
+    }
+    static findPropertyInNamespace(name, namespace) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+        return (_j = (_e = (_d = (_c = (_b = (_a = namespace.getDefaultClass()) === null || _a === void 0 ? void 0 : _a.getMethodWithName(name)) !== null && _b !== void 0 ? _b : findArkExport(namespace.getExportInfoBy(name))) !== null && _c !== void 0 ? _c : namespace.getClassWithName(name)) !== null && _d !== void 0 ? _d : namespace.getNamespaceWithName(name)) !== null && _e !== void 0 ? _e : (_h = (_g = (_f = namespace.getDefaultClass()) === null || _f === void 0 ? void 0 : _f.getDefaultArkMethod()) === null || _g === void 0 ? void 0 : _g.getBody()) === null || _h === void 0 ? void 0 : _h.getAliasTypeByName(name)) !== null && _j !== void 0 ? _j : (_o = (_m = (_l = (_k = namespace.getDefaultClass()) === null || _k === void 0 ? void 0 : _k.getDefaultArkMethod()) === null || _l === void 0 ? void 0 : _l.getBody()) === null || _m === void 0 ? void 0 : _m.getLocals()) === null || _o === void 0 ? void 0 : _o.get(name);
+    }
+    static findPropertyInClass(name, arkClass) {
+        var _a, _b, _c, _d;
+        let arkMethod = (_b = (_a = arkClass.getMethodWithName(name)) !== null && _a !== void 0 ? _a : arkClass.getStaticMethodWithName(name)) !== null && _b !== void 0 ? _b : (_c = arkClass.getSuperClass()) === null || _c === void 0 ? void 0 : _c.getMethodWithName(name);
+        if (arkMethod) {
+            return arkMethod;
+        }
+        const arkField = (_d = arkClass.getFieldWithName(name)) !== null && _d !== void 0 ? _d : arkClass.getStaticFieldWithName(name);
+        if (arkField) {
+            return arkField;
+        }
+        if (arkClass.isDefaultArkClass()) {
+            return findArkExport(arkClass.getDeclaringArkFile().getExportInfoBy(name));
+        }
+        return null;
+    }
+    static buildGlobalMap(file, globalMap) {
+        var _a, _b;
+        if (file.getFilePath().includes(EtsConst_1.COMPONENT_PATH) || file.getFilePath().includes(EtsConst_1.API_INTERNAL)) {
+            this.getAllClassesInFile(file).forEach(cls => {
+                if (!cls.isAnonymousClass()) {
+                    globalMap.set(cls.getName(), cls);
+                    cls.getMethods().forEach(mtd => {
+                        if (!mtd.isDefaultArkMethod() && !mtd.isAnonymousMethod()) {
+                            globalMap.set(mtd.getName(), mtd);
+                        }
+                    });
+                }
+            });
+            (_b = (_a = file.getDefaultClass().getDefaultArkMethod()) === null || _a === void 0 ? void 0 : _a.getBody()) === null || _b === void 0 ? void 0 : _b.getLocals().forEach(local => {
+                const name = local.getName();
+                if (name !== TSConst_1.THIS_NAME && !name.startsWith(TSConst_1.TEMP_LOCAL_PREFIX) && !name.endsWith(EtsConst_1.COMPONENT_INSTANCE)) {
+                    const type = local.getType();
+                    let arkExport;
+                    if (type instanceof Type_1.UnclearReferenceType) {
+                        arkExport = findArkExportInFile(type.getName(), file);
+                    }
+                    else if (type instanceof Type_1.ClassType) {
+                        arkExport = file.getScene().getClass(type.getClassSignature());
+                    }
+                    if (arkExport instanceof ArkClass_1.ArkClass) {
+                        const signature = new ArkSignature_1.ClassSignature(name, arkExport.getSignature().getDeclaringFileSignature(), arkExport.getSignature().getDeclaringNamespaceSignature());
+                        let entry = new ArkClass_1.ArkClass();
+                        entry.setSignature(signature);
+                        arkExport.getMethods().forEach(m => {
+                            const ms = m.getSignature();
+                            m.setSignature(new ArkSignature_1.MethodSignature(signature, ms.getMethodSubSignature()));
+                            entry.addMethod(m);
+                        });
+                        const attr = globalMap.get(name + EtsConst_1.COMPONENT_ATTRIBUTE);
+                        if (attr instanceof ArkClass_1.ArkClass) {
+                            attr.getMethods().forEach(m => {
+                                const ms = m.getSignature();
+                                m.setSignature(new ArkSignature_1.MethodSignature(signature, ms.getMethodSubSignature()));
+                                entry.addMethod(m);
+                            });
+                        }
+                        globalMap.set(name, entry);
+                    }
+                }
+            });
+        }
+    }
+}
+exports.ModelUtils = ModelUtils;
+ModelUtils.implicitArkUIBuilderMethods = new Set();
+const logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'ModelUtils');
+let moduleMap = undefined;
+const fileSuffixArray = ['.ets: ', '.ts: ', '.d.ets: ', '.d.ts: '];
+/**
+ * find arkFile by from info
+ * export xx from '../xx'
+ * import xx from '@ohos/xx'
+ * import xx from '@ohos.xx'
+ * @param im importInfo or exportInfo
+ */
+function getArkFile(im) {
+    const from = im.getFrom();
+    if (!from) {
+        return null;
+    }
+    if (/^([^@]*\/)([^\/]*)$/.test(from)) { //relative path
+        const parentPath = /^\.{1,2}\//.test(from) ? path_1.default.dirname(im.getDeclaringArkFile().getFilePath())
+            : im.getDeclaringArkFile().getProjectDir();
+        const originPath = path_1.default.resolve(parentPath, from);
+        return getArkFileFromScene(im, originPath);
+    }
+    else if (/^@[a-z|\-]+?\//.test(from)) { //module path
+        const arkFile = getArkFileFromOtherModule(im);
+        if (arkFile) {
+            return arkFile;
+        }
+    }
+    //sdk path
+    const scene = im.getDeclaringArkFile().getScene();
+    for (const sdk of scene.getProjectSdkMap().values()) {
+        const arkFile = getArkFileFormMap(processSdkPath(sdk, from), scene.getSdkArkFilesMap());
+        if (arkFile) {
+            return arkFile;
+        }
+    }
+}
+exports.getArkFile = getArkFile;
+/**
+ * find from info's export
+ * @param fromInfo importInfo or exportInfo
+ */
+function findExportInfo(fromInfo) {
+    var _a, _b;
+    let file = getArkFile(fromInfo);
+    if (!file) {
+        logger.warn(`${fromInfo.getOriginName()} ${fromInfo.getFrom()} file not found: 
+        ${(_b = (_a = fromInfo.getDeclaringArkFile()) === null || _a === void 0 ? void 0 : _a.getFileSignature()) === null || _b === void 0 ? void 0 : _b.toString()}`);
+        return null;
+    }
+    let exportInfo = findExportInfoInfile(fromInfo, file) || null;
+    if (exportInfo === null) {
+        logger.warn('export info not found, ' + fromInfo.getFrom() + ' in file: '
+            + fromInfo.getDeclaringArkFile().getFileSignature().toString());
+        return null;
+    }
+    const arkExport = findArkExport(exportInfo);
+    exportInfo.setArkExport(arkExport);
+    if (arkExport) {
+        exportInfo.setExportClauseType(arkExport.getExportType());
+    }
+    return exportInfo;
+}
+exports.findExportInfo = findExportInfo;
+function findArkExport(exportInfo) {
+    var _a, _b, _c, _d;
+    if (!exportInfo) {
+        return null;
+    }
+    let arkExport = exportInfo.getArkExport();
+    if (arkExport || arkExport === null) {
+        return arkExport;
+    }
+    if (!exportInfo.getFrom()) {
+        const name = exportInfo.getOriginName();
+        if (exportInfo.getExportClauseType() === ArkExport_1.ExportType.LOCAL) {
+            arkExport = ((_b = (_a = exportInfo.getDeclaringArkFile().getDefaultClass().getDefaultArkMethod()) === null || _a === void 0 ? void 0 : _a.getBody()) === null || _b === void 0 ? void 0 : _b.getLocals().get(name)) || null;
+        }
+        else if (exportInfo.getExportClauseType() === ArkExport_1.ExportType.TYPE) {
+            arkExport = ((_d = (_c = exportInfo.getDeclaringArkFile().getDefaultClass().getDefaultArkMethod()) === null || _c === void 0 ? void 0 : _c.getBody()) === null || _d === void 0 ? void 0 : _d.getAliasTypeByName(name)) || null;
+        }
+        else {
+            arkExport = findArkExportInFile(name, exportInfo.getDeclaringArkFile());
+        }
+    }
+    else if (exportInfo.getExportClauseType() === ArkExport_1.ExportType.UNKNOWN) {
+        const result = findExportInfo(exportInfo);
+        if (result) {
+            arkExport = result.getArkExport() || null;
+        }
+    }
+    if (!arkExport) {
+        logger.warn(`${exportInfo.getExportClauseName()} get arkExport fail from ${exportInfo.getFrom()} at
+                ${exportInfo.getDeclaringArkFile().getFileSignature().toString()}`);
+    }
+    return arkExport || null;
+}
+function findArkExportInFile(name, declaringArkFile) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    let arkExport = (_f = (_c = (_b = (_a = declaringArkFile.getClassWithName(name)) !== null && _a !== void 0 ? _a : declaringArkFile.getDefaultClass().getMethodWithName(name)) !== null && _b !== void 0 ? _b : declaringArkFile.getNamespaceWithName(name)) !== null && _c !== void 0 ? _c : (_e = (_d = declaringArkFile.getDefaultClass().getDefaultArkMethod()) === null || _d === void 0 ? void 0 : _d.getBody()) === null || _e === void 0 ? void 0 : _e.getLocals().get(name)) !== null && _f !== void 0 ? _f : (_h = (_g = declaringArkFile.getDefaultClass().getDefaultArkMethod()) === null || _g === void 0 ? void 0 : _g.getBody()) === null || _h === void 0 ? void 0 : _h.getAliasTypeByName(name);
+    if (!arkExport) {
+        const importInfo = declaringArkFile.getImportInfoBy(name);
+        if (importInfo) {
+            const result = findExportInfo(importInfo);
+            if (result) {
+                arkExport = result.getArkExport();
+            }
+        }
+    }
+    return arkExport || null;
+}
+exports.findArkExportInFile = findArkExportInFile;
+function processSdkPath(sdk, formPath) {
+    const sdkName = sdk.name;
+    let dir;
+    if (formPath.startsWith('@ohos.') || formPath.startsWith('@hms.') || formPath.startsWith('@system.')) {
+        dir = 'api';
+    }
+    else if (formPath.startsWith('@kit.')) {
+        dir = 'kits';
+    }
+    else if (formPath.startsWith('@arkts.')) {
+        dir = 'arkts';
+    }
+    else {
+        let originPath = path_1.default.join(sdk.path, formPath);
+        if (FileUtils_1.FileUtils.isDirectory(originPath)) {
+            formPath = path_1.default.join(formPath, FileUtils_1.FileUtils.getIndexFileName(originPath));
+        }
+        return `@${sdkName}/${formPath}`;
+    }
+    return `@${sdkName}/${dir}/${formPath}`;
+}
+function getArkFileFromScene(im, originPath) {
+    if (FileUtils_1.FileUtils.isDirectory(originPath)) {
+        originPath = path_1.default.join(originPath, FileUtils_1.FileUtils.getIndexFileName(originPath));
+    }
+    const fileName = path_1.default.relative(im.getDeclaringArkFile().getProjectDir(), originPath);
+    const scene = im.getDeclaringArkFile().getScene();
+    if (/\.e?ts$/.test(originPath)) {
+        const fromSignature = new ArkSignature_1.FileSignature(im.getDeclaringArkFile().getProjectName(), fileName);
+        return scene.getFile(fromSignature);
+    }
+    const projectName = im.getDeclaringArkFile().getProjectName();
+    const filePath = `@${projectName}/${fileName}`;
+    if (projectName !== scene.getProjectName()) {
+        return getArkFileFormMap(filePath, scene.getSdkArkFilesMap());
+    }
+    return getArkFileFormMap(filePath, scene.getFilesMap());
+}
+function getArkFileFormMap(filePath, map) {
+    if (/\.e?ts$/.test(filePath)) {
+        return map.get((0, pathTransfer_1.transfer2UnixPath)(filePath) + ': ');
+    }
+    for (const suffix of fileSuffixArray) {
+        const arkFile = map.get((0, pathTransfer_1.transfer2UnixPath)(filePath) + suffix);
+        if (arkFile) {
+            return arkFile;
+        }
+    }
+}
+function findExportInfoInfile(fromInfo, file) {
+    const exportName = fromInfo.isDefault() ? TSConst_1.DEFAULT : fromInfo.getOriginName();
+    let exportInfo = file.getExportInfoBy(exportName);
+    if (exportInfo) {
+        return exportInfo;
+    }
+    if (fromInfo.isDefault()) {
+        exportInfo = file.getExportInfos().find(p => p.isDefault());
+        if (exportInfo) {
+            file.addExportInfo(exportInfo, TSConst_1.DEFAULT);
+            return exportInfo;
+        }
+    }
+    if (fromInfo.getOriginName() === TSConst_1.ALL) {
+        exportInfo = (0, ArkExportBuilder_1.buildDefaultExportInfo)(fromInfo, file);
+        file.addExportInfo(exportInfo, TSConst_1.ALL);
+    }
+    else if (/\.d\.e?ts$/.test(file.getName())) {
+        const declare = findArkExportInFile(fromInfo.getOriginName(), file);
+        if (declare) {
+            exportInfo = (0, ArkExportBuilder_1.buildDefaultExportInfo)(fromInfo, file, declare);
+        }
+    }
+    return exportInfo;
+}
+function getArkFileFromOtherModule(fromInfo) {
+    if (moduleMap === undefined) {
+        moduleMap = FileUtils_1.FileUtils.generateModuleMap(fromInfo.getDeclaringArkFile().getScene().getOhPkgContentMap());
+    }
+    if (!moduleMap || moduleMap.size === 0) {
+        return;
+    }
+    const from = fromInfo.getFrom();
+    let index;
+    let file;
+    let modulePath;
+    //find file by given from like '@ohos/module/src/xxx' '@ohos/module/index'
+    if ((index = from.indexOf('src')) > 0 || (index = from.indexOf('Index')) > 0 || (index = from.indexOf('index')) > 0) {
+        modulePath = moduleMap.get(from.substring(0, index).replace(/\/*$/, ''));
+        file = findFileInModule(fromInfo, modulePath, from.substring(index));
+    }
+    if (file) {
+        return file;
+    }
+    modulePath = modulePath !== null && modulePath !== void 0 ? modulePath : moduleMap.get(from);
+    if (!modulePath) {
+        return file;
+    }
+    //find file in module json main path
+    if (modulePath.main) {
+        file = getArkFileFromScene(fromInfo, modulePath.main);
+    }
+    //find file in module path Index.ts
+    if (!file && FileUtils_1.FileUtils.isDirectory(modulePath.path)) {
+        file = findFileInModule(fromInfo, modulePath, FileUtils_1.FileUtils.getIndexFileName(modulePath.path));
+    }
+    //find file in module path/src/main/ets/TsIndex.ts
+    if (!file) {
+        file = findFileInModule(fromInfo, modulePath, '/src/main/ets/TsIndex.ts');
+    }
+    return file;
+}
+function findFileInModule(fromInfo, modulePath, contentPath) {
+    if (!modulePath) {
+        return;
+    }
+    const originPath = path_1.default.join(modulePath.path, contentPath);
+    let file;
+    if (originPath !== modulePath.main) {
+        file = getArkFileFromScene(fromInfo, originPath);
+    }
+    if (file && findExportInfoInfile(fromInfo, file)) {
+        return file;
+    }
+}

package/lib/core/common/RefUseReplacer.d.ts

@@ -0,0 +1,14 @@
+import { AbstractRef } from '../base/Ref';
+import { Value } from '../base/Value';
+/**
+ * Replace old use of a Ref inplace
+ */
+export declare class RefUseReplacer {
+    private oldUse;
+    private newUse;
+    constructor(oldUse: Value, newUse: Value);
+    caseRef(ref: AbstractRef): void;
+    private caseFieldRef;
+    private caseArrayRef;
+}
+//# sourceMappingURL=RefUseReplacer.d.ts.map

package/lib/core/common/RefUseReplacer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RefUseReplacer.d.ts","sourceRoot":"","sources":["../../../src/core/common/RefUseReplacer.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,WAAW,EAAoC,MAAM,aAAa,CAAC;AAC5E,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAEtC;;GAEG;AACH,qBAAa,cAAc;IACvB,OAAO,CAAC,MAAM,CAAQ;IACtB,OAAO,CAAC,MAAM,CAAQ;gBAEV,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK;IAMjC,OAAO,CAAC,GAAG,EAAE,WAAW,GAAG,IAAI;IAQtC,OAAO,CAAC,YAAY;IAMpB,OAAO,CAAC,YAAY;CAOvB"}