}

    let arrayLit = ast::synthNode(arena, ast::NodeValue::ArrayLit(elements));

    // Build: `&[...]`.

    let testsRef = ast::synthNode(arena, ast::NodeValue::AddressOf(ast::AddressOf {

    }));

    // Build: `testing::runAllTests(&[...])`.

    let runFn = synthScopeAccess(arena, &["testing", "runAllTests"]);

    let callArgs = ast::nodeSlice(arena, 1).append(testsRef, a);

    returnType: ?*Node,

    /// Throwable type nodes declared in the signature.

    throwList: *[*Node],

}

/// Address-of expression metadata.

export record AddressOf: Copy {

    /// Target expression being referenced.

    target: *Node,

}

/// Compound statement block with optional dedicated scope.

export record Block: Copy {

    /// Statements that belong to this block.

        case super::NodeValue::FieldAccess(acc) =>

            return sexpr::list(a, ".", &[toExpr(a, acc.parent), toExpr(a, acc.child)]),

        case super::NodeValue::ScopeAccess(acc) =>

            return sexpr::list(a, "::", &[toExpr(a, acc.parent), toExpr(a, acc.child)]),

        case super::NodeValue::AddressOf(addr) =>

                else sexpr::list(a, "&", &[toExpr(a, addr.target)]),

        case super::NodeValue::Deref(target) =>

            return sexpr::list(a, "deref", &[toExpr(a, target)]),

        case super::NodeValue::As(cast) =>

            return sexpr::list(a, "as", &[toExpr(a, cast.value), toExpr(a, cast.type)]),

        children: [0; MAX_MODULES],

        childrenLen: 0,

        ast: nil,

        source: nil,

    };

    // TODO: This is a common pattern that needs better syntax.

    let m = try! alloc::alloc(&mut arena.arena, @sizeOf(ModuleEntry), @alignOf(ModuleEntry)) as *mut ModuleEntry;

    set *m = ModuleEntry {

        id: idx as u16,

            let value = try parseUnaryExpr(p);

            return node(p, ast::NodeValue::Deref(value));

        }

        case scanner::TokenKind::Amp => {

            advance(p);

            let target = try parseUnaryExpr(p);

        }

        else => {

            return try parsePrimary(p);

        }

    }

}

/// Find the operator info for a token if it has precedence greater than the

/// given minimum.

fn findNextOp(kind: scanner::TokenKind, minPrec: i32) -> ?OpInfo {

    if let opInfo = getOpInfo(kind) {

        if opInfo.prec > minPrec {

    let mut region = node(p, ast::NodeValue::Region { name: regionName, parent: nil });

    let mut bindings = ast::nodeSlice(p.arena, 4);

    loop {

        try expect(p, scanner::TokenKind::Equal, "expected `=` after region binding");

        try expect(p, scanner::TokenKind::Amp, "expected `&` before borrowed place");

        let target = try parseUnaryExpr(p);

        bindings.append(node(p, ast::NodeValue::RegionBinding({ label: binding, value })), p.allocator);

        if not consume(p, scanner::TokenKind::Comma) {

            break;

        }

        set binding = try parseIdent(p, "expected region binding name");

/// Parse an allocation session with an implicit exclusive source borrow.

unsafe fn parseSessionBlock(p: &mut Parser) -> *ast::Node throws (ParseError) {

    try expect(p, scanner::TokenKind::Use, "expected `use`");

    let target = try parseUnaryExpr(p);

    try expect(p, scanner::TokenKind::As, "expected `as` after allocation source");

    let binding = try parseIdent(p, "expected allocation binding after `as`");

    let region = sessionRegion(p, binding);

    try expect(p, scanner::TokenKind::In, "expected `in` after allocation binding");

    let bindings = ast::nodeSlice(p.arena, 1).append(

    }

}

/// Test parsing reference (address-of) expressions.

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

    {

        let refExpr = try! parseExprStr("&foo");

        let case ast::NodeValue::AddressOf(refNode) = refExpr.value

            else throw testing::TestError::Failed;

        try expectIdent(refNode.target, "foo");

    }

    {

        let mutRefExpr = try! parseExprStr("&mut bar");

        let case ast::NodeValue::AddressOf(mutRefNode) = mutRefExpr.value

            else throw testing::TestError::Failed;

        try expectIdent(mutRefNode.target, "bar");

    }

    {

        let refFieldExpr = try! parseExprStr("&obj.field");

        let case ast::NodeValue::AddressOf(refFieldNode) = refFieldExpr.value

            else throw testing::TestError::Failed;

        let case ast::NodeValue::FieldAccess(access) = refFieldNode.target.value

            else throw testing::TestError::Failed;

        try expectIdent(access.parent, "obj");

        try expectIdent(access.child, "field");

    }

    {

        let mutRefFieldExpr = try! parseExprStr("&mut obj.field");

        let case ast::NodeValue::AddressOf(mutRefFieldNode) = mutRefFieldExpr.value

            else throw testing::TestError::Failed;

        let case ast::NodeValue::FieldAccess(access) = mutRefFieldNode.target.value

            else throw testing::TestError::Failed;

        try expectIdent(access.parent, "obj");

        try expectIdent(access.child, "field");

    }

    let case ast::NodeValue::RegionBinding(arenaBinding) = arenaBindings[0].value

        else throw testing::TestError::Failed;

    let arenaLabel = arenaBinding.label else throw testing::TestError::Failed;

    let case ast::NodeValue::Ident(arenaLabelName) = arenaLabel.value

        else throw testing::TestError::Failed;

        else throw testing::TestError::Failed;

    let case ast::NodeValue::Ident(arenaTargetName) = arenaTarget.value

        else throw testing::TestError::Failed;

    try testing::expect(

        arenaSession and arenaBindings.len == 1

        if not types::regionContains(source, region) {

            throw emitError(self, node, ErrorKind::RegionParent(region.name));

        }

    }

    match ty {

        case Type::Pointer { target, mutable, .. } =>

            return Type::Pointer { class: types::PointerClass::Region(region), target, mutable },

        case Type::Slice { item, mutable, .. } =>

            return Type::Slice { class: types::PointerClass::Region(region), item, mutable },

        else => throw emitError(self, node, ErrorKind::RefBinding),

            break;

        }

    }

    let selected = allocInstance

        else throw emitError(self, node, ErrorKind::InvalidSessionSource);

        or borrowPlace(self, address.target).root == nil

    {

        throw emitError(self, binding.value, ErrorKind::InvalidSessionSource);

    }

    let _ = setNodeCoercion(self, binding.value, Coercion::TraitObject {

        }

    }

    return false;

}

/// Analyze an address-of expression.

unsafe fn resolveAddressOf 'arena (self: &mut Resolver 'arena, node: *ast::Node, addr: ast::AddressOf, hint: Type) -> Type

    throws (ResolveError)

{

    if try isCellPayloadPlace(self, addr.target) {

        throw emitError(self, addr.target, ErrorKind::ImmutableBinding);

    }

        if not try canBorrowMutFrom(self, addr.target) {

            throw emitError(self, addr.target, ErrorKind::ImmutableBinding);

        }

    }

    if let case ast::NodeValue::Subscript { container, index } = addr.target.value {

        if let case ast::NodeValue::Range(range) = index.value {

            let containerTy = try infer(self, container);

            let subjectTy = autoDeref(containerTy);

            try checkSliceRangeIndices(self, range);

            let mut item: *Type = undefined;

            let mut capacity: ?u32 = nil;

            if let case Type::Slice { item: sliceItem, mutable: sliceMutable, .. } = subjectTy {

                    throw emitError(self, addr.target, ErrorKind::ImmutableBinding);

                }

                set item = sliceItem;

            } else {

                match subjectTy {

                        throw emitError(self, container, ErrorKind::ExpectedIndexable);

                    }

                }

            }

            let class = try addressClass(self, addr.target, hint);

            let alloc = allocType(self, sliceTy);

            setSliceRangeInfo(self, node, SliceRangeInfo {

                itemType: item,

                capacity,

            });

            setNodeType(self, addr.target, *alloc);

            return setNodeType(self, node, *alloc);

        }

                else => {}

            }

        }

    }

    if let case Type::Array(arrayInfo) = targetTy {

        match addr.target.value {

            case ast::NodeValue::ArrayLit(_),

                 ast::NodeValue::ArrayRepeatLit(_) =>

            {

                return setNodeType(self, node, *allocType(self, sliceTy));

            }

            else => {}

        }

    }

    let pointerTy = Type::Pointer {

    };

    return setNodeType(self, node, pointerTy);

}

/// Analyze a dereference expression.

    }

    if checker.regionalLen >= MAX_REGIONAL_LOANS {

        throw emitError(checker.resolver, node, ErrorKind::RegionalLoanOverflow);

    }

    let index = checker.regionalLen;

    set checker.regionalLen += 1;

    set env.regionalLoans |= (1 as u64) << (index as u64);

}

/// Return whether an initializer copies a shared reference with a named region.

    }

    if checker.localLen >= MAX_LINEAR_BINDINGS {

        throw emitError(checker.resolver, node, ErrorKind::Internal);

    }

    let sym = symbolFor(checker.resolver, node) else panic "reference without binding";

    if let case Type::Cell { .. } = ty {

        if let case ast::NodeValue::As(expr) = binding.value.value {

            if let source = typeFor(checker.resolver, expr.value) {

                if let case Type::Pointer { mutable: true, .. } = source {

                    set exclusive = true;

        }

    }

    for arg, i in call.args {

        let expected = *info.paramTypes[i];

        if argExclusive {

            try checkPatternLoan(checker, arg);

        }

        let place = borrowPlace(checker.resolver, arg);

        if not isUnsafePointerType(expected) {

        }

        else => panic "checkLinearLoopPass: expected loop",

    }

}

/// Check one expression or statement under an ownership-use context.

unsafe fn checkLinearNode 'arena 'checking (

    checker: &mut LinearChecker 'arena 'checking,

    env: &mut LinearEnv,

    node: *ast::Node,

        }

        case ast::NodeValue::RegionApply { value, .. } =>

            try checkLinearNode(checker, env, value, usage),

        case ast::NodeValue::Call(call) => try checkLinearCall(checker, env, node, call),

        case ast::NodeValue::AddressOf(addr) => {

                try checkPatternLoan(checker, addr.target);

            }

            try addRegionalLoan(checker, env, node, addr);

        }

        case ast::NodeValue::Deref(target) => {

            if let resultTy = typeFor(checker.resolver, node) {

                if isMoveOnly(resultTy) and usage == LinearUse::Consume {

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

    let programs = &[

        "fn run() { let value: u32 = 0; let pointer: *u32 = &value; }",

        "fn run() -> *u32 { let value: u32 = 0; return &value; }",

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

        "fn run() { let values = [1, 2]; let pointer: *i32 = &values[0]; }",

        "fn run() { let values = [1, 2]; let slice: *[i32] = &values[..]; }",

        "fn run(value: i32) { let slice: *[i32] = &[value]; }",

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

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

            try super::expectErrorKind(&result, resolver::ErrorKind::InvalidCellPayload);

        }

    }

}

/// Cell access cannot expose payload references or restore exclusive pointers.

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

    for program in [

        "fn f(p: *cell u32) { let r = &*p; }",

        "unsafe fn f(p: *cell u32) { let r = &*p; }",

}

/// Cell conversion consumes exclusive access, including call arguments.

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

    for program in [

        "fn f(p: *mut u32) { let c = p as *cell u32; set *p = 1; }",

        "unsafe fn f(p: *mut u32) { let c = p as *cell u32; set *p = 1; }",

        "fn read(p: &cell u32) {} fn f(p: &mut u32) { read(p as &cell u32); set *p = 1; }",

    ] {

        let mut testArena60 = super::testArena();

    fill(rawValues);

    assert sum(rawValues) == 30;

    assert sum(@sliceOf(&values[0] as *unsafe u32, 2)) == 30;

    let cell = Cell { value: 7 };

    assert inspect(rawCell) == 7;

    let object: *unsafe opaque Reader = rawCell;

    assert inspect(object) == 7;

    return 0;

}

    static DATA: [u8; 1024] = [0; 1024];

    let mut arena = alloc::new(&mut DATA[..]);

    let mut result: u32 = 0;

    use arena as graph in {

        let initial = try! graph.new(State 'graph::Pending);

        let body: &'graph Body 'graph = try! graph.new(Body 'graph { state });

        set *state = State 'graph::Ready(body);

        set result = snapshot(state);

    }

    alloc::reset(&mut arena);

fn unionCell 'r (allocation: &Session 'r) -> u32 {

    let value = try! allocation.new(19 as u32);

    let shared: &'r u32 = value;

    let initial: Link 'r = Link::Value(shared);

    let storage = try! allocation.new(initial);

    let snapshot = *pointer;

    set *pointer = Link::Empty;

    match *pointer {

        case Link::Empty => {

        },

}

fn local() -> u32 {

    let mut value: u32 = 0;

    {

        let alias = pointer;

        set *alias = 7;

        assert *pointer == 7;

        set *pointer = 8;

        assert *alias == 8;

@default fn main() -> u32 {

    assert local() == 7;

    assert @sizeOf(*cell u32) == @sizeOf(*mut u32);

    static VALUE: u32 = 0;

    let pointer: *mut u32 = &mut VALUE;

    let alias = cell;

    update(alias);

    assert *cell == 20;

    static CALLS: u32 = 0;

    set *select(cell, calls) += 1;

    assert *calls == 1;

    assert *cell == 21;

    set *cell = 20;

    static DATA: [u8; 256] = [0; 256];

    let mut arena = alloc::new(&mut DATA[..]);

    use arena as objects in {

        assert unionCell(&objects) == 19;

        let value = try! objects.new(22 as u32);

        let optional: ?&'objects cell u32 = shared;

        if let present = optional {

            assert *present == 22;

        } else {

            panic;

        let copy = entry;

        set *copy.index = 21;

        assert read(entry.index) == 21;

        set *shared = 22;

        let pair = try! objects.new(Pair { a: 1, b: 2 });

        let snapshot = *pairCell;

        set *pairCell = Pair { a: 3, b: 4 };

        assert snapshot.a == 1 and snapshot.b == 2;

        assert (*pairCell).b == 4;

        assert replace(*pairCell, pairCell) == 3;

@default unsafe fn main() -> u32 {

    static DATA: [u8; 256] = [0; 256];

    let mut arena = alloc::new(&mut DATA[..]);

    use arena as graph in {

        let initial = try! graph.new(Node 'graph::End);

        set *node = Node 'graph::Link(node);

        let snapshot = *node;

        match snapshot {

            case Node 'graph::Link(alias) => set *alias = Node 'graph::End,

            case Node 'graph::End => panic,

@default fn main() -> u32 {

    static DATA: [u8; 256] = [0; 256];

    let mut arena = alloc::new(&mut DATA[..]);

    use arena as graph in {

        let index = try! graph.new(0 as u32);

        let owned = try! graph.new(description);

        let shared: &'graph Symbol 'graph = owned;

        let byName = try! graph.fill(shared, 2);

        let byId = try! graph.fill(shared, 2);

        assert byName[0] == byId[1];

    let a: 'slices = &xs[..], b = &ys[..] in {

        assert followSlice(a, b) == 22;

    }

    let mut x: u32 = 0;

    let mut y: u32 = 0;

        followCell(firstCell, secondCell);

        assert *firstCell == 20;

        assert *secondCell == 22;

    }

    assert x == 20;