arkanalyzer 1.0.17 → 1.0.19

package/lib/core/graph/builder/ConditionBuilder.d.ts

@@ -0,0 +1,16 @@
+import { BasicBlock } from '../BasicBlock';
+/**
+ * Builder for condition in CFG
+ */
+export declare class ConditionBuilder {
+    rebuildBlocksContainConditionalOperator(basicBlockSet: Set<BasicBlock>, isArkUIBuilder: boolean): void;
+    private relinkPrevAndSuccOfBlockContainConditionalOperator;
+    private generateBlocksContainConditionalOperatorGroup;
+    private generateBlocksContainSingleConditionalOperator;
+    private generateBlockWithoutConditionalOperator;
+    private deleteDummyConditionalOperatorStmt;
+    private findFirstConditionalOperator;
+    private removeUnnecessaryBlocksInConditionalOperator;
+    private replaceTempRecursively;
+}
+//# sourceMappingURL=ConditionBuilder.d.ts.map

package/lib/core/graph/builder/ConditionBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConditionBuilder.d.ts","sourceRoot":"","sources":["../../../../src/core/graph/builder/ConditionBuilder.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAM3C;;GAEG;AACH,qBAAa,gBAAgB;IAClB,uCAAuC,CAAC,aAAa,EAAE,GAAG,CAAC,UAAU,CAAC,EAAE,cAAc,EAAE,OAAO,GAAG,IAAI;IA8C7G,OAAO,CAAC,kDAAkD;IAqB1D,OAAO,CAAC,6CAA6C;IAkCrD,OAAO,CAAC,8CAA8C;IAoDtD,OAAO,CAAC,uCAAuC;IAc/C,OAAO,CAAC,kCAAkC;IAY1C,OAAO,CAAC,4BAA4B;IA4BpC,OAAO,CAAC,4CAA4C;IAqCpD,OAAO,CAAC,sBAAsB;CA4CjC"}

package/lib/core/graph/builder/ConditionBuilder.js

@@ -0,0 +1,252 @@
+"use strict";
+/*
+ * Copyright (c) 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.ConditionBuilder = void 0;
+const BasicBlock_1 = require("../BasicBlock");
+const ArkIRTransformer_1 = require("../../common/ArkIRTransformer");
+const Stmt_1 = require("../../base/Stmt");
+const Local_1 = require("../../base/Local");
+const IRUtils_1 = require("../../common/IRUtils");
+/**
+ * Builder for condition in CFG
+ */
+class ConditionBuilder {
+    rebuildBlocksContainConditionalOperator(basicBlockSet, isArkUIBuilder) {
+        var _a;
+        if (isArkUIBuilder) {
+            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;
+    }
+}
+exports.ConditionBuilder = ConditionBuilder;

package/lib/core/graph/builder/LoopBuilder.d.ts

@@ -0,0 +1,21 @@
+import { BasicBlock } from '../BasicBlock';
+import { BlockBuilder } from './CfgBuilder';
+/**
+ * Builder for loop in CFG
+ */
+export declare class LoopBuilder {
+    rebuildBlocksInLoop(blockBuilderToCfgBlock: Map<BlockBuilder, BasicBlock>, blocksContainLoopCondition: Set<BlockBuilder>, basicBlockSet: Set<BasicBlock>, blockBuilders: BlockBuilder[]): void;
+    private doesPrevBlockBuilderContainLoop;
+    private insertBeforeConditionBlockBuilder;
+    private getBlockFromMap;
+    private collectBlocksBeforeAndReenter;
+    private getCollectedBlocks;
+    private createAndLinkBlocks;
+    private updatePredecessors;
+    private getNewPrevBlocks;
+    private updateConditionBlockBuilder;
+    private finalizeInsertion;
+    private findIteratorIdx;
+    private adjustIncrementorStmts;
+}
+//# sourceMappingURL=LoopBuilder.d.ts.map

package/lib/core/graph/builder/LoopBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LoopBuilder.d.ts","sourceRoot":"","sources":["../../../../src/core/graph/builder/LoopBuilder.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAK3C,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAE5C;;GAEG;AACH,qBAAa,WAAW;IACb,mBAAmB,CAAC,sBAAsB,EAAE,GAAG,CAAC,YAAY,EAAE,UAAU,CAAC,EACrD,0BAA0B,EAAE,GAAG,CAAC,YAAY,CAAC,EAC7C,aAAa,EAAE,GAAG,CAAC,UAAU,CAAC,EAAE,aAAa,EAAE,YAAY,EAAE,GAAG,IAAI;IAwD/F,OAAO,CAAC,+BAA+B;IAYvC,OAAO,CAAC,iCAAiC;IAqCzC,OAAO,CAAC,eAAe;IAKvB,OAAO,CAAC,6BAA6B;IA2BrC,OAAO,CAAC,kBAAkB;IAmB1B,OAAO,CAAC,mBAAmB;IAiB3B,OAAO,CAAC,kBAAkB;IAmB1B,OAAO,CAAC,gBAAgB;IAqBxB,OAAO,CAAC,2BAA2B;IAWnC,OAAO,CAAC,iBAAiB;IAYzB,OAAO,CAAC,eAAe;IAiCvB,OAAO,CAAC,sBAAsB;CA4CjC"}

package/lib/core/graph/builder/LoopBuilder.js

@@ -0,0 +1,251 @@
+"use strict";
+/*
+ * Copyright (c) 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.LoopBuilder = void 0;
+const BasicBlock_1 = require("../BasicBlock");
+const Stmt_1 = require("../../base/Stmt");
+const Expr_1 = require("../../base/Expr");
+const Builtin_1 = require("../../common/Builtin");
+const ArkIRTransformer_1 = require("../../common/ArkIRTransformer");
+const CfgBuilder_1 = require("./CfgBuilder");
+/**
+ * Builder for loop in CFG
+ */
+class LoopBuilder {
+    rebuildBlocksInLoop(blockBuilderToCfgBlock, blocksContainLoopCondition, basicBlockSet, blockBuilders) {
+        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);
+                // If the loop body is empty, the loop conditional block should contain its own
+                const emptyLoopBody = blockBuilder.nexts.length === 1;
+                if (emptyLoopBody) {
+                    blockBuilder.nexts.splice(0, 0, blockBuilder);
+                    blockBuilder.lasts.push(blockBuilder);
+                    block.getSuccessors().splice(0, 0, block);
+                    block.addPredecessorBlock(block);
+                }
+                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, blockBuilders);
+                }
+                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, emptyLoopBody, blockBuilders);
+                }
+                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, blockBuilders) {
+        if (stmtsInsertBeforeCondition.length === 0) {
+            return;
+        }
+        const blockId = conditionBlockBuilder.id;
+        const block = this.getBlockFromMap(blockBuilderToCfgBlock, conditionBlockBuilder);
+        const { blockBuildersBeforeCondition, blocksBeforeCondition, blockBuildersReenterCondition, blocksReenterCondition, } = this.collectBlocksBeforeAndReenter(blockBuilderToCfgBlock, conditionBlockBuilder, blockId);
+        const { collectedBlockBuilders, collectedBlocks, } = this.getCollectedBlocks(collectReenter, blockBuildersBeforeCondition, blocksBeforeCondition, blockBuildersReenterCondition, blocksReenterCondition);
+        const { blockBuilderInsertBeforeCondition, blockInsertBeforeCondition } = this.createAndLinkBlocks(collectedBlockBuilders, collectedBlocks, conditionBlockBuilder, stmtsInsertBeforeCondition, block);
+        this.updatePredecessors(collectedBlockBuilders, blockBuilderToCfgBlock, conditionBlockBuilder, blockBuilderInsertBeforeCondition, blockInsertBeforeCondition);
+        const { newPrevBlockBuildersBeforeCondition, newPrevBlocksBeforeCondition } = this.getNewPrevBlocks(collectReenter, blockBuildersBeforeCondition, blocksBeforeCondition, blockBuilderInsertBeforeCondition, blockInsertBeforeCondition, blockBuildersReenterCondition, blocksReenterCondition);
+        this.updateConditionBlockBuilder(conditionBlockBuilder, newPrevBlockBuildersBeforeCondition, block, newPrevBlocksBeforeCondition);
+        this.finalizeInsertion(blockBuilderInsertBeforeCondition, blockInsertBeforeCondition, basicBlockSet, blockBuilderToCfgBlock, blockBuilders);
+    }
+    getBlockFromMap(blockBuilderToCfgBlock, conditionBlockBuilder) {
+        return blockBuilderToCfgBlock.get(conditionBlockBuilder);
+    }
+    collectBlocksBeforeAndReenter(blockBuilderToCfgBlock, conditionBlockBuilder, blockId) {
+        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);
+            }
+        }
+        return {
+            blockBuildersBeforeCondition, blocksBeforeCondition, blockBuildersReenterCondition, blocksReenterCondition,
+        };
+    }
+    getCollectedBlocks(collectReenter, blockBuildersBeforeCondition, blocksBeforeCondition, blockBuildersReenterCondition, blocksReenterCondition) {
+        let collectedBlockBuilders = [];
+        let collectedBlocks = [];
+        if (collectReenter) {
+            collectedBlockBuilders = blockBuildersReenterCondition;
+            collectedBlocks = blocksReenterCondition;
+        }
+        else {
+            collectedBlockBuilders = blockBuildersBeforeCondition;
+            collectedBlocks = blocksBeforeCondition;
+        }
+        return { collectedBlockBuilders, collectedBlocks };
+    }
+    createAndLinkBlocks(collectedBlockBuilders, collectedBlocks, conditionBlockBuilder, stmtsInsertBeforeCondition, block) {
+        const blockBuilderInsertBeforeCondition = new CfgBuilder_1.BlockBuilder(-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);
+        return { blockBuilderInsertBeforeCondition, blockInsertBeforeCondition };
+    }
+    updatePredecessors(collectedBlockBuilders, blockBuilderToCfgBlock, conditionBlockBuilder, blockBuilderInsertBeforeCondition, blockInsertBeforeCondition) {
+        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;
+                }
+            }
+        }
+    }
+    getNewPrevBlocks(collectReenter, blockBuildersBeforeCondition, blocksBeforeCondition, blockBuilderInsertBeforeCondition, blockInsertBeforeCondition, blockBuildersReenterCondition, blocksReenterCondition) {
+        let newPrevBlockBuildersBeforeCondition = [];
+        let newPrevBlocksBeforeCondition = [];
+        if (collectReenter) {
+            newPrevBlockBuildersBeforeCondition = [...blockBuildersBeforeCondition, blockBuilderInsertBeforeCondition];
+            newPrevBlocksBeforeCondition = [...blocksBeforeCondition, blockInsertBeforeCondition];
+        }
+        else {
+            newPrevBlockBuildersBeforeCondition = [blockBuilderInsertBeforeCondition, ...blockBuildersReenterCondition];
+            newPrevBlocksBeforeCondition = [blockInsertBeforeCondition, ...blocksReenterCondition];
+        }
+        return { newPrevBlockBuildersBeforeCondition, newPrevBlocksBeforeCondition };
+    }
+    updateConditionBlockBuilder(conditionBlockBuilder, newPrevBlockBuildersBeforeCondition, block, newPrevBlocksBeforeCondition) {
+        conditionBlockBuilder.lasts = newPrevBlockBuildersBeforeCondition;
+        const predecessorsCnt = block.getPredecessors().length;
+        block.getPredecessors().splice(0, predecessorsCnt, ...newPrevBlocksBeforeCondition);
+    }
+    finalizeInsertion(blockBuilderInsertBeforeCondition, blockInsertBeforeCondition, basicBlockSet, blockBuilderToCfgBlock, blockBuilders) {
+        blockBuilders.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, emptyLoopBody, blockBuilders) {
+        const stmtsReenterCondition = stmts.slice(ifStmtIdx + 1);
+        if (emptyLoopBody) {
+            const incrementorBlockBuilder = new CfgBuilder_1.BlockBuilder(-1, []);
+            incrementorBlockBuilder.lasts.push(currBlockBuilder);
+            currBlockBuilder.nexts[0] = incrementorBlockBuilder;
+            incrementorBlockBuilder.nexts.push(currBlockBuilder);
+            currBlockBuilder.lasts[1] = incrementorBlockBuilder;
+            const incrementorBlock = new BasicBlock_1.BasicBlock();
+            blockBuilderToCfgBlock.set(incrementorBlockBuilder, incrementorBlock);
+            stmtsReenterCondition.forEach(stmt => incrementorBlock.getStmts().push(stmt));
+            const currBlock = blockBuilderToCfgBlock.get(currBlockBuilder);
+            incrementorBlock.getPredecessors().push(currBlock);
+            currBlock.setPredecessorBlock(1, incrementorBlock);
+            incrementorBlock.addSuccessorBlock(currBlock);
+            currBlock.setSuccessorBlock(0, incrementorBlock);
+            basicBlockSet.add(incrementorBlock);
+            return;
+        }
+        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, blockBuilders);
+        }
+        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));
+        }
+    }
+}
+exports.LoopBuilder = LoopBuilder;

package/lib/core/graph/builder/SwitchBuilder.d.ts

@@ -0,0 +1,12 @@
+import { BasicBlock } from '../BasicBlock';
+import { ArkIRTransformer, ValueAndStmts } from '../../common/ArkIRTransformer';
+import { BlockBuilder } from './CfgBuilder';
+/**
+ * Builder for switch statement in CFG
+ */
+export declare class SwitchBuilder {
+    buildSwitch(blockBuilderToCfgBlock: Map<BlockBuilder, BasicBlock>, blockBuildersContainSwitch: BlockBuilder[], valueAndStmtsOfSwitchAndCasesAll: ValueAndStmts[][], arkIRTransformer: ArkIRTransformer, basicBlockSet: Set<BasicBlock>): void;
+    private generateIfBlocksForCases;
+    private linkIfBlockAndCaseBlock;
+}
+//# sourceMappingURL=SwitchBuilder.d.ts.map

package/lib/core/graph/builder/SwitchBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwitchBuilder.d.ts","sourceRoot":"","sources":["../../../../src/core/graph/builder/SwitchBuilder.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAEhF,OAAO,EAAE,YAAY,EAA0B,MAAM,cAAc,CAAC;AAKpE;;GAEG;AACH,qBAAa,aAAa;IACf,WAAW,CAAC,sBAAsB,EAAE,GAAG,CAAC,YAAY,EAAE,UAAU,CAAC,EACrD,0BAA0B,EAAE,YAAY,EAAE,EAC1C,gCAAgC,EAAE,aAAa,EAAE,EAAE,EAAE,gBAAgB,EAAE,gBAAgB,EACvF,aAAa,EAAE,GAAG,CAAC,UAAU,CAAC,GAAG,IAAI;IAsCxD,OAAO,CAAC,wBAAwB;IAiChC,OAAO,CAAC,uBAAuB;CA8ClC"}