//! returns: 42

/// Return the optional value or a default.

fn fallback(value: ?u32) -> u32 {

    let item = value else 40;

    return item;

}

/// Exercise value-producing and case-pattern `let-else`.

@default fn main() -> u32 {

    let expected: u32 = 1;

    let actual: u32 = 2;

    let case expected = actual else fallback(nil);

    assert expected == 1;

    return fallback(nil) + fallback(2);

}

//! returns: 42

/// Linear token consumed by the test.

union Token: Linear {

    Value(u32),

}

/// Consume a token and return its payload.

fn consume(token: Token) -> u32 {

    match token {

        case Token::Value(value) => return value,

    }

}

/// Exercise linear ownership.

@default fn main() -> u32 {

    let token = Token::Value(42);

    return consume(token);

}

fn w32 $consume(w64 %0) {

  @entry0

    reserve %1 8 4;

    blit %1 %0 8;

    jmp @arm1;

  @arm1

    jmp @case2;

  @case2

    load w32 %2 %1 4;

    ret %2;

}

fn w32 $main() {

  @entry0

    reserve %0 4 4;

    store w32 42 %0 0;

    reserve %1 8 4;

    store w8 0 %1 0;

    add w64 %2 %1 4;

    blit %2 %0 4;

    call w32 %3 $consume(%1);

    ret %3;

}

//! returns: 42

/// Linear counter borrowed and consumed by the test.

union Counter: Linear {

    Value(u32),

}

/// Increment a borrowed counter.

fn increment(counter: &mut Counter) {

    match counter {

        case Counter::Value(value) => set *value += 1,

    }

}

/// Consume a counter and return its value.

fn consume(counter: Counter) -> u32 {

    match counter {

        case Counter::Value(value) => return value,

    }

}

/// Exercise mutable references to linear values.

@default fn main() -> u32 {

    let mut counter = Counter::Value(40);

    increment(&mut counter);

    increment(&mut counter);

    return consume(counter);

}

fn w64 $increment(w64 %0) {

  @entry0

    jmp @arm1;

  @arm1

    jmp @case2;

  @case2

    add w64 %1 %0 4;

    load w32 %2 %1 0;

    add w32 %3 %2 1;

    store w32 %3 %1 0;

    jmp @merge4;

  @merge4

    ret;

}

fn w32 $consume(w64 %0) {

  @entry0

    reserve %1 8 4;

    blit %1 %0 8;

    jmp @arm1;

  @arm1

    jmp @case2;

  @case2

    load w32 %2 %1 4;

    ret %2;

}

fn w32 $main() {

  @entry0

    reserve %0 4 4;

    store w32 40 %0 0;

    reserve %1 8 4;

    store w8 0 %1 0;

    add w64 %2 %1 4;

    blit %2 %0 4;

    call w64 $increment(%1);

    call w64 $increment(%1);

    call w32 %3 $consume(%1);

    ret %3;

}

//! returns: 42

/// Linear marker that enables linear checking.

record Marker: Linear {}

/// Load a value through an unsafe pointer.

unsafe fn load(pointer: *unsafe u32) -> u32 {

    return *pointer;

}

/// Store a value through an unsafe pointer.

unsafe fn store(pointer: *unsafe mut u32, value: u32) {

    set *pointer = value;

}

/// Exercise unsafe pointer loads and stores.

@default unsafe fn main() -> u32 {

    let mut value: u32 = 0;

    store(&mut value as *unsafe mut u32, 42);

    return load(&value as *unsafe u32);

}

fn w32 $load(w64 %0) {

  @entry0

    load w32 %1 %0 0;

    ret %1;

}

fn w64 $store(w64 %0, w32 %1) {

  @entry0

    store w32 %1 %0 0;

    ret;

}

fn w32 $main() {

  @entry0

    reserve %0 4 4;

    store w32 0 %0 0;

    call w64 $store(%0, 42);

    call w32 %1 $load(%0);

    ret %1;

}