//! returns: 0
// Test deref behavior for single-field unlabeled records.

record Wrap(i32);
record WrapBool(bool);
record WrapU8(u8);
record WrapU64(u64);

fn getInner(w: Wrap) -> i32 {
    return *w;
}

fn passThrough(w: Wrap) -> Wrap {
    return Wrap(*w);
}

@default fn main() -> i32 {
    let w: Wrap = Wrap(42);

    // Basic deref.
    if *w != 42 {
        return 1;
    }

    // Deref in function call.
    if getInner(w) != 42 {
        return 2;
    }

    // Deref bool.
    let b: WrapBool = WrapBool(true);
    if *b != true {
        return 3;
    }

    // Deref u8.
    let u: WrapU8 = WrapU8(7);
    if *u != 7 {
        return 4;
    }

    // Deref in arithmetic.
    let a: Wrap = Wrap(10);
    let b2: Wrap = Wrap(20);
    if *a + *b2 != 30 {
        return 5;
    }

    // Deref and reconstruct.
    let w2: Wrap = passThrough(w);
    if *w2 != 42 {
        return 6;
    }

    // Deref u64.
    let big: WrapU64 = WrapU64(1234567890);
    if *big != 1234567890 {
        return 7;
    }

    // Deref in comparison.
    let x: Wrap = Wrap(5);
    let y: Wrap = Wrap(5);
    if *x != *y {
        return 8;
    }

    // Deref in let binding.
    let val: i32 = *Wrap(99);
    if val != 99 {
        return 9;
    }

    // Assignment through deref on mutable binding.
    let mut m: Wrap = Wrap(0);
    *m = 77;
    if *m != 77 {
        return 10;
    }

    return 0;
}