Enum BlockType 

pub enum BlockType {
    Entry,
    Exit,
    Branch,
    LoopHeader,
    LoopBody,
    Return,
    Body,
    Exception,
    Finally,
    TryOperator,
    ErrorReturn,
    PanicSite,
    PatternMatch,
    Closure,
    DeferredCall,
    RecoverCall,
    ErrorCheck,
    GoPanicSite,
    GoroutineSpawn,
    ChannelSend,
    ChannelReceive,
    SelectBlock,
    SelectCase,
    MutexLock,
    MutexUnlock,
    WaitGroupWait,
    WaitGroupOp,
    OnceCall,
    ChannelMake,
    ChannelClose,
    ContextCheck,
    AwaitPoint,
    AsyncForLoop,
    AsyncWithBlock,
    TaskSpawn,
    PromiseThen,
    PromiseCatch,
    PromiseFinally,
    PromiseAll,
    PromiseRace,
    PromiseAllSettled,
    PromiseAny,
    AsyncGeneratorYield,
    ForAwaitOf,
    RustAwaitPoint,
    RustTaskSpawn,
    RustJoin,
    RustSelect,
    RustSelectBranch,
    RustBlockingCall,
    RustLockAcrossAwait,
    RustAsyncBlock,
}

Type of a basic block in the control flow graph.

Categorizes blocks by their role in the control flow:

• Entry/Exit: Function boundaries
• Branch: Conditional decision points
• LoopHeader/LoopBody: Loop constructs
• Return: Explicit return statements
• Body: Regular sequential code
• Exception/Finally: Error handling constructs
• TryOperator/ErrorReturn/PanicSite: Rust Result/Option handling

Variants

Entry

Function entry point

Exit

Function exit point

Branch

Conditional branch (if, elif, match case)

LoopHeader

Loop header (condition evaluation)

LoopBody

Loop body

Return

Return statement block

Body

Regular code block (default)

Exception

Exception handler (except, catch)

Finally

Finally block

TryOperator

Rust ? operator - may propagate error/none (Result/Option)

ErrorReturn

Rust early return from ? operator on Err/None

PanicSite

Potential panic site (.unwrap(), .expect(), panic!(), unreachable!(), todo!())

PatternMatch

Pattern match block (if let, while let, match arm)

Closure

Closure body (separate control flow context)

DeferredCall

Go: Deferred function call (executes on function exit in LIFO order)

RecoverCall

Go: Recover call site (recover() in deferred function)

ErrorCheck

Go: Error check pattern (if err != nil { return err })

GoPanicSite

Go: Panic site (explicit panic() or potential runtime panic)

GoroutineSpawn

Go: Goroutine spawn (go func() {…} or go existingFunc())

ChannelSend

Go: Channel send operation (ch <- value) - may block

ChannelReceive

Go: Channel receive operation (val := <-ch or <-ch) - may block

SelectBlock

Go: Select statement block (multi-way channel operation)

SelectCase

Go: Select case (case <-ch: or case ch <-:)

MutexLock

Go: Mutex lock operation (mu.Lock() or mu.RLock())

MutexUnlock

Go: Mutex unlock operation (mu.Unlock() or mu.RUnlock())

WaitGroupWait

Go: WaitGroup wait operation (wg.Wait()) - synchronization point

WaitGroupOp

Go: WaitGroup add/done operation (wg.Add(), wg.Done())

OnceCall

Go: sync.Once.Do() call - one-time initialization

ChannelMake

Go: Channel make/creation (make(chan T) or make(chan T, size))

ChannelClose

Go: Channel close operation (close(ch))

ContextCheck

Go: Context cancellation check (ctx.Done(), ctx.Err())

AwaitPoint

Python: Await expression - suspension point where execution yields to event loop

AsyncForLoop

Python: Async for loop header

AsyncWithBlock

Python: Async with block (async context manager)

TaskSpawn

Python: Task spawn point (asyncio.create_task, asyncio.gather, etc.)

PromiseThen

JS/TS: Promise.then() callback block - executes on promise resolution

PromiseCatch

JS/TS: Promise.catch() callback block - executes on promise rejection

PromiseFinally

JS/TS: Promise.finally() callback block - executes regardless of outcome

PromiseAll

JS/TS: Promise.all() - parallel execution, waits for all promises

PromiseRace

JS/TS: Promise.race() - parallel execution, resolves with first settled

PromiseAllSettled

JS/TS: Promise.allSettled() - parallel execution, waits for all to settle

PromiseAny

JS/TS: Promise.any() - parallel execution, resolves with first fulfilled

AsyncGeneratorYield

JS/TS: Async generator yield point (yield* in async generator)

ForAwaitOf

JS/TS: for await…of loop header (async iteration)

RustAwaitPoint

Rust: Await expression (.await) - suspension point where Future yields Critical for tracking async state machine transitions and cancellation safety.

RustTaskSpawn

Rust: Task spawn point (tokio::spawn, async_std::spawn, etc.) Creates a concurrent task that runs independently.

RustJoin

Rust: tokio::join! - concurrent execution, waits for all futures All branches run concurrently, function continues when all complete.

RustSelect

Rust: tokio::select! - concurrent execution, first completion wins All branches race, first to complete is taken, others are cancelled.

RustSelectBranch

Rust: select! branch (individual arm in select!)

RustBlockingCall

Rust: Blocking call in async context (std::thread::sleep, blocking I/O) ANTI-PATTERN: Blocks the executor thread, starving other tasks.

RustLockAcrossAwait

Rust: Lock held across await (MutexGuard, RwLockGuard across .await) ANTI-PATTERN: Causes deadlocks and breaks Send bounds.

RustAsyncBlock

Rust: Async block (async { … }) - creates anonymous Future

Trait Implementations

impl Clone for BlockType

fn clone(&self) -> BlockType

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for BlockType

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for BlockType

fn default() -> BlockType

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for BlockType

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for BlockType

fn eq(&self, other: &BlockType) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for BlockType

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for BlockType

impl Eq for BlockType

impl StructuralPartialEq for BlockType