arkanalyzer 1.0.6 → 1.0.8

package/lib/core/base/Expr.js

@@ -54,12 +54,14 @@ const Constant_1 = require("./Constant");
 const TSConst_1 = require("../common/TSConst");
 const Builtin_1 = require("../common/Builtin");
 const EtsConst_1 = require("../common/EtsConst");
+const Const_1 = require("../common/Const");
+const ArkField_1 = require("../model/ArkField");
 const logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'Expr');
 /**
  * @category core/base/expr
  */
 class AbstractExpr {
-    inferType(arkClass) {
+    inferType(arkMethod) {
         return this;
     }
 }
@@ -71,28 +73,120 @@ class AbstractInvokeExpr extends AbstractExpr {
         this.args = args;
         this.realGenericTypes = realGenericTypes;
     }
+    /**
+     * Get method Signature. The method signature is consist of ClassSignature and MethodSubSignature.
+     * It is the unique flag of a method. It is usually used to compose a expression string in ArkIRTransformer.
+     * @returns The class method signature, such as ArkStaticInvokeExpr.
+     * @example
+     * 1. 3AC information composed of getMethodSignature ().
+
+     ```typescript
+     let strs: string[] = [];
+     strs.push('staticinvoke <');
+     strs.push(this.getMethodSignature().toString());
+     strs.push('>(');
+     ```
+     */
     getMethodSignature() {
         return this.methodSignature;
     }
     setMethodSignature(newMethodSignature) {
         this.methodSignature = newMethodSignature;
     }
+    /**
+     * Returns an argument used in the expression according to its index.
+     * @param index - the index of the argument.
+     * @returns An argument used in the expression.
+     */
     getArg(index) {
         return this.args[index];
     }
+    /**
+     * Returns an **array** of arguments used in the expression.
+     * @returns An **array** of arguments used in the expression.
+     * @example
+     * 1. get args number.
+
+     ```typescript
+     const argsNum = expr.getArgs().length;
+     if (argsNum < 5) {
+     ... ...
+     }
+     ```
+
+     2. iterate arg based on expression
+
+     ```typescript
+     for (const arg of this.getArgs()) {
+     strs.push(arg.toString());
+     strs.push(', ');
+     }
+     ```
+     */
     getArgs() {
         return this.args;
     }
     setArgs(newArgs) {
         this.args = newArgs;
     }
+    inferArgs(arkMethod) {
+        const scene = arkMethod.getDeclaringArkFile().getScene();
+        const parameters = this.methodSignature.getMethodSubSignature().getParameters();
+        let realTypes = [];
+        for (let index = 0; index < this.args.length; index++) {
+            const arg = this.args[index];
+            TypeInference_1.TypeInference.inferValueType(arg, arkMethod);
+            if (index >= parameters.length) {
+                break;
+            }
+            const argType = arg.getType();
+            const paramType = parameters[index].getType();
+            if (paramType instanceof Type_1.UnionType) {
+                paramType.getTypes().forEach(t => this.inferArg(argType, t, scene));
+            }
+            else if (paramType instanceof Type_1.GenericType) {
+                realTypes.push(argType);
+            }
+            else {
+                this.inferArg(argType, paramType, scene);
+            }
+        }
+        if (realTypes.length > 0) {
+            this.realGenericTypes = realTypes;
+        }
+    }
+    inferArg(argType, paramType, scene) {
+        var _a, _b;
+        if (argType instanceof Type_1.FunctionType) {
+            let params;
+            let realTypes;
+            if (paramType instanceof Type_1.ClassType) {
+                params = (_b = (_a = scene.getClass(paramType.getClassSignature())) === null || _a === void 0 ? void 0 : _a.getMethodWithName(Const_1.CALL_SIGNATURE_NAME)) === null || _b === void 0 ? void 0 : _b.getParameters();
+                realTypes = paramType.getRealGenericTypes();
+            }
+            else if (paramType instanceof Type_1.FunctionType) {
+                params = paramType.getMethodSignature().getMethodSubSignature().getParameters();
+                realTypes = this.realGenericTypes;
+            }
+            if (params) {
+                argType.getMethodSignature().getMethodSubSignature().getParameters().forEach((p, i) => {
+                    var _a;
+                    let type = (_a = params === null || params === void 0 ? void 0 : params[i]) === null || _a === void 0 ? void 0 : _a.getType();
+                    if (type instanceof Type_1.GenericType && realTypes) {
+                        type = realTypes === null || realTypes === void 0 ? void 0 : realTypes[type.getIndex()];
+                    }
+                    if (type) {
+                        p.setType(type);
+                    }
+                });
+            }
+        }
+    }
     getType() {
+        var _a;
         let type = this.methodSignature.getType();
-        if (!this.realGenericTypes) {
-            return type;
-        }
         if (type instanceof Type_1.GenericType) {
-            const realType = this.realGenericTypes[type.getIndex()];
+            const realType = (_a = this.realGenericTypes) === null || _a === void 0 ? void 0 : _a[type.getIndex()];
             if (realType) {
                 type = realType;
             }
@@ -114,6 +208,77 @@ class AbstractInvokeExpr extends AbstractExpr {
     getRealGenericTypes() {
         return this.realGenericTypes;
     }
+    inferMethod(baseType, methodName, scene) {
+        if (baseType instanceof Type_1.ClassType) {
+            return this.processClassMethod(baseType, methodName, scene);
+        }
+        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);
+                    let signature = foundMethod.matchMethodSignature(this.args);
+                    this.setMethodSignature(signature);
+                    return new ArkStaticInvokeExpr(signature, 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;
+    }
+    processClassMethod(baseType, methodName, scene) {
+        let arkClass = scene.getClass(baseType.getClassSignature());
+        if (!arkClass) {
+            const globalClass = scene.getSdkGlobal(baseType.getClassSignature().getClassName());
+            if (globalClass instanceof ArkClass_1.ArkClass) {
+                arkClass = globalClass;
+            }
+        }
+        const method = arkClass ? ModelUtils_1.ModelUtils.findPropertyInClass(methodName, arkClass) : null;
+        if (method instanceof ArkMethod_1.ArkMethod) {
+            TypeInference_1.TypeInference.inferMethodReturnType(method);
+            const methodSignature = method.matchMethodSignature(this.args);
+            this.setMethodSignature(methodSignature);
+            this.realGenericTypes = method.getDeclaringArkClass() === arkClass ? baseType.getRealGenericTypes() :
+                arkClass === null || arkClass === void 0 ? void 0 : arkClass.getRealTypes();
+            if (method.isStatic()) {
+                return new ArkStaticInvokeExpr(methodSignature, this.getArgs(), this.getRealGenericTypes());
+            }
+            return this;
+        }
+        else if (method instanceof ArkField_1.ArkField) {
+            const type = method.getType();
+            if (type instanceof Type_1.FunctionType ||
+                (type instanceof Type_1.ClassType && type.getClassSignature().getClassName() === EtsConst_1.CALL_BACK)) {
+                const subSignature = new ArkSignature_1.MethodSubSignature(methodName, [], Type_1.VoidType);
+                this.setMethodSignature(new ArkSignature_1.MethodSignature(baseType.getClassSignature(), subSignature));
+                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;
+            }
+        }
+        return null;
+    }
     getUses() {
         let uses = [];
         uses.push(...this.args);
@@ -129,12 +294,22 @@ class ArkInstanceInvokeExpr extends AbstractInvokeExpr {
         super(methodSignature, args, realGenericTypes);
         this.base = base;
     }
+    /**
+     * Returns the local of the instance of invoke expression.
+     * @returns The local of the invoke expression's instance..
+     */
     getBase() {
         return this.base;
     }
     setBase(newBase) {
         this.base = newBase;
     }
+    /**
+     * Returns an **array** of values used in this invoke expression,
+     * including all arguments and values each arguments used.
+     * For {@link ArkInstanceInvokeExpr}, the return also contains the caller base and uses of base.
+     * @returns An **array** of arguments used in the invoke expression.
+     */
     getUses() {
         let uses = [];
         uses.push(this.base);
@@ -162,8 +337,8 @@ class ArkInstanceInvokeExpr extends AbstractInvokeExpr {
         strs.push(')');
         return strs.join('');
     }
-    inferType(arkClass) {
-        this.getArgs().forEach(arg => TypeInference_1.TypeInference.inferValueType(arg, arkClass));
+    inferType(arkMethod) {
+        const arkClass = arkMethod.getDeclaringArkClass();
         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);
@@ -173,7 +348,7 @@ class ArkInstanceInvokeExpr extends AbstractInvokeExpr {
         }
         const methodName = this.getMethodSignature().getMethodSubSignature().getMethodName();
         if (!baseType) {
-            if (!this.tryInferFormGlobal(methodName, arkClass)) {
+            if (!this.tryInferFormGlobal(methodName, arkMethod)) {
                 logger.warn('infer ArkInstanceInvokeExpr base type fail: ' + this.toString());
             }
             return this;
@@ -201,10 +376,11 @@ class ArkInstanceInvokeExpr extends AbstractInvokeExpr {
         else {
             result = this.inferMethod(baseType, methodName, scene);
         }
-        if (!result && this.tryInferFormGlobal(methodName, arkClass)) {
+        if (!result && this.tryInferFormGlobal(methodName, arkMethod)) {
             result = this;
         }
         if (result) {
+            this.inferArgs(arkMethod);
             return result;
         }
         logger.warn('invoke ArkInstanceInvokeExpr MethodSignature type fail: ', this.toString());
@@ -229,65 +405,18 @@ class ArkInstanceInvokeExpr extends AbstractInvokeExpr {
             logger.warn(`arg of forEach must be callable`);
         }
     }
-    tryInferFormGlobal(methodName, arkClass) {
+    tryInferFormGlobal(methodName, arkMethod) {
+        let arkClass = arkMethod.getDeclaringArkClass();
         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());
+                const methodSignature = global.matchMethodSignature(this.getArgs());
+                this.setMethodSignature(methodSignature);
                 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 {
@@ -309,63 +438,60 @@ class ArkStaticInvokeExpr extends AbstractInvokeExpr {
         strs.push(')');
         return strs.join('');
     }
-    inferType(arkClass) {
+    inferType(arkMethod) {
         var _a, _b;
-        this.getArgs().forEach(arg => TypeInference_1.TypeInference.inferValueType(arg, arkClass));
+        const arkClass = arkMethod.getDeclaringArkClass();
         const oldMethodSignature = this.getMethodSignature();
         const oldMethodSubSignature = oldMethodSignature.getMethodSubSignature();
         const methodName = oldMethodSubSignature.getMethodName();
+        if (methodName === TSConst_1.IMPORT && this.getArgs()[0] instanceof Constant_1.Constant) {
+            this.processDynamicImport(arkClass, methodName, oldMethodSignature);
+            return this;
+        }
+        const className = this.getMethodSignature().getDeclaringClassSignature().getClassName();
+        if (className && className !== Const_1.UNKNOWN_CLASS_NAME) {
+            const baseType = TypeInference_1.TypeInference.inferUnclearReferenceType(className, arkClass);
+            if (baseType) {
+                this.inferMethod(baseType, methodName, arkClass.getDeclaringArkFile().getScene());
+                this.inferArgs(arkMethod);
+            }
+            return this;
+        }
         let method;
-        const arkExport = (_a = ModelUtils_1.ModelUtils.getStaticMethodWithName(methodName, arkClass)) !== null && _a !== void 0 ? _a : ModelUtils_1.ModelUtils.getArkExportInImportInfoWithName(methodName, arkClass.getDeclaringArkFile());
+        const arkExport = (_b = (_a = ModelUtils_1.ModelUtils.getStaticMethodWithName(methodName, arkClass)) !== null && _a !== void 0 ? _a : ModelUtils_1.ModelUtils.getArkExportInImportInfoWithName(methodName, arkClass.getDeclaringArkFile())) !== null && _b !== void 0 ? _b : arkClass.getDeclaringArkFile().getScene().getSdkGlobal(methodName);
         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);
+            let signature = method.matchMethodSignature(this.getArgs());
+            if (method.isAnonymousMethod()) {
+                const subSignature = signature.getMethodSubSignature();
+                const newSubSignature = new ArkSignature_1.MethodSubSignature(methodName, subSignature.getParameters(), subSignature.getReturnType(), subSignature.isStatic());
+                signature = new ArkSignature_1.MethodSignature(signature.getDeclaringClassSignature(), newSubSignature);
+            }
+            this.setMethodSignature(signature);
+            this.inferArgs(arkMethod);
         }
         return this;
     }
+    processDynamicImport(arkClass, methodName, oldMethodSignature) {
+        var _a;
+        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((_a = importInfo.getLazyExportInfo()) === null || _a === void 0 ? void 0 : _a.getArkExport());
+        if (type) {
+            const subSignature = new ArkSignature_1.MethodSubSignature(methodName, oldMethodSignature.getMethodSubSignature().getParameters(), type);
+            const signature = new ArkSignature_1.MethodSignature(oldMethodSignature.getDeclaringClassSignature(), subSignature);
+            this.setMethodSignature(signature);
+        }
+    }
 }
 exports.ArkStaticInvokeExpr = ArkStaticInvokeExpr;
 class ArkPtrInvokeExpr extends AbstractInvokeExpr {
@@ -394,7 +520,7 @@ class ArkPtrInvokeExpr extends AbstractInvokeExpr {
         strs.push(')');
         return strs.join('');
     }
-    inferType(arkClass) {
+    inferType(arkMethod) {
         // TODO: handle type inference
         return this;
     }
@@ -417,12 +543,15 @@ class ArkNewExpr extends AbstractExpr {
     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;
+    inferType(arkMethod) {
+        const classSignature = this.classType.getClassSignature();
+        if (classSignature.getDeclaringFileSignature().getFileName() === Const_1.UNKNOWN_FILE_NAME) {
+            const className = classSignature.getClassName();
+            const type = TypeInference_1.TypeInference.inferUnclearReferenceType(className, arkMethod.getDeclaringArkClass());
+            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;
     }
@@ -453,8 +582,8 @@ class ArkNewArrayExpr extends AbstractExpr {
     isFromLiteral() {
         return this.fromLiteral;
     }
-    inferType(arkClass) {
-        const type = TypeInference_1.TypeInference.inferUnclearedType(this.baseType, arkClass);
+    inferType(arkMethod) {
+        const type = TypeInference_1.TypeInference.inferUnclearedType(this.baseType, arkMethod.getDeclaringArkClass());
         if (type) {
             this.baseType = type;
         }
@@ -507,10 +636,18 @@ class ArkAwaitExpr extends AbstractExpr {
         this.promise = newPromise;
     }
     getType() {
-        return this.promise.getType();
+        var _a, _b;
+        const type = this.promise.getType();
+        if (type instanceof Type_1.UnclearReferenceType) {
+            return type.getGenericTypes()[0];
+        }
+        else if (type instanceof Type_1.ClassType) {
+            return (_b = (_a = type.getRealGenericTypes()) === null || _a === void 0 ? void 0 : _a[0]) !== null && _b !== void 0 ? _b : type;
+        }
+        return type;
     }
-    inferType(arkClass) {
-        TypeInference_1.TypeInference.inferValueType(this.promise, arkClass);
+    inferType(arkMethod) {
+        TypeInference_1.TypeInference.inferValueType(this.promise, arkMethod);
         return this;
     }
     getUses() {
@@ -573,7 +710,7 @@ var NormalBinaryOperator;
     // Logical
     NormalBinaryOperator["LogicalAnd"] = "&&";
     NormalBinaryOperator["LogicalOr"] = "||";
-})(NormalBinaryOperator || (exports.NormalBinaryOperator = NormalBinaryOperator = {}));
+})(NormalBinaryOperator = exports.NormalBinaryOperator || (exports.NormalBinaryOperator = {}));
 var RelationalBinaryOperator;
 (function (RelationalBinaryOperator) {
     RelationalBinaryOperator["LessThan"] = "<";
@@ -584,7 +721,7 @@ var RelationalBinaryOperator;
     RelationalBinaryOperator["InEquality"] = "!=";
     RelationalBinaryOperator["StrictEquality"] = "===";
     RelationalBinaryOperator["StrictInequality"] = "!==";
-})(RelationalBinaryOperator || (exports.RelationalBinaryOperator = RelationalBinaryOperator = {}));
+})(RelationalBinaryOperator = exports.RelationalBinaryOperator || (exports.RelationalBinaryOperator = {}));
 // 二元运算表达式
 class AbstractBinopExpr extends AbstractExpr {
     constructor(op1, op2, operator) {
@@ -593,18 +730,43 @@ class AbstractBinopExpr extends AbstractExpr {
         this.op2 = op2;
         this.operator = operator;
     }
+    /**
+     * Returns the first operand in the binary operation expression.
+     * For example, the first operand in `a + b;` is `a`.
+     * @returns The first operand in the binary operation expression.
+     */
     getOp1() {
         return this.op1;
     }
     setOp1(newOp1) {
         this.op1 = newOp1;
     }
+    /**
+     * Returns the second operand in the binary operation expression.
+     * For example, the second operand in `a + b;` is `b`.
+     * @returns The second operand in the binary operation expression.
+     */
     getOp2() {
         return this.op2;
     }
     setOp2(newOp2) {
         this.op2 = newOp2;
     }
+    /**
+     * Get the binary operator from the statement.
+     * The binary operator can be divided into two categories,
+     * one is the normal binary operator and the other is relational binary operator.
+     * @returns The binary operator from the statement.
+     * @example
+     ```typescript
+     if (expr instanceof AbstractBinopExpr) {
+     let op1: Value = expr.getOp1();
+     let op2: Value = expr.getOp2();
+     let operator: string = expr.getOperator();
+     ... ...
+     }
+     ```
+     */
     getOperator() {
         return this.operator;
     }
@@ -625,9 +787,9 @@ class AbstractBinopExpr extends AbstractExpr {
     toString() {
         return this.op1 + ' ' + this.operator + ' ' + this.op2;
     }
-    inferOpType(op, arkClass) {
+    inferOpType(op, arkMethod) {
         if (op instanceof AbstractExpr || op instanceof Ref_1.AbstractRef) {
-            TypeInference_1.TypeInference.inferValueType(op, arkClass);
+            TypeInference_1.TypeInference.inferValueType(op, arkMethod);
         }
     }
     setType() {
@@ -688,12 +850,14 @@ class AbstractBinopExpr extends AbstractExpr {
                     type = op1Type;
                 }
                 break;
+            default:
+                ;
         }
         this.type = type;
     }
-    inferType(arkClass) {
-        this.inferOpType(this.op1, arkClass);
-        this.inferOpType(this.op2, arkClass);
+    inferType(arkMethod) {
+        this.inferOpType(this.op1, arkMethod);
+        this.inferOpType(this.op2, arkMethod);
         this.setType();
         return this;
     }
@@ -703,10 +867,10 @@ class ArkConditionExpr extends AbstractBinopExpr {
     constructor(op1, op2, operator) {
         super(op1, op2, operator);
     }
-    inferType(arkClass) {
-        this.inferOpType(this.op1, arkClass);
+    inferType(arkMethod) {
+        this.inferOpType(this.op1, arkMethod);
         const op1Type = this.op1.getType();
-        if (this.operator == RelationalBinaryOperator.InEquality && this.op2 == ValueUtil_1.ValueUtil.getOrCreateNumberConst(0)) {
+        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);
             }
@@ -718,7 +882,7 @@ class ArkConditionExpr extends AbstractBinopExpr {
             }
         }
         else {
-            this.inferOpType(this.getOp2(), arkClass);
+            this.inferOpType(this.getOp2(), arkMethod);
         }
         this.type = Type_1.BooleanType.getInstance();
         return this;
@@ -807,9 +971,9 @@ class ArkCastExpr extends AbstractExpr {
     getType() {
         return this.type;
     }
-    inferType(arkClass) {
+    inferType(arkMethod) {
         var _a;
-        const type = (_a = TypeInference_1.TypeInference.inferUnclearedType(this.type, arkClass)) !== null && _a !== void 0 ? _a : this.op.getType();
+        const type = (_a = TypeInference_1.TypeInference.inferUnclearedType(this.type, arkMethod.getDeclaringArkClass())) !== null && _a !== void 0 ? _a : this.op.getType();
         if (!TypeInference_1.TypeInference.isUnclearType(type)) {
             this.type = type;
         }
@@ -866,7 +1030,7 @@ var UnaryOperator;
     UnaryOperator["Neg"] = "-";
     UnaryOperator["BitwiseNot"] = "~";
     UnaryOperator["LogicalNot"] = "!";
-})(UnaryOperator || (exports.UnaryOperator = UnaryOperator = {}));
+})(UnaryOperator = exports.UnaryOperator || (exports.UnaryOperator = {}));
 // unary operation expression
 class ArkUnopExpr extends AbstractExpr {
     constructor(op, operator) {
@@ -886,6 +1050,10 @@ class ArkUnopExpr extends AbstractExpr {
     getType() {
         return this.op.getType();
     }
+    /**
+     * Get the unary operator from the statement, such as `-`,`~`,`!`.
+     * @returns the unary operator of a statement.
+     */
     getOperator() {
         return this.operator;
     }