arkanalyzer 1.0.5

package/lib/core/base/Expr.js

@@ -0,0 +1,896 @@
+"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.ArkUnopExpr = exports.UnaryOperator = exports.ArkPhiExpr = exports.ArkCastExpr = exports.ArkInstanceOfExpr = exports.ArkTypeOfExpr = exports.ArkNormalBinopExpr = exports.ArkConditionExpr = exports.AbstractBinopExpr = exports.RelationalBinaryOperator = exports.NormalBinaryOperator = exports.ArkYieldExpr = exports.ArkAwaitExpr = exports.ArkDeleteExpr = exports.ArkNewArrayExpr = exports.ArkNewExpr = exports.ArkPtrInvokeExpr = exports.ArkStaticInvokeExpr = exports.ArkInstanceInvokeExpr = exports.AbstractInvokeExpr = exports.AbstractExpr = void 0;
+const TypeInference_1 = require("../common/TypeInference");
+const ArkClass_1 = require("../model/ArkClass");
+const ArkSignature_1 = require("../model/ArkSignature");
+const Local_1 = require("./Local");
+const Type_1 = require("./Type");
+const Ref_1 = require("./Ref");
+const ModelUtils_1 = require("../common/ModelUtils");
+const Stmt_1 = require("./Stmt");
+const logger_1 = __importStar(require("../../utils/logger"));
+const ValueUtil_1 = require("../common/ValueUtil");
+const ArkMethod_1 = require("../model/ArkMethod");
+const ArkImport_1 = require("../model/ArkImport");
+const Constant_1 = require("./Constant");
+const TSConst_1 = require("../common/TSConst");
+const Builtin_1 = require("../common/Builtin");
+const EtsConst_1 = require("../common/EtsConst");
+const logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'Expr');
+/**
+ * @category core/base/expr
+ */
+class AbstractExpr {
+    inferType(arkClass) {
+        return this;
+    }
+}
+exports.AbstractExpr = AbstractExpr;
+class AbstractInvokeExpr extends AbstractExpr {
+    constructor(methodSignature, args, realGenericTypes) {
+        super();
+        this.methodSignature = methodSignature;
+        this.args = args;
+        this.realGenericTypes = realGenericTypes;
+    }
+    getMethodSignature() {
+        return this.methodSignature;
+    }
+    setMethodSignature(newMethodSignature) {
+        this.methodSignature = newMethodSignature;
+    }
+    getArg(index) {
+        return this.args[index];
+    }
+    getArgs() {
+        return this.args;
+    }
+    setArgs(newArgs) {
+        this.args = newArgs;
+    }
+    getType() {
+        let type = this.methodSignature.getType();
+        if (!this.realGenericTypes) {
+            return type;
+        }
+        if (type instanceof Type_1.GenericType) {
+            const realType = this.realGenericTypes[type.getIndex()];
+            if (realType) {
+                type = realType;
+            }
+        }
+        else if (type instanceof Type_1.UnionType) {
+            const types = [];
+            type.getTypes().forEach(t => {
+                var _a;
+                let realType;
+                if (t instanceof Type_1.GenericType) {
+                    realType = (_a = this.realGenericTypes) === null || _a === void 0 ? void 0 : _a[t.getIndex()];
+                }
+                types.push(realType !== null && realType !== void 0 ? realType : t);
+            });
+            type = new Type_1.UnionType(types, type.getCurrType());
+        }
+        return type;
+    }
+    getRealGenericTypes() {
+        return this.realGenericTypes;
+    }
+    getUses() {
+        let uses = [];
+        uses.push(...this.args);
+        for (const arg of this.args) {
+            uses.push(...arg.getUses());
+        }
+        return uses;
+    }
+}
+exports.AbstractInvokeExpr = AbstractInvokeExpr;
+class ArkInstanceInvokeExpr extends AbstractInvokeExpr {
+    constructor(base, methodSignature, args, realGenericTypes) {
+        super(methodSignature, args, realGenericTypes);
+        this.base = base;
+    }
+    getBase() {
+        return this.base;
+    }
+    setBase(newBase) {
+        this.base = newBase;
+    }
+    getUses() {
+        let uses = [];
+        uses.push(this.base);
+        uses.push(...this.base.getUses());
+        uses.push(...this.getArgs());
+        for (const arg of this.getArgs()) {
+            uses.push(...arg.getUses());
+        }
+        return uses;
+    }
+    toString() {
+        let strs = [];
+        strs.push('instanceinvoke ');
+        strs.push(this.base.toString());
+        strs.push('.<');
+        strs.push(this.getMethodSignature().toString());
+        strs.push('>(');
+        if (this.getArgs().length > 0) {
+            for (const arg of this.getArgs()) {
+                strs.push(arg.toString());
+                strs.push(', ');
+            }
+            strs.pop();
+        }
+        strs.push(')');
+        return strs.join('');
+    }
+    inferType(arkClass) {
+        this.getArgs().forEach(arg => TypeInference_1.TypeInference.inferValueType(arg, arkClass));
+        let baseType = this.base.getType();
+        if (this.base instanceof Local_1.Local && baseType instanceof Type_1.UnknownType) {
+            baseType = TypeInference_1.TypeInference.inferBaseType(this.base.getName(), arkClass);
+        }
+        else if (baseType instanceof Type_1.UnclearReferenceType) {
+            baseType = TypeInference_1.TypeInference.inferUnclearReferenceType(baseType.getName(), arkClass);
+        }
+        const methodName = this.getMethodSignature().getMethodSubSignature().getMethodName();
+        if (!baseType) {
+            if (!this.tryInferFormGlobal(methodName, arkClass)) {
+                logger.warn('infer ArkInstanceInvokeExpr base type fail: ' + this.toString());
+            }
+            return this;
+        }
+        if (this.base instanceof Local_1.Local) {
+            this.base.setType(baseType);
+        }
+        const scene = arkClass.getDeclaringArkFile().getScene();
+        if ((methodName === 'forEach') && (baseType instanceof Type_1.ArrayType)) {
+            this.processForEach(baseType, scene);
+        }
+        TypeInference_1.TypeInference.inferRealGenericTypes(this.getRealGenericTypes(), arkClass);
+        let result;
+        if (baseType instanceof Type_1.AliasType) {
+            baseType = baseType.getOriginalType();
+        }
+        if (baseType instanceof Type_1.UnionType) {
+            for (const type of baseType.getTypes()) {
+                result = this.inferMethod(type, methodName, scene);
+                if (result) {
+                    break;
+                }
+            }
+        }
+        else {
+            result = this.inferMethod(baseType, methodName, scene);
+        }
+        if (!result && this.tryInferFormGlobal(methodName, arkClass)) {
+            result = this;
+        }
+        if (result) {
+            return result;
+        }
+        logger.warn('invoke ArkInstanceInvokeExpr MethodSignature type fail: ', this.toString());
+        return this;
+    }
+    processForEach(baseType, scene) {
+        const arg = this.getArg(0);
+        if (arg.getType() instanceof Type_1.FunctionType) {
+            const argMethodSignature = arg.getType().getMethodSignature();
+            const argMethod = scene.getMethod(argMethodSignature);
+            if (argMethod != null && argMethod.getBody()) {
+                const body = argMethod.getBody();
+                const firstStmt = body.getCfg().getStartingStmt();
+                if ((firstStmt instanceof Stmt_1.ArkAssignStmt) && (firstStmt.getRightOp() instanceof Ref_1.ArkParameterRef)) {
+                    const parameterRef = firstStmt.getRightOp();
+                    parameterRef.setType(baseType.getBaseType());
+                }
+                TypeInference_1.TypeInference.inferTypeInMethod(argMethod);
+            }
+        }
+        else {
+            logger.warn(`arg of forEach must be callable`);
+        }
+    }
+    tryInferFormGlobal(methodName, arkClass) {
+        if (arkClass.hasComponentDecorator() || arkClass.getCategory() === ArkClass_1.ClassCategory.OBJECT) {
+            const global = arkClass.getDeclaringArkFile().getScene().getSdkGlobal(methodName);
+            if (global instanceof ArkMethod_1.ArkMethod) {
+                TypeInference_1.TypeInference.inferMethodReturnType(global);
+                this.setMethodSignature(global.getSignature());
+                return true;
+            }
+        }
+        return false;
+    }
+    inferMethod(baseType, methodName, scene) {
+        if (baseType instanceof Type_1.ClassType) {
+            const arkClass = scene.getClass(baseType.getClassSignature());
+            const method = arkClass ? ModelUtils_1.ModelUtils.findPropertyInClass(methodName, arkClass) : null;
+            if (method instanceof ArkMethod_1.ArkMethod) {
+                TypeInference_1.TypeInference.inferMethodReturnType(method);
+                this.setMethodSignature(method.getSignature());
+                if (method.isStatic()) {
+                    return new ArkStaticInvokeExpr(method.getSignature(), this.getArgs(), this.getRealGenericTypes());
+                }
+                return this;
+            }
+            else if (methodName === TSConst_1.CONSTRUCTOR_NAME) { //sdk隐式构造
+                const subSignature = new ArkSignature_1.MethodSubSignature(methodName, [], new Type_1.ClassType(baseType.getClassSignature()));
+                const signature = new ArkSignature_1.MethodSignature(baseType.getClassSignature(), subSignature);
+                this.setMethodSignature(signature);
+                return this;
+            }
+            else if (methodName === Builtin_1.Builtin.ITERATOR_NEXT) { //sdk隐式构造
+                const returnType = this.getMethodSignature().getMethodSubSignature().getReturnType();
+                if (returnType instanceof Type_1.ClassType && returnType.getClassSignature().getDeclaringFileSignature()
+                    .getProjectName() === Builtin_1.Builtin.DUMMY_PROJECT_NAME) {
+                    returnType.setRealGenericTypes(baseType.getRealGenericTypes());
+                    return this;
+                }
+            }
+        }
+        else if (baseType instanceof Type_1.AnnotationNamespaceType) {
+            const namespace = scene.getNamespace(baseType.getNamespaceSignature());
+            if (namespace) {
+                const foundMethod = ModelUtils_1.ModelUtils.findPropertyInNamespace(methodName, namespace);
+                if (foundMethod instanceof ArkMethod_1.ArkMethod) {
+                    TypeInference_1.TypeInference.inferMethodReturnType(foundMethod);
+                    this.setMethodSignature(foundMethod.getSignature());
+                    return new ArkStaticInvokeExpr(foundMethod.getSignature(), this.getArgs(), this.getRealGenericTypes());
+                }
+            }
+        }
+        else if (baseType instanceof Type_1.ArrayType && methodName === Builtin_1.Builtin.ITERATOR_FUNCTION) {
+            const returnType = this.getMethodSignature().getMethodSubSignature().getReturnType();
+            if (returnType instanceof Type_1.ClassType && returnType.getClassSignature().getDeclaringFileSignature()
+                .getProjectName() === Builtin_1.Builtin.DUMMY_PROJECT_NAME) {
+                returnType.setRealGenericTypes([baseType.getBaseType()]);
+                return this;
+            }
+        }
+        return null;
+    }
+}
+exports.ArkInstanceInvokeExpr = ArkInstanceInvokeExpr;
+class ArkStaticInvokeExpr extends AbstractInvokeExpr {
+    constructor(methodSignature, args, realGenericTypes) {
+        super(methodSignature, args, realGenericTypes);
+    }
+    toString() {
+        let strs = [];
+        strs.push('staticinvoke <');
+        strs.push(this.getMethodSignature().toString());
+        strs.push('>(');
+        if (this.getArgs().length > 0) {
+            for (const arg of this.getArgs()) {
+                strs.push(arg.toString());
+                strs.push(', ');
+            }
+            strs.pop();
+        }
+        strs.push(')');
+        return strs.join('');
+    }
+    inferType(arkClass) {
+        var _a, _b;
+        this.getArgs().forEach(arg => TypeInference_1.TypeInference.inferValueType(arg, arkClass));
+        const oldMethodSignature = this.getMethodSignature();
+        const oldMethodSubSignature = oldMethodSignature.getMethodSubSignature();
+        const methodName = oldMethodSubSignature.getMethodName();
+        let method;
+        const arkExport = (_a = ModelUtils_1.ModelUtils.getStaticMethodWithName(methodName, arkClass)) !== null && _a !== void 0 ? _a : ModelUtils_1.ModelUtils.getArkExportInImportInfoWithName(methodName, arkClass.getDeclaringArkFile());
+        if (arkExport instanceof ArkMethod_1.ArkMethod) {
+            method = arkExport;
+        }
+        else if (arkExport instanceof ArkClass_1.ArkClass) {
+            method = arkExport.getMethodWithName(TSConst_1.CONSTRUCTOR_NAME);
+        }
+        if (!method) {
+            if (methodName === TSConst_1.IMPORT && this.getArgs()[0] instanceof Constant_1.Constant) {
+                const importInfo = new ArkImport_1.ImportInfo();
+                importInfo.setNameBeforeAs(TSConst_1.ALL);
+                importInfo.setImportClauseName(TSConst_1.ALL);
+                importInfo.setImportFrom(this.getArgs()[0].getValue());
+                importInfo.setDeclaringArkFile(arkClass.getDeclaringArkFile());
+                const type = TypeInference_1.TypeInference.parseArkExport2Type((_b = importInfo.getLazyExportInfo()) === null || _b === void 0 ? void 0 : _b.getArkExport());
+                if (type) {
+                    const subSignature = new ArkSignature_1.MethodSubSignature(methodName, oldMethodSubSignature.getParameters(), type);
+                    const signature = new ArkSignature_1.MethodSignature(oldMethodSignature.getDeclaringClassSignature(), subSignature);
+                    this.setMethodSignature(signature);
+                }
+                return this;
+            }
+            if (arkClass.hasComponentDecorator() || arkClass.getCategory() === ArkClass_1.ClassCategory.OBJECT) {
+                let className;
+                if (EtsConst_1.COMPONENT_CREATE_FUNCTION === methodName || EtsConst_1.COMPONENT_POP_FUNCTION === methodName) {
+                    className = this.getMethodSignature().getDeclaringClassSignature().getClassName();
+                }
+                const globalName = className !== null && className !== void 0 ? className : methodName;
+                const global = arkClass.getDeclaringArkFile().getScene().getSdkGlobal(globalName);
+                if (global instanceof ArkMethod_1.ArkMethod) {
+                    method = global;
+                }
+                else if (global instanceof ArkClass_1.ArkClass) {
+                    const callable = ModelUtils_1.ModelUtils.findPropertyInClass(methodName, global);
+                    if (callable instanceof ArkMethod_1.ArkMethod) {
+                        method = callable;
+                    }
+                    else {
+                        const signature = new ArkSignature_1.MethodSignature(global.getSignature(), oldMethodSubSignature);
+                        this.setMethodSignature(signature);
+                    }
+                }
+            }
+        }
+        if (method) {
+            this.setMethodSignature(method.getSignature());
+            TypeInference_1.TypeInference.inferMethodReturnType(method);
+        }
+        return this;
+    }
+}
+exports.ArkStaticInvokeExpr = ArkStaticInvokeExpr;
+class ArkPtrInvokeExpr extends AbstractInvokeExpr {
+    constructor(methodSignature, ptr, args, realGenericTypes) {
+        super(methodSignature, args, realGenericTypes);
+        this.funPtrLocal = ptr;
+    }
+    setFunPtrLocal(ptr) {
+        this.funPtrLocal = ptr;
+    }
+    getFuncPtrLocal() {
+        return this.funPtrLocal;
+    }
+    toString() {
+        let strs = [];
+        strs.push('ptrinvoke <');
+        strs.push(this.getMethodSignature().toString());
+        strs.push('>(');
+        if (this.getArgs().length > 0) {
+            for (const arg of this.getArgs()) {
+                strs.push(arg.toString());
+                strs.push(', ');
+            }
+            strs.pop();
+        }
+        strs.push(')');
+        return strs.join('');
+    }
+    inferType(arkClass) {
+        // TODO: handle type inference
+        return this;
+    }
+}
+exports.ArkPtrInvokeExpr = ArkPtrInvokeExpr;
+class ArkNewExpr extends AbstractExpr {
+    constructor(classType) {
+        super();
+        this.classType = classType;
+    }
+    getClassType() {
+        return this.classType;
+    }
+    getUses() {
+        return [];
+    }
+    getType() {
+        return this.classType;
+    }
+    toString() {
+        return 'new ' + this.classType;
+    }
+    inferType(arkClass) {
+        const className = this.classType.getClassSignature().getClassName();
+        const type = TypeInference_1.TypeInference.inferUnclearReferenceType(className, arkClass);
+        if (type && type instanceof Type_1.ClassType) {
+            let realGenericTypes = this.classType.getRealGenericTypes();
+            this.classType = realGenericTypes ? new Type_1.ClassType(type.getClassSignature(), realGenericTypes) : type;
+        }
+        return this;
+    }
+}
+exports.ArkNewExpr = ArkNewExpr;
+class ArkNewArrayExpr extends AbstractExpr {
+    constructor(baseType, size, fromLiteral = false) {
+        super();
+        this.baseType = baseType;
+        this.size = size;
+        this.fromLiteral = fromLiteral;
+    }
+    getSize() {
+        return this.size;
+    }
+    setSize(newSize) {
+        this.size = newSize;
+    }
+    getType() {
+        return new Type_1.ArrayType(this.baseType, 1);
+    }
+    getBaseType() {
+        return this.baseType;
+    }
+    setBaseType(newType) {
+        this.baseType = newType;
+    }
+    isFromLiteral() {
+        return this.fromLiteral;
+    }
+    inferType(arkClass) {
+        const type = TypeInference_1.TypeInference.inferUnclearedType(this.baseType, arkClass);
+        if (type) {
+            this.baseType = type;
+        }
+        return this;
+    }
+    getUses() {
+        let uses = [this.size];
+        uses.push(...this.size.getUses());
+        return uses;
+    }
+    toString() {
+        return 'newarray (' + this.baseType + ')[' + this.size + ']';
+    }
+}
+exports.ArkNewArrayExpr = ArkNewArrayExpr;
+class ArkDeleteExpr extends AbstractExpr {
+    constructor(field) {
+        super();
+        this.field = field;
+    }
+    getField() {
+        return this.field;
+    }
+    setField(newField) {
+        this.field = newField;
+    }
+    getType() {
+        return Type_1.BooleanType.getInstance();
+    }
+    getUses() {
+        const uses = [];
+        uses.push(this.field);
+        uses.push(...this.field.getUses());
+        return uses;
+    }
+    toString() {
+        return 'delete ' + this.field;
+    }
+}
+exports.ArkDeleteExpr = ArkDeleteExpr;
+class ArkAwaitExpr extends AbstractExpr {
+    constructor(promise) {
+        super();
+        this.promise = promise;
+    }
+    getPromise() {
+        return this.promise;
+    }
+    setPromise(newPromise) {
+        this.promise = newPromise;
+    }
+    getType() {
+        return this.promise.getType();
+    }
+    inferType(arkClass) {
+        TypeInference_1.TypeInference.inferValueType(this.promise, arkClass);
+        return this;
+    }
+    getUses() {
+        const uses = [];
+        uses.push(this.promise);
+        uses.push(...this.promise.getUses());
+        return uses;
+    }
+    toString() {
+        const str = 'await ' + this.promise;
+        return str;
+    }
+}
+exports.ArkAwaitExpr = ArkAwaitExpr;
+class ArkYieldExpr extends AbstractExpr {
+    constructor(yieldValue) {
+        super();
+        this.yieldValue = yieldValue;
+    }
+    getYieldValue() {
+        return this.yieldValue;
+    }
+    setYieldValue(newYieldValue) {
+        this.yieldValue = newYieldValue;
+    }
+    getType() {
+        return this.yieldValue.getType();
+    }
+    getUses() {
+        const uses = [];
+        uses.push(this.yieldValue);
+        uses.push(...this.yieldValue.getUses());
+        return uses;
+    }
+    toString() {
+        const str = 'yield ' + this.yieldValue;
+        return str;
+    }
+}
+exports.ArkYieldExpr = ArkYieldExpr;
+var NormalBinaryOperator;
+(function (NormalBinaryOperator) {
+    // TODO: unfold it
+    NormalBinaryOperator["NullishCoalescing"] = "??";
+    // arithmetic
+    NormalBinaryOperator["Exponentiation"] = "**";
+    NormalBinaryOperator["Division"] = "/";
+    NormalBinaryOperator["Addition"] = "+";
+    NormalBinaryOperator["Subtraction"] = "-";
+    NormalBinaryOperator["Multiplication"] = "*";
+    NormalBinaryOperator["Remainder"] = "%";
+    // shift
+    NormalBinaryOperator["LeftShift"] = "<<";
+    NormalBinaryOperator["RightShift"] = ">>";
+    NormalBinaryOperator["UnsignedRightShift"] = ">>>";
+    // Bitwise
+    NormalBinaryOperator["BitwiseAnd"] = "&";
+    NormalBinaryOperator["BitwiseOr"] = "|";
+    NormalBinaryOperator["BitwiseXor"] = "^";
+    // Logical
+    NormalBinaryOperator["LogicalAnd"] = "&&";
+    NormalBinaryOperator["LogicalOr"] = "||";
+})(NormalBinaryOperator = exports.NormalBinaryOperator || (exports.NormalBinaryOperator = {}));
+var RelationalBinaryOperator;
+(function (RelationalBinaryOperator) {
+    RelationalBinaryOperator["LessThan"] = "<";
+    RelationalBinaryOperator["LessThanOrEqual"] = "<=";
+    RelationalBinaryOperator["GreaterThan"] = ">";
+    RelationalBinaryOperator["GreaterThanOrEqual"] = ">=";
+    RelationalBinaryOperator["Equality"] = "==";
+    RelationalBinaryOperator["InEquality"] = "!=";
+    RelationalBinaryOperator["StrictEquality"] = "===";
+    RelationalBinaryOperator["StrictInequality"] = "!==";
+})(RelationalBinaryOperator = exports.RelationalBinaryOperator || (exports.RelationalBinaryOperator = {}));
+// 二元运算表达式
+class AbstractBinopExpr extends AbstractExpr {
+    constructor(op1, op2, operator) {
+        super();
+        this.op1 = op1;
+        this.op2 = op2;
+        this.operator = operator;
+    }
+    getOp1() {
+        return this.op1;
+    }
+    setOp1(newOp1) {
+        this.op1 = newOp1;
+    }
+    getOp2() {
+        return this.op2;
+    }
+    setOp2(newOp2) {
+        this.op2 = newOp2;
+    }
+    getOperator() {
+        return this.operator;
+    }
+    getType() {
+        if (!this.type) {
+            this.setType();
+        }
+        return this.type;
+    }
+    getUses() {
+        let uses = [];
+        uses.push(this.op1);
+        uses.push(...this.op1.getUses());
+        uses.push(this.op2);
+        uses.push(...this.op2.getUses());
+        return uses;
+    }
+    toString() {
+        return this.op1 + ' ' + this.operator + ' ' + this.op2;
+    }
+    inferOpType(op, arkClass) {
+        if (op instanceof AbstractExpr || op instanceof Ref_1.AbstractRef) {
+            TypeInference_1.TypeInference.inferValueType(op, arkClass);
+        }
+    }
+    setType() {
+        let op1Type = this.op1.getType();
+        let op2Type = this.op2.getType();
+        if (op1Type instanceof Type_1.UnionType) {
+            op1Type = op1Type.getCurrType();
+        }
+        if (op2Type instanceof Type_1.UnionType) {
+            op2Type = op2Type.getCurrType();
+        }
+        let type = Type_1.UnknownType.getInstance();
+        switch (this.operator) {
+            case '+':
+                if (op1Type === Type_1.StringType.getInstance() || op2Type === Type_1.StringType.getInstance()) {
+                    type = Type_1.StringType.getInstance();
+                }
+                if (op1Type === Type_1.NumberType.getInstance() && op2Type === Type_1.NumberType.getInstance()) {
+                    type = Type_1.NumberType.getInstance();
+                }
+                break;
+            case '-':
+            case '*':
+            case '/':
+            case '%':
+                if (op1Type === Type_1.NumberType.getInstance() && op2Type === Type_1.NumberType.getInstance()) {
+                    type = Type_1.NumberType.getInstance();
+                }
+                break;
+            case '!=':
+            case '!==':
+            case '<':
+            case '>':
+            case '<=':
+            case '>=':
+            case '&&':
+            case '||':
+            case '==':
+            case '===':
+                type = Type_1.BooleanType.getInstance();
+                break;
+            case '&':
+            case '|':
+            case '^':
+            case '<<':
+            case '>>':
+            case '>>>':
+                if (op1Type === Type_1.NumberType.getInstance() && op2Type === Type_1.NumberType.getInstance()) {
+                    type = Type_1.NumberType.getInstance();
+                }
+                break;
+            case '??':
+                if (op1Type === Type_1.UnknownType.getInstance() || op1Type === Type_1.UndefinedType.getInstance()
+                    || op1Type === Type_1.NullType.getInstance()) {
+                    type = op2Type;
+                }
+                else {
+                    type = op1Type;
+                }
+                break;
+        }
+        this.type = type;
+    }
+    inferType(arkClass) {
+        this.inferOpType(this.op1, arkClass);
+        this.inferOpType(this.op2, arkClass);
+        this.setType();
+        return this;
+    }
+}
+exports.AbstractBinopExpr = AbstractBinopExpr;
+class ArkConditionExpr extends AbstractBinopExpr {
+    constructor(op1, op2, operator) {
+        super(op1, op2, operator);
+    }
+    inferType(arkClass) {
+        this.inferOpType(this.op1, arkClass);
+        const op1Type = this.op1.getType();
+        if (this.operator == RelationalBinaryOperator.InEquality && this.op2 == ValueUtil_1.ValueUtil.getOrCreateNumberConst(0)) {
+            if (op1Type instanceof Type_1.StringType) {
+                this.op2 = ValueUtil_1.ValueUtil.createStringConst(ValueUtil_1.EMPTY_STRING);
+            }
+            else if (op1Type instanceof Type_1.BooleanType) {
+                this.op2 = ValueUtil_1.ValueUtil.getBooleanConstant(false);
+            }
+            else if (op1Type instanceof Type_1.ClassType) {
+                this.op2 = ValueUtil_1.ValueUtil.getUndefinedConst();
+            }
+        }
+        else {
+            this.inferOpType(this.getOp2(), arkClass);
+        }
+        this.type = Type_1.BooleanType.getInstance();
+        return this;
+    }
+}
+exports.ArkConditionExpr = ArkConditionExpr;
+class ArkNormalBinopExpr extends AbstractBinopExpr {
+    constructor(op1, op2, operator) {
+        super(op1, op2, operator);
+    }
+}
+exports.ArkNormalBinopExpr = ArkNormalBinopExpr;
+class ArkTypeOfExpr extends AbstractExpr {
+    constructor(op) {
+        super();
+        this.op = op;
+    }
+    getOp() {
+        return this.op;
+    }
+    setOp(newOp) {
+        this.op = newOp;
+    }
+    getUses() {
+        let uses = [];
+        uses.push(this.op);
+        uses.push(...this.op.getUses());
+        return uses;
+    }
+    getType() {
+        return Type_1.StringType.getInstance();
+    }
+    toString() {
+        return 'typeof ' + this.op;
+    }
+}
+exports.ArkTypeOfExpr = ArkTypeOfExpr;
+class ArkInstanceOfExpr extends AbstractExpr {
+    constructor(op, checkType) {
+        super();
+        this.op = op;
+        this.checkType = checkType;
+    }
+    getOp() {
+        return this.op;
+    }
+    setOp(newOp) {
+        this.op = newOp;
+    }
+    getCheckType() {
+        return this.checkType;
+    }
+    getType() {
+        return Type_1.BooleanType.getInstance();
+    }
+    getUses() {
+        let uses = [];
+        uses.push(this.op);
+        uses.push(...this.op.getUses());
+        return uses;
+    }
+    toString() {
+        return this.op + ' instanceof ' + this.checkType;
+    }
+}
+exports.ArkInstanceOfExpr = ArkInstanceOfExpr;
+// 类型转换
+class ArkCastExpr extends AbstractExpr {
+    constructor(op, type) {
+        super();
+        this.op = op;
+        this.type = type;
+    }
+    getOp() {
+        return this.op;
+    }
+    setOp(newOp) {
+        this.op = newOp;
+    }
+    getUses() {
+        let uses = [];
+        uses.push(this.op);
+        uses.push(...this.op.getUses());
+        return uses;
+    }
+    getType() {
+        return this.type;
+    }
+    inferType(arkClass) {
+        var _a;
+        const type = (_a = TypeInference_1.TypeInference.inferUnclearedType(this.type, arkClass)) !== null && _a !== void 0 ? _a : this.op.getType();
+        if (!TypeInference_1.TypeInference.isUnclearType(type)) {
+            this.type = type;
+        }
+        return this;
+    }
+    toString() {
+        return '<' + this.type + '>' + this.op;
+    }
+}
+exports.ArkCastExpr = ArkCastExpr;
+class ArkPhiExpr extends AbstractExpr {
+    constructor() {
+        super();
+        this.args = [];
+        this.argToBlock = new Map();
+    }
+    getUses() {
+        let uses = [];
+        uses.push(...this.args);
+        return uses;
+    }
+    getArgs() {
+        return this.args;
+    }
+    setArgs(args) {
+        this.args = args;
+    }
+    getArgToBlock() {
+        return this.argToBlock;
+    }
+    setArgToBlock(argToBlock) {
+        this.argToBlock = argToBlock;
+    }
+    getType() {
+        return this.args[0].getType();
+    }
+    toString() {
+        let strs = [];
+        strs.push('phi(');
+        if (this.args.length > 0) {
+            for (const arg of this.args) {
+                strs.push(arg.toString());
+                strs.push(', ');
+            }
+            strs.pop();
+        }
+        strs.push(')');
+        return strs.join('');
+    }
+}
+exports.ArkPhiExpr = ArkPhiExpr;
+var UnaryOperator;
+(function (UnaryOperator) {
+    UnaryOperator["Neg"] = "-";
+    UnaryOperator["BitwiseNot"] = "~";
+    UnaryOperator["LogicalNot"] = "!";
+})(UnaryOperator = exports.UnaryOperator || (exports.UnaryOperator = {}));
+// unary operation expression
+class ArkUnopExpr extends AbstractExpr {
+    constructor(op, operator) {
+        super();
+        this.op = op;
+        this.operator = operator;
+    }
+    getUses() {
+        let uses = [];
+        uses.push(this.op);
+        uses.push(...this.op.getUses());
+        return uses;
+    }
+    getOp() {
+        return this.op;
+    }
+    getType() {
+        return this.op.getType();
+    }
+    getOperator() {
+        return this.operator;
+    }
+    toString() {
+        return this.operator + this.op;
+    }
+}
+exports.ArkUnopExpr = ArkUnopExpr;