import { Local } from '../../../../core/base/Local';
import { ArkAliasTypeDefineStmt } from '../../../../core/base/Stmt';
import { Cfg } from '../../../../core/graph/Cfg';
import { ArkClass } from '../../../../core/model/ArkClass';
import { ArkMethod } from '../../../../core/model/ArkMethod';
import { AliasType } from '../../../../core/base/Type';
import { CxxTrap } from '../../base/Trap';
import { GlobalRef } from '../../../../core/base/Ref';
import { Catch, Variable, Scope } from '../../../../core/graph/builder/CfgBuilder';
import { CxxAstNode } from '../../utils/ArkCxxAstNode';
export declare class BlockBuilder {
    id: number;
    stmts: StatementBuilder[];
    nexts: BlockBuilder[];
    lasts: BlockBuilder[];
    walked: boolean;
    constructor(id: number, stmts: StatementBuilder[]);
}
export declare class Case {
    value: string;
    stmt: StatementBuilder;
    valueNode: CxxAstNode;
    constructor(value: string, stmt: StatementBuilder);
}
export declare class StatementBuilder {
    type: string;
    code: string;
    next: StatementBuilder | null;
    lasts: Set<StatementBuilder>;
    walked: boolean;
    index: number;
    line: number;
    column: number;
    astNode: CxxAstNode | null;
    scopeID: number;
    addressCode3: string[];
    block: BlockBuilder | null;
    ifExitPass: boolean;
    passTimes: number;
    numOfIdentifier: number;
    isDoWhile: boolean;
    hasDoWhileBody: boolean;
    constructor(type: string, code: string, astNode: CxxAstNode | null, scopeID: number);
}
declare class ConditionStatementBuilder extends StatementBuilder {
    nextT: StatementBuilder | null;
    nextF: StatementBuilder | null;
    loopBlock: BlockBuilder | null;
    condition: string;
    doStatement: StatementBuilder | null;
    constructor(type: string, code: string, astNode: CxxAstNode, scopeID: number);
}
export declare class SwitchStatementBuilder extends StatementBuilder {
    nexts: StatementBuilder[];
    cases: Case[];
    default: StatementBuilder | null;
    afterSwitch: StatementBuilder | null;
    constructor(type: string, code: string, astNode: CxxAstNode, scopeID: number);
}
export declare class TryStatementBuilder extends StatementBuilder {
    tryFirst: StatementBuilder | null;
    tryExit: StatementBuilder | null;
    catchStatement: StatementBuilder[];
    catchError: CxxAstNode[];
    finallyStatement: StatementBuilder | null;
    afterFinal: StatementBuilder | null;
    constructor(type: string, code: string, astNode: CxxAstNode, scopeID: number);
}
export declare class CfgBuilder {
    name: string;
    astRoot: CxxAstNode;
    entry: StatementBuilder;
    exit: StatementBuilder;
    loopStack: ConditionStatementBuilder[];
    switchExitStack: StatementBuilder[];
    functions: CfgBuilder[];
    breakin: string;
    statementArray: StatementBuilder[];
    dotEdges: number[][];
    scopes: Scope[];
    tempVariableNum: number;
    current3ACstm: StatementBuilder;
    blocks: BlockBuilder[];
    currentDeclarationKeyword: string;
    variables: Variable[];
    declaringClass: ArkClass;
    importFromPath: string[];
    catches: Catch[];
    exits: StatementBuilder[];
    emptyBody: boolean;
    arrowFunctionWithoutBlock: boolean;
    private sourceFile;
    private declaringMethod;
    private gotoStmtMap;
    private labelStmtMap;
    constructor(ast: CxxAstNode, name: string, declaringMethod: ArkMethod, sourceFile: CxxAstNode);
    getDeclaringMethod(): ArkMethod;
    judgeLastType(s: StatementBuilder, lastStatement: StatementBuilder): void;
    ASTNodeBreakStatement(c: CxxAstNode, lastStatement: StatementBuilder): void;
    ASTNodeIfStatement(c: CxxAstNode, lastStatement: StatementBuilder, scopeID: number): StatementBuilder;
    ASTNodeWhileStatement(c: CxxAstNode, lastStatement: StatementBuilder, scopeID: number): StatementBuilder;
    ASTNodeForStatement(c: CxxAstNode, lastStatement: StatementBuilder, scopeID: number): StatementBuilder;
    ASTNodeDoStatement(c: CxxAstNode, lastStatement: StatementBuilder, scopeID: number): StatementBuilder;
    private sliceCaseDefaultNode;
    private getCaseDefClauseAsts;
    /** Case constant label from structured literal/name fields (not {@link CxxAstNode.code}). */
    private caseLabelText;
    private getGotoLabel;
    ASTNodeSwitchStatement(c: CxxAstNode, lastStatement: StatementBuilder, scopeID: number): StatementBuilder;
    private ASTNodeCXXMemberCallExpr;
    ASTNodeGotoStatement(innerNode: CxxAstNode, lastStatement: StatementBuilder, scopeID: number): void;
    handleLabelStmtPassTimes(s: StatementBuilder, label: string): void;
    private judgeLastStmtForLabel;
    ASTNodeLabelStatement(innerNode: CxxAstNode, lastStatement: StatementBuilder, scopeID: number): StatementBuilder;
    /** Catch clause header from handler VarDecl / catch-all structure (not {@link CxxAstNode.code}). */
    private catchClauseHeaderText;
    ASTNodeTryStatement(c: CxxAstNode, lastStatement: StatementBuilder, scopeID: number): StatementBuilder;
    private hitsControlBoundaryBeforeRoot;
    walkAST(lastStatement: StatementBuilder, nextStatement: StatementBuilder, nodes: CxxAstNode[]): void;
    handleASTStmtSuccession(innerNode: CxxAstNode, lastStatement: StatementBuilder, scope: Scope): StatementBuilder;
    private ASTNodeImplicitCastExpr;
    addReturnInEmptyMethod(): void;
    deleteExitAfterCondition(last: ConditionStatementBuilder, exit: StatementBuilder): void;
    deleteExitAfterSwitch(last: SwitchStatementBuilder, exit: StatementBuilder): void;
    deleteExit(): void;
    addStmt2BlockStmtQueueInSpecialCase(stmt: StatementBuilder, stmtQueue: StatementBuilder[]): StatementBuilder | null;
    addStmt2BlockStmtQueue(stmt: StatementBuilder, stmtQueue: StatementBuilder[]): StatementBuilder | null;
    buildBlocks(): void;
    buildConditionNextBlocks(originStatement: ConditionStatementBuilder, block: BlockBuilder, isLastStatement: boolean): void;
    buildSwitchNextBlocks(originStatement: SwitchStatementBuilder, block: BlockBuilder, isLastStatement: boolean): void;
    buildNormalNextBlocks(originStatement: StatementBuilder, block: BlockBuilder, isLastStatement: boolean): void;
    buildBlocksNextLast(): void;
    addReturnBlock(returnStatement: StatementBuilder, notReturnStmts: StatementBuilder[]): void;
    addReturnStmt(): void;
    addStmtBuilderPosition(): void;
    CfgBuilder2Array(stmt: StatementBuilder): void;
    errorTest(stmt: StatementBuilder): void;
    getFuncBodyStmt(): CxxAstNode[];
    buildCfgBuilder(): void;
    isBodyEmpty(): boolean;
    buildCfg(): {
        cfg: Cfg;
        locals: Set<Local>;
        globals: Map<string, GlobalRef> | null;
        aliasTypeMap: Map<string, [AliasType, ArkAliasTypeDefineStmt]>;
        traps: CxxTrap[];
    };
    buildCfgForSimpleArrowFunction(): {
        cfg: Cfg;
        locals: Set<Local>;
        globals: Map<string, GlobalRef> | null;
        aliasTypeMap: Map<string, [AliasType, ArkAliasTypeDefineStmt]>;
        traps: CxxTrap[];
    };
    buildNormalCfg(): {
        cfg: Cfg;
        locals: Set<Local>;
        globals: Map<string, GlobalRef> | null;
        aliasTypeMap: Map<string, [AliasType, ArkAliasTypeDefineStmt]>;
        traps: CxxTrap[];
    };
    /**
     * 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.
     */
    private removeEmptyBlocks;
    /**
     * Bypasses a block by connecting all its predecessors directly to its successors.
     */
    private bypassAndRemoveBlock;
    private initializeBuild;
    /** Whether a {@link StatementBuilder} should be lowered to IR via its {@link CxxAstNode}. */
    private shouldEmitStatementBuilderAsIr;
    private processBlocks;
    private generateReturnStmt;
    private adjustBlocks;
    private createCfg;
    private linkBasicBlocks;
}
export {};
//# sourceMappingURL=CfgBuilder.d.ts.map