Struct valkyrie_ast::WhileLoop

pub struct WhileLoop {
    pub kind: WhileLoopKind,
    pub condition: WhileConditionNode,
    pub then: StatementBlock,
    pub span: Range<u32>,
}

while cond {...} otherwise {...}

outer: loop {
    if c1 {
        break; // break 'outer
    }
    if c2 {
        continue; // continue 'outer
    }
    if c3 {
        return;
    }
    inner: loop {
        if c4 {
            break 'outer;
        }
        if c5 {
            continue 'outer;
        }
        if c6 {
            return;
        }
        if c7 {
            break; // break 'inner
        }
        if c8 {
            continue; // continue 'inner
        }
        if c9 {
            return;
        }
        "inner-continuation"
    }
    "outer-continuation"
}
"function-continuation"

// promotion local variable here!!
let outer_continue = || {
    if c1 {
        outer_break()
    }
    if c2 {
        outer_continue();
    }
    if c3 {
        return;
    }
    inner: loop {
        if c4 {
            outer_break()
        }
        if c5 {
            outer_continue()
        }
        if c6 {
            return;
        }
        if c7 {
            break; // break 'inner
        }
        if c8 {
            continue; // continue 'inner
        }
        if c9 {
            return;
        }
        "inner-continuation"
    }
    "outer-continuation"
}
let outer_break = || {
    "function-continuation"
}

// promotion local variable here!!
let outer_continue = || {
    if c1 {
        outer_break()
    }
    if c2 {
        outer_continue();
    }
    if c3 {
        return;
    }
    inner_continue()
}
let outer_break = || {
    "function-continuation"
}
let inner_continue = || {
    if c4 {
        outer_break()
    }
    if c5 {
        outer_continue()
    }
    if c6 {
        return;
    }
    if c7 {
        inner_break()
    }
    if c8 {
        inner_continue()
    }
    if c9 {
        return;
    }
}
let inner_break = || {
    "outer-continuation"
}

Fields

kind: WhileLoopKind

The kind of while loop, including while and until

condition: WhileConditionNode

The condition of the loop

then: StatementBlock

The main body of the loop

span: Range<u32>

The range of the node

Trait Implementations

impl Clone for WhileLoop

fn clone(&self) -> WhileLoop

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for WhileLoop

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

Formats the value using the given formatter.

impl From<WhileLoop> for StatementKind

fn from(o: WhileLoop) -> Self

Converts to this type from the input type.

impl Hash for WhileLoop

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for WhileLoop

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl ValkyrieNode for WhileLoop

fn get_range(&self) -> Range<usize>

The range of the node

fn get_start(&self) -> usize

Get the start of the node

fn get_end(&self) -> usize

Get the end of the node

impl Eq for WhileLoop

impl StructuralPartialEq for WhileLoop