arkanalyzer 1.0.5

package/lib/core/common/TypeInference.js

@@ -0,0 +1,519 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeInference = void 0;
+const logger_1 = __importStar(require("../../utils/logger"));
+const Expr_1 = require("../base/Expr");
+const Local_1 = require("../base/Local");
+const Ref_1 = require("../base/Ref");
+const Stmt_1 = require("../base/Stmt");
+const Type_1 = require("../base/Type");
+const ArkMethod_1 = require("../model/ArkMethod");
+const ArkClass_1 = require("../model/ArkClass");
+const ArkField_1 = require("../model/ArkField");
+const Constant_1 = require("../base/Constant");
+const ArkNamespace_1 = require("../model/ArkNamespace");
+const TSConst_1 = require("./TSConst");
+const ModelUtils_1 = require("./ModelUtils");
+const Builtin_1 = require("./Builtin");
+const ArkSignature_1 = require("../model/ArkSignature");
+const Const_1 = require("./Const");
+const ValueUtil_1 = require("./ValueUtil");
+const logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'TypeInference');
+class TypeInference {
+    static inferTypeInArkField(arkField) {
+        const arkClass = arkField.getDeclaringArkClass();
+        const stmts = arkField.getInitializer();
+        for (const stmt of stmts) {
+            this.resolveExprsInStmt(stmt, arkClass);
+            this.resolveFieldRefsInStmt(stmt, arkClass, arkClass.getMethodWithName('@instance_init'));
+            this.resolveArkAssignStmt(stmt, arkClass);
+        }
+        if (!this.isUnclearType(arkField.getType())) {
+            return;
+        }
+        const lastStmt = stmts[stmts.length - 1];
+        let fieldRef;
+        if (lastStmt instanceof Stmt_1.ArkAssignStmt && lastStmt.getLeftOp() instanceof Ref_1.AbstractFieldRef) {
+            fieldRef = lastStmt.getLeftOp();
+        }
+        const fieldType = this.inferUnclearedType(arkField.getType(), arkClass, fieldRef === null || fieldRef === void 0 ? void 0 : fieldRef.getType());
+        if (fieldType) {
+            const old = arkField.getSignature();
+            arkField.setSignature(new ArkSignature_1.FieldSignature(old.getFieldName(), old.getDeclaringSignature(), fieldType, old.isStatic()));
+        }
+        else if (fieldRef && !this.isUnclearType(fieldRef.getType())) {
+            arkField.setSignature(fieldRef.getFieldSignature());
+        }
+    }
+    static inferUnclearedType(leftOpType, declaringArkClass, rightType) {
+        let type;
+        if (leftOpType instanceof Type_1.UnclearReferenceType) {
+            type = this.inferUnclearReferenceType(leftOpType.getName(), declaringArkClass);
+        }
+        else if (leftOpType instanceof Type_1.ClassType
+            && leftOpType.getClassSignature().getDeclaringFileSignature().getFileName() === Const_1.UNKNOWN_FILE_NAME) {
+            type = TypeInference.inferUnclearReferenceType(leftOpType.getClassSignature().getClassName(), declaringArkClass);
+        }
+        else if (leftOpType instanceof Type_1.UnionType) {
+            let types = leftOpType.getTypes();
+            for (let i = 0; i < types.length; i++) {
+                let optionType = types[i];
+                let newType;
+                if (optionType instanceof Type_1.ClassType) {
+                    newType = TypeInference.inferUnclearReferenceType(optionType.getClassSignature().getClassName(), declaringArkClass);
+                }
+                else if (optionType instanceof Type_1.UnclearReferenceType) {
+                    newType = TypeInference.inferUnclearReferenceType(optionType.getName(), declaringArkClass);
+                }
+                else {
+                    newType = optionType;
+                }
+                if (newType && newType != optionType) {
+                    types[i] = newType;
+                }
+                if (rightType && newType && newType === rightType) {
+                    leftOpType.setCurrType(rightType);
+                    type = leftOpType;
+                }
+            }
+        }
+        else if (leftOpType instanceof Type_1.ArrayType) {
+            let baseType = this.inferUnclearedType(leftOpType.getBaseType(), declaringArkClass);
+            if (baseType) {
+                leftOpType.setBaseType(baseType);
+                type = leftOpType;
+            }
+        }
+        else if (leftOpType instanceof Type_1.AliasType) {
+            let baseType = this.inferUnclearedType(leftOpType.getOriginalType(), declaringArkClass);
+            if (baseType) {
+                leftOpType.setOriginalType(baseType);
+                type = leftOpType;
+            }
+        }
+        else if (leftOpType instanceof Type_1.AnnotationNamespaceType) {
+            type = this.inferUnclearReferenceType(leftOpType.getOriginType(), declaringArkClass);
+        }
+        return type;
+    }
+    static inferTypeInMethod(arkMethod) {
+        var _a;
+        const body = arkMethod.getBody();
+        if (!body) {
+            logger.warn('empty body');
+            return;
+        }
+        const arkClass = arkMethod.getDeclaringArkClass();
+        (_a = body.getAliasTypeMap()) === null || _a === void 0 ? void 0 : _a.forEach((value) => this.inferUnclearedType(value[0], arkClass));
+        this.inferGenericType(arkMethod.getGenericTypes(), arkClass);
+        const cfg = body.getCfg();
+        for (const block of cfg.getBlocks()) {
+            for (const stmt of block.getStmts()) {
+                this.resolveExprsInStmt(stmt, arkClass);
+                this.resolveFieldRefsInStmt(stmt, arkClass, arkMethod);
+                this.resolveArkAssignStmt(stmt, arkClass);
+            }
+        }
+        this.inferMethodReturnType(arkMethod);
+    }
+    /**
+     * @Deprecated
+     * @param arkMethod
+     */
+    static inferSimpleTypeInMethod(arkMethod) {
+        const body = arkMethod.getBody();
+        if (!body) {
+            logger.warn('empty body');
+            return;
+        }
+        const cfg = body.getCfg();
+        for (const block of cfg.getBlocks()) {
+            for (const stmt of block.getStmts()) {
+                TypeInference.inferSimpleTypeInStmt(stmt);
+            }
+        }
+    }
+    /**
+     * infer type for Exprs in stmt which invoke method.
+     * such as ArkInstanceInvokeExpr ArkStaticInvokeExpr ArkNewExpr
+     */
+    static resolveExprsInStmt(stmt, arkClass) {
+        const exprs = stmt.getExprs();
+        for (const expr of exprs) {
+            const newExpr = expr.inferType(arkClass);
+            if (stmt.containsInvokeExpr() && expr instanceof Expr_1.ArkInstanceInvokeExpr && newExpr instanceof Expr_1.ArkStaticInvokeExpr) {
+                if (stmt instanceof Stmt_1.ArkAssignStmt && stmt.getRightOp() instanceof Expr_1.ArkInstanceInvokeExpr) {
+                    stmt.setRightOp(newExpr);
+                }
+                else if (stmt instanceof Stmt_1.ArkInvokeStmt) {
+                    stmt.replaceInvokeExpr(newExpr);
+                }
+            }
+        }
+    }
+    /**
+     * infer type for fieldRefs in stmt.
+     */
+    static resolveFieldRefsInStmt(stmt, arkClass, arkMethod) {
+        var _a;
+        for (const use of stmt.getUses()) {
+            if (use instanceof Ref_1.AbstractRef) {
+                const fieldRef = use.inferType(arkClass);
+                if (fieldRef instanceof Ref_1.ArkStaticFieldRef && stmt instanceof Stmt_1.ArkAssignStmt) {
+                    if (stmt.getRightOp() instanceof Ref_1.ArkInstanceFieldRef) {
+                        stmt.setRightOp(fieldRef);
+                    }
+                    else {
+                        stmt.replaceUse(use, fieldRef);
+                        stmt.setRightOp(stmt.getRightOp());
+                    }
+                }
+                else if (use instanceof Ref_1.ArkInstanceFieldRef && fieldRef instanceof Ref_1.ArkArrayRef && stmt instanceof Stmt_1.ArkAssignStmt) {
+                    const index = fieldRef.getIndex();
+                    if (index instanceof Constant_1.Constant && index.getType() instanceof Type_1.StringType) {
+                        const local = (_a = arkMethod === null || arkMethod === void 0 ? void 0 : arkMethod.getBody()) === null || _a === void 0 ? void 0 : _a.getLocals().get(index.getValue());
+                        if (local) {
+                            fieldRef.setIndex(local);
+                        }
+                    }
+                    stmt.replaceUse(use, fieldRef);
+                    stmt.setRightOp(stmt.getRightOp());
+                }
+            }
+        }
+        const stmtDef = stmt.getDef();
+        if (stmtDef && stmtDef instanceof Ref_1.AbstractRef) {
+            const fieldRef = stmtDef.inferType(arkClass);
+            if (fieldRef instanceof Ref_1.ArkStaticFieldRef && stmt instanceof Stmt_1.ArkAssignStmt) {
+                stmt.setLeftOp(fieldRef);
+            }
+        }
+    }
+    static parseArkExport2Type(arkExport) {
+        var _a;
+        if (!arkExport) {
+            return null;
+        }
+        if (arkExport instanceof ArkClass_1.ArkClass) {
+            return new Type_1.ClassType(arkExport.getSignature(), (_a = arkExport.getGenericsTypes()) === null || _a === void 0 ? void 0 : _a.map((x, index) => {
+                let defaultType = x.getDefaultType();
+                if (defaultType instanceof Type_1.UnclearReferenceType) {
+                    const newType = TypeInference.inferUnclearReferenceType(defaultType.getName(), arkExport);
+                    if (newType) {
+                        defaultType = newType;
+                    }
+                }
+                return defaultType !== null && defaultType !== void 0 ? defaultType : Type_1.UndefinedType.getInstance();
+            }));
+        }
+        else if (arkExport instanceof ArkNamespace_1.ArkNamespace) {
+            let namespaceType = new Type_1.AnnotationNamespaceType(arkExport.getName());
+            namespaceType.setNamespaceSignature(arkExport.getSignature());
+            return namespaceType;
+        }
+        else if (arkExport instanceof ArkMethod_1.ArkMethod) {
+            return new Type_1.FunctionType(arkExport.getSignature());
+        }
+        else if (arkExport instanceof Local_1.Local) {
+            if (arkExport.getType() instanceof Type_1.UnknownType || arkExport.getType() instanceof Type_1.UnclearReferenceType) {
+                return null;
+            }
+            return arkExport.getType();
+        }
+        else if (arkExport instanceof Type_1.AliasType) {
+            return arkExport;
+        }
+        else {
+            return null;
+        }
+    }
+    /**
+     * infer and pass type for ArkAssignStmt right and left
+     * @param stmt
+     * @param arkClass
+     */
+    static resolveArkAssignStmt(stmt, arkClass) {
+        if (!(stmt instanceof Stmt_1.ArkAssignStmt)) {
+            return;
+        }
+        const rightOp = stmt.getRightOp();
+        if (rightOp instanceof Local_1.Local && rightOp.getType() instanceof Type_1.UnknownType) {
+            const type = this.inferUnclearReferenceType(rightOp.getName(), arkClass);
+            if (type) {
+                rightOp.setType(type);
+            }
+        }
+        else if (rightOp.getType() instanceof Type_1.UnclearReferenceType) {
+            const type = this.inferUnclearReferenceType(rightOp.getType().getName(), arkClass);
+            if (type && rightOp instanceof Ref_1.ArkParameterRef) {
+                rightOp.setType(type);
+            }
+        }
+        const leftOp = stmt.getLeftOp();
+        if (leftOp instanceof Local_1.Local) {
+            const leftOpType = leftOp.getType();
+            let type = this.inferUnclearedType(leftOpType, arkClass, rightOp.getType());
+            if (type) {
+                leftOp.setType(type);
+            }
+            else if (rightOp instanceof Ref_1.ArkThisRef) {
+                leftOp.setType(rightOp.getType());
+            }
+        }
+        if ((this.isUnclearType(leftOp.getType()) || leftOp.getType() instanceof Type_1.FunctionType) &&
+            !this.isUnclearType(rightOp.getType())) {
+            if (leftOp instanceof Local_1.Local) {
+                leftOp.setType(rightOp.getType());
+            }
+            else if (leftOp instanceof Ref_1.AbstractFieldRef) {
+                leftOp.getFieldSignature().setType(rightOp.getType());
+            }
+        }
+    }
+    static isUnclearType(type) {
+        if (!type || type instanceof Type_1.UnknownType || type instanceof Type_1.UnclearReferenceType) {
+            return true;
+        }
+        else if (type instanceof Type_1.ClassType
+            && type.getClassSignature().getDeclaringFileSignature().getFileName() === '_UnknownFileName') {
+            return true;
+        }
+        return false;
+    }
+    static inferSimpleTypeInStmt(stmt) {
+        if (stmt instanceof Stmt_1.ArkAssignStmt) {
+            const leftOp = stmt.getLeftOp();
+            if (leftOp instanceof Local_1.Local) {
+                const leftOpType = leftOp.getType();
+                if (leftOpType instanceof Type_1.UnknownType) {
+                    const rightOp = stmt.getRightOp();
+                    leftOp.setType(rightOp.getType());
+                }
+            }
+        }
+    }
+    // Deal only with simple situations
+    static buildTypeFromStr(typeStr) {
+        switch (typeStr) {
+            case 'boolean':
+                return Type_1.BooleanType.getInstance();
+            case 'number':
+                return Type_1.NumberType.getInstance();
+            case 'string':
+                return Type_1.StringType.getInstance();
+            case 'undefined':
+                return Type_1.UndefinedType.getInstance();
+            case 'null':
+                return Type_1.NullType.getInstance();
+            case 'any':
+                return Type_1.AnyType.getInstance();
+            case 'void':
+                return Type_1.VoidType.getInstance();
+            case 'never':
+                return Type_1.NeverType.getInstance();
+            case 'RegularExpression':
+                const classSignature = Builtin_1.Builtin.REGEXP_CLASS_SIGNATURE;
+                return new Type_1.ClassType(classSignature);
+            default:
+                return new Type_1.UnclearReferenceType(typeStr);
+        }
+    }
+    static inferValueType(value, arkClass) {
+        if (value instanceof Ref_1.ArkInstanceFieldRef || value instanceof Expr_1.ArkInstanceInvokeExpr) {
+            this.inferValueType(value.getBase(), arkClass);
+        }
+        if (value instanceof Ref_1.AbstractRef || value instanceof Expr_1.AbstractExpr || value instanceof Local_1.Local) {
+            value.inferType(arkClass);
+        }
+        return value.getType();
+    }
+    static inferMethodReturnType(method) {
+        const oldMethodSignature = method.getSignature();
+        const oldMethodSubSignature = oldMethodSignature.getMethodSubSignature();
+        if (method.getName() === TSConst_1.CONSTRUCTOR_NAME) {
+            const newReturnType = new Type_1.ClassType(method.getDeclaringArkClass().getSignature());
+            const newMethodSubSignature = new ArkSignature_1.MethodSubSignature(oldMethodSubSignature.getMethodName(), oldMethodSubSignature.getParameters(), newReturnType, oldMethodSubSignature.isStatic());
+            method.setSignature(new ArkSignature_1.MethodSignature(oldMethodSignature.getDeclaringClassSignature(), newMethodSubSignature));
+            return;
+        }
+        const returnType = method.getReturnType();
+        let inferType;
+        if (returnType instanceof Type_1.UnclearReferenceType) {
+            inferType = this.inferUnclearReferenceType(returnType.getName(), method.getDeclaringArkClass());
+        }
+        if (inferType) {
+            const newMethodSubSignature = new ArkSignature_1.MethodSubSignature(oldMethodSubSignature.getMethodName(), oldMethodSubSignature.getParameters(), inferType, oldMethodSubSignature.isStatic());
+            method.setSignature(new ArkSignature_1.MethodSignature(oldMethodSignature.getDeclaringClassSignature(), newMethodSubSignature));
+        }
+    }
+    static inferGenericType(types, arkClass) {
+        types === null || types === void 0 ? void 0 : types.forEach(type => {
+            const defaultType = type.getDefaultType();
+            if (defaultType instanceof Type_1.UnclearReferenceType) {
+                const newDefaultType = TypeInference.inferUnclearReferenceType(defaultType.getName(), arkClass);
+                if (newDefaultType) {
+                    type.setDefaultType(newDefaultType);
+                }
+            }
+            const constraint = type.getConstraint();
+            if (constraint instanceof Type_1.UnclearReferenceType) {
+                const newConstraint = TypeInference.inferUnclearReferenceType(constraint.getName(), arkClass);
+                if (newConstraint) {
+                    type.setConstraint(newConstraint);
+                }
+            }
+        });
+    }
+    static inferUnclearReferenceType(refName, arkClass) {
+        var _a;
+        if (!refName) {
+            return null;
+        }
+        //split and iterate to infer each type
+        const singleNames = refName.split('.');
+        let type = null;
+        for (let i = 0; i < singleNames.length; i++) {
+            let genericName = ValueUtil_1.EMPTY_STRING;
+            const name = singleNames[i].replace(/<(\w+)>/, function (match, group1) {
+                genericName = group1;
+                return ValueUtil_1.EMPTY_STRING;
+            });
+            if (i === 0) {
+                type = this.inferBaseType(name, arkClass);
+            }
+            else if (type) {
+                type = (_a = this.inferFieldType(type, name, arkClass)) === null || _a === void 0 ? void 0 : _a[1];
+            }
+            if (!type) {
+                return null;
+            }
+            if (genericName) {
+                const realTypes = genericName.split(',').map(generic => {
+                    const realType = this.inferBaseType(generic, arkClass);
+                    return realType !== null && realType !== void 0 ? realType : new Type_1.UnclearReferenceType(generic);
+                });
+                if (type instanceof Type_1.ClassType) {
+                    type = new Type_1.ClassType(type.getClassSignature(), realTypes);
+                }
+                else if (type instanceof Type_1.FunctionType) {
+                    type = new Type_1.FunctionType(type.getMethodSignature(), realTypes);
+                }
+            }
+        }
+        return type;
+    }
+    static inferFieldType(baseType, fieldName, declareClass) {
+        if (baseType instanceof Type_1.AliasType) {
+            baseType = baseType.getOriginalType();
+        }
+        else if (baseType instanceof Type_1.UnionType && baseType.getCurrType()) {
+            baseType = baseType.getCurrType();
+        }
+        let propertyAndType = null;
+        if (baseType instanceof Type_1.ClassType) {
+            const arkClass = declareClass.getDeclaringArkFile().getScene().getClass(baseType.getClassSignature());
+            if (!arkClass) {
+                if (fieldName === Builtin_1.Builtin.ITERATOR_RESULT_VALUE && baseType.getClassSignature()
+                    .getDeclaringFileSignature().getProjectName() === Builtin_1.Builtin.DUMMY_PROJECT_NAME) {
+                    const types = baseType.getRealGenericTypes();
+                    if (types && types.length > 0) {
+                        propertyAndType = [null, types[0]];
+                    }
+                }
+                return propertyAndType;
+            }
+            const property = ModelUtils_1.ModelUtils.findPropertyInClass(fieldName, arkClass);
+            let propertyType = null;
+            if (property instanceof ArkField_1.ArkField) {
+                propertyType = property.getType();
+            }
+            else if (property) {
+                propertyType = this.parseArkExport2Type(property);
+            }
+            if (propertyType) {
+                propertyAndType = [property, propertyType];
+            }
+        }
+        else if (baseType instanceof Type_1.AnnotationNamespaceType) {
+            const namespace = declareClass.getDeclaringArkFile().getScene().getNamespace(baseType.getNamespaceSignature());
+            if (namespace) {
+                const property = ModelUtils_1.ModelUtils.findPropertyInNamespace(fieldName, namespace);
+                const propertyType = this.parseArkExport2Type(property);
+                if (propertyType) {
+                    propertyAndType = [property, propertyType];
+                }
+            }
+        }
+        else {
+            logger.warn('infer unclear reference type fail: ' + fieldName);
+        }
+        return propertyAndType;
+    }
+    static inferBaseType(baseName, arkClass) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        if (TSConst_1.SUPER_NAME === baseName) {
+            return this.parseArkExport2Type(arkClass.getSuperClass());
+        }
+        const field = (_c = (_b = (_a = arkClass.getDeclaringArkFile().getDefaultClass().getDefaultArkMethod()) === null || _a === void 0 ? void 0 : _a.getBody()) === null || _b === void 0 ? void 0 : _b.getLocals()) === null || _c === void 0 ? void 0 : _c.get(baseName);
+        if (field && !this.isUnclearType(field.getType())) {
+            return field.getType();
+        }
+        let arkExport = (_l = (_g = (_e = (_d = ModelUtils_1.ModelUtils.getClassWithName(baseName, arkClass)) !== null && _d !== void 0 ? _d : ModelUtils_1.ModelUtils.getNamespaceWithName(baseName, arkClass)) !== null && _e !== void 0 ? _e : (_f = ModelUtils_1.ModelUtils.getDefaultClass(arkClass)) === null || _f === void 0 ? void 0 : _f.getMethodWithName(baseName)) !== null && _g !== void 0 ? _g : (_k = (_j = (_h = ModelUtils_1.ModelUtils.getDefaultClass(arkClass)) === null || _h === void 0 ? void 0 : _h.getDefaultArkMethod()) === null || _j === void 0 ? void 0 : _j.getBody()) === null || _k === void 0 ? void 0 : _k.getAliasTypeByName(baseName)) !== null && _l !== void 0 ? _l : ModelUtils_1.ModelUtils.getArkExportInImportInfoWithName(baseName, arkClass.getDeclaringArkFile());
+        if (!arkExport && !arkClass.getDeclaringArkFile().getImportInfoBy(baseName)) {
+            arkExport = arkClass.getDeclaringArkFile().getScene().getSdkGlobal(baseName);
+        }
+        return this.parseArkExport2Type(arkExport);
+    }
+    static inferRealGenericTypes(realTypes, arkClass) {
+        if (!realTypes) {
+            return;
+        }
+        for (let i = 0; i < realTypes.length; i++) {
+            const mayType = realTypes[i];
+            if (this.isUnclearType(mayType)) {
+                const newType = this.inferUnclearedType(mayType, arkClass);
+                if (newType) {
+                    realTypes[i] = newType;
+                }
+            }
+        }
+    }
+}
+exports.TypeInference = TypeInference;

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

@@ -0,0 +1,17 @@
+import { Constant } from '../base/Constant';
+export declare const EMPTY_STRING = "";
+export declare class ValueUtil {
+    private static readonly NumberConstantCache;
+    private static readonly UndefinedConstant;
+    private static readonly NullConstant;
+    private static readonly TrueConstant;
+    private static readonly FalseConstant;
+    private static readonly EMPTY_STRING_CONSTANT;
+    static getOrCreateNumberConst(n: number): Constant;
+    static createStringConst(str: string): Constant;
+    static createConst(str: string): Constant;
+    static getUndefinedConst(): Constant;
+    static getNullConstant(): Constant;
+    static getBooleanConstant(value: boolean): Constant;
+}
+//# sourceMappingURL=ValueUtil.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ValueUtil.d.ts","sourceRoot":"","sources":["../../../src/core/common/ValueUtil.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAG5C,eAAO,MAAM,YAAY,KAAK,CAAC;AAE/B,qBAAa,SAAS;IAClB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,mBAAmB,CAYxC;IACH,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,iBAAiB,CAA0D;IACnG,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,YAAY,CAAgD;IACpF,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,YAAY,CAAmD;IACvF,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,aAAa,CAAoD;IACzF,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,qBAAqB,CAAwD;WAEvF,sBAAsB,CAAC,CAAC,EAAE,MAAM,GAAG,QAAQ;WAS3C,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ;WAOxC,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ;WAQlC,iBAAiB,IAAI,QAAQ;WAI7B,eAAe,IAAI,QAAQ;WAI3B,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,QAAQ;CAG7D"}

package/lib/core/common/ValueUtil.js

@@ -0,0 +1,71 @@
+"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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueUtil = exports.EMPTY_STRING = void 0;
+const Constant_1 = require("../base/Constant");
+const Type_1 = require("../base/Type");
+exports.EMPTY_STRING = '';
+class ValueUtil {
+    static getOrCreateNumberConst(n) {
+        let constant = this.NumberConstantCache.get(n);
+        if (constant == undefined) {
+            constant = new Constant_1.Constant(n.toString(), Type_1.NumberType.getInstance());
+            this.NumberConstantCache.set(n, constant);
+        }
+        return constant;
+    }
+    static createStringConst(str) {
+        if (str == exports.EMPTY_STRING) {
+            return this.EMPTY_STRING_CONSTANT;
+        }
+        return new Constant_1.Constant(str, Type_1.StringType.getInstance());
+    }
+    static createConst(str) {
+        const n = Number(str);
+        if (!isNaN(n)) {
+            return this.getOrCreateNumberConst(n);
+        }
+        return new Constant_1.Constant(str, Type_1.StringType.getInstance());
+    }
+    static getUndefinedConst() {
+        return this.UndefinedConstant;
+    }
+    static getNullConstant() {
+        return this.NullConstant;
+    }
+    static getBooleanConstant(value) {
+        return value ? this.TrueConstant : this.FalseConstant;
+    }
+}
+exports.ValueUtil = ValueUtil;
+ValueUtil.NumberConstantCache = new Map([
+    [0, new Constant_1.Constant('0', Type_1.NumberType.getInstance())],
+    [1, new Constant_1.Constant('1', Type_1.NumberType.getInstance())],
+    [2, new Constant_1.Constant('2', Type_1.NumberType.getInstance())],
+    [3, new Constant_1.Constant('3', Type_1.NumberType.getInstance())],
+    [4, new Constant_1.Constant('4', Type_1.NumberType.getInstance())],
+    [5, new Constant_1.Constant('5', Type_1.NumberType.getInstance())],
+    [6, new Constant_1.Constant('6', Type_1.NumberType.getInstance())],
+    [7, new Constant_1.Constant('7', Type_1.NumberType.getInstance())],
+    [8, new Constant_1.Constant('8', Type_1.NumberType.getInstance())],
+    [9, new Constant_1.Constant('9', Type_1.NumberType.getInstance())],
+    [10, new Constant_1.Constant('10', Type_1.NumberType.getInstance())],
+]);
+ValueUtil.UndefinedConstant = new Constant_1.Constant('undefined', Type_1.UndefinedType.getInstance());
+ValueUtil.NullConstant = new Constant_1.Constant('null', Type_1.NullType.getInstance());
+ValueUtil.TrueConstant = new Constant_1.Constant('true', Type_1.BooleanType.getInstance());
+ValueUtil.FalseConstant = new Constant_1.Constant('false', Type_1.BooleanType.getInstance());
+ValueUtil.EMPTY_STRING_CONSTANT = new Constant_1.Constant(exports.EMPTY_STRING, Type_1.StringType.getInstance());

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

@@ -0,0 +1,37 @@
+import { Value } from '../base/Value';
+import { BasicBlock } from '../graph/BasicBlock';
+import { ArkClass } from '../model/ArkClass';
+import { ArkFile } from '../model/ArkFile';
+import { ArkMethod } from '../model/ArkMethod';
+import { ArkNamespace } from '../model/ArkNamespace';
+export declare class VisibleValue {
+    private scopeChain;
+    private currScope;
+    private currVisibleValues;
+    constructor();
+    /** get values that is visible in curr scope */
+    getCurrVisibleValues(): Value[];
+    getScopeChain(): Scope[];
+    /** udpate visible values after entered a scope, only support step by step */
+    updateIntoScope(model: ArkModel): void;
+    /** udpate visible values after left a scope, only support step by step */
+    updateOutScope(): void;
+    /** clear up previous scope */
+    private deleteScope;
+    /** add this scope to scope chain and update visible values */
+    private addScope;
+    private getTargetDepth;
+    private getVisibleValuesIntoFileOrNameSpace;
+    private getVisibleValuesIntoClass;
+    private getVisibleValuesIntoMethod;
+    private getVisibleValuesIntoBasicBlock;
+}
+type ArkModel = ArkFile | ArkNamespace | ArkClass | ArkMethod | BasicBlock;
+export declare class Scope {
+    values: Value[];
+    depth: number;
+    arkModel: ArkModel | null;
+    constructor(values: Value[], depth?: number, arkModel?: ArkModel | null);
+}
+export {};
+//# sourceMappingURL=VisibleValue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"VisibleValue.d.ts","sourceRoot":"","sources":["../../../src/core/common/VisibleValue.ts"],"names":[],"mappings":"AAoBA,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AACtC,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAC3C,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC/C,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAIrD,qBAAa,YAAY;IACrB,OAAO,CAAC,UAAU,CAAU;IAC5B,OAAO,CAAC,SAAS,CAAQ;IACzB,OAAO,CAAC,iBAAiB,CAAU;;IASnC,+CAA+C;IACxC,oBAAoB,IAAI,KAAK,EAAE;IAI/B,aAAa,IAAI,KAAK,EAAE;IAI/B,6EAA6E;IACtE,eAAe,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI;IA2B7C,0EAA0E;IACnE,cAAc,IAAI,IAAI;IAuB7B,8BAA8B;IAC9B,OAAO,CAAC,WAAW;IAsBnB,8DAA8D;IAC9D,OAAO,CAAC,QAAQ;IAQhB,OAAO,CAAC,cAAc;IAuBtB,OAAO,CAAC,mCAAmC;IAM3C,OAAO,CAAC,yBAAyB;IAgBjC,OAAO,CAAC,0BAA0B;IAKlC,OAAO,CAAC,8BAA8B;CASzC;AAGD,KAAK,QAAQ,GAAG,OAAO,GAAG,YAAY,GAAG,QAAQ,GAAG,SAAS,GAAG,UAAU,CAAC;AAE3E,qBAAa,KAAK;IACP,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAAC;gBACrB,MAAM,EAAE,KAAK,EAAE,EAAE,KAAK,GAAE,MAAW,EAAE,QAAQ,GAAE,QAAQ,GAAG,IAAW;CAKpF"}