//! returns: 0
//! Borrow raw storage for safe function calls inside an unsafe context.

/// Read a borrowed value.
fn read(value: &u32) -> u32 {
    return *value;
}

/// Write a borrowed value.
fn write(value: &mut u32, number: u32) {
    set *value = number;
}

/// Write both elements of the borrowed test slice.
fn fill(values: &mut [u32]) {
    set values[0] = 10;
    set values[1] = 20;
}

/// Add both elements of the borrowed test slice.
fn sum(values: &[u32]) -> u32 {
    return values[0] + values[1];
}

/// Value inspected through a borrowed trait object.
record Cell {
    /// Number returned by the reader.
    value: u32,
}

/// Read a number through a borrowed receiver.
trait Reader {
    /// Return the stored number.
    fn (&Reader) get() -> u32;
}

instance Reader for Cell {
    /// Return the cell's stored number.
    fn (cell: &Cell) get() -> u32 {
        return cell.value;
    }
}

/// Read through an erased borrowed receiver.
fn inspect(reader: &opaque Reader) -> u32 {
    return reader.get();
}

/// Keep raw storage live for each borrowed call.
@default unsafe fn main() -> u32 {
    let mut value: u32 = 0;
    let raw: *unsafe mut u32 = &mut value;
    let alias = raw;
    write(raw, 42);
    assert read(alias) == 42;
    write(alias, 43);
    assert read(raw) == 43;

    let mut values: [u32; 2] = [0, 0];
    let rawValues: *unsafe mut [u32] = &mut values[..];
    fill(rawValues);
    assert sum(rawValues) == 30;
    assert sum(@sliceOf(&values[0] as *unsafe u32, 2)) == 30;

    let cell = Cell { value: 7 };
    let rawCell: *unsafe Cell = &(cell);
    assert inspect(rawCell) == 7;
    let object: *unsafe opaque Reader = rawCell;
    assert inspect(object) == 7;
    return 0;
}