/// Return whether pointer classes are compatible in the current safety context.

    inUnsafeContext: bool,

        and (from == types::PointerClass::Owned

            or (from == types::PointerClass::Unsafe and inUnsafeContext))

        if not pointerClassesAssignable(lhsClass, rhsClass, self.inUnsafeContext) {

            if not pointerClassesAssignable(lhsClass, rhsClass, self.inUnsafeContext)

            if not pointerClassesAssignable(lhsClass, rhsClass, self.inUnsafeContext)

        if not pointerClassesAssignable(lhsClass, rhsClass, self.inUnsafeContext)

    if isRefType(to) and isUnsafePointerType(from) {

        try requireUnsafe(self, site);

    }

/// Raw pointers and slices can be borrowed in an unsafe context.

@test unsafe fn testImplicitRawBorrowAllowed() throws (testing::TestError) {

    let programs = &[

        "fn read(p: &u32) -> u32 { return *p; } unsafe fn run(p: *unsafe u32) -> u32 { return read(p); }",

        "fn write(p: &mut u32) { set *p = 7; } fn run(p: *unsafe mut u32) { unsafe { write(p); write(p); } }",

        "fn read(p: &[u32]) -> u32 { return p[0]; } unsafe fn run(p: *unsafe [u32]) -> u32 { return read(p); }",

        "fn write(p: &mut [u32]) { set p[0] = 7; } unsafe fn run(p: *unsafe mut [u32]) { write(p); write(p); }",

        "fn read(p: &u32) {} unsafe fn run(p: *unsafe mut u32) { read(p); }",

        "trait Read { fn (&Read) get(); } fn read(p: &opaque Read) {} unsafe fn run(p: *unsafe opaque Read) { read(p); }",

    ];

    for program in programs {

        try expectAnalyzeOk(program);

    }

}

/// An implicit borrow of raw storage requires an unsafe context.

@test unsafe fn testImplicitRawBorrowRequiresUnsafe() throws (testing::TestError) {

    let programs = &[

        "fn read(p: &u32) {} fn run(p: *unsafe u32) { read(p); }",

        "fn write(p: &mut u32) {} fn run(p: *unsafe mut u32) { write(p); }",

        "fn read(p: &[u32]) {} fn run(p: *unsafe [u32]) { read(p); }",

        "fn write(p: &mut [u32]) {} fn run(p: *unsafe mut [u32]) { write(p); }",

        "trait Read { fn (&Read) get(); } fn read(p: &opaque Read) {} fn run(p: *unsafe opaque Read) { read(p); }",

        "fn read(p: &u32) {} fn run(p: *unsafe u32) { unsafe { read(p); } read(p); }",

    ];

    for program in programs {

        let mut a = testResolver();

        let result = try resolveProgramStr(&mut a, program);

        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);

    }

}

/// Raw borrows preserve mutability, storage type, and ownership constraints.

@test unsafe fn testImplicitRawBorrowPreservesTypes() throws (testing::TestError) {

    let programs = &[

        "fn write(p: &mut u32) {} unsafe fn run(p: *unsafe u32) { write(p); }",

        "fn write(p: &mut [u32]) {} unsafe fn run(p: *unsafe [u32]) { write(p); }",

        "fn read(p: &u64) {} unsafe fn run(p: *unsafe u32) { read(p); }",

        "fn read(p: &[u64]) {} unsafe fn run(p: *unsafe [u32]) { read(p); }",

        "fn take(p: *u32) {} unsafe fn run(p: *unsafe u32) { take(p); }",

        "fn take(p: *[u32]) {} unsafe fn run(p: *unsafe [u32]) { take(p); }",

        "fn read(p: &*u32) {} unsafe fn run(p: *unsafe *unsafe u32) { read(p); }",

    ];

    for program in programs {

        let mut a = testResolver();

        let result = try resolveProgramStr(&mut a, program);

        let err = try expectError(&result);

        let case super::ErrorKind::TypeMismatch(_) = err.kind

            else throw testing::TestError::Failed;

    }

}

/// Implicit raw borrows retain the call's exclusive-borrow checks.

@test unsafe fn testImplicitRawBorrowConflict() throws (testing::TestError) {

    let mut a = testResolver();

    let result = try resolveProgramStr(&mut a,

        "fn useBoth(a: &mut u32, b: &u32) {} unsafe fn run(p: *unsafe mut u32) { useBoth(p, p); }");

    try expectErrorKind(&result, super::ErrorKind::BorrowConflict("p"));

}

//! 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;

}