arkanalyzer 1.0.5

package/lib/core/common/ArkIRTransformer.js

@@ -0,0 +1,1674 @@
+"use strict";
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArkIRTransformer = exports.DUMMY_INITIALIZER_STMT = void 0;
+const Expr_1 = require("../base/Expr");
+const Ref_1 = require("../base/Ref");
+const ts = __importStar(require("ohos-typescript"));
+const Local_1 = require("../base/Local");
+const Stmt_1 = require("../base/Stmt");
+const Type_1 = require("../base/Type");
+const Constant_1 = require("../base/Constant");
+const ValueUtil_1 = require("./ValueUtil");
+const ArkSignature_1 = require("../model/ArkSignature");
+const logger_1 = __importStar(require("../../utils/logger"));
+const IRUtils_1 = require("./IRUtils");
+const ArkMethod_1 = require("../model/ArkMethod");
+const ArkMethodBuilder_1 = require("../model/builder/ArkMethodBuilder");
+const ArkClassBuilder_1 = require("../model/builder/ArkClassBuilder");
+const ArkClass_1 = require("../model/ArkClass");
+const ArkSignatureBuilder_1 = require("../model/builder/ArkSignatureBuilder");
+const EtsConst_1 = require("./EtsConst");
+const Position_1 = require("../base/Position");
+const ModelUtils_1 = require("./ModelUtils");
+const Builtin_1 = require("./Builtin");
+const TSConst_1 = require("./TSConst");
+const logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'ArkIRTransformer');
+exports.DUMMY_INITIALIZER_STMT = 'dummyInitializerStmt';
+class ArkIRTransformer {
+    constructor(sourceFile, declaringMethod) {
+        this.tempLocalPrefix = '$temp';
+        this.tempLocalIndex = 0;
+        this.locals = new Map();
+        this.inBuilderMethod = false;
+        this.stmtToOriginalStmt = new Map();
+        this.aliasTypeMap = new Map();
+        this.builderMethodContextFlag = false;
+        this.sourceFile = sourceFile;
+        this.declaringMethod = declaringMethod;
+        this.thisLocal = new Local_1.Local(TSConst_1.THIS_NAME, declaringMethod.getDeclaringArkClass().getSignature().getType());
+        this.locals.set(this.thisLocal.getName(), this.thisLocal);
+        this.inBuilderMethod = ModelUtils_1.ModelUtils.isArkUIBuilderMethod(declaringMethod);
+    }
+    getLocals() {
+        return new Set(this.locals.values());
+    }
+    getThisLocal() {
+        return this.thisLocal;
+    }
+    getStmtToOriginalStmt() {
+        return this.stmtToOriginalStmt;
+    }
+    getAliasTypeMap() {
+        return this.aliasTypeMap;
+    }
+    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.getOrCreatLocal(methodParameter.getName(), parameterRef.getType()), parameterRef));
+            index++;
+        }
+        const thisRef = new Ref_1.ArkThisRef(this.getThisLocal().getType());
+        stmts.push(new Stmt_1.ArkAssignStmt(this.getThisLocal(), thisRef));
+        return stmts;
+    }
+    tsNodeToStmts(node) {
+        let stmts = [];
+        if (ts.isExpressionStatement(node)) {
+            stmts = this.expressionStatementToStmts(node);
+        }
+        else if (ts.isTypeAliasDeclaration(node)) {
+            stmts = this.typeAliasDeclarationToStmts(node);
+        }
+        else if (ts.isBlock(node)) {
+            stmts = this.blockToStmts(node);
+        }
+        else if (ts.isSwitchStatement(node)) {
+            stmts = this.switchStatementToStmts(node);
+        }
+        else if (ts.isForStatement(node)) {
+            stmts = this.forStatementToStmts(node);
+        }
+        else if (ts.isForInStatement(node) || ts.isForOfStatement(node)) {
+            stmts = this.rangeForStatementToStmts(node);
+        }
+        else if (ts.isWhileStatement(node)) {
+            stmts = this.whileStatementToStmts(node);
+        }
+        else if (ts.isDoStatement(node)) {
+            stmts = this.doStatementToStmts(node);
+        }
+        else if (ts.isVariableStatement(node)) {
+            stmts = this.variableStatementToStmts(node);
+        }
+        else if (ts.isVariableDeclarationList(node)) {
+            stmts = this.variableDeclarationListToStmts(node);
+        }
+        else if (ts.isIfStatement(node)) {
+            stmts = this.ifStatementToStmts(node);
+        }
+        else if (ts.isBreakStatement(node) || ts.isContinueStatement(node)) {
+            stmts = this.gotoStatementToStmts(node);
+        }
+        else if (ts.isThrowStatement(node)) {
+            stmts = this.throwStatementToStmts(node);
+        }
+        else if (ts.isCatchClause(node)) {
+            stmts = this.catchClauseToStmts(node);
+        }
+        else if (ts.isReturnStatement(node)) {
+            stmts = this.returnStatementToStmts(node);
+        }
+        this.mapStmtsToTsStmt(stmts, node);
+        return stmts;
+    }
+    returnStatementToStmts(returnStatement) {
+        const stmts = [];
+        if (returnStatement.expression) {
+            let { value: exprValue, valueOriginalPositions: exprPositions, stmts: exprStmts, } = this.tsNodeToValueAndStmts(returnStatement.expression);
+            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);
+        }
+        else {
+            stmts.push(new Stmt_1.ArkReturnVoidStmt());
+        }
+        return stmts;
+    }
+    blockToStmts(block) {
+        const stmts = [];
+        for (const statement of block.statements) {
+            stmts.push(...this.tsNodeToStmts(statement));
+        }
+        return stmts;
+    }
+    expressionStatementToStmts(expressionStatement) {
+        return this.expressionToStmts(expressionStatement.expression);
+    }
+    expressionToStmts(expression) {
+        const { value: exprValue, valueOriginalPositions: exprPositions, stmts: stmts } = this.tsNodeToValueAndStmts(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) && (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);
+            }
+        }
+        else if (exprValue instanceof Expr_1.AbstractExpr) {
+            const { stmts: exprStmts } = this.generateAssignStmtForValue(exprValue, exprPositions);
+            stmts.push(...exprStmts);
+        }
+        return stmts;
+    }
+    typeAliasDeclarationToStmts(typeAliasDeclaration) {
+        const aliasName = typeAliasDeclaration.name.text;
+        const originalType = this.resolveTypeNode(typeAliasDeclaration.type);
+        const aliasType = new Type_1.AliasType(aliasName, originalType, new ArkSignature_1.LocalSignature(aliasName, this.declaringMethod.getSignature()));
+        const sourceCode = typeAliasDeclaration.getText(this.sourceFile);
+        const aliasTypePosition = Position_1.LineColPosition.buildFromNode(typeAliasDeclaration, this.sourceFile);
+        const aliasTypeDeclaration = new Type_1.AliasTypeDeclaration(sourceCode, aliasTypePosition);
+        this.aliasTypeMap.set(aliasName, [aliasType, aliasTypeDeclaration]);
+        return [];
+    }
+    switchStatementToStmts(switchStatement) {
+        const stmts = [];
+        let { value: exprValue, valueOriginalPositions: exprPositions, stmts: exprStmts, } = this.tsNodeToValueAndStmts(switchStatement.expression);
+        stmts.push(...exprStmts);
+        if (IRUtils_1.IRUtils.moreThanOneAddress(exprValue)) {
+            const { value: newExprValue, stmts: exprStmts } = this.generateAssignStmtForValue(exprValue, exprPositions);
+            stmts.push(...exprStmts);
+            exprValue = newExprValue;
+        }
+        const caseValues = [];
+        for (const clause of switchStatement.caseBlock.clauses) {
+            if (ts.isCaseClause(clause)) {
+                let { value: clauseValue, valueOriginalPositions: clausePositions, stmts: clauseStmts, } = this.tsNodeToValueAndStmts(switchStatement.expression);
+                stmts.push(...clauseStmts);
+                if (IRUtils_1.IRUtils.moreThanOneAddress(clauseValue)) {
+                    const { value: newClauseValue, stmts: clauseStmts, } = this.generateAssignStmtForValue(exprValue, clausePositions);
+                    stmts.push(...clauseStmts);
+                    clauseValue = newClauseValue;
+                }
+                caseValues.push(clauseValue);
+            }
+        }
+        return stmts;
+    }
+    forStatementToStmts(forStatement) {
+        const stmts = [];
+        if (forStatement.initializer) {
+            stmts.push(...this.tsNodeToValueAndStmts(forStatement.initializer).stmts);
+        }
+        const dummyInitializerStmt = new Stmt_1.OriginalStmt(exports.DUMMY_INITIALIZER_STMT, Position_1.LineColPosition.DEFAULT);
+        stmts.push(dummyInitializerStmt);
+        if (forStatement.condition) {
+            const { value: conditionValue, stmts: conditionStmts, } = this.conditionToValueAndStmts(forStatement.condition);
+            stmts.push(...conditionStmts);
+            stmts.push(new Stmt_1.ArkIfStmt(conditionValue));
+        }
+        if (forStatement.incrementor) {
+            stmts.push(...this.tsNodeToValueAndStmts(forStatement.incrementor).stmts);
+        }
+        return stmts;
+    }
+    rangeForStatementToStmts(forOfStatement) {
+        const stmts = [];
+        let { value: iterableValue, valueOriginalPositions: iterablePositions, stmts: iterableStmts, } = this.tsNodeToValueAndStmts(forOfStatement.expression);
+        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.Builtin.ITERATOR_FUNCTION, [], Builtin_1.Builtin.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];
+        const { value: iterator, valueOriginalPositions: iteratorPositions, stmts: iteratorStmts, } = this.generateAssignStmtForValue(iteratorInvokeExpr, iteratorInvokeExprPositions);
+        stmts.push(...iteratorStmts);
+        iterator.setType(Builtin_1.Builtin.ITERATOR_CLASS_TYPE);
+        const nextMethodSubSignature = new ArkSignature_1.MethodSubSignature(Builtin_1.Builtin.ITERATOR_NEXT, [], Builtin_1.Builtin.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 = [iteratorPositions[0], ...iteratorPositions];
+        const { value: iteratorResult, valueOriginalPositions: iteratorResultPositions, stmts: iteratorResultStmts, } = this.generateAssignStmtForValue(iteratorNextInvokeExpr, iteratorNextInvokeExprPositions);
+        stmts.push(...iteratorResultStmts);
+        iteratorResult.setType(Builtin_1.Builtin.ITERATOR_RESULT_CLASS_TYPE);
+        const doneFieldSignature = new ArkSignature_1.FieldSignature(Builtin_1.Builtin.ITERATOR_RESULT_DONE, Builtin_1.Builtin.ITERATOR_RESULT_CLASS_SIGNATURE, Type_1.BooleanType.getInstance(), false);
+        const doneFieldRef = new Ref_1.ArkInstanceFieldRef(iteratorResult, doneFieldSignature);
+        const doneFieldRefPositions = [iteratorResultPositions[0], ...iteratorResultPositions];
+        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(doneFlag, ValueUtil_1.ValueUtil.getBooleanConstant(true), 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 valueFieldSignature = new ArkSignature_1.FieldSignature(Builtin_1.Builtin.ITERATOR_RESULT_VALUE, Builtin_1.Builtin.ITERATOR_RESULT_CLASS_SIGNATURE, Type_1.UnknownType.getInstance(), false);
+        const valueFieldRef = new Ref_1.ArkInstanceFieldRef(iteratorResult, valueFieldSignature);
+        const valueFieldRefPositions = [iteratorResultPositions[0], ...iteratorResultPositions];
+        const { value: yieldValue, valueOriginalPositions: yieldValuePositions, stmts: yieldValueStmts, } = this.generateAssignStmtForValue(valueFieldRef, valueFieldRefPositions);
+        stmts.push(...yieldValueStmts);
+        // TODO: Support generics and then fill in the exact type
+        const castExpr = new Expr_1.ArkCastExpr(yieldValue, Type_1.UnknownType.getInstance());
+        const castExprPositions = [yieldValuePositions[0], ...yieldValuePositions];
+        if (ts.isVariableDeclarationList(forOfStatement.initializer)) {
+            const variableDeclarationList = forOfStatement.initializer;
+            const isConst = (variableDeclarationList.flags & ts.NodeFlags.Const) != 0;
+            const variableDeclaration = variableDeclarationList.declarations[0];
+            if (ts.isArrayBindingPattern(variableDeclaration.name)) {
+                const { value: arrayItem, valueOriginalPositions: arrayItemPositions, stmts: arrayItemStmts, } = this.generateAssignStmtForValue(castExpr, castExprPositions);
+                stmts.push(...arrayItemStmts);
+                arrayItem.setType(new Type_1.ArrayType(Type_1.UnknownType.getInstance(), 1));
+                const elements = variableDeclaration.name.elements;
+                let index = 0;
+                for (const element of elements) {
+                    const arrayRef = new Ref_1.ArkArrayRef(arrayItem, new Constant_1.Constant(index.toString(), Type_1.NumberType.getInstance()));
+                    const arrayRefPositions = [arrayItemPositions[0], ...arrayItemPositions, Position_1.FullPosition.DEFAULT];
+                    const item = new Local_1.Local(element.getText(this.sourceFile));
+                    const itemPosition = Position_1.FullPosition.buildFromNode(element, this.sourceFile);
+                    item.setConstFlag(isConst);
+                    const assignStmt = new Stmt_1.ArkAssignStmt(item, arrayRef);
+                    assignStmt.setOperandOriginalPositions([itemPosition, ...arrayRefPositions]);
+                    stmts.push(assignStmt);
+                    index++;
+                }
+            }
+            else if (ts.isObjectBindingPattern(variableDeclaration.name)) {
+                const { value: objectItem, valueOriginalPositions: objectItemPositions, stmts: objectItemStmts, } = this.generateAssignStmtForValue(castExpr, castExprPositions);
+                stmts.push(...objectItemStmts);
+                const elements = variableDeclaration.name.elements;
+                for (const element of elements) {
+                    const fieldName = element.propertyName ? element.propertyName.getText(this.sourceFile) : element.name.getText(this.sourceFile);
+                    const fieldSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildFieldSignatureFromFieldName(fieldName);
+                    const fieldRef = new Ref_1.ArkInstanceFieldRef(objectItem, fieldSignature);
+                    const fieldRefPositions = [objectItemPositions[0], ...objectItemPositions];
+                    const fieldLocal = this.getOrCreatLocal(element.name.getText(this.sourceFile));
+                    const fieldLocalPosition = Position_1.FullPosition.buildFromNode(element, this.sourceFile);
+                    fieldLocal.setConstFlag(isConst);
+                    const assignStmt = new Stmt_1.ArkAssignStmt(fieldLocal, fieldRef);
+                    assignStmt.setOperandOriginalPositions([fieldLocalPosition, ...fieldRefPositions]);
+                    stmts.push(assignStmt);
+                }
+            }
+            else {
+                const item = this.getOrCreatLocal(variableDeclaration.name.getText(this.sourceFile));
+                item.setConstFlag(isConst);
+                stmts.push(new Stmt_1.ArkAssignStmt(item, castExpr));
+            }
+        }
+        else {
+            const { value: item, valueOriginalPositions: itemPositions, stmts: itemStmts } = this.tsNodeToValueAndStmts(forOfStatement.initializer);
+            stmts.push(...itemStmts);
+            const assignStmt = new Stmt_1.ArkAssignStmt(item, castExpr);
+            assignStmt.setOperandOriginalPositions([...itemPositions, ...castExprPositions]);
+            stmts.push(assignStmt);
+        }
+        return stmts;
+    }
+    whileStatementToStmts(whileStatement) {
+        const stmts = [];
+        const dummyInitializerStmt = new Stmt_1.OriginalStmt(exports.DUMMY_INITIALIZER_STMT, Position_1.LineColPosition.DEFAULT);
+        stmts.push(dummyInitializerStmt);
+        const { value: conditionExpr, stmts: conditionStmts, } = this.conditionToValueAndStmts(whileStatement.expression);
+        stmts.push(...conditionStmts);
+        stmts.push(new Stmt_1.ArkIfStmt(conditionExpr));
+        return stmts;
+    }
+    doStatementToStmts(doStatement) {
+        const stmts = [];
+        const { value: conditionExpr, stmts: conditionStmts, } = this.conditionToValueAndStmts(doStatement.expression);
+        stmts.push(...conditionStmts);
+        stmts.push(new Stmt_1.ArkIfStmt(conditionExpr));
+        return stmts;
+    }
+    variableStatementToStmts(variableStatement) {
+        return this.variableDeclarationListToStmts(variableStatement.declarationList);
+    }
+    variableDeclarationListToStmts(variableDeclarationList) {
+        return this.variableDeclarationListToValueAndStmts(variableDeclarationList).stmts;
+    }
+    ifStatementToStmts(ifStatement) {
+        const stmts = [];
+        if (this.inBuilderMethod) {
+            const { value: conditionExpr, valueOriginalPositions: conditionExprPositions, stmts: conditionStmts, } = this.conditionToValueAndStmts(ifStatement.expression);
+            stmts.push(...conditionStmts);
+            const createMethodSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSignatureFromClassNameAndMethodName(EtsConst_1.COMPONENT_IF, EtsConst_1.COMPONENT_CREATE_FUNCTION);
+            const { value: conditionLocal, valueOriginalPositions: conditionLocalPositions, stmts: assignConditionStmts } = this.generateAssignStmtForValue(conditionExpr, conditionExprPositions);
+            stmts.push(...assignConditionStmts);
+            const createInvokeExpr = new Expr_1.ArkStaticInvokeExpr(createMethodSignature, [conditionLocal]);
+            const createInvokeExprPositions = [conditionLocalPositions[0], ...conditionLocalPositions];
+            const { stmts: createStmts } = this.generateAssignStmtForValue(createInvokeExpr, createInvokeExprPositions);
+            stmts.push(...createStmts);
+            const branchMethodSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSignatureFromClassNameAndMethodName(EtsConst_1.COMPONENT_IF, EtsConst_1.COMPONENT_BRANCH_FUNCTION);
+            const branchInvokeExpr = new Expr_1.ArkStaticInvokeExpr(branchMethodSignature, [ValueUtil_1.ValueUtil.getOrCreateNumberConst(0)]);
+            const branchInvokeExprPositions = [conditionLocalPositions[0], Position_1.FullPosition.DEFAULT];
+            const branchInvokeStmt = new Stmt_1.ArkInvokeStmt(branchInvokeExpr);
+            branchInvokeStmt.setOperandOriginalPositions(branchInvokeExprPositions);
+            stmts.push(branchInvokeStmt);
+            stmts.push(...this.tsNodeToStmts(ifStatement.thenStatement));
+            if (ifStatement.elseStatement) {
+                const branchElseMethodSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSignatureFromClassNameAndMethodName(EtsConst_1.COMPONENT_IF, EtsConst_1.COMPONENT_BRANCH_FUNCTION);
+                const branchElseInvokeExpr = new Expr_1.ArkStaticInvokeExpr(branchElseMethodSignature, [ValueUtil_1.ValueUtil.getOrCreateNumberConst(1)]);
+                const branchElseInvokeExprPositions = [Position_1.FullPosition.buildFromNode(ifStatement.elseStatement, this.sourceFile), Position_1.FullPosition.DEFAULT];
+                const branchElseInvokeStmt = new Stmt_1.ArkInvokeStmt(branchElseInvokeExpr);
+                branchElseInvokeStmt.setOperandOriginalPositions(branchElseInvokeExprPositions);
+                stmts.push(branchElseInvokeStmt);
+                stmts.push(...this.tsNodeToStmts(ifStatement.elseStatement));
+            }
+            const popMethodSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSignatureFromClassNameAndMethodName(EtsConst_1.COMPONENT_IF, EtsConst_1.COMPONENT_POP_FUNCTION);
+            const popInvokeExpr = new Expr_1.ArkStaticInvokeExpr(popMethodSignature, []);
+            const popInvokeStmt = new Stmt_1.ArkInvokeStmt(popInvokeExpr);
+            stmts.push(popInvokeStmt);
+        }
+        else {
+            const { value: conditionExpr, valueOriginalPositions: conditionExprPositions, stmts: conditionStmts, } = this.conditionToValueAndStmts(ifStatement.expression);
+            stmts.push(...conditionStmts);
+            const ifStmt = new Stmt_1.ArkIfStmt(conditionExpr);
+            ifStmt.setOperandOriginalPositions(conditionExprPositions);
+            stmts.push(ifStmt);
+        }
+        return stmts;
+    }
+    gotoStatementToStmts(gotoStatement) {
+        return [];
+    }
+    throwStatementToStmts(throwStatement) {
+        const stmts = [];
+        const { value: throwValue, valueOriginalPositions: throwValuePositions, stmts: throwStmts, } = this.tsNodeToValueAndStmts(throwStatement.expression);
+        stmts.push(...throwStmts);
+        const throwStmt = new Stmt_1.ArkThrowStmt(throwValue);
+        throwStmt.setOperandOriginalPositions(throwValuePositions);
+        stmts.push(throwStmt);
+        return stmts;
+    }
+    catchClauseToStmts(catchClause) {
+        const stmts = [];
+        if (catchClause.variableDeclaration) {
+            const { value: catchValue, valueOriginalPositions: catchValuePositions, stmts: catchStmts, } = this.tsNodeToValueAndStmts(catchClause.variableDeclaration);
+            stmts.push(...catchStmts);
+            const caughtExceptionRef = new Ref_1.ArkCaughtExceptionRef(Type_1.UnknownType.getInstance());
+            const assignStmt = new Stmt_1.ArkAssignStmt(catchValue, caughtExceptionRef);
+            assignStmt.setOperandOriginalPositions(catchValuePositions);
+            stmts.push(assignStmt);
+        }
+        return stmts;
+    }
+    tsNodeToValueAndStmts(node) {
+        if (ts.isBinaryExpression(node)) {
+            return this.binaryExpressionToValueAndStmts(node);
+        }
+        else if (ts.isCallExpression(node)) {
+            return this.callExpressionToValueAndStmts(node);
+        }
+        else if (ts.isVariableDeclarationList(node)) {
+            return this.variableDeclarationListToValueAndStmts(node);
+        }
+        else if (ts.isIdentifier(node)) {
+            return this.identifierToValueAndStmts(node);
+        }
+        else if (ts.isPropertyAccessExpression(node)) {
+            return this.propertyAccessExpressionToValue(node);
+        }
+        else if (ts.isPrefixUnaryExpression(node)) {
+            return this.prefixUnaryExpressionToValueAndStmts(node);
+        }
+        else if (ts.isPostfixUnaryExpression(node)) {
+            return this.postfixUnaryExpressionToValueAndStmts(node);
+        }
+        else if (ts.isTemplateExpression(node)) {
+            return this.templateExpressionToValueAndStmts(node);
+        }
+        else if (ts.isAwaitExpression(node)) {
+            return this.awaitExpressionToValueAndStmts(node);
+        }
+        else if (ts.isYieldExpression(node)) {
+            return this.yieldExpressionToValueAndStmts(node);
+        }
+        else if (ts.isDeleteExpression(node)) {
+            return this.deleteExpressionToValueAndStmts(node);
+        }
+        else if (ts.isVoidExpression(node)) {
+            return this.voidExpressionToValueAndStmts(node);
+        }
+        else if (ts.isElementAccessExpression(node)) {
+            return this.elementAccessExpressionToValueAndStmts(node);
+        }
+        else if (ts.isNewExpression(node)) {
+            return this.newExpressionToValueAndStmts(node);
+        }
+        else if (ts.isParenthesizedExpression(node)) {
+            return this.parenthesizedExpressionToValueAndStmts(node);
+        }
+        else if (ts.isAsExpression(node)) {
+            return this.asExpressionToValueAndStmts(node);
+        }
+        else if (ts.isNonNullExpression(node)) {
+            return this.nonNullExpressionToValueAndStmts(node);
+        }
+        else if (ts.isTypeAssertionExpression(node)) {
+            return this.typeAssertionToValueAndStmts(node);
+        }
+        else if (ts.isTypeOfExpression(node)) {
+            return this.typeOfExpressionToValueAndStmts(node);
+        }
+        else if (ts.isArrayLiteralExpression(node)) {
+            return this.arrayLiteralExpressionToValueAndStmts(node);
+        }
+        else if (this.isLiteralNode(node)) {
+            return this.literalNodeToValueAndStmts(node);
+        }
+        else if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
+            return this.callableNodeToValueAndStmts(node);
+        }
+        else if (ts.isClassExpression(node)) {
+            return this.classExpressionToValueAndStmts(node);
+        }
+        else if (ts.isEtsComponentExpression(node)) {
+            return this.etsComponentExpressionToValueAndStmts(node);
+        }
+        else if (ts.isObjectLiteralExpression(node)) {
+            return this.objectLiteralExpresionToValueAndStmts(node);
+        }
+        else if (node.kind === ts.SyntaxKind.ThisKeyword) {
+            return this.thisExpressionToValueAndStmts(node);
+        }
+        else if (ts.isConditionalExpression(node)) {
+            return this.conditionalExpressionToValueAndStmts(node);
+        }
+        return {
+            value: new Local_1.Local(node.getText(this.sourceFile)),
+            valueOriginalPositions: [Position_1.FullPosition.buildFromNode(node, this.sourceFile)],
+            stmts: [],
+        };
+    }
+    thisExpressionToValueAndStmts(thisExpression) {
+        return {
+            value: this.getThisLocal(),
+            valueOriginalPositions: [Position_1.FullPosition.buildFromNode(thisExpression, this.sourceFile)],
+            stmts: [],
+        };
+    }
+    conditionalExpressionToValueAndStmts(conditionalExpression) {
+        // TODO: separated by blocks
+        const stmts = [];
+        const { value: conditionValue, valueOriginalPositions: conditionPositions, stmts: conditionStmts, } = this.conditionToValueAndStmts(conditionalExpression.condition);
+        stmts.push(...conditionStmts);
+        const ifStmt = new Stmt_1.ArkIfStmt(conditionValue);
+        ifStmt.setOperandOriginalPositions(conditionPositions);
+        stmts.push(ifStmt);
+        const { value: whenTrueValue, valueOriginalPositions: whenTruePositions, stmts: whenTrueStmts } = this.tsNodeToValueAndStmts(conditionalExpression.whenTrue);
+        stmts.push(...whenTrueStmts);
+        const { value: resultValue, valueOriginalPositions: resultPositions, stmts: tempStmts, } = this.generateAssignStmtForValue(whenTrueValue, whenTruePositions);
+        stmts.push(...tempStmts);
+        const { value: whenFalseValue, valueOriginalPositions: whenFalsePositions, stmts: whenFalseStmts, } = this.tsNodeToValueAndStmts(conditionalExpression.whenFalse);
+        stmts.push(...whenFalseStmts);
+        const assignStmt = new Stmt_1.ArkAssignStmt(resultValue, whenFalseValue);
+        assignStmt.setOperandOriginalPositions([...resultPositions, ...whenFalsePositions]);
+        stmts.push(assignStmt);
+        return { value: resultValue, valueOriginalPositions: resultPositions, stmts: stmts };
+    }
+    objectLiteralExpresionToValueAndStmts(objectLiteralExpression) {
+        const declaringArkClass = this.declaringMethod.getDeclaringArkClass();
+        const declaringArkNamespace = declaringArkClass.getDeclaringArkNamespace();
+        const anonymousClass = new ArkClass_1.ArkClass();
+        if (declaringArkNamespace) {
+            (0, ArkClassBuilder_1.buildNormalArkClassFromArkNamespace)(objectLiteralExpression, declaringArkNamespace, anonymousClass, this.sourceFile, this.declaringMethod);
+            declaringArkNamespace.addArkClass(anonymousClass);
+        }
+        else {
+            const declaringArkFile = declaringArkClass.getDeclaringArkFile();
+            (0, ArkClassBuilder_1.buildNormalArkClassFromArkFile)(objectLiteralExpression, declaringArkFile, anonymousClass, this.sourceFile, this.declaringMethod);
+            declaringArkFile.addArkClass(anonymousClass);
+        }
+        const objectLiteralExpressionPosition = Position_1.FullPosition.buildFromNode(objectLiteralExpression, this.sourceFile);
+        const stmts = [];
+        const anonymousClassSignature = anonymousClass.getSignature();
+        const anonymousClassType = new Type_1.ClassType(anonymousClassSignature);
+        const newExpr = new Expr_1.ArkNewExpr(anonymousClassType);
+        const { value: newExprLocal, valueOriginalPositions: newExprLocalPositions, stmts: newExprStmts, } = this.generateAssignStmtForValue(newExpr, [objectLiteralExpressionPosition]);
+        stmts.push(...newExprStmts);
+        const constructorMethodSubSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSubSignatureFromMethodName(TSConst_1.CONSTRUCTOR_NAME);
+        const constructorMethodSignature = new ArkSignature_1.MethodSignature(anonymousClassSignature, constructorMethodSubSignature);
+        const constructorInvokeExpr = new Expr_1.ArkInstanceInvokeExpr(newExprLocal, constructorMethodSignature, []);
+        const constructorInvokeExprPositions = [objectLiteralExpressionPosition, ...newExprLocalPositions];
+        const constructorInvokeStmt = new Stmt_1.ArkInvokeStmt(constructorInvokeExpr);
+        constructorInvokeStmt.setOperandOriginalPositions(constructorInvokeExprPositions);
+        stmts.push(constructorInvokeStmt);
+        return { value: newExprLocal, valueOriginalPositions: newExprLocalPositions, stmts: stmts };
+    }
+    createCustomViewStmt(componentName, args, argPositionsAll, componentExpression, currStmts) {
+        const stmts = [...currStmts];
+        const componentExpressionPosition = Position_1.FullPosition.buildFromNode(componentExpression, this.sourceFile);
+        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.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,
+            ...argPositionsAll.flat()];
+        const instanceInvokeStmt = new Stmt_1.ArkInvokeStmt(instanceInvokeExpr);
+        instanceInvokeStmt.setOperandOriginalPositions(instanceInvokeExprPositions);
+        stmts.push(instanceInvokeStmt);
+        const createViewArgs = [newExprLocal];
+        const createViewArgPositionsAll = [newExprPositions];
+        if (ts.isEtsComponentExpression(componentExpression) && componentExpression.body) {
+            const anonymous = ts.factory.createArrowFunction([], [], [], undefined, undefined, componentExpression.body);
+            // @ts-ignore
+            anonymous.pos = componentExpression.body.pos;
+            // @ts-ignore
+            anonymous.end = componentExpression.body.end;
+            const { value: builderMethod, valueOriginalPositions: builderMethodPositions, } = this.callableNodeToValueAndStmts(anonymous);
+            createViewArgs.push(builderMethod);
+            createViewArgPositionsAll.push(builderMethodPositions);
+        }
+        const createMethodSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSignatureFromClassNameAndMethodName(EtsConst_1.COMPONENT_CUSTOMVIEW, EtsConst_1.COMPONENT_CREATE_FUNCTION);
+        const createInvokeExpr = new Expr_1.ArkStaticInvokeExpr(createMethodSignature, createViewArgs);
+        const createInvokeExprPositions = [componentExpressionPosition, ...createViewArgPositionsAll.flat()];
+        const { value: componentValue, valueOriginalPositions: componentPositions, stmts: componentStmts, } = this.generateAssignStmtForValue(createInvokeExpr, createInvokeExprPositions);
+        stmts.push(...componentStmts);
+        const popMethodSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSignatureFromClassNameAndMethodName(EtsConst_1.COMPONENT_CUSTOMVIEW, EtsConst_1.COMPONENT_POP_FUNCTION);
+        const popInvokeExpr = new Expr_1.ArkStaticInvokeExpr(popMethodSignature, []);
+        const popInvokeExprPositions = [componentExpressionPosition];
+        const popInvokeStmt = new Stmt_1.ArkInvokeStmt(popInvokeExpr);
+        popInvokeStmt.setOperandOriginalPositions(popInvokeExprPositions);
+        stmts.push(popInvokeStmt);
+        return { value: componentValue, valueOriginalPositions: componentPositions, stmts: stmts };
+    }
+    etsComponentExpressionToValueAndStmts(etsComponentExpression) {
+        const stmts = [];
+        const componentName = etsComponentExpression.expression.text;
+        let builderMethodIndexes = undefined;
+        if (componentName === EtsConst_1.COMPONENT_FOR_EACH || componentName === EtsConst_1.COMPONENT_LAZY_FOR_EACH) {
+            builderMethodIndexes = new Set([1]);
+        }
+        const { args: args, argPositionsAll: argPositionsAll } = this.parseArguments(stmts, etsComponentExpression.arguments, builderMethodIndexes);
+        if ((0, EtsConst_1.isEtsSystemComponent)(componentName)) {
+            const createMethodSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSignatureFromClassNameAndMethodName(componentName, EtsConst_1.COMPONENT_CREATE_FUNCTION);
+            const createInvokeExpr = new Expr_1.ArkStaticInvokeExpr(createMethodSignature, args);
+            const argPositionsAllFlat = argPositionsAll.flat();
+            let createInvokeExprPosition = Position_1.FullPosition.buildFromNode(etsComponentExpression, this.sourceFile);
+            const createInvokeExprPositions = [createInvokeExprPosition, ...argPositionsAllFlat];
+            const { value: componentValue, valueOriginalPositions: componentPositions, stmts: componentStmts, } = this.generateAssignStmtForValue(createInvokeExpr, createInvokeExprPositions);
+            stmts.push(...componentStmts);
+            if (etsComponentExpression.body) {
+                for (const statement of etsComponentExpression.body.statements) {
+                    stmts.push(...this.tsNodeToStmts(statement));
+                }
+            }
+            const popMethodSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSignatureFromClassNameAndMethodName(componentName, EtsConst_1.COMPONENT_POP_FUNCTION);
+            const popInvokeExpr = new Expr_1.ArkStaticInvokeExpr(popMethodSignature, []);
+            const popInvokeExprPositions = [Position_1.FullPosition.DEFAULT];
+            const popInvokeStmt = new Stmt_1.ArkInvokeStmt(popInvokeExpr);
+            popInvokeStmt.setOperandOriginalPositions(popInvokeExprPositions);
+            stmts.push(popInvokeStmt);
+            return { value: componentValue, valueOriginalPositions: componentPositions, stmts: stmts };
+        }
+        return this.createCustomViewStmt(componentName, args, argPositionsAll, etsComponentExpression, stmts);
+    }
+    classExpressionToValueAndStmts(classExpression) {
+        const declaringArkClass = this.declaringMethod.getDeclaringArkClass();
+        const declaringArkNamespace = declaringArkClass.getDeclaringArkNamespace();
+        const newClass = new ArkClass_1.ArkClass();
+        if (declaringArkNamespace) {
+            (0, ArkClassBuilder_1.buildNormalArkClassFromArkNamespace)(classExpression, declaringArkNamespace, newClass, this.sourceFile, this.declaringMethod);
+            declaringArkNamespace.addArkClass(newClass);
+        }
+        else {
+            const declaringArkFile = declaringArkClass.getDeclaringArkFile();
+            (0, ArkClassBuilder_1.buildNormalArkClassFromArkFile)(classExpression, declaringArkFile, newClass, this.sourceFile, this.declaringMethod);
+            declaringArkFile.addArkClass(newClass);
+        }
+        const classValue = this.getOrCreatLocal(newClass.getName(), new Type_1.ClassType(newClass.getSignature()));
+        return {
+            value: classValue,
+            valueOriginalPositions: [Position_1.FullPosition.buildFromNode(classExpression, this.sourceFile)],
+            stmts: [],
+        };
+    }
+    templateExpressionToValueAndStmts(templateExpression) {
+        const stmts = [];
+        const head = templateExpression.head;
+        const templateValues = [];
+        const templatePositions = [];
+        if (head.rawText) {
+            templateValues.push(ValueUtil_1.ValueUtil.createStringConst(head.rawText));
+            templatePositions.push([Position_1.FullPosition.buildFromNode(head, this.sourceFile)]);
+        }
+        for (const templateSpan of templateExpression.templateSpans) {
+            let { value: exprValue, valueOriginalPositions: exprPositions, stmts: exprStmts, } = this.tsNodeToValueAndStmts(templateSpan.expression);
+            stmts.push(...exprStmts);
+            if (IRUtils_1.IRUtils.moreThanOneAddress(exprValue)) {
+                ({ value: exprValue, valueOriginalPositions: exprPositions, stmts: exprStmts } =
+                    this.generateAssignStmtForValue(exprValue, exprPositions));
+                stmts.push(...exprStmts);
+            }
+            templateValues.push(exprValue);
+            templatePositions.push(exprPositions);
+            const literalRawText = templateSpan.literal.rawText;
+            if (literalRawText) {
+                templateValues.push(ValueUtil_1.ValueUtil.createStringConst(literalRawText));
+                templatePositions.push([Position_1.FullPosition.buildFromNode(templateSpan.literal, this.sourceFile)]);
+            }
+        }
+        let currTemplateValue = ValueUtil_1.ValueUtil.getUndefinedConst();
+        let currTemplatePositions = [Position_1.FullPosition.DEFAULT];
+        const templateValueCnt = templateValues.length;
+        if (templateValueCnt > 0) {
+            currTemplateValue = templateValues[0];
+            currTemplatePositions = templatePositions[0];
+            for (let i = 1; i < templateValueCnt; i++) {
+                const nextTemplatePositions = templatePositions[i];
+                const normalBinopExpr = new Expr_1.ArkNormalBinopExpr(currTemplateValue, templateValues[i], Expr_1.NormalBinaryOperator.Addition);
+                const normalBinopExprPositions = [Position_1.FullPosition.merge(currTemplatePositions[0], nextTemplatePositions[0]), ...currTemplatePositions, ...nextTemplatePositions];
+                const { value: combinationValue, valueOriginalPositions: combinationPositions, stmts: combinationStmts, } = this.generateAssignStmtForValue(normalBinopExpr, normalBinopExprPositions);
+                stmts.push(...combinationStmts);
+                currTemplateValue = combinationValue;
+                currTemplatePositions = combinationPositions;
+            }
+        }
+        return { value: currTemplateValue, valueOriginalPositions: currTemplatePositions, stmts: stmts };
+    }
+    identifierToValueAndStmts(identifier) {
+        // TODO: handle global variable
+        let identifierValue;
+        let identifierPositions = [Position_1.FullPosition.buildFromNode(identifier, this.sourceFile)];
+        if (identifier.text == Type_1.UndefinedType.getInstance().getName()) {
+            identifierValue = ValueUtil_1.ValueUtil.getUndefinedConst();
+        }
+        else {
+            identifierValue = this.getOrCreatLocal(identifier.text);
+        }
+        return { value: identifierValue, valueOriginalPositions: identifierPositions, stmts: [] };
+    }
+    propertyAccessExpressionToValue(propertyAccessExpression) {
+        const stmts = [];
+        let { value: baseValue, valueOriginalPositions: basePositions, stmts: baseStmts, } = this.tsNodeToValueAndStmts(propertyAccessExpression.expression);
+        stmts.push(...baseStmts);
+        if (IRUtils_1.IRUtils.moreThanOneAddress(baseValue)) {
+            ({ value: baseValue, valueOriginalPositions: basePositions, stmts: baseStmts } =
+                this.generateAssignStmtForValue(baseValue, basePositions));
+            stmts.push(...baseStmts);
+        }
+        if (!(baseValue instanceof Local_1.Local)) {
+            ({ value: baseValue, valueOriginalPositions: basePositions, stmts: baseStmts } =
+                this.generateAssignStmtForValue(baseValue, basePositions));
+            stmts.push(...baseStmts);
+        }
+        const fieldSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildFieldSignatureFromFieldName(propertyAccessExpression.name.getText(this.sourceFile));
+        const fieldRef = new Ref_1.ArkInstanceFieldRef(baseValue, fieldSignature);
+        const fieldRefPositions = [Position_1.FullPosition.buildFromNode(propertyAccessExpression, this.sourceFile), ...basePositions];
+        return { value: fieldRef, valueOriginalPositions: fieldRefPositions, stmts: stmts };
+    }
+    elementAccessExpressionToValueAndStmts(elementAccessExpression) {
+        const stmts = [];
+        let { value: baseValue, valueOriginalPositions: basePositions, stmts: baseStmts } = this.tsNodeToValueAndStmts(elementAccessExpression.expression);
+        stmts.push(...baseStmts);
+        if (!(baseValue instanceof Local_1.Local)) {
+            ({ value: baseValue, valueOriginalPositions: basePositions, stmts: baseStmts } =
+                this.generateAssignStmtForValue(baseValue, basePositions));
+            stmts.push(...baseStmts);
+        }
+        let { value: argumentValue, valueOriginalPositions: arguPositions, stmts: argumentStmts, } = this.tsNodeToValueAndStmts(elementAccessExpression.argumentExpression);
+        stmts.push(...argumentStmts);
+        if (IRUtils_1.IRUtils.moreThanOneAddress(argumentValue)) {
+            ({ value: argumentValue, valueOriginalPositions: arguPositions, stmts: argumentStmts } =
+                this.generateAssignStmtForValue(argumentValue, arguPositions));
+            stmts.push(...argumentStmts);
+        }
+        let elementAccessExpr;
+        if (baseValue.getType() instanceof Type_1.ArrayType) {
+            elementAccessExpr = new Ref_1.ArkArrayRef(baseValue, argumentValue);
+        }
+        else {
+            // TODO: deal with ArkStaticFieldRef
+            const fieldSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildFieldSignatureFromFieldName(argumentValue.toString());
+            elementAccessExpr = new Ref_1.ArkInstanceFieldRef(baseValue, fieldSignature);
+        }
+        const exprPositions = [Position_1.FullPosition.buildFromNode(elementAccessExpression, this.sourceFile), ...basePositions,
+            ...arguPositions];
+        return { value: elementAccessExpr, valueOriginalPositions: exprPositions, stmts: stmts };
+    }
+    callExpressionToValueAndStmts(callExpression) {
+        let realGenericTypes = undefined;
+        if (callExpression.typeArguments) {
+            realGenericTypes = [];
+            callExpression.typeArguments.forEach(typeArgument => {
+                // @ts-ignore
+                realGenericTypes.push(this.resolveTypeNode(typeArgument));
+            });
+        }
+        const stmts = [];
+        const { args: args, argPositionsAll: argPositionsAll } = this.parseArguments(stmts, callExpression.arguments);
+        const argPositionsAllFlat = argPositionsAll.flat();
+        let { value: callerValue, valueOriginalPositions: callerPositions, stmts: callerStmts, } = this.tsNodeToValueAndStmts(callExpression.expression);
+        stmts.push(...callerStmts);
+        let invokeValue;
+        let invokeValuePositions = [Position_1.FullPosition.buildFromNode(callExpression, this.sourceFile)];
+        if (callerValue instanceof Ref_1.ArkInstanceFieldRef) {
+            const methodSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSignatureFromMethodName(callerValue.getFieldName());
+            invokeValue = new Expr_1.ArkInstanceInvokeExpr(callerValue.getBase(), methodSignature, args, realGenericTypes);
+            invokeValuePositions.push(...callerPositions.slice(1), ...argPositionsAllFlat);
+        }
+        else if (callerValue instanceof Ref_1.ArkStaticFieldRef) {
+            const methodSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSignatureFromMethodName(callerValue.getFieldName());
+            invokeValue = new Expr_1.ArkStaticInvokeExpr(methodSignature, args, realGenericTypes);
+            invokeValuePositions.push(...argPositionsAllFlat);
+        }
+        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);
+            if (cls === null || cls === void 0 ? void 0 : cls.hasComponentDecorator()) {
+                return this.createCustomViewStmt(callerName, args, argPositionsAll, callExpression, stmts);
+            }
+            const methodSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSignatureFromMethodName(callerName);
+            if (callerValue.getType() instanceof Type_1.FunctionType) {
+                invokeValue = new Expr_1.ArkPtrInvokeExpr(methodSignature, callerValue, args, realGenericTypes);
+            }
+            else {
+                invokeValue = new Expr_1.ArkStaticInvokeExpr(methodSignature, args, realGenericTypes);
+            }
+            invokeValuePositions.push(...argPositionsAllFlat);
+        }
+        else {
+            ({ value: callerValue, valueOriginalPositions: callerPositions, stmts: callerStmts } =
+                this.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);
+        }
+        return { value: invokeValue, valueOriginalPositions: invokeValuePositions, stmts: stmts };
+    }
+    parseArguments(currStmts, argumentNodes, builderMethodIndexes) {
+        const args = [];
+        const argPositionsAll = [];
+        if (argumentNodes) {
+            for (let i = 0; i < argumentNodes.length; i++) {
+                const argument = argumentNodes[i];
+                const prevBuilderMethodContextFlag = this.builderMethodContextFlag;
+                if (builderMethodIndexes === null || builderMethodIndexes === void 0 ? void 0 : builderMethodIndexes.has(i)) {
+                    this.builderMethodContextFlag = true;
+                }
+                let { value: argValue, valueOriginalPositions: argPositions, stmts: argStmts, } = this.tsNodeToValueAndStmts(argument);
+                this.builderMethodContextFlag = prevBuilderMethodContextFlag;
+                currStmts.push(...argStmts);
+                if (IRUtils_1.IRUtils.moreThanOneAddress(argValue)) {
+                    ({ value: argValue, valueOriginalPositions: argPositions, stmts: argStmts } =
+                        this.generateAssignStmtForValue(argValue, argPositions));
+                    currStmts.push(...argStmts);
+                }
+                args.push(argValue);
+                argPositionsAll.push(argPositions);
+            }
+        }
+        return { args: args, argPositionsAll: argPositionsAll };
+    }
+    callableNodeToValueAndStmts(callableNode) {
+        const declaringClass = this.declaringMethod.getDeclaringArkClass();
+        const arrowArkMethod = new ArkMethod_1.ArkMethod();
+        if (this.builderMethodContextFlag) {
+            ModelUtils_1.ModelUtils.implicitArkUIBuilderMethods.add(arrowArkMethod);
+        }
+        (0, ArkMethodBuilder_1.buildArkMethodFromArkClass)(callableNode, declaringClass, arrowArkMethod, this.sourceFile, this.declaringMethod);
+        declaringClass.addMethod(arrowArkMethod);
+        const callableType = new Type_1.FunctionType(arrowArkMethod.getSignature());
+        const callableValue = this.getOrCreatLocal(arrowArkMethod.getName(), callableType);
+        return {
+            value: callableValue,
+            valueOriginalPositions: [Position_1.FullPosition.buildFromNode(callableNode, this.sourceFile)],
+            stmts: [],
+        };
+    }
+    newExpressionToValueAndStmts(newExpression) {
+        const className = newExpression.expression.getText(this.sourceFile);
+        if (className === Builtin_1.Builtin.ARRAY) {
+            return this.newArrayExpressionToValueAndStmts(newExpression);
+        }
+        const stmts = [];
+        let realGenericTypes = undefined;
+        if (newExpression.typeArguments) {
+            realGenericTypes = [];
+            newExpression.typeArguments.forEach(typeArgument => {
+                // @ts-ignore
+                realGenericTypes.push(this.resolveTypeNode(typeArgument));
+            });
+        }
+        const classSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildClassSignatureFromClassName(className);
+        const classType = new Type_1.ClassType(classSignature, realGenericTypes);
+        const newExpr = new Expr_1.ArkNewExpr(classType);
+        const { value: newLocal, valueOriginalPositions: newLocalPositions, stmts: newExprStmts, } = this.generateAssignStmtForValue(newExpr, [Position_1.FullPosition.buildFromNode(newExpression, this.sourceFile)]);
+        stmts.push(...newExprStmts);
+        const constructorMethodSubSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildMethodSubSignatureFromMethodName(TSConst_1.CONSTRUCTOR_NAME);
+        const constructorMethodSignature = new ArkSignature_1.MethodSignature(classSignature, constructorMethodSubSignature);
+        const { args: argValues, argPositionsAll: argPositionsAll } = this.parseArguments(stmts, newExpression.arguments);
+        const instanceInvokeExpr = new Expr_1.ArkInstanceInvokeExpr(newLocal, constructorMethodSignature, argValues);
+        const instanceInvokeExprPositions = [newLocalPositions[0], ...newLocalPositions, ...argPositionsAll.flat()];
+        const invokeStmt = new Stmt_1.ArkInvokeStmt(instanceInvokeExpr);
+        invokeStmt.setOperandOriginalPositions(instanceInvokeExprPositions);
+        stmts.push(invokeStmt);
+        return { value: newLocal, valueOriginalPositions: newLocalPositions, stmts: stmts };
+    }
+    newArrayExpressionToValueAndStmts(newArrayExpression) {
+        let baseType = Type_1.UnknownType.getInstance();
+        if (newArrayExpression.typeArguments && newArrayExpression.typeArguments.length > 0) {
+            const argumentType = this.resolveTypeNode(newArrayExpression.typeArguments[0]);
+            if (!(argumentType instanceof Type_1.AnyType || argumentType instanceof Type_1.UnknownType)) {
+                baseType = argumentType;
+            }
+        }
+        const stmts = [];
+        const { args: argumentValues, argPositionsAll: argumentPositionsAll } = this.parseArguments(stmts, newArrayExpression.arguments);
+        let arrayLength = newArrayExpression.arguments ? newArrayExpression.arguments.length : 0;
+        let arrayLengthValue = ValueUtil_1.ValueUtil.getOrCreateNumberConst(arrayLength);
+        let arrayLengthPosition = Position_1.FullPosition.DEFAULT;
+        let arrayLengthFlag = false;
+        if ((arrayLength === 1) && ((argumentValues[0].getType() instanceof Type_1.NumberType) || argumentValues[0].getType() instanceof Type_1.UnknownType)) {
+            arrayLengthValue = argumentValues[0];
+            arrayLengthPosition = argumentPositionsAll[0][0];
+            arrayLengthFlag = true;
+        }
+        if (baseType instanceof Type_1.UnknownType) {
+            if ((arrayLength > 1) && !(argumentValues[0].getType() instanceof Type_1.UnknownType)) {
+                baseType = argumentValues[0].getType();
+            }
+            else {
+                baseType = Type_1.AnyType.getInstance();
+            }
+        }
+        const newArrayExpr = new Expr_1.ArkNewArrayExpr(baseType, arrayLengthValue);
+        const newArrayExprPositions = [Position_1.FullPosition.buildFromNode(newArrayExpression, this.sourceFile),
+            arrayLengthPosition];
+        const { value: arrayLocal, valueOriginalPositions: arrayLocalPositions, stmts: arrayStmts, } = this.generateAssignStmtForValue(newArrayExpr, newArrayExprPositions);
+        stmts.push(...arrayStmts);
+        if (!arrayLengthFlag) {
+            for (let i = 0; i < arrayLength; i++) {
+                const arrayRef = new Ref_1.ArkArrayRef(arrayLocal, ValueUtil_1.ValueUtil.getOrCreateNumberConst(i));
+                const arrayRefPositions = [arrayLocalPositions[0], ...arrayLocalPositions, Position_1.FullPosition.DEFAULT];
+                const assignStmt = new Stmt_1.ArkAssignStmt(arrayRef, argumentValues[i]);
+                assignStmt.setOperandOriginalPositions([...arrayRefPositions, ...argumentPositionsAll[i]]);
+                stmts.push(assignStmt);
+            }
+        }
+        return { value: arrayLocal, valueOriginalPositions: arrayLocalPositions, stmts: stmts };
+    }
+    arrayLiteralExpressionToValueAndStmts(arrayLiteralExpression) {
+        const stmts = [];
+        const elementTypes = new Set();
+        const elementValues = [];
+        const elementPositonsAll = [];
+        const arrayLength = arrayLiteralExpression.elements.length;
+        for (const element of arrayLiteralExpression.elements) {
+            let { value: elementValue, valueOriginalPositions: elementPosition, stmts: elementStmts, } = this.tsNodeToValueAndStmts(element);
+            stmts.push(...elementStmts);
+            if (IRUtils_1.IRUtils.moreThanOneAddress(elementValue)) {
+                ({ value: elementValue, valueOriginalPositions: elementPosition, stmts: elementStmts } =
+                    this.generateAssignStmtForValue(elementValue, elementPosition));
+                stmts.push(...elementStmts);
+            }
+            elementValues.push(elementValue);
+            elementTypes.add(elementValue.getType());
+            elementPositonsAll.push(elementPosition);
+        }
+        let baseType = Type_1.AnyType.getInstance();
+        if (elementTypes.size == 1) {
+            baseType = elementTypes.keys().next().value;
+        }
+        else if (elementTypes.size > 1) {
+            baseType = new Type_1.UnionType(Array.from(elementTypes));
+        }
+        const newArrayExpr = new Expr_1.ArkNewArrayExpr(baseType, ValueUtil_1.ValueUtil.getOrCreateNumberConst(arrayLength), true);
+        const newArrayExprPositions = [Position_1.FullPosition.buildFromNode(arrayLiteralExpression, this.sourceFile),
+            Position_1.FullPosition.DEFAULT];
+        const { value: newArrayLocal, valueOriginalPositions: newArrayPositions, stmts: elementStmts, } = this.generateAssignStmtForValue(newArrayExpr, newArrayExprPositions);
+        stmts.push(...elementStmts);
+        for (let i = 0; i < arrayLength; i++) {
+            const arrayRef = new Ref_1.ArkArrayRef(newArrayLocal, ValueUtil_1.ValueUtil.getOrCreateNumberConst(i));
+            const arrayRefPositions = [newArrayPositions[0], ...newArrayPositions, Position_1.FullPosition.DEFAULT];
+            const assignStmt = new Stmt_1.ArkAssignStmt(arrayRef, elementValues[i]);
+            assignStmt.setOperandOriginalPositions([...arrayRefPositions, ...elementPositonsAll[i]]);
+            stmts.push(assignStmt);
+        }
+        return { value: newArrayLocal, valueOriginalPositions: newArrayPositions, stmts: stmts };
+    }
+    prefixUnaryExpressionToValueAndStmts(prefixUnaryExpression) {
+        const stmts = [];
+        let { value: operandValue, valueOriginalPositions: operandPositions, stmts: operandStmts, } = this.tsNodeToValueAndStmts(prefixUnaryExpression.operand);
+        stmts.push(...operandStmts);
+        if (IRUtils_1.IRUtils.moreThanOneAddress(operandValue)) {
+            ({ value: operandValue, valueOriginalPositions: operandPositions, stmts: operandStmts } =
+                this.generateAssignStmtForValue(operandValue, operandPositions));
+            stmts.push(...operandStmts);
+        }
+        const operatorToken = prefixUnaryExpression.operator;
+        let exprPositions = [Position_1.FullPosition.buildFromNode(prefixUnaryExpression, this.sourceFile)];
+        if (operatorToken === ts.SyntaxKind.PlusPlusToken || operatorToken === ts.SyntaxKind.MinusMinusToken) {
+            const binaryOperator = operatorToken === ts.SyntaxKind.PlusPlusToken ? Expr_1.NormalBinaryOperator.Addition : Expr_1.NormalBinaryOperator.Subtraction;
+            const binopExpr = new Expr_1.ArkNormalBinopExpr(operandValue, ValueUtil_1.ValueUtil.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 === ts.SyntaxKind.PlusToken) {
+            return { value: operandValue, valueOriginalPositions: operandPositions, stmts: stmts };
+        }
+        else {
+            let unopExpr;
+            const operator = ArkIRTransformer.tokenToUnaryOperator(operatorToken);
+            if (operator) {
+                unopExpr = new Expr_1.ArkUnopExpr(operandValue, operator);
+                exprPositions.push(...operandPositions);
+            }
+            else {
+                unopExpr = ValueUtil_1.ValueUtil.getUndefinedConst();
+                exprPositions = [Position_1.FullPosition.DEFAULT];
+            }
+            return { value: unopExpr, valueOriginalPositions: exprPositions, stmts: stmts };
+        }
+    }
+    postfixUnaryExpressionToValueAndStmts(postfixUnaryExpression) {
+        const stmts = [];
+        let { value: operandValue, valueOriginalPositions: operandPositions, stmts: exprStmts, } = this.tsNodeToValueAndStmts(postfixUnaryExpression.operand);
+        stmts.push(...exprStmts);
+        if (IRUtils_1.IRUtils.moreThanOneAddress(operandValue)) {
+            ({ value: operandValue, valueOriginalPositions: operandPositions, stmts: exprStmts } =
+                this.generateAssignStmtForValue(operandValue, operandPositions));
+            stmts.push(...exprStmts);
+        }
+        let value;
+        let exprPositions = [Position_1.FullPosition.buildFromNode(postfixUnaryExpression, this.sourceFile)];
+        const operatorToken = postfixUnaryExpression.operator;
+        if (operatorToken === ts.SyntaxKind.PlusPlusToken || operatorToken === ts.SyntaxKind.MinusMinusToken) {
+            const binaryOperator = operatorToken === ts.SyntaxKind.PlusPlusToken ? Expr_1.NormalBinaryOperator.Addition : Expr_1.NormalBinaryOperator.Subtraction;
+            const binopExpr = new Expr_1.ArkNormalBinopExpr(operandValue, ValueUtil_1.ValueUtil.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);
+            value = operandValue;
+        }
+        else {
+            value = ValueUtil_1.ValueUtil.getUndefinedConst();
+            exprPositions = [Position_1.FullPosition.DEFAULT];
+        }
+        return { value: value, valueOriginalPositions: exprPositions, stmts: stmts };
+    }
+    awaitExpressionToValueAndStmts(awaitExpression) {
+        const { value: promiseValue, valueOriginalPositions: promisePositions, stmts: stmts, } = this.tsNodeToValueAndStmts(awaitExpression.expression);
+        const awaitExpr = new Expr_1.ArkAwaitExpr(promiseValue);
+        const awaitExprPositions = [Position_1.FullPosition.buildFromNode(awaitExpression, this.sourceFile), ...promisePositions];
+        return { value: awaitExpr, valueOriginalPositions: awaitExprPositions, stmts: stmts };
+    }
+    yieldExpressionToValueAndStmts(yieldExpression) {
+        let yieldValue = ValueUtil_1.ValueUtil.getUndefinedConst();
+        let yieldPositions = [Position_1.FullPosition.DEFAULT];
+        let stmts = [];
+        if (yieldExpression.expression) {
+            ({ value: yieldValue, valueOriginalPositions: yieldPositions, stmts: stmts } =
+                this.tsNodeToValueAndStmts(yieldExpression.expression));
+        }
+        const yieldExpr = new Expr_1.ArkYieldExpr(yieldValue);
+        const yieldExprPositions = [Position_1.FullPosition.buildFromNode(yieldExpression, this.sourceFile), ...yieldPositions];
+        return { value: yieldExpr, valueOriginalPositions: yieldExprPositions, stmts: stmts };
+    }
+    deleteExpressionToValueAndStmts(deleteExpression) {
+        const { value: exprValue, valueOriginalPositions: exprPositions, stmts: stmts } = this.tsNodeToValueAndStmts(deleteExpression.expression);
+        const deleteExpr = new Expr_1.ArkDeleteExpr(exprValue);
+        const deleteExprPositions = [Position_1.FullPosition.buildFromNode(deleteExpression, this.sourceFile),
+            ...exprPositions];
+        return { value: deleteExpr, valueOriginalPositions: deleteExprPositions, stmts: stmts };
+    }
+    voidExpressionToValueAndStmts(voidExpression) {
+        const stmts = this.expressionToStmts(voidExpression.expression);
+        return { value: ValueUtil_1.ValueUtil.getUndefinedConst(), valueOriginalPositions: [Position_1.FullPosition.DEFAULT], stmts: stmts };
+    }
+    nonNullExpressionToValueAndStmts(nonNullExpression) {
+        return this.tsNodeToValueAndStmts(nonNullExpression.expression);
+    }
+    parenthesizedExpressionToValueAndStmts(parenthesizedExpression) {
+        return this.tsNodeToValueAndStmts(parenthesizedExpression.expression);
+    }
+    typeOfExpressionToValueAndStmts(typeOfExpression) {
+        const { value: exprValue, valueOriginalPositions: exprPositions, stmts: exprStmts, } = this.tsNodeToValueAndStmts(typeOfExpression.expression);
+        const typeOfExpr = new Expr_1.ArkTypeOfExpr(exprValue);
+        const typeOfExprPositions = [Position_1.FullPosition.buildFromNode(typeOfExpression, this.sourceFile), ...exprPositions];
+        return { value: typeOfExpr, valueOriginalPositions: typeOfExprPositions, stmts: exprStmts };
+    }
+    asExpressionToValueAndStmts(asExpression) {
+        const stmts = [];
+        let { value: exprValue, valueOriginalPositions: exprPositions, stmts: exprStmts } = this.tsNodeToValueAndStmts(asExpression.expression);
+        stmts.push(...exprStmts);
+        if (IRUtils_1.IRUtils.moreThanOneAddress(exprValue)) {
+            ({ value: exprValue, valueOriginalPositions: exprPositions, stmts: exprStmts } =
+                this.generateAssignStmtForValue(exprValue, exprPositions));
+            stmts.push(...exprStmts);
+        }
+        const castExpr = new Expr_1.ArkCastExpr(exprValue, this.resolveTypeNode(asExpression.type));
+        const castExprPositions = [Position_1.FullPosition.buildFromNode(asExpression, this.sourceFile), ...exprPositions];
+        return { value: castExpr, valueOriginalPositions: castExprPositions, stmts: stmts };
+    }
+    typeAssertionToValueAndStmts(typeAssertion) {
+        const { value: exprValue, valueOriginalPositions: exprPositions, stmts: exprStmts, } = this.tsNodeToValueAndStmts(typeAssertion.expression);
+        const castExpr = new Expr_1.ArkCastExpr(exprValue, this.resolveTypeNode(typeAssertion.type));
+        const castExprPositions = [Position_1.FullPosition.buildFromNode(typeAssertion, this.sourceFile), ...exprPositions];
+        return { value: castExpr, valueOriginalPositions: castExprPositions, stmts: exprStmts };
+    }
+    variableDeclarationListToValueAndStmts(variableDeclarationList) {
+        const stmts = [];
+        for (const declaration of variableDeclarationList.declarations) {
+            const { stmts: declaredStmts, } = this.variableDeclarationToValueAndStmts(declaration, variableDeclarationList.flags);
+            stmts.push(...declaredStmts);
+        }
+        return { value: ValueUtil_1.ValueUtil.getUndefinedConst(), valueOriginalPositions: [Position_1.FullPosition.DEFAULT], stmts: stmts };
+    }
+    variableDeclarationToValueAndStmts(variableDeclaration, nodeFlag) {
+        const leftOpNode = variableDeclaration.name;
+        let rightOpNode = null;
+        if (variableDeclaration.initializer) {
+            rightOpNode = variableDeclaration.initializer;
+        }
+        const stmts = [];
+        let { value: leftValue, valueOriginalPositions: leftPositions, stmts: leftStmts } = this.tsNodeToValueAndStmts(leftOpNode);
+        stmts.push(...leftStmts);
+        let rightValue;
+        let rightPositions;
+        if (rightOpNode) {
+            let { value: tempRightValue, valueOriginalPositions: tempRightPositions, stmts: rightStmts, } = this.tsNodeToValueAndStmts(rightOpNode);
+            stmts.push(...rightStmts);
+            rightValue = tempRightValue;
+            rightPositions = tempRightPositions;
+        }
+        else {
+            rightValue = ValueUtil_1.ValueUtil.getUndefinedConst();
+            rightPositions = [Position_1.FullPosition.DEFAULT];
+        }
+        if (IRUtils_1.IRUtils.moreThanOneAddress(leftValue) && IRUtils_1.IRUtils.moreThanOneAddress(rightValue)) {
+            const { value: tempRightValue, valueOriginalPositions: tempRightPositions, stmts: rightStmts, } = this.generateAssignStmtForValue(rightValue, rightPositions);
+            stmts.push(...rightStmts);
+            rightValue = tempRightValue;
+            rightPositions = tempRightPositions;
+        }
+        const isConst = (nodeFlag & ts.NodeFlags.Const) != 0;
+        if (leftValue instanceof Local_1.Local) {
+            leftValue.setConstFlag(isConst);
+            if (variableDeclaration.type) {
+                leftValue.setType(this.resolveTypeNode(variableDeclaration.type));
+            }
+            if (leftValue.getType() instanceof Type_1.UnknownType && !(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]);
+        stmts.push(assignStmt);
+        if (ts.isArrayBindingPattern(leftOpNode)) {
+            const elements = leftOpNode.elements;
+            let index = 0;
+            for (const element of elements) {
+                const arrayRef = new Ref_1.ArkArrayRef(leftValue, new Constant_1.Constant(index.toString(), Type_1.NumberType.getInstance()));
+                const arrayRefPositions = [leftPositions[0], ...leftPositions, Position_1.FullPosition.DEFAULT];
+                const item = new Local_1.Local(element.getText(this.sourceFile));
+                const itemPosition = Position_1.FullPosition.buildFromNode(element, this.sourceFile);
+                item.setConstFlag(isConst);
+                const assignStmt = new Stmt_1.ArkAssignStmt(item, arrayRef);
+                assignStmt.setOperandOriginalPositions([itemPosition, ...arrayRefPositions]);
+                stmts.push(assignStmt);
+                index++;
+            }
+        }
+        else if (ts.isObjectBindingPattern(leftOpNode)) {
+            const elements = leftOpNode.elements;
+            for (const element of elements) {
+                const fieldName = element.propertyName ? element.propertyName.getText(this.sourceFile) : element.name.getText(this.sourceFile);
+                const fieldSignature = ArkSignatureBuilder_1.ArkSignatureBuilder.buildFieldSignatureFromFieldName(fieldName);
+                const fieldRef = new Ref_1.ArkInstanceFieldRef(leftValue, fieldSignature);
+                const fieldRefPositions = [leftPositions[0], ...leftPositions];
+                const fieldLocal = this.getOrCreatLocal(element.name.getText(this.sourceFile));
+                fieldLocal.setConstFlag(isConst);
+                const fieldLocalPosition = Position_1.FullPosition.buildFromNode(element, this.sourceFile);
+                const assignStmt = new Stmt_1.ArkAssignStmt(fieldLocal, fieldRef);
+                assignStmt.setOperandOriginalPositions([fieldLocalPosition, ...fieldRefPositions]);
+                stmts.push(assignStmt);
+            }
+        }
+        return { value: leftValue, valueOriginalPositions: leftPositions, stmts: stmts };
+    }
+    binaryExpressionToValueAndStmts(binaryExpression) {
+        const compoundAssignmentOperators = new Set([ts.SyntaxKind.PlusEqualsToken,
+            ts.SyntaxKind.MinusEqualsToken,
+            ts.SyntaxKind.AsteriskAsteriskEqualsToken,
+            ts.SyntaxKind.AsteriskEqualsToken,
+            ts.SyntaxKind.SlashEqualsToken,
+            ts.SyntaxKind.PercentEqualsToken,
+            ts.SyntaxKind.AmpersandEqualsToken,
+            ts.SyntaxKind.BarEqualsToken,
+            ts.SyntaxKind.CaretEqualsToken,
+            ts.SyntaxKind.LessThanLessThanEqualsToken,
+            ts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken,
+            ts.SyntaxKind.GreaterThanGreaterThanEqualsToken,
+            ts.SyntaxKind.BarBarEqualsToken,
+            ts.SyntaxKind.AmpersandAmpersandEqualsToken,
+            ts.SyntaxKind.QuestionQuestionEqualsToken]);
+        const operatorToken = binaryExpression.operatorToken;
+        if (operatorToken.kind === ts.SyntaxKind.FirstAssignment) {
+            return this.assignmentToValueAndStmts(binaryExpression);
+        }
+        else if (compoundAssignmentOperators.has(operatorToken.kind)) {
+            return this.compoundAssignmentToValueAndStmts(binaryExpression);
+        }
+        const stmts = [];
+        let { value: opValue1, valueOriginalPositions: opPositions1, stmts: opStmts1, } = this.tsNodeToValueAndStmts(binaryExpression.left);
+        stmts.push(...opStmts1);
+        if (IRUtils_1.IRUtils.moreThanOneAddress(opValue1)) {
+            ({ value: opValue1, valueOriginalPositions: opPositions1, stmts: opStmts1 } =
+                this.generateAssignStmtForValue(opValue1, opPositions1));
+            stmts.push(...opStmts1);
+        }
+        const binaryExpressionPosition = Position_1.FullPosition.buildFromNode(binaryExpression, this.sourceFile);
+        if (operatorToken.kind === ts.SyntaxKind.InstanceOfKeyword) {
+            const instanceOfExpr = new Expr_1.ArkInstanceOfExpr(opValue1, new Type_1.UnclearReferenceType(binaryExpression.right.getText(this.sourceFile)));
+            const instanceOfExprPositions = [binaryExpressionPosition, ...opPositions1];
+            return { value: instanceOfExpr, valueOriginalPositions: instanceOfExprPositions, stmts: stmts };
+        }
+        let { value: opValue2, valueOriginalPositions: opPositions2, stmts: opStmts2, } = this.tsNodeToValueAndStmts(binaryExpression.right);
+        stmts.push(...opStmts2);
+        if (IRUtils_1.IRUtils.moreThanOneAddress(opValue2)) {
+            ({ value: opValue2, valueOriginalPositions: opPositions2, stmts: opStmts2 } =
+                this.generateAssignStmtForValue(opValue2, opPositions2));
+            stmts.push(...opStmts2);
+        }
+        let exprValue;
+        let exprValuePositions = [binaryExpressionPosition];
+        if (operatorToken.kind === ts.SyntaxKind.CommaToken) {
+            exprValue = opValue2;
+        }
+        else {
+            const operator = ArkIRTransformer.tokenToBinaryOperator(operatorToken.kind);
+            if (operator) {
+                if (this.isRelationalOperator(operator)) {
+                    exprValue = new Expr_1.ArkConditionExpr(opValue1, opValue2, operator);
+                }
+                else {
+                    exprValue = new Expr_1.ArkNormalBinopExpr(opValue1, opValue2, operator);
+                }
+                exprValuePositions.push(...opPositions1, ...opPositions2);
+            }
+            else {
+                exprValue = ValueUtil_1.ValueUtil.getUndefinedConst();
+                exprValuePositions.push(binaryExpressionPosition);
+            }
+        }
+        return { value: exprValue, valueOriginalPositions: exprValuePositions, stmts: stmts };
+    }
+    assignmentToValueAndStmts(binaryExpression) {
+        const leftOpNode = binaryExpression.left;
+        const rightOpNode = binaryExpression.right;
+        const stmts = [];
+        let { value: leftValue, valueOriginalPositions: leftPositions, stmts: leftStmts } = this.tsNodeToValueAndStmts(leftOpNode);
+        stmts.push(...leftStmts);
+        let { value: rightValue, valueOriginalPositions: rightPositions, stmts: rightStmts, } = this.tsNodeToValueAndStmts(rightOpNode);
+        stmts.push(...rightStmts);
+        if (IRUtils_1.IRUtils.moreThanOneAddress(leftValue) && IRUtils_1.IRUtils.moreThanOneAddress(rightValue)) {
+            const { value: newRightValue, valueOriginalPositions: newRightPositions, stmts: rightStmts, } = this.generateAssignStmtForValue(rightValue, rightPositions);
+            stmts.push(...rightStmts);
+            rightValue = newRightValue;
+            rightPositions = newRightPositions;
+        }
+        if (leftValue instanceof Local_1.Local && leftValue.getType() instanceof Type_1.UnknownType
+            && !(rightValue.getType() instanceof Type_1.UnknownType)) {
+            leftValue.setType(rightValue.getType());
+        }
+        const assignStmt = new Stmt_1.ArkAssignStmt(leftValue, rightValue);
+        assignStmt.setOperandOriginalPositions([...leftPositions, ...rightPositions]);
+        stmts.push(assignStmt);
+        return { value: leftValue, valueOriginalPositions: leftPositions, stmts: stmts };
+    }
+    compoundAssignmentToValueAndStmts(binaryExpression) {
+        const stmts = [];
+        let { value: leftValue, valueOriginalPositions: leftPositions, stmts: leftStmts, } = this.tsNodeToValueAndStmts(binaryExpression.left);
+        stmts.push(...leftStmts);
+        let { value: rightValue, valueOriginalPositions: rightPositions, stmts: rightStmts, } = this.tsNodeToValueAndStmts(binaryExpression.right);
+        stmts.push(...rightStmts);
+        if (IRUtils_1.IRUtils.moreThanOneAddress(leftValue) && IRUtils_1.IRUtils.moreThanOneAddress(rightValue)) {
+            const { value: newRightValue, valueOriginalPositions: newRightPositions, stmts: rightStmts, } = this.generateAssignStmtForValue(rightValue, rightPositions);
+            rightValue = newRightValue;
+            rightPositions = newRightPositions;
+            stmts.push(...rightStmts);
+        }
+        let leftOpValue;
+        let leftOpPositions;
+        const operator = this.compoundAssignmentTokenToBinaryOperator(binaryExpression.operatorToken.kind);
+        if (operator) {
+            const exprValue = new Expr_1.ArkNormalBinopExpr(leftValue, rightValue, operator);
+            const exprValuePosition = Position_1.FullPosition.buildFromNode(binaryExpression, this.sourceFile);
+            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.ValueUtil.getUndefinedConst();
+            leftOpPositions = [leftPositions[0]];
+        }
+        return { value: leftOpValue, valueOriginalPositions: leftOpPositions, stmts: stmts };
+    }
+    compoundAssignmentTokenToBinaryOperator(token) {
+        switch (token) {
+            case ts.SyntaxKind.QuestionQuestionEqualsToken:
+                return Expr_1.NormalBinaryOperator.NullishCoalescing;
+            case ts.SyntaxKind.AsteriskAsteriskEqualsToken:
+                return Expr_1.NormalBinaryOperator.Exponentiation;
+            case ts.SyntaxKind.SlashEqualsToken:
+                return Expr_1.NormalBinaryOperator.Division;
+            case ts.SyntaxKind.PlusEqualsToken:
+                return Expr_1.NormalBinaryOperator.Addition;
+            case ts.SyntaxKind.MinusEqualsToken:
+                return Expr_1.NormalBinaryOperator.Subtraction;
+            case ts.SyntaxKind.AsteriskEqualsToken:
+                return Expr_1.NormalBinaryOperator.Multiplication;
+            case ts.SyntaxKind.PercentEqualsToken:
+                return Expr_1.NormalBinaryOperator.Remainder;
+            case ts.SyntaxKind.LessThanLessThanEqualsToken:
+                return Expr_1.NormalBinaryOperator.LeftShift;
+            case ts.SyntaxKind.GreaterThanGreaterThanEqualsToken:
+                return Expr_1.NormalBinaryOperator.RightShift;
+            case ts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken:
+                return Expr_1.NormalBinaryOperator.UnsignedRightShift;
+            case ts.SyntaxKind.AmpersandEqualsToken:
+                return Expr_1.NormalBinaryOperator.BitwiseAnd;
+            case ts.SyntaxKind.BarEqualsToken:
+                return Expr_1.NormalBinaryOperator.BitwiseOr;
+            case ts.SyntaxKind.CaretEqualsToken:
+                return Expr_1.NormalBinaryOperator.BitwiseXor;
+            case ts.SyntaxKind.AmpersandAmpersandEqualsToken:
+                return Expr_1.NormalBinaryOperator.LogicalAnd;
+            case ts.SyntaxKind.BarBarEqualsToken:
+                return Expr_1.NormalBinaryOperator.LogicalOr;
+        }
+        return null;
+    }
+    conditionToValueAndStmts(condition) {
+        const stmts = [];
+        let { value: conditionValue, valueOriginalPositions: conditionPositions, stmts: conditionStmts, } = this.tsNodeToValueAndStmts(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.generateAssignStmtForValue(conditionValue, conditionPositions));
+                stmts.push(...conditionStmts);
+            }
+            conditionExpr = new Expr_1.ArkConditionExpr(conditionValue, ValueUtil_1.ValueUtil.getOrCreateNumberConst(0), Expr_1.RelationalBinaryOperator.InEquality);
+            conditionPositions = [conditionPositions[0], ...conditionPositions, Position_1.FullPosition.DEFAULT];
+        }
+        return { value: conditionExpr, valueOriginalPositions: conditionPositions, stmts: stmts };
+    }
+    literalNodeToValueAndStmts(literalNode) {
+        const syntaxKind = literalNode.kind;
+        let constant = null;
+        switch (syntaxKind) {
+            case ts.SyntaxKind.NumericLiteral:
+                constant = ValueUtil_1.ValueUtil.getOrCreateNumberConst(parseFloat(literalNode.text));
+                break;
+            case ts.SyntaxKind.BigIntLiteral:
+                constant = ValueUtil_1.ValueUtil.getOrCreateNumberConst(parseInt(literalNode.text));
+                break;
+            case ts.SyntaxKind.StringLiteral:
+                constant = ValueUtil_1.ValueUtil.createStringConst(literalNode.text);
+                break;
+            case ts.SyntaxKind.RegularExpressionLiteral:
+                constant = new Constant_1.Constant(literalNode.text, Builtin_1.Builtin.REGEXP_CLASS_TYPE);
+                break;
+            case ts.SyntaxKind.NoSubstitutionTemplateLiteral:
+                constant = ValueUtil_1.ValueUtil.createStringConst(literalNode.text);
+                break;
+            case ts.SyntaxKind.NullKeyword:
+                constant = ValueUtil_1.ValueUtil.getNullConstant();
+                break;
+            case ts.SyntaxKind.UndefinedKeyword:
+                constant = ValueUtil_1.ValueUtil.getUndefinedConst();
+                break;
+            case ts.SyntaxKind.TrueKeyword:
+                constant = ValueUtil_1.ValueUtil.getBooleanConstant(true);
+                break;
+            case ts.SyntaxKind.FalseKeyword:
+                constant = ValueUtil_1.ValueUtil.getBooleanConstant(false);
+                break;
+            default:
+                logger.warn(`ast node's syntaxKind is ${ts.SyntaxKind[literalNode.kind]}, not literalNode`);
+        }
+        if (constant === null) {
+            return null;
+        }
+        return {
+            value: constant,
+            valueOriginalPositions: [Position_1.FullPosition.buildFromNode(literalNode, this.sourceFile)],
+            stmts: [],
+        };
+    }
+    getOrCreatLocal(localName, localType = Type_1.UnknownType.getInstance()) {
+        let local = this.locals.get(localName) || null;
+        if (local == null) {
+            local = new Local_1.Local(localName, localType);
+            this.locals.set(localName, local);
+        }
+        return local;
+    }
+    generateTempLocal(localType = Type_1.UnknownType.getInstance()) {
+        const tempLocalName = this.tempLocalPrefix + this.tempLocalIndex;
+        this.tempLocalIndex++;
+        const tempLocal = new Local_1.Local(tempLocalName, localType);
+        this.locals.set(tempLocalName, tempLocal);
+        return tempLocal;
+    }
+    generateAssignStmtForValue(value, valueOriginalPositions) {
+        const leftOp = this.generateTempLocal(value.getType());
+        const leftOpPosition = valueOriginalPositions[0];
+        const assignStmt = new Stmt_1.ArkAssignStmt(leftOp, value);
+        assignStmt.setOperandOriginalPositions([leftOpPosition, ...valueOriginalPositions]);
+        return { value: leftOp, valueOriginalPositions: [leftOpPosition], stmts: [assignStmt] };
+    }
+    isRelationalOperator(operator) {
+        return operator == Expr_1.RelationalBinaryOperator.LessThan ||
+            operator == Expr_1.RelationalBinaryOperator.LessThanOrEqual ||
+            operator == Expr_1.RelationalBinaryOperator.GreaterThan ||
+            operator == Expr_1.RelationalBinaryOperator.GreaterThanOrEqual ||
+            operator == Expr_1.RelationalBinaryOperator.Equality ||
+            operator == Expr_1.RelationalBinaryOperator.InEquality ||
+            operator == Expr_1.RelationalBinaryOperator.StrictEquality ||
+            operator == Expr_1.RelationalBinaryOperator.StrictInequality;
+    }
+    resolveTypeNode(type) {
+        const kind = type.kind;
+        switch (kind) {
+            case ts.SyntaxKind.BooleanKeyword:
+                return Type_1.BooleanType.getInstance();
+            case ts.SyntaxKind.NumberKeyword:
+                return Type_1.NumberType.getInstance();
+            case ts.SyntaxKind.StringKeyword:
+                return Type_1.StringType.getInstance();
+            case ts.SyntaxKind.UndefinedKeyword:
+                return Type_1.UndefinedType.getInstance();
+            case ts.SyntaxKind.AnyKeyword:
+                return Type_1.AnyType.getInstance();
+            case ts.SyntaxKind.VoidKeyword:
+                return Type_1.VoidType.getInstance();
+            case ts.SyntaxKind.NeverKeyword:
+                return Type_1.NeverType.getInstance();
+            case ts.SyntaxKind.TypeReference:
+                return this.resolveTypeReferenceNode(type);
+            case ts.SyntaxKind.ArrayType:
+                return new Type_1.ArrayType(this.resolveTypeNode(type.elementType), 1);
+            case ts.SyntaxKind.UnionType:
+                const cur = type;
+                const mayTypes = [];
+                cur.types.forEach(t => mayTypes.push(this.resolveTypeNode(t)));
+                return new Type_1.UnionType(mayTypes);
+            case ts.SyntaxKind.TupleType:
+                const types = [];
+                type.elements.forEach(element => {
+                    types.push(this.resolveTypeNode(element));
+                });
+                return new Type_1.TupleType(types);
+            case ts.SyntaxKind.NamedTupleMember:
+                return this.resolveTypeNode(type.type);
+            case ts.SyntaxKind.LiteralType:
+                return this.resolveLiteralTypeNode(type);
+            case ts.SyntaxKind.TemplateLiteralType:
+                return this.resolveTemplateLiteralTypeNode(type);
+            case ts.SyntaxKind.TypeLiteral:
+                return this.resolveTypeLiteralNode(type);
+            case ts.SyntaxKind.FunctionType:
+                return this.resolveFunctionTypeNode(type);
+        }
+        return Type_1.UnknownType.getInstance();
+    }
+    resolveLiteralTypeNode(literalTypeNode) {
+        const literal = literalTypeNode.literal;
+        const kind = literal.kind;
+        switch (kind) {
+            case ts.SyntaxKind.NullKeyword:
+                return Type_1.NullType.getInstance();
+            case ts.SyntaxKind.TrueKeyword:
+                return Type_1.LiteralType.TRUE;
+            case ts.SyntaxKind.FalseKeyword:
+                return Type_1.LiteralType.FALSE;
+            case ts.SyntaxKind.NumericLiteral:
+                return new Type_1.LiteralType(parseFloat(literal.text));
+            case ts.SyntaxKind.PrefixUnaryExpression:
+                return new Type_1.LiteralType(parseFloat(literal.getText(this.sourceFile)));
+        }
+        return new Type_1.LiteralType(literal.getText(this.sourceFile));
+    }
+    resolveTemplateLiteralTypeNode(templateLiteralTypeNode) {
+        let stringLiterals = [''];
+        const headString = templateLiteralTypeNode.head.rawText || '';
+        let newStringLiterals = [];
+        for (const stringLiteral of stringLiterals) {
+            newStringLiterals.push(stringLiteral + headString);
+        }
+        stringLiterals = newStringLiterals;
+        newStringLiterals = [];
+        for (const templateSpan of templateLiteralTypeNode.templateSpans) {
+            const templateType = this.resolveTypeNode(templateSpan.type);
+            const unfoldTemplateTypes = [];
+            if (templateType instanceof Type_1.UnionType) {
+                unfoldTemplateTypes.push(...templateType.getTypes());
+            }
+            else {
+                unfoldTemplateTypes.push(templateType);
+            }
+            const unfoldTemplateTypeStrs = [];
+            for (const unfoldTemplateType of unfoldTemplateTypes) {
+                unfoldTemplateTypeStrs.push(unfoldTemplateType instanceof Type_1.AliasType ? unfoldTemplateType.getOriginalType().toString() : unfoldTemplateType.toString());
+            }
+            const templateSpanString = templateSpan.literal.rawText || '';
+            for (const stringLiteral of stringLiterals) {
+                for (const unfoldTemplateTypeStr of unfoldTemplateTypeStrs) {
+                    newStringLiterals.push(stringLiteral + unfoldTemplateTypeStr + templateSpanString);
+                }
+            }
+            stringLiterals = newStringLiterals;
+            newStringLiterals = [];
+        }
+        const templateTypes = [];
+        for (const stringLiteral of stringLiterals) {
+            templateTypes.push(new Type_1.LiteralType(stringLiteral));
+        }
+        if (templateTypes.length > 0) {
+            return new Type_1.UnionType(templateTypes);
+        }
+        return templateTypes[0];
+    }
+    resolveTypeReferenceNode(typeReferenceNode) {
+        const typeReferenceFullName = typeReferenceNode.getText(this.sourceFile);
+        const aliasTypeAndPosition = this.aliasTypeMap.get(typeReferenceFullName);
+        if (!aliasTypeAndPosition) {
+            const genericTypes = [];
+            if (typeReferenceNode.typeArguments) {
+                for (const typeArgument of typeReferenceNode.typeArguments) {
+                    genericTypes.push(this.resolveTypeNode(typeArgument));
+                }
+            }
+            // TODO:handle ts.QualifiedName
+            const typeNameNode = typeReferenceNode.typeName;
+            const typeName = typeNameNode.getText(this.sourceFile);
+            return new Type_1.UnclearReferenceType(typeName, genericTypes);
+        }
+        else {
+            return aliasTypeAndPosition[0];
+        }
+    }
+    resolveTypeLiteralNode(typeLiteralNode) {
+        const anonymousClass = new ArkClass_1.ArkClass();
+        const declaringClass = this.declaringMethod.getDeclaringArkClass();
+        const declaringNamespace = declaringClass.getDeclaringArkNamespace();
+        if (declaringNamespace) {
+            (0, ArkClassBuilder_1.buildNormalArkClassFromArkNamespace)(typeLiteralNode, declaringNamespace, anonymousClass, this.sourceFile);
+        }
+        else {
+            (0, ArkClassBuilder_1.buildNormalArkClassFromArkFile)(typeLiteralNode, declaringClass.getDeclaringArkFile(), anonymousClass, this.sourceFile);
+        }
+        return new Type_1.ClassType(anonymousClass.getSignature());
+    }
+    resolveFunctionTypeNode(functionTypeNode) {
+        const anonymousMethod = new ArkMethod_1.ArkMethod();
+        const declaringClass = this.declaringMethod.getDeclaringArkClass();
+        (0, ArkMethodBuilder_1.buildArkMethodFromArkClass)(functionTypeNode, declaringClass, anonymousMethod, this.sourceFile);
+        return new Type_1.FunctionType(anonymousMethod.getSignature());
+    }
+    isLiteralNode(node) {
+        if (ts.isStringLiteral(node) ||
+            ts.isNumericLiteral(node) ||
+            ts.isBigIntLiteral(node) ||
+            ts.isRegularExpressionLiteral(node) ||
+            ts.isNoSubstitutionTemplateLiteral(node) ||
+            node.kind === ts.SyntaxKind.NullKeyword ||
+            node.kind === ts.SyntaxKind.TrueKeyword ||
+            node.kind === ts.SyntaxKind.FalseKeyword ||
+            node.kind === ts.SyntaxKind.UndefinedKeyword) {
+            return true;
+        }
+        return false;
+    }
+    mapStmtsToTsStmt(stmts, node) {
+        const originalStmt = new Stmt_1.OriginalStmt(node.getText(this.sourceFile), Position_1.LineColPosition.buildFromNode(node, this.sourceFile));
+        for (const stmt of stmts) {
+            if (!this.stmtToOriginalStmt.has(stmt)) {
+                this.stmtToOriginalStmt.set(stmt, originalStmt);
+            }
+        }
+    }
+    static tokenToUnaryOperator(token) {
+        switch (token) {
+            case ts.SyntaxKind.MinusToken:
+                return Expr_1.UnaryOperator.Neg;
+            case ts.SyntaxKind.TildeToken:
+                return Expr_1.UnaryOperator.BitwiseNot;
+            case ts.SyntaxKind.ExclamationToken:
+                return Expr_1.UnaryOperator.LogicalNot;
+        }
+        return null;
+    }
+    static tokenToBinaryOperator(token) {
+        switch (token) {
+            case ts.SyntaxKind.QuestionQuestionToken:
+                return Expr_1.NormalBinaryOperator.NullishCoalescing;
+            case ts.SyntaxKind.AsteriskAsteriskToken:
+                return Expr_1.NormalBinaryOperator.Exponentiation;
+            case ts.SyntaxKind.SlashToken:
+                return Expr_1.NormalBinaryOperator.Division;
+            case ts.SyntaxKind.PlusToken:
+                return Expr_1.NormalBinaryOperator.Addition;
+            case ts.SyntaxKind.MinusToken:
+                return Expr_1.NormalBinaryOperator.Subtraction;
+            case ts.SyntaxKind.AsteriskToken:
+                return Expr_1.NormalBinaryOperator.Multiplication;
+            case ts.SyntaxKind.PercentToken:
+                return Expr_1.NormalBinaryOperator.Remainder;
+            case ts.SyntaxKind.LessThanLessThanToken:
+                return Expr_1.NormalBinaryOperator.LeftShift;
+            case ts.SyntaxKind.GreaterThanGreaterThanToken:
+                return Expr_1.NormalBinaryOperator.RightShift;
+            case ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken:
+                return Expr_1.NormalBinaryOperator.UnsignedRightShift;
+            case ts.SyntaxKind.AmpersandToken:
+                return Expr_1.NormalBinaryOperator.BitwiseAnd;
+            case ts.SyntaxKind.BarToken:
+                return Expr_1.NormalBinaryOperator.BitwiseOr;
+            case ts.SyntaxKind.CaretToken:
+                return Expr_1.NormalBinaryOperator.BitwiseXor;
+            case ts.SyntaxKind.AmpersandAmpersandToken:
+                return Expr_1.NormalBinaryOperator.LogicalAnd;
+            case ts.SyntaxKind.BarBarToken:
+                return Expr_1.NormalBinaryOperator.LogicalOr;
+            case ts.SyntaxKind.LessThanToken:
+                return Expr_1.RelationalBinaryOperator.LessThan;
+            case ts.SyntaxKind.LessThanEqualsToken:
+                return Expr_1.RelationalBinaryOperator.LessThanOrEqual;
+            case ts.SyntaxKind.GreaterThanToken:
+                return Expr_1.RelationalBinaryOperator.GreaterThan;
+            case ts.SyntaxKind.GreaterThanEqualsToken:
+                return Expr_1.RelationalBinaryOperator.GreaterThanOrEqual;
+            case ts.SyntaxKind.EqualsEqualsToken:
+                return Expr_1.RelationalBinaryOperator.Equality;
+            case ts.SyntaxKind.ExclamationEqualsToken:
+                return Expr_1.RelationalBinaryOperator.InEquality;
+            case ts.SyntaxKind.EqualsEqualsEqualsToken:
+                return Expr_1.RelationalBinaryOperator.StrictEquality;
+            case ts.SyntaxKind.ExclamationEqualsEqualsToken:
+                return Expr_1.RelationalBinaryOperator.StrictInequality;
+        }
+        return null;
+    }
+}
+exports.ArkIRTransformer = ArkIRTransformer;