arkanalyzer 1.0.16 → 1.0.18

package/lib/core/common/CfgBuilder.js

@@ -1,1886 +0,0 @@
-"use strict";
-/*
- * Copyright (c) 2024-2025 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CfgBuilder = void 0;
-const ts = __importStar(require("ohos-typescript"));
-const Local_1 = require("../base/Local");
-const Stmt_1 = require("../base/Stmt");
-const BasicBlock_1 = require("../graph/BasicBlock");
-const Cfg_1 = require("../graph/Cfg");
-const ArkIRTransformer_1 = require("./ArkIRTransformer");
-const ModelUtils_1 = require("./ModelUtils");
-const Expr_1 = require("../base/Expr");
-const Builtin_1 = require("./Builtin");
-const IRUtils_1 = require("./IRUtils");
-const Type_1 = require("../base/Type");
-const Trap_1 = require("../base/Trap");
-const logger_1 = __importStar(require("../../utils/logger"));
-const Ref_1 = require("../base/Ref");
-const Position_1 = require("../base/Position");
-const logger = logger_1.default.getLogger(logger_1.LOG_MODULE_TYPE.ARKANALYZER, 'CfgBuilder');
-class StatementBuilder {
-    constructor(type, code, astNode, scopeID) {
-        this.addressCode3 = [];
-        this.passTmies = 0;
-        this.numOfIdentifier = 0;
-        this.isDoWhile = false;
-        this.type = type;
-        this.code = code;
-        this.next = null;
-        this.lasts = new Set();
-        this.walked = false;
-        this.index = 0;
-        this.line = -1;
-        this.column = -1;
-        this.astNode = astNode;
-        this.scopeID = scopeID;
-        this.block = null;
-        this.ifExitPass = false;
-    }
-}
-class ConditionStatementBuilder extends StatementBuilder {
-    constructor(type, code, astNode, scopeID) {
-        super(type, code, astNode, scopeID);
-        this.doStatement = null;
-        this.nextT = null;
-        this.nextF = null;
-        this.loopBlock = null;
-        this.condition = '';
-    }
-}
-class SwitchStatementBuilder extends StatementBuilder {
-    constructor(type, code, astNode, scopeID) {
-        super(type, code, astNode, scopeID);
-        this.cases = [];
-        this.default = null;
-        this.afterSwitch = null;
-        this.nexts = [];
-    }
-}
-class TryStatementBuilder extends StatementBuilder {
-    constructor(type, code, astNode, scopeID) {
-        super(type, code, astNode, scopeID);
-        this.tryFirst = null;
-        this.tryExit = null;
-        this.catchStatement = null;
-        this.catchError = '';
-        this.finallyStatement = null;
-        this.afterFinal = null;
-    }
-}
-class Case {
-    constructor(value, stmt) {
-        this.value = value;
-        this.stmt = stmt;
-    }
-}
-class DefUseChain {
-    constructor(def, use) {
-        this.def = def;
-        this.use = use;
-    }
-}
-class Variable {
-    constructor(name, lastDef) {
-        this.properties = [];
-        this.propOf = null;
-        this.name = name;
-        this.lastDef = lastDef;
-        this.defUse = [];
-    }
-}
-class Scope {
-    constructor(id) {
-        this.id = id;
-    }
-}
-class Block {
-    constructor(id, stmts) {
-        this.nexts = [];
-        this.lasts = [];
-        this.walked = false;
-        this.id = id;
-        this.stmts = stmts;
-    }
-}
-class Catch {
-    constructor(errorName, from, to, withLabel) {
-        this.errorName = errorName;
-        this.from = from;
-        this.to = to;
-        this.withLabel = withLabel;
-    }
-}
-class textError extends Error {
-    constructor(message) {
-        // 调用父类的构造函数，并传入错误消息
-        super(message);
-        // 设置错误类型的名称
-        this.name = 'textError';
-    }
-}
-class CfgBuilder {
-    constructor(ast, name, declaringMethod, sourceFile) {
-        this.exits = [];
-        this.emptyBody = false;
-        this.arrowFunctionWithoutBlock = false;
-        this.name = name;
-        this.astRoot = ast;
-        this.declaringMethod = declaringMethod;
-        this.declaringClass = declaringMethod.getDeclaringArkClass();
-        this.entry = new StatementBuilder('entry', '', ast, 0);
-        this.loopStack = [];
-        this.switchExitStack = [];
-        this.functions = [];
-        this.breakin = '';
-        this.statementArray = [];
-        this.dotEdges = [];
-        this.exit = new StatementBuilder('exit', 'return;', null, 0);
-        this.scopes = [];
-        this.tempVariableNum = 0;
-        this.current3ACstm = this.entry;
-        this.blocks = [];
-        this.currentDeclarationKeyword = '';
-        this.variables = [];
-        this.importFromPath = [];
-        this.catches = [];
-        this.sourceFile = sourceFile;
-        this.arrowFunctionWithoutBlock = true;
-    }
-    getDeclaringMethod() {
-        return this.declaringMethod;
-    }
-    judgeLastType(s, lastStatement) {
-        if (lastStatement.type === 'ifStatement') {
-            let lastIf = lastStatement;
-            if (lastIf.nextT == null) {
-                lastIf.nextT = s;
-                s.lasts.add(lastIf);
-            }
-            else {
-                lastIf.nextF = s;
-                s.lasts.add(lastIf);
-            }
-        }
-        else if (lastStatement.type === 'loopStatement') {
-            let lastLoop = lastStatement;
-            lastLoop.nextT = s;
-            s.lasts.add(lastLoop);
-        }
-        else if (lastStatement.type === 'catchOrNot') {
-            let lastLoop = lastStatement;
-            lastLoop.nextT = s;
-            s.lasts.add(lastLoop);
-        }
-        else {
-            lastStatement.next = s;
-            s.lasts.add(lastStatement);
-        }
-    }
-    ASTNodeBreakStatement(c, lastStatement) {
-        let p = c;
-        while (p && p !== this.astRoot) {
-            if (ts.isWhileStatement(p) || ts.isDoStatement(p) || ts.isForStatement(p) || ts.isForInStatement(p) || ts.isForOfStatement(p)) {
-                const lastLoopNextF = this.loopStack[this.loopStack.length - 1].nextF;
-                this.judgeLastType(lastLoopNextF, lastStatement);
-                lastLoopNextF.lasts.add(lastStatement);
-                return;
-            }
-            if (ts.isCaseClause(p) || ts.isDefaultClause(p)) {
-                const lastSwitchExit = this.switchExitStack[this.switchExitStack.length - 1];
-                this.judgeLastType(lastSwitchExit, lastStatement);
-                lastSwitchExit.lasts.add(lastStatement);
-                return;
-            }
-            p = p.parent;
-        }
-    }
-    ASTNodeIfStatement(c, lastStatement, scopeID) {
-        let ifstm = new ConditionStatementBuilder('ifStatement', '', c, scopeID);
-        this.judgeLastType(ifstm, lastStatement);
-        let ifexit = new StatementBuilder('ifExit', '', c, scopeID);
-        this.exits.push(ifexit);
-        ifstm.condition = c.expression.getText(this.sourceFile);
-        ifstm.code = 'if (' + ifstm.condition + ')';
-        if (ts.isBlock(c.thenStatement)) {
-            this.walkAST(ifstm, ifexit, [...c.thenStatement.statements]);
-        }
-        else {
-            this.walkAST(ifstm, ifexit, [c.thenStatement]);
-        }
-        if (c.elseStatement) {
-            if (ts.isBlock(c.elseStatement)) {
-                this.walkAST(ifstm, ifexit, [...c.elseStatement.statements]);
-            }
-            else {
-                this.walkAST(ifstm, ifexit, [c.elseStatement]);
-            }
-        }
-        if (!ifstm.nextT) {
-            ifstm.nextT = ifexit;
-            ifexit.lasts.add(ifstm);
-        }
-        if (!ifstm.nextF) {
-            ifstm.nextF = ifexit;
-            ifexit.lasts.add(ifstm);
-        }
-        return ifexit;
-    }
-    ASTNodeWhileStatement(c, lastStatement, scopeID) {
-        this.breakin = 'loop';
-        let loopstm = new ConditionStatementBuilder('loopStatement', '', c, scopeID);
-        this.loopStack.push(loopstm);
-        this.judgeLastType(loopstm, lastStatement);
-        let loopExit = new StatementBuilder('loopExit', '', c, scopeID);
-        this.exits.push(loopExit);
-        loopstm.nextF = loopExit;
-        loopExit.lasts.add(loopstm);
-        loopstm.condition = c.expression.getText(this.sourceFile);
-        loopstm.code = 'while (' + loopstm.condition + ')';
-        if (ts.isBlock(c.statement)) {
-            this.walkAST(loopstm, loopstm, [...c.statement.statements]);
-        }
-        else {
-            this.walkAST(loopstm, loopstm, [c.statement]);
-        }
-        if (!loopstm.nextF) {
-            loopstm.nextF = loopExit;
-            loopExit.lasts.add(loopstm);
-        }
-        if (!loopstm.nextT) {
-            loopstm.nextT = loopExit;
-            loopExit.lasts.add(loopstm);
-        }
-        this.loopStack.pop();
-        return loopExit;
-    }
-    ASTNodeForStatement(c, lastStatement, scopeID) {
-        var _a, _b, _c, _d, _e;
-        this.breakin = 'loop';
-        let loopstm = new ConditionStatementBuilder('loopStatement', '', c, scopeID);
-        this.loopStack.push(loopstm);
-        this.judgeLastType(loopstm, lastStatement);
-        let loopExit = new StatementBuilder('loopExit', '', c, scopeID);
-        this.exits.push(loopExit);
-        loopstm.nextF = loopExit;
-        loopExit.lasts.add(loopstm);
-        loopstm.code = 'for (';
-        if (ts.isForStatement(c)) {
-            loopstm.code += ((_a = c.initializer) === null || _a === void 0 ? void 0 : _a.getText(this.sourceFile)) + '; ' + ((_b = c.condition) === null || _b === void 0 ? void 0 : _b.getText(this.sourceFile)) + '; ' + ((_c = c.incrementor) === null || _c === void 0 ? void 0 : _c.getText(this.sourceFile));
-        }
-        else if (ts.isForOfStatement(c)) {
-            loopstm.code += ((_d = c.initializer) === null || _d === void 0 ? void 0 : _d.getText(this.sourceFile)) + ' of ' + c.expression.getText(this.sourceFile);
-        }
-        else {
-            loopstm.code += ((_e = c.initializer) === null || _e === void 0 ? void 0 : _e.getText(this.sourceFile)) + ' in ' + c.expression.getText(this.sourceFile);
-        }
-        loopstm.code += ')';
-        if (ts.isBlock(c.statement)) {
-            this.walkAST(loopstm, loopstm, [...c.statement.statements]);
-        }
-        else {
-            this.walkAST(loopstm, loopstm, [c.statement]);
-        }
-        if (!loopstm.nextF) {
-            loopstm.nextF = loopExit;
-            loopExit.lasts.add(loopstm);
-        }
-        if (!loopstm.nextT) {
-            loopstm.nextT = loopExit;
-            loopExit.lasts.add(loopstm);
-        }
-        this.loopStack.pop();
-        return loopExit;
-    }
-    ASTNodeDoStatement(c, lastStatement, scopeID) {
-        var _a, _b;
-        this.breakin = 'loop';
-        let loopstm = new ConditionStatementBuilder('loopStatement', '', c, scopeID);
-        this.loopStack.push(loopstm);
-        let loopExit = new StatementBuilder('loopExit', '', c, scopeID);
-        this.exits.push(loopExit);
-        loopstm.nextF = loopExit;
-        loopExit.lasts.add(loopstm);
-        loopstm.condition = c.expression.getText(this.sourceFile);
-        loopstm.code = 'while (' + loopstm.condition + ')';
-        loopstm.isDoWhile = true;
-        if (ts.isBlock(c.statement)) {
-            this.walkAST(lastStatement, loopstm, [...c.statement.statements]);
-        }
-        else {
-            this.walkAST(lastStatement, loopstm, [c.statement]);
-        }
-        let lastType = lastStatement.type;
-        if (lastType === 'ifStatement' || lastType === 'loopStatement') {
-            let lastCondition = lastStatement;
-            loopstm.nextT = lastCondition.nextT;
-            (_a = lastCondition.nextT) === null || _a === void 0 ? void 0 : _a.lasts.add(loopstm);
-        }
-        else {
-            loopstm.nextT = lastStatement.next;
-            (_b = lastStatement.next) === null || _b === void 0 ? void 0 : _b.lasts.add(loopstm);
-        }
-        if (loopstm.nextT && loopstm.nextT !== loopstm) {
-            loopstm.nextT.isDoWhile = true;
-            loopstm.doStatement = loopstm.nextT;
-        }
-        this.loopStack.pop();
-        return loopExit;
-    }
-    ASTNodeSwitchStatement(c, lastStatement, scopeID) {
-        var _a;
-        this.breakin = 'switch';
-        let switchstm = new SwitchStatementBuilder('switchStatement', '', c, scopeID);
-        this.judgeLastType(switchstm, lastStatement);
-        let switchExit = new StatementBuilder('switchExit', '', null, scopeID);
-        this.exits.push(switchExit);
-        this.switchExitStack.push(switchExit);
-        switchExit.lasts.add(switchstm);
-        switchstm.code = 'switch (' + c.expression + ')';
-        let lastCaseExit = null;
-        for (let i = 0; i < c.caseBlock.clauses.length; i++) {
-            const clause = c.caseBlock.clauses[i];
-            let casestm;
-            if (ts.isCaseClause(clause)) {
-                casestm = new StatementBuilder('statement', 'case ' + clause.expression.getText(this.sourceFile) + ':', clause, scopeID);
-            }
-            else {
-                casestm = new StatementBuilder('statement', 'default:', clause, scopeID);
-            }
-            switchstm.nexts.push(casestm);
-            casestm.lasts.add(switchstm);
-            let caseExit = new StatementBuilder('caseExit', '', null, scopeID);
-            this.exits.push(caseExit);
-            this.walkAST(casestm, caseExit, [...clause.statements]);
-            if (ts.isCaseClause(clause)) {
-                const cas = new Case(casestm.code, casestm.next);
-                switchstm.cases.push(cas);
-            }
-            else {
-                switchstm.default = casestm.next;
-            }
-            switchstm.nexts[switchstm.nexts.length - 1] = casestm.next;
-            for (const stmt of [...casestm.lasts]) {
-                casestm.next.lasts.add(stmt);
-            }
-            casestm.next.lasts.delete(casestm);
-            if (lastCaseExit) {
-                lastCaseExit.next = casestm.next;
-                (_a = casestm.next) === null || _a === void 0 ? void 0 : _a.lasts.add(lastCaseExit);
-            }
-            lastCaseExit = caseExit;
-            if (i === c.caseBlock.clauses.length - 1) {
-                caseExit.next = switchExit;
-                switchExit.lasts.add(caseExit);
-            }
-        }
-        this.switchExitStack.pop();
-        return switchExit;
-    }
-    ASTNodeTryStatement(c, lastStatement, scopeID) {
-        var _a, _b;
-        let trystm = new TryStatementBuilder('tryStatement', 'try', c, scopeID);
-        this.judgeLastType(trystm, lastStatement);
-        let tryExit = new StatementBuilder('tryExit', '', c, scopeID);
-        this.exits.push(tryExit);
-        trystm.tryExit = tryExit;
-        this.walkAST(trystm, tryExit, [...c.tryBlock.statements]);
-        trystm.tryFirst = trystm.next;
-        (_a = trystm.next) === null || _a === void 0 ? void 0 : _a.lasts.add(trystm);
-        if (c.catchClause) {
-            let text = 'catch';
-            if (c.catchClause.variableDeclaration) {
-                text += '(' + c.catchClause.variableDeclaration.getText(this.sourceFile) + ')';
-            }
-            let catchOrNot = new ConditionStatementBuilder('catchOrNot', text, c, scopeID);
-            let catchExit = new StatementBuilder('catch exit', '', c, scopeID);
-            catchOrNot.nextF = catchExit;
-            catchExit.lasts.add(catchOrNot);
-            this.walkAST(catchOrNot, catchExit, [...c.catchClause.block.statements]);
-            if (!catchOrNot.nextT) {
-                catchOrNot.nextT = catchExit;
-                catchExit.lasts.add(catchOrNot);
-            }
-            const catchStatement = new StatementBuilder('statement', catchOrNot.code, c.catchClause, catchOrNot.nextT.scopeID);
-            catchStatement.next = catchOrNot.nextT;
-            trystm.catchStatement = catchStatement;
-            catchStatement.lasts.add(trystm);
-            if (c.catchClause.variableDeclaration) {
-                trystm.catchError = c.catchClause.variableDeclaration.getText(this.sourceFile);
-            }
-            else {
-                trystm.catchError = 'Error';
-            }
-        }
-        let final = new StatementBuilder('statement', 'finally', c, scopeID);
-        let finalExit = new StatementBuilder('finallyExit', '', c, scopeID);
-        this.exits.push(finalExit);
-        if (c.finallyBlock && c.finallyBlock.statements.length > 0) {
-            this.walkAST(final, finalExit, [...c.finallyBlock.statements]);
-        }
-        else {
-            let dummyFinally = new StatementBuilder('statement', 'dummyFinally', c, (new Scope(this.scopes.length)).id);
-            final.next = dummyFinally;
-            dummyFinally.lasts.add(final);
-            dummyFinally.next = finalExit;
-            finalExit.lasts.add(dummyFinally);
-        }
-        trystm.finallyStatement = final.next;
-        tryExit.next = final.next;
-        (_b = final.next) === null || _b === void 0 ? void 0 : _b.lasts.add(tryExit);
-        trystm.next = finalExit;
-        finalExit.lasts.add(trystm);
-        return finalExit;
-    }
-    walkAST(lastStatement, nextStatement, nodes) {
-        let scope = new Scope(this.scopes.length);
-        this.scopes.push(scope);
-        for (let i = 0; i < nodes.length; i++) {
-            let c = nodes[i];
-            if (ts.isVariableStatement(c) || ts.isExpressionStatement(c) || ts.isThrowStatement(c) || ts.isTypeAliasDeclaration(c)) {
-                let s = new StatementBuilder('statement', c.getText(this.sourceFile), c, scope.id);
-                this.judgeLastType(s, lastStatement);
-                lastStatement = s;
-            }
-            else if (!this.declaringMethod.isDefaultArkMethod() && ts.isFunctionDeclaration(c)) {
-                let s = new StatementBuilder('functionDeclarationStatement', c.getText(this.sourceFile), c, scope.id);
-                this.judgeLastType(s, lastStatement);
-                lastStatement = s;
-            }
-            else if (!this.declaringMethod.isDefaultArkMethod() && ts.isClassDeclaration(c)) {
-                let s = new StatementBuilder('classDeclarationStatement', c.getText(this.sourceFile), c, scope.id);
-                this.judgeLastType(s, lastStatement);
-                lastStatement = s;
-            }
-            else if (ts.isReturnStatement(c)) {
-                let s = new StatementBuilder('returnStatement', c.getText(this.sourceFile), c, scope.id);
-                this.judgeLastType(s, lastStatement);
-                lastStatement = s;
-                break;
-            }
-            else if (ts.isBreakStatement(c)) {
-                this.ASTNodeBreakStatement(c, lastStatement);
-                return;
-            }
-            else if (ts.isContinueStatement(c)) {
-                const lastLoop = this.loopStack[this.loopStack.length - 1];
-                this.judgeLastType(lastLoop, lastStatement);
-                lastLoop.lasts.add(lastStatement);
-                return;
-            }
-            else if (ts.isIfStatement(c)) {
-                lastStatement = this.ASTNodeIfStatement(c, lastStatement, scope.id);
-            }
-            else if (ts.isWhileStatement(c)) {
-                lastStatement = this.ASTNodeWhileStatement(c, lastStatement, scope.id);
-            }
-            if (ts.isForStatement(c) || ts.isForInStatement(c) || ts.isForOfStatement(c)) {
-                lastStatement = this.ASTNodeForStatement(c, lastStatement, scope.id);
-            }
-            else if (ts.isDoStatement(c)) {
-                lastStatement = this.ASTNodeDoStatement(c, lastStatement, scope.id);
-            }
-            else if (ts.isSwitchStatement(c)) {
-                lastStatement = this.ASTNodeSwitchStatement(c, lastStatement, scope.id);
-            }
-            else if (ts.isBlock(c)) {
-                let blockExit = new StatementBuilder('blockExit', '', c, scope.id);
-                this.exits.push(blockExit);
-                this.walkAST(lastStatement, blockExit, c.getChildren(this.sourceFile)[1].getChildren(this.sourceFile));
-                lastStatement = blockExit;
-            }
-            else if (ts.isTryStatement(c)) {
-                lastStatement = this.ASTNodeTryStatement(c, lastStatement, scope.id);
-            }
-            else if (ts.isExportAssignment(c)) {
-                if (ts.isNewExpression(c.expression) || ts.isObjectLiteralExpression(c.expression)) {
-                    let s = new StatementBuilder('statement', c.getText(this.sourceFile), c, scope.id);
-                    this.judgeLastType(s, lastStatement);
-                    lastStatement = s;
-                }
-            }
-        }
-        if (lastStatement.type !== 'breakStatement' && lastStatement.type !== 'continueStatement' && lastStatement.type !== 'returnStatement') {
-            lastStatement.next = nextStatement;
-            nextStatement.lasts.add(lastStatement);
-        }
-    }
-    addReturnInEmptyMethod() {
-        if (this.entry.next === this.exit) {
-            const ret = new StatementBuilder('returnStatement', 'return;', null, this.entry.scopeID);
-            this.entry.next = ret;
-            ret.lasts.add(this.entry);
-            ret.next = this.exit;
-            this.exit.lasts = new Set([ret]);
-        }
-    }
-    deleteExitAfterCondition(last, exit) {
-        if (last.nextT === exit) {
-            last.nextT = exit.next;
-            const lasts = exit.next.lasts;
-            lasts.delete(exit);
-            lasts.add(last);
-        }
-        else if (last.nextF === exit) {
-            last.nextF = exit.next;
-            const lasts = exit.next.lasts;
-            lasts.delete(exit);
-            lasts.add(last);
-        }
-    }
-    deleteExitAfterSwitch(last, exit) {
-        var _a;
-        if (exit.type === 'switchExit') {
-            last.afterSwitch = exit.next;
-        }
-        exit.next.lasts.delete(exit);
-        last.nexts = last.nexts.filter(item => item !== exit);
-        if (last.nexts.length === 0) {
-            last.next = exit.next;
-            (_a = exit.next) === null || _a === void 0 ? void 0 : _a.lasts.add(last);
-        }
-    }
-    deleteExit() {
-        for (const exit of this.exits) {
-            const lasts = [...exit.lasts];
-            for (const last of lasts) {
-                if (last instanceof ConditionStatementBuilder) {
-                    this.deleteExitAfterCondition(last, exit);
-                }
-                else if (last instanceof SwitchStatementBuilder) {
-                    this.deleteExitAfterSwitch(last, exit);
-                }
-                else if (last instanceof TryStatementBuilder && exit.type === 'finallyExit') {
-                    last.afterFinal = exit.next;
-                    last.next = last.tryFirst;
-                    exit.lasts.delete(last);
-                }
-                else {
-                    last.next = exit.next;
-                    const lasts = exit.next.lasts;
-                    lasts.delete(exit);
-                    lasts.add(last);
-                }
-            }
-        }
-        // 部分语句例如return后面的exit语句的next无法在上面清除
-        for (const exit of this.exits) {
-            if (exit.next && exit.next.lasts.has(exit)) {
-                exit.next.lasts.delete(exit);
-            }
-        }
-    }
-    addStmt2BlockStmtQueueInSpecialCase(stmt, stmtQueue) {
-        if (stmt.next) {
-            if ((stmt.type === 'continueStatement' || stmt.next.type === 'loopStatement') && stmt.next.block || stmt.next.type.includes('exit')) {
-                return null;
-            }
-            stmt.next.passTmies++;
-            if (stmt.next.passTmies === stmt.next.lasts.size || stmt.next.type === 'loopStatement' || stmt.next.isDoWhile) {
-                if (stmt.next.scopeID !== stmt.scopeID && !(stmt.next instanceof ConditionStatementBuilder && stmt.next.doStatement) &&
-                    !(ts.isCaseClause(stmt.astNode) || ts.isDefaultClause(stmt.astNode))) {
-                    stmtQueue.push(stmt.next);
-                    return null;
-                }
-                return stmt.next;
-            }
-        }
-        return null;
-    }
-    addStmt2BlockStmtQueue(stmt, stmtQueue) {
-        if (stmt instanceof ConditionStatementBuilder) {
-            stmtQueue.push(stmt.nextF);
-            stmtQueue.push(stmt.nextT);
-        }
-        else if (stmt instanceof SwitchStatementBuilder) {
-            if (stmt.nexts.length === 0) {
-                stmtQueue.push(stmt.afterSwitch);
-            }
-            for (let i = stmt.nexts.length - 1; i >= 0; i--) {
-                stmtQueue.push(stmt.nexts[i]);
-            }
-        }
-        else if (stmt instanceof TryStatementBuilder) {
-            if (stmt.finallyStatement) {
-                stmtQueue.push(stmt.finallyStatement);
-            }
-            if (stmt.catchStatement) {
-                stmtQueue.push(stmt.catchStatement);
-            }
-            if (stmt.tryFirst) {
-                stmtQueue.push(stmt.tryFirst);
-            }
-        }
-        else if (stmt.next) {
-            return this.addStmt2BlockStmtQueueInSpecialCase(stmt, stmtQueue);
-        }
-        return null;
-    }
-    buildBlocks() {
-        const stmtQueue = [this.entry];
-        const handledStmts = new Set();
-        while (stmtQueue.length > 0) {
-            let stmt = stmtQueue.pop();
-            if (stmt.type.includes('exit')) {
-                continue;
-            }
-            if (handledStmts.has(stmt)) {
-                continue;
-            }
-            const block = new Block(this.blocks.length, []);
-            this.blocks.push(block);
-            while (stmt && !handledStmts.has(stmt)) {
-                if (stmt.type === 'loopStatement' && block.stmts.length > 0 && !stmt.isDoWhile) {
-                    stmtQueue.push(stmt);
-                    break;
-                }
-                if (stmt.type.includes('Exit')) {
-                    break;
-                }
-                block.stmts.push(stmt);
-                stmt.block = block;
-                handledStmts.add(stmt);
-                const addRet = this.addStmt2BlockStmtQueue(stmt, stmtQueue);
-                if (addRet instanceof StatementBuilder) {
-                    stmt = addRet;
-                }
-                else {
-                    break;
-                }
-            }
-        }
-    }
-    buildConditionNextBlocks(originStatement, block, isLastStatement) {
-        var _a, _b, _c, _d;
-        let nextT = (_a = originStatement.nextT) === null || _a === void 0 ? void 0 : _a.block;
-        if (nextT && (isLastStatement || nextT !== block) && !((_b = originStatement.nextT) === null || _b === void 0 ? void 0 : _b.type.includes(' exit'))) {
-            block.nexts.push(nextT);
-            nextT.lasts.push(block);
-        }
-        let nextF = (_c = originStatement.nextF) === null || _c === void 0 ? void 0 : _c.block;
-        if (nextF && (isLastStatement || nextF !== block) && !((_d = originStatement.nextF) === null || _d === void 0 ? void 0 : _d.type.includes(' exit'))) {
-            block.nexts.push(nextF);
-            nextF.lasts.push(block);
-        }
-    }
-    buildSwitchNextBlocks(originStatement, block, isLastStatement) {
-        if (originStatement.nexts.length === 0) {
-            const nextBlock = originStatement.afterSwitch.block;
-            if (nextBlock && (isLastStatement || nextBlock !== block)) {
-                block.nexts.push(nextBlock);
-                nextBlock.lasts.push(block);
-            }
-        }
-        for (const next of originStatement.nexts) {
-            const nextBlock = next.block;
-            if (nextBlock && (isLastStatement || nextBlock !== block)) {
-                block.nexts.push(nextBlock);
-                nextBlock.lasts.push(block);
-            }
-        }
-    }
-    buildNormalNextBlocks(originStatement, block, isLastStatement) {
-        var _a, _b;
-        let next = (_a = originStatement.next) === null || _a === void 0 ? void 0 : _a.block;
-        if (next && (isLastStatement || next !== block) && !((_b = originStatement.next) === null || _b === void 0 ? void 0 : _b.type.includes(' exit'))) {
-            block.nexts.push(next);
-            next.lasts.push(block);
-        }
-    }
-    buildBlocksNextLast() {
-        for (let block of this.blocks) {
-            for (let originStatement of block.stmts) {
-                let isLastStatement = (block.stmts.indexOf(originStatement) === block.stmts.length - 1);
-                if (originStatement instanceof ConditionStatementBuilder) {
-                    this.buildConditionNextBlocks(originStatement, block, isLastStatement);
-                }
-                else if (originStatement instanceof SwitchStatementBuilder) {
-                    this.buildSwitchNextBlocks(originStatement, block, isLastStatement);
-                }
-                else {
-                    this.buildNormalNextBlocks(originStatement, block, isLastStatement);
-                }
-            }
-        }
-    }
-    addReturnBlock(returnStatement, notReturnStmts) {
-        var _a, _b, _c;
-        let returnBlock = new Block(this.blocks.length, [returnStatement]);
-        returnStatement.block = returnBlock;
-        this.blocks.push(returnBlock);
-        for (const notReturnStmt of notReturnStmts) {
-            if (notReturnStmt instanceof ConditionStatementBuilder) {
-                if (this.exit === notReturnStmt.nextT) {
-                    notReturnStmt.nextT = returnStatement;
-                    (_a = notReturnStmt.block) === null || _a === void 0 ? void 0 : _a.nexts.splice(0, 0, returnBlock);
-                }
-                else if (this.exit === notReturnStmt.nextF) {
-                    notReturnStmt.nextF = returnStatement;
-                    (_b = notReturnStmt.block) === null || _b === void 0 ? void 0 : _b.nexts.push(returnBlock);
-                }
-            }
-            else {
-                notReturnStmt.next = returnStatement;
-                (_c = notReturnStmt.block) === null || _c === void 0 ? void 0 : _c.nexts.push(returnBlock);
-            }
-            returnStatement.lasts.add(notReturnStmt);
-            returnStatement.next = this.exit;
-            const lasts = [...this.exit.lasts];
-            lasts[lasts.indexOf(notReturnStmt)] = returnStatement;
-            this.exit.lasts = new Set(lasts);
-            returnBlock.lasts.push(notReturnStmt.block);
-        }
-        this.exit.block = returnBlock;
-    }
-    addReturnStmt() {
-        var _a;
-        let notReturnStmts = [];
-        for (let stmt of [...this.exit.lasts]) {
-            if (stmt.type !== 'returnStatement') {
-                notReturnStmts.push(stmt);
-            }
-        }
-        if (notReturnStmts.length < 1) {
-            return;
-        }
-        const returnStatement = new StatementBuilder('returnStatement', 'return;', null, this.exit.scopeID);
-        let TryOrSwitchExit = false;
-        if (notReturnStmts.length === 1 && notReturnStmts[0].block) {
-            let p = notReturnStmts[0].astNode;
-            while (p && p !== this.astRoot) {
-                if (ts.isTryStatement(p) || ts.isSwitchStatement(p)) {
-                    TryOrSwitchExit = true;
-                    break;
-                }
-                p = p.parent;
-            }
-        }
-        if (notReturnStmts.length === 1 && !(notReturnStmts[0] instanceof ConditionStatementBuilder) && !TryOrSwitchExit) {
-            const notReturnStmt = notReturnStmts[0];
-            notReturnStmt.next = returnStatement;
-            returnStatement.lasts = new Set([notReturnStmt]);
-            returnStatement.next = this.exit;
-            const lasts = [...this.exit.lasts];
-            lasts[lasts.indexOf(notReturnStmt)] = returnStatement;
-            this.exit.lasts = new Set(lasts);
-            (_a = notReturnStmt.block) === null || _a === void 0 ? void 0 : _a.stmts.push(returnStatement);
-            returnStatement.block = notReturnStmt.block;
-        }
-        else {
-            this.addReturnBlock(returnStatement, notReturnStmts);
-        }
-    }
-    resetWalked() {
-        for (let stmt of this.statementArray) {
-            stmt.walked = false;
-        }
-    }
-    addStmtBuilderPosition() {
-        for (const stmt of this.statementArray) {
-            if (stmt.astNode) {
-                const { line, character } = ts.getLineAndCharacterOfPosition(this.sourceFile, stmt.astNode.getStart(this.sourceFile));
-                stmt.line = line + 1;
-                stmt.column = character + 1;
-            }
-        }
-    }
-    CfgBuilder2Array(stmt) {
-        if (stmt.walked)
-            return;
-        stmt.walked = true;
-        stmt.index = this.statementArray.length;
-        if (!stmt.type.includes(' exit'))
-            this.statementArray.push(stmt);
-        if (stmt.type === 'ifStatement' || stmt.type === 'loopStatement' || stmt.type === 'catchOrNot') {
-            let cstm = stmt;
-            if (cstm.nextT == null || cstm.nextF == null) {
-                this.errorTest(cstm);
-                return;
-            }
-            this.CfgBuilder2Array(cstm.nextF);
-            this.CfgBuilder2Array(cstm.nextT);
-        }
-        else if (stmt.type === 'switchStatement') {
-            let sstm = stmt;
-            for (let ss of sstm.nexts) {
-                this.CfgBuilder2Array(ss);
-            }
-        }
-        else if (stmt.type === 'tryStatement') {
-            let trystm = stmt;
-            if (trystm.tryFirst) {
-                this.CfgBuilder2Array(trystm.tryFirst);
-            }
-            if (trystm.catchStatement) {
-                this.CfgBuilder2Array(trystm.catchStatement);
-            }
-            if (trystm.finallyStatement) {
-                this.CfgBuilder2Array(trystm.finallyStatement);
-            }
-            if (trystm.next) {
-                this.CfgBuilder2Array(trystm.next);
-            }
-        }
-        else {
-            if (stmt.next != null)
-                this.CfgBuilder2Array(stmt.next);
-        }
-    }
-    getDotEdges(stmt) {
-        if (this.statementArray.length === 0)
-            this.CfgBuilder2Array(this.entry);
-        if (stmt.walked)
-            return;
-        stmt.walked = true;
-        if (stmt.type === 'ifStatement' || stmt.type === 'loopStatement' || stmt.type === 'catchOrNot') {
-            let cstm = stmt;
-            if (cstm.nextT == null || cstm.nextF == null) {
-                this.errorTest(cstm);
-                return;
-            }
-            let edge = [cstm.index, cstm.nextF.index];
-            this.dotEdges.push(edge);
-            edge = [cstm.index, cstm.nextT.index];
-            this.dotEdges.push(edge);
-            this.getDotEdges(cstm.nextF);
-            this.getDotEdges(cstm.nextT);
-        }
-        else if (stmt.type === 'switchStatement') {
-            let sstm = stmt;
-            for (let ss of sstm.nexts) {
-                let edge = [sstm.index, ss.index];
-                this.dotEdges.push(edge);
-                this.getDotEdges(ss);
-            }
-        }
-        else {
-            if (stmt.next != null) {
-                let edge = [stmt.index, stmt.next.index];
-                this.dotEdges.push(edge);
-                this.getDotEdges(stmt.next);
-            }
-        }
-    }
-    errorTest(stmt) {
-        var _a, _b;
-        let mes = 'ifnext error    ';
-        if ((_a = this.declaringClass) === null || _a === void 0 ? void 0 : _a.getDeclaringArkFile()) {
-            mes += ((_b = this.declaringClass) === null || _b === void 0 ? void 0 : _b.getDeclaringArkFile().getName()) + '.' + this.declaringClass.getName() + '.' + this.name;
-        }
-        mes += '\n' + stmt.code;
-        throw new textError(mes);
-    }
-    printBlocks() {
-        var _a, _b, _c, _d, _e, _f, _g;
-        let text = '';
-        if ((_a = this.declaringClass) === null || _a === void 0 ? void 0 : _a.getDeclaringArkFile()) {
-            text += this.declaringClass.getDeclaringArkFile().getName() + '\n';
-        }
-        for (let bi = 0; bi < this.blocks.length; bi++) {
-            let block = this.blocks[bi];
-            if (bi !== 0)
-                text += 'label' + block.id + ':\n';
-            let length = block.stmts.length;
-            for (let i = 0; i < length; i++) {
-                let stmt = block.stmts[i];
-                if (stmt.type === 'ifStatement' || stmt.type === 'loopStatement' || stmt.type === 'catchOrNot') {
-                    let cstm = stmt;
-                    if (cstm.nextT == null || cstm.nextF == null) {
-                        this.errorTest(cstm);
-                        return text;
-                    }
-                    if (!cstm.nextF.block || !cstm.nextT.block) {
-                        this.errorTest(cstm);
-                        return text;
-                    }
-                    stmt.code = 'if !(' + cstm.condition + ') goto label' + cstm.nextF.block.id;
-                    if (i === length - 1 && bi + 1 < this.blocks.length && this.blocks[bi + 1].id !== cstm.nextT.block.id) {
-                        let gotoStm = new StatementBuilder('gotoStatement', 'goto label' + cstm.nextT.block.id, null, block.stmts[0].scopeID);
-                        block.stmts.push(gotoStm);
-                        length++;
-                    }
-                }
-                else if (stmt.type === 'breakStatement' || stmt.type === 'continueStatement') {
-                    if (!((_b = stmt.next) === null || _b === void 0 ? void 0 : _b.block)) {
-                        this.errorTest(stmt);
-                        return text;
-                    }
-                    stmt.code = 'goto label' + ((_c = stmt.next) === null || _c === void 0 ? void 0 : _c.block.id);
-                }
-                else {
-                    if (i === length - 1 && ((_d = stmt.next) === null || _d === void 0 ? void 0 : _d.block) && (bi + 1 < this.blocks.length && this.blocks[bi + 1].id !== stmt.next.block.id || bi + 1 === this.blocks.length)) {
-                        let gotoStm = new StatementBuilder('StatementBuilder', 'goto label' + ((_e = stmt.next) === null || _e === void 0 ? void 0 : _e.block.id), null, block.stmts[0].scopeID);
-                        block.stmts.push(gotoStm);
-                        length++;
-                    }
-                }
-                if (stmt.addressCode3.length === 0) {
-                    text += '    ' + stmt.code + '\n';
-                }
-                else {
-                    for (let ac of stmt.addressCode3) {
-                        if (ac.startsWith('if') || ac.startsWith('while')) {
-                            let cstm = stmt;
-                            let condition = ac.substring(ac.indexOf('('));
-                            let goto = '';
-                            if ((_f = cstm.nextF) === null || _f === void 0 ? void 0 : _f.block)
-                                goto = 'if !' + condition + ' goto label' + ((_g = cstm.nextF) === null || _g === void 0 ? void 0 : _g.block.id);
-                            stmt.addressCode3[stmt.addressCode3.indexOf(ac)] = goto;
-                            text += '    ' + goto + '\n';
-                        }
-                        else
-                            text += '    ' + ac + '\n';
-                    }
-                }
-            }
-        }
-        for (let cat of this.catches) {
-            text += 'catch ' + cat.errorName + ' from label ' + cat.from + ' to label ' + cat.to + ' with label' + cat.withLabel + '\n';
-        }
-        return text;
-    }
-    buildStatementBuilder4ArrowFunction(stmt) {
-        let s = new StatementBuilder('statement', stmt.getText(this.sourceFile), stmt, 0);
-        this.entry.next = s;
-        s.lasts = new Set([this.entry]);
-        s.next = this.exit;
-        this.exit.lasts = new Set([s]);
-    }
-    buildCfgBuilder() {
-        let stmts = [];
-        if (ts.isSourceFile(this.astRoot)) {
-            stmts = [...this.astRoot.statements];
-        }
-        else if (ts.isFunctionDeclaration(this.astRoot) || ts.isMethodDeclaration(this.astRoot) || ts.isConstructorDeclaration(this.astRoot)
-            || ts.isGetAccessorDeclaration(this.astRoot) || ts.isSetAccessorDeclaration(this.astRoot) || ts.isFunctionExpression(this.astRoot)
-            || ts.isClassStaticBlockDeclaration(this.astRoot)) {
-            if (this.astRoot.body) {
-                stmts = [...this.astRoot.body.statements];
-            }
-            else {
-                this.emptyBody = true;
-            }
-        }
-        else if (ts.isArrowFunction(this.astRoot)) {
-            if (ts.isBlock(this.astRoot.body)) {
-                stmts = [...this.astRoot.body.statements];
-            }
-        }
-        else if (ts.isMethodSignature(this.astRoot) || ts.isConstructSignatureDeclaration(this.astRoot)
-            || ts.isCallSignatureDeclaration(this.astRoot) || ts.isFunctionTypeNode(this.astRoot)) {
-            this.emptyBody = true;
-        }
-        else if (ts.isModuleDeclaration(this.astRoot) && ts.isModuleBlock(this.astRoot.body)) {
-            stmts = [...this.astRoot.body.statements];
-        }
-        if (!ModelUtils_1.ModelUtils.isArkUIBuilderMethod(this.declaringMethod)) {
-            this.walkAST(this.entry, this.exit, stmts);
-        }
-        else {
-            this.handleBuilder(stmts);
-        }
-        if (ts.isArrowFunction(this.astRoot) && !ts.isBlock(this.astRoot.body)) {
-            this.buildStatementBuilder4ArrowFunction(this.astRoot.body);
-        }
-        this.addReturnInEmptyMethod();
-        this.deleteExit();
-        this.CfgBuilder2Array(this.entry);
-        this.addStmtBuilderPosition();
-        this.buildBlocks();
-        this.blocks = this.blocks.filter((b) => b.stmts.length !== 0);
-        this.buildBlocksNextLast();
-        this.addReturnStmt();
-    }
-    handleBuilder(stmts) {
-        let lastStmt = this.entry;
-        for (const stmt of stmts) {
-            const stmtBuilder = new StatementBuilder('statement', stmt.getText(this.sourceFile), stmt, 0);
-            lastStmt.next = stmtBuilder;
-            stmtBuilder.lasts.add(lastStmt);
-            lastStmt = stmtBuilder;
-        }
-        lastStmt.next = this.exit;
-        this.exit.lasts.add(lastStmt);
-    }
-    isBodyEmpty() {
-        return this.emptyBody;
-    }
-    buildCfgAndOriginalCfg() {
-        if (ts.isArrowFunction(this.astRoot) && !ts.isBlock(this.astRoot.body)) {
-            return this.buildCfgAndOriginalCfgForSimpleArrowFunction();
-        }
-        return this.buildNormalCfgAndOriginalCfg();
-    }
-    buildCfgAndOriginalCfgForSimpleArrowFunction() {
-        const stmts = [];
-        const arkIRTransformer = new ArkIRTransformer_1.ArkIRTransformer(this.sourceFile, this.declaringMethod);
-        arkIRTransformer.prebuildStmts().forEach(stmt => stmts.push(stmt));
-        const expressionBodyNode = this.astRoot.body;
-        const expressionBodyStmts = [];
-        let { value: expressionBodyValue, valueOriginalPositions: expressionBodyPositions, stmts: tempStmts, } = arkIRTransformer.tsNodeToValueAndStmts(expressionBodyNode);
-        tempStmts.forEach(stmt => expressionBodyStmts.push(stmt));
-        if (IRUtils_1.IRUtils.moreThanOneAddress(expressionBodyValue)) {
-            ({
-                value: expressionBodyValue,
-                valueOriginalPositions: expressionBodyPositions,
-                stmts: tempStmts,
-            } = arkIRTransformer.generateAssignStmtForValue(expressionBodyValue, expressionBodyPositions));
-            tempStmts.forEach(stmt => expressionBodyStmts.push(stmt));
-        }
-        const returnStmt = new Stmt_1.ArkReturnStmt(expressionBodyValue);
-        returnStmt.setOperandOriginalPositions([expressionBodyPositions[0], ...expressionBodyPositions]);
-        expressionBodyStmts.push(returnStmt);
-        arkIRTransformer.mapStmtsToTsStmt(expressionBodyStmts, expressionBodyNode);
-        expressionBodyStmts.forEach(stmt => stmts.push(stmt));
-        const cfg = new Cfg_1.Cfg();
-        const blockInCfg = new BasicBlock_1.BasicBlock();
-        blockInCfg.setId(0);
-        stmts.forEach(stmt => {
-            blockInCfg.addStmt(stmt);
-            stmt.setCfg(cfg);
-        });
-        cfg.addBlock(blockInCfg);
-        cfg.setStartingStmt(stmts[0]);
-        return {
-            cfg: cfg,
-            locals: arkIRTransformer.getLocals(),
-            globals: arkIRTransformer.getGlobals(),
-            aliasTypeMap: arkIRTransformer.getAliasTypeMap(),
-            traps: [],
-        };
-    }
-    buildNormalCfgAndOriginalCfg() {
-        const blockBuilderToCfgBlock = new Map();
-        const basicBlockSet = new Set();
-        const arkIRTransformer = new ArkIRTransformer_1.ArkIRTransformer(this.sourceFile, this.declaringMethod);
-        const blocksContainLoopCondition = new Set();
-        const blockBuildersBeforeTry = new Set();
-        const blockBuildersContainSwitch = [];
-        const valueAndStmtsOfSwitchAndCasesAll = [];
-        for (let i = 0; i < this.blocks.length; i++) {
-            // build block in Cfg
-            const stmtsInBlock = [];
-            if (i === 0) {
-                arkIRTransformer.prebuildStmts().forEach(stmt => stmtsInBlock.push(stmt));
-            }
-            const stmtsCnt = this.blocks[i].stmts.length;
-            if (this.blocks[i].stmts[stmtsCnt - 1].type === 'tryStatement') {
-                blockBuildersBeforeTry.add(this.blocks[i]);
-            }
-            for (const statementBuilder of this.blocks[i].stmts) {
-                if (statementBuilder.type === 'loopStatement') {
-                    blocksContainLoopCondition.add(this.blocks[i]);
-                }
-                else if (statementBuilder instanceof SwitchStatementBuilder) {
-                    blockBuildersContainSwitch.push(this.blocks[i]);
-                    const valueAndStmtsOfSwitchAndCases = arkIRTransformer.switchStatementToValueAndStmts(statementBuilder.astNode);
-                    valueAndStmtsOfSwitchAndCasesAll.push(valueAndStmtsOfSwitchAndCases);
-                    continue;
-                }
-                if (statementBuilder.astNode && statementBuilder.code !== '') {
-                    arkIRTransformer.tsNodeToStmts(statementBuilder.astNode).forEach(s => stmtsInBlock.push(s));
-                }
-                else if (statementBuilder.code.startsWith('return')) {
-                    stmtsInBlock.push(new Stmt_1.ArkReturnVoidStmt());
-                }
-            }
-            const blockInCfg = new BasicBlock_1.BasicBlock();
-            blockInCfg.setId(this.blocks[i].id);
-            for (const stmt of stmtsInBlock) {
-                blockInCfg.addStmt(stmt);
-            }
-            basicBlockSet.add(blockInCfg);
-            blockBuilderToCfgBlock.set(this.blocks[i], blockInCfg);
-        }
-        let currBlockId = this.blocks.length;
-        this.linkBasicBlocks(blockBuilderToCfgBlock);
-        this.rebuildBlocksInLoop(blockBuilderToCfgBlock, blocksContainLoopCondition, basicBlockSet);
-        this.buildSwitch(blockBuilderToCfgBlock, blockBuildersContainSwitch, valueAndStmtsOfSwitchAndCasesAll, arkIRTransformer, basicBlockSet);
-        this.rebuildBlocksContainConditionalOperator(basicBlockSet);
-        const traps = this.buildTraps(blockBuilderToCfgBlock, blockBuildersBeforeTry, arkIRTransformer, basicBlockSet);
-        for (const blockBuilder of this.blocks) {
-            if (blockBuilder.id === -1) {
-                blockBuilder.id = currBlockId++;
-                const block = blockBuilderToCfgBlock.get(blockBuilder);
-                block.setId(blockBuilder.id);
-            }
-        }
-        const cfg = new Cfg_1.Cfg();
-        const startingBasicBlock = blockBuilderToCfgBlock.get(this.blocks[0]);
-        cfg.setStartingStmt(startingBasicBlock.getStmts()[0]);
-        currBlockId = 0;
-        for (const basicBlock of basicBlockSet) {
-            basicBlock.setId(currBlockId++);
-            cfg.addBlock(basicBlock);
-        }
-        for (const stmt of cfg.getStmts()) {
-            stmt.setCfg(cfg);
-        }
-        return {
-            cfg: cfg,
-            locals: arkIRTransformer.getLocals(),
-            globals: arkIRTransformer.getGlobals(),
-            aliasTypeMap: arkIRTransformer.getAliasTypeMap(),
-            traps: traps,
-        };
-    }
-    linkBasicBlocks(blockBuilderToCfgBlock) {
-        for (const [blockBuilder, cfgBlock] of blockBuilderToCfgBlock) {
-            for (const successorBlockBuilder of blockBuilder.nexts) {
-                if (!blockBuilderToCfgBlock.get(successorBlockBuilder)) {
-                    continue;
-                }
-                const successorBlock = blockBuilderToCfgBlock.get(successorBlockBuilder);
-                cfgBlock.addSuccessorBlock(successorBlock);
-            }
-            for (const predecessorBlockBuilder of blockBuilder.lasts) {
-                if (!blockBuilderToCfgBlock.get(predecessorBlockBuilder)) {
-                    continue;
-                }
-                const predecessorBlock = blockBuilderToCfgBlock.get(predecessorBlockBuilder);
-                cfgBlock.addPredecessorBlock(predecessorBlock);
-            }
-        }
-    }
-    rebuildBlocksContainConditionalOperator(basicBlockSet) {
-        var _a;
-        if (ModelUtils_1.ModelUtils.isArkUIBuilderMethod(this.declaringMethod)) {
-            this.deleteDummyConditionalOperatorStmt(basicBlockSet);
-            return;
-        }
-        const currBasicBlocks = Array.from(basicBlockSet);
-        for (const currBasicBlock of currBasicBlocks) {
-            const stmtsInCurrBasicBlock = Array.from(currBasicBlock.getStmts());
-            const stmtsCnt = stmtsInCurrBasicBlock.length;
-            let conditionalOperatorEndPos = -1;
-            for (let i = stmtsCnt - 1; i >= 0; i--) {
-                const stmt = stmtsInCurrBasicBlock[i];
-                if (stmt instanceof ArkIRTransformer_1.DummyStmt && ((_a = stmt.toString()) === null || _a === void 0 ? void 0 : _a.startsWith(ArkIRTransformer_1.ArkIRTransformer.DUMMY_CONDITIONAL_OPERATOR_END_STMT))) {
-                    conditionalOperatorEndPos = i;
-                    break;
-                }
-            }
-            if (conditionalOperatorEndPos === -1) {
-                continue;
-            }
-            let { generatedTopBlock: generatedTopBlock, generatedBottomBlocks: generatedBottomBlocks, } = this.generateBlocksContainConditionalOperatorGroup(stmtsInCurrBasicBlock.slice(0, conditionalOperatorEndPos + 1), basicBlockSet);
-            if (conditionalOperatorEndPos !== stmtsCnt - 1) { // need create a new basic block for rest statements
-                const { generatedTopBlock: extraBlock, } = this.generateBlockWithoutConditionalOperator(stmtsInCurrBasicBlock.slice(conditionalOperatorEndPos + 1));
-                generatedBottomBlocks.forEach(generatedBottomBlock => {
-                    generatedBottomBlock.addSuccessorBlock(extraBlock);
-                    extraBlock.addPredecessorBlock(generatedBottomBlock);
-                });
-                basicBlockSet.add(extraBlock);
-                generatedBottomBlocks = this.removeUnnecessaryBlocksInConditionalOperator(extraBlock, basicBlockSet);
-            }
-            this.relinkPrevAndSuccOfBlockContainConditionalOperator(currBasicBlock, generatedTopBlock, generatedBottomBlocks);
-            basicBlockSet.delete(currBasicBlock);
-        }
-    }
-    relinkPrevAndSuccOfBlockContainConditionalOperator(currBasicBlock, generatedTopBlock, generatedBottomBlocks) {
-        const predecessorsOfCurrBasicBlock = Array.from(currBasicBlock.getPredecessors());
-        predecessorsOfCurrBasicBlock.forEach(predecessor => {
-            predecessor.removeSuccessorBlock(currBasicBlock);
-            currBasicBlock.removePredecessorBlock(predecessor);
-            generatedTopBlock.addPredecessorBlock(predecessor);
-            predecessor.addSuccessorBlock(generatedTopBlock);
-        });
-        const successorsOfCurrBasicBlock = Array.from(currBasicBlock.getSuccessors());
-        successorsOfCurrBasicBlock.forEach(successor => {
-            successor.removePredecessorBlock(currBasicBlock);
-            currBasicBlock.removeSuccessorBlock(successor);
-            generatedBottomBlocks.forEach(generatedBottomBlock => {
-                generatedBottomBlock.addSuccessorBlock(successor);
-                successor.addPredecessorBlock(generatedBottomBlock);
-            });
-        });
-    }
-    generateBlocksContainConditionalOperatorGroup(sourceStmts, basicBlockSet) {
-        const { firstEndPos: firstEndPos } = this.findFirstConditionalOperator(sourceStmts);
-        if (firstEndPos === -1) {
-            return this.generateBlockWithoutConditionalOperator(sourceStmts);
-        }
-        const { generatedTopBlock: firstGeneratedTopBlock, generatedBottomBlocks: firstGeneratedBottomBlocks, generatedAllBlocks: firstGeneratedAllBlocks, } = this.generateBlocksContainSingleConditionalOperator(sourceStmts.slice(0, firstEndPos + 1));
-        const generatedTopBlock = firstGeneratedTopBlock;
-        let generatedBottomBlocks = firstGeneratedBottomBlocks;
-        firstGeneratedAllBlocks.forEach(block => basicBlockSet.add(block));
-        const stmtsCnt = sourceStmts.length;
-        if (firstEndPos !== stmtsCnt - 1) { // need handle other conditional operators
-            const { generatedTopBlock: restGeneratedTopBlock, generatedBottomBlocks: restGeneratedBottomBlocks, } = this.generateBlocksContainConditionalOperatorGroup(sourceStmts.slice(firstEndPos + 1, stmtsCnt), basicBlockSet);
-            firstGeneratedBottomBlocks.forEach(firstGeneratedBottomBlock => {
-                firstGeneratedBottomBlock.addSuccessorBlock(restGeneratedTopBlock);
-                restGeneratedTopBlock.addPredecessorBlock(firstGeneratedBottomBlock);
-            });
-            restGeneratedBottomBlocks.forEach(block => basicBlockSet.add(block));
-            this.removeUnnecessaryBlocksInConditionalOperator(restGeneratedTopBlock, basicBlockSet);
-            generatedBottomBlocks = restGeneratedBottomBlocks;
-        }
-        return { generatedTopBlock, generatedBottomBlocks };
-    }
-    generateBlocksContainSingleConditionalOperator(sourceStmts) {
-        const { firstIfTruePos: ifTruePos, firstIfFalsePos: ifFalsePos, firstEndPos: endPos, } = this.findFirstConditionalOperator(sourceStmts);
-        if (endPos === -1) {
-            return this.generateBlockWithoutConditionalOperator(sourceStmts);
-        }
-        const { generatedTopBlock: generatedTopBlock, generatedAllBlocks: generatedAllBlocks, } = this.generateBlockWithoutConditionalOperator(sourceStmts.slice(0, ifTruePos));
-        let generatedBottomBlocks = [];
-        const { generatedTopBlock: generatedTopBlockOfTrueBranch, generatedBottomBlocks: generatedBottomBlocksOfTrueBranch, generatedAllBlocks: generatedAllBlocksOfTrueBranch, } = this.generateBlocksContainSingleConditionalOperator(sourceStmts.slice(ifTruePos + 1, ifFalsePos));
-        generatedBottomBlocks.push(...generatedBottomBlocksOfTrueBranch);
-        generatedAllBlocks.push(...generatedAllBlocksOfTrueBranch);
-        const { generatedTopBlock: generatedTopBlockOfFalseBranch, generatedBottomBlocks: generatedBottomBlocksOfFalseBranch, generatedAllBlocks: generatedAllBlocksOfFalseBranch, } = this.generateBlocksContainSingleConditionalOperator(sourceStmts.slice(ifFalsePos + 1, endPos));
-        generatedBottomBlocks.push(...generatedBottomBlocksOfFalseBranch);
-        generatedAllBlocks.push(...generatedAllBlocksOfFalseBranch);
-        generatedTopBlock.addSuccessorBlock(generatedTopBlockOfTrueBranch);
-        generatedTopBlockOfTrueBranch.addPredecessorBlock(generatedTopBlock);
-        generatedTopBlock.addSuccessorBlock(generatedTopBlockOfFalseBranch);
-        generatedTopBlockOfFalseBranch.addPredecessorBlock(generatedTopBlock);
-        const stmtsCnt = sourceStmts.length;
-        if (endPos !== stmtsCnt - 1) { // need create a new basic block for rest statements
-            const { generatedTopBlock: extraBlock, } = this.generateBlockWithoutConditionalOperator(sourceStmts.slice(endPos + 1));
-            generatedBottomBlocks.forEach(generatedBottomBlock => {
-                generatedBottomBlock.addSuccessorBlock(extraBlock);
-                extraBlock.addPredecessorBlock(generatedBottomBlock);
-            });
-            generatedBottomBlocks = [extraBlock];
-            generatedAllBlocks.push(extraBlock);
-        }
-        return { generatedTopBlock, generatedBottomBlocks, generatedAllBlocks };
-    }
-    generateBlockWithoutConditionalOperator(sourceStmts) {
-        const generatedBlock = new BasicBlock_1.BasicBlock();
-        sourceStmts.forEach(stmt => generatedBlock.addStmt(stmt));
-        return {
-            generatedTopBlock: generatedBlock,
-            generatedBottomBlocks: [generatedBlock],
-            generatedAllBlocks: [generatedBlock],
-        };
-    }
-    deleteDummyConditionalOperatorStmt(basicBlockSet) {
-        var _a;
-        for (const basicBlock of basicBlockSet) {
-            const stmts = Array.from(basicBlock.getStmts());
-            for (const stmt of stmts) {
-                if (stmt instanceof ArkIRTransformer_1.DummyStmt && ((_a = stmt.toString()) === null || _a === void 0 ? void 0 : _a.startsWith(ArkIRTransformer_1.ArkIRTransformer.DUMMY_CONDITIONAL_OPERATOR))) {
-                    basicBlock.remove(stmt);
-                }
-            }
-        }
-    }
-    findFirstConditionalOperator(stmts) {
-        let firstIfTruePos = -1;
-        let firstIfFalsePos = -1;
-        let firstEndPos = -1;
-        let firstConditionalOperatorNo = '';
-        for (let i = 0; i < stmts.length; i++) {
-            const stmt = stmts[i];
-            if (stmt instanceof ArkIRTransformer_1.DummyStmt) {
-                if (stmt.toString()
-                    .startsWith(ArkIRTransformer_1.ArkIRTransformer.DUMMY_CONDITIONAL_OPERATOR_IF_TRUE_STMT) && firstIfTruePos === -1) {
-                    firstIfTruePos = i;
-                    firstConditionalOperatorNo =
-                        stmt.toString().replace(ArkIRTransformer_1.ArkIRTransformer.DUMMY_CONDITIONAL_OPERATOR_IF_TRUE_STMT, '');
-                }
-                else if (stmt.toString() === ArkIRTransformer_1.ArkIRTransformer.DUMMY_CONDITIONAL_OPERATOR_IF_FALSE_STMT + firstConditionalOperatorNo) {
-                    firstIfFalsePos = i;
-                }
-                else if (stmt.toString() === ArkIRTransformer_1.ArkIRTransformer.DUMMY_CONDITIONAL_OPERATOR_END_STMT + firstConditionalOperatorNo) {
-                    firstEndPos = i;
-                }
-            }
-        }
-        return { firstIfTruePos, firstIfFalsePos, firstEndPos };
-    }
-    removeUnnecessaryBlocksInConditionalOperator(bottomBlock, allBlocks) {
-        const firstStmtInBottom = bottomBlock.getStmts()[0];
-        if (!(firstStmtInBottom instanceof Stmt_1.ArkAssignStmt)) {
-            return [bottomBlock];
-        }
-        const targetValue = firstStmtInBottom.getLeftOp();
-        const tempResultValue = firstStmtInBottom.getRightOp();
-        if (!(targetValue instanceof Local_1.Local && IRUtils_1.IRUtils.isTempLocal(tempResultValue))) {
-            return [bottomBlock];
-        }
-        const oldPredecessors = Array.from(bottomBlock.getPredecessors());
-        const newPredecessors = [];
-        for (const predecessor of oldPredecessors) {
-            predecessor.removeSuccessorBlock(bottomBlock);
-            newPredecessors.push(...this.replaceTempRecursively(predecessor, targetValue, tempResultValue, allBlocks));
-        }
-        bottomBlock.remove(firstStmtInBottom);
-        if (bottomBlock.getStmts().length === 0) { // must be a new block without successors
-            allBlocks.delete(bottomBlock);
-            return newPredecessors;
-        }
-        oldPredecessors.forEach((oldPredecessor) => {
-            bottomBlock.removePredecessorBlock(oldPredecessor);
-        });
-        newPredecessors.forEach((newPredecessor) => {
-            bottomBlock.addPredecessorBlock(newPredecessor);
-            newPredecessor.addSuccessorBlock(bottomBlock);
-        });
-        return [bottomBlock];
-    }
-    replaceTempRecursively(currBottomBlock, targetLocal, tempResultLocal, allBlocks) {
-        const stmts = currBottomBlock.getStmts();
-        const stmtsCnt = stmts.length;
-        let tempResultReassignStmt = null;
-        for (let i = stmtsCnt - 1; i >= 0; i--) {
-            const stmt = stmts[i];
-            if (stmt instanceof Stmt_1.ArkAssignStmt && stmt.getLeftOp() === tempResultLocal) {
-                if (IRUtils_1.IRUtils.isTempLocal(stmt.getRightOp())) {
-                    tempResultReassignStmt = stmt;
-                }
-                else {
-                    stmt.setLeftOp(targetLocal);
-                }
-            }
-        }
-        let newBottomBlocks = [];
-        if (tempResultReassignStmt) {
-            const oldPredecessors = currBottomBlock.getPredecessors();
-            const newPredecessors = [];
-            const prevTempResultLocal = tempResultReassignStmt.getRightOp();
-            for (const predecessor of oldPredecessors) {
-                predecessor.removeSuccessorBlock(currBottomBlock);
-                newPredecessors.push(...this.replaceTempRecursively(predecessor, targetLocal, prevTempResultLocal, allBlocks));
-            }
-            currBottomBlock.remove(tempResultReassignStmt);
-            if (currBottomBlock.getStmts().length === 0) {
-                // remove this block
-                newBottomBlocks = newPredecessors;
-                allBlocks.delete(currBottomBlock);
-            }
-            else {
-                currBottomBlock.getPredecessors().splice(0, oldPredecessors.length, ...newPredecessors);
-                newPredecessors.forEach((newPredecessor) => {
-                    newPredecessor.addSuccessorBlock(currBottomBlock);
-                });
-                newBottomBlocks = [currBottomBlock];
-            }
-        }
-        else {
-            newBottomBlocks = [currBottomBlock];
-        }
-        return newBottomBlocks;
-    }
-    rebuildBlocksInLoop(blockBuilderToCfgBlock, blocksContainLoopCondition, basicBlockSet) {
-        for (const blockBuilder of blocksContainLoopCondition) {
-            if (!blockBuilderToCfgBlock.get(blockBuilder)) {
-                continue;
-            }
-            const block = blockBuilderToCfgBlock.get(blockBuilder);
-            const blockId = block.getId();
-            const stmts = block.getStmts();
-            const stmtsCnt = stmts.length;
-            const { ifStmtIdx, iteratorNextStmtIdx, dummyInitializerStmtIdx } = this.findIteratorIdx(stmts);
-            if (iteratorNextStmtIdx !== -1 || dummyInitializerStmtIdx !== -1) {
-                const lastStmtIdxBeforeCondition = iteratorNextStmtIdx !== -1 ? iteratorNextStmtIdx : dummyInitializerStmtIdx;
-                const stmtsInsertBeforeCondition = stmts.slice(0, lastStmtIdxBeforeCondition);
-                let prevBlockBuilderContainsLoop = this.doesPrevBlockBuilderContainLoop(blockBuilder, blockId, blocksContainLoopCondition);
-                if (prevBlockBuilderContainsLoop) {
-                    // should create an extra block when previous block contains loop condition
-                    this.insertBeforeConditionBlockBuilder(blockBuilderToCfgBlock, blockBuilder, stmtsInsertBeforeCondition, false, basicBlockSet);
-                }
-                else {
-                    const blockBuilderBeforeCondition = blockBuilder.lasts[0];
-                    const blockBeforeCondition = blockBuilderToCfgBlock.get(blockBuilderBeforeCondition);
-                    stmtsInsertBeforeCondition.forEach(stmt => blockBeforeCondition === null || blockBeforeCondition === void 0 ? void 0 : blockBeforeCondition.getStmts().push(stmt));
-                }
-                if (dummyInitializerStmtIdx !== -1 && ifStmtIdx !== stmtsCnt - 1) {
-                    // put incrementor statements into block which reenters condition
-                    this.adjustIncrementorStmts(stmts, ifStmtIdx, blockBuilder, blockId, blockBuilderToCfgBlock, blocksContainLoopCondition, basicBlockSet);
-                }
-                else if (iteratorNextStmtIdx !== -1) {
-                    // put statements which get value of iterator into block after condition
-                    const blockBuilderAfterCondition = blockBuilder.nexts[0];
-                    const blockAfterCondition = blockBuilderToCfgBlock.get(blockBuilderAfterCondition);
-                    const stmtsAfterCondition = stmts.slice(ifStmtIdx + 1);
-                    blockAfterCondition === null || blockAfterCondition === void 0 ? void 0 : blockAfterCondition.getStmts().splice(0, 0, ...stmtsAfterCondition);
-                }
-                // remove statements which should not in condition
-                const firstStmtIdxInCondition = iteratorNextStmtIdx !== -1 ? iteratorNextStmtIdx : dummyInitializerStmtIdx + 1;
-                stmts.splice(0, firstStmtIdxInCondition);
-                stmts.splice(ifStmtIdx - firstStmtIdxInCondition + 1);
-            }
-        }
-    }
-    doesPrevBlockBuilderContainLoop(currBlockBuilder, currBlockId, blocksContainLoopCondition) {
-        let prevBlockBuilderContainsLoop = false;
-        for (const prevBlockBuilder of currBlockBuilder.lasts) {
-            if (prevBlockBuilder.id < currBlockId && blocksContainLoopCondition.has(prevBlockBuilder)) {
-                prevBlockBuilderContainsLoop = true;
-                break;
-            }
-        }
-        return prevBlockBuilderContainsLoop;
-    }
-    insertBeforeConditionBlockBuilder(blockBuilderToCfgBlock, conditionBlockBuilder, stmtsInsertBeforeCondition, collectReenter, basicBlockSet) {
-        const blockId = conditionBlockBuilder.id;
-        const block = blockBuilderToCfgBlock.get(conditionBlockBuilder);
-        const blockBuildersBeforeCondition = [];
-        const blocksBeforeCondition = [];
-        const blockBuildersReenterCondition = [];
-        const blocksReenterCondition = [];
-        for (const prevBlockBuilder of conditionBlockBuilder.lasts) {
-            const prevBlock = blockBuilderToCfgBlock.get(prevBlockBuilder);
-            if (prevBlock.getId() < blockId) {
-                blockBuildersBeforeCondition.push(prevBlockBuilder);
-                blocksBeforeCondition.push(prevBlock);
-            }
-            else {
-                blockBuildersReenterCondition.push(prevBlockBuilder);
-                blocksReenterCondition.push(prevBlock);
-            }
-        }
-        let collectedBlockBuilders = [];
-        let collectedBlocks = [];
-        if (collectReenter) {
-            collectedBlockBuilders = blockBuildersReenterCondition;
-            collectedBlocks = blocksReenterCondition;
-        }
-        else {
-            collectedBlockBuilders = blockBuildersBeforeCondition;
-            collectedBlocks = blocksBeforeCondition;
-        }
-        const blockBuilderInsertBeforeCondition = new Block(-1, []);
-        blockBuilderInsertBeforeCondition.lasts.push(...collectedBlockBuilders);
-        blockBuilderInsertBeforeCondition.nexts.push(conditionBlockBuilder);
-        const blockInsertBeforeCondition = new BasicBlock_1.BasicBlock();
-        stmtsInsertBeforeCondition.forEach(stmt => blockInsertBeforeCondition.getStmts().push(stmt));
-        blockInsertBeforeCondition.getPredecessors().push(...collectedBlocks);
-        blockInsertBeforeCondition.addSuccessorBlock(block);
-        for (const prevBlockBuilder of collectedBlockBuilders) {
-            const prevBlock = blockBuilderToCfgBlock.get(prevBlockBuilder);
-            for (let j = 0; j < prevBlockBuilder.nexts.length; j++) {
-                if (prevBlockBuilder.nexts[j] === conditionBlockBuilder) {
-                    prevBlockBuilder.nexts[j] = blockBuilderInsertBeforeCondition;
-                    prevBlock.setSuccessorBlock(j, blockInsertBeforeCondition);
-                    break;
-                }
-            }
-        }
-        let newPrevBlockBuildersBeforeCondition = [];
-        let newPrevBlocksBeforeCondition = [];
-        if (collectReenter) {
-            newPrevBlockBuildersBeforeCondition = [...blockBuildersBeforeCondition, blockBuilderInsertBeforeCondition];
-            newPrevBlocksBeforeCondition = [...blocksBeforeCondition, blockInsertBeforeCondition];
-        }
-        else {
-            newPrevBlockBuildersBeforeCondition = [blockBuilderInsertBeforeCondition, ...blockBuildersReenterCondition];
-            newPrevBlocksBeforeCondition = [blockInsertBeforeCondition, ...blocksReenterCondition];
-        }
-        conditionBlockBuilder.lasts = newPrevBlockBuildersBeforeCondition;
-        const predecessorsCnt = block.getPredecessors().length;
-        block.getPredecessors().splice(0, predecessorsCnt, ...newPrevBlocksBeforeCondition);
-        this.blocks.push(blockBuilderInsertBeforeCondition);
-        basicBlockSet.add(blockInsertBeforeCondition);
-        blockBuilderToCfgBlock.set(blockBuilderInsertBeforeCondition, blockInsertBeforeCondition);
-    }
-    findIteratorIdx(stmts) {
-        let ifStmtIdx = -1;
-        let iteratorNextStmtIdx = -1;
-        let dummyInitializerStmtIdx = -1;
-        const stmtsCnt = stmts.length;
-        for (let i = 0; i < stmtsCnt; i++) {
-            const stmt = stmts[i];
-            if (stmt instanceof Stmt_1.ArkAssignStmt && stmt.getRightOp() instanceof Expr_1.AbstractInvokeExpr) {
-                const invokeExpr = stmt.getRightOp();
-                if (invokeExpr.getMethodSignature().getMethodSubSignature()
-                    .getMethodName() === Builtin_1.Builtin.ITERATOR_NEXT) {
-                    iteratorNextStmtIdx = i;
-                    continue;
-                }
-            }
-            if (stmt.toString() === ArkIRTransformer_1.ArkIRTransformer.DUMMY_LOOP_INITIALIZER_STMT) {
-                dummyInitializerStmtIdx = i;
-                continue;
-            }
-            if (stmt instanceof Stmt_1.ArkIfStmt) {
-                ifStmtIdx = i;
-                break;
-            }
-        }
-        return {
-            ifStmtIdx: ifStmtIdx,
-            iteratorNextStmtIdx: iteratorNextStmtIdx,
-            dummyInitializerStmtIdx: dummyInitializerStmtIdx,
-        };
-    }
-    adjustIncrementorStmts(stmts, ifStmtIdx, currBlockBuilder, currBlockId, blockBuilderToCfgBlock, blocksContainLoopCondition, basicBlockSet) {
-        const stmtsReenterCondition = stmts.slice(ifStmtIdx + 1);
-        const blockBuildersReenterCondition = [];
-        for (const prevBlockBuilder of currBlockBuilder.lasts) {
-            const prevBlock = blockBuilderToCfgBlock.get(prevBlockBuilder);
-            if (prevBlock.getId() > currBlockId) {
-                blockBuildersReenterCondition.push(prevBlockBuilder);
-            }
-        }
-        if (blockBuildersReenterCondition.length > 1 || blocksContainLoopCondition.has(blockBuildersReenterCondition[0])) {
-            // put incrementor statements into an extra block
-            this.insertBeforeConditionBlockBuilder(blockBuilderToCfgBlock, currBlockBuilder, stmtsReenterCondition, true, basicBlockSet);
-        }
-        else {
-            // put incrementor statements into prev reenter block
-            const blockReenterCondition = blockBuilderToCfgBlock.get(blockBuildersReenterCondition[0]);
-            stmtsReenterCondition.forEach(stmt => blockReenterCondition === null || blockReenterCondition === void 0 ? void 0 : blockReenterCondition.getStmts().push(stmt));
-        }
-    }
-    buildTraps(blockBuilderToCfgBlock, blockBuildersBeforeTry, arkIRTransformer, basicBlockSet) {
-        var _a, _b, _c;
-        const traps = [];
-        for (const blockBuilderBeforeTry of blockBuildersBeforeTry) {
-            if (blockBuilderBeforeTry.nexts.length === 0) {
-                logger.error(`can't find try block.`);
-                continue;
-            }
-            const blockBuilderContainTry = blockBuilderBeforeTry.nexts[0];
-            const stmtsCnt = blockBuilderBeforeTry.stmts.length;
-            const tryStmtBuilder = blockBuilderBeforeTry.stmts[stmtsCnt - 1];
-            const finallyBlockBuilder = (_a = tryStmtBuilder.finallyStatement) === null || _a === void 0 ? void 0 : _a.block;
-            if (!finallyBlockBuilder) {
-                logger.error(`can't find finally block or dummy finally block.`);
-                continue;
-            }
-            const { bfsBlocks: tryBfsBlocks, tailBlocks: tryTailBlocks } = this.getAllBlocksBFS(blockBuilderToCfgBlock, blockBuilderContainTry, finallyBlockBuilder);
-            let catchBfsBlocks = [];
-            let catchTailBlocks = [];
-            const catchBlockBuilder = (_b = tryStmtBuilder.catchStatement) === null || _b === void 0 ? void 0 : _b.block;
-            if (catchBlockBuilder) {
-                ({ bfsBlocks: catchBfsBlocks, tailBlocks: catchTailBlocks } = this.getAllBlocksBFS(blockBuilderToCfgBlock, catchBlockBuilder));
-            }
-            const finallyStmts = finallyBlockBuilder.stmts;
-            const blockBuilderAfterFinally = (_c = tryStmtBuilder.afterFinal) === null || _c === void 0 ? void 0 : _c.block;
-            if (!blockBuilderAfterFinally) {
-                logger.error(`can't find block after try...catch.`);
-                continue;
-            }
-            if (finallyStmts.length === 1 && finallyStmts[0].code === 'dummyFinally') { // no finally block
-                const trapsIfNoFinally = this.buildTrapsIfNoFinally(tryBfsBlocks, tryTailBlocks, catchBfsBlocks, catchTailBlocks, finallyBlockBuilder, blockBuilderAfterFinally, basicBlockSet, blockBuilderToCfgBlock);
-                if (trapsIfNoFinally) {
-                    traps.push(...trapsIfNoFinally);
-                }
-            }
-            else {
-                const trapsIfFinallyExist = this.buildTrapsIfFinallyExist(tryBfsBlocks, tryTailBlocks, catchBfsBlocks, catchTailBlocks, finallyBlockBuilder, blockBuilderAfterFinally, basicBlockSet, arkIRTransformer, blockBuilderToCfgBlock);
-                traps.push(...trapsIfFinallyExist);
-            }
-        }
-        return traps;
-    }
-    buildTrapsIfNoFinally(tryBfsBlocks, tryTailBlocks, catchBfsBlocks, catchTailBlocks, finallyBlockBuilder, blockBuilderAfterFinally, basicBlockSet, blockBuilderToCfgBlock) {
-        if (catchBfsBlocks.length === 0) {
-            logger.error(`catch block expected.`);
-            return null;
-        }
-        if (!blockBuilderToCfgBlock.has(blockBuilderAfterFinally)) {
-            logger.error(`can't find basicBlock corresponding to the blockBuilder.`);
-            return null;
-        }
-        let blockAfterFinally = blockBuilderToCfgBlock.get(blockBuilderAfterFinally);
-        if (!blockBuilderToCfgBlock.has(finallyBlockBuilder)) {
-            logger.error(`can't find basicBlock corresponding to the blockBuilder.`);
-            return null;
-        }
-        const finallyBlock = blockBuilderToCfgBlock.get(finallyBlockBuilder);
-        let dummyFinallyIdxInPredecessors = -1;
-        for (let i = 0; i < blockAfterFinally.getPredecessors().length; i++) {
-            if (blockAfterFinally.getPredecessors()[i] === finallyBlock) {
-                dummyFinallyIdxInPredecessors = i;
-                break;
-            }
-        }
-        if (dummyFinallyIdxInPredecessors === -1) {
-            return null;
-        }
-        blockAfterFinally.getPredecessors().splice(dummyFinallyIdxInPredecessors, 1);
-        for (const tryTailBlock of tryTailBlocks) {
-            tryTailBlock.setSuccessorBlock(0, blockAfterFinally);
-            blockAfterFinally.addPredecessorBlock(tryTailBlock);
-        }
-        basicBlockSet.delete(finallyBlock);
-        for (const catchTailBlock of catchTailBlocks) {
-            catchTailBlock.addSuccessorBlock(blockAfterFinally);
-            blockAfterFinally.addPredecessorBlock(catchTailBlock);
-        }
-        for (const tryTailBlock of tryTailBlocks) {
-            tryTailBlock.addExceptionalSuccessorBlock(catchBfsBlocks[0]);
-        }
-        return [new Trap_1.Trap(tryBfsBlocks, catchBfsBlocks)];
-    }
-    buildTrapsIfFinallyExist(tryBfsBlocks, tryTailBlocks, catchBfsBlocks, catchTailBlocks, finallyBlockBuilder, blockBuilderAfterFinally, basicBlockSet, arkIRTransformer, blockBuilderToCfgBlock) {
-        const { bfsBlocks: finallyBfsBlocks, tailBlocks: finallyTailBlocks } = this.getAllBlocksBFS(blockBuilderToCfgBlock, finallyBlockBuilder, blockBuilderAfterFinally);
-        const copyFinallyBfsBlocks = this.copyFinallyBlocks(finallyBfsBlocks, finallyTailBlocks, basicBlockSet, arkIRTransformer, blockBuilderToCfgBlock);
-        const traps = [];
-        if (catchBfsBlocks.length !== 0) {
-            for (const catchTailBlock of catchTailBlocks) {
-                catchTailBlock.addSuccessorBlock(finallyBfsBlocks[0]);
-                finallyBfsBlocks[0].addPredecessorBlock(catchTailBlock);
-            }
-            // try -> catch trap
-            for (const tryTailBlock of tryTailBlocks) {
-                tryTailBlock.addExceptionalSuccessorBlock(catchBfsBlocks[0]);
-            }
-            traps.push(new Trap_1.Trap(tryBfsBlocks, catchBfsBlocks));
-            // catch -> finally trap
-            for (const catchTailBlock of catchTailBlocks) {
-                catchTailBlock.addExceptionalSuccessorBlock(copyFinallyBfsBlocks[0]);
-            }
-            traps.push(new Trap_1.Trap(catchBfsBlocks, copyFinallyBfsBlocks));
-        }
-        else {
-            // try -> finally trap
-            for (const tryTailBlock of tryTailBlocks) {
-                tryTailBlock.addExceptionalSuccessorBlock(copyFinallyBfsBlocks[0]);
-            }
-            traps.push(new Trap_1.Trap(tryBfsBlocks, copyFinallyBfsBlocks));
-        }
-        return traps;
-    }
-    getAllBlocksBFS(blockBuilderToCfgBlock, startBlockBuilder, endBlockBuilder) {
-        const bfsBlocks = [];
-        const tailBlocks = [];
-        const queue = [];
-        const visitedBlockBuilders = new Set();
-        queue.push(startBlockBuilder);
-        while (queue.length !== 0) {
-            const currBlockBuilder = queue.splice(0, 1)[0];
-            if (visitedBlockBuilders.has(currBlockBuilder)) {
-                continue;
-            }
-            visitedBlockBuilders.add(currBlockBuilder);
-            if (!blockBuilderToCfgBlock.has(currBlockBuilder)) {
-                logger.error(`can't find basicBlock corresponding to the blockBuilder.`);
-                continue;
-            }
-            const currBlock = blockBuilderToCfgBlock.get(currBlockBuilder);
-            bfsBlocks.push(currBlock);
-            const childList = currBlockBuilder.nexts;
-            if (childList.length === 0 || (childList.length !== 0 && (childList[0] === endBlockBuilder))) {
-                if (childList[0] === endBlockBuilder) {
-                    tailBlocks.push(currBlock);
-                    continue;
-                }
-            }
-            if (childList.length !== 0) {
-                for (const child of childList) {
-                    queue.push(child);
-                }
-            }
-        }
-        return { bfsBlocks, tailBlocks };
-    }
-    copyFinallyBlocks(finallyBfsBlocks, finallyTailBlocks, basicBlockSet, arkIRTransformer, blockBuilderToCfgBlock) {
-        var _a;
-        const copyFinallyBfsBlocks = this.copyBlocks(finallyBfsBlocks);
-        const caughtExceptionRef = new Ref_1.ArkCaughtExceptionRef(Type_1.UnknownType.getInstance());
-        const { value: exceptionValue, stmts: exceptionAssignStmts, } = arkIRTransformer.generateAssignStmtForValue(caughtExceptionRef, [Position_1.FullPosition.DEFAULT]);
-        copyFinallyBfsBlocks[0].addHead(exceptionAssignStmts);
-        const finallyPredecessorsCnt = copyFinallyBfsBlocks[0].getPredecessors().length;
-        copyFinallyBfsBlocks[0].getPredecessors().splice(0, finallyPredecessorsCnt);
-        const throwStmt = new Stmt_1.ArkThrowStmt(exceptionValue);
-        let copyFinallyTailBlocks = copyFinallyBfsBlocks.splice(copyFinallyBfsBlocks.length - finallyTailBlocks.length, finallyTailBlocks.length);
-        copyFinallyTailBlocks.forEach((copyFinallyTailBlock) => {
-            const successorsCnt = copyFinallyTailBlock.getSuccessors().length;
-            copyFinallyTailBlock.getSuccessors().splice(0, successorsCnt);
-        });
-        if (copyFinallyTailBlocks.length > 1) {
-            const newCopyFinallyTailBlock = new BasicBlock_1.BasicBlock();
-            copyFinallyTailBlocks.forEach((copyFinallyTailBlock) => {
-                copyFinallyTailBlock.addSuccessorBlock(newCopyFinallyTailBlock);
-                newCopyFinallyTailBlock.addPredecessorBlock(copyFinallyTailBlock);
-            });
-            copyFinallyTailBlocks = [newCopyFinallyTailBlock];
-        }
-        (_a = copyFinallyTailBlocks[0]) === null || _a === void 0 ? void 0 : _a.addStmt(throwStmt);
-        copyFinallyBfsBlocks.push(...copyFinallyTailBlocks);
-        copyFinallyBfsBlocks.forEach((copyFinallyBfsBlock) => {
-            basicBlockSet.add(copyFinallyBfsBlock);
-        });
-        return copyFinallyBfsBlocks;
-    }
-    copyBlocks(sourceBlocks) {
-        const sourceToTarget = new Map();
-        const targetBlocks = [];
-        for (const sourceBlock of sourceBlocks) {
-            const targetBlock = new BasicBlock_1.BasicBlock();
-            for (const stmt of sourceBlock.getStmts()) {
-                targetBlock.addStmt(this.copyStmt(stmt));
-            }
-            sourceToTarget.set(sourceBlock, targetBlock);
-            targetBlocks.push(targetBlock);
-        }
-        for (const sourceBlock of sourceBlocks) {
-            const targetBlock = sourceToTarget.get(sourceBlock);
-            for (const predecessor of sourceBlock.getPredecessors()) {
-                const targetPredecessor = sourceToTarget.get(predecessor);
-                targetBlock.addPredecessorBlock(targetPredecessor);
-            }
-            for (const successor of sourceBlock.getSuccessors()) {
-                const targetSuccessor = sourceToTarget.get(successor);
-                targetBlock.addSuccessorBlock(targetSuccessor);
-            }
-        }
-        return targetBlocks;
-    }
-    copyStmt(sourceStmt) {
-        if (sourceStmt instanceof Stmt_1.ArkAssignStmt) {
-            return new Stmt_1.ArkAssignStmt(sourceStmt.getLeftOp(), sourceStmt.getRightOp());
-        }
-        else if (sourceStmt instanceof Stmt_1.ArkInvokeStmt) {
-            return new Stmt_1.ArkInvokeStmt(sourceStmt.getInvokeExpr());
-        }
-        else if (sourceStmt instanceof Stmt_1.ArkIfStmt) {
-            return new Stmt_1.ArkIfStmt(sourceStmt.getConditionExpr());
-        }
-        else if (sourceStmt instanceof Stmt_1.ArkReturnStmt) {
-            return new Stmt_1.ArkReturnStmt(sourceStmt.getOp());
-        }
-        else if (sourceStmt instanceof Stmt_1.ArkReturnVoidStmt) {
-            return new Stmt_1.ArkReturnVoidStmt();
-        }
-        else if (sourceStmt instanceof Stmt_1.ArkThrowStmt) {
-            return new Stmt_1.ArkThrowStmt(sourceStmt.getOp());
-        }
-        return null;
-    }
-    buildSwitch(blockBuilderToCfgBlock, blockBuildersContainSwitch, valueAndStmtsOfSwitchAndCasesAll, arkIRTransformer, basicBlockSet) {
-        for (let i = 0; i < blockBuildersContainSwitch.length; i++) {
-            const blockBuilderContainSwitch = blockBuildersContainSwitch[i];
-            if (!blockBuilderToCfgBlock.has(blockBuilderContainSwitch)) {
-                logger.error(`can't find basicBlock corresponding to the blockBuilder.`);
-                continue;
-            }
-            const blockContainSwitch = blockBuilderToCfgBlock.get(blockBuilderContainSwitch);
-            const valueAndStmtsOfSwitch = valueAndStmtsOfSwitchAndCasesAll[i][0];
-            const stmtsOfSwitch = valueAndStmtsOfSwitch.stmts;
-            stmtsOfSwitch.forEach((stmt) => {
-                blockContainSwitch.addStmt(stmt);
-            });
-            const stmtsCnt = blockBuilderContainSwitch.stmts.length;
-            const switchStmtBuilder = blockBuilderContainSwitch.stmts[stmtsCnt - 1];
-            const cases = switchStmtBuilder.cases;
-            let nonEmptyCaseCnt = 0;
-            for (const currCase of cases) {
-                if (currCase.stmt.block) { // there are stmts after this case
-                    nonEmptyCaseCnt++;
-                }
-            }
-            if (nonEmptyCaseCnt === 0) {
-                continue;
-            }
-            const caseCnt = cases.length;
-            const caseIfBlocks = this.generateIfBlocksForCases(valueAndStmtsOfSwitchAndCasesAll[i], caseCnt, blockContainSwitch, basicBlockSet, arkIRTransformer);
-            this.linkIfBlockAndCaseBlock(blockContainSwitch, caseIfBlocks, switchStmtBuilder, blockBuilderToCfgBlock);
-        }
-    }
-    generateIfBlocksForCases(valueAndStmtsOfSwitchAndCases, caseCnt, blockContainSwitch, basicBlockSet, arkIRTransformer) {
-        const valueAndStmtsOfSwitch = valueAndStmtsOfSwitchAndCases[0];
-        const valueOfSwitch = valueAndStmtsOfSwitch.value;
-        const caseIfBlocks = [];
-        for (let j = 0; j < caseCnt; j++) {
-            let caseIfBlock;
-            if (j === 0) {
-                caseIfBlock = blockContainSwitch;
-            }
-            else {
-                caseIfBlock = new BasicBlock_1.BasicBlock();
-                basicBlockSet.add(caseIfBlock);
-            }
-            caseIfBlocks.push(caseIfBlock);
-            const caseValueAndStmts = valueAndStmtsOfSwitchAndCases[j + 1];
-            const caseValue = caseValueAndStmts.value;
-            const caseStmts = caseValueAndStmts.stmts;
-            caseStmts.forEach((stmt) => {
-                caseIfBlock.addStmt(stmt);
-            });
-            const caseIfStmts = arkIRTransformer.generateIfStmtForValues(valueOfSwitch, valueAndStmtsOfSwitch.valueOriginalPositions, caseValue, caseValueAndStmts.valueOriginalPositions);
-            caseIfStmts.forEach((stmt) => {
-                caseIfBlock.addStmt(stmt);
-            });
-        }
-        return caseIfBlocks;
-    }
-    linkIfBlockAndCaseBlock(blockContainSwitch, caseIfBlocks, switchStmtBuilder, blockBuilderToCfgBlock) {
-        const successorsOfBlockContainSwitch = Array.from(blockContainSwitch.getSuccessors());
-        const expectedSuccessorsOfCaseIfBlock = [];
-        const defaultStmtBuilder = switchStmtBuilder.default;
-        if (defaultStmtBuilder && defaultStmtBuilder.block) {
-            expectedSuccessorsOfCaseIfBlock.push(...successorsOfBlockContainSwitch.splice(-1, 1));
-        }
-        else {
-            const afterSwitchStmtBuilder = switchStmtBuilder.afterSwitch;
-            const afterSwitchBlockBuilder = afterSwitchStmtBuilder === null || afterSwitchStmtBuilder === void 0 ? void 0 : afterSwitchStmtBuilder.block;
-            if (!afterSwitchBlockBuilder || !blockBuilderToCfgBlock.has(afterSwitchBlockBuilder)) {
-                logger.error(`can't find basicBlock corresponding to the blockBuilder.`);
-                return false;
-            }
-            expectedSuccessorsOfCaseIfBlock.push(blockBuilderToCfgBlock.get(afterSwitchBlockBuilder));
-        }
-        const caseCnt = switchStmtBuilder.cases.length;
-        for (let i = caseCnt - 1; i >= 0; i--) {
-            const currCase = switchStmtBuilder.cases[i];
-            if (currCase.stmt.block) {
-                expectedSuccessorsOfCaseIfBlock.push(...successorsOfBlockContainSwitch.splice(-1, 1));
-            }
-            else { // if there are no stmts after this case, reuse the successor of the next case
-                expectedSuccessorsOfCaseIfBlock.push(...expectedSuccessorsOfCaseIfBlock.slice(-1));
-            }
-        }
-        expectedSuccessorsOfCaseIfBlock.reverse();
-        blockContainSwitch.getSuccessors().forEach((successor) => {
-            successor.getPredecessors().splice(0, 1);
-        });
-        blockContainSwitch.getSuccessors().splice(0);
-        for (let j = 0; j < caseCnt; j++) {
-            const caseIfBlock = caseIfBlocks[j];
-            caseIfBlock.addSuccessorBlock(expectedSuccessorsOfCaseIfBlock[j]);
-            expectedSuccessorsOfCaseIfBlock[j].addPredecessorBlock(caseIfBlock);
-            if (j === caseCnt - 1) { // the false branch of last case should be default or block after switch statement
-                caseIfBlock.addSuccessorBlock(expectedSuccessorsOfCaseIfBlock[j + 1]);
-                expectedSuccessorsOfCaseIfBlock[j + 1].addPredecessorBlock(caseIfBlock);
-            }
-            else {
-                caseIfBlock.addSuccessorBlock(caseIfBlocks[j + 1]);
-                caseIfBlocks[j + 1].addPredecessorBlock(caseIfBlock);
-            }
-        }
-        return true;
-    }
-}
-exports.CfgBuilder = CfgBuilder;