span: Span,

    /// Variant-specific payload for the node.

    value: NodeValue,

}

/// Allocate a new AST node from the arena with the given span and value.

export fn allocNode(arena: *mut NodeArena, span: Span, value: NodeValue) -> *mut Node {

    let p = try! alloc::alloc(&mut arena.arena, @sizeOf(Node), @alignOf(Node));

    let node = p as *mut Node;

    let nodeId = arena.nextId;

    return init(bits);

}

/// Set bit `n` in the bitset.

    if n >= bs.len {

        return;

    }

    let word = n / 32;

    let b = n % 32;

    try testing::expect(not super::contains(&bs, 31));

    try testing::expect(not super::contains(&bs, 32));

    try testing::expect(not super::contains(&bs, 127));

    // Set various bits including word boundaries.

    try testing::expect(super::contains(&bs, 0));

    try testing::expect(super::contains(&bs, 31));

    try testing::expect(super::contains(&bs, 32));

    try testing::expect(super::contains(&bs, 127));

/// Test clear operation.

@test fn testClear() throws (testing::TestError) {

    let mut bits: [u32; 2] = [0; 2];

    let mut bs = super::new(&mut bits[..]);

    try testing::expect(super::contains(&bs, 0));

    try testing::expect(super::contains(&bs, 31));

    try testing::expect(super::contains(&bs, 32));

    let mut bits: [u32; 2] = [0; 2];

    let mut bs = super::new(&mut bits[..]);

    try testing::expect(super::count(&bs) == 0);

    try testing::expect(super::count(&bs) == 1);

    try testing::expect(super::count(&bs) == 4);

    super::clear(&mut bs, 31);

    try testing::expect(super::count(&bs) == 3);

}

    let mut bits_a: [u32; 2] = [0; 2];

    let mut bits_b: [u32; 2] = [0; 2];

    let mut a = super::new(&mut bits_a[..]);

    let mut b = super::new(&mut bits_b[..]);

    super::union_(&mut a, &b);

    try testing::expect(super::contains(&a, 0));

    try testing::expect(super::contains(&a, 10));

    let mut bits_a: [u32; 2] = [0; 2];

    let mut bits_b: [u32; 2] = [0; 2];

    let mut a = super::new(&mut bits_a[..]);

    let mut b = super::new(&mut bits_b[..]);

    super::subtract(&mut a, &b);

    try testing::expect(super::contains(&a, 0));

    try testing::expect(not super::contains(&a, 10));

    let mut b = super::new(&mut bits_b[..]);

    // Both empty.

    try testing::expect(super::eq(&a, &b));

    try testing::expect(not super::eq(&a, &b));

    try testing::expect(super::eq(&a, &b));

    try testing::expect(super::eq(&a, &b));

    try testing::expect(not super::eq(&a, &b));

}

/// Test copy operation.

@test fn testCopy() throws (testing::TestError) {

    let mut bits_a: [u32; 2] = [0; 2];

    let mut bits_b: [u32; 2] = [0; 2];

    let mut a = super::new(&mut bits_a[..]);

    let mut b = super::new(&mut bits_b[..]);

    super::copy(&mut b, &a);

    try testing::expect(super::eq(&a, &b));

    try testing::expect(super::contains(&b, 0));

/// Test clearAll operation.

@test fn testClearAll() throws (testing::TestError) {

    let mut bits: [u32; 2] = [0; 2];

    let mut bs = super::new(&mut bits[..]);

    try testing::expect(super::count(&bs) == 4);

    super::clearAll(&mut bs);

    try testing::expect(super::count(&bs) == 0);

    try testing::expect(not super::contains(&bs, 0));

/// Test iteration over set bits.

@test fn testIter() throws (testing::TestError) {

    let mut bits: [u32; 2] = [0; 2];

    let mut bs = super::new(&mut bits[..]);

    let mut it = super::iter(&bs);

    let mut count: u32 = 0;

    let mut sum: u32 = 0;

@test fn testOutOfBounds() throws (testing::TestError) {

    let mut bits: [u32; 1] = [0; 1];

    let mut bs = super::new(&mut bits[..]);

    // Setting beyond length should be ignored.

    try testing::expect(not super::contains(&bs, 100));

    // Clearing beyond length should be safe.

    super::clear(&mut bs, 100);

            for k in 0..pred.n {

                if bitset::contains(&live.liveIn[b], pred.virtRegs[k]) {

                    current.virtRegs[current.n] = pred.virtRegs[k];

                    current.physRegs[current.n] = pred.physRegs[k];

                    current.n += 1;

                }

            }

        }

        // Mark all live-in values' registers as used.

        let mut liveInIter = bitset::iter(&live.liveIn[b]);

        while let ssaReg = bitset::iterNext(&mut liveInIter) {

            let reg = il::Reg { n: ssaReg };

            if not spill::isSpilled(spillInfo, reg) {

                if let phys = assignments[ssaReg] {

                    // Also track in current mapping for block-end state.

                    if rmapFind(&current, ssaReg) == nil {

                        rmapSet(&mut current, ssaReg, phys);

                    }

                } else {

/// Find first free register in pool, allocate it, return it.

fn findFreeInPool(usedRegs: *mut bitset::Bitset, current: *mut RegMap, ssaReg: u32, pool: *[gen::Reg]) -> ?gen::Reg {

    for i in 0..pool.len {

        let r = pool[i];

        if not bitset::contains(usedRegs, *r as u32) {

            rmapSet(current, ssaReg, r);

            return r;

        }

    }

    return nil;

}

/// Compute local defs and uses for a single block.

fn computeLocalDefsUses(block: *il::Block, defs: *mut bitset::Bitset, uses: *mut bitset::Bitset) {

    for p in block.params {

    }

    for i in 0..block.instrs.len {

        let instr = block.instrs[i];

        let mut ctx = DefsUses { defs, uses };

        il::forEachReg(instr, addUseCallback, &mut ctx as *mut opaque);

        if let dst = il::instrDst(instr) {

        }

    }

}

/// Callback for [`il::forEachReg`]: adds register to uses if not already defined.

fn addUseCallback(reg: il::Reg, ctx: *mut opaque) {

    let c = ctx as *mut DefsUses;

    if not bitset::contains(c.defs, reg.n) {

    }

}

/// Callback for [`il::forEachReg`]: updates max register number.

fn maxRegCallback(reg: il::Reg, ctx: *mut opaque) {

    // a callee-saved register for cross-call values.

    while bitset::count(&calleeClass) > numCalleeSaved {

        let mut it = bitset::iter(&calleeClass);

        if let reg = bitset::iterNext(&mut it) {

            bitset::clear(&mut calleeClass, reg);

        } else {

            panic "spill: count > 0 but no set bits found";

        }

    }

        }

        c.entries[j] = key;

    }

    let toSpill = c.n if excess > c.n else excess;

    for i in 0..toSpill {

        bitset::clear(source, c.entries[i].reg);

    }

}

/// Collect all values from a bitset into a candidates buffer with their costs.

    let mut c = Candidates { entries: undefined, n: 0 };

    while let reg = bitset::iterNext(&mut it) {

        assert c.n < MAX_CANDIDATES, "collectCandidates: too many live values";

        if reg < costs.len {

            c.entries[c.n] = CostEntry { reg, cost: costs[reg].defs + costs[reg].uses };

            c.n += 1;

    }

    // Mark crossing values that remain after spilling as callee-saved class.

    let mut it2 = bitset::iter(live);

    while let n = bitset::iterNext(&mut it2) {

        if not isCallDst(callDst, n) {

        }

    }

}

/// Callback for [`il::forEachReg`]: increments use count for register.

    ctx.costs[reg.n].uses = ctx.costs[reg.n].uses + ctx.weight;

}

/// Callback for [`il::forEachReg`]: adds register to live set.

fn addRegToSetCallback(reg: il::Reg, ctx: *mut opaque) {

}

/// Check if a register is spilled.

export fn isSpilled(info: *SpillInfo, reg: il::Reg) -> bool {

    if reg.n >= info.maxReg {

        emit(self, il::Instr::Zext { typ: extType, dst, val });

    }

    return il::Val::Reg(dst);

}

/// Lower an identifier that refers to a global symbol.

fn lowerGlobalSymbol(self: *mut FnLowerer, node: *ast::Node) -> il::Val throws (LowerError) {

    // First try to get a compile-time constant value.

    if let constVal = resolver::constValueEntry(self.low.resolver, node) {

        return try constValueToVal(self, constVal, node);

    }

    // Otherwise get the symbol.

    let sym = try symOf(self, node);

    match sym.data {

        }

        else => throw LowerError::UnexpectedNodeValue(node),

    }

}

/// Lower an assignment to a static variable.

fn lowerStaticAssign(self: *mut FnLowerer, target: *ast::Node, val: il::Val) throws (LowerError) {

    let sym = try symOf(self, target);

                return il::Val::Reg(dst);

            }

            return emitRead(self, src, 0, type);

        }

    }

}

/// Lower an expression AST node to an IL value.

/// This is the main expression dispatch, all expression nodes go through here.

    match node.value {

        case ast::NodeValue::Ident(_) =>

            return true,

        case ast::NodeValue::FieldAccess(_) =>

            return true,

        case ast::NodeValue::Subscript { .. } =>

            return true,

        case ast::NodeValue::Deref(_) =>

            return true,

        else =>

            if consume(p, scanner::TokenKind::Mut) {

                return try parseLet(p, true);

            }

            return try parseLet(p, false);

        }

        case scanner::TokenKind::Constant => {

            return try parseConst(p, attrs);

        }

        case scanner::TokenKind::Static => {

            return try parseStatic(p, attrs);

            else throw testing::TestError::Failed;

        let case ast::NodeValue::BinOp(bin) = node.right.value

            else throw testing::TestError::Failed;

        try testing::expect(bin.op == ast::BinaryOp::Add);

    }

}

/// Test parsing basic arithmetic binary operators (+, -, *, /, %).

@test fn testParseBinOpArithmetic() throws (testing::TestError) {

    let add = try! parseExprStr("a + b");

        }

        case ast::NodeValue::FieldAccess(access) => {

            let _ = try infer(self, access.parent);

            return try canBorrowMutFrom(self, access.parent);

        }

        case ast::NodeValue::Subscript { container, .. } => {

            let containerTy = try infer(self, container);

            // Subscript auto-derefs pointers, so check the actual indexed type.

            let subjectTy = autoDeref(containerTy);

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

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

        {

            return true;

        }

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

            let innerTy = try infer(self, inner);

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

                return mutable;

    let program = "fn f(s: *mut [i32]) { let x: *mut i32 = &mut s[0]; }";

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

    try expectNoErrors(&result);

}

/// Test that mutable bindings of immutable pointers cannot borrow mutably through the pointer.

@test fn testMutableBorrowFromMutableBindingOfPointer() throws (testing::TestError) {

    let mut a = testResolver();

    let program = "fn f() { let mut x: i32 = 1; let p: *i32 = &x; let y = &mut *p; }";

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

    Continue, While, For, In,

    Loop, Match, Case, Try, Catch,

    Throw, Throws, Panic, Assert,

    // Variable binding tokens.

    // Module-related tokens.

    Mod, Use, Super,

    // Type or function attributes.

    /// Corresponding token.

    tok: TokenKind,

}

/// Sorted keyword table for binary search.

    { name: "align", tok: TokenKind::Align },

    { name: "and", tok: TokenKind::And },

    { name: "as", tok: TokenKind::As },

    { name: "assert", tok: TokenKind::Assert },

    { name: "bool", tok: TokenKind::Bool },

    { name: "opaque", tok: TokenKind::Opaque },

    { name: "or", tok: TokenKind::Or },

    { name: "panic", tok: TokenKind::Panic },

    { name: "record", tok: TokenKind::Record },

    { name: "return", tok: TokenKind::Return },

    { name: "static", tok: TokenKind::Static },

    { name: "super", tok: TokenKind::Super },

    { name: "throw", tok: TokenKind::Throw },

    { name: "throws", tok: TokenKind::Throws },

    { name: "trait", tok: TokenKind::Trait },

        throw testing::TestError::Failed;

    }

    try testing::expect(vec::get(&v, 3) == nil);

    let new: i32 = 999;

    if let ptr = vec::get(&v, 1) {

        let value: i32 = *(ptr as *i32);

        try testing::expect(value == 999);

    } else {

        throw testing::TestError::Failed;

    }

}

@test fn testVecCapacity() throws (testing::TestError) {

    let mut arena: [u8; 16] align(4) = undefined;

    let mut v = vec::new(&mut arena[..], @sizeOf(i32), @alignOf(i32));

}

/// Set the element at the given index.

///

/// Returns false if index is out of bounds.

    if index >= vec.len {

        return false;

    }

    let off: u32 = index * vec.stride;

    let dst: *mut u8 = &mut vec.data[off];

//!

//! The critical case is when the loop executes zero iterations: the merge

//! block tries to `load` through the initial integer value (not a valid

//! pointer), crashing the program.

    *ptr = val;

}

/// Zero-iteration loop with &mut inside the body.

/// Without the fix, `val` starts as integer 42 in SSA, but the post-loop

/// merge tries to `load` through it as if it were a pointer.

fn testZeroIter(n: u32) -> u32 {

    let mut val: u32 = 42;

    let mut i: u32 = 0;

    while i < n {

        i += 1;

    }

    return val;

}

/// Multiple iterations: accumulate via &mut pointer in a loop.

fn testMultiIter() -> u32 {

    let mut acc: u32 = 0;

    let mut i: u32 = 0;

    while i < 5 {

        i += 1;

    }

    return acc;

}

fn testMultipleVars() -> u32 {

    let mut a: u32 = 0;

    let mut b: u32 = 100;

    let mut i: u32 = 0;

    while i < 3 {

        i += 1;

    }

    return a + b;

}

//! Regression test: address-of inside an if branch.

//!

//! When `&mut var` appears in only one branch of an if/else, the merge

//! block's phi merges the original integer value with a stack pointer.

    *ptr = val;

}

fn testIfBranch(cond: bool) -> u32 {

    let mut val: u32 = 42;

    if cond {

    }

    return val;

}

@default fn main() -> i32 {

//! returns: 84

//! Test mutable pointer references.

    *ptr = 42;

}

@default fn main() -> i32 {

    let mut a: i32 = 0;

    let p: *mut i32 = &mut a;

    let mut b: i32 = 0;

    return a + b;

}

    n: i32,

}

trait Ops {

    fn (*Ops) get() -> i32;

}

instance Ops for Acc {

    fn (a: *Acc) get() -> i32 {

        return a.n;

    }

        a.n = n;

    }

}

fn dispatch(o: *mut opaque Ops) -> i32 {

    return o.get();

}

data $"vtable::Acc::Ops" align 8 {

    fn $"Acc::get";

}

fn w32 $"Acc::get"(w64 %0) {

  @entry0

    sload w32 %1 %0 0;

    ret %1;

}

  @entry0

    store w32 %1 %0 0;

    ret;

}

syntax keyword radianceTodo TODO FIXME contained containedin=radianceComment

" Keywords

syntax keyword radianceKeyword mod fn return if else while true false and or not case align static

syntax keyword radianceKeyword export break continue use loop in for match nil undefined

syntax keyword radianceKeyword throws throw try catch panic assert super

syntax keyword radianceType i8 i16 i32 i64 u8 u16 u32 u64 f32 void bool bit opaque

" Double-quoted strings

syntax region radianceString start=/"/ skip=/\\"/ end=/"/ contains=radianceEscape