arkanalyzer 1.0.85 → 1.0.87

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

@@ -0,0 +1,925 @@
+"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.ArkCxxIRTransformer = void 0;
+const Expr_1 = require("../../../core/base/Expr");
+const Ref_1 = require("../../../core/base/Ref");
+const Local_1 = require("../../../core/base/Local");
+const Stmt_1 = require("../../../core/base/Stmt");
+const Type_1 = require("../../../core/base/Type");
+const ValueUtil_1 = require("./ValueUtil");
+const IRUtils_1 = require("./IRUtils");
+const EtsConst_1 = require("../../../core/common/EtsConst");
+const Position_1 = require("../../../core/base/Position");
+const ArkValueTransformer_1 = require("./ArkValueTransformer");
+const ArkSignature_1 = require("../../../core/model/ArkSignature");
+const Builtin_1 = require("./Builtin");
+const ArkSignatureBuilder_1 = require("../../../core/model/builder/ArkSignatureBuilder");
+const ArkIRTransformer_1 = require("../../../core/common/ArkIRTransformer");
+const TypeExpr_1 = require("../../../core/base/TypeExpr");
+const builderUtils_1 = require("../model/builder/builderUtils");
+const ModelUtils_1 = require("../../../core/common/ModelUtils");
+const ArkClass_1 = require("../../../core/model/ArkClass");
+const ArkClassBuilder_1 = require("../model/builder/ArkClassBuilder");
+const ArkCxxAstNode_1 = require("../ast/ArkCxxAstNode");
+const ValueUtil_2 = require("../../../core/common/ValueUtil");
+const Type_2 = require("../base/Type");
+const builderUtils_2 = require("../../../core/model/builder/builderUtils");
+const logger_1 = __importStar(require("../../../utils/logger"));
+const ArkFileBuilder_1 = require("../model/builder/ArkFileBuilder");
+const logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'ArkIRTransformer');
+function nodeInnerNode(node) {
+    if (node.inner && node.inner.length > 0) {
+        return node.inner[0];
+    }
+    console.log('unsupported node !');
+    return { kind: 'unsupported kind' };
+}
+class ArkCxxIRTransformer extends ArkIRTransformer_1.ArkIRTransformer {
+    constructor(sourceFile, declaringMethod) {
+        super(sourceFile, declaringMethod);
+        this.catchedExceptions = [];
+        this.cxxSourceFile = sourceFile;
+        this.ArkCxxValueTransformer = new ArkValueTransformer_1.ArkCxxValueTransformer(this, this.cxxSourceFile, this.declaringMethod);
+    }
+    getLocals() {
+        return this.ArkCxxValueTransformer.getLocals();
+    }
+    getGlobals() {
+        return this.ArkCxxValueTransformer.getGlobals();
+    }
+    getThisLocal() {
+        return this.ArkCxxValueTransformer.getThisLocal();
+    }
+    getAliasTypeMap() {
+        return this.ArkCxxValueTransformer.getAliasTypeMap();
+    }
+    prebuildStmts() {
+        const stmts = [];
+        let index = 0;
+        for (const methodParameter of this.declaringMethod.getParameters()) {
+            const parameterRef = new Ref_1.ArkParameterRef(index, methodParameter.getType());
+            stmts.push(new Stmt_1.ArkAssignStmt(this.ArkCxxValueTransformer.addNewLocal(methodParameter.getName(), parameterRef.getType()), parameterRef));
+            index++;
+        }
+        const thisRef = new Ref_1.ArkThisRef(this.ArkCxxValueTransformer.getThisLocal().getType());
+        stmts.push(new Stmt_1.ArkAssignStmt(this.ArkCxxValueTransformer.getThisLocal(), thisRef));
+        return stmts;
+    }
+    // Determine whether to generate temporary variable assignment statement based on operator
+    shouldGenerateCxxExtraAssignStmt(expression) {
+        if (expression.kind === ArkCxxAstNode_1.astKind.ParentExpr) {
+            return this.shouldGenerateCxxExtraAssignStmt(expression.inner[0]);
+        }
+        return !((expression.kind === ArkCxxAstNode_1.astKind.BinaryOperator && expression.opcode === '=') ||
+            ArkValueTransformer_1.ArkCxxValueTransformer.isCxxCompoundAssignmentOperator(expression.opcode) ||
+            expression.kind === ArkCxxAstNode_1.astKind.CXXNewExpr ||
+            expression.kind === ArkCxxAstNode_1.astKind.CallExpr ||
+            (expression.kind === ArkCxxAstNode_1.astKind.UnaryOperator && (expression.opcode === '++' || expression.opcode === '--')) ||
+            expression.kind === ArkCxxAstNode_1.astKind.CXXOperatorCallExpr ||
+            expression.kind === ArkCxxAstNode_1.astKind.CXXConstructExpr ||
+            expression.kind === ArkCxxAstNode_1.astKind.CXXCtorInitializer);
+    }
+    /** The main function for converting C++ AST nodes to Stmts */
+    cxxNodeToStmts(node) {
+        let stmts = [];
+        switch (node.kind) {
+            case ArkCxxAstNode_1.astKind.ParmVarDecl:
+                stmts = this.cxxParameterToStmts(node);
+                break;
+            case ArkCxxAstNode_1.astKind.BreakStmt:
+            case ArkCxxAstNode_1.astKind.ContinueStmt:
+            case ArkCxxAstNode_1.astKind.GotoStmt:
+                stmts = [];
+                break;
+            case ArkCxxAstNode_1.astKind.CXXRewrittenBinaryOperator:
+            case ArkCxxAstNode_1.astKind.BinaryOperator:
+            case ArkCxxAstNode_1.astKind.CallExpr:
+            case ArkCxxAstNode_1.astKind.CompoundAssignOperator:
+            case ArkCxxAstNode_1.astKind.CXXConstructExpr:
+            case ArkCxxAstNode_1.astKind.CXXOperatorCallExpr:
+            case ArkCxxAstNode_1.astKind.UnaryOperator:
+            case ArkCxxAstNode_1.astKind.RecoveryExpr:
+            case ArkCxxAstNode_1.astKind.CXXDeleteExpr:
+            case ArkCxxAstNode_1.astKind.AtomicCallExpr:
+            case ArkCxxAstNode_1.astKind.CXXCtorInitializer:
+                stmts = this.cxxExpressionStatementToStmts(node);
+                break;
+            case ArkCxxAstNode_1.astKind.DeclStmt:
+                stmts = this.cxxDeclStatementToStmts(node);
+                break;
+            case ArkCxxAstNode_1.astKind.VarDecl:
+                stmts = this.cxxVariableDeclarationListToStmts(node);
+                break;
+            case ArkCxxAstNode_1.astKind.CompoundStmt:
+                stmts = this.compoundToStmts(node);
+                break;
+            case ArkCxxAstNode_1.astKind.CXXMemberCallExpr:
+                stmts = this.memberCallExprToStmts(node);
+                break;
+            case ArkCxxAstNode_1.astKind.CXXCatchStmt:
+                stmts = this.cxxCatchClauseToStmts(node);
+                break;
+            case ArkCxxAstNode_1.astKind.CXXThrowExpr:
+                stmts = this.cxxThrowStatementToStmts(node);
+                break;
+            case ArkCxxAstNode_1.astKind.DoStmt:
+                stmts = this.cxxDoStatementToStmts(node);
+                break;
+            case ArkCxxAstNode_1.astKind.ExprWithCleanups:
+                stmts = this.expressionWithCleanup(node);
+                break;
+            case ArkCxxAstNode_1.astKind.ForStmt:
+                stmts = this.cxxForStatementToStmts(node);
+                break;
+            case ArkCxxAstNode_1.astKind.IfStmt:
+                stmts = this.cxxIfStatementToStmts(node);
+                break;
+            case ArkCxxAstNode_1.astKind.ReturnStmt:
+                stmts = this.cxxReturnStatementToStmts(node);
+                break;
+            case ArkCxxAstNode_1.astKind.WhileStmt:
+                stmts = this.cxxWhileStatementToStmts(node);
+                break;
+            case ArkCxxAstNode_1.astKind.CXXForRangeStmt:
+                stmts = this.forRangeStatementToStmts(node);
+                break;
+            case ArkCxxAstNode_1.astKind.TypedefDecl:
+            case ArkCxxAstNode_1.astKind.TypeAliasDecl:
+                stmts = this.typeDefDeclToStmts(node);
+                break;
+            case ArkCxxAstNode_1.astKind.TypeAliasTemplateDecl:
+                stmts = this.typeDefDeclToStmts(node);
+                break;
+            case ArkCxxAstNode_1.astKind.EnumDecl:
+            case ArkCxxAstNode_1.astKind.CXXRecordDecl:
+                stmts = this.cxxClassDeclarationToStmts(node);
+                break;
+            case ArkCxxAstNode_1.astKind.DecompositionDecl:
+                stmts = this.decompositionDeclToStmts(node);
+                break;
+            default:
+                logger.warn('this ' + node.kind + ' is not supported');
+                break;
+        }
+        this.cxxMapStmtsToTsStmt(stmts, node);
+        if (stmts.length > 0) {
+            IRUtils_1.IRUtils.setComments(stmts[0], node, this.cxxSourceFile, this.declaringMethod.getDeclaringArkFile().getScene().getOptions());
+        }
+        return stmts;
+    }
+    cxxClassDeclarationToStmts(node) {
+        const cls = new ArkClass_1.ArkClass();
+        const declaringArkNamespace = this.declaringMethod.getDeclaringArkClass().getDeclaringArkNamespace();
+        if (declaringArkNamespace) {
+            cls.setDeclaringArkNamespace(declaringArkNamespace);
+        }
+        cls.setDeclaringArkFile(this.declaringMethod.getDeclaringArkFile());
+        (0, ArkClassBuilder_1.buildNormalArkClassFromArkMethod)(node, cls, this.cxxSourceFile, this.declaringMethod);
+        return [];
+    }
+    typeDefDeclToStmts(typeAliasDeclaration) {
+        // 1. Preprocess node to get the actual declaration and type string
+        const { rightOp, typeNode } = this.preprocessTypeAlias(typeAliasDeclaration);
+        // 2. Resolve the underlying type (handling anonymous types and AbstractTypeExpr)
+        let rightType = this.resolveInitialRightType(typeAliasDeclaration);
+        // 3. Create the AliasType instance
+        const aliasName = typeAliasDeclaration.name;
+        const aliasType = new Type_1.AliasType(aliasName, rightType, new ArkSignature_1.AliasTypeSignature(aliasName, this.declaringMethod.getSignature()));
+        // 4. Handle Template definitions and 'typename' keyword logic
+        this.configureTemplateAndTypename(typeAliasDeclaration, aliasType, rightOp, rightType);
+        // 5. Generate the type expression
+        const expr = this.cxxGenerateAliasTypeExpr(rightOp, aliasType);
+        // 6. Populate real generic types if it is a template declaration
+        this.populateRealGenericTypes(typeAliasDeclaration, expr);
+        // 7. Set modifiers
+        aliasType.setModifiers((0, builderUtils_1.buildModifiers)(typeAliasDeclaration));
+        // 8. Create and return the statement
+        const stmt = this.createAliasStmt(aliasType, expr, typeAliasDeclaration, typeNode);
+        this.getAliasTypeMap().set(aliasName, [aliasType, stmt]);
+        return [stmt];
+    }
+    /**
+     * Extracts the target declaration node and the type string (right operand).
+     */
+    preprocessTypeAlias(node) {
+        var _a, _b;
+        let targetDecl = node;
+        if (node.kind === ArkCxxAstNode_1.astKind.TypeAliasTemplateDecl) {
+            targetDecl = node.inner[node.inner.length - 1];
+        }
+        const typeNode = Array.isArray(targetDecl.inner) ? targetDecl.inner[0] : undefined;
+        let rightOp = (_b = (_a = node.type) === null || _a === void 0 ? void 0 : _a.desugaredQualType) !== null && _b !== void 0 ? _b : 'unknown';
+        if (rightOp === 'unknown') {
+            logger.warn(`${node} is a new style that is not supported.`);
+        }
+        return { targetDecl, rightOp, typeNode };
+    }
+    /**
+     * Resolves the basic right-hand side type, handling anonymous structs/unions/enums.
+     */
+    resolveInitialRightType(node) {
+        let rightType = this.getAnonymousInformation(node);
+        if (rightType instanceof TypeExpr_1.AbstractTypeExpr) {
+            rightType = rightType.getType();
+        }
+        return rightType;
+    }
+    /**
+     * Configures generics for template aliases and handles the 'typename' keyword.
+     */
+    configureTemplateAndTypename(node, aliasType, rightOp, initialRightType) {
+        var _a;
+        // Handle Template Alias
+        if (node.kind === ArkCxxAstNode_1.astKind.TypeAliasTemplateDecl) {
+            const genericTypes = (0, builderUtils_1.buildTypeParameters)(node, this.cxxSourceFile, this.declaringMethod);
+            aliasType.setGenericTypes(genericTypes);
+            aliasType.setOriginalType((0, builderUtils_2.buildGenericType)(initialRightType, aliasType));
+        }
+        // Handle scenario: template<typename T> using value_type_t = typename T::value_type;
+        if (rightOp.startsWith(Builtin_1.BuiltinCxx.TYPENAME_KEYWORD)) {
+            const firstGeneric = (_a = aliasType.getGenericTypes()) === null || _a === void 0 ? void 0 : _a[0];
+            if (firstGeneric) {
+                aliasType.setOriginalType(firstGeneric);
+            }
+        }
+    }
+    /**
+     * Extracts real generic types from TemplateTypeParmDecl nodes and sets them on the expression.
+     */
+    populateRealGenericTypes(node, expr) {
+        if (node.kind === ArkCxxAstNode_1.astKind.TypeAliasTemplateDecl) {
+            const realGenericTypes = [];
+            node.inner.filter(inn => inn.kind === ArkCxxAstNode_1.astKind.TemplateTypeParmDecl)
+                .forEach(typeArgument => {
+                realGenericTypes.push((0, builderUtils_1.cxxNode2Type)(typeArgument, this.declaringMethod));
+            });
+            expr.setRealGenericTypes(realGenericTypes);
+        }
+    }
+    /**
+     * Constructs the final ArkAliasTypeDefineStmt and sets source positions.
+     */
+    createAliasStmt(aliasType, expr, node, typeNode) {
+        const stmt = new Stmt_1.ArkAliasTypeDefineStmt(aliasType, expr);
+        const leftPosition = Position_1.FullPosition.cxxBuildFromNode(node, this.cxxSourceFile);
+        const rightPosition = Position_1.FullPosition.cxxBuildFromNode(typeNode, this.cxxSourceFile);
+        stmt.setOperandOriginalPositions([leftPosition, rightPosition]);
+        return stmt;
+    }
+    getAnonymousInformation(node) {
+        if (node.inner.length === 0 && node.originalId) {
+            const cls = ArkFileBuilder_1.classMap.get(node.originalId);
+            if (cls) {
+                return new Type_1.ClassType(cls.getSignature());
+            }
+        }
+        return (0, builderUtils_1.cxxNode2Type)(node, this.declaringMethod);
+    }
+    // When there are default parameters, how to handle them
+    cxxParameterToStmts(parameter) {
+        const stmts = [];
+        let paramName = parameter.name;
+        const paramLocal = Array.from(this.getLocals()).find(local => local.getName() === paramName);
+        if (paramLocal === undefined) {
+            return stmts;
+        }
+        // Inner contains only one element, indicating that no default value has been declared
+        const length = parameter.inner.length;
+        if (parameter.inner[0].code === 'maybe_unused' && length === 1) {
+            return stmts;
+        }
+        // The last element is the default value
+        const { value: paramInitValue, valueOriginalPositions: paramInitPositions, stmts: paramInitStmts, } = this.cxxNodeToValueAndStmts(parameter.inner[length - 1]);
+        stmts.push(...paramInitStmts);
+        const ifStmt = new Stmt_1.ArkIfStmt(new Expr_1.ArkConditionExpr(paramLocal, ValueUtil_2.ValueUtil.getUndefinedConst(), Expr_1.RelationalBinaryOperator.Equality));
+        ifStmt.setOperandOriginalPositions([Position_1.FullPosition.DEFAULT, Position_1.FullPosition.DEFAULT]);
+        stmts.push(ifStmt);
+        const currConditionalOperatorIndex = this.arkValueTransformer.conditionalOperatorNo++;
+        stmts.push(new ArkIRTransformer_1.DummyStmt(ArkIRTransformer_1.ArkIRTransformer.DUMMY_CONDITIONAL_OPERATOR_IF_TRUE_STMT + currConditionalOperatorIndex));
+        const assignStmt = new Stmt_1.ArkAssignStmt(paramLocal, paramInitValue);
+        assignStmt.setOperandOriginalPositions([Position_1.FullPosition.DEFAULT, ...paramInitPositions]);
+        stmts.push(assignStmt);
+        stmts.push(new ArkIRTransformer_1.DummyStmt(ArkIRTransformer_1.ArkIRTransformer.DUMMY_CONDITIONAL_OPERATOR_IF_FALSE_STMT + currConditionalOperatorIndex));
+        stmts.push(new ArkIRTransformer_1.DummyStmt(ArkIRTransformer_1.ArkIRTransformer.DUMMY_CONDITIONAL_OPERATOR_END_STMT + currConditionalOperatorIndex));
+        return stmts;
+    }
+    cxxGenerateAliasTypeExpr(rightOp, aliasType) {
+        let rightType = aliasType.getOriginalType();
+        let expr;
+        expr = new Expr_1.AliasTypeExpr(rightType, false);
+        // For statements like type A = {x:1, y:2}, the ClassType can be accurately obtained at this stage,
+        // and the corresponding ArkClass needs to be found as originalObject.
+        // For other cases, this is UnclearReferenceType here and will be found and processed by type inference
+        if (rightType instanceof Type_1.ClassType) {
+            const classObject = ModelUtils_1.ModelUtils.getClassWithName(rightType.getClassSignature().getClassName(), this.declaringMethod.getDeclaringArkClass());
+            if (classObject) {
+                expr.setOriginalObject(classObject);
+            }
+        }
+        return expr;
+    }
+    forRangeStatementToStmts(forOfStatement) {
+        const stmts = [];
+        let entry = forOfStatement.inner[1];
+        // Handle iterable initialization
+        let { iterablePositions, iteratorInvokeExpr, iteratorInvokeExprPositions, } = this.handleForRangeIterInit(entry, stmts);
+        const base = iteratorInvokeExpr.getBase();
+        // Handle iterable begin
+        const { iterator, doneFieldRef, doneFieldRefPositions, } = this.handleForRangeIterBegin(iteratorInvokeExpr, iteratorInvokeExprPositions, stmts, iterablePositions, base);
+        // Handle iterable end
+        const { iteratorNextInvokeExpr, iteratorNextInvokeExprPositions, } = this.handleForRangeIterEnd(doneFieldRef, doneFieldRefPositions, stmts, iterator);
+        // Handle iterable result value
+        const { valueFieldRef, valueFieldRefPositions, } = this.handleForRangeIterResult(iteratorNextInvokeExpr, iteratorNextInvokeExprPositions, stmts, iterator);
+        // Handle whether iterable is finished
+        const { value: yieldValue, valueOriginalPositions: yieldValuePositions, stmts: yieldValueStmts, } = this.generateAssignStmtForValue(valueFieldRef, valueFieldRefPositions);
+        stmts.push(...yieldValueStmts);
+        const castExpr = new Expr_1.ArkCastExpr(yieldValue, Type_1.UnknownType.getInstance());
+        const castExprPositions = [yieldValuePositions[0], ...yieldValuePositions];
+        let declStmts = forOfStatement.inner[0];
+        declStmts = declStmts.kind === ArkCxxAstNode_1.astKind.DeclStmt ? declStmts.inner[0] : declStmts;
+        if (declStmts.kind === ArkCxxAstNode_1.astKind.VarDecl) {
+            const { value: initValue, valueOriginalPositions: initOriPos, stmts: initStmts, } = this.ArkCxxValueTransformer.cxxVariableDeclarationToValueAndStmts(declStmts, false);
+            const assignStmt = new Stmt_1.ArkAssignStmt(initValue, castExpr);
+            assignStmt.setOperandOriginalPositions([...initOriPos, ...castExprPositions]);
+            stmts.push(assignStmt);
+            stmts.push(...initStmts);
+            // Processing structured binding under cyclic conditions
+        }
+        else if (declStmts.kind === ArkCxxAstNode_1.astKind.DecompositionDecl) {
+            const { stmts: initStmts, } = this.ArkCxxValueTransformer.bindingNodeToValueAndStmts(declStmts, yieldValue);
+            stmts.push(...initStmts);
+        }
+        else {
+            const { value: initValue, valueOriginalPositions: initOriPos, stmts: initStmts, } = this.cxxNodeToValueAndStmts(declStmts);
+            const assignStmt = new Stmt_1.ArkAssignStmt(initValue, castExpr);
+            assignStmt.setOperandOriginalPositions([...initOriPos, ...castExprPositions]);
+            stmts.push(...initStmts);
+            stmts.push(assignStmt);
+        }
+        return stmts;
+    }
+    handleForRangeIterInit(entry, stmts) {
+        let { value: iterableValue, valueOriginalPositions: iterablePositions, stmts: iterableStmts, } = this.cxxNodeToValueAndStmts(entry);
+        stmts.push(...iterableStmts);
+        if (!(iterableValue instanceof Local_1.Local)) {
+            ({
+                value: iterableValue,
+                valueOriginalPositions: iterablePositions,
+                stmts: iterableStmts,
+            } = this.generateAssignStmtForValue(iterableValue, iterablePositions));
+            stmts.push(...iterableStmts);
+        }
+        const iteratorMethodSubSignature = new ArkSignature_1.MethodSubSignature(Builtin_1.BuiltinCxx.ITERATOR_FUNCTION, [], Builtin_1.BuiltinCxx.ITERATOR_CLASS_TYPE);
+        const iteratorMethodSignature = new ArkSignature_1.MethodSignature(ArkSignature_1.ClassSignature.DEFAULT, iteratorMethodSubSignature);
+        const iteratorInvokeExpr = new Expr_1.ArkInstanceInvokeExpr(iterableValue, iteratorMethodSignature, []);
+        const iteratorInvokeExprPositions = [iterablePositions[0], ...iterablePositions];
+        return { iterablePositions, iteratorInvokeExpr, iteratorInvokeExprPositions };
+    }
+    handleForRangeIterBegin(iteratorInvokeExpr, iteratorInvokeExprPositions, stmts, iterablePositions, base) {
+        const { value: iterator, valueOriginalPositions: iteratorPositions, stmts: iteratorStmts, } = this.generateAssignStmtForValue(iteratorInvokeExpr, iteratorInvokeExprPositions);
+        stmts.push(...iteratorStmts);
+        if (iterator instanceof Local_1.Local) {
+            iterator.setType(Builtin_1.BuiltinCxx.ITERATOR_CLASS_TYPE);
+        }
+        else {
+            logger.error(logger_1.LOG_MODULE_TYPE.DEFAULT, 'iterator is not a local');
+        }
+        const baseType = base.getType();
+        const beginFieldSignature = baseType instanceof Type_1.ClassType ? new ArkSignature_1.FieldSignature(Builtin_1.BuiltinCxx.ITERATOR_RESULT_BEGIN, baseType.getClassSignature(), Type_1.BooleanType.getInstance(), false) :
+            new ArkSignature_1.FieldSignature(Builtin_1.BuiltinCxx.ITERATOR_RESULT_BEGIN, Builtin_1.BuiltinCxx.ITERATOR_RESULT_CLASS_SIGNATURE, Type_1.BooleanType.getInstance(), false);
+        const beginFieldRef = new Ref_1.ArkInstanceFieldRef(base, beginFieldSignature);
+        const beginStmt = new Stmt_1.ArkAssignStmt(iterator, beginFieldRef);
+        stmts.push(beginStmt);
+        const dummyInitializerStmt = new ArkIRTransformer_1.DummyStmt(ArkIRTransformer_1.ArkIRTransformer.DUMMY_LOOP_INITIALIZER_STMT);
+        stmts.push(dummyInitializerStmt);
+        const doneFieldSignature = baseType instanceof Type_1.ClassType ? new ArkSignature_1.FieldSignature(Builtin_1.BuiltinCxx.ITERATOR_RESULT_END, baseType.getClassSignature(), Type_1.BooleanType.getInstance(), false) :
+            new ArkSignature_1.FieldSignature(Builtin_1.BuiltinCxx.ITERATOR_RESULT_END, Builtin_1.BuiltinCxx.ITERATOR_RESULT_CLASS_SIGNATURE, Type_1.BooleanType.getInstance(), false);
+        const doneFieldRef = new Ref_1.ArkInstanceFieldRef(base, doneFieldSignature);
+        const doneFieldRefPositions = [iteratorPositions[0], ...iterablePositions];
+        return { iterator, doneFieldRef, doneFieldRefPositions };
+    }
+    handleForRangeIterEnd(doneFieldRef, doneFieldRefPositions, stmts, iterator) {
+        const { value: doneFlag, valueOriginalPositions: doneFlagPositions, stmts: doneFlagStmts, } = this.generateAssignStmtForValue(doneFieldRef, doneFieldRefPositions);
+        stmts.push(...doneFlagStmts);
+        doneFlag.setType(Type_1.BooleanType.getInstance());
+        const conditionExpr = new Expr_1.ArkConditionExpr(iterator, doneFlag, Expr_1.RelationalBinaryOperator.Equality);
+        const conditionExprPositions = [doneFlagPositions[0], ...doneFlagPositions, Position_1.FullPosition.DEFAULT];
+        const ifStmt = new Stmt_1.ArkIfStmt(conditionExpr);
+        ifStmt.setOperandOriginalPositions(conditionExprPositions);
+        stmts.push(ifStmt);
+        const nextMethodSubSignature = new ArkSignature_1.MethodSubSignature(Builtin_1.BuiltinCxx.ITERATOR_NEXT, [], Builtin_1.BuiltinCxx.ITERATOR_RESULT_CLASS_TYPE);
+        const nextMethodSignature = new ArkSignature_1.MethodSignature(ArkSignature_1.ClassSignature.DEFAULT, nextMethodSubSignature);
+        const iteratorNextInvokeExpr = new Expr_1.ArkInstanceInvokeExpr(iterator, nextMethodSignature, []);
+        const iteratorNextInvokeExprPositions = [doneFieldRefPositions[0], ...doneFieldRefPositions];
+        return { iteratorNextInvokeExpr, iteratorNextInvokeExprPositions };
+    }
+    handleForRangeIterResult(iteratorNextInvokeExpr, iteratorNextInvokeExprPositions, stmts, iterator) {
+        const nextStmt = new Stmt_1.ArkAssignStmt(iterator, iteratorNextInvokeExpr);
+        stmts.push(nextStmt);
+        const valueFieldSignature = new ArkSignature_1.FieldSignature(Builtin_1.BuiltinCxx.ITERATOR_VALUE, Builtin_1.BuiltinCxx.ITERATOR_CLASS_SIGNATURE, Type_1.UnknownType.getInstance(), false);
+        const valueFieldRef = new Ref_1.ArkInstanceFieldRef(iterator, valueFieldSignature);
+        const valueFieldRefPositions = [iteratorNextInvokeExprPositions[0], ...iteratorNextInvokeExprPositions];
+        return { valueFieldRef, valueFieldRefPositions };
+    }
+    cxxCatchClauseToStmts(catchClause) {
+        const stmts = [];
+        // When the scenario is catch (...), inner [0] is the exception handling content, and in other cases, it is the exception type
+        if (catchClause.inner && catchClause.inner.length > 1) {
+            const { value: catchValue, valueOriginalPositions: catchOriPos, stmts: catchStmts, } = this.ArkCxxValueTransformer.cxxVariableDeclarationToValueAndStmts(catchClause.inner[0], false);
+            this.catchedExceptions.push(catchValue);
+            const caughtExceptionRef = new Ref_1.ArkCaughtExceptionRef(catchValue.getType());
+            const assignStmt = new Stmt_1.ArkAssignStmt(catchValue, caughtExceptionRef);
+            assignStmt.setOperandOriginalPositions(catchOriPos);
+            stmts.push(assignStmt);
+            stmts.push(...catchStmts);
+        }
+        else { // When the scenario is catch (...)
+            const caughtExceptionRef = new Ref_1.ArkCaughtExceptionRef(Type_1.AnyType.getInstance());
+            const catchValue = new Local_1.Local('error');
+            this.catchedExceptions.push(catchValue);
+            const assignStmt = new Stmt_1.ArkAssignStmt(catchValue, caughtExceptionRef);
+            assignStmt.setOriginPositionInfo(Position_1.LineColPosition.cxxBuildFromNode(catchClause));
+            stmts.push(assignStmt);
+        }
+        return stmts;
+    }
+    /** The main function for converting C++ AST nodes to ValueAndStmts */
+    cxxNodeToValueAndStmts(node) {
+        return this.ArkCxxValueTransformer.cxxNodeToValueAndStmts(node);
+    }
+    cxxReturnStatementToStmts(returnStatement) {
+        const stmts = [];
+        if (returnStatement.inner.length > 0) {
+            let { value: exprValue, valueOriginalPositions: exprPositions, stmts: exprStmts, } = this.cxxNodeToValueAndStmts(returnStatement.inner[0]);
+            stmts.push(...exprStmts);
+            if (IRUtils_1.IRUtils.moreThanOneAddress(exprValue)) {
+                ({
+                    value: exprValue,
+                    valueOriginalPositions: exprPositions,
+                    stmts: exprStmts,
+                } = this.generateAssignStmtForValue(exprValue, exprPositions));
+                stmts.push(...exprStmts);
+            }
+            const returnStmt = new Stmt_1.ArkReturnStmt(exprValue);
+            returnStmt.setOperandOriginalPositions(exprPositions);
+            stmts.push(returnStmt);
+            if (this.declaringMethod.getSubSignature().getReturnType() instanceof Type_1.UnknownType) {
+                this.declaringMethod.getSubSignature().setReturnType(exprValue.getType());
+            }
+            return stmts;
+        }
+        stmts.push(new Stmt_1.ArkReturnVoidStmt());
+        if (this.declaringMethod.getSubSignature().getReturnType() instanceof Type_1.UnknownType) {
+            this.declaringMethod.getSubSignature().setReturnType(Type_1.VoidType.getInstance());
+        }
+        return stmts;
+    }
+    cxxExpressionStatementToStmts(expressionStatement) {
+        const { value: exprValue, valueOriginalPositions: exprPositions, stmts: stmts, } = this.cxxNodeToValueAndStmts(expressionStatement);
+        if (exprValue instanceof Expr_1.AbstractInvokeExpr) {
+            this.cxxAddInvokeStmts(exprValue, exprPositions, stmts);
+        }
+        else if (this.shouldGenerateCxxExtraAssignStmt(expressionStatement)) {
+            const { stmts: exprStmts } = this.generateAssignStmtForValue(exprValue, exprPositions);
+            stmts.push(...exprStmts);
+        }
+        return stmts;
+    }
+    cxxAddInvokeStmts(invokeExpr, exprPositions, stmts) {
+        const invokeStmt = new Stmt_1.ArkInvokeStmt(invokeExpr);
+        invokeStmt.setOperandOriginalPositions(exprPositions);
+        stmts.push(invokeStmt);
+        let hasRepeat = false;
+        for (const stmt of stmts) {
+            if (stmt instanceof Stmt_1.ArkAssignStmt && stmt.getRightOp() instanceof Expr_1.ArkStaticInvokeExpr) {
+                const rightOp = stmt.getRightOp();
+                if (rightOp.getMethodSignature().getMethodSubSignature().getMethodName() === EtsConst_1.COMPONENT_REPEAT) {
+                    const createMethodSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSignatureFromClassNameAndMethodName(EtsConst_1.COMPONENT_REPEAT, EtsConst_1.COMPONENT_CREATE_FUNCTION);
+                    const createInvokeExpr = new Expr_1.ArkStaticInvokeExpr(createMethodSignature, rightOp.getArgs());
+                    stmt.setRightOp(createInvokeExpr);
+                    hasRepeat = true;
+                }
+            }
+        }
+        if (hasRepeat) {
+            const popMethodSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSignatureFromClassNameAndMethodName(EtsConst_1.COMPONENT_REPEAT, EtsConst_1.COMPONENT_POP_FUNCTION);
+            const popInvokeExpr = new Expr_1.ArkStaticInvokeExpr(popMethodSignature, []);
+            const popInvokeStmt = new Stmt_1.ArkInvokeStmt(popInvokeExpr);
+            stmts.push(popInvokeStmt);
+        }
+    }
+    /** Convert C++ switch statements to ValueAndStmts */
+    cxxSwitchStatementToValueAndStmts(switchStatement) {
+        // switchNode.inner[length - 2] is the value
+        const valueAndStmtsOfSwitchAndCases = [];
+        const exprStmts = [];
+        for (let i = 0; i < switchStatement.inner.length - 2; i++) {
+            exprStmts.push(...this.cxxNodeToValueAndStmts(switchStatement.inner[i]).stmts);
+        }
+        let { value: exprValue, valueOriginalPositions: exprPositions, stmts: exprTempStmts, } = this.cxxNodeToValueAndStmts(switchStatement.inner[switchStatement.inner.length - 2]);
+        exprStmts.push(...exprTempStmts);
+        if (IRUtils_1.IRUtils.moreThanOneAddress(exprValue)) {
+            ({
+                value: exprValue,
+                valueOriginalPositions: exprPositions,
+                stmts: exprTempStmts,
+            } = this.generateAssignStmtForValue(exprValue, exprPositions));
+            exprStmts.push(...exprTempStmts);
+        }
+        valueAndStmtsOfSwitchAndCases.push({
+            value: exprValue,
+            valueOriginalPositions: exprPositions,
+            stmts: exprStmts,
+        });
+        // switchNode.inner[length - 1] is the cases
+        for (const clause of switchStatement.inner[switchStatement.inner.length - 1].inner) {
+            if (clause.kind.toString() === ArkCxxAstNode_1.astKind.CaseStmt) {
+                const clauseStmts = [];
+                let { value: clauseValue, valueOriginalPositions: clausePositions, stmts: clauseTempStmts, } = this.cxxNodeToValueAndStmts(clause.inner[0]);
+                clauseStmts.push(...clauseTempStmts);
+                if (IRUtils_1.IRUtils.moreThanOneAddress(clauseValue)) {
+                    ({
+                        value: clauseValue,
+                        valueOriginalPositions: clausePositions,
+                        stmts: clauseTempStmts,
+                    } = this.generateAssignStmtForValue(clauseValue, clausePositions));
+                    clauseStmts.push(...clauseTempStmts);
+                }
+                valueAndStmtsOfSwitchAndCases.push({
+                    value: clauseValue,
+                    valueOriginalPositions: clausePositions,
+                    stmts: clauseStmts,
+                });
+            }
+        }
+        return valueAndStmtsOfSwitchAndCases;
+    }
+    /**
+     * Convert C++for statement nodes to Ark IR statement arrays
+     * Under forStmt, there will be 5 child nodes. Taking for (a ; b; c) as an example,
+     * the content of block a is at node 0, if block b contains assignments, it will be at node 1,
+     * the Boolean judgment of block b is at node 2, the successor operation of block c's loop body is at node 3,
+     * and the loop body is at node 4
+     * @param forStatement -The for statement node in C++AST
+     * @returns Converted Ark IR statement array
+     */
+    cxxForStatementToStmts(forStatement) {
+        const stmts = [];
+        let initNode;
+        let conditionNoe;
+        let incrementor;
+        // The complete for structure allocates corresponding statements in order, so we need to process them in order.
+        if (forStatement.inner.length === 5) {
+            initNode = forStatement.inner.slice(0, 2);
+            conditionNoe = forStatement.inner[2];
+            incrementor = forStatement.inner[3];
+        }
+        else {
+            logger.error('Current node syntax tree generation error');
+            return stmts;
+        }
+        if (initNode) {
+            initNode.forEach(node => this.cxxNodeToStmts(node).forEach(stmt => stmts.push(stmt)));
+        }
+        const dummyInitializerStmt = new ArkIRTransformer_1.DummyStmt(ArkIRTransformer_1.ArkIRTransformer.DUMMY_LOOP_INITIALIZER_STMT);
+        stmts.push(dummyInitializerStmt);
+        if (conditionNoe.kind === undefined) {
+            // The omitted condition always evaluates to true.
+            const trueConstant = ValueUtil_1.CxxValueUtil.getBooleanConstant(true);
+            const conditionExpr = new Expr_1.ArkConditionExpr(trueConstant, trueConstant, Expr_1.RelationalBinaryOperator.Equality);
+            stmts.push(new Stmt_1.ArkIfStmt(conditionExpr));
+        }
+        else if (conditionNoe) {
+            stmts.push(...this.cxxIfStatementToStmts(conditionNoe));
+        }
+        if (incrementor) {
+            stmts.push(...this.cxxNodeToValueAndStmts(incrementor).stmts);
+        }
+        return stmts;
+    }
+    cxxWhileStatementToStmts(whileStatement) {
+        const stmts = [];
+        const dummyInitializerStmt = new ArkIRTransformer_1.DummyStmt(ArkIRTransformer_1.ArkIRTransformer.DUMMY_LOOP_INITIALIZER_STMT);
+        stmts.push(dummyInitializerStmt);
+        stmts.push(...this.cxxIfStatementToStmts(whileStatement.inner[0]));
+        return stmts;
+    }
+    cxxDoStatementToStmts(doStatement) {
+        const stmts = [];
+        stmts.push(...this.cxxIfStatementToStmts(doStatement.inner[1]));
+        return stmts;
+    }
+    expressionWithCleanup(exprWithCleanup) {
+        return this.expressionToStmts(nodeInnerNode(exprWithCleanup));
+    }
+    compoundToStmts(expressionStatement) {
+        return this.memberCallExpressionToStmts(expressionStatement.inner[0]);
+    }
+    memberCallExprToStmts(expressionStatement) {
+        return this.memberCallExpressionToStmts(expressionStatement);
+    }
+    memberCallExpressionToStmts(expression) {
+        const { value: exprValue, valueOriginalPositions: exprPositions, stmts: stmts, } = this.cxxNodeToValueAndStmts(expression);
+        if (exprValue instanceof Expr_1.AbstractInvokeExpr) {
+            const invokeStmt = new Stmt_1.ArkInvokeStmt(exprValue);
+            invokeStmt.setOperandOriginalPositions(exprPositions);
+            stmts.push(invokeStmt);
+            let hasRepeat = false;
+            for (const stmt of stmts) {
+                if (!(stmt instanceof Stmt_1.ArkAssignStmt)) {
+                    continue;
+                }
+                if (!(stmt.getRightOp() instanceof Expr_1.ArkStaticInvokeExpr)) {
+                    continue;
+                }
+                const rightOp = stmt.getRightOp();
+                if (rightOp.getMethodSignature().getMethodSubSignature().getMethodName() !== EtsConst_1.COMPONENT_REPEAT) {
+                    continue;
+                }
+                const createMethodSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSignatureFromClassNameAndMethodName(EtsConst_1.COMPONENT_REPEAT, EtsConst_1.COMPONENT_CREATE_FUNCTION);
+                const createInvokeExpr = new Expr_1.ArkStaticInvokeExpr(createMethodSignature, rightOp.getArgs());
+                stmt.setRightOp(createInvokeExpr);
+                hasRepeat = true;
+            }
+            if (hasRepeat) {
+                const popMethodSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSignatureFromClassNameAndMethodName(EtsConst_1.COMPONENT_REPEAT, EtsConst_1.COMPONENT_POP_FUNCTION);
+                const popInvokeExpr = new Expr_1.ArkStaticInvokeExpr(popMethodSignature, []);
+                const popInvokeStmt = new Stmt_1.ArkInvokeStmt(popInvokeExpr);
+                stmts.push(popInvokeStmt);
+            }
+        }
+        else if (exprValue instanceof Expr_1.AbstractExpr) {
+            const { stmts: exprStmts } = this.generateAssignStmtForValue(exprValue, exprPositions);
+            stmts.push(...exprStmts);
+        }
+        return stmts;
+    }
+    expressionToStmts(expression) {
+        var _a;
+        const { value: exprValue, valueOriginalPositions: exprPositions, stmts: stmts, } = this.cxxNodeToValueAndStmts(expression);
+        if (exprValue instanceof Expr_1.AbstractInvokeExpr) {
+            const invokeStmt = new Stmt_1.ArkInvokeStmt(exprValue);
+            invokeStmt.setOperandOriginalPositions(exprPositions);
+            stmts.push(invokeStmt);
+            let hasRepeat = false;
+            for (const stmt of stmts) {
+                // Not an assignment statement: skip
+                if (!(stmt instanceof Stmt_1.ArkAssignStmt)) {
+                    continue;
+                }
+                const rightOp = (_a = stmt.getRightOp) === null || _a === void 0 ? void 0 : _a.call(stmt); // 如果可能没有这个方法，用可选调用更安全
+                // Right side does not exist or is not a static call: skip
+                if (!(rightOp instanceof Expr_1.ArkStaticInvokeExpr)) {
+                    continue;
+                }
+                const methodName = rightOp.getMethodSignature().getMethodSubSignature().getMethodName();
+                // Not COMPONENT_REPEAT: skip
+                if (methodName !== EtsConst_1.COMPONENT_REPEAT) {
+                    continue;
+                }
+                const createMethodSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSignatureFromClassNameAndMethodName(EtsConst_1.COMPONENT_REPEAT, EtsConst_1.COMPONENT_CREATE_FUNCTION);
+                const createInvokeExpr = new Expr_1.ArkStaticInvokeExpr(createMethodSignature, rightOp.getArgs());
+                stmt.setRightOp(createInvokeExpr);
+                hasRepeat = true;
+            }
+            if (hasRepeat) {
+                const popMethodSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSignatureFromClassNameAndMethodName(EtsConst_1.COMPONENT_REPEAT, EtsConst_1.COMPONENT_POP_FUNCTION);
+                const popInvokeExpr = new Expr_1.ArkStaticInvokeExpr(popMethodSignature, []);
+                const popInvokeStmt = new Stmt_1.ArkInvokeStmt(popInvokeExpr);
+                stmts.push(popInvokeStmt);
+            }
+        }
+        else if (exprValue instanceof Expr_1.AbstractExpr) {
+            const { stmts: exprStmts } = this.generateAssignStmtForValue(exprValue, exprPositions);
+            stmts.push(...exprStmts);
+        }
+        return stmts;
+    }
+    cxxDeclStatementToStmts(declStatement) {
+        const stmts = [];
+        if (declStatement.inner.length === 0) {
+            return this.ArkCxxValueTransformer.cxxVariableDeclarationToValueAndStmts(declStatement).stmts;
+        }
+        for (const child of declStatement.inner) {
+            const childStmts = this.cxxNodeToStmts(child);
+            stmts.push(...childStmts);
+        }
+        return stmts;
+    }
+    decompositionDeclToStmts(decompositionDecl) {
+        return this.ArkCxxValueTransformer.bindingNodeToValueAndStmts(decompositionDecl).stmts;
+    }
+    cxxVariableDeclarationListToStmts(variableDeclarationList) {
+        return this.ArkCxxValueTransformer.cxxVariableDeclarationToValueAndStmts(variableDeclarationList).stmts;
+    }
+    cxxIfStatementToStmts(ifStatement, depth = 0, context) {
+        const stmts = [];
+        if (ifStatement.kind === ArkCxxAstNode_1.astKind.IfStmt) {
+            return this.cxxIfStatementToStmts(ifStatement.inner[0], depth);
+        }
+        else if (ifStatement.kind === ArkCxxAstNode_1.astKind.BinaryOperator && ifStatement.opcode === '||') {
+            // || The child of a node must have two child nodes
+            stmts.push(...this.cxxIfStatementToStmts(ifStatement.inner[0], depth + 1));
+            stmts.push(new ArkIRTransformer_1.DummyStmt(ArkCxxIRTransformer.DUMMY_IF_OPERATOR_OR_SIGNAL + depth));
+            stmts.push(...this.cxxIfStatementToStmts(ifStatement.inner[1], depth + 1));
+            stmts.push(new ArkIRTransformer_1.DummyStmt(ArkCxxIRTransformer.DUMMY_IF_OPERATOR_END + depth));
+        }
+        else if (ifStatement.kind === ArkCxxAstNode_1.astKind.BinaryOperator && ifStatement.opcode === '&&') {
+            // && The child of a node must have two child nodes
+            stmts.push(...this.cxxIfStatementToStmts(ifStatement.inner[0], depth + 1));
+            stmts.push(new ArkIRTransformer_1.DummyStmt(ArkCxxIRTransformer.DUMMY_IF_OPERATOR_AND_SIGNAL + depth));
+            stmts.push(...this.cxxIfStatementToStmts(ifStatement.inner[1], depth + 1));
+            stmts.push(new ArkIRTransformer_1.DummyStmt(ArkCxxIRTransformer.DUMMY_IF_OPERATOR_END + depth));
+        }
+        else if (ifStatement.kind === ArkCxxAstNode_1.astKind.ParenExpr) {
+            return this.cxxIfStatementToStmts(ifStatement.inner[0], depth);
+        }
+        else {
+            const { value: conditionExpr, valueOriginalPositions: conditionExprPositions, stmts: conditionStmts } = this.ArkCxxValueTransformer.cxxConditionToValueAndStmts(ifStatement);
+            stmts.push(...conditionStmts);
+            const ifStmt = new Stmt_1.ArkIfStmt(conditionExpr);
+            ifStmt.setOperandOriginalPositions(conditionExprPositions);
+            stmts.push(ifStmt);
+            if (context) {
+                context.conditionExpr = conditionExpr;
+            }
+        }
+        return stmts;
+    }
+    cxxThrowStatementToStmts(throwStatement) {
+        const stmts = [];
+        let { value: throwValue, valueOriginalPositions: throwValuePositions, stmts: throwStmts, } = this.cxxNodeToValueAndStmts(throwStatement.inner[0]);
+        if (throwStatement.inner.length === 0 && this.catchedExceptions.length !== 0) {
+            throwValue = this.catchedExceptions[this.catchedExceptions.length - 1];
+        }
+        stmts.push(...throwStmts);
+        const throwStmt = new Stmt_1.ArkThrowStmt(throwValue);
+        throwStmt.setOperandOriginalPositions(throwValuePositions);
+        stmts.push(throwStmt);
+        return stmts;
+    }
+    cxxMapStmtsToTsStmt(stmts, node) {
+        for (const stmt of stmts) {
+            if (!this.stmtsHaveOriginalText.has(stmt)) {
+                this.stmtsHaveOriginalText.add(stmt);
+                stmt.setOriginPositionInfo(Position_1.LineColPosition.cxxBuildFromNode(node));
+                stmt.setOriginalText(node.code);
+            }
+        }
+    }
+    /**
+     * Converts a C++ token to the corresponding unary operator.
+     *
+     * @param token - The C++ token to be converted.
+     * @returns - The corresponding `UnaryOperator` if the token matches, otherwise `null`.
+     */
+    static cxxTokenToUnaryOperator(token) {
+        switch (token) {
+            case '-':
+                return Expr_1.UnaryOperator.Neg;
+            case '~':
+                return Expr_1.UnaryOperator.BitwiseNot;
+            case '!':
+                return Expr_1.UnaryOperator.LogicalNot;
+            case '&':
+                return Expr_1.UnaryOperator.Addr;
+            case '*':
+                return Expr_1.UnaryOperator.Deref;
+            default:
+        }
+        return null;
+    }
+    generateAssignStmtForValue(value, valueOriginalPositions) {
+        let valueType;
+        if (value instanceof Expr_1.ArkUnopExpr) {
+            valueType = this.buildTypeForUnopExpr(value);
+        }
+        else if (value instanceof Expr_1.ArkNormalBinopExpr) {
+            valueType = this.buildTypeForBinOpExpr(value);
+        }
+        else if (value instanceof Ref_1.ArkArrayRef) {
+            valueType = this.buildTypeForArrayRefExpr(value);
+        }
+        else if (value instanceof Expr_1.ArkInstanceInvokeExpr) {
+            valueType = value.getMethodSignature().getMethodSubSignature().getReturnType();
+        }
+        else {
+            valueType = value.getType();
+        }
+        const leftOp = this.ArkCxxValueTransformer.generateTempLocal(valueType);
+        const leftOpPosition = valueOriginalPositions[0];
+        const assignStmt = new Stmt_1.ArkAssignStmt(leftOp, value);
+        assignStmt.setOperandOriginalPositions([leftOpPosition, ...valueOriginalPositions]);
+        return {
+            value: leftOp,
+            valueOriginalPositions: [leftOpPosition],
+            stmts: [assignStmt],
+        };
+    }
+    buildTypeForUnopExpr(value) {
+        const opType = value.getOp().getType();
+        const opCode = value.getOperator();
+        let valueType;
+        switch (opCode) {
+            case Expr_1.UnaryOperator.Addr:
+                if (opType instanceof Type_2.PointerType) {
+                    valueType = new Type_2.PointerType(opType.getBaseType(), opType.getLevel() + 1);
+                }
+                else {
+                    valueType = new Type_2.PointerType(opType, 1);
+                }
+                break;
+            case Expr_1.UnaryOperator.Deref:
+                valueType = this.buildTypeForDerefExpr(opType);
+                break;
+            default:
+                valueType = opType;
+        }
+        return valueType;
+    }
+    buildTypeForDerefExpr(opType) {
+        if (opType instanceof Type_2.PointerType) {
+            if (opType.getLevel() === 1) {
+                return opType.getBaseType();
+            }
+            else {
+                return new Type_2.PointerType(opType.getBaseType(), opType.getLevel() - 1);
+            }
+        }
+        return opType;
+    }
+    buildTypeForBinOpExpr(value) {
+        const valueOpCode = value.getOperator();
+        if (valueOpCode !== Expr_1.NormalBinaryOperator.Addition && valueOpCode !== Expr_1.NormalBinaryOperator.Subtraction) {
+            return value.getType();
+        }
+        const opValue1Type = value.getOp1().getType();
+        const opValue2Type = value.getOp2().getType();
+        if (opValue1Type instanceof Type_2.PointerType) {
+            return opValue1Type;
+        }
+        else if (opValue2Type instanceof Type_2.PointerType) {
+            return opValue2Type;
+        }
+        return value.getType();
+    }
+    buildTypeForArrayRefExpr(value) {
+        const valueBaseType = value.getBase().getType();
+        if (valueBaseType instanceof Type_1.ArrayType) {
+            const dimension = valueBaseType.getDimension();
+            const baseTypeOfArray = valueBaseType.getBaseType();
+            if (dimension === 1) {
+                return baseTypeOfArray;
+            }
+            // Handle multi-dimension array
+            return new Type_1.ArrayType(baseTypeOfArray, dimension - 1);
+        }
+        else if (valueBaseType instanceof Type_1.StringType) {
+            return Type_2.CxxCharType.getInstance(Type_2.CxxTypeSigned.UNKNOWN, Type_2.CxxTypeBitWidth.EIGHT_BITS, Type_2.CxxStdTypeName.CHAR);
+        }
+        return value.getBase().getType();
+    }
+    setBuilderMethodContextFlag(builderMethodContextFlag) {
+    }
+}
+exports.ArkCxxIRTransformer = ArkCxxIRTransformer;
+ArkCxxIRTransformer.DUMMY_IF_OPERATOR_AND_SIGNAL = 'If(&&)';
+ArkCxxIRTransformer.DUMMY_IF_OPERATOR_END = 'IfEnd';
+ArkCxxIRTransformer.DUMMY_IF_OPERATOR_OR_SIGNAL = 'If(||)';