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

    }

}

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

    let mut it = bitset::iter(bs);

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

        if c.n == MAX_CANDIDATES {

            throw alloc::AllocError::OutOfMemory;

        }

    }

    return c;

}

/// Limit register pressure by marking low-cost values as spilled.

    live: &mut [u32],

    spilled: &mut [u32],

    costs: &[SpillCost],

    numRegs: u32

) throws (alloc::AllocError) {

/// Limit cross-call pressure by spilling values that exceed callee-saved capacity.

///

/// At a call site, every live value must survive the call in a callee-saved

/// register. If the count exceeds `numCalleeSaved`, spill the cheapest

/// crossing values.

    live: &mut [u32],

    spilled: &mut [u32],

    costs: &[SpillCost],

    calleeClass: &mut [u32],

    numCalleeSaved: u32,

    callDst: ?il::Reg

) throws (alloc::AllocError) {

    // Collect crossing candidates: live values excluding the call destination.

    let mut numCandidates: u32 = 0;

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

    while let n = bitset::iterNext(&mut it, live) {

        if not isCallDst(callDst, n) and n < costs.len {

            if numCandidates == MAX_CANDIDATES {

    /// Whether the instruction has variable argument groups left to scan.

    arguments: bool,

}

/// Start a source-register scan in instruction operand order.

    match *instr {

        case Instr::Reserve { size, .. } => addOperand(&mut cursor, size),

        case Instr::Load { src, .. } => addOperand(&mut cursor, Val::Reg(src)),

        case Instr::Sload { src, .. } => addOperand(&mut cursor, Val::Reg(src)),

        case Instr::Store { src, dst, .. } => {

    set cursor.arguments = false;

    return nil;

}

/// Scan an argument group from the cursor's current position.

    while cursor.argument < args.len {

        let value = args[cursor.argument];

        set cursor.argument += 1;

        if let case Val::Reg(reg) = value {

            return reg;

//! Tests for RIL source register iteration.

use std::testing;

/// Require exact source-register order and stable exhaustion.

unsafe fn check(instr: super::Instr, expected: &[u32]) throws (testing::TestError) {

    let mut cursor = super::registers(&instr);

    for value in expected {

        let reg = super::nextReg(&mut cursor, &instr) else panic;

    return nil;

}

/// Set the package context for lowering.

/// Called before lowering each package.

    set self.pkgName = pkgName;

    set self.currentMod = nil;

    set self.packageDataStart = self.data.len;

}

    set self.regCounter += 1;

    return reg;

}

/// Look up the resolved type of an AST node, or throw `MissingType`.

    let ty = resolver::typeFor(self.low.resolver, node)

        else throw LowerError::MissingType(node);

    return ty;

}

/// Look up the symbol for an AST node, or throw `MissingSymbol`.

    let sym = resolver::nodeData(self.low.resolver, node).sym

        else throw LowerError::MissingSymbol(node);

    return sym;

}

        }

    }

}

/// Replace all occurrences of `from` with `to` in an args slice.

    for i in 0..args.len {

        if args[i] == from {

            set args[i] = to;

        }

    }

    set *layout = value;

    return layout;

}

/// Get the exact arguments of an applied nominal descriptor.

    match *info {

        case NominalType::Application(applied) => return applied,

        case NominalType::Record(body) => return body.application,

        case NominalType::Union(body) => return body.application,

        else => return nil,

    return ResolveError::Failure;

}

/// Like [`emitError`], but for type mismatches specifically.

    return emitError(self, node, ErrorKind::TypeMismatch(mismatch));

}

/// Allocate a scope object with the given symbol capacity.

unsafe fn allocScope 'arena (self: &mut Resolver 'arena, owner: *ast::Node, capacity: u32) -> *unsafe mut Scope {

    }

    return Type::Never;

}

/// Require that loop control statements appear inside a loop.

    if self.loopDepth == 0 {

        throw emitError(self, node, ErrorKind::InvalidLoopControl);

    }

}

    set self.currentFnNode = nil;

    exitScope(self);

}

/// Extract the identifier text from a node.

    throws (ResolveError)

{

    let case ast::NodeValue::Ident(name) = node.value

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

    return name;

    let scope = self.scope;

    return try bindIdent(self, name, owner, data, attrs, scope);

}

/// Predicate that matches any symbol.

    return true;

}

/// Predicate that matches value or constant symbols.

    if let case SymbolData::Value { .. } = sym.data {

        return true;

    }

    if let case SymbolData::Constant { .. } = sym.data {

        return true;

    }

    return false;

}

/// Predicate that matches type symbols.

    if let case SymbolData::Type(_) = sym.data {

        return true;

    }

    return false;

}

/// Find a symbol by name in a specific scope, filtered by a predicate.

    for i in 0..scope.symbolsLen {

        let sym = scope.symbols[i];

        if sym.name == name and predicate(sym) {

            return sym;

        }

    }

    return nil;

}

/// Find a symbol by name, traversing scopes upwards, filtered by a predicate.

    let mut curr = scope;

    loop {

        if let sym = findInScope(curr, name, predicate) {

            return sym;

        }

    }

    return false;

}

/// Return whether a typed expression accesses a whole cell payload.

    if let case ast::NodeValue::Deref(target) = node.value {

        if let ty = typeFor(self, target) {

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

                return true;

            }

        }

    }

}

/// Return whether a parameter borrows its argument only for the call.

    if not isRefType(ty) {

        return false;

    }

    match ty {

        case Type::Cell { class, .. } => return class == types::PointerClass::Ref,

    try checkLinearNode(checker, &mut elseEnv, conditional.elseExpr, usage);

    try joinLinearBranches(checker, env, &thenEnv, &elseEnv, node);

}

/// Pointer patterns borrow their subject; value patterns consume it.

    if let ty = typeFor(self, subject) {

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

            return LinearUse::Borrow;

        }

    }