arkanalyzer 1.0.86 → 1.0.88

package/lib/frontend/cppFrontend/graph/builder/CfgBuilder.js

@@ -0,0 +1,1435 @@
+"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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CfgBuilder = exports.TryStatementBuilder = exports.SwitchStatementBuilder = exports.StatementBuilder = exports.Case = exports.BlockBuilder = void 0;
+const Local_1 = require("../../../../core/base/Local");
+const Stmt_1 = require("../../../../core/base/Stmt");
+const BasicBlock_1 = require("../../../../core/graph/BasicBlock");
+const Cfg_1 = require("../../../../core/graph/Cfg");
+const ArkClass_1 = require("../../../../core/model/ArkClass");
+const ArkIRTransformer_1 = require("../../common/ArkIRTransformer");
+const IRUtils_1 = require("../../common/IRUtils");
+const Type_1 = require("../../../../core/base/Type");
+const SwitchBuilder_1 = require("./SwitchBuilder");
+const ConditionBuilder_1 = require("./ConditionBuilder");
+const TrapBuilder_1 = require("./TrapBuilder");
+const ArkBaseModel_1 = require("../../../../core/model/ArkBaseModel");
+const CfgBuilder_1 = require("../../../../core/graph/builder/CfgBuilder");
+const ModelUtils_1 = require("../../../../core/common/ModelUtils");
+const TSConst_1 = require("../../../../core/common/TSConst");
+const ast_1 = require("../../ast");
+const LoopBuilder_1 = require("./LoopBuilder");
+const IfBuilder_1 = require("./IfBuilder");
+class BlockBuilder {
+    constructor(id, stmts) {
+        this.nexts = [];
+        this.lasts = [];
+        this.walked = false;
+        this.id = id;
+        this.stmts = stmts;
+    }
+}
+exports.BlockBuilder = BlockBuilder;
+class Case {
+    constructor(value, stmt) {
+        this.value = value;
+        this.stmt = stmt;
+    }
+}
+exports.Case = Case;
+class StatementBuilder {
+    constructor(type, code, astNode, scopeID) {
+        this.addressCode3 = [];
+        this.passTimes = 0;
+        this.numOfIdentifier = 0;
+        this.isDoWhile = false;
+        this.hasDoWhileBody = 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;
+    }
+}
+exports.StatementBuilder = StatementBuilder;
+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 = [];
+    }
+}
+exports.SwitchStatementBuilder = SwitchStatementBuilder;
+class TryStatementBuilder extends StatementBuilder {
+    constructor(type, code, astNode, scopeID) {
+        super(type, code, astNode, scopeID);
+        this.tryFirst = null;
+        this.tryExit = null;
+        this.catchStatement = [];
+        this.catchError = [];
+        this.finallyStatement = null;
+        this.afterFinal = null;
+    }
+}
+exports.TryStatementBuilder = TryStatementBuilder;
+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;
+        this.gotoStmtMap = new Map();
+        this.labelStmtMap = new Map();
+    }
+    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);
+            // Process the passTimes when multiple goto entries exist in a node
+            if (lastStatement.code.includes('goto label:') &&
+                lastStatement.lasts.size > 1 && s.passTimes === 0) {
+                s.passTimes += (lastStatement.lasts.size - 1);
+            }
+        }
+    }
+    ASTNodeBreakStatement(c, lastStatement) {
+        var _a, _b, _c;
+        let p = c;
+        while (p && p.id !== this.astRoot.id) {
+            let pKind = p.kind.toString();
+            if (pKind === 'WhileStmt' || pKind === 'DoStmt' || pKind === 'ForStmt') {
+                const lastLoopNextF = this.loopStack[this.loopStack.length - 1].nextF;
+                this.judgeLastType(lastLoopNextF, lastStatement);
+                lastLoopNextF.lasts.add(lastStatement);
+                return;
+            }
+            if (pKind === 'CaseStmt' || pKind === 'DefaultStmt') {
+                const lastSwitchExit = this.switchExitStack[this.switchExitStack.length - 1];
+                this.judgeLastType(lastSwitchExit, lastStatement);
+                lastSwitchExit.lasts.add(lastStatement);
+                return;
+            }
+            p = (_c = ((_a = p.parent) !== null && _a !== void 0 ? _a : (_b = p.getParent) === null || _b === void 0 ? void 0 : _b.call(p, true))) !== null && _c !== void 0 ? _c : null;
+        }
+    }
+    ASTNodeIfStatement(c, lastStatement, scopeID) {
+        let ifstm = new ConditionStatementBuilder('ifStatement', 'IfStmt', c, scopeID);
+        this.judgeLastType(ifstm, lastStatement);
+        let ifexit = new StatementBuilder('ifExit', '', c, scopeID);
+        this.exits.push(ifexit);
+        ifstm.condition = c.inner[0].code;
+        ifstm.code = 'if (' + ifstm.condition + ')';
+        if (c.inner.length >= 2) { // length >= 2 means there is a condition and a body
+            if (c.inner[1].kind === ast_1.astKind.CompoundStmt) {
+                // Body is a braced block { ... }
+                this.walkAST(ifstm, ifexit, [...c.inner[1].inner]);
+            }
+            else {
+                // Reaching this branch means there's no braces {}
+                this.walkAST(ifstm, ifexit, [c.inner[1]]);
+            }
+        }
+        else if (c.inner.length === 1) {
+            // Only one child; treat it as the body
+            this.walkAST(ifstm, ifexit, [c.inner[0]]);
+        }
+        if (c.inner.length > 2) {
+            if (c.inner[2].kind === ast_1.astKind.CompoundStmt) {
+                // Handle else here
+                this.walkAST(ifstm, ifexit, [...c.inner[2].inner]);
+            }
+            else {
+                // Handle else-if here
+                this.walkAST(ifstm, ifexit, [c.inner[2]]);
+            }
+        }
+        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.inner[0].code;
+        loopstm.code = 'while (' + loopstm.condition + ')';
+        if (c.inner.length >= 2) {
+            if (c.inner[1].kind === ast_1.astKind.CompoundStmt) {
+                this.walkAST(loopstm, loopstm, [...c.inner[1].inner]);
+            }
+            else {
+                this.walkAST(loopstm, loopstm, [c.inner[1]]);
+            }
+        }
+        else if (c.inner.length === 1 && c.inner[0].kind.toString() === ast_1.astKind.CompoundStmt) {
+            this.walkAST(loopstm, loopstm, [c.inner[0]]);
+        }
+        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;
+    }
+    getPrefix(s, varName) {
+        const index = s.indexOf(varName);
+        if (index === -1) {
+            return s;
+        }
+        return s.substring(0, index);
+    }
+    ASTNodeForStatement(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.code = this.getPrefix(c.code, ' {\r\n');
+        if (c.inner[c.inner.length - 1].kind === ast_1.astKind.CompoundStmt) {
+            this.walkAST(loopstm, loopstm, [...c.inner[c.inner.length - 1].inner]);
+        }
+        else {
+            this.walkAST(loopstm, loopstm, [c.inner[c.inner.length - 1]]);
+        }
+        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.inner[1].code;
+        loopstm.code = 'while (' + loopstm.condition + ')';
+        loopstm.isDoWhile = true;
+        for (let idx = 0; idx < c.inner[0].inner.length; idx++) {
+            let kind = c.inner[0].inner[idx].kind;
+            if (kind !== 'NullStmt') {
+                loopstm.hasDoWhileBody = true;
+            }
+        }
+        if (c.inner[0].kind.toString() === 'CompoundStmt') {
+            this.walkAST(lastStatement, loopstm, [...c.inner[0].inner]);
+        }
+        else {
+            this.walkAST(lastStatement, loopstm, [c.inner[0]]);
+        }
+        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;
+    }
+    sliceCaseDefaultNode(node, clauses) {
+        if (node.kind === 'CaseStmt') {
+            for (let i = 0; i < node.inner.length; i++) {
+                let isCaseOrDefault = node.inner[i].kind === ast_1.astKind.CaseStmt || node.inner[i].kind === ast_1.astKind.DefaultStmt;
+                if (isCaseOrDefault) {
+                    clauses.push(node);
+                    this.sliceCaseDefaultNode(node.inner[i], clauses);
+                }
+                if (i === node.inner.length - 1 && !isCaseOrDefault) {
+                    clauses.push(node);
+                }
+            }
+        }
+        else {
+            // Divide subsequent nodes into cases
+            clauses.push(node);
+        }
+    }
+    // Convert cpp's case-default ast format to TS's caseClause/defaultClause
+    getCaseDefClauseAsts(switchNode) {
+        // When cpp parses case: without statements and no break,
+        // it will treat the following case/default as inner nodes of that case,
+        // so the original ast needs to be split into individual cases and defaults
+        let length = switchNode.inner.length;
+        let tempClauses = [];
+        for (let node of switchNode.inner[length - 1].inner) {
+            this.sliceCaseDefaultNode(node, tempClauses);
+        }
+        // When there are no case brackets, case and break/continue are separate nodes in cpp,
+        // here we add the break/continue nodes as inner members of case or default nodes
+        return tempClauses.reduce((acc, curr, idx, arr) => {
+            if (['CaseStmt', 'DefaultStmt'].includes(curr.kind)) {
+                curr.parent = switchNode.inner[length - 1];
+                // Reconstruct the syntax tree structure
+                while (idx + 1 < arr.length && ![ast_1.astKind.CaseStmt, ast_1.astKind.DefaultStmt].includes(arr[idx + 1].kind)) {
+                    arr[idx + 1].parent = curr;
+                    curr.inner.push(arr[idx + 1]);
+                    idx++;
+                }
+                acc.push(curr);
+            }
+            return acc;
+        }, []);
+    }
+    ASTNodeSwitchStatement(c, lastStatement, scopeID) {
+        var _a;
+        // In the switchNode node, inner [length-1] is Case related and inner [length-2] is a switch variable, which may be preceded by a declaration statement
+        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.inner[0].code + ')';
+        let lastCaseExit = null;
+        c.inner[c.inner.length - 1].inner = this.getCaseDefClauseAsts(c);
+        const astNodeCase = c.inner[c.inner.length - 1];
+        for (let i = 0; i < astNodeCase.inner.length; i++) {
+            const clause = astNodeCase.inner[i];
+            let casestm;
+            let caseBody = [...clause.inner];
+            if (clause.kind.toString() === 'CaseStmt') {
+                casestm = new StatementBuilder('statement', 'case ' + clause.inner[0].code + ':', clause, scopeID);
+                caseBody = caseBody.slice(1);
+            }
+            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, caseBody);
+            if (clause.kind.toString() === 'CaseStmt') {
+                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 === astNodeCase.inner.length - 1) {
+                caseExit.next = switchExit;
+                switchExit.lasts.add(caseExit);
+            }
+        }
+        this.switchExitStack.pop();
+        return switchExit;
+    }
+    ASTNodeCXXMemberCallExpr(innerNode, lastStatement, scopeID) {
+        var _a, _b;
+        let caller = '';
+        let callee = '';
+        const first = (_a = innerNode === null || innerNode === void 0 ? void 0 : innerNode.inner) === null || _a === void 0 ? void 0 : _a[0];
+        if (first && first.kind === 'MemberExpr') {
+            let childInner = first;
+            // Callee: name is preferred. Some JSONs may only have code
+            const op = childInner.isArrow ? '->' : '.';
+            callee = op + (childInner.name || childInner.code || '');
+            // 2) Go down through ImplicitCastExpr chain until DeclRefExpr or other end points use the optional chain at the same time to avoid out of bounds
+            while (childInner.inner && childInner.inner.length > 0) {
+                const n0 = childInner.inner[0];
+                const innerKind = n0 === null || n0 === void 0 ? void 0 : n0.kind;
+                if (innerKind === ast_1.astKind.DeclRefExpr) {
+                    // 3) Safely read referencedDecl? .name； Use n0. name/n0. code/empty string at the bottom
+                    caller = ((_b = n0.referencedDecl) === null || _b === void 0 ? void 0 : _b.name) || n0.name || n0.code || '';
+                    break;
+                }
+                if (innerKind === ast_1.astKind.ImplicitCastExpr) {
+                    childInner = n0; // Continue to traverse downward
+                    continue;
+                }
+                // Other nodes stop
+                break;
+            }
+        }
+        const nodeCode = caller + callee;
+        const s = new StatementBuilder('statement', nodeCode, innerNode, scopeID);
+        this.judgeLastType(s, lastStatement);
+        return s;
+    }
+    ASTNodeGotoStatement(innerNode, lastStatement, scopeID) {
+        let s = new StatementBuilder('gotoStatement', innerNode.code, innerNode, scopeID);
+        this.judgeLastType(s, lastStatement);
+        let label = innerNode.code.substring(innerNode.code.indexOf('goto ') + 5);
+        let gotoStmtsOfLabel = this.gotoStmtMap.get(label);
+        if (gotoStmtsOfLabel === undefined) {
+            this.gotoStmtMap.set(label, [s]);
+            this.handleLabelStmtPassTimes(s, label);
+        }
+        else {
+            gotoStmtsOfLabel.push(s);
+            this.handleLabelStmtPassTimes(s, label);
+        }
+    }
+    handleLabelStmtPassTimes(s, label) {
+        var _a;
+        if (this.labelStmtMap.has(label)) {
+            const labelStmt = this.labelStmtMap.get(label);
+            if (labelStmt === null || labelStmt === void 0 ? void 0 : labelStmt.next) {
+                labelStmt.next.passTimes = (labelStmt.next.passTimes || 0) + 1;
+            }
+            this.judgeLastType((_a = this.labelStmtMap.get(label)) === null || _a === void 0 ? void 0 : _a.next, s);
+        }
+    }
+    judgeLastStmtForLabel(s, lastStatement, gotoStatement) {
+        if (lastStatement.type === 'ifStatement') {
+            let lastIf = lastStatement;
+            if (lastIf.nextT.type === 'gotoStatement') {
+                lastIf.nextT = s;
+                s.lasts.add(lastIf);
+            }
+            else if (lastIf.nextF.type === 'gotoStatement') {
+                lastIf.nextF = s;
+                s.lasts.add(lastIf);
+            }
+        }
+        else if (lastStatement.type === 'switchStatement') {
+            let lastSwitch = lastStatement;
+            for (let i = 0; i < lastSwitch.nexts.length; i++) {
+                if (lastSwitch.nexts[i] === gotoStatement) {
+                    lastSwitch.nexts[i] = s;
+                    s.lasts.add(lastSwitch);
+                }
+            }
+        }
+        else {
+            lastStatement.next = s;
+            s.lasts.add(lastStatement);
+        }
+    }
+    ASTNodeLabelStatement(innerNode, lastStatement, scopeID) {
+        let labelStmt = new StatementBuilder('statement', 'goto label:' + innerNode.name, innerNode, scopeID);
+        // Handle the sequence relationship between goto statements and label statements
+        let label = innerNode.code.substring(0, innerNode.code.indexOf(':'));
+        if (!this.labelStmtMap.has(label)) {
+            this.labelStmtMap.set(label, labelStmt);
+        }
+        for (const [key, gotoStmts] of this.gotoStmtMap) {
+            if (key === label) {
+                for (const gotoStmt of gotoStmts) {
+                    for (const lastStmt of [...gotoStmt.lasts]) {
+                        this.judgeLastStmtForLabel(labelStmt, lastStmt, gotoStmt);
+                    }
+                }
+            }
+        }
+        // Handle the sequence relationship between label statements and the previous statement
+        this.judgeLastStmtForLabel(labelStmt, lastStatement, undefined);
+        // Processing nodes within labelStmt
+        let labelExit = new StatementBuilder('labelExit', '', innerNode, scopeID);
+        this.exits.push(labelExit);
+        this.walkAST(labelStmt, labelExit, [...innerNode.inner]);
+        // Remove labelStmt
+        for (const stmt of [...labelStmt.lasts]) {
+            labelStmt.next.lasts.add(stmt);
+            if (stmt.type === 'ifStatement') {
+                let lastIf = stmt;
+                if (lastIf.nextT === labelStmt) {
+                    lastIf.nextT = labelStmt.next;
+                }
+                else {
+                    lastIf.nextF = labelStmt.next;
+                }
+            }
+            else if (stmt.type === 'switchStatement') {
+                let lastSwitch = stmt;
+                for (let i = 0; i < lastSwitch.nexts.length; i++) {
+                    if (lastSwitch.nexts[i] === labelStmt && labelStmt.next) {
+                        lastSwitch.nexts[i] = labelStmt.next;
+                    }
+                }
+            }
+            else {
+                stmt.next = labelStmt.next;
+            }
+        }
+        labelStmt.next.lasts.delete(labelStmt);
+        return labelExit;
+    }
+    removeAfterBraces(str) {
+        const index = str.indexOf('{\r\n    ');
+        if (index !== -1) {
+            return str.substring(0, index);
+        }
+        return str;
+    }
+    ASTNodeTryStatement(c, lastStatement, scopeID) {
+        var _a, _b, _c, _d;
+        let trystmt = new TryStatementBuilder('tryStatement', 'try', c, scopeID);
+        this.judgeLastType(trystmt, lastStatement);
+        let tryExit = new StatementBuilder('tryExit', '', c, scopeID);
+        this.exits.push(tryExit);
+        trystmt.tryExit = tryExit;
+        let tryBlock = undefined;
+        let catchBlockList = [];
+        for (const node of c.inner) {
+            if (node.kind === ast_1.astKind.CompoundStmt) {
+                tryBlock = node;
+            }
+            else if (node.kind === ast_1.astKind.CXXCatchStmt) {
+                catchBlockList.push(node);
+            }
+        }
+        this.walkAST(trystmt, tryExit, (_a = tryBlock === null || tryBlock === void 0 ? void 0 : tryBlock.inner) !== null && _a !== void 0 ? _a : []);
+        trystmt.tryFirst = trystmt.next;
+        (_b = trystmt.next) === null || _b === void 0 ? void 0 : _b.lasts.add(trystmt);
+        for (const catchBlock of catchBlockList) {
+            let text = '';
+            if (catchBlock.code) {
+                text += this.removeAfterBraces(catchBlock.code);
+            }
+            if (((_c = catchBlock.inner) === null || _c === void 0 ? void 0 : _c.length) === 0) {
+                continue;
+            }
+            let catchOrNot = new ConditionStatementBuilder('catchOrNot', text, catchBlock, scopeID);
+            let catchExit = new StatementBuilder('catch exit', '', catchBlock, scopeID);
+            catchOrNot.nextF = catchExit;
+            catchExit.lasts.add(catchOrNot);
+            if (catchBlock.inner && catchBlock.inner[0].id === '0x0') {
+                catchBlock.inner[0].kind = 'catch_all_exception';
+            }
+            this.walkAST(catchOrNot, catchExit, catchBlock.inner[catchBlock.inner.length - 1].inner);
+            if (!catchOrNot.nextT) {
+                catchOrNot.nextT = catchExit;
+                catchExit.lasts.add(catchOrNot);
+            }
+            const catchStatement = new StatementBuilder('statement', catchOrNot.code, catchBlock, catchOrNot.nextT.scopeID);
+            catchStatement.next = catchOrNot.nextT;
+            trystmt.catchStatement.push(catchStatement);
+            catchStatement.lasts.add(trystmt);
+            trystmt.catchError.push(catchBlock.inner[0]);
+        }
+        let final = new StatementBuilder('statement', 'finally', c, scopeID);
+        let finalExit = new StatementBuilder('finallyExit', '', c, scopeID);
+        this.exits.push(finalExit);
+        let dummyFinally = new StatementBuilder('statement', 'dummyFinally', c, new CfgBuilder_1.Scope(this.scopes.length).id);
+        final.next = dummyFinally;
+        dummyFinally.lasts.add(final);
+        dummyFinally.next = finalExit;
+        finalExit.lasts.add(dummyFinally);
+        trystmt.finallyStatement = final.next;
+        tryExit.next = final.next;
+        (_d = final.next) === null || _d === void 0 ? void 0 : _d.lasts.add(tryExit);
+        trystmt.next = finalExit;
+        finalExit.lasts.add(trystmt);
+        return finalExit;
+    }
+    hitsControlBoundaryBeforeRoot(node) {
+        var _a, _b, _c;
+        const CONTROL_BOUNDARY_KINDS = new Set([
+            ast_1.astKind.IfStmt,
+            ast_1.astKind.WhileStmt,
+            ast_1.astKind.DoStmt,
+            ast_1.astKind.ForStmt,
+            ast_1.astKind.CaseStmt,
+            ast_1.astKind.DefaultStmt,
+            ast_1.astKind.CXXTryStmt,
+        ]);
+        let p = node;
+        const rootId = this.astRoot.id;
+        while (p && p.id !== rootId) {
+            if (CONTROL_BOUNDARY_KINDS.has(p.kind)) {
+                return true;
+            }
+            p = (_c = ((_a = p.parent) !== null && _a !== void 0 ? _a : (_b = p.getParent) === null || _b === void 0 ? void 0 : _b.call(p, true))) !== null && _c !== void 0 ? _c : null;
+        }
+        return false;
+    }
+    walkAST(lastStatement, nextStatement, nodes) {
+        var _a;
+        let scope = new CfgBuilder_1.Scope(this.scopes.length);
+        this.scopes.push(scope);
+        let gotoLabel = ((_a = lastStatement.next) === null || _a === void 0 ? void 0 : _a.type) === 'gotoStatement' && nextStatement.type === 'blockExit';
+        for (let i = 0; i < nodes.length; i++) {
+            let innerNode = nodes[i];
+            let nodeKind = innerNode.kind;
+            if (nodeKind === 'LabelStmt' && this.gotoStmtMap.get(innerNode.name) !== undefined) {
+                gotoLabel = false;
+            }
+            if (gotoLabel && nodeKind !== ast_1.astKind.CompoundStmt) { // Skip the code between goto and label in the code block
+                continue;
+            }
+            lastStatement = this.handleASTStmtSuccession(innerNode, lastStatement, scope);
+            if (nodeKind === ast_1.astKind.ReturnStmt) {
+                break;
+            }
+            else if (nodeKind === ast_1.astKind.BreakStmt || nodeKind === ast_1.astKind.ContinueStmt) {
+                return;
+            }
+            else if (nodeKind === ast_1.astKind.GotoStmt) {
+                if (this.hitsControlBoundaryBeforeRoot(innerNode)) {
+                    return;
+                }
+            }
+        }
+        if (lastStatement.type !== 'breakStatement' && lastStatement.type !== 'continueStatement' && lastStatement.type !== 'returnStatement') {
+            lastStatement.next = nextStatement;
+            nextStatement.lasts.add(lastStatement);
+        }
+    }
+    handleASTStmtSuccession(innerNode, lastStatement, scope) {
+        let s;
+        // 直接使用 innerNode.kind 进行 switch
+        switch (innerNode.kind) {
+            case ast_1.astKind.AtomicCallExpr:
+            case ast_1.astKind.BinaryOperator:
+            case ast_1.astKind.CallExpr:
+            case ast_1.astKind.CompoundAssignOperator:
+            case ast_1.astKind.CXXConstructExpr:
+            case ast_1.astKind.CXXCtorInitializer:
+            case ast_1.astKind.CXXDeleteExpr:
+            case ast_1.astKind.CXXOperatorCallExpr:
+            case ast_1.astKind.CXXThrowExpr:
+            case ast_1.astKind.DeclStmt:
+            case ast_1.astKind.RecoveryExpr:
+            case ast_1.astKind.TypedefDecl:
+            case ast_1.astKind.TypeAliasDecl:
+            case ast_1.astKind.TypeAliasTemplateDecl:
+            case ast_1.astKind.UnaryOperator:
+            case ast_1.astKind.VarDecl:
+                s = new StatementBuilder('statement', innerNode.code, innerNode, scope.id);
+                this.judgeLastType(s, lastStatement);
+                lastStatement = s;
+                break;
+            case ast_1.astKind.BreakStmt:
+                this.ASTNodeBreakStatement(innerNode, lastStatement);
+                break;
+            case ast_1.astKind.CompoundStmt:
+                let blockExit = new StatementBuilder('blockExit', '', innerNode, scope.id);
+                this.exits.push(blockExit);
+                this.walkAST(lastStatement, blockExit, [...innerNode.inner]);
+                lastStatement = blockExit;
+                break;
+            case ast_1.astKind.ContinueStmt:
+                const lastLoop = this.loopStack[this.loopStack.length - 1];
+                this.judgeLastType(lastLoop, lastStatement);
+                lastLoop.lasts.add(lastStatement);
+                break;
+            case ast_1.astKind.CXXMemberCallExpr:
+                lastStatement = this.ASTNodeCXXMemberCallExpr(innerNode, lastStatement, scope.id);
+                break;
+            case ast_1.astKind.CXXForRangeStmt:
+            case ast_1.astKind.ForStmt:
+                lastStatement = this.ASTNodeForStatement(innerNode, lastStatement, scope.id);
+                break;
+            case ast_1.astKind.CXXTryStmt:
+                lastStatement = this.ASTNodeTryStatement(innerNode, lastStatement, scope.id);
+                break;
+            case ast_1.astKind.DoStmt:
+                lastStatement = this.ASTNodeDoStatement(innerNode, lastStatement, scope.id);
+                break;
+            case ast_1.astKind.ExprWithCleanups:
+                lastStatement = this.ASTNodeImplicitCastExpr(innerNode, lastStatement, scope);
+                break;
+            case ast_1.astKind.GotoStmt:
+            case ast_1.astKind.IndirectGotoStmt:
+                this.ASTNodeGotoStatement(innerNode, lastStatement, scope.id);
+                break;
+            case ast_1.astKind.IfStmt:
+                lastStatement = this.ASTNodeIfStatement(innerNode, lastStatement, scope.id);
+                break;
+            case ast_1.astKind.LabelStmt:
+                lastStatement = this.ASTNodeLabelStatement(innerNode, lastStatement, scope.id);
+                break;
+            case ast_1.astKind.ReturnStmt:
+                s = new StatementBuilder('returnStatement', innerNode.code, innerNode, scope.id);
+                this.judgeLastType(s, lastStatement);
+                lastStatement = s;
+                break;
+            case ast_1.astKind.SwitchStmt:
+                lastStatement = this.ASTNodeSwitchStatement(innerNode, lastStatement, scope.id);
+                break;
+            case ast_1.astKind.WhileStmt:
+                lastStatement = this.ASTNodeWhileStatement(innerNode, lastStatement, scope.id);
+                break;
+            case ast_1.astKind.NullStmt:
+                break;
+            case ast_1.astKind.ParmVarDecl:
+                s = new StatementBuilder('statement', 'ParmVarDecl', innerNode, scope.id);
+                this.judgeLastType(s, lastStatement);
+                lastStatement = s;
+                break;
+            case ast_1.astKind.ImplicitCastExpr:
+                lastStatement = this.ASTNodeImplicitCastExpr(innerNode, lastStatement, scope);
+                break;
+            default:
+                break;
+        }
+        return lastStatement;
+    }
+    ASTNodeImplicitCastExpr(implicitCastExpr, lastStatement, scope) {
+        for (let i = 0; i < implicitCastExpr.inner.length; i++) {
+            let inner = implicitCastExpr.inner[i];
+            lastStatement = this.handleASTStmtSuccession(inner, lastStatement, scope);
+        }
+        return 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);
+                }
+            }
+        }
+        // The next of some statements, such as the exit statement after return, cannot be cleared
+        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.passTimes++;
+            if (stmt.next.passTimes === stmt.next.lasts.size || stmt.next.type === 'loopStatement' || stmt.next.isDoWhile) {
+                if (stmt.next.scopeID !== stmt.scopeID &&
+                    !(stmt.next instanceof ConditionStatementBuilder && stmt.next.doStatement)) {
+                    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]);
+            }
+            // add afterSwitch when the every case is return
+            if (stmt.afterSwitch && stmt.afterSwitch.lasts.size === 0) {
+                stmtQueue.push(stmt.afterSwitch);
+            }
+        }
+        else if (stmt instanceof TryStatementBuilder) {
+            if (stmt.finallyStatement) {
+                stmtQueue.push(stmt.finallyStatement);
+            }
+            if (stmt.catchStatement) {
+                for (let catchStmt of stmt.catchStatement) {
+                    stmtQueue.push(catchStmt);
+                }
+            }
+            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 BlockBuilder(this.blocks.length, []);
+            this.blocks.push(block);
+            while (stmt && !handledStmts.has(stmt)) {
+                if (stmt.type === 'loopStatement' && block.stmts.length > 0 && !stmt.hasDoWhileBody) {
+                    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 BlockBuilder(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, _b, _c, _d;
+        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.id !== this.astRoot.id) {
+                if (p.kind === ast_1.astKind.CXXTryStmt || p.kind === ast_1.astKind.SwitchStmt) {
+                    TryOrSwitchExit = true;
+                    break;
+                }
+                p = (_c = ((_a = p.parent) !== null && _a !== void 0 ? _a : (_b = p.getParent) === null || _b === void 0 ? void 0 : _b.call(p, true))) !== null && _c !== void 0 ? _c : null;
+            }
+        }
+        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);
+            (_d = notReturnStmt.block) === null || _d === void 0 ? void 0 : _d.stmts.push(returnStatement);
+            returnStatement.block = notReturnStmt.block;
+        }
+        else {
+            this.addReturnBlock(returnStatement, notReturnStmts);
+        }
+    }
+    addStmtBuilderPosition() {
+        var _a, _b;
+        for (const stmt of this.statementArray) {
+            if (stmt.astNode) {
+                if (((_a = stmt.astNode.range) === null || _a === void 0 ? void 0 : _a.begin) && stmt.astNode.range.begin.line) {
+                    stmt.line = stmt.astNode.range.begin.line;
+                }
+                else {
+                    stmt.line = 0;
+                }
+                if (((_b = stmt.astNode.range) === null || _b === void 0 ? void 0 : _b.begin) && stmt.astNode.range.begin.col) {
+                    stmt.column = stmt.astNode.range.begin.col;
+                }
+                else {
+                    stmt.column = 0;
+                }
+            }
+        }
+    }
+    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 trystmt = stmt;
+            if (trystmt.tryFirst) {
+                this.CfgBuilder2Array(trystmt.tryFirst);
+            }
+            if (trystmt.catchStatement) {
+                for (let catchStmt of trystmt.catchStatement) {
+                    this.CfgBuilder2Array(catchStmt);
+                }
+            }
+            if (trystmt.finallyStatement) {
+                this.CfgBuilder2Array(trystmt.finallyStatement);
+            }
+            if (trystmt.next) {
+                this.CfgBuilder2Array(trystmt.next);
+            }
+        }
+        else {
+            if (stmt.next !== null) {
+                this.CfgBuilder2Array(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 CfgBuilder_1.TextError(mes);
+    }
+    getFuncBodyStmt() {
+        let stmts = [];
+        if (this.astRoot.inner) {
+            for (let i = 0; i < this.astRoot.inner.length; i++) {
+                const allowedInnerKinds = [
+                    ast_1.astKind.CXXConstructExpr,
+                    ast_1.astKind.CXXCtorInitializer
+                ];
+                if (this.astRoot.kind === ast_1.astKind.CXXConstructorDecl && allowedInnerKinds.includes(this.astRoot.inner[i].kind)) {
+                    stmts.push(this.astRoot.inner[i]);
+                }
+                const length = this.astRoot.inner[i].inner.length;
+                if (this.astRoot.inner[i].kind === ast_1.astKind.ParmVarDecl && length > 0 &&
+                    this.astRoot.inner[i].inner[length - 1].kind !== ast_1.astKind.TypeRef) {
+                    stmts.push(this.astRoot.inner[i]);
+                    continue;
+                }
+                if (this.astRoot.inner[i].kind === ast_1.astKind.CompoundStmt) {
+                    stmts.push(...this.astRoot.inner[i].inner);
+                    break;
+                }
+            }
+        }
+        return stmts;
+    }
+    buildCfgBuilder() {
+        let stmts = [];
+        const translationUnitKinds = [
+            ast_1.astKind.TranslationUnitDecl,
+            ast_1.astKind.NamespaceDecl
+        ];
+        const functionKinds = [
+            ast_1.astKind.FunctionDecl,
+            ast_1.astKind.CXXMethodDecl,
+            ast_1.astKind.CXXConstructorDecl,
+            ast_1.astKind.LambdaExpr,
+            ast_1.astKind.FunctionTemplateDecl,
+            ast_1.astKind.CXXDestructorDecl
+        ];
+        if (translationUnitKinds.includes(this.astRoot.kind)) {
+            stmts = [...this.astRoot.inner];
+        }
+        else if (functionKinds.includes(this.astRoot.kind)) {
+            stmts = this.getFuncBodyStmt();
+        }
+        this.walkAST(this.entry, this.exit, stmts);
+        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();
+    }
+    isBodyEmpty() {
+        return this.emptyBody;
+    }
+    buildCfg() {
+        if (this.astRoot.kind === ast_1.astKind.LambdaExpr && this.astRoot.inner[this.astRoot.inner.length - 1].kind !== ast_1.astKind.CompoundStmt) {
+            return this.buildCfgForSimpleArrowFunction();
+        }
+        return this.buildNormalCfg();
+    }
+    buildCfgForSimpleArrowFunction() {
+        const stmts = [];
+        const arkIRTransformer = new ArkIRTransformer_1.ArkCxxIRTransformer(this.sourceFile, this.declaringMethod);
+        stmts.push(...arkIRTransformer.prebuildStmts());
+        const expressionBodyNode = this.astRoot;
+        const expressionBodyStmts = [];
+        let { value: expressionBodyValue, valueOriginalPositions: expressionBodyPositions, stmts: tempStmts, } = arkIRTransformer.cxxNodeToValueAndStmts(expressionBodyNode);
+        expressionBodyStmts.push(...tempStmts);
+        if (IRUtils_1.IRUtils.moreThanOneAddress(expressionBodyValue)) {
+            ({
+                value: expressionBodyValue,
+                valueOriginalPositions: expressionBodyPositions,
+                stmts: tempStmts,
+            } = arkIRTransformer.generateAssignStmtForValue(expressionBodyValue, expressionBodyPositions));
+            expressionBodyStmts.push(...tempStmts);
+        }
+        const returnStmt = new Stmt_1.ArkReturnStmt(expressionBodyValue);
+        returnStmt.setOperandOriginalPositions([expressionBodyPositions[0], ...expressionBodyPositions]);
+        expressionBodyStmts.push(returnStmt);
+        arkIRTransformer.cxxMapStmtsToTsStmt(expressionBodyStmts, expressionBodyNode);
+        stmts.push(...expressionBodyStmts);
+        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: [],
+        };
+    }
+    buildNormalCfg() {
+        const { blockBuilderToCfgBlock, basicBlockSet, arkIRTransformer } = this.initializeBuild();
+        const { blocksContainLoopCondition, blockBuildersBeforeTry, blockBuildersContainSwitch, valueAndStmtsOfSwitchAndCasesAll, } = this.processBlocks(blockBuilderToCfgBlock, basicBlockSet, arkIRTransformer);
+        const currBlockId = this.blocks.length;
+        this.linkBasicBlocks(blockBuilderToCfgBlock);
+        this.adjustBlocks(blockBuilderToCfgBlock, blocksContainLoopCondition, basicBlockSet, blockBuildersContainSwitch, valueAndStmtsOfSwitchAndCasesAll, arkIRTransformer);
+        const trapBuilder = new TrapBuilder_1.CxxTrapBuilder(blockBuildersBeforeTry, blockBuilderToCfgBlock, basicBlockSet);
+        const traps = trapBuilder.buildTraps();
+        this.removeEmptyBlocks(basicBlockSet);
+        const cfg = this.createCfg(blockBuilderToCfgBlock, basicBlockSet, currBlockId);
+        return {
+            cfg,
+            locals: arkIRTransformer.getLocals(),
+            globals: arkIRTransformer.getGlobals(),
+            aliasTypeMap: arkIRTransformer.getAliasTypeMap(),
+            traps,
+        };
+    }
+    /**
+     * Removes empty basic blocks from the CFG.
+     *
+     * Strategy:
+     * 1. Identify all empty blocks first (Snapshot).
+     * 2. For each empty block, bypass it by connecting its predecessors directly to its successors.
+     * 3. Delete the empty block.
+     *
+     * Note: This version strictly performs deletion and does NOT trigger block merging.
+     */
+    removeEmptyBlocks(basicBlockSet) {
+        // Phase 1: Identify all candidates for removal.
+        // We collect them into an array to avoid concurrent modification issues
+        // during the initial filtering.
+        const emptyBlocks = Array.from(basicBlockSet).filter(bb => bb.getStmts().length === 0);
+        for (const bb of emptyBlocks) {
+            // Double-check existence as a previous iteration might have merged/deleted it.
+            if (!basicBlockSet.has(bb)) {
+                continue;
+            }
+            // Phase 2: Perform the surgical removal and graph relinking.
+            this.bypassAndRemoveBlock(bb, basicBlockSet);
+        }
+    }
+    /**
+     * Bypasses a block by connecting all its predecessors directly to its successors.
+     */
+    bypassAndRemoveBlock(bb, basicBlockSet) {
+        const predecessors = bb.getPredecessors();
+        const successors = bb.getSuccessors();
+        // Link every Predecessor to every Successor (Pred -> Succ)
+        for (const pred of predecessors) {
+            // Sever the connection to the target block
+            pred.removeSuccessorBlock(bb);
+            for (const succ of successors) {
+                // Prevent introducing trivial self-loops (Pred -> Pred)
+                if (pred === succ) {
+                    continue;
+                }
+                // Standard Handshake: Maintain bidirectional CFG edges
+                pred.addSuccessorBlock(succ);
+                succ.addPredecessorBlock(pred);
+            }
+        }
+        // Phase 3: Final cleanup of outgoing edges from the removed block
+        for (const succ of successors) {
+            succ.removePredecessorBlock(bb);
+        }
+        // Phase 4: Erase from the global set
+        basicBlockSet.delete(bb);
+    }
+    initializeBuild() {
+        const blockBuilderToCfgBlock = new Map();
+        const basicBlockSet = new Set();
+        const arkIRTransformer = new ArkIRTransformer_1.ArkCxxIRTransformer(this.sourceFile, this.declaringMethod);
+        return { blockBuilderToCfgBlock, basicBlockSet, arkIRTransformer };
+    }
+    processBlocks(blockBuilderToCfgBlock, basicBlockSet, arkIRTransformer) {
+        const blocksContainLoopCondition = new Set();
+        const blockBuildersBeforeTry = new Set();
+        const blockBuildersContainSwitch = [];
+        const valueAndStmtsOfSwitchAndCasesAll = [];
+        for (let i = 0; i < this.blocks.length; i++) {
+            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.cxxSwitchStatementToValueAndStmts(statementBuilder.astNode);
+                    valueAndStmtsOfSwitchAndCasesAll.push(valueAndStmtsOfSwitchAndCases);
+                    continue;
+                }
+                else if (statementBuilder.type === '') {
+                    blockBuildersContainSwitch.push(this.blocks[i]);
+                    continue;
+                }
+                if (statementBuilder.astNode && statementBuilder.code !== '') {
+                    stmtsInBlock.push(...arkIRTransformer.cxxNodeToStmts(statementBuilder.astNode));
+                }
+                else if (statementBuilder.code.startsWith('return')) {
+                    stmtsInBlock.push(this.generateReturnStmt(arkIRTransformer));
+                }
+            }
+            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);
+        }
+        return { blocksContainLoopCondition, blockBuildersBeforeTry, blockBuildersContainSwitch, valueAndStmtsOfSwitchAndCasesAll };
+    }
+    generateReturnStmt(arkIRTransformer) {
+        if (this.name === TSConst_1.CONSTRUCTOR_NAME) {
+            this.declaringMethod.getSubSignature().setReturnType(arkIRTransformer.getThisLocal().getType());
+            return new Stmt_1.ArkReturnStmt(arkIRTransformer.getThisLocal());
+        }
+        if (this.declaringMethod.getSubSignature().getReturnType() instanceof Type_1.UnknownType && !this.declaringMethod.getAsteriskToken()) {
+            if (this.declaringMethod.containsModifier(ArkBaseModel_1.ModifierType.ASYNC)) {
+                const promise = this.declaringMethod.getDeclaringArkFile().getScene().getSdkGlobal(TSConst_1.PROMISE);
+                if (promise instanceof ArkClass_1.ArkClass) {
+                    this.declaringMethod.getSubSignature().setReturnType(new Type_1.ClassType(promise.getSignature()));
+                }
+                else {
+                    this.declaringMethod.getSubSignature().setReturnType(new Type_1.UnclearReferenceType(TSConst_1.PROMISE, [Type_1.VoidType.getInstance()]));
+                }
+            }
+            else {
+                this.declaringMethod.getSubSignature().setReturnType(Type_1.VoidType.getInstance());
+            }
+        }
+        if (!(this.declaringMethod.getSubSignature().getReturnType() instanceof Type_1.VoidType)) {
+            const methodName = this.declaringMethod.getSubSignature().getMethodName();
+            return new Stmt_1.ArkReturnStmt(new Local_1.Local((methodName === 'main' ? '0' : 'undefinedValue'), this.declaringMethod.getSubSignature().getReturnType()));
+        }
+        return new Stmt_1.ArkReturnVoidStmt();
+    }
+    adjustBlocks(blockBuilderToCfgBlock, blocksContainLoopCondition, basicBlockSet, blockBuildersContainSwitch, valueAndStmtsOfSwitchAndCasesAll, arkIRTransformer) {
+        const asCoreMap = blockBuilderToCfgBlock;
+        const asCoreArr = blockBuildersContainSwitch;
+        const loopBuilder = new LoopBuilder_1.CxxLoopBuilder();
+        loopBuilder.rebuildBlocksInLoop(blockBuilderToCfgBlock, blocksContainLoopCondition, basicBlockSet, this.blocks);
+        const switchBuilder = new SwitchBuilder_1.CxxSwitchBuilder();
+        switchBuilder.buildSwitch(asCoreMap, asCoreArr, valueAndStmtsOfSwitchAndCasesAll, arkIRTransformer, basicBlockSet);
+        const conditionalBuilder = new ConditionBuilder_1.CxxConditionBuilder();
+        conditionalBuilder.rebuildBlocksContainConditionalOperator(asCoreMap, basicBlockSet, ModelUtils_1.ModelUtils.isArkUIBuilderMethod(this.declaringMethod));
+        const ifBuilder = new IfBuilder_1.CxxIfBuilder();
+        ifBuilder.rebuildIf(basicBlockSet);
+    }
+    createCfg(blockBuilderToCfgBlock, basicBlockSet, prevBlockId) {
+        let currBlockId = prevBlockId;
+        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;
+    }
+    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);
+            }
+        }
+    }
+}
+exports.CfgBuilder = CfgBuilder;