arkanalyzer 1.0.20 → 1.0.21

package/lib/core/common/TypeInference.js

@@ -1,748 +1,748 @@
-"use strict";
-/*
- * Copyright (c) 2024 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeInference = void 0;
-const logger_1 = __importStar(require("../../utils/logger"));
-const Expr_1 = require("../base/Expr");
-const Local_1 = require("../base/Local");
-const Ref_1 = require("../base/Ref");
-const Stmt_1 = require("../base/Stmt");
-const Type_1 = require("../base/Type");
-const ArkMethod_1 = require("../model/ArkMethod");
-const ArkClass_1 = require("../model/ArkClass");
-const ArkField_1 = require("../model/ArkField");
-const Constant_1 = require("../base/Constant");
-const ArkNamespace_1 = require("../model/ArkNamespace");
-const TSConst_1 = require("./TSConst");
-const ModelUtils_1 = require("./ModelUtils");
-const Builtin_1 = require("./Builtin");
-const Const_1 = require("./Const");
-const ValueUtil_1 = require("./ValueUtil");
-const ArkImport_1 = require("../model/ArkImport");
-const IRInference_1 = require("./IRInference");
-const TypeExpr_1 = require("../base/TypeExpr");
-const logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'TypeInference');
-class TypeInference {
-    static inferTypeInArkField(arkField) {
-        var _a;
-        const arkClass = arkField.getDeclaringArkClass();
-        const stmts = arkField.getInitializer();
-        const method = (_a = arkClass.getMethodWithName(Const_1.INSTANCE_INIT_METHOD_NAME)) !== null && _a !== void 0 ? _a : arkClass.getMethodWithName(TSConst_1.CONSTRUCTOR_NAME);
-        for (const stmt of stmts) {
-            if (method) {
-                this.resolveTypeExprsInStmt(stmt, method);
-                this.resolveExprsInStmt(stmt, method);
-                this.resolveFieldRefsInStmt(stmt, method);
-                this.resolveArkAssignStmt(stmt, method);
-            }
-        }
-        const beforeType = arkField.getType();
-        if (!this.isUnclearType(beforeType)) {
-            return;
-        }
-        let rightType;
-        let fieldRef;
-        const lastStmt = stmts[stmts.length - 1];
-        if (lastStmt instanceof Stmt_1.ArkAssignStmt) {
-            rightType = lastStmt.getRightOp().getType();
-            if (lastStmt.getLeftOp() instanceof Ref_1.AbstractFieldRef) {
-                fieldRef = lastStmt.getLeftOp();
-            }
-        }
-        let fieldType;
-        if (beforeType) {
-            fieldType = this.inferUnclearedType(beforeType, arkClass, rightType);
-        }
-        if (fieldType) {
-            arkField.getSignature().setType(fieldType);
-            fieldRef === null || fieldRef === void 0 ? void 0 : fieldRef.setFieldSignature(arkField.getSignature());
-        }
-        else if (rightType && this.isUnclearType(beforeType) && !this.isUnclearType(rightType)) {
-            arkField.getSignature().setType(rightType);
-            fieldRef === null || fieldRef === void 0 ? void 0 : fieldRef.setFieldSignature(arkField.getSignature());
-        }
-    }
-    /**
-     * Infer type for a given unclear type.
-     * It returns an array with 2 items, original object and original type.
-     * The original object is null if there is no object, or it failed to find the object.
-     * The original type is null if failed to infer the type.
-     * @param leftOpType
-     * @param declaringArkClass
-     * @param [rightType]
-     * @returns
-     */
-    static inferUnclearedType(leftOpType, declaringArkClass, rightType) {
-        let type;
-        if (leftOpType instanceof Type_1.ClassType &&
-            leftOpType.getClassSignature().getDeclaringFileSignature().getFileName() === Const_1.UNKNOWN_FILE_NAME) {
-            type = TypeInference.inferUnclearRefName(leftOpType.getClassSignature().getClassName(), declaringArkClass);
-        }
-        else if (leftOpType instanceof Type_1.UnionType || leftOpType instanceof Type_1.IntersectionType || leftOpType instanceof Type_1.TupleType) {
-            let types = leftOpType.getTypes();
-            for (let i = 0; i < types.length; i++) {
-                let newType = this.inferUnclearedType(types[i], declaringArkClass);
-                if (newType) {
-                    types[i] = newType;
-                }
-            }
-            type = leftOpType;
-        }
-        else if (leftOpType instanceof Type_1.ArrayType) {
-            let baseType = this.inferUnclearedType(leftOpType.getBaseType(), declaringArkClass);
-            if (baseType) {
-                leftOpType.setBaseType(baseType);
-                type = leftOpType;
-            }
-        }
-        else if (leftOpType instanceof Type_1.AliasType) {
-            let baseType = this.inferUnclearedType(leftOpType.getOriginalType(), declaringArkClass);
-            if (baseType) {
-                leftOpType.setOriginalType(baseType);
-                type = leftOpType;
-            }
-        }
-        else if (leftOpType instanceof Type_1.AnnotationNamespaceType) {
-            type = this.inferUnclearRefName(leftOpType.getOriginType(), declaringArkClass);
-        }
-        else if (leftOpType instanceof Type_1.UnclearReferenceType) {
-            type = this.inferUnclearRefType(leftOpType, declaringArkClass);
-        }
-        return type;
-    }
-    static inferTypeInMethod(arkMethod) {
-        var _a;
-        const arkClass = arkMethod.getDeclaringArkClass();
-        this.inferGenericType(arkMethod.getGenericTypes(), arkClass);
-        const signatures = [];
-        (_a = arkMethod.getDeclareSignatures()) === null || _a === void 0 ? void 0 : _a.forEach(m => signatures.push(m));
-        const impl = arkMethod.getImplementationSignature();
-        if (impl) {
-            signatures.push(impl);
-        }
-        signatures.forEach(s => {
-            s.getMethodSubSignature().getParameters().forEach(p => {
-                this.inferParameterType(p, arkMethod);
-            });
-            this.inferSignatureReturnType(s, arkMethod);
-        });
-        const body = arkMethod.getBody();
-        if (!body) {
-            return;
-        }
-        const cfg = body.getCfg();
-        for (const block of cfg.getBlocks()) {
-            for (const stmt of block.getStmts()) {
-                this.resolveTypeExprsInStmt(stmt, arkMethod);
-                this.resolveExprsInStmt(stmt, arkMethod);
-                this.resolveFieldRefsInStmt(stmt, arkMethod);
-                this.resolveArkAssignStmt(stmt, arkMethod);
-            }
-        }
-    }
-    /**
-     * @Deprecated
-     * @param arkMethod
-     */
-    static inferSimpleTypeInMethod(arkMethod) {
-        const body = arkMethod.getBody();
-        if (!body) {
-            logger.warn('empty body');
-            return;
-        }
-        const cfg = body.getCfg();
-        for (const block of cfg.getBlocks()) {
-            for (const stmt of block.getStmts()) {
-                TypeInference.inferSimpleTypeInStmt(stmt);
-            }
-        }
-    }
-    /**
-     * infer type for Exprs in stmt which invoke method.
-     * such as ArkInstanceInvokeExpr ArkStaticInvokeExpr ArkNewExpr
-     */
-    static resolveExprsInStmt(stmt, arkMethod) {
-        for (const expr of stmt.getExprs()) {
-            const newExpr = expr.inferType(arkMethod);
-            if (stmt.containsInvokeExpr() && expr instanceof Expr_1.ArkInstanceInvokeExpr && newExpr instanceof Expr_1.ArkStaticInvokeExpr) {
-                stmt.replaceUse(expr, newExpr);
-            }
-        }
-        if (stmt instanceof Stmt_1.ArkAliasTypeDefineStmt && this.isUnclearType(stmt.getAliasType().getOriginalType())) {
-            stmt.getAliasType().setOriginalType(stmt.getAliasTypeExpr().getType());
-        }
-    }
-    /**
-     * infer value type for TypeExprs in stmt which specify the type such as TypeQueryExpr
-     */
-    static resolveTypeExprsInStmt(stmt, arkMethod) {
-        for (let typeExpr of stmt.getTypeExprs()) {
-            typeExpr.inferType(arkMethod);
-        }
-    }
-    /**
-     * infer type for fieldRefs in stmt.
-     */
-    static resolveFieldRefsInStmt(stmt, arkMethod) {
-        for (const use of stmt.getUses()) {
-            if (use instanceof Ref_1.AbstractRef) {
-                this.processRef(use, stmt, arkMethod);
-            }
-        }
-        const stmtDef = stmt.getDef();
-        if (stmtDef && stmtDef instanceof Ref_1.AbstractRef) {
-            const fieldRef = stmtDef.inferType(arkMethod);
-            stmt.replaceDef(stmtDef, fieldRef);
-        }
-    }
-    static processRef(use, stmt, arkMethod) {
-        var _a;
-        const fieldRef = use.inferType(arkMethod);
-        if (fieldRef instanceof Ref_1.ArkStaticFieldRef && stmt instanceof Stmt_1.ArkAssignStmt) {
-            stmt.replaceUse(use, fieldRef);
-        }
-        else if (use instanceof Ref_1.ArkInstanceFieldRef && fieldRef instanceof Ref_1.ArkArrayRef && stmt instanceof Stmt_1.ArkAssignStmt) {
-            const index = fieldRef.getIndex();
-            if (index instanceof Constant_1.Constant && index.getType() instanceof Type_1.StringType) {
-                const local = (_a = arkMethod === null || arkMethod === void 0 ? void 0 : arkMethod.getBody()) === null || _a === void 0 ? void 0 : _a.getLocals().get(index.getValue());
-                if (local) {
-                    fieldRef.setIndex(local);
-                }
-            }
-            stmt.replaceUse(use, fieldRef);
-        }
-    }
-    static parseArkExport2Type(arkExport) {
-        if (!arkExport) {
-            return null;
-        }
-        if (arkExport instanceof ArkClass_1.ArkClass) {
-            return new Type_1.ClassType(arkExport.getSignature(), arkExport.getGenericsTypes());
-        }
-        else if (arkExport instanceof ArkNamespace_1.ArkNamespace) {
-            return Type_1.AnnotationNamespaceType.getInstance(arkExport.getSignature());
-        }
-        else if (arkExport instanceof ArkMethod_1.ArkMethod) {
-            return new Type_1.FunctionType(arkExport.getSignature());
-        }
-        else if (arkExport instanceof Local_1.Local) {
-            if (arkExport.getType() instanceof Type_1.UnknownType || arkExport.getType() instanceof Type_1.UnclearReferenceType) {
-                return null;
-            }
-            return arkExport.getType();
-        }
-        else if (arkExport instanceof Type_1.AliasType) {
-            return arkExport;
-        }
-        else {
-            return null;
-        }
-    }
-    /**
-     * infer and pass type for ArkAssignStmt right and left
-     * @param stmt
-     * @param arkMethod
-     */
-    static resolveArkAssignStmt(stmt, arkMethod) {
-        var _a;
-        if (!(stmt instanceof Stmt_1.ArkAssignStmt)) {
-            return;
-        }
-        const arkClass = arkMethod.getDeclaringArkClass();
-        const rightOp = stmt.getRightOp();
-        let rightType = rightOp.getType();
-        if (this.isUnclearType(rightType)) {
-            rightType = this.inferUnclearedType(rightType, arkClass);
-            if (rightType) {
-                this.setValueType(rightOp, rightType);
-            }
-            else {
-                if (rightOp instanceof Local_1.Local) {
-                    IRInference_1.IRInference.inferLocal(rightOp, arkMethod);
-                    rightType = rightOp.getType();
-                }
-            }
-        }
-        const leftOp = stmt.getLeftOp();
-        let leftType = leftOp.getType();
-        if (this.isUnclearType(leftType)) {
-            const newLeftType = this.inferUnclearedType(leftType, arkClass);
-            if (!newLeftType && !this.isUnclearType(rightType)) {
-                leftType = rightType;
-            }
-            else if (newLeftType) {
-                leftType = newLeftType;
-            }
-        }
-        if (leftType && !this.isUnclearType(leftType)) {
-            this.setValueType(leftOp, leftType);
-            if (leftOp instanceof Local_1.Local && ((_a = stmt.getOriginalText()) === null || _a === void 0 ? void 0 : _a.startsWith(leftOp.getName()))) {
-                let localDef = ModelUtils_1.ModelUtils.findDeclaredLocal(leftOp, arkMethod);
-                if (localDef && this.isUnclearType(localDef.getType())) {
-                    localDef.setType(leftType);
-                }
-            }
-            if (rightType) {
-                IRInference_1.IRInference.inferRightWithSdkType(leftType, rightType, arkClass);
-            }
-        }
-    }
-    static setValueType(value, type) {
-        if (value instanceof Local_1.Local || value instanceof Ref_1.ArkParameterRef) {
-            value.setType(type);
-        }
-        else if (value instanceof Ref_1.AbstractFieldRef) {
-            value.getFieldSignature().setType(type);
-        }
-    }
-    static isUnclearType(type) {
-        // TODO: For UnionType, IntersectionType and TupleType, it should recurse check every item of them.
-        if (!type || type instanceof Type_1.UnknownType || type instanceof Type_1.UnclearReferenceType
-            || type instanceof Type_1.NullType || type instanceof Type_1.UndefinedType) {
-            return true;
-        }
-        else if (type instanceof Type_1.ClassType
-            && type.getClassSignature().getDeclaringFileSignature().getFileName() === Const_1.UNKNOWN_FILE_NAME) {
-            return true;
-        }
-        else if (type instanceof Type_1.UnionType || type instanceof Type_1.IntersectionType || type instanceof Type_1.TupleType) {
-            return !!type.getTypes().find(t => this.hasUnclearReferenceType(t));
-        }
-        else if (type instanceof Type_1.ArrayType) {
-            return this.hasUnclearReferenceType(type.getBaseType());
-        }
-        else if (type instanceof Type_1.AliasType) {
-            return this.isUnclearType(type.getOriginalType());
-        }
-        else if (type instanceof TypeExpr_1.KeyofTypeExpr) {
-            return this.isUnclearType(type.getOpType());
-        }
-        else if (type instanceof TypeExpr_1.TypeQueryExpr) {
-            return this.isUnclearType(type.getType());
-        }
-        return false;
-    }
-    // This is the temporally function to check unclearReferenceType recursively and can be removed after typeInfer supports multiple candidate types.
-    static hasUnclearReferenceType(type) {
-        if (type instanceof Type_1.UnclearReferenceType) {
-            return true;
-        }
-        else if (type instanceof Type_1.UnionType || type instanceof Type_1.IntersectionType || type instanceof Type_1.TupleType) {
-            return !!type.getTypes().find(t => this.hasUnclearReferenceType(t));
-        }
-        else if (type instanceof Type_1.ArrayType) {
-            return this.hasUnclearReferenceType(type.getBaseType());
-        }
-        else if (type instanceof Type_1.AliasType) {
-            return this.hasUnclearReferenceType(type.getOriginalType());
-        }
-        else if (type instanceof TypeExpr_1.KeyofTypeExpr) {
-            return this.hasUnclearReferenceType(type.getOpType());
-        }
-        else if (type instanceof TypeExpr_1.TypeQueryExpr) {
-            return this.hasUnclearReferenceType(type.getType());
-        }
-        return false;
-    }
-    static inferSimpleTypeInStmt(stmt) {
-        if (stmt instanceof Stmt_1.ArkAssignStmt) {
-            const leftOp = stmt.getLeftOp();
-            if (leftOp instanceof Local_1.Local) {
-                const leftOpType = leftOp.getType();
-                if (leftOpType instanceof Type_1.UnknownType) {
-                    const rightOp = stmt.getRightOp();
-                    leftOp.setType(rightOp.getType());
-                }
-            }
-        }
-    }
-    // Deal only with simple situations
-    static buildTypeFromStr(typeStr) {
-        switch (typeStr) {
-            case 'boolean':
-                return Type_1.BooleanType.getInstance();
-            case 'number':
-                return Type_1.NumberType.getInstance();
-            case 'string':
-                return Type_1.StringType.getInstance();
-            case 'undefined':
-                return Type_1.UndefinedType.getInstance();
-            case 'null':
-                return Type_1.NullType.getInstance();
-            case 'any':
-                return Type_1.AnyType.getInstance();
-            case 'void':
-                return Type_1.VoidType.getInstance();
-            case 'never':
-                return Type_1.NeverType.getInstance();
-            case 'RegularExpression': {
-                const classSignature = Builtin_1.Builtin.REGEXP_CLASS_SIGNATURE;
-                return new Type_1.ClassType(classSignature);
-            }
-            default:
-                return new Type_1.UnclearReferenceType(typeStr);
-        }
-    }
-    static inferValueType(value, arkMethod) {
-        if (value instanceof Ref_1.ArkInstanceFieldRef || value instanceof Expr_1.ArkInstanceInvokeExpr) {
-            this.inferValueType(value.getBase(), arkMethod);
-        }
-        if (value instanceof Ref_1.AbstractRef || value instanceof Expr_1.AbstractExpr || value instanceof Local_1.Local) {
-            value.inferType(arkMethod);
-        }
-        return value.getType();
-    }
-    static inferParameterType(param, arkMethod) {
-        let pType = param.getType();
-        const type = TypeInference.inferUnclearedType(pType, arkMethod.getDeclaringArkClass());
-        if (type) {
-            param.setType(type);
-        }
-        else {
-            if (pType instanceof TypeExpr_1.AbstractTypeExpr) {
-                pType.inferType(arkMethod);
-            }
-        }
-    }
-    static inferSignatureReturnType(oldSignature, arkMethod) {
-        if (oldSignature.getMethodSubSignature().getMethodName() === TSConst_1.CONSTRUCTOR_NAME) {
-            const newReturnType = new Type_1.ClassType(oldSignature.getDeclaringClassSignature());
-            oldSignature.getMethodSubSignature().setReturnType(newReturnType);
-            return;
-        }
-        const currReturnType = oldSignature.getType();
-        if (!this.isUnclearType(currReturnType)) {
-            return;
-        }
-        if (currReturnType instanceof TypeExpr_1.AbstractTypeExpr) {
-            currReturnType.inferType(arkMethod);
-            return;
-        }
-        if (currReturnType instanceof Type_1.ArrayType && currReturnType.getBaseType() instanceof TypeExpr_1.AbstractTypeExpr) {
-            currReturnType.getBaseType().inferType(arkMethod);
-            return;
-        }
-        const newReturnType = this.inferUnclearedType(currReturnType, arkMethod.getDeclaringArkClass());
-        if (newReturnType) {
-            oldSignature.getMethodSubSignature().setReturnType(newReturnType);
-        }
-        else if (arkMethod.getBody()) {
-            const typeMap = new Map();
-            for (let returnValue of arkMethod.getReturnValues()) {
-                const type = returnValue.getType();
-                if (type instanceof Type_1.UnionType) {
-                    type.flatType().filter(t => !TypeInference.isUnclearType(t)).forEach(t => typeMap.set(t.toString(), t));
-                }
-                else if (!TypeInference.isUnclearType(type)) {
-                    typeMap.set(type.toString(), type);
-                }
-            }
-            if (typeMap.size > 0) {
-                const types = Array.from(typeMap.values());
-                oldSignature.getMethodSubSignature().setReturnType(types.length === 1 ? types[0] : new Type_1.UnionType(types));
-            }
-        }
-    }
-    static inferGenericType(types, arkClass) {
-        types === null || types === void 0 ? void 0 : types.forEach(type => {
-            const defaultType = type.getDefaultType();
-            if (defaultType instanceof Type_1.UnclearReferenceType) {
-                const newDefaultType = TypeInference.inferUnclearRefName(defaultType.getName(), arkClass);
-                if (newDefaultType) {
-                    type.setDefaultType(this.replaceTypeWithReal(newDefaultType));
-                }
-            }
-            const constraint = type.getConstraint();
-            if (constraint instanceof Type_1.UnclearReferenceType) {
-                const newConstraint = TypeInference.inferUnclearRefName(constraint.getName(), arkClass);
-                if (newConstraint) {
-                    type.setConstraint(this.replaceTypeWithReal(newConstraint));
-                }
-            }
-        });
-    }
-    /**
-     * Infer type for a given {@link UnclearReferenceType} type.
-     * It returns original type.
-     * The original type is null if it failed to infer the type.
-     * @param urType
-     * @param arkClass
-     * @returns
-     */
-    static inferUnclearRefType(urType, arkClass) {
-        var _a;
-        const realTypes = urType.getGenericTypes();
-        this.inferRealGenericTypes(realTypes, arkClass);
-        if (urType.getName() === Builtin_1.Builtin.ARRAY) {
-            return new Type_1.ArrayType((_a = realTypes[0]) !== null && _a !== void 0 ? _a : Type_1.AnyType.getInstance(), 1);
-        }
-        let type = this.inferUnclearRefName(urType.getName(), arkClass);
-        return type ? this.replaceTypeWithReal(type, realTypes) : null;
-    }
-    /**
-     * Find out the original object and type for a given unclear reference type name.
-     * It returns original type.
-     * The original type is null if it failed to infer the type.
-     * @param refName
-     * @param arkClass
-     * @returns
-     */
-    static inferUnclearRefName(refName, arkClass) {
-        var _a;
-        if (!refName) {
-            return null;
-        }
-        //split and iterate to infer each type
-        const singleNames = refName.split('.');
-        let type = null;
-        for (let i = 0; i < singleNames.length; i++) {
-            let genericName = ValueUtil_1.EMPTY_STRING;
-            const name = singleNames[i].replace(/<(\w+)>/, (match, group1) => {
-                genericName = group1;
-                return ValueUtil_1.EMPTY_STRING;
-            });
-            if (i === 0) {
-                type = this.inferBaseType(name, arkClass);
-            }
-            else if (type) {
-                type = (_a = this.inferFieldType(type, name, arkClass)) === null || _a === void 0 ? void 0 : _a[1];
-            }
-            if (!type) {
-                return null;
-            }
-            if (genericName) {
-                const realTypes = genericName.split(',').map(generic => {
-                    const realType = this.inferBaseType(generic, arkClass);
-                    return realType !== null && realType !== void 0 ? realType : new Type_1.UnclearReferenceType(generic);
-                });
-                if (type instanceof Type_1.ClassType) {
-                    type = new Type_1.ClassType(type.getClassSignature(), realTypes);
-                }
-                else if (type instanceof Type_1.FunctionType) {
-                    type = new Type_1.FunctionType(type.getMethodSignature(), realTypes);
-                }
-            }
-        }
-        return type;
-    }
-    /**
-     * Find out the original object and type for a given base type and the field name.
-     * It returns an array with 2 items, original object and original type.
-     * The original object is null if there is no object, or it failed to find the object.
-     * The original type is null if it failed to infer the type.
-     * @param baseType
-     * @param fieldName
-     * @param declareClass
-     * @returns
-     */
-    static inferFieldType(baseType, fieldName, declareClass) {
-        if (baseType instanceof Type_1.AliasType) {
-            baseType = baseType.getOriginalType();
-        }
-        else if (baseType instanceof Type_1.UnionType && baseType.getCurrType()) {
-            baseType = baseType.getCurrType();
-        }
-        let propertyAndType = null;
-        if (baseType instanceof Type_1.ClassType) {
-            const arkClass = declareClass.getDeclaringArkFile().getScene().getClass(baseType.getClassSignature());
-            if (!arkClass && fieldName === Builtin_1.Builtin.ITERATOR_RESULT_VALUE && baseType.getClassSignature()
-                .getDeclaringFileSignature().getProjectName() === Builtin_1.Builtin.DUMMY_PROJECT_NAME) {
-                const types = baseType.getRealGenericTypes();
-                if (types && types.length > 0) {
-                    propertyAndType = [null, types[0]];
-                }
-            }
-            if (!arkClass) {
-                return propertyAndType;
-            }
-            if (arkClass.isAnonymousClass()) {
-                const fieldType = this.inferUnclearRefName(fieldName, arkClass);
-                return fieldType ? [null, fieldType] : null;
-            }
-            const property = ModelUtils_1.ModelUtils.findPropertyInClass(fieldName, arkClass);
-            let propertyType = null;
-            if (property instanceof ArkField_1.ArkField) {
-                propertyType = property.getType();
-            }
-            else if (property) {
-                propertyType = this.parseArkExport2Type(property);
-            }
-            if (propertyType) {
-                propertyAndType = [property, propertyType];
-            }
-        }
-        else if (baseType instanceof Type_1.AnnotationNamespaceType) {
-            const namespace = declareClass.getDeclaringArkFile().getScene().getNamespace(baseType.getNamespaceSignature());
-            if (namespace) {
-                const property = ModelUtils_1.ModelUtils.findPropertyInNamespace(fieldName, namespace);
-                const propertyType = this.parseArkExport2Type(property);
-                if (propertyType) {
-                    propertyAndType = [property, propertyType];
-                }
-            }
-        }
-        else {
-            logger.warn('infer unclear reference type fail: ' + fieldName);
-        }
-        return propertyAndType;
-    }
-    /**
-     * Find out the original object and type for a given base name.
-     * It returns original type.
-     * The original type is null if failed to infer the type.
-     * @param baseName
-     * @param arkClass
-     * @returns
-     */
-    static inferBaseType(baseName, arkClass) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
-        if (TSConst_1.SUPER_NAME === baseName) {
-            return this.parseArkExport2Type(arkClass.getSuperClass());
-        }
-        const field = (_d = (_c = (_b = (_a = ModelUtils_1.ModelUtils.getDefaultClass(arkClass)) === null || _a === void 0 ? void 0 : _a.getDefaultArkMethod()) === null || _b === void 0 ? void 0 : _b.getBody()) === null || _c === void 0 ? void 0 : _c.getLocals()) === null || _d === void 0 ? void 0 : _d.get(baseName);
-        if (field && !this.isUnclearType(field.getType())) {
-            return field.getType();
-        }
-        let arkExport = (_m = (_k = (_j = (_e = ModelUtils_1.ModelUtils.getClassWithName(baseName, arkClass)) !== null && _e !== void 0 ? _e : (_h = (_g = (_f = ModelUtils_1.ModelUtils.getDefaultClass(arkClass)) === null || _f === void 0 ? void 0 : _f.getDefaultArkMethod()) === null || _g === void 0 ? void 0 : _g.getBody()) === null || _h === void 0 ? void 0 : _h.getAliasTypeByName(baseName)) !== null && _j !== void 0 ? _j : ModelUtils_1.ModelUtils.getNamespaceWithName(baseName, arkClass)) !== null && _k !== void 0 ? _k : (_l = ModelUtils_1.ModelUtils.getDefaultClass(arkClass)) === null || _l === void 0 ? void 0 : _l.getMethodWithName(baseName)) !== null && _m !== void 0 ? _m : ModelUtils_1.ModelUtils.getArkExportInImportInfoWithName(baseName, arkClass.getDeclaringArkFile());
-        if (!arkExport && !arkClass.getDeclaringArkFile().getImportInfoBy(baseName)) {
-            arkExport = arkClass.getDeclaringArkFile().getScene().getSdkGlobal(baseName);
-        }
-        return this.parseArkExport2Type(arkExport);
-    }
-    static inferRealGenericTypes(realTypes, arkClass) {
-        if (!realTypes) {
-            return;
-        }
-        for (let i = 0; i < realTypes.length; i++) {
-            const mayType = realTypes[i];
-            if (this.isUnclearType(mayType)) {
-                const newType = this.inferUnclearedType(mayType, arkClass);
-                if (newType) {
-                    realTypes[i] = newType;
-                }
-            }
-        }
-    }
-    static inferDynamicImportType(from, arkClass) {
-        var _a;
-        const importInfo = new ArkImport_1.ImportInfo();
-        importInfo.setNameBeforeAs(TSConst_1.ALL);
-        importInfo.setImportClauseName(TSConst_1.ALL);
-        importInfo.setImportFrom(from);
-        importInfo.setDeclaringArkFile(arkClass.getDeclaringArkFile());
-        return TypeInference.parseArkExport2Type((_a = importInfo.getLazyExportInfo()) === null || _a === void 0 ? void 0 : _a.getArkExport());
-    }
-    static replaceTypeWithReal(type, realTypes) {
-        var _a, _b, _c, _d, _e, _f, _g, _h;
-        if (type instanceof Type_1.ClassType) {
-            const replacedTypes = (_b = (_a = type.getRealGenericTypes()) === null || _a === void 0 ? void 0 : _a.map(g => this.replaceTypeWithReal(g, realTypes))) !== null && _b !== void 0 ? _b : realTypes;
-            return replacedTypes && replacedTypes.length > 0 ? new Type_1.ClassType(type.getClassSignature(), replacedTypes) : type;
-        }
-        else if (type instanceof Type_1.FunctionType) {
-            const replacedTypes = (_d = (_c = type.getRealGenericTypes()) === null || _c === void 0 ? void 0 : _c.map(g => this.replaceTypeWithReal(g, realTypes))) !== null && _d !== void 0 ? _d : realTypes;
-            return replacedTypes && replacedTypes.length > 0 ? new Type_1.FunctionType(type.getMethodSignature(), replacedTypes) : type;
-        }
-        else if (type instanceof Type_1.AliasType && realTypes) {
-            const newObjectType = this.replaceTypeWithReal(type.getOriginalType(), realTypes);
-            const replacedTypes = (_f = (_e = type.getRealGenericTypes()) === null || _e === void 0 ? void 0 : _e.map(g => this.replaceTypeWithReal(g, realTypes))) !== null && _f !== void 0 ? _f : realTypes;
-            if (replacedTypes.length > 0) {
-                const newAliasType = new Type_1.AliasType(type.getName(), newObjectType, type.getSignature(), type.getGenericTypes());
-                newAliasType.setRealGenericTypes(replacedTypes);
-                return newAliasType;
-            }
-        }
-        else if (type instanceof Type_1.UnionType && realTypes) {
-            const types = [];
-            type.flatType().forEach(t => types.push(this.replaceTypeWithReal(t, realTypes)));
-            return new Type_1.UnionType(types, this.replaceTypeWithReal(type.getCurrType(), realTypes));
-        }
-        else if (type instanceof Type_1.IntersectionType && realTypes) {
-            const types = [];
-            type.getTypes().forEach(t => types.push(this.replaceTypeWithReal(t, realTypes)));
-            return new Type_1.IntersectionType(types);
-        }
-        else if (type instanceof Type_1.ArrayType && realTypes) {
-            const replacedBaseType = this.replaceTypeWithReal(type.getBaseType(), realTypes);
-            return new Type_1.ArrayType(replacedBaseType, type.getDimension());
-        }
-        else if (type instanceof Type_1.TupleType && realTypes) {
-            let replacedTypes = [];
-            type.getTypes().forEach(t => { replacedTypes.push(this.replaceTypeWithReal(t, realTypes)); });
-            return new Type_1.TupleType(replacedTypes);
-        }
-        else if (type instanceof Type_1.GenericType) {
-            const realType = (_h = (_g = realTypes === null || realTypes === void 0 ? void 0 : realTypes[type.getIndex()]) !== null && _g !== void 0 ? _g : type.getDefaultType()) !== null && _h !== void 0 ? _h : type.getConstraint();
-            if (realType) {
-                return realType;
-            }
-        }
-        else if (type instanceof Type_1.AnyType) {
-            const realType = realTypes === null || realTypes === void 0 ? void 0 : realTypes[0];
-            if (realType) {
-                return realType;
-            }
-        }
-        return type;
-    }
-    static replaceAliasType(type) {
-        let aliasType = type;
-        while (aliasType instanceof Type_1.AliasType) {
-            aliasType = aliasType.getOriginalType();
-        }
-        return aliasType;
-    }
-    static inferFunctionType(argType, params, realTypes) {
-        if (!params) {
-            return;
-        }
-        argType.getMethodSignature().getMethodSubSignature().getParameters()
-            .filter(p => !p.getName().startsWith(Const_1.LEXICAL_ENV_NAME_PREFIX))
-            .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);
-            }
-        });
-    }
-}
-exports.TypeInference = TypeInference;
+"use strict";
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeInference = void 0;
+const logger_1 = __importStar(require("../../utils/logger"));
+const Expr_1 = require("../base/Expr");
+const Local_1 = require("../base/Local");
+const Ref_1 = require("../base/Ref");
+const Stmt_1 = require("../base/Stmt");
+const Type_1 = require("../base/Type");
+const ArkMethod_1 = require("../model/ArkMethod");
+const ArkClass_1 = require("../model/ArkClass");
+const ArkField_1 = require("../model/ArkField");
+const Constant_1 = require("../base/Constant");
+const ArkNamespace_1 = require("../model/ArkNamespace");
+const TSConst_1 = require("./TSConst");
+const ModelUtils_1 = require("./ModelUtils");
+const Builtin_1 = require("./Builtin");
+const Const_1 = require("./Const");
+const ValueUtil_1 = require("./ValueUtil");
+const ArkImport_1 = require("../model/ArkImport");
+const IRInference_1 = require("./IRInference");
+const TypeExpr_1 = require("../base/TypeExpr");
+const logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'TypeInference');
+class TypeInference {
+    static inferTypeInArkField(arkField) {
+        var _a;
+        const arkClass = arkField.getDeclaringArkClass();
+        const stmts = arkField.getInitializer();
+        const method = (_a = arkClass.getMethodWithName(Const_1.INSTANCE_INIT_METHOD_NAME)) !== null && _a !== void 0 ? _a : arkClass.getMethodWithName(TSConst_1.CONSTRUCTOR_NAME);
+        for (const stmt of stmts) {
+            if (method) {
+                this.resolveTypeExprsInStmt(stmt, method);
+                this.resolveExprsInStmt(stmt, method);
+                this.resolveFieldRefsInStmt(stmt, method);
+                this.resolveArkAssignStmt(stmt, method);
+            }
+        }
+        const beforeType = arkField.getType();
+        if (!this.isUnclearType(beforeType)) {
+            return;
+        }
+        let rightType;
+        let fieldRef;
+        const lastStmt = stmts[stmts.length - 1];
+        if (lastStmt instanceof Stmt_1.ArkAssignStmt) {
+            rightType = lastStmt.getRightOp().getType();
+            if (lastStmt.getLeftOp() instanceof Ref_1.AbstractFieldRef) {
+                fieldRef = lastStmt.getLeftOp();
+            }
+        }
+        let fieldType;
+        if (beforeType) {
+            fieldType = this.inferUnclearedType(beforeType, arkClass, rightType);
+        }
+        if (fieldType) {
+            arkField.getSignature().setType(fieldType);
+            fieldRef === null || fieldRef === void 0 ? void 0 : fieldRef.setFieldSignature(arkField.getSignature());
+        }
+        else if (rightType && this.isUnclearType(beforeType) && !this.isUnclearType(rightType)) {
+            arkField.getSignature().setType(rightType);
+            fieldRef === null || fieldRef === void 0 ? void 0 : fieldRef.setFieldSignature(arkField.getSignature());
+        }
+    }
+    /**
+     * Infer type for a given unclear type.
+     * It returns an array with 2 items, original object and original type.
+     * The original object is null if there is no object, or it failed to find the object.
+     * The original type is null if failed to infer the type.
+     * @param leftOpType
+     * @param declaringArkClass
+     * @param [rightType]
+     * @returns
+     */
+    static inferUnclearedType(leftOpType, declaringArkClass, rightType) {
+        let type;
+        if (leftOpType instanceof Type_1.ClassType &&
+            leftOpType.getClassSignature().getDeclaringFileSignature().getFileName() === Const_1.UNKNOWN_FILE_NAME) {
+            type = TypeInference.inferUnclearRefName(leftOpType.getClassSignature().getClassName(), declaringArkClass);
+        }
+        else if (leftOpType instanceof Type_1.UnionType || leftOpType instanceof Type_1.IntersectionType || leftOpType instanceof Type_1.TupleType) {
+            let types = leftOpType.getTypes();
+            for (let i = 0; i < types.length; i++) {
+                let newType = this.inferUnclearedType(types[i], declaringArkClass);
+                if (newType) {
+                    types[i] = newType;
+                }
+            }
+            type = leftOpType;
+        }
+        else if (leftOpType instanceof Type_1.ArrayType) {
+            let baseType = this.inferUnclearedType(leftOpType.getBaseType(), declaringArkClass);
+            if (baseType) {
+                leftOpType.setBaseType(baseType);
+                type = leftOpType;
+            }
+        }
+        else if (leftOpType instanceof Type_1.AliasType) {
+            let baseType = this.inferUnclearedType(leftOpType.getOriginalType(), declaringArkClass);
+            if (baseType) {
+                leftOpType.setOriginalType(baseType);
+                type = leftOpType;
+            }
+        }
+        else if (leftOpType instanceof Type_1.AnnotationNamespaceType) {
+            type = this.inferUnclearRefName(leftOpType.getOriginType(), declaringArkClass);
+        }
+        else if (leftOpType instanceof Type_1.UnclearReferenceType) {
+            type = this.inferUnclearRefType(leftOpType, declaringArkClass);
+        }
+        return type;
+    }
+    static inferTypeInMethod(arkMethod) {
+        var _a;
+        const arkClass = arkMethod.getDeclaringArkClass();
+        this.inferGenericType(arkMethod.getGenericTypes(), arkClass);
+        const signatures = [];
+        (_a = arkMethod.getDeclareSignatures()) === null || _a === void 0 ? void 0 : _a.forEach(m => signatures.push(m));
+        const impl = arkMethod.getImplementationSignature();
+        if (impl) {
+            signatures.push(impl);
+        }
+        signatures.forEach(s => {
+            s.getMethodSubSignature().getParameters().forEach(p => {
+                this.inferParameterType(p, arkMethod);
+            });
+            this.inferSignatureReturnType(s, arkMethod);
+        });
+        const body = arkMethod.getBody();
+        if (!body) {
+            return;
+        }
+        const cfg = body.getCfg();
+        for (const block of cfg.getBlocks()) {
+            for (const stmt of block.getStmts()) {
+                this.resolveTypeExprsInStmt(stmt, arkMethod);
+                this.resolveExprsInStmt(stmt, arkMethod);
+                this.resolveFieldRefsInStmt(stmt, arkMethod);
+                this.resolveArkAssignStmt(stmt, arkMethod);
+            }
+        }
+    }
+    /**
+     * @Deprecated
+     * @param arkMethod
+     */
+    static inferSimpleTypeInMethod(arkMethod) {
+        const body = arkMethod.getBody();
+        if (!body) {
+            logger.warn('empty body');
+            return;
+        }
+        const cfg = body.getCfg();
+        for (const block of cfg.getBlocks()) {
+            for (const stmt of block.getStmts()) {
+                TypeInference.inferSimpleTypeInStmt(stmt);
+            }
+        }
+    }
+    /**
+     * infer type for Exprs in stmt which invoke method.
+     * such as ArkInstanceInvokeExpr ArkStaticInvokeExpr ArkNewExpr
+     */
+    static resolveExprsInStmt(stmt, arkMethod) {
+        for (const expr of stmt.getExprs()) {
+            const newExpr = expr.inferType(arkMethod);
+            if (stmt.containsInvokeExpr() && expr instanceof Expr_1.ArkInstanceInvokeExpr && newExpr instanceof Expr_1.ArkStaticInvokeExpr) {
+                stmt.replaceUse(expr, newExpr);
+            }
+        }
+        if (stmt instanceof Stmt_1.ArkAliasTypeDefineStmt && this.isUnclearType(stmt.getAliasType().getOriginalType())) {
+            stmt.getAliasType().setOriginalType(stmt.getAliasTypeExpr().getType());
+        }
+    }
+    /**
+     * infer value type for TypeExprs in stmt which specify the type such as TypeQueryExpr
+     */
+    static resolveTypeExprsInStmt(stmt, arkMethod) {
+        for (let typeExpr of stmt.getTypeExprs()) {
+            typeExpr.inferType(arkMethod);
+        }
+    }
+    /**
+     * infer type for fieldRefs in stmt.
+     */
+    static resolveFieldRefsInStmt(stmt, arkMethod) {
+        for (const use of stmt.getUses()) {
+            if (use instanceof Ref_1.AbstractRef) {
+                this.processRef(use, stmt, arkMethod);
+            }
+        }
+        const stmtDef = stmt.getDef();
+        if (stmtDef && stmtDef instanceof Ref_1.AbstractRef) {
+            const fieldRef = stmtDef.inferType(arkMethod);
+            stmt.replaceDef(stmtDef, fieldRef);
+        }
+    }
+    static processRef(use, stmt, arkMethod) {
+        var _a;
+        const fieldRef = use.inferType(arkMethod);
+        if (fieldRef instanceof Ref_1.ArkStaticFieldRef && stmt instanceof Stmt_1.ArkAssignStmt) {
+            stmt.replaceUse(use, fieldRef);
+        }
+        else if (use instanceof Ref_1.ArkInstanceFieldRef && fieldRef instanceof Ref_1.ArkArrayRef && stmt instanceof Stmt_1.ArkAssignStmt) {
+            const index = fieldRef.getIndex();
+            if (index instanceof Constant_1.Constant && index.getType() instanceof Type_1.StringType) {
+                const local = (_a = arkMethod === null || arkMethod === void 0 ? void 0 : arkMethod.getBody()) === null || _a === void 0 ? void 0 : _a.getLocals().get(index.getValue());
+                if (local) {
+                    fieldRef.setIndex(local);
+                }
+            }
+            stmt.replaceUse(use, fieldRef);
+        }
+    }
+    static parseArkExport2Type(arkExport) {
+        if (!arkExport) {
+            return null;
+        }
+        if (arkExport instanceof ArkClass_1.ArkClass) {
+            return new Type_1.ClassType(arkExport.getSignature(), arkExport.getGenericsTypes());
+        }
+        else if (arkExport instanceof ArkNamespace_1.ArkNamespace) {
+            return Type_1.AnnotationNamespaceType.getInstance(arkExport.getSignature());
+        }
+        else if (arkExport instanceof ArkMethod_1.ArkMethod) {
+            return new Type_1.FunctionType(arkExport.getSignature());
+        }
+        else if (arkExport instanceof Local_1.Local) {
+            if (arkExport.getType() instanceof Type_1.UnknownType || arkExport.getType() instanceof Type_1.UnclearReferenceType) {
+                return null;
+            }
+            return arkExport.getType();
+        }
+        else if (arkExport instanceof Type_1.AliasType) {
+            return arkExport;
+        }
+        else {
+            return null;
+        }
+    }
+    /**
+     * infer and pass type for ArkAssignStmt right and left
+     * @param stmt
+     * @param arkMethod
+     */
+    static resolveArkAssignStmt(stmt, arkMethod) {
+        var _a;
+        if (!(stmt instanceof Stmt_1.ArkAssignStmt)) {
+            return;
+        }
+        const arkClass = arkMethod.getDeclaringArkClass();
+        const rightOp = stmt.getRightOp();
+        let rightType = rightOp.getType();
+        if (this.isUnclearType(rightType)) {
+            rightType = this.inferUnclearedType(rightType, arkClass);
+            if (rightType) {
+                this.setValueType(rightOp, rightType);
+            }
+            else {
+                if (rightOp instanceof Local_1.Local) {
+                    IRInference_1.IRInference.inferLocal(rightOp, arkMethod);
+                    rightType = rightOp.getType();
+                }
+            }
+        }
+        const leftOp = stmt.getLeftOp();
+        let leftType = leftOp.getType();
+        if (this.isUnclearType(leftType)) {
+            const newLeftType = this.inferUnclearedType(leftType, arkClass);
+            if (!newLeftType && !this.isUnclearType(rightType)) {
+                leftType = rightType;
+            }
+            else if (newLeftType) {
+                leftType = newLeftType;
+            }
+        }
+        if (leftType && !this.isUnclearType(leftType)) {
+            this.setValueType(leftOp, leftType);
+            if (leftOp instanceof Local_1.Local && ((_a = stmt.getOriginalText()) === null || _a === void 0 ? void 0 : _a.startsWith(leftOp.getName()))) {
+                let localDef = ModelUtils_1.ModelUtils.findDeclaredLocal(leftOp, arkMethod);
+                if (localDef && this.isUnclearType(localDef.getType())) {
+                    localDef.setType(leftType);
+                }
+            }
+            if (rightType) {
+                IRInference_1.IRInference.inferRightWithSdkType(leftType, rightType, arkClass);
+            }
+        }
+    }
+    static setValueType(value, type) {
+        if (value instanceof Local_1.Local || value instanceof Ref_1.ArkParameterRef) {
+            value.setType(type);
+        }
+        else if (value instanceof Ref_1.AbstractFieldRef) {
+            value.getFieldSignature().setType(type);
+        }
+    }
+    static isUnclearType(type) {
+        // TODO: For UnionType, IntersectionType and TupleType, it should recurse check every item of them.
+        if (!type || type instanceof Type_1.UnknownType || type instanceof Type_1.UnclearReferenceType
+            || type instanceof Type_1.NullType || type instanceof Type_1.UndefinedType) {
+            return true;
+        }
+        else if (type instanceof Type_1.ClassType
+            && type.getClassSignature().getDeclaringFileSignature().getFileName() === Const_1.UNKNOWN_FILE_NAME) {
+            return true;
+        }
+        else if (type instanceof Type_1.UnionType || type instanceof Type_1.IntersectionType || type instanceof Type_1.TupleType) {
+            return !!type.getTypes().find(t => this.hasUnclearReferenceType(t));
+        }
+        else if (type instanceof Type_1.ArrayType) {
+            return this.hasUnclearReferenceType(type.getBaseType());
+        }
+        else if (type instanceof Type_1.AliasType) {
+            return this.isUnclearType(type.getOriginalType());
+        }
+        else if (type instanceof TypeExpr_1.KeyofTypeExpr) {
+            return this.isUnclearType(type.getOpType());
+        }
+        else if (type instanceof TypeExpr_1.TypeQueryExpr) {
+            return this.isUnclearType(type.getType());
+        }
+        return false;
+    }
+    // This is the temporally function to check unclearReferenceType recursively and can be removed after typeInfer supports multiple candidate types.
+    static hasUnclearReferenceType(type) {
+        if (type instanceof Type_1.UnclearReferenceType) {
+            return true;
+        }
+        else if (type instanceof Type_1.UnionType || type instanceof Type_1.IntersectionType || type instanceof Type_1.TupleType) {
+            return !!type.getTypes().find(t => this.hasUnclearReferenceType(t));
+        }
+        else if (type instanceof Type_1.ArrayType) {
+            return this.hasUnclearReferenceType(type.getBaseType());
+        }
+        else if (type instanceof Type_1.AliasType) {
+            return this.hasUnclearReferenceType(type.getOriginalType());
+        }
+        else if (type instanceof TypeExpr_1.KeyofTypeExpr) {
+            return this.hasUnclearReferenceType(type.getOpType());
+        }
+        else if (type instanceof TypeExpr_1.TypeQueryExpr) {
+            return this.hasUnclearReferenceType(type.getType());
+        }
+        return false;
+    }
+    static inferSimpleTypeInStmt(stmt) {
+        if (stmt instanceof Stmt_1.ArkAssignStmt) {
+            const leftOp = stmt.getLeftOp();
+            if (leftOp instanceof Local_1.Local) {
+                const leftOpType = leftOp.getType();
+                if (leftOpType instanceof Type_1.UnknownType) {
+                    const rightOp = stmt.getRightOp();
+                    leftOp.setType(rightOp.getType());
+                }
+            }
+        }
+    }
+    // Deal only with simple situations
+    static buildTypeFromStr(typeStr) {
+        switch (typeStr) {
+            case 'boolean':
+                return Type_1.BooleanType.getInstance();
+            case 'number':
+                return Type_1.NumberType.getInstance();
+            case 'string':
+                return Type_1.StringType.getInstance();
+            case 'undefined':
+                return Type_1.UndefinedType.getInstance();
+            case 'null':
+                return Type_1.NullType.getInstance();
+            case 'any':
+                return Type_1.AnyType.getInstance();
+            case 'void':
+                return Type_1.VoidType.getInstance();
+            case 'never':
+                return Type_1.NeverType.getInstance();
+            case 'RegularExpression': {
+                const classSignature = Builtin_1.Builtin.REGEXP_CLASS_SIGNATURE;
+                return new Type_1.ClassType(classSignature);
+            }
+            default:
+                return new Type_1.UnclearReferenceType(typeStr);
+        }
+    }
+    static inferValueType(value, arkMethod) {
+        if (value instanceof Ref_1.ArkInstanceFieldRef || value instanceof Expr_1.ArkInstanceInvokeExpr) {
+            this.inferValueType(value.getBase(), arkMethod);
+        }
+        if (value instanceof Ref_1.AbstractRef || value instanceof Expr_1.AbstractExpr || value instanceof Local_1.Local) {
+            value.inferType(arkMethod);
+        }
+        return value.getType();
+    }
+    static inferParameterType(param, arkMethod) {
+        let pType = param.getType();
+        const type = TypeInference.inferUnclearedType(pType, arkMethod.getDeclaringArkClass());
+        if (type) {
+            param.setType(type);
+        }
+        else {
+            if (pType instanceof TypeExpr_1.AbstractTypeExpr) {
+                pType.inferType(arkMethod);
+            }
+        }
+    }
+    static inferSignatureReturnType(oldSignature, arkMethod) {
+        if (oldSignature.getMethodSubSignature().getMethodName() === TSConst_1.CONSTRUCTOR_NAME) {
+            const newReturnType = new Type_1.ClassType(oldSignature.getDeclaringClassSignature());
+            oldSignature.getMethodSubSignature().setReturnType(newReturnType);
+            return;
+        }
+        const currReturnType = oldSignature.getType();
+        if (!this.isUnclearType(currReturnType)) {
+            return;
+        }
+        if (currReturnType instanceof TypeExpr_1.AbstractTypeExpr) {
+            currReturnType.inferType(arkMethod);
+            return;
+        }
+        if (currReturnType instanceof Type_1.ArrayType && currReturnType.getBaseType() instanceof TypeExpr_1.AbstractTypeExpr) {
+            currReturnType.getBaseType().inferType(arkMethod);
+            return;
+        }
+        const newReturnType = this.inferUnclearedType(currReturnType, arkMethod.getDeclaringArkClass());
+        if (newReturnType) {
+            oldSignature.getMethodSubSignature().setReturnType(newReturnType);
+        }
+        else if (arkMethod.getBody()) {
+            const typeMap = new Map();
+            for (let returnValue of arkMethod.getReturnValues()) {
+                const type = returnValue.getType();
+                if (type instanceof Type_1.UnionType) {
+                    type.flatType().filter(t => !TypeInference.isUnclearType(t)).forEach(t => typeMap.set(t.toString(), t));
+                }
+                else if (!TypeInference.isUnclearType(type)) {
+                    typeMap.set(type.toString(), type);
+                }
+            }
+            if (typeMap.size > 0) {
+                const types = Array.from(typeMap.values());
+                oldSignature.getMethodSubSignature().setReturnType(types.length === 1 ? types[0] : new Type_1.UnionType(types));
+            }
+        }
+    }
+    static inferGenericType(types, arkClass) {
+        types === null || types === void 0 ? void 0 : types.forEach(type => {
+            const defaultType = type.getDefaultType();
+            if (defaultType instanceof Type_1.UnclearReferenceType) {
+                const newDefaultType = TypeInference.inferUnclearRefName(defaultType.getName(), arkClass);
+                if (newDefaultType) {
+                    type.setDefaultType(this.replaceTypeWithReal(newDefaultType));
+                }
+            }
+            const constraint = type.getConstraint();
+            if (constraint instanceof Type_1.UnclearReferenceType) {
+                const newConstraint = TypeInference.inferUnclearRefName(constraint.getName(), arkClass);
+                if (newConstraint) {
+                    type.setConstraint(this.replaceTypeWithReal(newConstraint));
+                }
+            }
+        });
+    }
+    /**
+     * Infer type for a given {@link UnclearReferenceType} type.
+     * It returns original type.
+     * The original type is null if it failed to infer the type.
+     * @param urType
+     * @param arkClass
+     * @returns
+     */
+    static inferUnclearRefType(urType, arkClass) {
+        var _a;
+        const realTypes = urType.getGenericTypes();
+        this.inferRealGenericTypes(realTypes, arkClass);
+        if (urType.getName() === Builtin_1.Builtin.ARRAY) {
+            return new Type_1.ArrayType((_a = realTypes[0]) !== null && _a !== void 0 ? _a : Type_1.AnyType.getInstance(), 1);
+        }
+        let type = this.inferUnclearRefName(urType.getName(), arkClass);
+        return type ? this.replaceTypeWithReal(type, realTypes) : null;
+    }
+    /**
+     * Find out the original object and type for a given unclear reference type name.
+     * It returns original type.
+     * The original type is null if it failed to infer the type.
+     * @param refName
+     * @param arkClass
+     * @returns
+     */
+    static inferUnclearRefName(refName, arkClass) {
+        var _a;
+        if (!refName) {
+            return null;
+        }
+        //split and iterate to infer each type
+        const singleNames = refName.split('.');
+        let type = null;
+        for (let i = 0; i < singleNames.length; i++) {
+            let genericName = ValueUtil_1.EMPTY_STRING;
+            const name = singleNames[i].replace(/<(\w+)>/, (match, group1) => {
+                genericName = group1;
+                return ValueUtil_1.EMPTY_STRING;
+            });
+            if (i === 0) {
+                type = this.inferBaseType(name, arkClass);
+            }
+            else if (type) {
+                type = (_a = this.inferFieldType(type, name, arkClass)) === null || _a === void 0 ? void 0 : _a[1];
+            }
+            if (!type) {
+                return null;
+            }
+            if (genericName) {
+                const realTypes = genericName.split(',').map(generic => {
+                    const realType = this.inferBaseType(generic, arkClass);
+                    return realType !== null && realType !== void 0 ? realType : new Type_1.UnclearReferenceType(generic);
+                });
+                if (type instanceof Type_1.ClassType) {
+                    type = new Type_1.ClassType(type.getClassSignature(), realTypes);
+                }
+                else if (type instanceof Type_1.FunctionType) {
+                    type = new Type_1.FunctionType(type.getMethodSignature(), realTypes);
+                }
+            }
+        }
+        return type;
+    }
+    /**
+     * Find out the original object and type for a given base type and the field name.
+     * It returns an array with 2 items, original object and original type.
+     * The original object is null if there is no object, or it failed to find the object.
+     * The original type is null if it failed to infer the type.
+     * @param baseType
+     * @param fieldName
+     * @param declareClass
+     * @returns
+     */
+    static inferFieldType(baseType, fieldName, declareClass) {
+        if (baseType instanceof Type_1.AliasType) {
+            baseType = baseType.getOriginalType();
+        }
+        else if (baseType instanceof Type_1.UnionType && baseType.getCurrType()) {
+            baseType = baseType.getCurrType();
+        }
+        let propertyAndType = null;
+        if (baseType instanceof Type_1.ClassType) {
+            const arkClass = declareClass.getDeclaringArkFile().getScene().getClass(baseType.getClassSignature());
+            if (!arkClass && fieldName === Builtin_1.Builtin.ITERATOR_RESULT_VALUE && baseType.getClassSignature()
+                .getDeclaringFileSignature().getProjectName() === Builtin_1.Builtin.DUMMY_PROJECT_NAME) {
+                const types = baseType.getRealGenericTypes();
+                if (types && types.length > 0) {
+                    propertyAndType = [null, types[0]];
+                }
+            }
+            if (!arkClass) {
+                return propertyAndType;
+            }
+            if (arkClass.isAnonymousClass()) {
+                const fieldType = this.inferUnclearRefName(fieldName, arkClass);
+                return fieldType ? [null, fieldType] : null;
+            }
+            const property = ModelUtils_1.ModelUtils.findPropertyInClass(fieldName, arkClass);
+            let propertyType = null;
+            if (property instanceof ArkField_1.ArkField) {
+                propertyType = property.getType();
+            }
+            else if (property) {
+                propertyType = this.parseArkExport2Type(property);
+            }
+            if (propertyType) {
+                propertyAndType = [property, propertyType];
+            }
+        }
+        else if (baseType instanceof Type_1.AnnotationNamespaceType) {
+            const namespace = declareClass.getDeclaringArkFile().getScene().getNamespace(baseType.getNamespaceSignature());
+            if (namespace) {
+                const property = ModelUtils_1.ModelUtils.findPropertyInNamespace(fieldName, namespace);
+                const propertyType = this.parseArkExport2Type(property);
+                if (propertyType) {
+                    propertyAndType = [property, propertyType];
+                }
+            }
+        }
+        else {
+            logger.warn('infer unclear reference type fail: ' + fieldName);
+        }
+        return propertyAndType;
+    }
+    /**
+     * Find out the original object and type for a given base name.
+     * It returns original type.
+     * The original type is null if failed to infer the type.
+     * @param baseName
+     * @param arkClass
+     * @returns
+     */
+    static inferBaseType(baseName, arkClass) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+        if (TSConst_1.SUPER_NAME === baseName) {
+            return this.parseArkExport2Type(arkClass.getSuperClass());
+        }
+        const field = (_d = (_c = (_b = (_a = ModelUtils_1.ModelUtils.getDefaultClass(arkClass)) === null || _a === void 0 ? void 0 : _a.getDefaultArkMethod()) === null || _b === void 0 ? void 0 : _b.getBody()) === null || _c === void 0 ? void 0 : _c.getLocals()) === null || _d === void 0 ? void 0 : _d.get(baseName);
+        if (field && !this.isUnclearType(field.getType())) {
+            return field.getType();
+        }
+        let arkExport = (_m = (_k = (_j = (_e = ModelUtils_1.ModelUtils.getClassWithName(baseName, arkClass)) !== null && _e !== void 0 ? _e : (_h = (_g = (_f = ModelUtils_1.ModelUtils.getDefaultClass(arkClass)) === null || _f === void 0 ? void 0 : _f.getDefaultArkMethod()) === null || _g === void 0 ? void 0 : _g.getBody()) === null || _h === void 0 ? void 0 : _h.getAliasTypeByName(baseName)) !== null && _j !== void 0 ? _j : ModelUtils_1.ModelUtils.getNamespaceWithName(baseName, arkClass)) !== null && _k !== void 0 ? _k : (_l = ModelUtils_1.ModelUtils.getDefaultClass(arkClass)) === null || _l === void 0 ? void 0 : _l.getMethodWithName(baseName)) !== null && _m !== void 0 ? _m : ModelUtils_1.ModelUtils.getArkExportInImportInfoWithName(baseName, arkClass.getDeclaringArkFile());
+        if (!arkExport && !arkClass.getDeclaringArkFile().getImportInfoBy(baseName)) {
+            arkExport = arkClass.getDeclaringArkFile().getScene().getSdkGlobal(baseName);
+        }
+        return this.parseArkExport2Type(arkExport);
+    }
+    static inferRealGenericTypes(realTypes, arkClass) {
+        if (!realTypes) {
+            return;
+        }
+        for (let i = 0; i < realTypes.length; i++) {
+            const mayType = realTypes[i];
+            if (this.isUnclearType(mayType)) {
+                const newType = this.inferUnclearedType(mayType, arkClass);
+                if (newType) {
+                    realTypes[i] = newType;
+                }
+            }
+        }
+    }
+    static inferDynamicImportType(from, arkClass) {
+        var _a;
+        const importInfo = new ArkImport_1.ImportInfo();
+        importInfo.setNameBeforeAs(TSConst_1.ALL);
+        importInfo.setImportClauseName(TSConst_1.ALL);
+        importInfo.setImportFrom(from);
+        importInfo.setDeclaringArkFile(arkClass.getDeclaringArkFile());
+        return TypeInference.parseArkExport2Type((_a = importInfo.getLazyExportInfo()) === null || _a === void 0 ? void 0 : _a.getArkExport());
+    }
+    static replaceTypeWithReal(type, realTypes) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        if (type instanceof Type_1.ClassType) {
+            const replacedTypes = (_b = (_a = type.getRealGenericTypes()) === null || _a === void 0 ? void 0 : _a.map(g => this.replaceTypeWithReal(g, realTypes))) !== null && _b !== void 0 ? _b : realTypes;
+            return replacedTypes && replacedTypes.length > 0 ? new Type_1.ClassType(type.getClassSignature(), replacedTypes) : type;
+        }
+        else if (type instanceof Type_1.FunctionType) {
+            const replacedTypes = (_d = (_c = type.getRealGenericTypes()) === null || _c === void 0 ? void 0 : _c.map(g => this.replaceTypeWithReal(g, realTypes))) !== null && _d !== void 0 ? _d : realTypes;
+            return replacedTypes && replacedTypes.length > 0 ? new Type_1.FunctionType(type.getMethodSignature(), replacedTypes) : type;
+        }
+        else if (type instanceof Type_1.AliasType && realTypes) {
+            const newObjectType = this.replaceTypeWithReal(type.getOriginalType(), realTypes);
+            const replacedTypes = (_f = (_e = type.getRealGenericTypes()) === null || _e === void 0 ? void 0 : _e.map(g => this.replaceTypeWithReal(g, realTypes))) !== null && _f !== void 0 ? _f : realTypes;
+            if (replacedTypes.length > 0) {
+                const newAliasType = new Type_1.AliasType(type.getName(), newObjectType, type.getSignature(), type.getGenericTypes());
+                newAliasType.setRealGenericTypes(replacedTypes);
+                return newAliasType;
+            }
+        }
+        else if (type instanceof Type_1.UnionType && realTypes) {
+            const types = [];
+            type.flatType().forEach(t => types.push(this.replaceTypeWithReal(t, realTypes)));
+            return new Type_1.UnionType(types, this.replaceTypeWithReal(type.getCurrType(), realTypes));
+        }
+        else if (type instanceof Type_1.IntersectionType && realTypes) {
+            const types = [];
+            type.getTypes().forEach(t => types.push(this.replaceTypeWithReal(t, realTypes)));
+            return new Type_1.IntersectionType(types);
+        }
+        else if (type instanceof Type_1.ArrayType && realTypes) {
+            const replacedBaseType = this.replaceTypeWithReal(type.getBaseType(), realTypes);
+            return new Type_1.ArrayType(replacedBaseType, type.getDimension());
+        }
+        else if (type instanceof Type_1.TupleType && realTypes) {
+            let replacedTypes = [];
+            type.getTypes().forEach(t => { replacedTypes.push(this.replaceTypeWithReal(t, realTypes)); });
+            return new Type_1.TupleType(replacedTypes);
+        }
+        else if (type instanceof Type_1.GenericType) {
+            const realType = (_h = (_g = realTypes === null || realTypes === void 0 ? void 0 : realTypes[type.getIndex()]) !== null && _g !== void 0 ? _g : type.getDefaultType()) !== null && _h !== void 0 ? _h : type.getConstraint();
+            if (realType) {
+                return realType;
+            }
+        }
+        else if (type instanceof Type_1.AnyType) {
+            const realType = realTypes === null || realTypes === void 0 ? void 0 : realTypes[0];
+            if (realType) {
+                return realType;
+            }
+        }
+        return type;
+    }
+    static replaceAliasType(type) {
+        let aliasType = type;
+        while (aliasType instanceof Type_1.AliasType) {
+            aliasType = aliasType.getOriginalType();
+        }
+        return aliasType;
+    }
+    static inferFunctionType(argType, params, realTypes) {
+        if (!params) {
+            return;
+        }
+        argType.getMethodSignature().getMethodSubSignature().getParameters()
+            .filter(p => !p.getName().startsWith(Const_1.LEXICAL_ENV_NAME_PREFIX))
+            .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);
+            }
+        });
+    }
+}
+exports.TypeInference = TypeInference;