//! returns: 0
//! A constant of optional scalar type holds a present optional, also when its
//! initializer is a folded literal.

/// Record with an optional field.
record Holder {
    value: ?u32,
}

constant U: ?u32 = 9;
constant SUM: ?u32 = 4 + 5;
constant FLAG: ?bool = true;
constant OFF: ?bool = false;
constant NEG: ?i8 = -3;
constant WIDE: ?i64 = -300000000000;
constant BYTE: ?u8 = 200;
constant LETTER: ?u8 = 'a';
constant ABSENT: ?u32 = nil;
constant COPY: ?u32 = U;
constant LIST: [?u32; 3] = [U, nil, 5];
constant HOLDER: Holder = Holder { value: U };
static LIVE: ?u32 = 9;

/// Read an optional scalar with a default.
fn orZero(o: ?u32) -> u32 {
    if let v = o {
        return v;
    }
    return 0;
}

/// Return the constant as an optional value.
fn give() -> ?u32 {
    return U;
}

/// Classify an optional scalar by matching.
fn classify(o: ?u32) -> u32 {
    match o {
        case 9   => return 1,
        case nil => return 2,
        else     => return 3,
    }
}

/// Check `if-let`, equality, and matching on constants.
fn reads() {
    if let v = U {
        assert v == 9;
    } else {
        panic "reads: U";
    }
    assert U == 9;
    assert U <> nil;
    assert classify(U) == 1;
    assert classify(ABSENT) == 2;
    assert classify(LIVE) == 1;
    assert SUM == 9;
    let copy = U;
    assert copy == 9;
    let missing = ABSENT;
    assert missing == nil;
}

/// Check scalar kinds other than `u32`.
fn kinds() {
    if let v = FLAG {
        assert v;
    } else {
        panic "kinds: FLAG";
    }
    if let v = OFF {
        assert not v;
    } else {
        panic "kinds: OFF";
    }
    if let v = NEG {
        assert v == -3;
    } else {
        panic "kinds: NEG";
    }
    if let v = WIDE {
        assert v == -300000000000;
    } else {
        panic "kinds: WIDE";
    }
    if let v = BYTE {
        assert v == 200;
    } else {
        panic "kinds: BYTE";
    }
    if let v = LETTER {
        assert v == 'a';
    } else {
        panic "kinds: LETTER";
    }
}

/// Check arguments, return values, and other constants and records.
fn uses() {
    assert orZero(U) == 9;
    assert orZero(give()) == 9;
    assert orZero(COPY) == 9;
    assert orZero(LIST[0]) == 9;
    assert LIST[1] == nil;
    assert orZero(LIST[2]) == 5;
    assert orZero(HOLDER.value) == 9;
    assert orZero(LIVE) == 9;
}

/// Check a constant declared in a function.
fn locals() {
    constant LOCAL: ?u32 = 4;
    if let v = LOCAL {
        assert v == 4;
    } else {
        panic "locals: LOCAL";
    }
}

@default fn main() -> i32 {
    reads();
    kinds();
    uses();
    locals();
    return 0;
}
