arkanalyzer 1.0.86 → 1.0.87

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

@@ -0,0 +1,2746 @@
+"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.ArkCxxValueTransformer = void 0;
+const Local_1 = require("../../../core/base/Local");
+const Position_1 = require("../../../core/base/Position");
+const Stmt_1 = require("../../../core/base/Stmt");
+const Expr_1 = require("../../../core/base/Expr");
+const Expr_2 = require("../base/Expr");
+const Type_1 = require("../../../core/base/Type");
+const Type_2 = require("../base/Type");
+const ArkSignatureBuilder_1 = require("../../../core/model/builder/ArkSignatureBuilder");
+const ArkSignature_1 = require("../../../core/model/ArkSignature");
+const EtsConst_1 = require("../../../core/common/EtsConst");
+const ValueUtil_1 = require("./ValueUtil");
+const IRUtils_1 = require("./IRUtils");
+const Ref_1 = require("../../../core/base/Ref");
+const Ref_2 = require("../base/Ref");
+const ArkMethod_1 = require("../../../core/model/ArkMethod");
+const ArkMethodBuilder_1 = require("../model/builder/ArkMethodBuilder");
+const Builtin_1 = require("../../../core/common/Builtin");
+const Constant_1 = require("../../../core/base/Constant");
+const ArkIRTransformer_1 = require("./ArkIRTransformer");
+const builderUtils_1 = require("../model/builder/builderUtils");
+const logger_1 = __importStar(require("../../../utils/logger"));
+const ArkValueTransformer_1 = require("../../../core/common/ArkValueTransformer");
+const ModelUtils_1 = require("../../../core/common/ModelUtils");
+const TSConst_1 = require("../../../core/common/TSConst");
+const TypeInference_1 = require("./TypeInference");
+const ModelUtils_2 = require("./ModelUtils");
+const ArkCxxAstNode_1 = require("../ast/ArkCxxAstNode");
+const ArkIRTransformer_2 = require("../../../core/common/ArkIRTransformer");
+const Builtin_2 = require("./Builtin");
+const ArkClass_1 = require("../../../core/model/ArkClass");
+const ValueUtil_2 = require("../../../core/common/ValueUtil");
+const logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'ArkValueTransformer');
+var CompoundBinaryOperator;
+(function (CompoundBinaryOperator) {
+    CompoundBinaryOperator["AdditionEquals"] = "+=";
+    CompoundBinaryOperator["SubtractionEquals"] = "-=";
+    CompoundBinaryOperator["MultiplicationEquals"] = "*=";
+    CompoundBinaryOperator["DivisionEquals"] = "/=";
+    CompoundBinaryOperator["RemainderEquals"] = "%=";
+    CompoundBinaryOperator["LeftShiftEquals"] = "<<=";
+    CompoundBinaryOperator["RightShiftEquals"] = ">>=";
+    CompoundBinaryOperator["BitwiseAndEquals"] = "&=";
+    CompoundBinaryOperator["BitwiseOrEquals"] = "|=";
+    CompoundBinaryOperator["BitwiseXorEquals"] = "^=";
+})(CompoundBinaryOperator || (CompoundBinaryOperator = {}));
+/**
+ * Get the inner node of an AST node
+ *
+ * @param node - C++ AST node object
+ * @returns Returns the processed C++ AST node, or an unsupported type node if unable to process
+ */
+function nodeInnerNode(node) {
+    var _a, _b;
+    if (Array.isArray(node === null || node === void 0 ? void 0 : node.inner) && node.inner.length > 0) {
+        const last = node.inner[node.inner.length - 1];
+        // Return InitListExpr first
+        if ((last === null || last === void 0 ? void 0 : last.kind) === ArkCxxAstNode_1.astKind.InitListExpr) {
+            return last;
+        }
+        // Arrays containing only one TypeRef node do not return
+        if (!(node.inner.length === 1 && ((_a = node.inner[0]) === null || _a === void 0 ? void 0 : _a.kind) === ArkCxxAstNode_1.astKind.TypeRef) && !(0, builderUtils_1.isCxxFunctionPointer)(node.type.qualType)) {
+            return last;
+        }
+    }
+    logger.info(`unsupported node! kind: ${(_b = node === null || node === void 0 ? void 0 : node.kind) !== null && _b !== void 0 ? _b : ''}, node:`, node);
+    return { kind: 'unsupported kind' };
+}
+const COMPOUND_BIN_OPS = new Set(Object.values(CompoundBinaryOperator));
+class ArkCxxValueTransformer extends ArkValueTransformer_1.ArkValueTransformer {
+    constructor(arkIRTransformer, sourceFile, declaringMethod) {
+        super(arkIRTransformer, sourceFile, declaringMethod);
+        // An object that records the corresponding processing functions of CXX ast nodes.
+        this.nodeTransformerFuncMap = {
+            [ArkCxxAstNode_1.astKind.ArraySubscriptExpr]: this.cxxElementAccessExpressionToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.ArrayTypeTraitExpr]: this.arrayTypeTraitExprToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.AtomicCallExpr]: this.cxxCallExpressionToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.BinaryConditionalOperator]: this.cxxConditionalExpressionToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.CXXRewrittenBinaryOperator]: this.cxxBinaryExpressionToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.BinaryOperator]: this.cxxBinaryExpressionToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.BindingDecl]: this.bindingNodeToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.CallExpr]: this.cxxCallExpressionToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.CharacterLiteral]: this.cxxLiteralNodeToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.CompoundAssignOperator]: this.cxxCompoundAssignmentToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.CompoundLiteralExpr]: this.cxxAggregateToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.ConditionalOperator]: this.cxxConditionalExpressionToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.ConstantExpr]: this.processInnerNodeToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.CXXBindTemporaryExpr]: this.processInnerNodeToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.CXXBoolLiteralExpr]: this.cxxLiteralNodeToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.CXXConstCastExpr]: this.castExpressionToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.CXXConstructExpr]: this.cxxConstructExprToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.CXXCtorInitializer]: this.cxxCtorInitializerToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.CXXDeleteExpr]: this.cxxDeleteExpressionToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.CXXDynamicCastExpr]: this.castExpressionToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.CXXFoldExpr]: this.cxxFoldExprToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.CXXFunctionalCastExpr]: this.castExpressionToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.CXXMemberCallExpr]: this.cxxMemberCallExpressionToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.CXXNewExpr]: this.cxxNewExpressionToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.CXXNoexceptExpr]: this.cxxNoexceptExprToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.CXXNullPtrLiteralExpr]: this.cxxLiteralNodeToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.CXXOperatorCallExpr]: this.cxxOperatorExpressionToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.CXXReinterpretCastExpr]: this.castExpressionToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.CXXScalarValueInitExpr]: this.cxxScalarValueInitToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.CXXStdInitializerListExpr]: this.processInnerNodeToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.CXXStaticCastExpr]: this.castExpressionToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.CXXThisExpr]: this.cxxThisExpressionToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.CXXTypeidExpr]: this.cxxTypeidExprToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.CStyleCastExpr]: this.castExpressionToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.CXXTemporaryObjectExpr]: this.cxxTemporaryObjectExprToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.DeclRefExpr]: this.declAndTypeRefToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.DeclStmt]: this.declStmtToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.DecompositionDecl]: this.bindingNodeToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.ExprWithCleanups]: this.processInnerNodeToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.FloatingLiteral]: this.cxxLiteralNodeToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.ImplicitCastExpr]: this.implicitCastExprToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.InitListExpr]: this.initListExprToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.IntegerLiteral]: this.cxxLiteralNodeToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.LambdaExpr]: this.cxxCallableNodeToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.MaterializeTemporaryExpr]: this.materializeTemporaryExprToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.MemberExpr]: this.memberExpressionToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.MemberRef]: this.memberExpressionToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.NamespaceRef]: this.cxxNamespaceRefToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.ParenExpr]: this.processInnerNodeToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.ParenListExpr]: this.processInnerNodeToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.RecoveryExpr]: this.RecoverExpressionToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.StringLiteral]: this.cxxLiteralNodeToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.TypeRef]: this.declAndTypeRefToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.UnaryExprOrTypeTraitExpr]: this.unaryExprToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.UnaryOperator]: this.unaryOperatorToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.UnexposedExpr]: this.processInnerNodeToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.UnresolvedLookupExpr]: this.declAndTypeRefToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.UserDefinedLiteral]: this.userDefinedLiteralToValueAndStmts,
+            [ArkCxxAstNode_1.astKind.VarDecl]: this.cxxVariableDeclarationToValueAndStmts,
+        };
+        this.ArkCxxIRTransformer = arkIRTransformer;
+        this.cxxSourceFile = sourceFile;
+    }
+    /**
+     *Convert C++AST nodes into a combination of values and statements
+     *@ param node - C++AST node to be converted
+     *@ returns Objects containing converted values and related statements
+     */
+    cxxNodeToValueAndStmts(node) {
+        if (node === undefined) {
+            return this.undefinedToValueAndStmts();
+        }
+        const nodeKind = node.kind;
+        if (nodeKind in this.nodeTransformerFuncMap) {
+            const valueAndStmts = this.nodeTransformerFuncMap[nodeKind].bind(this)(node);
+            if (valueAndStmts) {
+                return valueAndStmts;
+            }
+        }
+        return this.unprocessedNodeToValueAndStmts(node);
+    }
+    /**
+     * Convert an unprocessed C++AST node into a combination of values and statements
+     * @param aggregate - C++AST node to be converted
+     * @returns Objects containing converted values and related statements
+     * @throws Error if the node cannot be processed
+     * For example:
+     *     struct Point q = (struct Point){.x = 5, .y = 8, .name = 'c'};
+     *     int* arr = (int[5]){1, 2, 3, 4, 5};
+     *     the right value is {},its kind is CompoundLiteralExpr or InitListExpr
+    */
+    cxxAggregateToValueAndStmts(aggregate) {
+        var _a, _b;
+        const stmts = [];
+        const type = (0, builderUtils_1.cxxNode2Type)(aggregate, this.declaringMethod);
+        const typeName = (_b = (_a = aggregate.type) === null || _a === void 0 ? void 0 : _a.qualType) !== null && _b !== void 0 ? _b : 'unknown';
+        let classSignature;
+        if (!(type instanceof Type_1.ClassType)) {
+            classSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildClassSignatureFromClassName(typeName);
+        }
+        else {
+            classSignature = type.getClassSignature();
+        }
+        const list = aggregate.kind === ArkCxxAstNode_1.astKind.InitListExpr ? aggregate : aggregate.inner[aggregate.inner.length - 1];
+        let elements = [];
+        if (list.kind !== ArkCxxAstNode_1.astKind.InitListExpr) {
+            return this.unprocessedNodeToValueAndStmts(aggregate);
+        }
+        const aggregateExpr = new Expr_2.ArkAggregateExpr(elements, type);
+        const fullPosition = [Position_1.FullPosition.cxxBuildFromNode(aggregate, this.cxxSourceFile)];
+        let { value: temp, valueOriginalPositions: tempPositions, stmts: exprStmts, } = this.ArkCxxIRTransformer.generateAssignStmtForValue(aggregateExpr, fullPosition);
+        for (let i = 0; i < list.inner.length; i++) {
+            if (list.inner[i].kind === ArkCxxAstNode_1.astKind.DesignatedInitExpr) {
+                // Because the syntax tree does not have fields representing field information,
+                // regular matching is used to preserve the information.
+                // If there are any changes to the syntax tree, optimization can be made here
+                const dotIndex = list.inner[i].code.indexOf('.');
+                const equalsIndex = list.inner[i].code.indexOf('=');
+                const field = list.inner[i].code.substring(dotIndex + 1, equalsIndex).trim();
+                const type = (0, builderUtils_1.cxxNode2Type)(list.inner[i].inner[0], this.declaringMethod);
+                const fieldSignature = new ArkSignature_1.FieldSignature(field, classSignature, type, false);
+                const init = new Ref_2.ArkCxxInstanceFieldRef(temp, false, fieldSignature);
+                const valueAndStmts = this.cxxNodeToValueAndStmts(list.inner[i].inner[0]);
+                const designator = valueAndStmts.value;
+                stmts.push(...valueAndStmts.stmts);
+                const designatedInitExpr = new Expr_2.ArkDesignatedInitExpr(init, designator);
+                elements.push(designatedInitExpr);
+            }
+            else {
+                const valueAndStmts = this.cxxNodeToValueAndStmts(list.inner[i]);
+                elements.push(valueAndStmts.value);
+                stmts.push(...valueAndStmts.stmts);
+            }
+        }
+        stmts.push(...exprStmts);
+        if (typeName === 'napi_property_descriptor') {
+            (0, ModelUtils_2.setTs2CxxFuncMapOfClass)(elements, false, this.declaringMethod);
+        }
+        return {
+            value: temp,
+            valueOriginalPositions: tempPositions,
+            stmts: stmts,
+        };
+    }
+    cxxThisExpressionToValueAndStmts(thisExpression) {
+        return {
+            value: this.getThisLocal(),
+            valueOriginalPositions: [Position_1.FullPosition.cxxBuildFromNode(thisExpression, this.cxxSourceFile)],
+            stmts: [],
+        };
+    }
+    // Judge whether the current node is related to the lambda function of CPP
+    isNodeRelatedToCXXLambdaFunc(node) {
+        var _a, _b, _c, _d;
+        return ((_b = (_a = node.type) === null || _a === void 0 ? void 0 : _a.qualType) === null || _b === void 0 ? void 0 : _b.startsWith('(lambda at')) || ((_d = (_c = node.inner) === null || _c === void 0 ? void 0 : _c[0]) === null || _d === void 0 ? void 0 : _d.kind) === ArkCxxAstNode_1.astKind.LambdaExpr;
+    }
+    isNodeRelatedToImplicitNode(node) {
+        var _a, _b;
+        if (node.inner) {
+            return (((_b = (_a = node.inner) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.kind) === ArkCxxAstNode_1.astKind.ImplicitCastExpr && (node.name === '__tree_const_iterator'));
+        }
+        return false;
+    }
+    // Judge whether the child nodes of the current node are materializing temporary variables
+    isNodeRelatedToMaterializeTemporaryExpr(node) {
+        var _a, _b;
+        return ((_b = (_a = node.inner) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.kind) === ArkCxxAstNode_1.astKind.MaterializeTemporaryExpr;
+    }
+    // Check if the child nodes of the current node are member function calls
+    isNodeRelatedToCXXMember(node) {
+        var _a, _b;
+        return ((((_b = (_a = node.inner) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.kind) === ArkCxxAstNode_1.astKind.CXXMemberCallExpr) ||
+            (node.inner[0].kind === ArkCxxAstNode_1.astKind.ImplicitCastExpr && node.inner[0].inner[0] && node.inner[0].inner[0].kind === ArkCxxAstNode_1.astKind.CXXMemberCallExpr));
+    }
+    // Construction of std::pair type
+    isPairConstructExpr(node) {
+        return node.type.qualType.includes('std::pair');
+    }
+    // Multi-layer std::pair construction
+    isNodeRelatedToTemporary(node) {
+        var _a, _b;
+        return ((_b = (_a = node.inner) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.kind) === ArkCxxAstNode_1.astKind.CXXBindTemporaryExpr && node.code === node.inner[0].code;
+    }
+    // Expressions that are not new statements (excluding constructors as parameters)
+    isNotNewExpression(newExpression) {
+        const firstChildKind = newExpression.inner.length > 0 ? newExpression.inner[0].kind : undefined;
+        if (!firstChildKind) {
+            return false;
+        }
+        const targetKinds = [
+            ArkCxxAstNode_1.astKind.IntegerLiteral,
+            ArkCxxAstNode_1.astKind.InitListExpr,
+            ArkCxxAstNode_1.astKind.CompoundLiteralExpr,
+            ArkCxxAstNode_1.astKind.CXXOperatorCallExpr,
+            ArkCxxAstNode_1.astKind.BinaryOperator
+        ];
+        return (targetKinds.includes(firstChildKind) ||
+            (firstChildKind === ArkCxxAstNode_1.astKind.ImplicitCastExpr && !newExpression.inner[0].code.includes('(')));
+    }
+    isNodeRelatedToCXXFuncCast(node) {
+        var _a;
+        return ((_a = node.inner[0]) === null || _a === void 0 ? void 0 : _a.kind) === 'CXXFunctionalCastExpr';
+    }
+    undefinedToValueAndStmts() {
+        var _a, _b;
+        logger.warn('ArkValueTransformer-Cpp NodeToValueAndStmts: node is undefined. Method signature is : ', (_b = (_a = this.declaringMethod) === null || _a === void 0 ? void 0 : _a.getSignature()) === null || _b === void 0 ? void 0 : _b.toString());
+        return {
+            value: new Local_1.Local('undefined'),
+            valueOriginalPositions: [new Position_1.FullPosition(0, 0, 0, 0)],
+            stmts: [],
+        };
+    }
+    unprocessedNodeToValueAndStmts(node) {
+        logger.warn(`ArkValueTransformer-cxxNodeToValueAndStmts: node '${node.kind}' is not specially processed.`);
+        return {
+            value: new Local_1.Local(node.code),
+            valueOriginalPositions: [Position_1.FullPosition.cxxBuildFromNode(node, this.cxxSourceFile)],
+            stmts: [],
+        };
+    }
+    cxxNamespaceRefToValueAndStmts(node) {
+        return {
+            value: new Local_1.Local(node.code),
+            valueOriginalPositions: [Position_1.FullPosition.cxxBuildFromNode(node, this.cxxSourceFile)],
+            stmts: [],
+        };
+    }
+    cxxTemporaryObjectExprToValueAndStmts(node) {
+        var _a, _b;
+        // if case: return Vector(x + other.x, y + other.y); ==> In the C++17 standard, a temporary object is no longer created in the return statement,
+        // instead, the object is directly constructed at the return value location. Therefore, it is processed here as a ConstructExpr.
+        const parentNode = (_a = node.getParent) === null || _a === void 0 ? void 0 : _a.call(node, false);
+        // case: Vector{1,2,3} Implicit call to destructor
+        if (((_b = parentNode === null || parentNode === void 0 ? void 0 : parentNode.dtor) === null || _b === void 0 ? void 0 : _b.kind) === ArkCxxAstNode_1.astKind.CXXDestructorDecl && node.inner.length > 0) {
+            return this.cxxConstructExprToValueAndStmts(node.inner[0]);
+        }
+        if (!parentNode || parentNode.kind !== ArkCxxAstNode_1.astKind.ExprWithCleanups && parentNode.kind !== ArkCxxAstNode_1.astKind.ReturnStmt) {
+            return this.unprocessedNodeToValueAndStmts(node);
+        }
+        return this.cxxConstructExprToValueAndStmts(node);
+    }
+    /**
+     *Convert the C++construction expression node into a combination of values and statements.
+     * The main scenarios are structure and class construction, STL data structure object construction, and thread object construction
+     *@ param node - C++AST node, representing the construction expression
+     *@ returns ValueAndStmts object, including converted values and related statements
+     */
+    cxxConstructExprToValueAndStmts(node) {
+        var _a, _b;
+        if (!this.isPairConstructExpr(node) &&
+            (this.isNodeRelatedToCXXLambdaFunc(node) ||
+                (this.isNodeRelatedToMaterializeTemporaryExpr(node) &&
+                    ((0, builderUtils_1.isCxxBasicString)((_a = node.type.desugaredQualType) !== null && _a !== void 0 ? _a : ''))) ||
+                this.isNodeRelatedToImplicitNode(node)) && ((_b = node.inner) === null || _b === void 0 ? void 0 : _b.length) > 0) {
+            return this.cxxNodeToValueAndStmts(node.inner[0]);
+        }
+        return this.cxxNewExpressionToValueAndStmts(node);
+    }
+    bindingNodeToValueAndStmts(node, yieldValue) {
+        var _a;
+        const length = (_a = node.inner) === null || _a === void 0 ? void 0 : _a.length;
+        if (length <= 0) {
+            return this.unprocessedNodeToValueAndStmts(node);
+        }
+        const stmts = [];
+        let objectValue;
+        let valueOriginalPositions;
+        let innerStmts;
+        if (yieldValue !== undefined) {
+            // If yieldValue exists, use it as the objectValue
+            objectValue = yieldValue;
+            valueOriginalPositions = [Position_1.FullPosition.cxxBuildFromNode(node, this.cxxSourceFile)];
+            innerStmts = [];
+        }
+        else {
+            // If yieldValue does not exist, obtain it by recursively calling cxxNodeToValueAndSTms
+            const result = this.cxxNodeToValueAndStmts(node.inner[0]);
+            valueOriginalPositions = result.valueOriginalPositions;
+            innerStmts = result.stmts;
+            const tempVas = this.ArkCxxIRTransformer.generateAssignStmtForValue(result.value, valueOriginalPositions);
+            innerStmts.push(...tempVas.stmts);
+            objectValue = tempVas.value;
+        }
+        stmts.push(...innerStmts);
+        let index = 0;
+        for (let i = 0; i < length; i++) {
+            if (node.inner[i].kind !== ArkCxxAstNode_1.astKind.BindingDecl) {
+                continue;
+            }
+            const leftValueAndStmts = this.cxxIdentifierToValueAndStmts(node.inner[i]);
+            const indexValue = ValueUtil_1.CxxValueUtil.getOrCreateNumberConst(index++);
+            const arrayRef = new Ref_1.ArkArrayRef(objectValue, indexValue);
+            const assignStmt = new Stmt_1.ArkAssignStmt(leftValueAndStmts.value, arrayRef);
+            stmts.push(assignStmt);
+            valueOriginalPositions = [Position_1.FullPosition.cxxBuildFromNode(node.inner[i], this.cxxSourceFile)];
+        }
+        return {
+            value: objectValue,
+            valueOriginalPositions: valueOriginalPositions,
+            stmts: stmts,
+        };
+    }
+    processInnerNodeToValueAndStmts(node) {
+        var _a, _b;
+        if (((_a = node.inner) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+            // When a node is an implicit node, the actual node is the last internal node
+            return this.cxxNodeToValueAndStmts(node.inner[((_b = node.inner) === null || _b === void 0 ? void 0 : _b.length) - 1]);
+        }
+        return this.unprocessedNodeToValueAndStmts(node);
+    }
+    /**
+     *Converts an implicit conversion expression node to a combination of values and statements
+     *@ param node - C++AST node, representing implicit type conversion expression
+     *@ returns ValueAndStmts object, including converted values and related statements
+     */
+    implicitCastExprToValueAndStmts(node) {
+        var _a;
+        if (((_a = node.inner) === null || _a === void 0 ? void 0 : _a.length) === 1) {
+            return this.cxxNodeToValueAndStmts(node.inner[0]);
+        }
+        node.kind = 'DeclRefExpr';
+        node.name = node.code;
+        return this.cxxNodeToValueAndStmts(node);
+    }
+    /**
+     *Convert declaration and type reference nodes to collections of values and statements
+     *@ param node - C++AST node
+     *@ returns ValueAndStmts object, including converted values and related statements
+     */
+    declAndTypeRefToValueAndStmts(node) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        if (((_a = node.inner) === null || _a === void 0 ? void 0 : _a.length) > 0 && !node.type) {
+            return this.cxxNodeToValueAndStmts(node.inner[0]);
+        }
+        // Handle the scenario: using Color::RED; Color c = RED;
+        if (((_b = node.referencedDecl) === null || _b === void 0 ? void 0 : _b.kind) === ArkCxxAstNode_1.astKind.EnumConstantDecl && node.inner.length === 0) {
+            const typeRefNode = {
+                kind: 'TypeRef',
+                name: node.referencedDecl.name,
+                code: node.referencedDecl.name,
+                inner: [],
+                type: node.referencedDecl.type,
+            };
+            node.inner.push(typeRefNode);
+            return this.staticMemberExprToValueAndStmts(node);
+        }
+        // when node.referencedDecl?.kind === astKind.NonTypeTemplateParmDecl ,this value is a const expr
+        if (((_c = node.referencedDecl) === null || _c === void 0 ? void 0 : _c.kind) === ArkCxxAstNode_1.astKind.NonTypeTemplateParmDecl) {
+            return {
+                value: ValueUtil_1.CxxValueUtil.createCompileConst(node.name, (0, builderUtils_1.cxxNode2Type)(node, this.declaringMethod)),
+                valueOriginalPositions: [],
+                stmts: [],
+            };
+        }
+        // Handle the invocation of static members of a class, such as A::a
+        if (((_d = node.code) === null || _d === void 0 ? void 0 : _d.includes('::')) && node.inner.length > 0 &&
+            (((_e = node.inner[0]) === null || _e === void 0 ? void 0 : _e.kind) === ArkCxxAstNode_1.astKind.TypeRef || ((_f = node.inner[0]) === null || _f === void 0 ? void 0 : _f.kind) === ArkCxxAstNode_1.astKind.NamespaceRef && ((_g = node.inner[0]) === null || _g === void 0 ? void 0 : _g.name) !== Builtin_2.BuiltinCxx.CXXSTD)) {
+            return this.staticMemberExprToValueAndStmts(node);
+        }
+        return this.cxxIdentifierToValueAndStmts(node);
+    }
+    staticMemberExprToValueAndStmts(declRefExpr) {
+        declRefExpr.kind = ArkCxxAstNode_1.astKind.MemberExpr; // Replace the type with "member invocation"
+        return this.memberExpressionToValueAndStmts(declRefExpr);
+    }
+    materializeTemporaryExprToValueAndStmts(node) {
+        if (this.isNotNewExpression(node) ||
+            this.isNodeRelatedToCXXLambdaFunc(node) ||
+            this.isNodeRelatedToCXXMember(node) ||
+            this.isNodeRelatedToTemporary(node) ||
+            this.isNodeRelatedToCXXFuncCast(node)) {
+            return this.cxxNodeToValueAndStmts(node.inner[0]);
+        }
+        return this.cxxNewExpressionToValueAndStmts(node);
+    }
+    /**
+     *Initialize a list expression into a collection of values and statements
+     *@ param node - C++abstract syntax tree node
+     *@ returns ValueAndStmts object, including converted values and related statements
+     */
+    initListExprToValueAndStmts(node) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        if ((((_b = (_a = node.type) === null || _a === void 0 ? void 0 : _a.qualType) === null || _b === void 0 ? void 0 : _b.includes('[')) && node.type.qualType.includes(']')) || node.type.qualType === 'void') {
+            return this.cxxArrayLiteralExpressionToValueAndStmts(node);
+        }
+        let pNode = (_e = ((_c = node.parent) !== null && _c !== void 0 ? _c : (_d = node.getParent) === null || _d === void 0 ? void 0 : _d.call(node, true))) !== null && _e !== void 0 ? _e : null;
+        if (pNode && ((_f = pNode === null || pNode === void 0 ? void 0 : pNode.inner) === null || _f === void 0 ? void 0 : _f.length) > 0 &&
+            (((_g = pNode.inner[0]) === null || _g === void 0 ? void 0 : _g.kind) === ArkCxxAstNode_1.astKind.TypeRef || !node.type.qualType.includes('[') || (0, builderUtils_1.cxxNode2Type)(node, this.declaringMethod) instanceof Type_1.ClassType)) {
+            try {
+                return this.cxxAggregateToValueAndStmts(node);
+            }
+            catch (error) {
+                logger.error(`Error in cxxAggregateToValueAndStmts.`);
+                return this.unprocessedNodeToValueAndStmts(node);
+            }
+        }
+        return this.cxxArrayLiteralExpressionToValueAndStmts(node);
+    }
+    /**
+     *Convert the unary operator node into a combination of values and statements
+     *@ param node - C++AST node, representing unary operator expression
+     *@ returns ValueAndStmts object, including converted values and related statements
+     */
+    unaryOperatorToValueAndStmts(node) {
+        if (node.isPostfix) {
+            return this.cxxPostfixUnaryExpressionToValueAndStmts(node);
+        }
+        else {
+            return this.cxxPrefixUnaryExpressionToValueAndStmts(node);
+        }
+    }
+    // expression with either a type or (unevaluated) expression operand.
+    // Used for sizeof/alignof (C99 6.5.3.4) and vec_step (OpenCL 1.1 6.11.12).
+    unaryExprToValueAndStmts(unaryExprNode) {
+        var _a;
+        const stmts = [];
+        let unaryValue;
+        const operatorString = (_a = unaryExprNode.name) !== null && _a !== void 0 ? _a : '';
+        let operator;
+        switch (operatorString) {
+            case Expr_2.Operator.sizeof:
+                operator = Expr_2.Operator.sizeof;
+                break;
+            case Expr_2.Operator.alignof:
+                operator = Expr_2.Operator.alignof;
+                break;
+            default:
+                operator = Expr_2.Operator.Unknown;
+                logger.warn(`Unsupported unary operator: ${operatorString}`);
+        }
+        let operpositions = [Position_1.FullPosition.cxxBuildFromNode(unaryExprNode, this.cxxSourceFile)];
+        if (unaryExprNode.inner.length > 0) {
+            let { value: innerValue, valueOriginalPositions: innerPositions, stmts: innerStmts } = this.cxxNodeToValueAndStmts(unaryExprNode.inner[0]);
+            unaryValue = innerValue;
+            stmts.push(...innerStmts);
+            operpositions.push(...innerPositions);
+        }
+        else {
+            const typeNameMatch = unaryExprNode.code.match(/\(([^)]*)\)/);
+            const typeName = typeNameMatch ? typeNameMatch[1] : '';
+            unaryValue = (0, builderUtils_1.buildTypeFromPreStr)(typeName, unaryExprNode, this.declaringMethod);
+        }
+        const unaryExpr = new Expr_2.ArkCxxUnaryExpr(operator, unaryValue);
+        return {
+            value: unaryExpr,
+            valueOriginalPositions: operpositions,
+            stmts: stmts,
+        };
+    }
+    /**
+     *Convert user-defined literals into sets of values and statements
+     *The syntax format of user-defined literals is: original value+suffix (for example: 123_km, "hello" _s, 'a' _s)
+     *
+     *@ param userDefinedLiteral - AST node of user-defined literal
+     *@ returns The ValueAndStmts object containing the converted value and related statements
+     */
+    userDefinedLiteralToValueAndStmts(userDefinedLiteral) {
+        var _a;
+        // The syntax for user-defined literals is: raw value + suffix (e.g., 123_km, "hello"_s, 'a'_s)
+        if (((_a = userDefinedLiteral.inner) === null || _a === void 0 ? void 0 : _a.length) < 2) {
+            return this.unprocessedNodeToValueAndStmts(userDefinedLiteral);
+        }
+        const stmts = [];
+        const literalStr = this.getOverloadOpName(userDefinedLiteral).replace('operator""', '');
+        const argNode = userDefinedLiteral.inner[1];
+        argNode.code = argNode.code.replace(literalStr, ''); // Get the primitive value (e.g., 123, 'a')
+        return this.buildValueAndStmtsForMemberCall(stmts, userDefinedLiteral.inner[0], [argNode], userDefinedLiteral, undefined);
+    }
+    /**
+     *Convert the C++constructor initialization list node to a collection of values and statements
+     *  1. C++uses the initialization list to initialize class member variables: Base (char pname): name (pname) {...}.
+     *         The final effect is similar to this ->name=pname, which is also processed as an assignment here
+     *  2. using parent::parent， The constructor of the subclass calls the constructor inherited from the parent class
+     *@ param cxxCtorInitializer C++constructor initializes list nodes
+     *@ returns An object containing a collection of values and statements
+     */
+    cxxCtorInitializerToValueAndStmts(cxxCtorInitializer) {
+        var _a, _b, _c, _d;
+        if (!cxxCtorInitializer.inner || cxxCtorInitializer.inner.length === 0) {
+            return this.unprocessedNodeToValueAndStmts(cxxCtorInitializer);
+        }
+        const firstInnerNode = cxxCtorInitializer.inner[0];
+        if (firstInnerNode.kind === ArkCxxAstNode_1.astKind.CXXInheritedCtorInitExpr) {
+            // Processing of using parent:: parent
+            return this.cxxInheritedCtorInitExprToValueAndStmts(firstInnerNode);
+        }
+        else if (firstInnerNode.kind === ArkCxxAstNode_1.astKind.CXXConstructExpr && cxxCtorInitializer.baseInit) {
+            // Processing of case: Left(const char& name) : Base(name) // call base class constructor
+            return this.cxxSuperExpressionToValueAndStmts(firstInnerNode);
+        }
+        // If the kind of firstNode is CXXConstructExpr and firstNode does not correspond to a parent class initialization call,
+        // it is equivalent to directly assigning a value to the class member.
+        // For example, the constructor of class Circle in file 'tests/cppResources/exports/crossFileCase/include/myHeader.h'.
+        const assignRight = (firstInnerNode.kind === ArkCxxAstNode_1.astKind.CXXConstructExpr && firstInnerNode.inner.length > 0) ? firstInnerNode.inner[0] : firstInnerNode;
+        const CtorInit2ThisMemberExpr = {
+            kind: 'MemberExpr',
+            name: (_b = (_a = cxxCtorInitializer.anyInit) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : '',
+            inner: [
+                {
+                    kind: 'CXXThisExpr',
+                },
+            ],
+            type: (_d = (_c = cxxCtorInitializer.anyInit) === null || _c === void 0 ? void 0 : _c.type) !== null && _d !== void 0 ? _d : '',
+        };
+        const initType = (0, builderUtils_1.cxxNode2Type)(CtorInit2ThisMemberExpr, undefined);
+        return this.cxxAssignmentToValueAndStmts(CtorInit2ThisMemberExpr, assignRight, false, false, initType, true);
+    }
+    /**
+     *Convert the C++inheritance constructor initialization expression to a collection of values and statements
+     * Using parent:: parent==>The constructor of the sub——class calls the constructor inherited from the parent
+     * class==>The same as calling the constructor of the parent class directly
+     *@ param cxxInheritedCtorInitExpr - C++inheritance constructor initialization expression node
+     *@ returns The object containing the converted value and statement array
+     */
+    cxxInheritedCtorInitExprToValueAndStmts(cxxInheritedCtorInitExpr) {
+        var _a;
+        cxxInheritedCtorInitExpr.code = `using ${cxxInheritedCtorInitExpr.code}::${cxxInheritedCtorInitExpr.code}`;
+        const cls = this.declaringMethod.getDeclaringArkClass();
+        const clsInitMtd = cls.getInstanceInitMethod();
+        if (!clsInitMtd) {
+            return this.unprocessedNodeToValueAndStmts(cxxInheritedCtorInitExpr);
+        }
+        const superClass = cls.getHeritageClass(cxxInheritedCtorInitExpr.type.qualType);
+        if (!superClass) {
+            return this.unprocessedNodeToValueAndStmts(cxxInheritedCtorInitExpr);
+        }
+        (0, ArkMethodBuilder_1.buildDefaultConstructor)(superClass);
+        const superConstructor = superClass.getMethodWithName(TSConst_1.CONSTRUCTOR_NAME);
+        if (!superConstructor) {
+            return this.unprocessedNodeToValueAndStmts(cxxInheritedCtorInitExpr);
+        }
+        let base = (_a = clsInitMtd.getBody()) === null || _a === void 0 ? void 0 : _a.getLocals().get(TSConst_1.THIS_NAME);
+        if (base === undefined) {
+            return this.unprocessedNodeToValueAndStmts(cxxInheritedCtorInitExpr);
+        }
+        const params = this.declaringMethod.getParameters();
+        const argValues = [];
+        params.forEach(param => {
+            argValues.push(this.getOrCreateLocal(param.getName()));
+        });
+        const newSuperInvokeExpr = new Expr_1.ArkInstanceInvokeExpr(base, superConstructor.getSignature(), argValues);
+        return {
+            value: newSuperInvokeExpr,
+            valueOriginalPositions: [Position_1.FullPosition.cxxBuildFromNode(cxxInheritedCtorInitExpr, this.cxxSourceFile)],
+            stmts: [],
+        };
+    }
+    /**
+     *Convert super expression in C++to IR
+     * C++subclasses call the parent class constructor for initialization,
+     * similar to ts super (xx). For example, Left (const char&name, int power): Base (name) {...}
+     *@ param cxxConstructExpr C++construction expression node
+     *@ returns The ValueAndStmts object containing the converted value and related statements
+     */
+    cxxSuperExpressionToValueAndStmts(cxxConstructExpr) {
+        var _a, _b;
+        const cls = this.declaringMethod.getDeclaringArkClass();
+        if (!cls) {
+            return this.cxxNewExpressionToValueAndStmts(cxxConstructExpr);
+        }
+        const clsInitMtd = cls.getInstanceInitMethod();
+        if (!clsInitMtd) {
+            return this.cxxNewExpressionToValueAndStmts(cxxConstructExpr);
+        }
+        const stmts = [];
+        const { args: argValues } = this.cxxParseArguments(stmts, cxxConstructExpr.inner);
+        const superClass = cls.getHeritageClass((_a = cxxConstructExpr.type.qualType) !== null && _a !== void 0 ? _a : '');
+        if (!superClass) {
+            return this.cxxNewExpressionToValueAndStmts(cxxConstructExpr);
+        }
+        (0, ArkMethodBuilder_1.buildDefaultConstructor)(superClass);
+        const superConstructor = superClass.getMethodWithName(TSConst_1.CONSTRUCTOR_NAME);
+        if (superConstructor !== null) {
+            let base = (_b = clsInitMtd.getBody()) === null || _b === void 0 ? void 0 : _b.getLocals().get(TSConst_1.THIS_NAME);
+            if (base === undefined) {
+                return this.cxxNewExpressionToValueAndStmts(cxxConstructExpr);
+            }
+            const newSuperInvokeExpr = new Expr_1.ArkInstanceInvokeExpr(base, superConstructor.getSignature(), argValues);
+            return {
+                value: newSuperInvokeExpr,
+                valueOriginalPositions: [Position_1.FullPosition.cxxBuildFromNode(cxxConstructExpr, this.cxxSourceFile)],
+                stmts: [],
+            };
+        }
+        return this.cxxNewExpressionToValueAndStmts(cxxConstructExpr);
+    }
+    /**
+     *Convert array type characteristic expression to IR
+     * ArrayTypeTraitExpr is processed by function call
+     *@ param ArrayTypeTraitExpr - C++AST node, representing array type characteristic expression
+     *@ returns ValueAndStmts object, including converted values and related statements
+     */
+    arrayTypeTraitExprToValueAndStmts(ArrayTypeTraitExpr) {
+        const stmts = [];
+        let dimensionSizes = [];
+        let op = null;
+        for (let i = 0; i < ArrayTypeTraitExpr.inner.length; i++) {
+            if (ArrayTypeTraitExpr.inner[i].kind === ArkCxxAstNode_1.astKind.IntegerLiteral) {
+                dimensionSizes.push(Number(ArrayTypeTraitExpr.inner[i].value));
+            }
+            else if (ArrayTypeTraitExpr.inner[i].kind === ArkCxxAstNode_1.astKind.DeclRefExpr) {
+                const innerValueAndStmts = this.cxxNodeToValueAndStmts(ArrayTypeTraitExpr.inner[i]);
+                op = innerValueAndStmts.value;
+                stmts.push(...innerValueAndStmts.stmts);
+            }
+        }
+        const arrayRankExpr = new Expr_2.ArkArrayTypeTraitExpr(dimensionSizes, op);
+        return {
+            value: arrayRankExpr,
+            valueOriginalPositions: [Position_1.FullPosition.cxxBuildFromNode(ArrayTypeTraitExpr, this.cxxSourceFile)],
+            stmts: stmts,
+        };
+    }
+    /**
+     * Convert C++typeid expression to IR, And CXXTypeidExpr is processed by function call.
+     *@ param CXXTypeidExpr - typeid expression node in C++AST
+     *@ returns Objects containing converted values and related statements
+     */
+    cxxTypeidExprToValueAndStmts(CXXTypeidExpr) {
+        const stmts = [];
+        let typeValue;
+        // [1.typeid's inner.length is 0 or 2, then the type name is passed in; 2. std:: Type refers to the type in the namespace]==>
+        // Parameter function call to construct the string corresponding to the type into the parameter
+        if (CXXTypeidExpr.inner.length === 0) {
+            const innerType = (0, builderUtils_1.cxxNode2Type)(CXXTypeidExpr, undefined, undefined);
+            typeValue = new Local_1.Local(innerType.toString(), innerType);
+        }
+        else {
+            let innerValueAndStmts = this.cxxNodeToValueAndStmts(CXXTypeidExpr.inner[0]);
+            stmts.push(...innerValueAndStmts.stmts);
+            typeValue = innerValueAndStmts.value;
+        }
+        const typeIdExpr = new Expr_2.ArkTypeIdExpr(typeValue);
+        return {
+            value: typeIdExpr,
+            valueOriginalPositions: [Position_1.FullPosition.cxxBuildFromNode(CXXTypeidExpr, this.cxxSourceFile)],
+            stmts: stmts,
+        };
+    }
+    /**
+     *Convert the noexcept expression of C++syntax tree to IR
+     *@ param CXXNoexceptExpr - AST node representing C++noexcept expression
+     *@ returns Objects containing converted values and related statements
+     */
+    cxxNoexceptExprToValueAndStmts(CXXNoexceptExpr) {
+        const stmts = [];
+        let innerValueAndStmts = this.cxxNodeToValueAndStmts(CXXNoexceptExpr.inner[0]);
+        stmts.push(...innerValueAndStmts.stmts);
+        const noExpectExpr = new Expr_2.ArkNoExpectExpr(innerValueAndStmts.value);
+        return {
+            value: noExpectExpr,
+            valueOriginalPositions: [Position_1.FullPosition.cxxBuildFromNode(CXXNoexceptExpr, this.cxxSourceFile)],
+            stmts: stmts,
+        };
+    }
+    /**
+     *Process the C++scalar value initialization expression and convert it to IR
+     *@ param CXXScalarValueInitExpr - C++abstract syntax tree node, representing scalar value initialization expression
+     *@ returns an object containing initialization values and related statements. If it cannot be processed, it returns null
+     */
+    cxxScalarValueInitToValueAndStmts(CXXScalarValueInitExpr) {
+        const initType = CXXScalarValueInitExpr.type.qualType;
+        let constant = null;
+        switch (initType) {
+            case 'int':
+                constant = ValueUtil_1.CxxValueUtil.getOrCreateNumberConst(parseFloat('0'));
+                break;
+            case 'float':
+            case 'double':
+                constant = ValueUtil_1.CxxValueUtil.getOrCreateNumberConst(parseFloat('0.0'));
+                break;
+            case 'char':
+                constant = ValueUtil_1.CxxValueUtil.createStringConst('');
+                break;
+            default:
+                logger.warn(`The initType of ast node "CXXScalarValueInitExpr" is ${initType}, maybe it is not literalNode or is not processed`);
+        }
+        if (constant === null) {
+            return null;
+        }
+        return {
+            value: constant,
+            valueOriginalPositions: [Position_1.FullPosition.cxxBuildFromNode(CXXScalarValueInitExpr, this.cxxSourceFile)],
+            stmts: [],
+        };
+    }
+    /**
+     *Convert C++delete expression to IR
+     *@ param deleteExpression - C++AST node, representing delete expression
+     *@ returns The object containing the converted value and statement array
+     */
+    cxxDeleteExpressionToValueAndStmts(deleteExpression) {
+        const { value: exprValue, valueOriginalPositions: exprPositions, stmts: stmts, } = this.cxxNodeToValueAndStmts(deleteExpression.inner[0]);
+        const isArray = deleteExpression.isArray;
+        const deleteExpr = isArray ? new Expr_2.ArkCxxDeleteArrayExpr(exprValue) : new Expr_1.ArkDeleteExpr(exprValue);
+        const deleteExprPosition = [Position_1.FullPosition.cxxBuildFromNode(deleteExpression, this.cxxSourceFile), ...exprPositions];
+        return { value: deleteExpr, valueOriginalPositions: deleteExprPosition, stmts: stmts };
+    }
+    /**
+     *Convert C++type conversion expression to IR
+     *@ param castExpression C++AST node, representing type conversion expression
+     *@ returns ValueAndStmts object, including converted values, original location information and related statements
+     */
+    castExpressionToValueAndStmts(castExpression) {
+        const stmts = [];
+        let { value: exprValue, valueOriginalPositions: exprPositions, stmts: exprStmts, } = this.cxxNodeToValueAndStmts(castExpression.inner[castExpression.inner.length - 1]);
+        stmts.push(...exprStmts);
+        if (IRUtils_1.IRUtils.moreThanOneAddress(exprValue)) {
+            ({
+                value: exprValue,
+                valueOriginalPositions: exprPositions,
+                stmts: exprStmts,
+            } = this.ArkCxxIRTransformer.generateAssignStmtForValue(exprValue, exprPositions));
+            stmts.push(...exprStmts);
+        }
+        const castType = castExpression.kind;
+        const castExpr = new Expr_2.ArkCxxCastExpr(exprValue, (0, builderUtils_1.cxxNode2Type)(castExpression, this.declaringMethod), castType);
+        const castExprPosition = [Position_1.FullPosition.cxxBuildFromNode(castExpression, this.cxxSourceFile), ...exprPositions];
+        return { value: castExpr, valueOriginalPositions: castExprPosition, stmts: stmts };
+    }
+    cxxFoldExprToValueAndStmts(CXXFoldExpr) {
+        var _a;
+        const stmts = [];
+        let { value: exprValue, valueOriginalPositions: exprPositions, stmts: exprStmts, } = this.cxxNodeToValueAndStmts(CXXFoldExpr.inner[CXXFoldExpr.inner.length - 1]);
+        stmts.push(...exprStmts);
+        if (IRUtils_1.IRUtils.moreThanOneAddress(exprValue)) {
+            ({
+                value: exprValue,
+                valueOriginalPositions: exprPositions,
+                stmts: exprStmts,
+            } = this.ArkCxxIRTransformer.generateAssignStmtForValue(exprValue, exprPositions));
+            stmts.push(...exprStmts);
+        }
+        const foldOp = (_a = CXXFoldExpr.op) !== null && _a !== void 0 ? _a : ' ';
+        const folderExpr = new Expr_2.ArkCxxFolderExpr(exprValue, foldOp);
+        const folderExprPosition = [Position_1.FullPosition.cxxBuildFromNode(CXXFoldExpr, this.cxxSourceFile), ...exprPositions];
+        return { value: folderExpr, valueOriginalPositions: folderExprPosition, stmts: stmts };
+    }
+    /**
+     *Convert C++conditional expression to IR
+     *@ param conditionalExpression - C++AST node, representing conditional expression
+     *@ returns ValueAndStmts object, including converted values, original location information and related statements
+     */
+    cxxConditionalExpressionToValueAndStmts(conditionalExpression) {
+        // Starting from 0 to access internal nodes
+        let InnerIdx = 0;
+        const stmts = [];
+        const currConditionalOperatorIndex = this.conditionalOperatorNo++;
+        // Peel off 'ImplicitCastExpr'
+        const conditionNode = conditionalExpression.inner[InnerIdx].kind === ArkCxxAstNode_1.astKind.ImplicitCastExpr ?
+            conditionalExpression.inner[InnerIdx].inner[0] : conditionalExpression.inner[InnerIdx];
+        let conditionExpr;
+        const context = { conditionExpr: conditionExpr };
+        const ifStmts = this.ArkCxxIRTransformer.cxxIfStatementToStmts(conditionNode, 0, context);
+        stmts.push(...ifStmts);
+        let isBooleanExpr = conditionNode.type.qualType === 'bool';
+        stmts.push(new ArkIRTransformer_2.DummyStmt(ArkIRTransformer_1.ArkCxxIRTransformer.DUMMY_CONDITIONAL_OPERATOR_IF_TRUE_STMT + currConditionalOperatorIndex));
+        // inner[1] is a value whose expression is true
+        InnerIdx++;
+        let whenTrueValueAndStmts;
+        if (conditionalExpression.kind === ArkCxxAstNode_1.astKind.ConditionalOperator) {
+            whenTrueValueAndStmts = this.cxxNodeToValueAndStmts(conditionalExpression.inner[InnerIdx]);
+            // else kind is BinaryConditionalOperator,No need to parse the node again, the result of the judgment is its value
+        }
+        else {
+            whenTrueValueAndStmts = {
+                value: isBooleanExpr ? ValueUtil_1.CxxValueUtil.getOrCreateNumberConst(1) : context.conditionExpr.getOp1(),
+                stmts: [],
+                valueOriginalPositions: [],
+            };
+        }
+        stmts.push(...whenTrueValueAndStmts.stmts);
+        const resultLocal = this.generateTempLocal();
+        const assignStmtWhenTrue = new Stmt_1.ArkAssignStmt(resultLocal, whenTrueValueAndStmts.value);
+        const resultLocalPosition = [whenTrueValueAndStmts.valueOriginalPositions[0]];
+        assignStmtWhenTrue.setOperandOriginalPositions([...resultLocalPosition, ...whenTrueValueAndStmts.valueOriginalPositions]);
+        stmts.push(assignStmtWhenTrue);
+        stmts.push(new ArkIRTransformer_2.DummyStmt(ArkIRTransformer_1.ArkCxxIRTransformer.DUMMY_CONDITIONAL_OPERATOR_IF_FALSE_STMT + currConditionalOperatorIndex));
+        // The last internal node is the value when the expression is false
+        InnerIdx = conditionalExpression.inner.length - 1;
+        const { value: whenFalseValue, valueOriginalPositions: whenFalsePositions, stmts: whenFalseStmts } = this.cxxNodeToValueAndStmts(conditionalExpression.inner[InnerIdx]);
+        stmts.push(...whenFalseStmts);
+        const assignStmt = new Stmt_1.ArkAssignStmt(resultLocal, whenFalseValue);
+        assignStmt.setOperandOriginalPositions([...resultLocalPosition, ...whenFalsePositions]);
+        stmts.push(assignStmt);
+        stmts.push(new ArkIRTransformer_2.DummyStmt(ArkIRTransformer_1.ArkCxxIRTransformer.DUMMY_CONDITIONAL_OPERATOR_END_STMT + currConditionalOperatorIndex));
+        return {
+            value: resultLocal,
+            valueOriginalPositions: resultLocalPosition,
+            stmts: stmts,
+        };
+    }
+    /**
+     *Extract the calling node and parameter node from the internal AST node array for overwriting
+     *@ param innerAsNodes An AST node array containing call information and parameters. The first element is the call node, and the rest are parameter nodes
+     *@ returns an array containing two elements: the first element is the call node, and the second element is the parameter node array
+     */
+    getArgumentNodeForRecover(innerAsNodes) {
+        const [callNode, ...argumentNodes] = innerAsNodes;
+        return [callNode, argumentNodes];
+    }
+    getArgumentNode(innerAstNodes) {
+        var _a, _b, _c;
+        // At this time, innerAstNode is a separate point
+        if (!Array.isArray(innerAstNodes)) {
+            const firstInner = (_a = innerAstNodes.inner) === null || _a === void 0 ? void 0 : _a[0];
+            if (!firstInner) {
+                return [undefined, []];
+            }
+            const call = this.getDeclRef(firstInner);
+            const args = ((_c = (_b = innerAstNodes.inner) === null || _b === void 0 ? void 0 : _b.slice(1)) !== null && _c !== void 0 ? _c : [])
+                .map(n => this.getDeclRef(n));
+            return [call, args];
+        }
+        // Several callable kinds
+        const CALLABLE_KINDS = new Set([
+            ArkCxxAstNode_1.astKind.DeclRefExpr,
+            ArkCxxAstNode_1.astKind.MemberExpr,
+            ArkCxxAstNode_1.astKind.OverloadedDeclRef,
+            ArkCxxAstNode_1.astKind.ArraySubscriptExpr,
+            ArkCxxAstNode_1.astKind.CXXOperatorCallExpr,
+            ArkCxxAstNode_1.astKind.UnresolvedLookupExpr,
+        ]);
+        function unwrapImplicit(n) {
+            var _a;
+            while (n && n.kind === ArkCxxAstNode_1.astKind.ImplicitCastExpr) {
+                n = (_a = n.inner) === null || _a === void 0 ? void 0 : _a[0];
+            }
+            return n;
+        }
+        let callNode;
+        const argumentNodes = [];
+        for (let i = 0; i < innerAstNodes.length; i++) {
+            const node = innerAstNodes[i];
+            if (i === 0) {
+                const first = unwrapImplicit(node);
+                if (!first) {
+                    continue;
+                }
+                if (CALLABLE_KINDS.has(first.kind)) {
+                    callNode = first;
+                }
+                else {
+                    argumentNodes.push(first);
+                }
+                continue;
+            }
+            argumentNodes.push(node);
+        }
+        return [callNode, argumentNodes];
+    }
+    getDeclRef(astNode) {
+        let n = astNode;
+        while (n) {
+            if (n.kind === ArkCxxAstNode_1.astKind.DeclRefExpr) {
+                return n;
+            }
+            // No child node or empty child node, end
+            if (!n.inner || n.inner.length === 0) {
+                break;
+            }
+            // Go down the first child node
+            n = n.inner[0];
+        }
+        return undefined;
+    }
+    cxxGenerateSystemComponentStmt(componentName, args, argPositionsAllFlat, componentExpression, currStmts) {
+        const stmts = [...currStmts];
+        const componentExpressionPosition = Position_1.FullPosition.cxxBuildFromNode(componentExpression, this.cxxSourceFile);
+        const { value: componentValue, valueOriginalPositions: componentPositions, stmts: componentStmts, } = this.cxxGenerateComponentCreationStmts(componentName, args, componentExpressionPosition, argPositionsAllFlat);
+        stmts.push(...componentStmts);
+        stmts.push(this.generateComponentPopStmts(componentName, componentExpressionPosition));
+        return {
+            value: componentValue,
+            valueOriginalPositions: componentPositions,
+            stmts: stmts,
+        };
+    }
+    cxxGenerateCustomViewStmt(componentName, args, argPositionsAllFlat, componentExpression, currStmts) {
+        const stmts = [...currStmts];
+        const componentExpressionPosition = Position_1.FullPosition.cxxBuildFromNode(componentExpression, this.cxxSourceFile);
+        const classSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildClassSignatureFromClassName(componentName);
+        const classType = new Type_1.ClassType(classSignature);
+        const newExpr = new Expr_1.ArkNewExpr(classType);
+        const { value: newExprLocal, valueOriginalPositions: newExprPositions, stmts: newExprStmts, } = this.ArkCxxIRTransformer.generateAssignStmtForValue(newExpr, [componentExpressionPosition]);
+        stmts.push(...newExprStmts);
+        const constructorMethodSubSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSubSignatureFromMethodName(TSConst_1.CONSTRUCTOR_NAME);
+        const constructorMethodSignature = new ArkSignature_1.MethodSignature(classSignature, constructorMethodSubSignature);
+        const instanceInvokeExpr = new Expr_1.ArkInstanceInvokeExpr(newExprLocal, constructorMethodSignature, args);
+        const instanceInvokeExprPositions = [componentExpressionPosition, ...newExprPositions, ...argPositionsAllFlat];
+        const instanceInvokeStmt = new Stmt_1.ArkInvokeStmt(instanceInvokeExpr);
+        instanceInvokeStmt.setOperandOriginalPositions(instanceInvokeExprPositions);
+        stmts.push(instanceInvokeStmt);
+        const createViewArgs = [newExprLocal];
+        const createViewArgPositionsAll = [newExprPositions];
+        const { value: componentValue, valueOriginalPositions: componentPositions, stmts: componentStmts, } = this.cxxGenerateComponentCreationStmts(EtsConst_1.COMPONENT_CUSTOMVIEW, createViewArgs, componentExpressionPosition, createViewArgPositionsAll.flat());
+        stmts.push(...componentStmts);
+        stmts.push(this.generateComponentPopStmts(EtsConst_1.COMPONENT_CUSTOMVIEW, componentExpressionPosition));
+        return {
+            value: componentValue,
+            valueOriginalPositions: componentPositions,
+            stmts: stmts,
+        };
+    }
+    cxxGenerateComponentCreationStmts(componentName, createArgs, componentExpressionPosition, createArgsPositionsAllFlat) {
+        const createMethodSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSignatureFromClassNameAndMethodName(componentName, EtsConst_1.COMPONENT_CREATE_FUNCTION);
+        const createInvokeExpr = new Expr_1.ArkStaticInvokeExpr(createMethodSignature, createArgs);
+        const createInvokeExprPositions = [componentExpressionPosition, ...createArgsPositionsAllFlat];
+        const { value: componentValue, valueOriginalPositions: componentPositions, stmts: componentStmts, } = this.ArkCxxIRTransformer.generateAssignStmtForValue(createInvokeExpr, createInvokeExprPositions);
+        return {
+            value: componentValue,
+            valueOriginalPositions: componentPositions,
+            stmts: componentStmts,
+        };
+    }
+    /**
+     *Convert C++identifiers to collections of values and statements
+     *@ param identifier C++AST node identifier
+     *@ param variableDefFlag Optional variable definition flag, used to distinguish variable declaration from variable use
+     *@ returns Objects containing values, location information and statement arrays
+     */
+    cxxIdentifierToValueAndStmts(identifier, variableDefFlag) {
+        var _a;
+        let identifierValue;
+        let identifierPositions = [Position_1.FullPosition.cxxBuildFromNode(identifier, this.cxxSourceFile)];
+        let varNode;
+        if (identifier.referencedDecl) {
+            varNode = identifier.referencedDecl;
+        }
+        else {
+            varNode = identifier;
+        }
+        let varName = varNode.kind === ArkCxxAstNode_1.astKind.TypeRef ? varNode.code : varNode.name;
+        const varType = (0, builderUtils_1.cxxNode2Type)(identifier, this.declaringMethod);
+        if (varName === Type_1.UndefinedType.getInstance().getName()) {
+            identifierValue = ValueUtil_1.CxxValueUtil.getUndefinedConst();
+        }
+        else {
+            if (variableDefFlag) {
+                identifierValue = this.addNewLocal(varName, varType);
+            }
+            else {
+                if ((_a = identifier.name) === null || _a === void 0 ? void 0 : _a.includes('::' + varName + '<')) { // Determine whether it is a variable template
+                    varName = identifier.name;
+                }
+                identifierValue = this.getOrCreateLocal(varName, varType);
+            }
+        }
+        return {
+            value: identifierValue,
+            valueOriginalPositions: identifierPositions,
+            stmts: [],
+        };
+    }
+    /**
+     *Convert the member expression of C++(such as testMap. insert) to ValueAndStmts of Ark IR
+     *@ param memberExpression - shaped like an AST MemberExpr/MemberRef node, which usually means obj. field or obj ->field
+     *@ param localValue - (Optional) The scenario where the baseValue is specified directly (
+     *  such as determining the base in advance when resolving the parent node)
+     */
+    memberExpressionToValueAndStmts(memberExpression, localValue) {
+        var _a, _b, _c;
+        const stmts = [];
+        // [Scenario 1] Process this ->field or this ->method calls in C++code
+        // If it's a class member reference (MemberExpr/MemberRef) but has no inner[0], it means implicit this, need to supplement this node
+        if ((memberExpression.kind === ArkCxxAstNode_1.astKind.MemberExpr || memberExpression.kind === ArkCxxAstNode_1.astKind.MemberRef) && memberExpression.inner[0] === undefined) {
+            memberExpression.inner[0] = {
+                kind: 'CXXThisExpr',
+                name: memberExpression.name,
+                code: '',
+                type: { qualType: 'void' },
+                inner: [],
+            }; //  As base node
+        }
+        // [Scenario 2] Recursively process base object, such as testMap in testMap.insert
+        //  Get baseValue (e.g., testMap), position information, and possible preceding statements (e.g., auto tmp = ...;)
+        let { value: baseValue, valueOriginalPositions: basePositions, stmts: baseStmts, } = this.cxxNodeToValueAndStmts(memberExpression.inner[0]);
+        // [Scenario 3] Processing chained member access, such as a.b.c or (* ptr). field
+        // If the base is a member access, generate an assignment statement to ensure the validity of SSA
+        if (((_a = memberExpression.inner[0]) === null || _a === void 0 ? void 0 : _a.kind) === ArkCxxAstNode_1.astKind.MemberExpr || memberExpression.kind === ArkCxxAstNode_1.astKind.MemberRef) {
+            ({ value: baseValue, valueOriginalPositions: basePositions, stmts: baseStmts } =
+                this.ArkCxxIRTransformer.generateAssignStmtForValue(baseValue, basePositions));
+        }
+        // [Scenario 4] On special occasions, the caller directly specifies the baseValue (generally used to replace the base,
+        // such as virtual members, generics, etc.)
+        if (localValue) {
+            baseValue = localValue;
+        }
+        // Combine preceding statements to ensure complete order
+        stmts.push(...baseStmts);
+        // [Scenario 5] Get the member's field signature
+        // The purpose is to associate the insert in testMap.insert with the base type (such as the type of testMap) to form a complete field signature
+        const fieldSignature = this.buildFieldSignatureFromMemberExpr(baseValue, memberExpression);
+        // [Scenario 6] Generate the field reference object of IR layer (such as testMap. insert)
+        let fieldRef;
+        if (((_b = memberExpression.referencedDecl) === null || _b === void 0 ? void 0 : _b.kind) === ArkCxxAstNode_1.astKind.EnumConstantDecl) {
+            fieldRef = new Ref_1.ArkStaticFieldRef(fieldSignature);
+        }
+        else {
+            fieldRef = new Ref_2.ArkCxxInstanceFieldRef(baseValue, // baseValue（eg: testMap）
+            (_c = memberExpression.isArrow) !== null && _c !== void 0 ? _c : false, // Whether it is arrow access (->)
+            fieldSignature);
+        }
+        // Record node location information for subsequent traceability and debugging
+        const fieldRefPositions = [Position_1.FullPosition.cxxBuildFromNode(memberExpression, this.cxxSourceFile), ...basePositions];
+        // Return resolution results, including IR field references, location information, and related SSA statements
+        return { value: fieldRef, valueOriginalPositions: fieldRefPositions, stmts: stmts };
+    }
+    buildFieldSignatureFromMemberExpr(baseValue, memberExpression) {
+        var _a, _b;
+        let fieldSignature;
+        const memberName = ((_a = memberExpression.referencedDecl) === null || _a === void 0 ? void 0 : _a.name) || memberExpression.name || memberExpression.code;
+        // ==Scenarios for Special Handling of Enum Members==
+        if (((_b = memberExpression.referencedDecl) === null || _b === void 0 ? void 0 : _b.kind) === ArkCxxAstNode_1.astKind.EnumConstantDecl) {
+            const enumClassName = memberExpression.type.qualType.replace('enum', '').trim();
+            const enumArkClass = ModelUtils_2.CxxModelUtils.findSymbolInFileWithName(enumClassName, this.declaringMethod.getDeclaringArkClass());
+            const enumSignature = (enumArkClass instanceof ArkClass_1.ArkClass) ?
+                enumArkClass.getSignature() :
+                ArkSignatureBuilder_1.ArkSignatureBuilder.buildClassSignatureFromClassName(enumClassName);
+            return new ArkSignature_1.FieldSignature(memberName, enumSignature, enumSignature.getType(), true);
+        }
+        // ==Handling common scenarios==
+        let baseType = baseValue.getType();
+        if (baseValue instanceof Ref_1.ArkArrayRef) {
+            let arrayBaseType = TypeInference_1.TypeInference.replaceTypeWithReal(baseValue.getBase().getType());
+            if (arrayBaseType instanceof Type_2.CxxArrayType) {
+                baseType = arrayBaseType.getBaseType();
+            }
+        }
+        let baseClassType = null;
+        // Judge whether the base is a class type or its pointer/reference
+        if (baseType instanceof Type_1.ClassType) {
+            baseClassType = baseType;
+        }
+        else if (baseType instanceof Type_2.PointerType && baseType.getBaseType() instanceof Type_1.ClassType) {
+            baseClassType = baseType.getBaseType();
+        }
+        else if (baseType instanceof Type_2.ReferenceType && baseType.getBaseType() instanceof Type_1.ClassType) {
+            baseClassType = baseType.getBaseType();
+        }
+        // Construction field signature
+        // If base is a class local variable, use the complete class signature
+        if ((baseValue instanceof Local_1.Local || baseValue instanceof Ref_1.ArkArrayRef) && baseClassType !== null) {
+            fieldSignature = new ArkSignature_1.FieldSignature(memberName, // Field name (such as insert)
+            baseClassType.getClassSignature(), // Base class type signature
+            baseType);
+        }
+        else {
+            // Otherwise, it is generated only according to the field name
+            fieldSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildFieldSignatureFromFieldName(memberName);
+        }
+        // Set field types to support C++complex type resolution (such as template, pointer, const, etc.)
+        fieldSignature.setType((0, builderUtils_1.cxxNode2Type)(memberExpression, this.declaringMethod));
+        return fieldSignature;
+    }
+    /**
+     *Convert element access expressions (such as array [index] or object. field) in C++AST to values and statements in intermediate representation (IR).
+     *
+     *@ param elementAccessExpression represents the AST node of C++element access expression
+     *@ returns contains the generated IR value, original location information and the ValueAndStmts object of related statements
+     */
+    cxxElementAccessExpressionToValueAndStmts(elementAccessExpression) {
+        const stmts = [];
+        let { value: baseValue, valueOriginalPositions: basePositions, stmts: baseStmts, } = this.cxxNodeToValueAndStmts(elementAccessExpression.inner[0]);
+        stmts.push(...baseStmts);
+        if (!(baseValue instanceof Local_1.Local)) {
+            ({
+                value: baseValue,
+                valueOriginalPositions: basePositions,
+                stmts: baseStmts,
+            } = this.ArkCxxIRTransformer.generateAssignStmtForValue(baseValue, basePositions));
+            stmts.push(...baseStmts);
+        }
+        let { value: argumentValue, valueOriginalPositions: arguPositions, stmts: argumentStmts, } = this.cxxNodeToValueAndStmts(elementAccessExpression.inner[1]);
+        stmts.push(...argumentStmts);
+        if (IRUtils_1.IRUtils.moreThanOneAddress(argumentValue)) {
+            ({
+                value: argumentValue,
+                valueOriginalPositions: arguPositions,
+                stmts: argumentStmts,
+            } = this.ArkCxxIRTransformer.generateAssignStmtForValue(argumentValue, arguPositions));
+            stmts.push(...argumentStmts);
+        }
+        let elementAccessExpr;
+        if (baseValue.getType() instanceof Type_2.CxxArrayType || baseValue.getType() instanceof Type_2.PointerType) {
+            elementAccessExpr = new Ref_1.ArkArrayRef(baseValue, argumentValue);
+        }
+        else {
+            const fieldSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildFieldSignatureFromFieldName(argumentValue.toString());
+            elementAccessExpr = new Ref_1.ArkInstanceFieldRef(baseValue, fieldSignature);
+        }
+        // reserve positions for field name
+        const exprPositions = [Position_1.FullPosition.cxxBuildFromNode(elementAccessExpression, this.cxxSourceFile), ...basePositions, ...arguPositions];
+        return {
+            value: elementAccessExpr,
+            valueOriginalPositions: exprPositions,
+            stmts: stmts,
+        };
+    }
+    cxxCallExpressionToValueAndStmts(callExpression) {
+        var _a, _b, _c, _d, _e, _f;
+        if (callExpression.kind === ArkCxxAstNode_1.astKind.CallExpr && ((_a = callExpression.inner) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+            if (((_e = (_d = ((_b = callExpression.parent) !== null && _b !== void 0 ? _b : (_c = callExpression.getParent) === null || _c === void 0 ? void 0 : _c.call(callExpression, true))) === null || _d === void 0 ? void 0 : _d.type) === null || _e === void 0 ? void 0 : _e.qualType) === 'std::thread') {
+                return this.cxxNewExpressionToValueAndStmts(callExpression);
+            }
+            else if (callExpression.inner[0].kind === ArkCxxAstNode_1.astKind.CXXPseudoDestructorExpression) {
+                return this.cxxCallExpressionToValueAndStmts(callExpression.inner[0]);
+            }
+            else if (callExpression.name === 'basic_string' || callExpression.inner[0].kind === ArkCxxAstNode_1.astKind.MaterializeTemporaryExpr) {
+                return this.cxxNodeToValueAndStmts(callExpression.inner[0]);
+            }
+        }
+        const stmts = [];
+        const [callNode, argumentNodes] = this.getArgumentNode(callExpression.inner);
+        if (callNode && (0, builderUtils_1.isFuncInClassOrNamespace)(callNode) && ((_f = callNode.referencedDecl) === null || _f === void 0 ? void 0 : _f.name)) {
+            // Process static function calls
+            callNode.kind = 'MemberExpr';
+            const replaceFuncName = callNode.referencedDecl.name;
+            callNode.name = replaceFuncName;
+            const outerName = callNode.code.replace('::' + replaceFuncName, '');
+            callNode.inner[0] = {
+                kind: 'DeclRefExpr',
+                name: outerName,
+                code: outerName,
+                type: { qualType: outerName },
+                inner: [],
+            };
+            return this.buildValueAndStmtsForMemberCall(stmts, callNode, argumentNodes, callExpression, undefined);
+        }
+        const argus = this.cxxParseArgumentsOfCallExpression(stmts, argumentNodes, callNode);
+        if (callExpression.name === 'napi_define_class') {
+            (0, ModelUtils_2.setTs2CxxFuncMapOfClass)(argus.args, true, this.declaringMethod);
+        }
+        const returnType = (0, builderUtils_1.cxxNode2Type)(callExpression, this.declaringMethod);
+        return this.cxxGenerateInvokeValueAndStmts(callNode, argus, stmts, callExpression, returnType);
+    }
+    /**
+     *Process the 'cout<<...' or lambda expression in C++, extract its operands and construct corresponding statements and values.
+     *
+     *@ param callExpression - The currently processed C++AST node, which represents an operator calling expression (such as<<).
+     *@ param callArgus - An array used to collect the parameter nodes involved in the expression.
+     *@ returns the ValueAndStmts object containing values and statements. If it cannot be processed, it returns null.
+     */
+    streamOrLambdaExprToValueAndStmts(callExpression, callArgus) {
+        const stmts = [];
+        // Because inner extracts the last parameters in turn, it traverses the last parameters in reverse order
+        for (let i = callExpression.inner.length - 1; i >= 0; i--) {
+            let innerNode = callExpression.inner[i];
+            if (!innerNode.code.includes('cout') &&
+                !innerNode.code.includes('<<') &&
+                !innerNode.code.includes('endl') &&
+                !callExpression.code.startsWith(innerNode.code)) {
+                callArgus.push(innerNode);
+            }
+            if (innerNode.kind === ArkCxxAstNode_1.astKind.CXXOperatorCallExpr) {
+                // Recursive call processing CXXOperatorCallExpr
+                if (innerNode.type.qualType !== 'std::ostream') {
+                    return this.streamOrLambdaExprToValueAndStmts(innerNode, callArgus);
+                }
+                // When the type is std:: ostream, it indicates an overloaded stream operator and records the overloaded node of the stream operator
+                callArgus.push(innerNode);
+                // Recursive call to process CXXOperatorCallExpr nested in the inner of CXXOperatorCallExpr
+                if (innerNode.inner[1].kind === ArkCxxAstNode_1.astKind.CXXOperatorCallExpr) {
+                    return this.streamOrLambdaExprToValueAndStmts(innerNode.inner[1], callArgus);
+                }
+                // If there is no nested CXXOperatorCallExpr, the ValueAndStmts of overloaded stream operators will be built directly
+                return this.buildValueAndStmtsForStreamOrLambdaCall(innerNode.inner[1], callArgus.reverse(), stmts, callExpression);
+            }
+            while (innerNode.kind === ArkCxxAstNode_1.astKind.ImplicitCastExpr && innerNode.valueCategory === 'lvalue' && innerNode.inner.length > 0) {
+                innerNode = innerNode.inner[0];
+            }
+            if (innerNode.kind === ArkCxxAstNode_1.astKind.DeclRefExpr &&
+                (innerNode.type.qualType.includes('iostream') ||
+                    innerNode.type.qualType.includes('ostream') ||
+                    innerNode.type.qualType.includes('istream') ||
+                    innerNode.type.qualType.includes('lambda at'))) {
+                // Get DeclRefExpr and its subsequent nodes
+                return this.buildValueAndStmtsForStreamOrLambdaCall(innerNode, callArgus.reverse(), stmts, callExpression);
+            }
+        }
+        return null;
+    }
+    /**
+     *Build a collection of values and statements for stream operations or lambda function call
+     *
+     *@ param streamNode The AST node of the stream node
+     *@ param args parameter array of stream operation
+     *@ param stmts statement array
+     *@ param streamExpr AST node of stream expression
+     *@ returns The ValueAndStmts object containing values and statements
+     */
+    buildValueAndStmtsForStreamOrLambdaCall(streamNode, args, stmts, streamExpr) {
+        let nonOverloadedArgs = [];
+        const currValueAndStmts = {
+            value: new Local_1.Local(streamExpr.code),
+            valueOriginalPositions: [],
+            stmts: [...stmts],
+        };
+        for (let i = 0; i < args.length; i += 1) {
+            let arg = args[i];
+            if (arg.kind === ArkCxxAstNode_1.astKind.CXXOperatorCallExpr) {
+                // Standard stream operator+overloaded stream operator
+                // 1. Object of standard stream operator, call std:: stream function
+                this.buildValueAndStmtsForStdStreamOrLambdaCall(streamNode, nonOverloadedArgs, streamExpr, currValueAndStmts);
+                // 2. Overload the object of the output operator and call the overloaded function
+                this.buildValueAndStmtsForOverloadedStream(streamNode, arg, currValueAndStmts);
+                nonOverloadedArgs = [];
+            }
+            else {
+                nonOverloadedArgs.push(arg);
+            }
+        }
+        // process the remaining standard stream operators
+        this.buildValueAndStmtsForStdStreamOrLambdaCall(streamNode, nonOverloadedArgs, streamExpr, currValueAndStmts);
+        return currValueAndStmts;
+    }
+    /**
+     *Build values and statements of overloaded flow operators
+     *@ param streamNode
+     *@ param overloadedArg overload parameter node
+     *@ param currValueAndStmts Current value and statement collection
+     */
+    buildValueAndStmtsForOverloadedStream(streamNode, overloadedArg, currValueAndStmts) {
+        // Replace the second child node with an overloaded operator node to avoid repeated processing of nested CXXOperatorCallExpr
+        overloadedArg.inner[1] = streamNode;
+        let overloadedStreamValueAndStmts = this.handleOverloadedOp(overloadedArg);
+        if (!overloadedStreamValueAndStmts) {
+            return;
+        }
+        currValueAndStmts.stmts.push(...overloadedStreamValueAndStmts.stmts);
+        currValueAndStmts.valueOriginalPositions.push(...overloadedStreamValueAndStmts.valueOriginalPositions);
+        if (overloadedStreamValueAndStmts.value instanceof Expr_1.AbstractInvokeExpr) {
+            const invokeStmt = new Stmt_1.ArkInvokeStmt(overloadedStreamValueAndStmts.value);
+            invokeStmt.setOperandOriginalPositions(overloadedStreamValueAndStmts.valueOriginalPositions);
+            currValueAndStmts.stmts.push(invokeStmt);
+        }
+    }
+    /**
+     *Build a collection of values and statements for standard flow or lambda call nodes
+     *@ param streamNode - AST node of the stream node
+     *@ param nonOverlooadedArgs - non overloaded parameter array
+     *@ param streamExpr - AST node of stream expression
+     *@ param currValueAndStmts - current value and statement collection object, used to store processing results
+     */
+    buildValueAndStmtsForStdStreamOrLambdaCall(streamNode, nonOverloadedArgs, streamExpr, currValueAndStmts) {
+        const stmts = [];
+        const argus = this.cxxParseArgumentsOfCallExpression(stmts, nonOverloadedArgs);
+        const normalCoutValueAndStmts = this.cxxGenerateInvokeValueAndStmts(streamNode, argus, stmts, streamExpr);
+        currValueAndStmts.stmts.push(...normalCoutValueAndStmts.stmts);
+        currValueAndStmts.valueOriginalPositions = normalCoutValueAndStmts.valueOriginalPositions;
+        if (streamNode.type.qualType.includes('lambda at')) {
+            currValueAndStmts.value = normalCoutValueAndStmts.value;
+        }
+        else if (normalCoutValueAndStmts.value instanceof Expr_1.AbstractInvokeExpr) {
+            const invokeStmt = new Stmt_1.ArkInvokeStmt(normalCoutValueAndStmts.value);
+            invokeStmt.setOperandOriginalPositions(normalCoutValueAndStmts.valueOriginalPositions);
+            currValueAndStmts.stmts.push(invokeStmt);
+        }
+    }
+    /**
+     *Convert C++operator expression to binary operator expression
+     *@ param expression - C++AST node, representing operator expression
+     *@ returns the converted values and statements
+     */
+    CXXOperatorExpressionToBinaryOperator(expression) {
+        let operatorExpression = Object.assign({}, expression);
+        operatorExpression.opcode = expression.inner[0].code;
+        operatorExpression.inner = [expression.inner[1], expression.inner[2]];
+        return this.cxxBinaryExpressionToValueAndStmts(operatorExpression);
+    }
+    /**
+     *Convert C++operator expression to unary operator expression
+     *@ param expression - C++AST node, representing operator expression
+     *@ returns ValueAndStmts object, including converted values and statements
+     */
+    CXXOperatorExpressionToUnaryOperator(expression) {
+        let operatorExpression = Object.assign({}, expression);
+        operatorExpression.opcode = expression.inner[0].code;
+        operatorExpression.inner = [expression.inner[1]];
+        if (expression.code.indexOf(expression.inner[0].code) === 0) {
+            return this.cxxPrefixUnaryExpressionToValueAndStmts(operatorExpression);
+        }
+        return this.cxxPostfixUnaryExpressionToValueAndStmts(operatorExpression);
+    }
+    cxxOperatorExpressionToValueAndStmts(callExpression, layer = true) {
+        var _a;
+        // First handle overloaded operators or other special cases
+        const specialResult = this.handleSpecialOperators(callExpression);
+        if (specialResult) {
+            return specialResult;
+        }
+        const innerStmts = [];
+        const stmts = [];
+        // Collect statements from all inner nodes
+        this.collectInnerOperatorStmts(callExpression, innerStmts);
+        if (!layer) {
+            // Only process final output in the first recursive layer
+            return innerStmts;
+        }
+        // Merge results and build element access expression
+        const exprPositions = [Position_1.FullPosition.cxxBuildFromNode(callExpression, this.cxxSourceFile)];
+        for (const stmt of innerStmts) {
+            exprPositions.push(...stmt.valueOriginalPositions);
+        }
+        // *ptr,When ptr is a smart pointer and the node type is CXXOperatorCallExpr, we will perform pointer dereference parsing here
+        let elementAccessExpr;
+        if (innerStmts.length >= 2) {
+            elementAccessExpr = new Ref_1.ArkArrayRef(innerStmts[0].value, innerStmts[1].value);
+        }
+        else {
+            const operatorToken = ((_a = callExpression.name) !== null && _a !== void 0 ? _a : '').replace('operator', '');
+            const operator = ArkIRTransformer_1.ArkCxxIRTransformer.cxxTokenToUnaryOperator(operatorToken);
+            if (operator && innerStmts.length > 0) {
+                elementAccessExpr = new Expr_1.ArkUnopExpr(innerStmts[0].value, operator);
+            }
+            else {
+                elementAccessExpr = ValueUtil_1.CxxValueUtil.getUndefinedConst();
+            }
+        }
+        innerStmts.forEach(innerStmt => {
+            stmts.push(...innerStmt.stmts);
+        });
+        return { value: elementAccessExpr, valueOriginalPositions: exprPositions, stmts: stmts };
+    }
+    /**
+     * Handle special operator scenarios and return early if matched
+     */
+    handleSpecialOperators(callExpression) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        // Overloaded operator
+        const overloadedOpToValueAndStmts = this.handleOverloadedOp(callExpression);
+        if (overloadedOpToValueAndStmts) {
+            return overloadedOpToValueAndStmts;
+        }
+        // operator<< / operator>> and lambda cout scenario
+        if ((((_a = callExpression.inner[0]) === null || _a === void 0 ? void 0 : _a.kind) === ArkCxxAstNode_1.astKind.ImplicitCastExpr && ((_b = callExpression.inner[0]) === null || _b === void 0 ? void 0 : _b.name) === 'operator>>') ||
+            callExpression.name === 'operator<<' ||
+            ((_c = callExpression.inner[0]) === null || _c === void 0 ? void 0 : _c.name) === 'operator<<' ||
+            ((_d = callExpression.inner[1]) === null || _d === void 0 ? void 0 : _d.type.qualType.toString().includes('(lambda at'))) {
+            return this.streamOrLambdaExprToValueAndStmts(callExpression, []);
+        }
+        // Relational binary operator or assignment operator
+        if (((_e = callExpression.inner[0]) === null || _e === void 0 ? void 0 : _e.kind) === ArkCxxAstNode_1.astKind.ImplicitCastExpr &&
+            (ArkCxxValueTransformer.isRelationalBinaryOperator((_f = callExpression.inner[0]) === null || _f === void 0 ? void 0 : _f.code) ||
+                this.getOverloadOpName(callExpression) === 'operator=')) {
+            return this.CXXOperatorExpressionToBinaryOperator(callExpression);
+        }
+        // Unary operators (++ / --)
+        if (((_g = callExpression.inner[0]) === null || _g === void 0 ? void 0 : _g.kind) === ArkCxxAstNode_1.astKind.ImplicitCastExpr &&
+            ['++', '--', '*'].includes((_h = callExpression.inner[0]) === null || _h === void 0 ? void 0 : _h.code)) {
+            return this.CXXOperatorExpressionToUnaryOperator(callExpression);
+        }
+        // Arrow operator (->) in iteration
+        if (((_j = callExpression.inner[0]) === null || _j === void 0 ? void 0 : _j.kind) === ArkCxxAstNode_1.astKind.ImplicitCastExpr &&
+            ((_k = callExpression.inner[0]) === null || _k === void 0 ? void 0 : _k.code) === '->') {
+            return this.cxxNodeToValueAndStmts(callExpression.inner[1]);
+        }
+        return null;
+    }
+    /**
+     * Collect ValueAndStmts from each inner node
+     */
+    collectInnerOperatorStmts(callExpression, innerStmts) {
+        for (let innerNode of callExpression.inner) {
+            // 将第一组递归表达式类型定义为 string 数组
+            const recursiveKinds = [
+                ArkCxxAstNode_1.astKind.CXXOperatorCallExpr,
+                ArkCxxAstNode_1.astKind.MaterializeTemporaryExpr,
+                ArkCxxAstNode_1.astKind.CXXBindTemporaryExpr,
+                ArkCxxAstNode_1.astKind.CXXConstructExpr
+            ];
+            if (recursiveKinds.includes(innerNode.kind) ||
+                (innerNode.kind === ArkCxxAstNode_1.astKind.ImplicitCastExpr && innerNode.castKind !== 'FunctionToPointerDecay')) {
+                innerStmts.push(...this.cxxOperatorExpressionToValueAndStmts(innerNode, false));
+            }
+            else if (innerNode.kind === ArkCxxAstNode_1.astKind.DeclRefExpr) {
+                innerStmts.push(this.cxxIdentifierToValueAndStmts(innerNode));
+            }
+            else if (innerNode.kind === ArkCxxAstNode_1.astKind.IntegerLiteral || innerNode.kind === ArkCxxAstNode_1.astKind.StringLiteral) {
+                let literalNode = this.cxxLiteralNodeToValueAndStmts(innerNode);
+                if (literalNode) {
+                    innerStmts.push(literalNode);
+                }
+            }
+        }
+    }
+    getOverloadOpName(cxxOperatorCallExpr) {
+        var _a, _b, _c, _d;
+        return (_d = (_c = (_b = (_a = cxxOperatorCallExpr.inner[0]) === null || _a === void 0 ? void 0 : _a.inner[0]) === null || _b === void 0 ? void 0 : _b.referencedDecl) === null || _c === void 0 ? void 0 : _c.name) !== null && _d !== void 0 ? _d : '';
+    }
+    /**
+     *Handling C++overloaded operator call expressions
+     *@ param cxxOperatorCallExpr C++AST node, representing operator calling expression
+     *@ returns the processed value and statement object. If it cannot be processed, it returns null
+     */
+    handleOverloadedOp(cxxOperatorCallExpr) {
+        var _a, _b, _c, _d;
+        if (((_a = cxxOperatorCallExpr.type) === null || _a === void 0 ? void 0 : _a.qualType) === '' ||
+            ((_c = (_b = cxxOperatorCallExpr.inner) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.castKind) !== 'FunctionToPointerDecay') {
+            return null;
+        }
+        // Handling Recursive function, e.g. Case10 in lambdaFuncSample.cpp
+        if ((_d = cxxOperatorCallExpr.inner) === null || _d === void 0 ? void 0 : _d[1]) {
+            let callNode = cxxOperatorCallExpr.inner[1];
+            while (callNode.kind === ArkCxxAstNode_1.astKind.ImplicitCastExpr && callNode.valueCategory === 'lvalue' && callNode.inner.length > 0) {
+                callNode = callNode.inner[0];
+            }
+            if (callNode.type.qualType.includes('std::function') || this.isNodeRelatedToCXXLambdaFunc(callNode)) {
+                return this.buildValueAndStmtsForMemberCall([], cxxOperatorCallExpr.inner[1], [...cxxOperatorCallExpr.inner.slice(2)], cxxOperatorCallExpr, undefined);
+            }
+        }
+        let callType = (0, builderUtils_1.cxxNode2Type)(cxxOperatorCallExpr, this.declaringMethod);
+        if (callType instanceof Type_2.ReferenceType) {
+            callType = callType.getBaseType();
+        }
+        // Handling overloaded stream operators
+        const callTypeStr = callType.toString();
+        if (callTypeStr.includes('istream') || callTypeStr.includes('ostream')) {
+            return this.buildInvokeValueForOverloadedStreamOp(cxxOperatorCallExpr);
+        }
+        if (!(callType instanceof Type_1.ClassType)) {
+            return null;
+        }
+        // Handling overloaded operators in user-defined class
+        const classSignature = callType.getClassSignature();
+        const arkClass = this.declaringMethod.getDeclaringArkFile().getScene().getClass(classSignature);
+        if (!arkClass) {
+            return null;
+        }
+        const overloadOpName = this.getOverloadOpName(cxxOperatorCallExpr);
+        const overloadOpMethod = overloadOpName ? arkClass.getMethodWithName(overloadOpName) : null;
+        if (!overloadOpMethod) {
+            return null;
+        }
+        return this.buildInvokeValueForNormalOverloadedOp(cxxOperatorCallExpr);
+    }
+    /**
+     *Build values and statements called by overloaded flow operators, such as<<or>>.
+     * Call IR for the function corresponding to the overload construction of the input/output stream operators operator<<, operator>>
+     *This function is used to handle operator overloading call expressions in C++, especially for input/output stream operators.
+     *It will parse parameters, find matching Ark methods, and generate corresponding call expressions.
+     *
+     *@ param cxxOperatorCallExpr represents the AST node of the C++operator call expression
+     *@ returns an object containing values and statements. If it cannot be constructed, it returns null
+     */
+    buildInvokeValueForOverloadedStreamOp(cxxOperatorCallExpr) {
+        if (!cxxOperatorCallExpr.inner || cxxOperatorCallExpr.inner.length < 2) {
+            return null;
+        }
+        const stmts = [];
+        const { args, argPositions: argPositionsAll, } = this.cxxParseArguments(stmts, cxxOperatorCallExpr.inner.slice(1));
+        // The input/output operator must be overloaded as a global function, and the overloaded function only has 2 parameters,
+        // because the input/output operator is actually a binary operation: stream (left operand)+object (right operand)
+        const defaultClass = this.declaringMethod.getDeclaringArkFile().getDefaultClass();
+        const arkMtds = defaultClass.getAllMethodsWithName(cxxOperatorCallExpr.name);
+        let matchMtd;
+        for (const mtd of arkMtds) {
+            const params = mtd.getParameters();
+            let objType = params[1].getType();
+            if (objType instanceof Type_2.ReferenceType) {
+                objType = objType.getBaseType();
+            }
+            if (objType.toString() === args[1].getType().toString()) {
+                matchMtd = mtd;
+                break;
+            }
+        }
+        const argus = {
+            realGenericTypes: undefined,
+            args: args,
+            argPositions: argPositionsAll,
+        };
+        if (!matchMtd) {
+            return this.cxxGenerateInvokeValueAndStmts(cxxOperatorCallExpr.inner[0], argus, stmts, cxxOperatorCallExpr);
+        }
+        // Construct callNode
+        const callNode = {
+            code: cxxOperatorCallExpr.name,
+            name: cxxOperatorCallExpr.name,
+            kind: 'DeclRefExpr',
+            inner: [],
+            range: cxxOperatorCallExpr.range,
+            type: cxxOperatorCallExpr.type,
+        };
+        const valueAndStmts = this.cxxGenerateInvokeValueAndStmts(callNode, argus, stmts, cxxOperatorCallExpr);
+        if (valueAndStmts.value instanceof Expr_1.ArkStaticInvokeExpr) {
+            valueAndStmts.value.setMethodSignature(matchMtd.getSignature());
+        }
+        return valueAndStmts;
+    }
+    /* Build corresponding function call IR for overloading ordinary operators */
+    buildInvokeValueForNormalOverloadedOp(cxxOperatorCallExpr) {
+        var _a;
+        // The child nodes of the overloaded operator node cannot be less than 2 (inner [0] is FunctionToPointerDecay,
+        // and inner [1] is the instance object DeclRefExpr)
+        const innerLen = (_a = cxxOperatorCallExpr.inner) === null || _a === void 0 ? void 0 : _a.length;
+        if (!innerLen || innerLen < 2) {
+            return null;
+        }
+        const stmts = [];
+        const argNodes = innerLen === 2 ? [] : cxxOperatorCallExpr.inner.slice(2);
+        // For example, when overloading operator+, a+b is equivalent to a.operator+(b), and the memberExpr of a.operator+is constructed as the caller
+        const overloadOpName = this.getOverloadOpName(cxxOperatorCallExpr);
+        const callNode = {
+            code: cxxOperatorCallExpr.inner[1].code + '.' + overloadOpName,
+            name: overloadOpName,
+            range: cxxOperatorCallExpr.range,
+            kind: 'MemberExpr',
+            type: { qualType: '<bound member function type>' },
+            inner: [cxxOperatorCallExpr.inner[1]],
+        };
+        return this.buildValueAndStmtsForMemberCall(stmts, callNode, argNodes, cxxOperatorCallExpr, undefined);
+    }
+    RecoverExpressionToValueAndStmts(callExpression) {
+        const stmts = [];
+        const [callNode, argumentNodes] = this.getArgumentNodeForRecover(callExpression.inner);
+        const argus = this.cxxParseArgumentsOfCallExpression(stmts, argumentNodes);
+        return this.cxxGenerateInvokeValueAndStmts(callNode, argus, stmts, callExpression);
+    }
+    /**
+     *Generate the value and statement block of the C++call expression (ValueAndStmts).
+     *
+     *@ param functionNameNode - the node corresponding to the function name, which is used to resolve the caller information.
+     *@ param argus - The object containing the actual generic type, parameter value list, and parameter location information.
+     *- realGenericTypes: list of actual generic types.
+     *- args: parameter value list.
+     *- argPositions: The location information of the parameter in the source code.
+     *@ param currStmts - List of existing statements. The newly generated statements will be appended on this basis.
+     *@ param callExpression - represents the AST node of the call expression, which is used to obtain the call location information.
+     *@ returns a ValueAndStmts object that contains the call value, value location information, and related statements.
+     */
+    cxxGenerateInvokeValueAndStmts(functionNameNode, argus, currStmts, callExpression, returnType) {
+        var _a;
+        functionNameNode = functionNameNode !== null && functionNameNode !== void 0 ? functionNameNode : callExpression;
+        const stmts = [...currStmts];
+        let { value: callerValue, valueOriginalPositions: callerPositions, stmts: callerStmts, } = this.cxxNodeToValueAndStmts(functionNameNode);
+        stmts.push(...callerStmts);
+        let invokeValue;
+        let invokeValuePositions = [Position_1.FullPosition.cxxBuildFromNode(callExpression, this.cxxSourceFile)];
+        const { args, argPositions, realGenericTypes } = argus;
+        if (callerValue instanceof Ref_1.AbstractFieldRef) {
+            invokeValue = this.buildInvokeValueForFieldRef(callerValue, args, realGenericTypes, invokeValuePositions, callerPositions, returnType);
+        }
+        else if (callerValue instanceof Local_1.Local) {
+            const callerName = callerValue.getName();
+            let classSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildClassSignatureFromClassName(callerName);
+            let cls = ModelUtils_1.ModelUtils.getClass(this.declaringMethod, classSignature);
+            const callExprs = [ArkCxxAstNode_1.astKind.CallExpr, ArkCxxAstNode_1.astKind.CXXOperatorCallExpr];
+            if ((cls === null || cls === void 0 ? void 0 : cls.hasComponentDecorator()) && callExprs.includes(callExpression.kind)) {
+                return this.cxxGenerateCustomViewStmt(callerName, args, argPositions, callExpression, stmts);
+            }
+            else if (callerName === EtsConst_1.COMPONENT_FOR_EACH || callerName === EtsConst_1.COMPONENT_LAZY_FOR_EACH) {
+                // foreach/lazyforeach will be parsed as ts.callExpression
+                return this.cxxGenerateSystemComponentStmt(callerName, args, argPositions, callExpression, stmts);
+            }
+            const methodSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSignatureFromMethodName(callerName);
+            const callerType = callerValue.getType();
+            if (callerType instanceof Type_1.FunctionType || (callerType instanceof Type_2.PointerType && callerType.getBaseType() instanceof Type_1.FunctionType) ||
+                !((_a = this.getGlobals()) === null || _a === void 0 ? void 0 : _a.has(callerName))) {
+                invokeValue = new Expr_1.ArkPtrInvokeExpr(methodSignature, callerValue, args, realGenericTypes);
+            }
+            else {
+                invokeValue = new Expr_1.ArkStaticInvokeExpr(methodSignature, args, realGenericTypes);
+            }
+        }
+        else {
+            ({
+                value: callerValue,
+                stmts: callerStmts,
+            } = this.ArkCxxIRTransformer.generateAssignStmtForValue(callerValue, callerPositions));
+            stmts.push(...callerStmts);
+            const methodSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSignatureFromMethodName(callerValue.getName());
+            invokeValue = new Expr_1.ArkStaticInvokeExpr(methodSignature, args, realGenericTypes);
+        }
+        invokeValuePositions.push(...argPositions);
+        return {
+            value: invokeValue,
+            valueOriginalPositions: invokeValuePositions,
+            stmts: stmts,
+        };
+    }
+    /**
+     *IR Processing of C++Function Calls
+     *@ param callExpression - C++AST node, representing member call expression
+     *@ returns ValueAndStmts object, including converted values and related statements
+     */
+    cxxMemberCallExpressionToValueAndStmts(callExpression) {
+        var _a, _b, _c, _d;
+        if (((_d = (_c = ((_a = callExpression.parent) !== null && _a !== void 0 ? _a : (_b = callExpression.getParent) === null || _b === void 0 ? void 0 : _b.call(callExpression, true))) === null || _c === void 0 ? void 0 : _c.type) === null || _d === void 0 ? void 0 : _d.qualType) === 'std::thread') {
+            return this.cxxNewExpressionToValueAndStmts(callExpression);
+        }
+        const cxxMemberCallExprType = (0, builderUtils_1.cxxNode2Type)(callExpression, this.declaringMethod, this.cxxSourceFile, callExpression);
+        let realGenericTypes;
+        const stmts = [];
+        const [_, rightNodes] = this.getArgumentNode(callExpression.inner);
+        return this.buildValueAndStmtsForMemberCall(stmts, callExpression.inner[0], rightNodes, callExpression, realGenericTypes, cxxMemberCallExprType);
+    }
+    /**
+     *Build values and statements called by members
+     *@ param stmts statement array, used to collect generated statements
+     *@ param callerNode Caller Node
+     *@ param argNodes parameter node array
+     *@ param callExpression calls the expression node
+     *@ param realGenericTypes Actual generic type array
+     *@ returns The ValueAndStmts object containing values, location information, and statements
+     */
+    buildValueAndStmtsForMemberCall(stmts, callerNode, argNodes, callExpression, realGenericTypes, cxxMemberCallExprType) {
+        const { args, argPositions: argPositionsAll } = this.cxxParseArguments(stmts, argNodes);
+        const argPositionsAllFlat = argPositionsAll.flat();
+        let { value: callerValue, valueOriginalPositions: callerPositions, stmts: callerStmts, } = this.cxxNodeToValueAndStmts(callerNode);
+        stmts.push(...callerStmts);
+        let invokeValue;
+        let invokeValuePositions = [Position_1.FullPosition.cxxBuildFromNode(callExpression, this.cxxSourceFile)];
+        if (callerValue instanceof Ref_1.ArkInstanceFieldRef) {
+            invokeValue = this.buildInvokeValueForFieldRef(callerValue, args, realGenericTypes, invokeValuePositions, callerPositions, cxxMemberCallExprType);
+        }
+        else if (callerValue instanceof Local_1.Local) {
+            invokeValue = this.buildInvokeValueForLocal(callerValue, args, realGenericTypes, cxxMemberCallExprType);
+        }
+        else {
+            ({
+                value: callerValue,
+                valueOriginalPositions: callerPositions,
+                stmts: callerStmts,
+            } = this.ArkCxxIRTransformer.generateAssignStmtForValue(callerValue, callerPositions));
+            stmts.push(...callerStmts);
+            const methodSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSignatureFromMethodName(callerValue.getName());
+            invokeValue = new Expr_1.ArkStaticInvokeExpr(methodSignature, args, realGenericTypes);
+            invokeValuePositions.push(...argPositionsAllFlat);
+        }
+        invokeValuePositions.push(...argPositionsAllFlat);
+        return {
+            value: invokeValue,
+            valueOriginalPositions: invokeValuePositions,
+            stmts: stmts,
+        };
+    }
+    /**
+     *Build the call value referenced by the field
+     *
+     *@ param callerValue The caller value indicates the field reference
+     *@ param args calls the parameter array
+     *@ param realGenericTypes The actual generic type array may be undefined
+     *@ param invokeValuePositions calls the value position information array
+     *@ param callerPositions Caller position information array
+     *@ returns the ArkInstanceFieldRef or ArkStaticInvokeExpr instance
+     */
+    buildInvokeValueForFieldRef(callerValue, args, realGenericTypes, invokeValuePositions, callerPositions, returnType) {
+        let methodSignature;
+        const declareSignature = callerValue.getFieldSignature().getDeclaringSignature();
+        if (declareSignature instanceof ArkSignature_1.ClassSignature) {
+            methodSignature = new ArkSignature_1.MethodSignature(declareSignature, ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSubSignatureFromMethodName(callerValue.getFieldName()));
+        }
+        else {
+            methodSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSignatureFromMethodName(callerValue.getFieldName());
+        }
+        methodSignature.getMethodSubSignature().setReturnType(returnType !== null && returnType !== void 0 ? returnType : Type_1.UnknownType.getInstance());
+        if (callerValue instanceof Ref_1.ArkInstanceFieldRef) {
+            invokeValuePositions.push(...callerPositions.slice());
+            return new Expr_1.ArkInstanceInvokeExpr(callerValue.getBase(), methodSignature, args, realGenericTypes);
+        }
+        else {
+            return new Expr_1.ArkStaticInvokeExpr(methodSignature, args, realGenericTypes);
+        }
+    }
+    buildInvokeValueForLocal(callerValue, args, realGenericTypes, cxxMemberCallExprType) {
+        const callerName = callerValue.getName();
+        const methodSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSignatureFromMethodName(callerName);
+        methodSignature.getMethodSubSignature().setReturnType(cxxMemberCallExprType !== null && cxxMemberCallExprType !== void 0 ? cxxMemberCallExprType : Type_1.UnknownType.getInstance());
+        if (callerValue.getType() instanceof Type_1.FunctionType) {
+            return new Expr_1.ArkPtrInvokeExpr(methodSignature, callerValue, args, realGenericTypes);
+        }
+        else {
+            return new Expr_1.ArkStaticInvokeExpr(methodSignature, args, realGenericTypes);
+        }
+    }
+    cxxParseArgumentsOfCallExpression(currStmts, callExpression, callNode) {
+        let realGenericTypes = this.getRealGenericTypes(callNode);
+        let builderMethodIndexes;
+        const { args: args, argPositions: argPositions, } = this.cxxParseArguments(currStmts, callExpression, builderMethodIndexes);
+        return {
+            realGenericTypes: realGenericTypes,
+            args: args,
+            argPositions: argPositions,
+        };
+    }
+    getRealGenericTypes(node, qualType) {
+        if (!node) {
+            return undefined;
+        }
+        // 1. Determine the target type string
+        const nodeType = this.getTargetQualType(node, qualType);
+        if (!nodeType) {
+            return undefined;
+        }
+        // 2. Extract and split template content
+        const match = nodeType.match(/<(.*)>/);
+        if (!match || !match[1]) {
+            return undefined;
+        }
+        const members = this.splitTemplateArguments(match[1]);
+        // 3. Map to Type objects
+        return members.map(arg => (0, builderUtils_1.buildTypeFromPreStr)(arg, node, this.declaringMethod));
+    }
+    /**
+     * Resolves the type string based on priority (provided qualType > desugared > default).
+     */
+    getTargetQualType(node, qualType) {
+        if (qualType) {
+            return qualType;
+        }
+        return (node.type.desugaredQualType && node.type.typeAliasDeclId)
+            ? node.type.desugaredQualType
+            : node.type.qualType;
+    }
+    /**
+     * Splits template arguments by comma, but remains aware of nested brackets
+     * to prevent incorrect splitting of nested templates.
+     */
+    splitTemplateArguments(content) {
+        const parts = [];
+        let current = '';
+        let depth = 0;
+        for (const char of content) {
+            if (char === '<') {
+                depth++;
+            }
+            if (char === '>') {
+                depth--;
+            }
+            if (char === ',' && depth === 0) {
+                parts.push(current.trim());
+                current = '';
+            }
+            else {
+                current += char;
+            }
+        }
+        if (current.trim()) {
+            parts.push(current.trim());
+        }
+        return parts;
+    }
+    cxxParseArguments(currStmts, argumentNodes, builderMethodIndexes) {
+        const args = [];
+        const argPositions = [];
+        if (argumentNodes) {
+            for (let i = 0; i < argumentNodes.length; i++) {
+                if (argumentNodes[i].kind === ArkCxxAstNode_1.astKind.CXXDefaultArgExpr) {
+                    continue;
+                }
+                const argument = argumentNodes[i];
+                const prevBuilderMethodContextFlag = this.builderMethodContextFlag;
+                if (builderMethodIndexes === null || builderMethodIndexes === void 0 ? void 0 : builderMethodIndexes.has(i)) {
+                    this.builderMethodContextFlag = true;
+                    this.ArkCxxIRTransformer.setBuilderMethodContextFlag(true);
+                }
+                let { value: argValue, valueOriginalPositions: argPositionsSingle, stmts: argStmts, } = this.cxxNodeToValueAndStmts(argument);
+                this.builderMethodContextFlag = prevBuilderMethodContextFlag;
+                this.ArkCxxIRTransformer.setBuilderMethodContextFlag(prevBuilderMethodContextFlag);
+                currStmts.push(...argStmts);
+                if (IRUtils_1.IRUtils.moreThanOneAddress(argValue)) {
+                    ({
+                        value: argValue,
+                        valueOriginalPositions: argPositionsSingle,
+                        stmts: argStmts,
+                    } = this.ArkCxxIRTransformer.generateAssignStmtForValue(argValue, argPositionsSingle));
+                    currStmts.push(...argStmts);
+                }
+                args.push(argValue);
+                argPositions.push(argPositionsSingle[0]);
+            }
+        }
+        return { args: args, argPositions: argPositions };
+    }
+    cxxCallableNodeToValueAndStmts(callableNode) {
+        const declaringClass = this.declaringMethod.getDeclaringArkClass();
+        const lambdaArkMethod = new ArkMethod_1.ArkMethod();
+        (0, ArkMethodBuilder_1.buildArkMethodFromArkClass)(callableNode, declaringClass, lambdaArkMethod, this.cxxSourceFile, this.declaringMethod);
+        const callableType = new Type_1.FunctionType(lambdaArkMethod.getSignature());
+        const callableValue = this.addNewLocal(lambdaArkMethod.getName(), callableType);
+        return {
+            value: callableValue,
+            valueOriginalPositions: [Position_1.FullPosition.cxxBuildFromNode(callableNode, this.cxxSourceFile)],
+            stmts: [],
+        };
+    }
+    cxxNewExpressionToValueAndStmts(newExpression) {
+        var _a, _b;
+        let className = this.getNewExpressionClassName(newExpression);
+        // Add handling for dynamic array creation: int *arr = new int[10]
+        if (className === Builtin_1.Builtin.ARRAY || newExpression.isArray) {
+            return this.cxxNewArrayExpressionToValueAndStmts(newExpression);
+        }
+        const stmts = [];
+        let realGenericTypes = this.getRealGenericTypes(newExpression);
+        // Handle the scenarios of namespace::Member and class::member
+        const parentClassOrNs = (_a = newExpression.getParent) === null || _a === void 0 ? void 0 : _a.call(newExpression, true).inner.filter(inn => [ArkCxxAstNode_1.astKind.TypeRef, ArkCxxAstNode_1.astKind.NamespaceRef].includes(inn.kind));
+        let refType = null;
+        // If the parent node has a namespaceRef or TypeRef, it indicates a constructor call,
+        // and should infer the type of the corresponding namespace/class.
+        if (parentClassOrNs && parentClassOrNs.length > 0) {
+            refType = (_b = TypeInference_1.TypeInference.inferUnclearRefName(className, this.declaringMethod.getDeclaringArkClass())) !== null && _b !== void 0 ? _b : (0, builderUtils_1.cxxNode2Type)(newExpression, this.declaringMethod.getDeclaringArkClass());
+        }
+        let classType;
+        let classSignature;
+        if (refType instanceof Type_1.ClassType) {
+            classType = refType;
+        }
+        else if (refType instanceof Type_1.AliasType && refType.getOriginalType() instanceof Type_1.ClassType) {
+            classType = refType.getOriginalType();
+        }
+        else {
+            let curClass = this.declaringMethod.getDeclaringArkFile().getClassWithName(className);
+            classSignature = curClass ? curClass.getSignature() : ArkSignatureBuilder_1.ArkSignatureBuilder.buildClassSignatureFromClassName(className);
+            classType = new Type_1.ClassType(classSignature, realGenericTypes);
+        }
+        const expr = new Expr_1.ArkNewExpr(classType);
+        const { value: newLocal, valueOriginalPositions: newLocalPositions, stmts: newExprStmts } = this.ArkCxxIRTransformer.generateAssignStmtForValue(expr, [Position_1.FullPosition.cxxBuildFromNode(newExpression, this.cxxSourceFile)]);
+        // When using the new keyword, the type of Local should be a pointer type.
+        if (newExpression.kind === ArkCxxAstNode_1.astKind.CXXNewExpr) {
+            newLocal.setType(new Type_2.PointerType(classType, 1));
+        }
+        stmts.push(...newExprStmts);
+        this.cxxEmitCtorInvokeAndMemberInits(stmts, newExpression, newLocal, newLocalPositions, classType, className);
+        return { value: newLocal, valueOriginalPositions: newLocalPositions, stmts: stmts };
+    }
+    /**
+     *Generate C++code representation of constructor calls and member initialization, and add related statements to stmts.
+     * Extracted tail logic: construction call+special case processing+member initialization
+     *@ param stmts - an array that stores the generated statement nodes
+     *@ param newExpression - C++AST node representing new expression
+     *@ param newLocal - local variable representing the newly created object
+     *@ param newLocalPositions - the location information of the new local variable in the source code
+     *@ param constructorMethodSignature - constructor's method signature
+     *@ param className - the name of the current class, which is used for special processing of certain types (such as napi_property_descriptor)
+     */
+    cxxEmitCtorInvokeAndMemberInits(stmts, newExpression, newLocal, newLocalPositions, classType, className) {
+        // 对象构造，使用 invokeStmt 表达
+        const constructArgs = (() => {
+            var _a, _b;
+            let args = newExpression.inner;
+            if (newExpression.kind === ArkCxxAstNode_1.astKind.CXXNewExpr && ((_a = newExpression.inner[0]) === null || _a === void 0 ? void 0 : _a.kind) === ArkCxxAstNode_1.astKind.CXXConstructExpr) {
+                return [...newExpression.inner[0].inner];
+            }
+            else if (newExpression.kind === ArkCxxAstNode_1.astKind.CompoundLiteralExpr) {
+                return this.getConstructArgs(args);
+            }
+            else if (
+            // if case : struct LargeStruct s;, inner.length is 0, so we need to avoid it
+            newExpression.kind === ArkCxxAstNode_1.astKind.CXXConstructExpr &&
+                newExpression.type.qualType.startsWith('struct') &&
+                args.length > 0 && ((_b = args[0].inner[0]) === null || _b === void 0 ? void 0 : _b.kind) === ArkCxxAstNode_1.astKind.CompoundLiteralExpr) {
+                return this.getConstructArgs(args[0].inner[0].inner);
+            }
+            else if (newExpression.kind === ArkCxxAstNode_1.astKind.InitListExpr) {
+                return this.getConstructArgs(newExpression);
+            }
+            return args.filter(arg => (arg === null || arg === void 0 ? void 0 : arg.kind) !== ArkCxxAstNode_1.astKind.TemplateRef &&
+                (arg === null || arg === void 0 ? void 0 : arg.kind) !== ArkCxxAstNode_1.astKind.NamespaceRef &&
+                (arg === null || arg === void 0 ? void 0 : arg.kind) !== ArkCxxAstNode_1.astKind.TypeRef);
+        })();
+        const { args: argValues, argPositions } = this.cxxParseArguments(stmts, constructArgs);
+        const constructorMethodSignature = this.getConstructorSignatureByClassTypeAndArgs(classType, argValues);
+        const instanceInvokeExpr = new Expr_1.ArkInstanceInvokeExpr(newLocal, constructorMethodSignature, argValues);
+        const invokeStmt = new Stmt_1.ArkInvokeStmt(instanceInvokeExpr);
+        const instanceInvokeExprPositions = [newLocalPositions[0], ...newLocalPositions, ...argPositions];
+        invokeStmt.setOperandOriginalPositions(instanceInvokeExprPositions);
+        stmts.push(invokeStmt);
+        // Processing the interface between cpp and ts
+        if (className === 'napi_property_descriptor') {
+            (0, ModelUtils_2.setTs2CxxFuncMapOfClass)(argValues, false, this.declaringMethod);
+        }
+    }
+    getConstructorSignatureByClassTypeAndArgs(classType, args) {
+        const file = this.declaringMethod.getDeclaringArkFile();
+        const arkClass = file.getClass(classType.getClassSignature());
+        const constructorMethodSubSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSubSignatureFromMethodName(TSConst_1.CONSTRUCTOR_NAME);
+        if (!arkClass) {
+            return new ArkSignature_1.MethodSignature(ArkSignatureBuilder_1.ArkSignatureBuilder.buildClassSignatureFromClassName(classType.getClassSignature().getClassName()), constructorMethodSubSignature);
+        }
+        const constructors = arkClass.getMethodsWithName(TSConst_1.CONSTRUCTOR_NAME);
+        if (constructors.length === 0) {
+            return new ArkSignature_1.MethodSignature(classType.getClassSignature(), constructorMethodSubSignature);
+        }
+        else if (constructors.length === 1) {
+            return constructors[0].getSignature();
+        }
+        const argsStr = args.map(arg => arg.getType().toString());
+        for (const constructor of constructors) {
+            const paramTypes = constructor.getSignature().getMethodSubSignature().getParameterTypes();
+            if (paramTypes.length !== args.length) {
+                continue;
+            }
+            for (const [idx, paramType] of paramTypes.entries()) {
+                const paramTypeStr = paramType.toString();
+                if (!paramTypeStr.includes(argsStr[idx]) && !argsStr[idx].includes(paramTypeStr)) {
+                    break;
+                }
+                if (idx === paramTypes.length - 1) {
+                    return constructor.getSignature();
+                }
+            }
+        }
+        return new ArkSignature_1.MethodSignature(classType.getClassSignature(), constructorMethodSubSignature);
+    }
+    getConstructArgs(constructArgs) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        // 1) Regularize to "parameter array"
+        let arr;
+        if (Array.isArray(constructArgs)) {
+            arr = constructArgs;
+        }
+        else if (constructArgs.kind === ArkCxxAstNode_1.astKind.InitListExpr) {
+            arr = (_a = constructArgs.inner) !== null && _a !== void 0 ? _a : [];
+        }
+        else {
+            // Parameters of some scenarios (such as CXXConstructExpr) may be placed in InitListExpr of inner [1]
+            arr = (_b = constructArgs.inner) !== null && _b !== void 0 ? _b : [];
+        }
+        // 2) If the second element itself is InitListExpr, take its inner as the real parameter
+        if (((_c = arr[1]) === null || _c === void 0 ? void 0 : _c.kind) === ArkCxxAstNode_1.astKind.InitListExpr) {
+            arr = (_d = arr[1].inner) !== null && _d !== void 0 ? _d : [];
+        }
+        // 3) If there is "implicit conversion" (original logic: check whether the second element is ImplicitCastExpr)
+        const useInner1 = ((_e = arr[1]) === null || _e === void 0 ? void 0 : _e.kind) === ArkCxxAstNode_1.astKind.ImplicitCastExpr;
+        // 4) Generate a new parameter list (equivalent to the original logic)
+        const newConstructArgs = [];
+        for (let i = 0; i < arr.length; i++) {
+            if (useInner1) {
+                const inner1 = (_g = (_f = arr[i]) === null || _f === void 0 ? void 0 : _f.inner) === null || _g === void 0 ? void 0 : _g[1];
+                newConstructArgs.push(inner1 !== null && inner1 !== void 0 ? inner1 : arr[i]); // 防御：缺少 inner[1] 时退回 arr[i]
+            }
+            else {
+                newConstructArgs.push(arr[i]);
+            }
+        }
+        return newConstructArgs;
+    }
+    /**
+     *Get the class name of the new expression
+     *@ param newExpression - new expression node of CxxAstNode type
+     *@ returns the processed class name string
+     */
+    getNewExpressionClassName(newExpression) {
+        let oriType = '';
+        if (newExpression.type.desugaredQualType) {
+            oriType = newExpression.type.desugaredQualType.replace(Builtin_2.BuiltinCxx.ANONYMOUS_NAMESPACE_REF, '');
+        }
+        else if (newExpression.type.qualType) {
+            oriType = newExpression.type.qualType;
+        }
+        else if (newExpression.code) {
+            oriType = newExpression.code;
+        }
+        oriType = this.removeOutermostTemplateArgs(oriType);
+        if ((0, builderUtils_1.isCXXSTLContainer)(oriType)) {
+            return oriType;
+        }
+        return oriType.replace(/[()]|\ \*|struct\ |union\ |const\ /g, '');
+    }
+    /**
+     *Remove the outermost template parameter (angle brackets and their contents) from the string
+     *@ param typeStr is a type string containing template parameters
+     *@ returns string after removing the outermost template parameter
+     */
+    removeOutermostTemplateArgs(typeStr) {
+        // Find the position of the first '<'
+        const start = typeStr.indexOf('<');
+        if (start === -1) {
+            return typeStr; // Cannot find '<', return the original string directly
+        }
+        let bracketCount = 1;
+        let end = -1;
+        // Starting from the first '<', search and calculate bracket matches
+        for (let i = start + 1; i < typeStr.length; i++) {
+            if (typeStr[i] === '<') {
+                bracketCount++;
+            }
+            else if (typeStr[i] === '>') {
+                bracketCount--;
+                if (bracketCount === 0) {
+                    end = i;
+                    break;
+                }
+            }
+        }
+        // If a matching ending '>' is found, remove this paragraph
+        if (end !== -1) {
+            return typeStr.substring(0, start) + typeStr.substring(end + 1);
+        }
+        return typeStr;
+    }
+    /**
+     *Convert the new array expression of C++to ValueAndStmts
+     *@ param newArrayExpression - C++AST node, representing new array expression
+     *@ returns ValueAndStmts object, including converted values and related statements
+     */
+    cxxNewArrayExpressionToValueAndStmts(newArrayExpression) {
+        let baseType = Type_1.UnknownType.getInstance();
+        if (newArrayExpression.type.qualType) {
+            const argumentType = (0, builderUtils_1.cxxNode2Type)(newArrayExpression, this.declaringMethod);
+            if (!(argumentType instanceof Type_1.AnyType || argumentType instanceof Type_1.UnknownType)) {
+                baseType = argumentType;
+            }
+        }
+        const stmts = [];
+        const { args: argumentValues, argPositions: argPositions, } = this.cxxParseArguments(stmts, newArrayExpression.inner);
+        let argumentsLength = newArrayExpression.inner ? newArrayExpression.inner.length : 0;
+        let arrayLengthValue;
+        let fromLiteral; // Does it contain specific elements
+        let arrayLengthPosition = Position_1.FullPosition.DEFAULT;
+        if (argumentsLength === 1 && (argumentValues[0].getType() instanceof Type_1.NumberType || argumentValues[0].getType() instanceof Type_1.UnknownType)) {
+            arrayLengthValue = argumentValues[0];
+            arrayLengthPosition = argPositions[0];
+            fromLiteral = false;
+        }
+        else {
+            arrayLengthValue = ValueUtil_1.CxxValueUtil.getOrCreateNumberConst(argumentsLength);
+            fromLiteral = true;
+        }
+        if (baseType instanceof Type_1.UnknownType) {
+            if (argumentsLength > 1 && !(argumentValues[0].getType() instanceof Type_1.UnknownType)) {
+                baseType = argumentValues[0].getType();
+            }
+            else {
+                baseType = Type_1.AnyType.getInstance();
+            }
+        }
+        const newArrayExprPosition = Position_1.FullPosition.cxxBuildFromNode(newArrayExpression, this.cxxSourceFile);
+        return this.cxxGenerateArrayExprAndStmts(baseType, arrayLengthValue, arrayLengthPosition, argumentValues, argPositions, stmts, newArrayExprPosition, fromLiteral);
+    }
+    /**
+     *Convert C++array literal expression to ValueAndStmts
+     *@ param arrayLiteralExpression - Array literal node in C++abstract syntax tree
+     *@ returns The ValueAndStmts object containing the converted value and related statements
+     */
+    cxxArrayLiteralExpressionToValueAndStmts(arrayLiteralExpression, dimensions, isInitZero) {
+        var _a, _b, _c, _d;
+        const stmts = [];
+        const elementTypes = new Set();
+        const elementValues = [];
+        const elementPositions = [];
+        const oriType = arrayLiteralExpression.type.qualType;
+        let arrayLength = 0; // Indicate the length of the array
+        let elementsNumber = 0; // Indicates the total number of elements included
+        if (!dimensions) {
+            // Obtain dimensional information
+            dimensions = this.getArrayDimensions(oriType);
+        }
+        arrayLength = (_a = dimensions[0]) !== null && _a !== void 0 ? _a : arrayLiteralExpression.inner.length;
+        elementsNumber = (_b = dimensions.reduce((acc, cur) => acc * cur, 1)) !== null && _b !== void 0 ? _b : arrayLength;
+        dimensions.shift();
+        isInitZero = (((_c = arrayLiteralExpression.inner) === null || _c === void 0 ? void 0 : _c.length) === 1 && arrayLiteralExpression.inner[0].code === '0' ||
+            ((_d = arrayLiteralExpression.inner) === null || _d === void 0 ? void 0 : _d.length) === 0);
+        this.getArrayLiteralExpression(arrayLiteralExpression, stmts, elementTypes, elementValues, elementPositions, dimensions, isInitZero);
+        if ((0, builderUtils_1.isCxxFunctionPointer)(oriType)) {
+            // If it's an array of function pointers, the array symbols in the type should be removed here before resolving for the base type.
+            arrayLiteralExpression.type.qualType = arrayLiteralExpression.type.qualType.replace(/\[.*?\]/g, '');
+        }
+        let baseType = (0, builderUtils_1.cxxNode2Type)(arrayLiteralExpression, this.declaringMethod);
+        arrayLiteralExpression.type.qualType = oriType;
+        if (baseType === Type_1.UnknownType.getInstance()) {
+            // If the type is uncertain, it is regarded as an unknown reference type
+            return this.cxxNewExpressionToValueAndStmts(arrayLiteralExpression);
+        }
+        const newArrayExprPosition = Position_1.FullPosition.cxxBuildFromNode(arrayLiteralExpression, this.cxxSourceFile);
+        return this.cxxGenerateArrayExprAndStmts(baseType, ValueUtil_1.CxxValueUtil.getOrCreateNumberConst(arrayLength), Position_1.FullPosition.DEFAULT, elementValues, elementPositions, stmts, newArrayExprPosition, true, elementsNumber, isInitZero);
+    }
+    // Analyze array dimension information
+    getArrayDimensions(declaration) {
+        // Extract all dimensional numbers using regular expressions
+        const dimensions = declaration.match(/\[(\d+)\]/g);
+        if (!dimensions) {
+            return [];
+        }
+        // Parse numbers and return a dimension array
+        return dimensions
+            .map(dim => parseInt(dim.replace(/[\[\]]/g, '')));
+    }
+    /**
+     *Process array literal expression and convert it to intermediate representation
+     *@ param arrayLiteralExpression array literal expression node
+     *@ param stmts is used to collect the generated statement list
+     *@ param elementTypes is used to collect the collection of array element types
+     *@ param elementValues is used to collect the list of array element values
+     *@ param elementPositions is used to collect the list of array element position information
+     */
+    getArrayLiteralExpression(arrayLiteralExpression, stmts, elementTypes, elementValues, elementPositions, dimensions, isInitZero) {
+        for (const element of arrayLiteralExpression.inner) {
+            // If there is still dimension information in the array, build an internal array
+            let { value: elementValue, valueOriginalPositions: elementPosition, stmts: elementStmts } = dimensions.length > 0 ? this.cxxArrayLiteralExpressionToValueAndStmts(element, dimensions) : this.cxxNodeToValueAndStmts(element);
+            stmts.push(...elementStmts);
+            if (IRUtils_1.IRUtils.moreThanOneAddress(elementValue)) {
+                ({
+                    value: elementValue,
+                    valueOriginalPositions: elementPosition,
+                    stmts: elementStmts,
+                } = this.ArkCxxIRTransformer.generateAssignStmtForValue(elementValue, elementPosition));
+                stmts.push(...elementStmts);
+            }
+            elementValues.push(elementValue);
+            elementTypes.add(elementValue.getType());
+            elementPositions.push(elementPosition[0]);
+        }
+    }
+    /**
+     *Generate IR expressed by C++array
+     *
+     *@ param baseType - the basic type of the array element
+     *@ param arrayLengthValue - value object of array length
+     *@ param arrayLengthPosition - position information of array length
+     *@ param arrayLength - the actual length of the array
+     *@ param initializerValues - array initialization value list
+     *@ param initializerPositions - List of location information of initialization values
+     *@ param currStmts - List of existing statements
+     *@ param newArrayExprPosition - position information of the new array expression
+     *@ param fromLiteral - whether from literal
+     *@ returns The ValueAndStmts object containing values and statements
+     */
+    cxxGenerateArrayExprAndStmts(baseType, arrayLengthValue, arrayLengthPosition, initializerValues, initializerPositions, currStmts, newArrayExprPosition, fromLiteral, elementsNumber, isInitZero) {
+        var _a;
+        const stmts = [...currStmts];
+        const newArrayExpr = new Expr_2.ArkCxxNewArrayExpr(baseType, arrayLengthValue, fromLiteral, elementsNumber);
+        const newArrayExprPositions = [newArrayExprPosition, arrayLengthPosition];
+        const { value: arrayLocal, valueOriginalPositions: arrayLocalPositions, stmts: arrayStmts, } = this.ArkCxxIRTransformer.generateAssignStmtForValue(newArrayExpr, newArrayExprPositions);
+        stmts.push(...arrayStmts);
+        const initializerZero = ValueUtil_1.CxxValueUtil.getOrCreateNumberConst(0);
+        for (let i = 0; i < initializerValues.length; i++) {
+            // If the array is initialized with 0 or does not contain specific elements, do not create element statements
+            if (isInitZero || !fromLiteral) {
+                break;
+            }
+            const indexValue = ValueUtil_1.CxxValueUtil.getOrCreateNumberConst(i);
+            const arrayRef = new Ref_1.ArkArrayRef(arrayLocal, indexValue);
+            const arrayRefPositions = [arrayLocalPositions[0], ...arrayLocalPositions, Position_1.FullPosition.DEFAULT];
+            const assignStmt = new Stmt_1.ArkAssignStmt(arrayRef, initializerValues[i]);
+            assignStmt.setOperandOriginalPositions([...arrayRefPositions, initializerPositions[i]]);
+            stmts.push(assignStmt);
+        }
+        if (isInitZero) {
+            // When the array is initialized to 0, initialize Values only contains one element for use by the upper layer
+            let initExpr = new Expr_2.ArkCxxInitArrayExpr((_a = initializerValues[0]) !== null && _a !== void 0 ? _a : initializerZero);
+            let assignStmt = new Stmt_1.ArkAssignStmt(arrayLocal, initExpr);
+            stmts.push(assignStmt);
+        }
+        return {
+            value: arrayLocal,
+            valueOriginalPositions: arrayLocalPositions,
+            stmts: stmts,
+        };
+    }
+    /**
+     *Converts C++prefix unary expression nodes to IR values and statement lists.
+     *
+     *@ param prefixUnaryExpression - prefix unary expression node in C++AST
+     *@ returns The object containing the converted value and the generated statement list
+     */
+    cxxPrefixUnaryExpressionToValueAndStmts(prefixUnaryExpression) {
+        var _a;
+        const stmts = [];
+        let { value: operandValue, valueOriginalPositions: operandPositions, stmts: operandStmts } = this.cxxNodeToValueAndStmts(prefixUnaryExpression.inner[0]);
+        stmts.push(...operandStmts);
+        if (IRUtils_1.IRUtils.moreThanOneAddress(operandValue)) {
+            ({
+                value: operandValue,
+                valueOriginalPositions: operandPositions,
+                stmts: operandStmts,
+            } = this.ArkCxxIRTransformer.generateAssignStmtForValue(operandValue, operandPositions));
+            stmts.push(...operandStmts);
+        }
+        const operatorToken = (_a = prefixUnaryExpression.opcode) !== null && _a !== void 0 ? _a : ''; // Optional fields default to empty strings.
+        let exprPositions = [Position_1.FullPosition.cxxBuildFromNode(prefixUnaryExpression, this.cxxSourceFile)];
+        if (operatorToken === '++' || operatorToken === '--') {
+            const binaryOperator = operatorToken === '++' ? Expr_1.NormalBinaryOperator.Addition : Expr_1.NormalBinaryOperator.Subtraction;
+            const binopExpr = new Expr_2.ArkCxxNormalBinOpExpr(operandValue, ValueUtil_1.CxxValueUtil.getOrCreateNumberConst(1), binaryOperator);
+            exprPositions.push(...operandPositions, Position_1.FullPosition.DEFAULT);
+            const assignStmt = new Stmt_1.ArkAssignStmt(operandValue, binopExpr);
+            assignStmt.setOperandOriginalPositions([...operandPositions, ...exprPositions]);
+            stmts.push(assignStmt);
+            return {
+                value: operandValue,
+                valueOriginalPositions: operandPositions,
+                stmts: stmts,
+            };
+        }
+        else if (operatorToken === '+') {
+            return {
+                value: operandValue,
+                valueOriginalPositions: operandPositions,
+                stmts: stmts,
+            };
+        }
+        else {
+            let unopExpr;
+            const operator = ArkIRTransformer_1.ArkCxxIRTransformer.cxxTokenToUnaryOperator(operatorToken);
+            if (operator) {
+                unopExpr = new Expr_1.ArkUnopExpr(operandValue, operator);
+                exprPositions.push(...operandPositions);
+            }
+            else {
+                unopExpr = ValueUtil_1.CxxValueUtil.getUndefinedConst();
+                exprPositions = [Position_1.FullPosition.DEFAULT];
+            }
+            return {
+                value: unopExpr,
+                valueOriginalPositions: exprPositions,
+                stmts: stmts,
+            };
+        }
+    }
+    /**
+     *Convert a C++suffix unary expression to a sequence of values and statements
+     *
+     *@ param postfixUnaryExpression - suffix unary expression node in C++AST
+     *@ returns The object containing the converted value and related statements
+     */
+    cxxPostfixUnaryExpressionToValueAndStmts(postfixUnaryExpression) {
+        var _a, _b, _c;
+        const stmts = [];
+        let { value: operandValue, valueOriginalPositions: operandPositions, stmts: exprStmts, } = this.cxxNodeToValueAndStmts(postfixUnaryExpression.inner[0]);
+        stmts.push(...exprStmts);
+        if (IRUtils_1.IRUtils.moreThanOneAddress(operandValue)) {
+            ({
+                value: operandValue, valueOriginalPositions: operandPositions, stmts: exprStmts,
+            } = this.ArkCxxIRTransformer.generateAssignStmtForValue(operandValue, operandPositions));
+            stmts.push(...exprStmts);
+        }
+        let value = undefined;
+        let exprPositions = [Position_1.FullPosition.cxxBuildFromNode(postfixUnaryExpression, this.cxxSourceFile)];
+        const operatorToken = postfixUnaryExpression.opcode;
+        // Use temporary variables to store the value before self increment, and avoid this expression for some non assignment operation scenarios
+        if (operatorToken === '++' || operatorToken === '--') {
+            const needAssign = [
+                ArkCxxAstNode_1.astKind.VarDecl, ArkCxxAstNode_1.astKind.BinaryOperator, ArkCxxAstNode_1.astKind.BinaryConditionalOperator,
+                ArkCxxAstNode_1.astKind.ConditionalOperator, ArkCxxAstNode_1.astKind.ArraySubscriptExpr,
+            ];
+            let parent = (_c = ((_a = postfixUnaryExpression.parent) !== null && _a !== void 0 ? _a : (_b = postfixUnaryExpression.getParent) === null || _b === void 0 ? void 0 : _b.call(postfixUnaryExpression, true))) !== null && _c !== void 0 ? _c : null;
+            if (parent && needAssign.includes(parent.kind)) {
+                let { value: tempValue, stmts: tempStmts, } = this.arkIRTransformer.generateAssignStmtForValue(operandValue, exprPositions);
+                stmts.push(...tempStmts);
+                value = tempValue;
+            }
+            const binaryOperator = operatorToken === '++' ? Expr_1.NormalBinaryOperator.Addition : Expr_1.NormalBinaryOperator.Subtraction;
+            const binopExpr = new Expr_2.ArkCxxNormalBinOpExpr(operandValue, ValueUtil_1.CxxValueUtil.getOrCreateNumberConst(1), binaryOperator);
+            exprPositions.push(...operandPositions, Position_1.FullPosition.DEFAULT);
+            const assignStmt = new Stmt_1.ArkAssignStmt(operandValue, binopExpr);
+            assignStmt.setOperandOriginalPositions([...operandPositions, ...exprPositions]);
+            stmts.push(assignStmt);
+            if (value === undefined) {
+                value = operandValue;
+            }
+        }
+        else {
+            value = ValueUtil_1.CxxValueUtil.getUndefinedConst();
+            exprPositions = [Position_1.FullPosition.DEFAULT];
+        }
+        return {
+            value: value, valueOriginalPositions: exprPositions, stmts: stmts,
+        };
+    }
+    declStmtToValueAndStmts(decl) {
+        const stmt = [];
+        let value = ValueUtil_2.ValueUtil.getUndefinedConst();
+        let fullPositions = [];
+        for (const node of decl.inner) {
+            const valueAndStmts = this.cxxNodeToValueAndStmts(node);
+            stmt.push(...valueAndStmts.stmts);
+            value = valueAndStmts.value;
+            fullPositions.push(...valueAndStmts.valueOriginalPositions);
+        }
+        return {
+            value: value,
+            valueOriginalPositions: fullPositions,
+            stmts: stmt,
+        };
+    }
+    /**
+     *Convert C++variable declarations to combinations of values and statements
+     *@ param variableDeclaration - C++variable declaration node
+     *@ param isConst - whether it is a constant declaration
+     *@ param needRightOp - Whether the right operand is required, the default is true
+     *@ returns the ValueAndStmts object containing values and statements
+     */
+    cxxVariableDeclarationToValueAndStmts(variableDeclaration, needRightOp = true) {
+        let isConst = variableDeclaration.type.qualType.includes('const');
+        const leftOpNode = variableDeclaration;
+        let rightOpNode = undefined;
+        if (variableDeclaration.inner !== null && variableDeclaration.inner.length !== 0) {
+            rightOpNode = nodeInnerNode(variableDeclaration);
+        }
+        // In this case, the non assigned information on the right node needs to be discarded
+        if (this.isCxxArray(leftOpNode.type.qualType) && (rightOpNode === null || rightOpNode === void 0 ? void 0 : rightOpNode.kind) === ArkCxxAstNode_1.astKind.IntegerLiteral) {
+            rightOpNode = undefined;
+        }
+        const declarationType = variableDeclaration.type ? (0, builderUtils_1.cxxNode2Type)(variableDeclaration, this.declaringMethod) : Type_1.UnknownType.getInstance();
+        const assignment = this.cxxAssignmentToValueAndStmts(leftOpNode, rightOpNode, true, isConst, declarationType, needRightOp);
+        if (declarationType instanceof Type_2.ReferenceType && assignment.stmts[0] instanceof Stmt_1.ArkAssignStmt) {
+            declarationType.setSourceValue(assignment.stmts[0].getRightOp());
+        }
+        return assignment;
+    }
+    isCxxArray(qualType) {
+        const pattern = /\[.*\]/;
+        return pattern.test(qualType);
+    }
+    /**
+     *Process C++assignment expressions and convert them into ValueAndStmts structures.
+     *
+     *@ param leftOpNode The AST node of the left operand
+     *@ param rightOpNode The AST node of the right operand, which may be undefined
+     *@ param variableDefFlag indicates whether the variable is defined
+     *@ param isConst indicates whether it is a constant
+     *@ param declarationType Declared type
+     *@ param needRightOp Whether to process the right operand, the default is true
+     *@ returns the ValueAndStmts object containing the value, original position and statement list
+     */
+    cxxAssignmentToValueAndStmts(leftOpNode, rightOpNode, variableDefFlag, isConst, declarationType, needRightOp = true) {
+        let leftValueAndStmts;
+        if (leftOpNode.kind.toString() === ArkCxxAstNode_1.astKind.VarDecl) {
+            leftValueAndStmts = this.cxxIdentifierToValueAndStmts(leftOpNode, variableDefFlag);
+        }
+        else {
+            leftValueAndStmts = this.cxxNodeToValueAndStmts(leftOpNode);
+        }
+        const { value: leftValue, valueOriginalPositions: leftPositions, stmts: leftStmts } = leftValueAndStmts;
+        let stmts = [];
+        if (needRightOp) {
+            const { value: rightValue, valueOriginalPositions: rightPositions, stmts: rightStmts } = this.cxxAssignmentRightOpToValueAndStmts(rightOpNode, leftValue);
+            if (leftValue instanceof Local_1.Local) {
+                if (variableDefFlag) {
+                    leftValue.setConstFlag(isConst);
+                    leftValue.setType(declarationType);
+                }
+                if ((leftValue.getType() instanceof Type_1.UnknownType || leftValue.getType() instanceof Type_1.UnclearReferenceType) &&
+                    !(rightValue.getType() instanceof Type_1.UnknownType) && !(rightValue.getType() instanceof Type_1.UndefinedType)) {
+                    leftValue.setType(rightValue.getType());
+                }
+            }
+            const assignStmt = new Stmt_1.ArkAssignStmt(leftValue, rightValue);
+            assignStmt.setOperandOriginalPositions([...leftPositions, ...rightPositions]);
+            if (leftOpNode.kind === ArkCxxAstNode_1.astKind.InitListExpr) {
+                stmts.push(...rightStmts);
+                stmts.push(assignStmt);
+                stmts.push(...leftStmts);
+            }
+            else {
+                stmts.push(...rightStmts);
+                stmts.push(...leftStmts);
+                stmts.push(assignStmt);
+            }
+        }
+        else {
+            stmts = leftStmts;
+        }
+        return {
+            value: leftValue,
+            valueOriginalPositions: leftPositions,
+            stmts: stmts,
+        };
+    }
+    /**
+     *CPP implementation of converting the right operand node to a list of values and statements
+     *@ param rightOpNode The AST node of the right operand, which may be undefined
+     *@ param leftValue Left value object
+     *@ returns Objects containing values, location information, and statement lists
+     */
+    cxxAssignmentRightOpToValueAndStmts(rightOpNode, leftValue) {
+        let rightValue;
+        let rightPositions;
+        let tempRightStmts = [];
+        const rightStmts = [];
+        if (rightOpNode) {
+            ({
+                value: rightValue,
+                valueOriginalPositions: rightPositions,
+                stmts: tempRightStmts,
+            } = this.cxxNodeToValueAndStmts(rightOpNode));
+            rightStmts.push(...tempRightStmts);
+        }
+        else {
+            rightValue = ValueUtil_1.CxxValueUtil.getUndefinedConst();
+            rightPositions = [Position_1.FullPosition.DEFAULT];
+        }
+        if (IRUtils_1.IRUtils.moreThanOneAddress(leftValue) && IRUtils_1.IRUtils.moreThanOneAddress(rightValue)) {
+            ({
+                value: rightValue,
+                valueOriginalPositions: rightPositions,
+                stmts: tempRightStmts,
+            } = this.ArkCxxIRTransformer.generateAssignStmtForValue(rightValue, rightPositions));
+            rightStmts.push(...tempRightStmts);
+        }
+        return {
+            value: rightValue,
+            valueOriginalPositions: rightPositions,
+            stmts: rightStmts,
+        };
+    }
+    /**
+     *Convert the C++AST node to a single address value and statement list
+     *@ param node - C++AST node to be converted
+     *@ returns An object containing a list of values, original positions, and statements
+     */
+    cxxNodeToSingleAddressValueAndStmts(node) {
+        const allStmts = [];
+        let { value, valueOriginalPositions, stmts } = this.cxxNodeToValueAndStmts(node);
+        allStmts.push(...stmts);
+        if (IRUtils_1.IRUtils.moreThanOneAddress(value)) {
+            ({
+                value,
+                valueOriginalPositions,
+                stmts,
+            } = this.arkIRTransformer.generateAssignStmtForValue(value, valueOriginalPositions));
+            allStmts.push(...stmts);
+        }
+        return { value, valueOriginalPositions, stmts: allStmts };
+    }
+    /**
+     *Converts a C++binary expression node to a list of values and statements.
+     *In assignment patterns, the left operand will be an array literal expression
+     *In assignment patterns, the left operand will be an object literal expression
+     *@ param binaryExpression - Binary expression node in C++AST
+     *@ returns The ValueAndStmts object containing calculated values and related statements
+     */
+    cxxBinaryExpressionToValueAndStmts(binaryExpression) {
+        var _a;
+        const operatorToken = (_a = binaryExpression.opcode) !== null && _a !== void 0 ? _a : '!=';
+        const binaryExpressionLeft = binaryExpression.inner[0];
+        const binaryExpressionRight = binaryExpression.inner[1];
+        if (operatorToken === '=') {
+            const leftType = (0, builderUtils_1.cxxNode2Type)(binaryExpressionLeft, undefined);
+            return this.cxxAssignmentToValueAndStmts(binaryExpressionLeft, binaryExpressionRight, false, false, leftType, true);
+        }
+        const stmts = [];
+        const binaryExpressionPosition = Position_1.FullPosition.cxxBuildFromNode(binaryExpression, this.cxxSourceFile);
+        const { value: opValue1, valueOriginalPositions: opPositions1, stmts: opStmts1, } = this.cxxNodeToSingleAddressValueAndStmts(binaryExpressionLeft);
+        stmts.push(...opStmts1);
+        const { value: opValue2, valueOriginalPositions: opPositions2, stmts: opStmts2, } = this.cxxNodeToSingleAddressValueAndStmts(binaryExpressionRight);
+        stmts.push(...opStmts2);
+        let exprValue;
+        let exprValuePositions = [binaryExpressionPosition];
+        // In scenarios where the operator is', 'and' value 'is the rightmost value
+        if (operatorToken === ',') {
+            exprValue = opValue2;
+            exprValuePositions.push(...opPositions1, ...opPositions2);
+        }
+        else if (operatorToken) {
+            if (this.isRelationalOperator(operatorToken)) {
+                exprValue = new Expr_1.ArkConditionExpr(opValue1, opValue2, operatorToken);
+            }
+            else {
+                exprValue = new Expr_2.ArkCxxNormalBinOpExpr(opValue1, opValue2, operatorToken);
+                const exprTye = (0, builderUtils_1.cxxNode2Type)(binaryExpression, undefined, undefined);
+                exprValue.setCxxType(exprTye);
+            }
+            exprValuePositions.push(...opPositions1, ...opPositions2);
+        }
+        else {
+            exprValue = ValueUtil_1.CxxValueUtil.getUndefinedConst();
+            exprValuePositions.push(binaryExpressionPosition);
+        }
+        return {
+            value: exprValue,
+            valueOriginalPositions: exprValuePositions,
+            stmts: stmts,
+        };
+    }
+    /**
+     *Convert compound assignment expressions (such as+=, -=, etc.) in C++to values and statement lists in intermediate representation (IR).
+     *
+     *@ param binaryExpression represents the C++AST node of the compound assignment operation
+     *@ returns an object containing the calculated value, the original location information, and the generated statement list
+     */
+    cxxCompoundAssignmentToValueAndStmts(binaryExpression) {
+        var _a;
+        const stmts = [];
+        let { value: leftValue, valueOriginalPositions: leftPositions, stmts: leftStmts, } = this.cxxNodeToValueAndStmts(binaryExpression.inner[0]);
+        stmts.push(...leftStmts);
+        let { value: rightValue, valueOriginalPositions: rightPositions, stmts: rightStmts, } = this.cxxNodeToValueAndStmts(binaryExpression.inner[1]);
+        stmts.push(...rightStmts);
+        if (IRUtils_1.IRUtils.moreThanOneAddress(leftValue) && IRUtils_1.IRUtils.moreThanOneAddress(rightValue)) {
+            const { value: newRightValue, valueOriginalPositions: newRightPositions, stmts: rightStmts, } = this.ArkCxxIRTransformer.generateAssignStmtForValue(rightValue, rightPositions);
+            rightValue = newRightValue;
+            rightPositions = newRightPositions;
+            stmts.push(...rightStmts);
+        }
+        let leftOpValue;
+        let leftOpPositions;
+        const operator = this.cxxCcompoundAssignmentTokenToBinaryOperator((_a = binaryExpression.opcode) !== null && _a !== void 0 ? _a : '');
+        if (operator) {
+            const exprValue = new Expr_2.ArkCxxNormalBinOpExpr(leftValue, rightValue, operator);
+            const exprValuePosition = Position_1.FullPosition.cxxBuildFromNode(binaryExpression, this.cxxSourceFile);
+            const assignStmt = new Stmt_1.ArkAssignStmt(leftValue, exprValue);
+            assignStmt.setOperandOriginalPositions([...leftPositions, exprValuePosition, ...leftPositions, ...rightPositions]);
+            stmts.push(assignStmt);
+            leftOpValue = leftValue;
+            leftOpPositions = leftPositions;
+        }
+        else {
+            leftOpValue = ValueUtil_1.CxxValueUtil.getUndefinedConst();
+            leftOpPositions = [leftPositions[0]];
+        }
+        return {
+            value: leftOpValue,
+            valueOriginalPositions: leftOpPositions,
+            stmts: stmts,
+        };
+    }
+    /**
+     *Convert the compound assignment operator to the corresponding binary operator
+     *
+     *@ param token - compound assignment operator string
+     *@ returns The corresponding binary operator. If no match is found, null is returned
+     */
+    cxxCcompoundAssignmentTokenToBinaryOperator(token) {
+        switch (token) {
+            case CompoundBinaryOperator.AdditionEquals:
+                return Expr_1.NormalBinaryOperator.Addition;
+            case CompoundBinaryOperator.SubtractionEquals:
+                return Expr_1.NormalBinaryOperator.Subtraction;
+            case CompoundBinaryOperator.MultiplicationEquals:
+                return Expr_1.NormalBinaryOperator.Multiplication;
+            case CompoundBinaryOperator.DivisionEquals:
+                return Expr_1.NormalBinaryOperator.Division;
+            case CompoundBinaryOperator.RemainderEquals:
+                return Expr_1.NormalBinaryOperator.Remainder;
+            case CompoundBinaryOperator.LeftShiftEquals:
+                return Expr_1.NormalBinaryOperator.LeftShift;
+            case CompoundBinaryOperator.RightShiftEquals:
+                return Expr_1.NormalBinaryOperator.RightShift;
+            case CompoundBinaryOperator.BitwiseAndEquals:
+                return Expr_1.NormalBinaryOperator.BitwiseAnd;
+            case CompoundBinaryOperator.BitwiseOrEquals:
+                return Expr_1.NormalBinaryOperator.BitwiseOr;
+            case CompoundBinaryOperator.BitwiseXorEquals:
+                return Expr_1.NormalBinaryOperator.BitwiseXor;
+            default:
+        }
+        return null;
+    }
+    /**
+     *Convert C++conditional expression nodes to a combination of values and statements
+     *@ param condition - Condition node in C++abstract syntax tree
+     *@ returns Objects containing conditional expression values and related statements
+     */
+    cxxConditionToValueAndStmts(condition) {
+        const stmts = [];
+        let { value: conditionValue, valueOriginalPositions: conditionPositions, stmts: conditionStmts, } = this.cxxNodeToValueAndStmts(condition);
+        stmts.push(...conditionStmts);
+        let conditionExpr;
+        if (conditionValue instanceof Expr_1.AbstractBinopExpr && this.isRelationalOperator(conditionValue.getOperator())) {
+            const operator = conditionValue.getOperator();
+            conditionExpr = new Expr_1.ArkConditionExpr(conditionValue.getOp1(), conditionValue.getOp2(), operator);
+        }
+        else {
+            if (IRUtils_1.IRUtils.moreThanOneAddress(conditionValue)) {
+                ({
+                    value: conditionValue,
+                    valueOriginalPositions: conditionPositions,
+                    stmts: conditionStmts,
+                } = this.ArkCxxIRTransformer.generateAssignStmtForValue(conditionValue, conditionPositions));
+                stmts.push(...conditionStmts);
+            }
+            conditionExpr = new Expr_1.ArkConditionExpr(conditionValue, ValueUtil_1.CxxValueUtil.getOrCreateNumberConst(0), Expr_1.RelationalBinaryOperator.InEquality);
+            conditionPositions = [conditionPositions[0], ...conditionPositions, Position_1.FullPosition.DEFAULT];
+        }
+        return {
+            value: conditionExpr,
+            valueOriginalPositions: conditionPositions,
+            stmts: stmts,
+        };
+    }
+    parseFloatAsCxxFloat(s) {
+        const num = Number.parseFloat(s);
+        // perform a float32 round-trip using Float32Array to simulate C++ 'float' precision
+        const f32 = new Float32Array(1);
+        f32[0] = num;
+        return +f32[0].toFixed(5);
+    }
+    /**
+     *Convert literal nodes in C++AST into corresponding value and statement lists.
+     *Literals currently processed: integer, floating point, string, character, Boolean value, null pointer, address label
+     *@ param literalNode - an AST node representing a C++literal
+     *@ returns the object containing the value, original location information and statement list. If the node type cannot be processed, null is returned
+     */
+    cxxLiteralNodeToValueAndStmts(literalNode) {
+        var _a, _b;
+        const stmts = [];
+        const pos = [Position_1.FullPosition.cxxBuildFromNode(literalNode, this.cxxSourceFile)];
+        const S = (v) => v !== null && v !== void 0 ? v : '';
+        switch (literalNode.kind) {
+            case ArkCxxAstNode_1.astKind.IntegerLiteral: {
+                const num = (S(literalNode.value) || S(literalNode.code));
+                const constant = ValueUtil_1.CxxValueUtil.getOrCreateNumberConst(num ? num : 0);
+                return { value: constant, valueOriginalPositions: pos, stmts };
+            }
+            case ArkCxxAstNode_1.astKind.FloatingLiteral: {
+                const num = this.parseFloatAsCxxFloat(S(literalNode.value) || S(literalNode.code));
+                const constant = ValueUtil_1.CxxValueUtil.getOrCreateNumberConst(Number.isFinite(num) ? num : 0);
+                return { value: constant, valueOriginalPositions: pos, stmts };
+            }
+            case ArkCxxAstNode_1.astKind.StringLiteral: {
+                const constant = ValueUtil_1.CxxValueUtil.createStringConst(S(literalNode.value) || S(literalNode.code));
+                return { value: constant, valueOriginalPositions: pos, stmts };
+            }
+            case ArkCxxAstNode_1.astKind.CharacterLiteral: {
+                const constant = ValueUtil_1.CxxValueUtil.createCharConst(S(literalNode.code));
+                return { value: constant, valueOriginalPositions: pos, stmts };
+            }
+            case ArkCxxAstNode_1.astKind.CXXBoolLiteralExpr: {
+                const raw = ((_b = (_a = literalNode.value) !== null && _a !== void 0 ? _a : literalNode.code) !== null && _b !== void 0 ? _b : '').toString().trim().toLowerCase();
+                const b = raw === 'true' || raw === '1';
+                const constant = ValueUtil_1.CxxValueUtil.getBooleanConstant(b);
+                return { value: constant, valueOriginalPositions: pos, stmts };
+            }
+            case ArkCxxAstNode_1.astKind.CXXNullPtrLiteralExpr: {
+                const constant = Constant_1.NullConstant.getInstance();
+                return { value: constant, valueOriginalPositions: pos, stmts };
+            }
+            default: {
+                logger.warn(`ast node's syntaxKind is ${literalNode.kind}, not literalNode`);
+                return null;
+            }
+        }
+    }
+    static isCxxCompoundAssignmentOperator(op) {
+        return !!op && COMPOUND_BIN_OPS.has(op);
+    }
+    static isRelationalBinaryOperator(op) {
+        return Object.values(Expr_1.RelationalBinaryOperator).includes(op);
+    }
+}
+exports.ArkCxxValueTransformer = ArkCxxValueTransformer;