arkanalyzer 1.0.7 → 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;
     }
 }
@@ -78,12 +80,12 @@ class AbstractInvokeExpr extends AbstractExpr {
      * @example
      * 1. 3AC information composed of getMethodSignature ().
 
-    ```typescript
-    let strs: string[] = [];
-    strs.push('staticinvoke <');
-    strs.push(this.getMethodSignature().toString());
-    strs.push('>(');
-    ```
+     ```typescript
+     let strs: string[] = [];
+     strs.push('staticinvoke <');
+     strs.push(this.getMethodSignature().toString());
+     strs.push('>(');
+     ```
      */
     getMethodSignature() {
         return this.methodSignature;
@@ -105,21 +107,21 @@ class AbstractInvokeExpr extends AbstractExpr {
      * @example
      * 1. get args number.
 
-    ```typescript
-    const argsNum = expr.getArgs().length;
-    if (argsNum < 5) {
-        ... ...
-    }
-    ```
+     ```typescript
+     const argsNum = expr.getArgs().length;
+     if (argsNum < 5) {
+     ... ...
+     }
+     ```
 
-    2. iterate arg based on expression
+     2. iterate arg based on expression
 
-    ```typescript
-    for (const arg of this.getArgs()) {
-        strs.push(arg.toString());
-        strs.push(', ');
-    }
-    ```
+     ```typescript
+     for (const arg of this.getArgs()) {
+     strs.push(arg.toString());
+     strs.push(', ');
+     }
+     ```
      */
     getArgs() {
         return this.args;
@@ -127,13 +129,64 @@ class AbstractInvokeExpr extends AbstractExpr {
     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;
             }
@@ -155,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);
@@ -213,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);
@@ -224,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;
@@ -252,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());
@@ -280,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 {
@@ -360,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 {
@@ -445,7 +520,7 @@ class ArkPtrInvokeExpr extends AbstractInvokeExpr {
         strs.push(')');
         return strs.join('');
     }
-    inferType(arkClass) {
+    inferType(arkMethod) {
         // TODO: handle type inference
         return this;
     }
@@ -468,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;
     }
@@ -504,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;
         }
@@ -558,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() {
@@ -624,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"] = "<";
@@ -635,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) {
@@ -672,14 +758,14 @@ class AbstractBinopExpr extends AbstractExpr {
      * 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();
-        ... ...
-    }
-    ```
+     ```typescript
+     if (expr instanceof AbstractBinopExpr) {
+     let op1: Value = expr.getOp1();
+     let op2: Value = expr.getOp2();
+     let operator: string = expr.getOperator();
+     ... ...
+     }
+     ```
      */
     getOperator() {
         return this.operator;
@@ -701,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() {
@@ -769,9 +855,9 @@ class AbstractBinopExpr extends AbstractExpr {
         }
         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;
     }
@@ -781,8 +867,8 @@ 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 (op1Type instanceof Type_1.StringType) {
@@ -796,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;
@@ -885,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;
         }
@@ -944,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) {

package/lib/core/base/Local.d.ts

@@ -1,10 +1,10 @@
 import { Stmt } from './Stmt';
 import { Type } from './Type';
 import { Value } from './Value';
-import { ArkClass } from '../model/ArkClass';
 import { ArkExport, ExportType } from '../model/ArkExport';
 import { LocalSignature } from '../model/ArkSignature';
 import { ModifierType } from '../model/ArkBaseModel';
+import { ArkMethod } from '../model/ArkMethod';
 /**
  * @category core/base
  */
@@ -17,7 +17,7 @@ export declare class Local implements Value, ArkExport {
     private signature?;
     private constFlag?;
     constructor(name: string, type?: Type);
-    inferType(arkClass: ArkClass): Local;
+    inferType(arkMethod: ArkMethod): Local;
     /**
      * Returns the name of local value.
      * @returns The name of local value.

package/lib/core/base/Local.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Local.d.ts","sourceRoot":"","sources":["../../../src/core/base/Local.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAE,IAAI,EAAe,MAAM,QAAQ,CAAC;AAC3C,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAE7C,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,EAAkB,cAAc,EAAmB,MAAM,uBAAuB,CAAC;AAGxF,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAErD;;GAEG;AACH,qBAAa,KAAM,YAAW,KAAK,EAAE,SAAS;IAC1C,OAAO,CAAC,IAAI,CAAS;IACrB,OAAO,CAAC,IAAI,CAAO;IAEnB,OAAO,CAAC,aAAa,CAAe;IAEpC,OAAO,CAAC,aAAa,CAAc;IACnC,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,SAAS,CAAC,CAAiB;IACnC,OAAO,CAAC,SAAS,CAAC,CAAU;gBAEhB,IAAI,EAAE,MAAM,EAAE,IAAI,GAAE,IAAgC;IASzD,SAAS,CAAC,QAAQ,EAAE,QAAQ,GAAG,KAAK;IAU3C;;;;;;;;;;;;;;;;;OAiBG;IACI,OAAO,IAAI,MAAM;IAIjB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAIlC;;;OAGG;IACI,OAAO,IAAI,IAAI;IAIf,OAAO,CAAC,OAAO,EAAE,IAAI,GAAG,IAAI;IAI5B,gBAAgB,IAAI,KAAK,GAAG,IAAI;IAIhC,gBAAgB,CAAC,aAAa,EAAE,KAAK,GAAG,IAAI;IAInD;;;;;;;;;;;;;;;;;OAiBG;IACI,gBAAgB,IAAI,IAAI,GAAG,IAAI;IAI/B,gBAAgB,CAAC,aAAa,EAAE,IAAI;IAI3C;;;OAGG;IACI,OAAO,IAAI,KAAK,EAAE;IAIlB,WAAW,CAAC,QAAQ,EAAE,IAAI;IAIjC;;;;;;OAMG;IACI,YAAY,IAAI,IAAI,EAAE;IAI7B;;;;;;;;;;;;OAYG;IACI,QAAQ,IAAI,MAAM;IAIlB,aAAa,IAAI,UAAU;IAG3B,YAAY,IAAI,MAAM;IAItB,gBAAgB,CAAC,YAAY,EAAE,YAAY,GAAG,OAAO;IAOrD,YAAY,IAAI,cAAc;IAK9B,YAAY,CAAC,SAAS,EAAE,cAAc,GAAG,IAAI;IAI7C,YAAY,IAAI,OAAO;IAOvB,YAAY,CAAC,YAAY,EAAE,OAAO,GAAG,IAAI;CAGnD"}
+{"version":3,"file":"Local.d.ts","sourceRoot":"","sources":["../../../src/core/base/Local.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAE,IAAI,EAAe,MAAM,QAAQ,CAAC;AAC3C,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,EAAkB,cAAc,EAAmB,MAAM,uBAAuB,CAAC;AAGxF,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAE/C;;GAEG;AACH,qBAAa,KAAM,YAAW,KAAK,EAAE,SAAS;IAC1C,OAAO,CAAC,IAAI,CAAS;IACrB,OAAO,CAAC,IAAI,CAAO;IAEnB,OAAO,CAAC,aAAa,CAAe;IAEpC,OAAO,CAAC,aAAa,CAAc;IACnC,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,SAAS,CAAC,CAAiB;IACnC,OAAO,CAAC,SAAS,CAAC,CAAU;gBAEhB,IAAI,EAAE,MAAM,EAAE,IAAI,GAAE,IAAgC;IASzD,SAAS,CAAC,SAAS,EAAE,SAAS,GAAG,KAAK;IAU7C;;;;;;;;;;;;;;;;;OAiBG;IACI,OAAO,IAAI,MAAM;IAIjB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAIlC;;;OAGG;IACI,OAAO,IAAI,IAAI;IAIf,OAAO,CAAC,OAAO,EAAE,IAAI,GAAG,IAAI;IAI5B,gBAAgB,IAAI,KAAK,GAAG,IAAI;IAIhC,gBAAgB,CAAC,aAAa,EAAE,KAAK,GAAG,IAAI;IAInD;;;;;;;;;;;;;;;;;OAiBG;IACI,gBAAgB,IAAI,IAAI,GAAG,IAAI;IAI/B,gBAAgB,CAAC,aAAa,EAAE,IAAI;IAI3C;;;OAGG;IACI,OAAO,IAAI,KAAK,EAAE;IAIlB,WAAW,CAAC,QAAQ,EAAE,IAAI;IAIjC;;;;;;OAMG;IACI,YAAY,IAAI,IAAI,EAAE;IAI7B;;;;;;;;;;;;OAYG;IACI,QAAQ,IAAI,MAAM;IAIlB,aAAa,IAAI,UAAU;IAG3B,YAAY,IAAI,MAAM;IAItB,gBAAgB,CAAC,YAAY,EAAE,YAAY,GAAG,OAAO;IAOrD,YAAY,IAAI,cAAc;IAK9B,YAAY,CAAC,SAAS,EAAE,cAAc,GAAG,IAAI;IAI7C,YAAY,IAAI,OAAO;IAOvB,YAAY,CAAC,YAAY,EAAE,OAAO,GAAG,IAAI;CAGnD"}

package/lib/core/base/Local.js

@@ -33,9 +33,9 @@ class Local {
         this.declaringStmt = null;
         this.usedStmts = [];
     }
-    inferType(arkClass) {
+    inferType(arkMethod) {
         if (TypeInference_1.TypeInference.isUnclearType(this.type)) {
-            const type = TypeInference_1.TypeInference.inferUnclearReferenceType(this.name, arkClass);
+            const type = TypeInference_1.TypeInference.inferUnclearReferenceType(this.name, arkMethod.getDeclaringArkClass());
             if (type) {
                 this.type = type;
             }