//! 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);
    set *m = 77;
    if *m <> 77 {
        return 10;
    }

    return 0;
}