arkanalyzer 1.0.86 → 1.0.87

package/lib/frontend/cppFrontend/common/TypeInference.js

@@ -0,0 +1,1354 @@
+"use strict";
+/*
+ * Copyright (c) 2024-2025 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("../../../core/base/Expr");
+const Local_1 = require("../../../core/base/Local");
+const Ref_1 = require("../../../core/base/Ref");
+const Stmt_1 = require("../../../core/base/Stmt");
+const Type_1 = require("../../../core/base/Type");
+const Type_2 = require("../base/Type");
+const ArkMethod_1 = require("../../../core/model/ArkMethod");
+const ArkClass_1 = require("../../../core/model/ArkClass");
+const ArkField_1 = require("../../../core/model/ArkField");
+const Constant_1 = require("../../../core/base/Constant");
+const ArkNamespace_1 = require("../../../core/model/ArkNamespace");
+const TSConst_1 = require("../../../core/common/TSConst");
+const ModelUtils_1 = require("../../../core/common/ModelUtils");
+const Builtin_1 = require("../../../core/common/Builtin");
+const ArkSignature_1 = require("../../../core/model/ArkSignature");
+const Const_1 = require("../../../core/common/Const");
+const ValueUtil_1 = require("../../../core/common/ValueUtil");
+const ArkImport_1 = require("../../../core/model/ArkImport");
+const IRInference_1 = require("./IRInference");
+const TypeExpr_1 = require("../../../core/base/TypeExpr");
+const SdkUtils_1 = require("../../../core/common/SdkUtils");
+const ArkBaseModel_1 = require("../../../core/model/ArkBaseModel");
+const Builtin_2 = require("./Builtin");
+const ModelUtils_2 = require("./ModelUtils");
+const ArkFile_1 = require("../../../core/model/ArkFile");
+const logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'TypeInference');
+const unknownFileName = [Const_1.UNKNOWN_FILE_NAME, Builtin_1.Builtin.DUMMY_FILE_NAME];
+class TypeInference {
+    static inferTypeInArkField(arkField) {
+        var _a, _b;
+        const arkClass = arkField.getDeclaringArkClass();
+        const stmts = arkField.getInitializer();
+        const method = (_b = (_a = arkClass.getMethodWithName(Const_1.INSTANCE_INIT_METHOD_NAME)) !== null && _a !== void 0 ? _a : arkClass.getMethodWithName(Const_1.STATIC_INIT_METHOD_NAME)) !== null && _b !== void 0 ? _b : arkClass.getMethodWithName(TSConst_1.CONSTRUCTOR_NAME);
+        for (const stmt of stmts) {
+            if (method) {
+                this.resolveStmt(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.ArkInstanceFieldRef) {
+                fieldRef = lastStmt.getLeftOp();
+            }
+        }
+        let fieldType;
+        if (beforeType) {
+            fieldType = this.inferUnclearedType(beforeType, arkClass);
+        }
+        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 visited
+     * @returns
+     */
+    static inferUnclearedType(leftOpType, declaringArkClass, visited = new Set()) {
+        let typeWithoutPtrOrRef = leftOpType;
+        if (typeWithoutPtrOrRef instanceof Type_2.PointerType || typeWithoutPtrOrRef instanceof Type_2.ReferenceType) {
+            typeWithoutPtrOrRef = typeWithoutPtrOrRef.getBaseType();
+        }
+        if (visited.has(typeWithoutPtrOrRef)) {
+            return typeWithoutPtrOrRef;
+        }
+        else {
+            visited.add(typeWithoutPtrOrRef);
+        }
+        let type;
+        if (typeWithoutPtrOrRef instanceof Type_1.ClassType &&
+            unknownFileName.includes(typeWithoutPtrOrRef.getClassSignature().getDeclaringFileSignature().getFileName())) {
+            const realTypes = typeWithoutPtrOrRef.getRealGenericTypes();
+            this.inferRealGenericTypes(realTypes, declaringArkClass);
+            let newType = this.inferUnclearRefName(typeWithoutPtrOrRef.getClassSignature().getClassName(), declaringArkClass);
+            type = newType ? this.replaceTypeWithReal(newType, realTypes) : null;
+        }
+        else if (typeWithoutPtrOrRef instanceof TypeExpr_1.TypeQueryExpr) {
+            this.inferRealGenericTypes(typeWithoutPtrOrRef.getGenerateTypes(), declaringArkClass);
+            type = typeWithoutPtrOrRef;
+        }
+        else if (typeWithoutPtrOrRef instanceof Type_1.TupleType) {
+            this.inferRealGenericTypes(typeWithoutPtrOrRef.getTypes(), declaringArkClass);
+            type = typeWithoutPtrOrRef;
+        }
+        else if (typeWithoutPtrOrRef instanceof Type_1.GenericType) {
+            this.inferGenericType([typeWithoutPtrOrRef], declaringArkClass);
+            type = typeWithoutPtrOrRef;
+        }
+        else if (typeWithoutPtrOrRef instanceof Type_1.AnnotationNamespaceType) {
+            type = this.inferBaseType(typeWithoutPtrOrRef.getOriginType(), declaringArkClass);
+        }
+        else if (typeWithoutPtrOrRef instanceof Type_1.UnclearReferenceType) {
+            type = this.inferUnclearRefType(typeWithoutPtrOrRef, declaringArkClass);
+        }
+        if (type) {
+            if (leftOpType instanceof Type_2.PointerType || leftOpType instanceof Type_2.ReferenceType) {
+                leftOpType.setBaseType(type);
+                return leftOpType;
+            }
+            return type;
+        }
+        type = this.inferUnclearComplexType(typeWithoutPtrOrRef, declaringArkClass, visited);
+        if (type) {
+            if (leftOpType instanceof Type_2.PointerType || leftOpType instanceof Type_2.ReferenceType) {
+                leftOpType.setBaseType(type);
+                return leftOpType;
+            }
+        }
+        return type;
+    }
+    static inferUnclearComplexType(leftOpType, declaringArkClass, visited) {
+        var _a;
+        let type;
+        if (leftOpType instanceof Type_1.ArrayType) {
+            let baseType = this.inferUnclearedType(leftOpType.getBaseType(), declaringArkClass, visited);
+            if (baseType) {
+                leftOpType.setBaseType(baseType);
+                type = leftOpType;
+            }
+        }
+        else if (leftOpType instanceof Type_1.AliasType) {
+            const defArkClass = (_a = declaringArkClass.getDeclaringArkFile().getScene().getMethod(leftOpType.getSignature().getDeclaringMethodSignature())) === null || _a === void 0 ? void 0 : _a.getDeclaringArkClass();
+            let baseType = this.inferUnclearedType(leftOpType.getOriginalType(), defArkClass !== null && defArkClass !== void 0 ? defArkClass : declaringArkClass, visited);
+            if (baseType) {
+                leftOpType.setOriginalType(baseType);
+                type = leftOpType;
+            }
+        }
+        return type;
+    }
+    /**
+     * Type information in inference method
+     * @param arkMethod Ark method object for type inference
+     */
+    static inferTypeInMethod(arkMethod) {
+        var _a, _b;
+        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);
+            });
+        });
+        const body = arkMethod.getBody();
+        if (!body) {
+            signatures.forEach(s => this.inferSignatureReturnType(s, arkMethod));
+            return;
+        }
+        (_b = body.getUsedGlobals()) === null || _b === void 0 ? void 0 : _b.forEach((value, key) => {
+            if (value instanceof Ref_1.GlobalRef && !value.getRef()) {
+                const arkExport = ModelUtils_1.ModelUtils.findGlobalRef(key, arkMethod);
+                if (arkExport instanceof Local_1.Local) {
+                    arkExport.getUsedStmts().push(...value.getUsedStmts());
+                    value.setRef(arkExport);
+                }
+            }
+        });
+        const cfg = body.getCfg();
+        for (const block of cfg.getBlocks()) {
+            for (const stmt of block.getStmts()) {
+                this.resolveStmt(stmt, arkMethod);
+            }
+        }
+        signatures.forEach(s => this.inferSignatureReturnType(s, arkMethod));
+    }
+    /**
+     * Parse statement and process various references and expressions within it
+     * @param stmt Statement object to be parsed
+     * @param arkMethod Current Ark method context
+     */
+    static resolveStmt(stmt, arkMethod) {
+        try {
+            this.resolveTypeExprsInStmt(stmt, arkMethod);
+            this.resolveExprsInStmt(stmt, arkMethod);
+            this.resolveFieldRefsInStmt(stmt, arkMethod);
+            this.resolveArkAssignStmt(stmt, arkMethod);
+            this.resolveArkReturnStmt(stmt, arkMethod);
+        }
+        catch (e) {
+            logger.warn('stmt is not correct: ' + stmt.toString());
+        }
+    }
+    /**
+     * @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) {
+        var _a;
+        for (const expr of stmt.getExprs()) {
+            const newExpr = expr.inferType(arkMethod);
+            if ((stmt.containsInvokeExpr() &&
+                ((expr instanceof Expr_1.ArkInstanceInvokeExpr && newExpr instanceof Expr_1.ArkStaticInvokeExpr) || newExpr instanceof Expr_1.ArkPtrInvokeExpr)) ||
+                (newExpr instanceof Expr_1.ArkInstanceInvokeExpr && Builtin_2.BuiltinCxx.isBuiltinClass(newExpr.getMethodSignature().getDeclaringClassSignature()))) {
+                stmt.replaceUse(expr, newExpr);
+            }
+            // After infer the invoke method, it should replace the super.foo() to this.foo() while the foo is with super class as declaring class.
+            if (newExpr instanceof Expr_1.ArkInstanceInvokeExpr && newExpr.getBase().getName() === TSConst_1.SUPER_NAME) {
+                const thisLocal = (_a = arkMethod.getBody()) === null || _a === void 0 ? void 0 : _a.getLocals().get(TSConst_1.THIS_NAME);
+                if (thisLocal) {
+                    newExpr.setBase(thisLocal);
+                    thisLocal.addUsedStmt(stmt);
+                }
+            }
+        }
+        if (stmt instanceof Stmt_1.ArkAliasTypeDefineStmt && this.isUnclearType(stmt.getAliasType().getOriginalType())) {
+            stmt.getAliasType().setOriginalType(stmt.getAliasTypeExpr().getType());
+        }
+        // 处理ts2cxxFuncMap
+        if (stmt instanceof Stmt_1.ArkInvokeStmt) {
+            const invokeExpr = stmt.getInvokeExpr();
+            if (!(invokeExpr instanceof Expr_1.ArkInstanceInvokeExpr)) {
+                return;
+            }
+            const instInvokeExpr = invokeExpr;
+            const invokeBaseType = instInvokeExpr.getBase().getType();
+            if (invokeBaseType instanceof Type_1.ClassType && invokeBaseType.getClassSignature().getClassName() === 'napi_property_descriptor') {
+                (0, ModelUtils_2.setTs2CxxFuncMapOfClass)(instInvokeExpr.getArgs(), false, stmt.getCfg().getDeclaringMethod());
+            }
+        }
+    }
+    /**
+     * 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) {
+            if (arkMethod.getName() === Const_1.INSTANCE_INIT_METHOD_NAME &&
+                stmtDef instanceof Ref_1.ArkInstanceFieldRef &&
+                stmtDef.getBase().getName() === TSConst_1.THIS_NAME &&
+                arkMethod.getDeclaringArkClass().isAnonymousClass() &&
+                stmtDef.getFieldName().indexOf('.') === -1) {
+                return;
+            }
+            this.processRef(stmtDef, stmt, arkMethod, false);
+        }
+    }
+    /**
+     *Process field references, perform corresponding conversion processing according to the reference type and statement type,
+     * process static field references, process instance field references and field references as array references,
+     * and try to replace them with local variables when the index is a string constant
+     *@param use - abstract reference object, which may be a static field reference or an instance field reference
+     *@param stmt - statement object, used to replace references
+     *@param arkMethod - Ark method object, used to obtain method body information
+     *@param replaceUse - is new fieldRef replace use
+     */
+    static processRef(use, stmt, arkMethod, replaceUse = true) {
+        const fieldRef = use.inferType(arkMethod);
+        if (fieldRef instanceof Ref_1.ArkStaticFieldRef && stmt instanceof Stmt_1.ArkAssignStmt) {
+            if (replaceUse) {
+                stmt.replaceUse(use, fieldRef);
+            }
+            else {
+                stmt.replaceDef(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 = this.getLocalFromMethodBody(index.getValue(), arkMethod);
+                if (local) {
+                    fieldRef.setIndex(local);
+                }
+            }
+            if (replaceUse) {
+                stmt.replaceUse(use, fieldRef);
+            }
+            else {
+                stmt.replaceDef(use, fieldRef);
+            }
+        }
+    }
+    static getLocalFromMethodBody(name, arkMethod) {
+        var _a, _b, _c;
+        const local = (_a = arkMethod === null || arkMethod === void 0 ? void 0 : arkMethod.getBody()) === null || _a === void 0 ? void 0 : _a.getLocals().get(name);
+        if (local) {
+            return local;
+        }
+        const globalRef = (_c = (_b = arkMethod === null || arkMethod === void 0 ? void 0 : arkMethod.getBody()) === null || _b === void 0 ? void 0 : _b.getUsedGlobals()) === null || _c === void 0 ? void 0 : _c.get(name);
+        if (globalRef === undefined || !(globalRef instanceof Ref_1.GlobalRef)) {
+            return null;
+        }
+        const ref = globalRef.getRef();
+        if (ref !== null && ref instanceof Local_1.Local) {
+            return ref;
+        }
+        return null;
+    }
+    /**
+     * Parse ArkExport object into corresponding Type
+     * @param arkExport - The ArkExport object to parse, may be undefined or null
+     * @returns The parsed Type object, or null if it cannot be parsed
+     */
+    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) {
+        if (!(stmt instanceof Stmt_1.ArkAssignStmt)) {
+            return;
+        }
+        const arkClass = arkMethod.getDeclaringArkClass();
+        const rightOp = stmt.getRightOp();
+        // infer not only UnknowType but also other unclear types
+        if (rightOp instanceof Local_1.Local && this.isUnclearType(rightOp.getType())) {
+            IRInference_1.IRInference.inferLocal(rightOp, arkMethod);
+        }
+        let rightType = rightOp.getType();
+        let baseType;
+        if (rightType instanceof Type_2.PointerType || rightType instanceof Type_2.ReferenceType) {
+            baseType = rightType.getBaseType();
+            if (this.isUnclearType(baseType)) {
+                baseType = this.inferUnclearedType(baseType, arkClass);
+                if (baseType) {
+                    rightType.setBaseType(baseType);
+                }
+            }
+        }
+        if (this.isUnclearType(rightType)) {
+            rightType = this.inferUnclearedType(rightType, arkClass);
+            if (rightType) {
+                this.setValueType(rightOp, rightType);
+            }
+        }
+        TypeInference.resolveLeftOp(stmt, arkClass, rightType, arkMethod);
+    }
+    /**
+     * Resolve type inference and setting for the left operand of an assignment statement
+     *
+     * @param stmt Assignment statement node
+     * @param arkClass The current Ark class
+     * @param rightType Type of the right-hand expression in the assignment
+     * @param arkMethod The current Ark method
+     */
+    static resolveLeftOp(stmt, arkClass, rightType, arkMethod) {
+        var _a;
+        let leftType = this.inferLeftOpType(stmt, arkClass, rightType, arkMethod);
+        const leftOp = stmt.getLeftOp();
+        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);
+            }
+            if (leftOp instanceof Ref_1.AbstractFieldRef) {
+                const declaringSignature = leftOp.getFieldSignature().getDeclaringSignature();
+                if (declaringSignature instanceof ArkSignature_1.NamespaceSignature && declaringSignature.getNamespaceName() === TSConst_1.GLOBAL_THIS_NAME) {
+                    SdkUtils_1.SdkUtils.computeGlobalThis(leftOp, arkMethod);
+                }
+            }
+        }
+    }
+    /**
+     * Infer the type of the left operand in an assignment statement
+     *
+     * @param arkClass Current class object
+     * @param rightType The type on the right side of the assignment statement
+     * @param leftOp The operand on the left side of the assignment
+     * @param arkMethod Current method object
+     * @param stmt Assignment statement object
+     * @returns The inferred left type, or null/undefined if it cannot be inferred
+     */
+    static inferLeftOpType(stmt, arkClass, rightType, arkMethod) {
+        const leftOp = stmt.getLeftOp();
+        let leftType = leftOp.getType();
+        let baseType = leftType;
+        // If it is a Cxx pointer or reference type, it is necessary to obtain its baseType and determine whether type inference is required.
+        if (leftType instanceof Type_2.PointerType || leftType instanceof Type_2.ReferenceType) {
+            baseType = leftType.getBaseType();
+        }
+        if (this.isUnclearType(baseType)) {
+            const newLeftType = this.inferUnclearedType(baseType, arkClass);
+            if (!newLeftType && !this.isUnclearType(rightType)) {
+                leftType = rightType;
+            }
+            else if (newLeftType) {
+                if (leftType instanceof Type_2.PointerType || leftType instanceof Type_2.ReferenceType) {
+                    leftType.setBaseType(newLeftType);
+                }
+                else {
+                    leftType = newLeftType;
+                }
+            }
+        }
+        else if (leftOp instanceof Local_1.Local && leftOp.getName() === TSConst_1.THIS_NAME) {
+            const thisLocal = IRInference_1.IRInference.inferThisLocal(arkMethod);
+            if (thisLocal) {
+                stmt.setLeftOp(thisLocal);
+            }
+            else {
+                leftType = rightType;
+            }
+        }
+        else if (baseType instanceof Type_1.FunctionType && !this.isUnclearType(rightType) &&
+            baseType.getMethodSignature().getMethodSubSignature().getMethodName().startsWith(Const_1.ANONYMOUS_METHOD_PREFIX)) {
+            leftType = rightType;
+        }
+        return leftType || null;
+    }
+    /**
+     * Set the type of value
+     *
+     * @param value The value object whose type needs to be set
+     * @param type The type to be set
+     */
+    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);
+        }
+        else if (value instanceof Expr_1.ArkNewExpr && type instanceof Type_1.AliasType && type.getOriginalType() instanceof Type_1.ClassType) {
+            value.getClassType().setClassSignature(type.getOriginalType().getClassSignature());
+        }
+    }
+    /**
+     * Determine if the given type is an unclear type
+     * @param type The type to check, which can be null or undefined
+     * @returns true if the type is unclear, otherwise false
+     */
+    static isUnclearType(type) {
+        var _a;
+        // 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 ||
+            type instanceof Type_1.GenericType) {
+            return true;
+        }
+        else if (type instanceof Type_1.ClassType &&
+            (type.getClassSignature().getDeclaringFileSignature().getFileName() === Const_1.UNKNOWN_FILE_NAME ||
+                (type.getClassSignature().getClassName() === TSConst_1.PROMISE && !type.getRealGenericTypes()) ||
+                (type.getClassSignature().getDeclaringFileSignature().getFileName() === Builtin_1.Builtin.DUMMY_FILE_NAME &&
+                    ((_a = type.getRealGenericTypes()) === null || _a === void 0 ? void 0 : _a.find(t => t instanceof Type_1.GenericType))))) {
+            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.checkType(t, e => e instanceof Type_1.UnclearReferenceType || e instanceof Type_1.GenericType));
+        }
+        else if (type instanceof Type_1.ArrayType) {
+            const baseType = type.getBaseType();
+            return this.checkType(baseType, t => t instanceof Type_1.UnclearReferenceType || baseType instanceof Type_1.GenericType);
+        }
+        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 temporal function to check Type recursively and can be removed after typeInfer supports multiple candidate types.
+     * @param type The type to check
+     * @param check Condition checking function that takes a type parameter and returns a boolean
+     * @param visited Set of visited types to prevent infinite recursion from circular references, defaults to empty set
+     * @returns true if the type meets the condition, otherwise false
+     */
+    static checkType(type, check, visited = new Set()) {
+        var _a;
+        if (visited.has(type)) {
+            return false;
+        }
+        else {
+            visited.add(type);
+        }
+        if (check(type)) {
+            return true;
+        }
+        else if (type instanceof Type_1.ClassType) {
+            return !!((_a = type.getRealGenericTypes()) === null || _a === void 0 ? void 0 : _a.find(t => this.checkType(t, check, visited)));
+        }
+        else if (type instanceof Type_1.UnionType || type instanceof Type_1.IntersectionType || type instanceof Type_1.TupleType) {
+            return !!type.getTypes().find(t => this.checkType(t, check, visited));
+        }
+        else if (type instanceof Type_1.ArrayType) {
+            return this.checkType(type.getBaseType(), check, visited);
+        }
+        else if (type instanceof Type_1.AliasType) {
+            return this.checkType(type.getOriginalType(), check, visited);
+        }
+        else if (type instanceof TypeExpr_1.KeyofTypeExpr) {
+            return this.checkType(type.getOpType(), check, visited);
+        }
+        else if (type instanceof TypeExpr_1.TypeQueryExpr) {
+            return this.checkType(type.getType(), check, visited);
+        }
+        return false;
+    }
+    /**
+     * Infer simple types in a statement
+     * @param stmt The statement to perform type inference on
+     */
+    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());
+                }
+            }
+        }
+    }
+    /**
+     * Build corresponding Type object based on TypeScript type string
+     * Deal only with simple situations
+     * @param tsTypeStr TypeScript type string used to identify basic types
+     * @param cxxTypeStr Optional C++ type string used for detailed type information of number and string types
+     * @returns Returns the Type instance corresponding to the input string
+     */
+    static buildTypeFromStr(tsTypeStr, cxxTypeStr) {
+        switch (tsTypeStr) {
+            case 'boolean':
+                return Type_1.BooleanType.getInstance();
+            case 'number':
+                return this.buildTypeFromCxxNumberStr(cxxTypeStr);
+            case 'string':
+                return this.buildTypeFromCxxStringStr(cxxTypeStr);
+            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);
+            }
+            case 'type_info':
+                return new Type_2.TypeInfo('type_info', new Type_1.UnclearReferenceType(tsTypeStr));
+            case 'auto':
+                return Type_2.AutoType.getInstance();
+            default:
+                return new Type_1.UnclearReferenceType(tsTypeStr);
+        }
+    }
+    static buildTypeFromCxxNumberStr(cxxTypeStr) {
+        if (!cxxTypeStr) {
+            return Type_1.NumberType.getInstance();
+        }
+        cxxTypeStr = cxxTypeStr.replace(Builtin_2.BuiltinCxx.CXXSTDREF, '');
+        switch (cxxTypeStr) {
+            case 'short':
+                return Type_2.CxxShortType.getInstance(Type_2.CxxTypeSigned.SIGNED, Type_2.CxxTypeBitWidth.SIXTEEN_BITS, Type_2.CxxStdTypeName.SHORT);
+            case 'unsigned short':
+                return Type_2.CxxShortType.getInstance(Type_2.CxxTypeSigned.UNSIGNED, Type_2.CxxTypeBitWidth.SIXTEEN_BITS, Type_2.CxxStdTypeName.UNSIGNED_SHORT);
+            case 'int':
+                return Type_2.CxxIntType.getInstance(Type_2.CxxTypeSigned.SIGNED, Type_2.CxxTypeBitWidth.THIRTY_TWO_BITS, Type_2.CxxStdTypeName.INT);
+            case 'unsigned int':
+                return Type_2.CxxIntType.getInstance(Type_2.CxxTypeSigned.UNSIGNED, Type_2.CxxTypeBitWidth.THIRTY_TWO_BITS, Type_2.CxxStdTypeName.UNSIGNED_INT);
+            case 'int8_t':
+                return Type_2.CxxIntType.getInstance(Type_2.CxxTypeSigned.SIGNED, Type_2.CxxTypeBitWidth.EIGHT_BITS, Type_2.CxxStdTypeName.INT8_T);
+            case 'uint8_t':
+                return Type_2.CxxIntType.getInstance(Type_2.CxxTypeSigned.UNSIGNED, Type_2.CxxTypeBitWidth.EIGHT_BITS, Type_2.CxxStdTypeName.UINT8_T);
+            case 'int16_t':
+                return Type_2.CxxIntType.getInstance(Type_2.CxxTypeSigned.SIGNED, Type_2.CxxTypeBitWidth.SIXTEEN_BITS, Type_2.CxxStdTypeName.INT16_T);
+            case 'uint16_t':
+                return Type_2.CxxIntType.getInstance(Type_2.CxxTypeSigned.UNSIGNED, Type_2.CxxTypeBitWidth.SIXTEEN_BITS, Type_2.CxxStdTypeName.UINT16_T);
+            case 'int32_t':
+                return Type_2.CxxIntType.getInstance(Type_2.CxxTypeSigned.SIGNED, Type_2.CxxTypeBitWidth.THIRTY_TWO_BITS, Type_2.CxxStdTypeName.INT32_T);
+            case 'uint32_t':
+                return Type_2.CxxIntType.getInstance(Type_2.CxxTypeSigned.UNSIGNED, Type_2.CxxTypeBitWidth.THIRTY_TWO_BITS, Type_2.CxxStdTypeName.UINT32_T);
+            case 'int64_t':
+                return Type_2.CxxIntType.getInstance(Type_2.CxxTypeSigned.SIGNED, Type_2.CxxTypeBitWidth.SIXTY_FOUR_BITS, Type_2.CxxStdTypeName.INT64_T);
+            case 'uint64_t':
+                return Type_2.CxxIntType.getInstance(Type_2.CxxTypeSigned.UNSIGNED, Type_2.CxxTypeBitWidth.SIXTY_FOUR_BITS, Type_2.CxxStdTypeName.UINT64_T);
+            case 'intptr_t':
+                return Type_2.CxxIntType.getInstance(Type_2.CxxTypeSigned.SIGNED, Type_2.CxxTypeBitWidth.UNKNOWN, Type_2.CxxStdTypeName.INTPTR_T);
+            case 'uintptr_t':
+                return Type_2.CxxIntType.getInstance(Type_2.CxxTypeSigned.UNSIGNED, Type_2.CxxTypeBitWidth.UNKNOWN, Type_2.CxxStdTypeName.UINTPTR_T);
+            case 'size_t':
+                return Type_2.CxxSizeTType.getInstance(Type_2.CxxTypeSigned.UNSIGNED, Type_2.CxxTypeBitWidth.UNKNOWN, Type_2.CxxStdTypeName.SIZE_T);
+            case 'long':
+                return Type_2.CxxLongType.getInstance(Type_2.CxxTypeSigned.SIGNED, Type_2.CxxTypeBitWidth.THIRTY_TWO_BITS, Type_2.CxxStdTypeName.LONG);
+            case 'unsigned long':
+                return Type_2.CxxLongType.getInstance(Type_2.CxxTypeSigned.UNSIGNED, Type_2.CxxTypeBitWidth.THIRTY_TWO_BITS, Type_2.CxxStdTypeName.UNSIGNED_LONG);
+            case 'long long':
+                return Type_2.CxxLongLongType.getInstance(Type_2.CxxTypeSigned.SIGNED, Type_2.CxxTypeBitWidth.SIXTY_FOUR_BITS, Type_2.CxxStdTypeName.LONG_LONG);
+            case 'unsigned long long':
+                return Type_2.CxxLongLongType.getInstance(Type_2.CxxTypeSigned.UNSIGNED, Type_2.CxxTypeBitWidth.SIXTY_FOUR_BITS, Type_2.CxxStdTypeName.UNSIGNED_LONG_LONG);
+            case 'float':
+                return Type_2.CxxFloatType.getInstance();
+            case 'double':
+                return Type_2.CxxDoubleType.getInstance();
+            case 'long double':
+                return Type_2.CxxLongDoubleType.getInstance();
+            default:
+                return new Type_1.UnclearReferenceType(cxxTypeStr);
+        }
+    }
+    static buildTypeFromCxxStringStr(cxxTypeStr) {
+        if (!cxxTypeStr) {
+            return Type_1.StringType.getInstance();
+        }
+        switch (cxxTypeStr) {
+            case 'string':
+            case 'std::string':
+            case 'std::basic_string<char>':
+                return Type_1.StringType.getInstance();
+            case 'char':
+                return Type_2.CxxCharType.getInstance(Type_2.CxxTypeSigned.UNKNOWN, Type_2.CxxTypeBitWidth.EIGHT_BITS, Type_2.CxxStdTypeName.CHAR);
+            case 'signed char':
+                return Type_2.CxxCharType.getInstance(Type_2.CxxTypeSigned.SIGNED, Type_2.CxxTypeBitWidth.EIGHT_BITS, Type_2.CxxStdTypeName.SIGNED_CHAR);
+            case 'unsigned char':
+                return Type_2.CxxCharType.getInstance(Type_2.CxxTypeSigned.UNSIGNED, Type_2.CxxTypeBitWidth.EIGHT_BITS, Type_2.CxxStdTypeName.UNSIGNED_CHAR);
+            case 'unsignedchar':
+                return Type_2.CxxCharType.getInstance(Type_2.CxxTypeSigned.UNSIGNED, Type_2.CxxTypeBitWidth.EIGHT_BITS, Type_2.CxxStdTypeName.UNSIGNED_CHAR);
+            case 'char16_t':
+                return Type_2.CxxCharType.getInstance(Type_2.CxxTypeSigned.UNSIGNED, Type_2.CxxTypeBitWidth.SIXTEEN_BITS, Type_2.CxxStdTypeName.CHAR16_T);
+            case 'char32_t':
+                return Type_2.CxxCharType.getInstance(Type_2.CxxTypeSigned.UNSIGNED, Type_2.CxxTypeBitWidth.THIRTY_TWO_BITS, Type_2.CxxStdTypeName.CHAR32_T);
+            case 'wchar_t':
+                return Type_2.CxxWcharType.getInstance(Type_2.CxxTypeSigned.UNKNOWN, Type_2.CxxTypeBitWidth.UNKNOWN, Type_2.CxxStdTypeName.WCHAR_T);
+            default:
+                return new Type_1.UnclearReferenceType(cxxTypeStr);
+        }
+    }
+    /**
+     * Infer the type of value
+     * @param value The value whose type needs to be inferred
+     * @param arkMethod The current method context
+     * @returns The inferred type, or null if it cannot be inferred
+     */
+    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);
+            // If the type of value is functionType and the current file is a CXX file,
+            // it should be represented as a CXX function pointer type ==> PointerType(FunctionType, 1).
+            const valueType = value.getType();
+            if (arkMethod.getLanguage() === ArkFile_1.Language.CXX && valueType instanceof Type_1.FunctionType) {
+                if (value instanceof Ref_1.ArkParameterRef || value instanceof Local_1.Local) {
+                    value.setType(new Type_2.PointerType(valueType, 1));
+                }
+            }
+        }
+        return value.getType();
+    }
+    /**
+     * Infer the type of method parameters and update the parameter's type information.
+     *
+     * @param param - The parameter object whose type needs to be inferred
+     * @param arkMethod - The method object that the parameter belongs to
+     */
+    static inferParameterType(param, arkMethod) {
+        let pType = param.getType();
+        const arkClass = arkMethod.getDeclaringArkClass();
+        let type;
+        if (pType instanceof TypeExpr_1.AbstractTypeExpr) {
+            pType.inferType(arkMethod);
+        }
+        else if (param.getName() === 'value' && arkClass.hasComponentDecorator() && arkMethod.getName() === TSConst_1.CONSTRUCTOR_NAME) {
+            type = this.parseArkExport2Type(arkClass);
+        }
+        else {
+            type = TypeInference.inferUnclearedType(pType, arkClass);
+        }
+        if (type) {
+            param.setType(type);
+        }
+    }
+    /**
+     * Infer the return type of method signature and update the return type information in the signature.
+     *
+     * @param oldSignature - The method signature object whose return type needs to be inferred
+     * @param arkMethod - The method object that corresponds to the signature
+     */
+    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();
+        let retTypeWithoutPtrOrRef = currReturnType;
+        // If it is a Cxx pointer or reference type, it is necessary to obtain its baseType and determine whether type inference is required.
+        if (retTypeWithoutPtrOrRef instanceof Type_2.PointerType || retTypeWithoutPtrOrRef instanceof Type_2.ReferenceType) {
+            retTypeWithoutPtrOrRef = retTypeWithoutPtrOrRef.getBaseType();
+        }
+        if (!this.isUnclearType(retTypeWithoutPtrOrRef)) {
+            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;
+        }
+        let newReturnType = this.inferUnclearedType(retTypeWithoutPtrOrRef, arkMethod.getDeclaringArkClass());
+        if (newReturnType && (currReturnType instanceof Type_2.PointerType || currReturnType instanceof Type_2.ReferenceType)) {
+            currReturnType.setBaseType(newReturnType);
+            newReturnType = currReturnType;
+        }
+        if (newReturnType) {
+            oldSignature.getMethodSubSignature().setReturnType(newReturnType);
+        }
+        else if (arkMethod.getBody()) {
+            const returnType = TypeInference.inferReturnType(arkMethod);
+            if (returnType) {
+                oldSignature.getMethodSubSignature().setReturnType(returnType);
+            }
+        }
+    }
+    /**
+     * Infer the return type of method and update the return type information in the method.
+     *
+     * @param arkMethod - The method object whose return type needs to be inferred
+     */
+    static inferReturnType(arkMethod) {
+        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 (type instanceof Type_2.PointerType || type instanceof Type_2.ReferenceType) {
+                if (!TypeInference.isUnclearType(type.getBaseType())) {
+                    typeMap.set(type.toString(), type);
+                }
+            }
+            else if (!TypeInference.isUnclearType(type)) {
+                typeMap.set(type.toString(), type);
+            }
+        }
+        if (typeMap.size > 0) {
+            const types = Array.from(typeMap.values());
+            let returnType = types.length === 1 ? types[0] : new Type_1.UnionType(types);
+            if (arkMethod.containsModifier(ArkBaseModel_1.ModifierType.ASYNC)) {
+                const promise = arkMethod.getDeclaringArkFile().getScene().getSdkGlobal(TSConst_1.PROMISE);
+                if (promise instanceof ArkClass_1.ArkClass) {
+                    returnType = new Type_1.ClassType(promise.getSignature(), [returnType]);
+                }
+            }
+            return returnType;
+        }
+        return null;
+    }
+    /**
+     * Infer the type of generic type and update the generic type information.
+     *
+     * @param types - The generic type array that needs to be inferred
+     * @param arkClass - The class object that the generic type belongs to
+     */
+    static inferGenericType(types, arkClass) {
+        types === null || types === void 0 ? void 0 : types.forEach(type => {
+            const defaultType = type.getDefaultType();
+            if (defaultType && this.isUnclearType(defaultType)) {
+                const newDefaultType = TypeInference.inferUnclearedType(defaultType, arkClass);
+                if (newDefaultType) {
+                    type.setDefaultType(this.replaceTypeWithReal(newDefaultType));
+                }
+            }
+            const constraint = type.getConstraint();
+            if (constraint && this.isUnclearType(constraint)) {
+                const newConstraint = TypeInference.inferUnclearedType(constraint, 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);
+        }
+        const 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 = singleNames.length > 1 ? this.inferBaseType(name, arkClass) : this.inferTypeByName(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.inferUnclearRefName(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;
+    }
+    /**
+     *Inferred field type
+     *@ param baseType Base Type
+     *@ param fieldName
+     *@ param declareClass Declare the class
+     *@ returns a tuple of attributes and types. If the inference fails, null is returned
+     */
+    static inferFieldType(baseType, fieldName, declareClass) {
+        var _a;
+        if (baseType instanceof Type_1.AliasType) {
+            baseType = baseType.getOriginalType();
+        }
+        else if (baseType instanceof Type_1.UnionType && baseType.getCurrType()) {
+            baseType = baseType.getCurrType();
+        }
+        let propertyAndType = null;
+        let typeWithoutPtrOrRef = baseType;
+        // If it is a Cxx pointer or reference type, it is necessary to obtain its baseType and determine whether type inference is required.
+        if (baseType instanceof Type_2.PointerType || baseType instanceof Type_2.ReferenceType) {
+            typeWithoutPtrOrRef = baseType.getBaseType();
+        }
+        if (typeWithoutPtrOrRef instanceof Type_1.ClassType) {
+            if (fieldName === Builtin_1.Builtin.ITERATOR_RESULT_VALUE &&
+                typeWithoutPtrOrRef.getClassSignature().getDeclaringFileSignature().getProjectName() === Builtin_1.Builtin.DUMMY_PROJECT_NAME) {
+                const types = typeWithoutPtrOrRef.getRealGenericTypes();
+                if (types && types.length > 0) {
+                    return [null, types[0]];
+                }
+                return null;
+            }
+            propertyAndType =
+                (_a = this.inferClassFieldType(declareClass, typeWithoutPtrOrRef, fieldName)) !== null && _a !== void 0 ? _a : this.inferNestedClassType(declareClass, typeWithoutPtrOrRef, fieldName);
+        }
+        else if (typeWithoutPtrOrRef instanceof Type_1.ArrayType) {
+            propertyAndType = this.inferArrayFieldType(declareClass, fieldName);
+        }
+        else if (typeWithoutPtrOrRef instanceof Type_1.AnnotationNamespaceType) {
+            const namespace = declareClass.getDeclaringArkFile().getScene().getNamespace(typeWithoutPtrOrRef.getNamespaceSignature());
+            if (namespace) {
+                const property = ModelUtils_2.CxxModelUtils.findPropertyInNamespace(fieldName, namespace);
+                const propertyType = this.parseArkExport2Type(property);
+                if (propertyType) {
+                    propertyAndType = [property, propertyType];
+                }
+            }
+        }
+        else {
+            logger.warn('infer unclear reference type fail: ' + fieldName);
+        }
+        return propertyAndType;
+    }
+    /**
+     *Infer type information of class fields
+     *@ param declareClass Declare the class object
+     *@ param baseType Basic class type
+     *@ param fieldName
+     *@ returns a tuple containing property and type information. If it cannot be inferred, it returns null
+     */
+    static inferClassFieldType(declareClass, baseType, fieldName) {
+        const arkClass = declareClass.getDeclaringArkFile().getScene().getClass(baseType.getClassSignature());
+        if (!arkClass) {
+            return null;
+        }
+        const property = ModelUtils_2.CxxModelUtils.findPropertyInClass(fieldName, arkClass);
+        let propertyType = null;
+        if (property instanceof ArkField_1.ArkField) {
+            if (arkClass.getCategory() === ArkClass_1.ClassCategory.ENUM) {
+                propertyType = this.getEnumValueType(property);
+            }
+            else {
+                propertyType = this.replaceTypeWithReal(property.getType(), baseType.getRealGenericTypes());
+            }
+        }
+        else if (property) {
+            propertyType = this.parseArkExport2Type(property);
+        }
+        if (propertyType) {
+            return [property, propertyType];
+        }
+        else if (arkClass.isAnonymousClass()) {
+            const fieldType = this.inferUnclearRefName(fieldName, arkClass);
+            return fieldType ? [null, fieldType] : null;
+        }
+        return null;
+    }
+    static getEnumValueType(property) {
+        if (property.getCategory() !== ArkField_1.FieldCategory.ENUM_MEMBER) {
+            return null;
+        }
+        const type = property.getType();
+        if (type instanceof Type_1.EnumValueType) {
+            return type;
+        }
+        const initStmts = property.getInitializer();
+        const lastStmt = initStmts[initStmts.length - 1];
+        let constant;
+        if (lastStmt instanceof Stmt_1.ArkAssignStmt) {
+            const rightOp = lastStmt.getRightOp();
+            constant = rightOp instanceof Constant_1.Constant ? rightOp : new Constant_1.Constant('unknown', rightOp.getType());
+        }
+        const enumValueType = new Type_1.EnumValueType(property.getSignature(), constant);
+        property.getSignature().setType(enumValueType);
+        return enumValueType;
+    }
+    static inferArrayFieldType(declareClass, fieldName) {
+        const arrayClass = declareClass.getDeclaringArkFile().getScene().getSdkGlobal(Builtin_1.Builtin.ARRAY);
+        if (arrayClass instanceof ArkClass_1.ArkClass) {
+            const property = ModelUtils_2.CxxModelUtils.findPropertyInClass(fieldName, arrayClass);
+            if (property instanceof ArkField_1.ArkField) {
+                return [property, property.getType()];
+            }
+            return null;
+        }
+        return null;
+    }
+    /**
+     *Infer Base Type
+     *@ param baseName
+     *@ param arkClass Ark class object
+     *@ returns the inferred type. If it cannot be inferred, it returns null
+     */
+    static inferBaseType(baseName, arkClass) {
+        var _a, _b;
+        if (TSConst_1.SUPER_NAME === baseName) {
+            return this.parseArkExport2Type(arkClass.getSuperClass());
+        }
+        else if (TSConst_1.DEFAULT === baseName) {
+            return this.parseArkExport2Type((_a = arkClass.getDeclaringArkFile().getExportInfoBy(TSConst_1.DEFAULT)) === null || _a === void 0 ? void 0 : _a.getArkExport());
+        }
+        let arkExport = (_b = ModelUtils_2.CxxModelUtils.findSymbolInFileWithName(baseName, arkClass)) !== null && _b !== void 0 ? _b : ModelUtils_2.CxxModelUtils.getArkExportInImportInfoWithName(baseName, arkClass.getDeclaringArkFile(), arkClass);
+        if (!arkExport && !arkClass.getDeclaringArkFile().getImportInfoBy(baseName)) {
+            arkExport = arkClass.getDeclaringArkFile().getScene().getSdkGlobal(baseName);
+        }
+        return this.parseArkExport2Type(arkExport);
+    }
+    /**
+     *Infer type information based on type name
+     *@ param typeName - the type name to infer
+     *@ param arkClass - the current Ark class object
+     *@ returns The type object inferred. If it cannot be inferred, null is returned
+     */
+    static inferTypeByName(typeName, arkClass) {
+        var _a, _b;
+        //look up from declared file, if not found then from imports
+        const declaredArkFile = arkClass.getDeclaringArkFile();
+        let arkExport = (_a = ModelUtils_2.CxxModelUtils.findSymbolInFileWithName(typeName, arkClass, true)) !== null && _a !== void 0 ? _a : ModelUtils_2.CxxModelUtils.getArkExportInImportInfoWithName(typeName, declaredArkFile, arkClass);
+        //if not found or local in built-in then look up global in sdks
+        if ((!arkExport || (arkExport instanceof Local_1.Local && declaredArkFile.getProjectName() === SdkUtils_1.SdkUtils.BUILT_IN_NAME)) &&
+            !declaredArkFile.getImportInfoBy(typeName)) {
+            const globalVal = arkClass.getDeclaringArkFile().getScene().getSdkGlobal(typeName);
+            if (globalVal) {
+                arkExport = globalVal;
+            }
+        }
+        const type = this.parseArkExport2Type(arkExport);
+        if (type instanceof Type_1.ClassType || type instanceof Type_1.AliasType) {
+            return type;
+        }
+        return ((_b = arkClass.getGenericsTypes()) === null || _b === void 0 ? void 0 : _b.find(g => g.getName() === typeName)) || null;
+    }
+    /**
+     * Infer real generic types
+     *
+     * This function iterates through the passed type array, infers unclear types,
+     * and replaces the unclear types in the original array with the inferred concrete types.
+     *
+     * @param realTypes - Type array that may contain unclear types, returns directly if undefined
+     * @param arkClass - ArkClass object used for type inference
+     */
+    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;
+                }
+            }
+        }
+    }
+    /**
+     *Infer type information of dynamic import
+     *@ param from - import source path
+     *@ param arkClass - Ark class information
+     *@ returns The type information obtained by parsing. If it cannot be parsed, null is returned
+     */
+    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());
+    }
+    /**
+     *Replace generic parameters in type with actual types
+     *@ param type - the original type to be replaced
+     *@ param realTypes - array of actual types, used to replace generic parameters
+     *@ param visited - the accessed type collection, used to prevent circular references
+     *@ returns The actual type after replacement
+     */
+    static replaceTypeWithReal(type, realTypes, visited = new Set()) {
+        var _a, _b;
+        if (visited.has(type)) {
+            return type;
+        }
+        else {
+            visited.add(type);
+        }
+        if (type instanceof Type_1.GenericType) {
+            const realType = (_b = (_a = realTypes === null || realTypes === void 0 ? void 0 : realTypes[type.getIndex()]) !== null && _a !== void 0 ? _a : type.getDefaultType()) !== null && _b !== void 0 ? _b : type.getConstraint();
+            return realType !== null && realType !== void 0 ? realType : type;
+        }
+        else if (type instanceof Type_1.AnyType) {
+            const realType = realTypes === null || realTypes === void 0 ? void 0 : realTypes[0];
+            return realType !== null && realType !== void 0 ? realType : type;
+        }
+        return this.replaceRecursiveType(type, visited, realTypes);
+    }
+    /**
+     * Recursively replace generic parameters in types with actual types.
+     *
+     * @param type The original type to process
+     * @param visited Set of visited types to prevent infinite recursion
+     * @param realTypes List of actual types used to replace generic parameters
+     * @returns The replaced type
+     */
+    static replaceRecursiveType(type, visited, realTypes) {
+        var _a, _b, _c, _d, _e, _f;
+        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, visited))) !== 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, visited))) !== 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, visited);
+            const replacedTypes = (_f = (_e = type.getRealGenericTypes()) === null || _e === void 0 ? void 0 : _e.map(g => this.replaceTypeWithReal(g, realTypes, visited))) !== 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, visited)));
+            return new Type_1.UnionType(types, this.replaceTypeWithReal(type.getCurrType(), realTypes, visited));
+        }
+        else if (type instanceof Type_1.IntersectionType && realTypes) {
+            const types = [];
+            type.getTypes().forEach(t => types.push(this.replaceTypeWithReal(t, realTypes, visited)));
+            return new Type_1.IntersectionType(types);
+        }
+        else if (type instanceof Type_1.ArrayType && realTypes) {
+            const replacedBaseType = this.replaceTypeWithReal(type.getBaseType(), realTypes, visited);
+            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, visited)));
+            return new Type_1.TupleType(replacedTypes);
+        }
+        return type;
+    }
+    /**
+     * Replace alias types with their original types
+     *
+     * This function recursively resolves alias types by following the chain of type aliases
+     * until it reaches the original underlying type. If the input type is an alias type,
+     * it will trace through to the non-alias type.
+     *
+     * @param type - The type to be replaced, which may be an alias type
+     * @returns Returns the resolved original type; if the input is not an alias type, it returns the original type directly
+     */
+    static replaceAliasType(type) {
+        let aliasType = type;
+        while (aliasType instanceof Type_1.AliasType) {
+            aliasType = aliasType.getOriginalType();
+        }
+        return aliasType;
+    }
+    /**
+     * Infer function type for generic type inference
+     * @param argType Function argument type
+     * @param paramSubSignature Parameter sub-signature
+     * @param realTypes Array of real types
+     */
+    static inferFunctionType(argType, paramSubSignature, realTypes) {
+        const returnType = argType.getMethodSignature().getMethodSubSignature().getReturnType();
+        const declareType = paramSubSignature === null || paramSubSignature === void 0 ? void 0 : paramSubSignature.getReturnType();
+        if (declareType instanceof Type_1.GenericType &&
+            realTypes &&
+            !realTypes[declareType.getIndex()] &&
+            !this.isUnclearType(returnType) &&
+            !(returnType instanceof Type_1.VoidType)) {
+            realTypes[declareType.getIndex()] = returnType;
+        }
+        const params = paramSubSignature === null || paramSubSignature === void 0 ? void 0 : paramSubSignature.getParameters();
+        if (!params) {
+            return;
+        }
+        argType
+            .getMethodSignature()
+            .getMethodSubSignature()
+            .getParameters()
+            .filter(p => !p.getName().startsWith(Const_1.LEXICAL_ENV_NAME_PREFIX))
+            .forEach((p, i) => {
+            var _a;
+            if (this.isUnclearType(p.getType())) {
+                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);
+                }
+            }
+        });
+    }
+    /**
+     * Resolve Ark return statement, perform type inference processing
+     * @param stmt The statement object that needs to be parsed
+     * @param arkMethod The current Ark method
+     */
+    static resolveArkReturnStmt(stmt, arkMethod) {
+        var _a;
+        if (!(stmt instanceof Stmt_1.ArkReturnStmt)) {
+            return;
+        }
+        this.inferValueType(stmt.getOp(), arkMethod);
+        let returnType = arkMethod.getSignature().getType();
+        if (returnType instanceof Type_1.ClassType && returnType.getClassSignature().getClassName() === TSConst_1.PROMISE) {
+            returnType = (_a = returnType.getRealGenericTypes()) === null || _a === void 0 ? void 0 : _a[0];
+        }
+        if (returnType) {
+            IRInference_1.IRInference.inferRightWithSdkType(returnType, stmt.getOp().getType(), arkMethod.getDeclaringArkClass());
+        }
+    }
+    static inferMethodFromImportNamespace(baseType, expr, arkMethod, methodName) {
+        var _a, _b;
+        if (!(baseType instanceof Type_1.AnnotationNamespaceType)) {
+            return null;
+        }
+        const im = arkMethod.getDeclaringArkFile().getImportInfoBy(baseType.getNamespaceSignature().getNamespaceName());
+        if (!im || !(((_a = im.getLazyExportInfo()) === null || _a === void 0 ? void 0 : _a.getArkExport()) instanceof ArkNamespace_1.ArkNamespace)) {
+            return null;
+        }
+        const matchedNamespace = (_b = im.getLazyExportInfo()) === null || _b === void 0 ? void 0 : _b.getArkExport();
+        const foundMethod = ModelUtils_2.CxxModelUtils.findPropertyInNamespace(methodName, matchedNamespace);
+        if (foundMethod instanceof ArkMethod_1.ArkMethod) {
+            let signature = foundMethod.matchMethodSignature(expr.getArgs());
+            TypeInference.inferSignatureReturnType(signature, foundMethod);
+            expr.setMethodSignature(signature);
+            return expr instanceof Expr_1.ArkInstanceInvokeExpr ? new Expr_1.ArkStaticInvokeExpr(signature, expr.getArgs(), expr.getRealGenericTypes()) : expr;
+        }
+        return null;
+    }
+    static inferNestedClassType(declareClass, baseType, fieldName) {
+        var _a;
+        const arkClass = declareClass.getDeclaringArkFile().getScene().getClass(baseType.getClassSignature());
+        if (!arkClass) {
+            return null;
+        }
+        const declScope = (_a = arkClass.getDeclaringArkNamespace()) !== null && _a !== void 0 ? _a : arkClass.getDeclaringArkFile();
+        const nestedClassName = fieldName + Const_1.NAME_DELIMITER + baseType.getClassSignature().getClassName();
+        const nestedClass = declScope.getClassWithName(nestedClassName);
+        if (!nestedClass) {
+            return null;
+        }
+        const type = this.parseArkExport2Type(nestedClass);
+        if (type) {
+            return [nestedClass, type];
+        }
+        return null;
+    }
+}
+exports.TypeInference = TypeInference;