radiance · commit

Make slice append report allocation failures

a8669da64479a5fd13b47a125dd331f281b8de0597fafc9c43718f08e1bfcee0

Alexis Sellier committed 1 month ago 1 parent dee95968

compiler/radiance.rad +11 -10

    }
    set funcPath[desc.modPath.len - 1] = desc.fnName;
    let funcArg = synthScopeAccess(arena, &funcPath[..desc.modPath.len]);

    let a = alloc::arenaAllocator(&mut arena.arena);
    let args = ast::nodeSlice(arena, 3)
        .append(modArg, a)
        .append(nameArg, a)
        .append(funcArg, a);
    let args = ast::nodeSlice(arena, 3);
    try! args.append(modArg, a);
    try! args.append(nameArg, a);
    try! args.append(funcArg, a);

    return ast::synthNode(arena, ast::NodeValue::Call(ast::Call { callee, args }));
}

/// Inject a test runner into the entry package's root module.

unsafe fn synthTestMainFn(arena: &mut ast::NodeArena, tests: &[TestDesc]) -> *ast::Node {
    // Build array literal: `[testing::test(...), ...]`.
    let a = alloc::arenaAllocator(&mut arena.arena);
    let mut elements = ast::nodeSlice(arena, tests.len as u32);
    for i in 0..tests.len {
        elements.append(synthTestCall(arena, &tests[i]), a);
        try! elements.append(synthTestCall(arena, &tests[i]), a);
    }
    let arrayLit = ast::synthNode(arena, ast::NodeValue::ArrayLit(elements));

    // Build: `&[...]`.
    let testsRef = ast::synthNode(arena, ast::NodeValue::AddressOf(ast::AddressOf {
        target: arrayLit, mutable: false,
    }));

    // Build: `testing::runAllTests(&[...])`.
    let runFn = synthScopeAccess(arena, &["testing", "runAllTests"]);
    let callArgs = ast::nodeSlice(arena, 1).append(testsRef, a);
    let callArgs = try! ast::nodeSlice(arena, 1).append(testsRef, a);
    let callExpr = ast::synthNode(arena, ast::NodeValue::Call(ast::Call {
        callee: runFn, args: callArgs,
    }));

    // Build: `return testing::runAllTests(&[...]);`
    let retStmt = ast::synthNode(arena, ast::NodeValue::Return { value: callExpr });
    let bodyStmts = ast::nodeSlice(arena, 1).append(retStmt, a);
    let bodyStmts = try! ast::nodeSlice(arena, 1).append(retStmt, a);
    let fnBody = ast::synthNode(arena, ast::NodeValue::Block(ast::Block { statements: bodyStmts, isUnsafe: false }));

    // Build: `unsafe fn #testMain() -> i32`
    let fnName = ast::synthNode(arena, ast::NodeValue::Ident(strings::intern(&mut STRING_POOL, "#testMain")));
    let returnType = ast::synthNode(arena, ast::NodeValue::TypeSig(ast::TypeSig::Integer {

    };

    // Entry and function safety attributes.
    let attrNode = ast::synthNode(arena, ast::NodeValue::Attribute(ast::Attribute::Default));
    let unsafeAttr = ast::synthNode(arena, ast::NodeValue::Attribute(ast::Attribute::Unsafe));
    let attrList = ast::nodeSlice(arena, 2).append(attrNode, a).append(unsafeAttr, a);
    let attrList = try! ast::nodeSlice(arena, 2).append(attrNode, a);
    try! attrList.append(unsafeAttr, a);
    let fnAttrs = ast::Attributes { list: attrList };

    return ast::synthNode(arena, ast::NodeValue::FnDecl(ast::FnDecl {
        name: fnName, sig: fnSig, body: fnBody, attrs: fnAttrs,
    }));

        panic "injectIntoBlock: expected Block node";
    };
    let allocator = alloc::arenaAllocator(&mut arena.arena);
    let mut stmts = ast::nodeSlice(arena, block.statements.len + 1);
    for stmt in block.statements {
        stmts.append(stmt, allocator);
        try! stmts.append(stmt, allocator);
    }
    stmts.append(decl, allocator);
    try! stmts.append(decl, allocator);
    return ast::allocNode(arena, blockNode.span, ast::NodeValue::Block(
        ast::Block { statements: stmts, isUnsafe: block.isUnsafe }
    ));
}


lib/std/arch/rv64/asm/emit.rad +9 -5

    let idx = a.symbols.len;
    let offset: i32 = a.data.len as i32
        if a.section == super::Section::Data
        else a.text.len as i32 * rv64::INSTR_SIZE;

    a.symbols.append(super::Symbol {
    try! a.symbols.append(super::Symbol {
        name,
        section: a.section,
        offset,
        isExported: dict::get(&a.exportMap, name) <> nil,
    }, alloc::arenaAllocator(a.arena));
    dict::insert(&mut a.symbolMap, name, idx as i32);
}

/// Append one encoded instruction word to the text section.
export unsafe fn emitText(a: &mut super::Assembler, word: u32) throws (super::Error) {
    a.text.append(word, alloc::arenaAllocator(a.arena));
    try a.text.append(word, alloc::arenaAllocator(a.arena)) catch {
        throw super::Error::TextOverflow;
    };
}

/// Append `words` no-op instructions to the text section.
export unsafe fn emitTextPadding(a: &mut super::Assembler, words: u32) throws (super::Error) {
    for _ in 0..words {

    }
}

/// Append one byte to the data section.
export unsafe fn emitByte(a: &mut super::Assembler, byte: u8) throws (super::Error) {
    a.data.append(byte, alloc::arenaAllocator(a.arena));
    try a.data.append(byte, alloc::arenaAllocator(a.arena)) catch {
        throw super::Error::DataOverflow;
    };
}

/// Emit a little-endian integer with `bytes` bytes.
unsafe fn emitDataInt(a: &mut super::Assembler, bits: u64, bytes: u32) throws (super::Error) {
    for i in 0..bytes {

    }
}

/// Record a pending symbol fixup.
unsafe fn recordFixup(a: &mut super::Assembler, symbol: *[u8], info: super::FixupInfo) {
    a.fixups.append(super::Fixup { symbol, info }, alloc::arenaAllocator(a.arena));
    try! a.fixups.append(super::Fixup { symbol, info }, alloc::arenaAllocator(a.arena));
}

/// Record a text fixup that must be resolved after all program text is known.
unsafe fn recordExternalFixup(a: &mut super::Assembler, fixup: super::Fixup) {
    a.externalFixups.append(fixup, alloc::arenaAllocator(a.arena));
    try! a.externalFixups.append(fixup, alloc::arenaAllocator(a.arena));
}

/// Record a text-section symbol fixup and reserve its instruction words.
export unsafe fn recordTextFixup(a: &mut super::Assembler, symbol: *[u8], info: super::FixupInfo, words: u32) throws (super::Error) {
    recordFixup(a, symbol, info);

lib/std/arch/rv64/emit.rad +7 -6

    let pendingBranchesBuf = pendingBranches as *mut [PendingBranch];
    let pendingCallsBuf = pendingCalls as *mut [PendingCall];
    let pendingJumpsBuf = pendingJumps as *mut [PendingJump];
    let pendingAddrLoadsBuf = pendingAddrLoads as *mut [PendingAddrLoad];
    let funcsBuf = funcs as *mut [types::FuncAddr];

    return Emitter {
        allocator: alloc::arenaAllocator(arena),
        code: code as *mut [u32],
        codeLen: 0,
        pendingBranches: &mut pendingBranchesBuf[..0],

    recordFuncAt(e, name, codeLen);
}

/// Record a function's start position at `index` for printing.
export fn recordFuncAt(e: &mut Emitter, name: *[u8], index: u32) {
    e.funcs.append(types::FuncAddr { name, index }, e.allocator);
    try! e.funcs.append(types::FuncAddr { name, index }, e.allocator);
}

/// Record a local branch needing later patching.
/// Unconditional jumps use a single slot (J-type, +-1MB range).
/// Conditional branches use two slots (B-type has only +-4KB range,
/// so large functions may need the inverted-branch + JAL fallback).
export fn recordBranch(e: &mut Emitter, targetBlock: u32, kind: BranchKind) {
    e.pendingBranches.append(PendingBranch {
    try! e.pendingBranches.append(PendingBranch {
        index: e.codeLen,
        target: targetBlock,
        kind: kind,
    }, e.allocator);



/// Record a function call needing later patching.
/// Emits placeholder instructions that will be patched later.
/// Uses two slots to support long-distance calls.
export fn recordCall(e: &mut Emitter, target: *[u8]) {
    e.pendingCalls.append(PendingCall {
    try! e.pendingCalls.append(PendingCall {
        index: e.codeLen,
        target,
    }, e.allocator);

    emit(e, encode::nop()); // Placeholder for AUIPC.
    emit(e, encode::nop()); // Placeholder for JALR.
}

/// Record a jump emitted by assembly that needs whole-program patching.
export fn recordJumpAt(e: &mut Emitter, target: *[u8], rd: gen::Reg, index: u32) {
    e.pendingJumps.append(PendingJump {
    try! e.pendingJumps.append(PendingJump {
        index,
        target,
        rd,
    }, e.allocator);
}

    emit(e, encode::nop()); // Placeholder for ADDI.
}

/// Record a function address load already reserved by assembly.
export fn recordAddrLoadAt(e: &mut Emitter, target: *[u8], rd: gen::Reg, index: u32) {
    e.pendingAddrLoads.append(PendingAddrLoad {
    try! e.pendingAddrLoads.append(PendingAddrLoad {
        index,
        target,
        rd: rd,
        isData: false,
    }, e.allocator);
}

/// Record a data address load needing later patching.
/// Uses an absolute 32-bit load sequence matching the current data memory map.
export fn recordDataAddrLoad(e: &mut Emitter, target: *[u8], rd: gen::Reg) {
    e.pendingAddrLoads.append(PendingAddrLoad {
    try! e.pendingAddrLoads.append(PendingAddrLoad {
        index: e.codeLen,
        target,
        rd: rd,
        isData: true,
    }, e.allocator);

lib/std/lang/alloc.rad +5 -5

///
/// Bundles an allocation function with an opaque context pointer so that
/// any allocation strategy (arena, free-list, mmap, pool) can be used
/// through a uniform interface. The `func` field is called with the context
/// pointer, a byte size and an alignment, and must return a pointer to
/// the allocated memory or panic on failure.
/// the allocated memory or throw `AllocError` on failure.
export record Allocator: Copy {
    /// Allocation function. Returns a pointer to `size` bytes
    /// aligned to `alignment`, or panics on failure.
    func: unsafe fn(*unsafe mut opaque, u32, u32) -> *mut opaque,
    /// aligned to `alignment`, or throws `AllocError` on failure.
    func: unsafe fn(*unsafe mut opaque, u32, u32) -> *mut opaque throws (AllocError),
    /// Opaque context pointer passed to `func`.
    ctx: *unsafe mut opaque,
}

/// Create an allocator whose arena must outlive all uses of the allocator.

        ctx: (arena as *unsafe mut Arena) as *unsafe mut opaque,
    };
}

/// Arena allocation function conforming to the `Allocator` interface.
unsafe fn arenaAllocFn(ctx: *unsafe mut opaque, size: u32, alignment: u32) -> *mut opaque {
unsafe fn arenaAllocFn(ctx: *unsafe mut opaque, size: u32, alignment: u32) -> *mut opaque throws (AllocError) {
    let arena = ctx as *unsafe mut Arena;
    return try! alloc(arena, size, alignment);
    return try alloc(arena, size, alignment);
}

/// Allocate raw storage that remains valid until the arena is reset.
export unsafe fn allocRaw(arena: &mut Arena, size: u32, alignment: u32) -> *unsafe mut opaque throws (AllocError) {
    let owner = try alloc(arena, size, alignment);

lib/std/lang/alloc/tests.rad +21 -2

    static STORAGE: [u8; 256] = [0; 256];
    let mut arena = super::new(&mut STORAGE[..]);
    let a = super::arenaAllocator(&mut arena);

    // Allocate through the Allocator indirection.
    let p1 = a.func(a.ctx, 16, 4);
    let p1 = try! a.func(a.ctx, 16, 4);
    try testing::expect(super::used(&arena) == 16);

    let p2 = a.func(a.ctx, 8, 8);
    let p2 = try! a.func(a.ctx, 8, 8);
    try testing::expect(super::used(&arena) == 24);

    // Verify the pointers are distinct.
    try testing::expect(p1 as u64 <> p2 as u64);
}

/// Append reports arena exhaustion and preserves the slice and arena state.
@test unsafe fn testAllocatorAppendExhausted() throws (testing::TestError) {
    static storage: [u8; 4] = [0; 4];
    let mut arena = super::new(&mut storage[..]);
    let a = super::arenaAllocator(&mut arena);
    let mut items: *mut [u32] = &mut [];
    try! items.append(42, a);
    let mut caught = false;
    try items.append(99, a) catch error as super::AllocError {
        try testing::expect(error == super::AllocError::OutOfMemory);
        set caught = true;
    };
    try testing::expect(caught);
    try testing::expect(items.len == 1);
    try testing::expect(items.cap == 1);
    try testing::expect(items[0] == 42);
    try testing::expect(arena.offset == 4);
}

lib/std/lang/ast.rad +1 -1

    let fnBody: *Node = synthNode(arena, NodeValue::Block(Block { statements: bodyStmts, isUnsafe: false }));
    let fnDecl = synthNode(arena, NodeValue::FnDecl(FnDecl {
        name: fnName, sig: fnSig, body: fnBody, attrs: nil,
    }));
    let mut rootStmts: *mut [*Node] = &mut [];
    rootStmts.append(fnDecl, a);
    try! rootStmts.append(fnDecl, a);
    let modBody = synthNode(arena, NodeValue::Block(Block { statements: rootStmts, isUnsafe: false }));

    return SynthFnMod { modBody, fnBody };
}

lib/std/lang/lower.rad +70 -33

use std::lang::types;
use std::mem;
use std::lang::ast;
use std::lang::il;
use std::lang::module;
use std::lang::parser;
use std::lang::resolver;

// TODO: Search for all `_ as i32` to ensure that casts from u32 to i32 don't
// happen, since they are potentially truncating values.


        }
    }
    let tag = self.errTagCounter;

    set self.errTagCounter += 1;
    self.errTags.append(ErrTagEntry { ty: errType, tag }, self.allocator);
    try! self.errTags.append(ErrTagEntry { ty: errType, tag }, self.allocator);

    return tag;
}

/// Emit one function to the active output.
unsafe fn emitFunction(self: &mut Lowerer, func: *unsafe il::Fn, role: FnRole) {
    match self.output {
        case FnOutput::Accumulate(accumulated) => {
            let mut fns = accumulated;
            fns.append(func, self.allocator);
            try! fns.append(func, self.allocator);
            set self.output = FnOutput::Accumulate(fns);
        }
        case FnOutput::Stream(sink) => {
            sink.emitFn(sink.ctx, func, role);
        }

    return true;
}

/// Append a data value to the builder.
fn dataBuilderPush(b: &mut DataValueBuilder, value: il::DataValue) {
    b.values.append(value, b.allocator);
    try! b.values.append(value, b.allocator);

    if value.count > 0 and not dataIsZero(value.item) {
        set b.zeroInit = false;
    }
}


/// Register a function symbol with its qualified name.
/// Called when lowering function declarations, so cross-package calls can find
/// the function by name.
fn registerFnSym(self: &mut Lowerer, sym: *unsafe resolver::Symbol, qualName: *[u8]) {
    self.fnSyms.append(FnSymEntry { sym, qualName }, self.allocator);
    try! self.fnSyms.append(FnSymEntry { sym, qualName }, self.allocator);
}

/// Look up a function's qualified name by its symbol.
/// Returns `nil` if the symbol wasn't registered (e.g. callee's module is not yet lowered).
// TODO: This is kind of dubious as an optimization, if it depends on the order

        set values[i] = il::DataValue {
            item: il::DataItem::Fn(methodNames[i]),
            count: 1,
        };
    }
    self.data.append(il::Data {
    try! self.data.append(il::Data {
        name: vName,
        size: traitInfo.methods.len as u32 * resolver::PTR_SIZE,
        alignment: resolver::PTR_SIZE,
        readOnly: true,
        isZeroInit: false,

    let qualName = qualifyName(self, nil, sym.name);
    let mut b = dataBuilder(self.allocator);
    try lowerConstDataInto(self, value, data.ty, layout.size, qualName, &mut b);
    let result = dataBuilderFinish(b);

    self.data.append(il::Data {
    try! self.data.append(il::Data {
        name: qualName,
        size: layout.size,
        alignment: layout.alignment,
        readOnly,
        isZeroInit: not readOnly and result.zeroInit,

    values: *[il::DataValue],
    dataPrefix: *[u8]
) -> *[u8] throws (LowerError) {
    let dataCount = self.data.len;
    let name = try nextDeclDataName(self, dataPrefix, dataCount, "literal");
    self.data.append(il::Data {
    try! self.data.append(il::Data {
        name,
        size,
        alignment,
        readOnly,
        isZeroInit: not readOnly and dataValuesAreZeroInit(values),

    }
    if let name = found {
        set dataName = name;
    } else {
        set dataName = try nextDataName(self);
        self.low.data.append(il::Data {
        try! self.low.data.append(il::Data {
            name: dataName,
            size,
            alignment,
            readOnly,
            isZeroInit: not readOnly and result.zeroInit,

    let vars = try! alloc::allocRawSlice(self.low.fnArena, @sizeOf(?il::Val), @alignOf(?il::Val), varCount) as *unsafe mut [?il::Val];

    for i in 0..varCount {
        set vars[i] = nil;
    }
    self.blockData.append(BlockData {
    try! self.blockData.append(BlockData {
        label,
        params: &mut [],
        paramVars: &mut [],
        instrs: &mut [],
        locs: &mut [],

    labelBase: *[u8],
    param: il::Param
) -> BlockId throws (LowerError) {
    let block = try createBlock(self, labelBase);
    let blk = getBlockMut(self, block);
    blk.params.append(param, self.allocator);
    try! blk.params.append(param, self.allocator);

    return block;
}

/// Switch to building a different block.

            else => {},
        }
    }
    // Record source location alongside instruction when enabled.
    if self.low.options.debug {
        block.locs.append(self.srcLoc, self.allocator);
        try! block.locs.append(self.srcLoc, self.allocator);
    }
    block.instrs.append(instr, self.allocator);
    try! block.instrs.append(instr, self.allocator);
}

/// Emit an unconditional jump to `target`.
unsafe fn emitJmp(self: &mut FnLowerer, target: BlockId) throws (LowerError) {
    emit(self, il::Instr::Jmp { target: *target, args: &mut [] });

    for i in 0..preds.len {
        if preds[i] == *pred { // Avoid duplicate predecessor entries.
            return;
        }
    }
    preds.append(*pred, self.allocator);
    try! preds.append(*pred, self.allocator);
}

/// Finalize all blocks and return the block array.
unsafe fn finalizeBlocks(self: &mut FnLowerer) -> *unsafe [il::Block] throws (LowerError) {
    let blockCount = self.blockData.len;

    type: il::Type,
    mutable: bool,
    val: il::Val
) -> Var {
    let id = self.vars.len;
    self.vars.append(VarData { name, type, mutable, addressTaken: false }, self.allocator);
    try! self.vars.append(VarData { name, type, mutable, addressTaken: false }, self.allocator);

    let v = Var(id);
    if self.currentBlock <> nil {
        defVar(self, v, val);
    }


    // Create block parameter and add it to the block.
    let param = il::Param { value: reg, type };
    let blk = getBlockMut(self, block);
    let paramIdx = blk.paramVars.len;
    blk.params.append(param, self.allocator);
    blk.paramVars.append(*v, self.allocator); // Associate variable with parameter.
    try! blk.params.append(param, self.allocator);
    try! blk.paramVars.append(*v, self.allocator); // Associate variable with parameter.

    // Record that this variable's value in this block is now the parameter register.
    // This must happen before the predecessor loop to handle self-referential loops.
    set blk.vars[*v] = il::Val::Reg(reg);


        } else {
            set name = try paramName(&astParams[i].value);
        }
        let v = newVar(self, name, type, false, il::Val::Undef);

        self.params.append(FnParamBinding { var: v, reg }, self.allocator);
        try! self.params.append(FnParamBinding { var: v, reg }, self.allocator);
    }
    return params;
}

/// Resolve match subject.

                set blocks[i] = try createBlock(self, "case");
                for pat in pats {
                    let cv = resolver::constValueEntry(self.low.resolver, pat)
                        else throw LowerError::MissingConst(pat);

                    cases.append(il::SwitchCase {
                    try! cases.append(il::SwitchCase {
                        value: constToScalar(cv),
                        target: *blocks[i],
                        args: &mut []
                    }, self.allocator);
                }

    // if successful, or an optional of it, if using `try?`.
    let tryExprTy = try typeOf(self, node);
    // Check for trait method dispatch or standalone method call.
    let mut resVal: il::Val = undefined;
    let callNodeExtra = resolver::nodeData(self.low.resolver, t.expr).extra;
    if let case resolver::NodeExtra::TraitMethodCall {
    if let case resolver::NodeExtra::SliceAppend { elemType } = callNodeExtra {
        set resVal = try lowerSliceAppend(self, callExpr, elemType);
    } else if let case resolver::NodeExtra::TraitMethodCall {
        traitInfo, methodIndex
    } = callNodeExtra {
        set resVal = try lowerTraitMethodCall(self, t.expr, callExpr, traitInfo, methodIndex);
    } else if let case resolver::NodeExtra::MethodCall { method } = callNodeExtra {
        set resVal = try lowerMethodCall(self, t.expr, callExpr, method);


        if let typeNode = clause.typeNode {
            let errTy = try typeOf(self, typeNode);
            set errTypes[i] = errTy;

            cases.append(il::SwitchCase {
            try! cases.append(il::SwitchCase {
                value: getOrAssignErrorTag(self.low, errTy) as i64,
                target: *blocks[i],
                args: &mut []
            }, self.allocator);
        } else {

    // Now all predecessors of header are known, seal it.
    try sealBlock(self, header);
    try switchToAndSeal(self, done);
}

/// Lower `slice.append(val, allocator)`.
/// Lower `slice.append(val, allocator)` and return its result aggregate.
///
/// Emits inline grow-if-needed logic:
///
///     load len, cap from slice header
///     if len < cap: jmp @store
///     else:         jmp @grow
///
///     @grow:
///       newCap = max(cap * 2, 1)
///       call allocator.func(allocator.ctx, newCap * stride, alignment)
///       limit = U32_MAX / stride
///       trap if cap > (limit - 1) / 2
///       newCap = cap * 2 + 1
///       bytes = newCap * stride
///       call allocator.func(allocator.ctx, bytes, alignment)
///       if allocation failed: return error result
///       copy old data to new pointer
///       update slice ptr and cap
///       jmp @store
///
///     @store:
///       store element at ptr + len * stride
///       increment len
///       return success result
///
unsafe fn lowerSliceAppend(self: &mut FnLowerer, call: ast::Call, elemType: *resolver::Type) -> il::Val throws (LowerError) {
/// The slice header changes only after allocation succeeds.
unsafe fn lowerSliceAppend(
    self: &mut FnLowerer,
    call: ast::Call,
    elemType: *resolver::Type,
) -> il::Val throws (LowerError) {
    let case ast::NodeValue::FieldAccess(access) = call.callee.value
        else throw LowerError::MissingMetadata;
    let case resolver::Type::Fn(info) = try typeOf(self, call.callee)
        else throw LowerError::ExpectedFunction;

    let result = emitReserveLayout(self, resolver::getResultLayout(*info.returnType, info.throwList));

    // Get the address of the slice header.
    let sliceVal = try lowerExpr(self, access.parent);
    let sliceReg = emitValToReg(self, sliceVal);


    let lenVal = loadSliceLen(self, sliceReg);
    let capVal = loadSliceCap(self, sliceReg);

    // Branch: if length is smaller than capacity, go to @store else @grow.
    let storeBlock = try createBlock(self, "append.store");
    let doneBlock = try createBlock(self, "append.done");
    let growBlock = try createBlock(self, "append.grow");
    try emitBrCmp(self, il::CmpOp::Ult, il::Type::W32, lenVal, capVal, storeBlock, growBlock);
    try switchToAndSeal(self, growBlock);

    // -- @grow block ----------------------------------------------------------

    // `newCap = max(cap * 2, 1)`.
    // We are only here when at capacity, so we use `or` with `1` to ensure at least capacity `1`.
    // Each allocation size and slice length must fit in u32.
    let limit = parser::U32_MAX / stride;
    try emitTrapUnlessCmp(self, il::CmpOp::Ult, il::Type::W32, capVal, il::Val::Imm(((limit - 1) / 2 + 1) as i64));

    // Grow capacity to `cap * 2 + 1`.
    let doubledVal = emitTypedBinOp(self, il::BinOp::Shl, il::Type::W32, capVal, il::Val::Imm(1));
    let newCapVal = emitTypedBinOp(self, il::BinOp::Or, il::Type::W32, doubledVal, il::Val::Imm(1));

    // Call allocator: `a.func(a.ctx, newCap * stride, alignment)`.
    let allocFnReg = nextReg(self);


    let allocCtxReg = nextReg(self);
    emitLoadW64At(self, allocCtxReg, allocReg, 8);

    let byteSize = emitTypedBinOp(self, il::BinOp::Mul, il::Type::W32, newCapVal, il::Val::Imm(stride as i64));
    let args = try allocVals(self, 3);

    set args[0] = il::Val::Reg(allocCtxReg);
    set args[1] = byteSize;
    set args[2] = il::Val::Imm(alignment as i64);
    let args = try allocVals(self, 4);

    // The append result fits the allocation pointer and the shared error types.
    set args[0] = il::Val::Reg(result);
    set args[1] = il::Val::Reg(allocCtxReg);
    set args[2] = byteSize;
    set args[3] = il::Val::Imm(alignment as i64);

    let newPtrReg = nextReg(self);
    emit(self, il::Instr::Call {
        retTy: il::Type::W64,
        dst: newPtrReg,
        dst: nil,
        func: il::Val::Reg(allocFnReg),
        args,
    });

    let tag = resultTagReg(self, result);
    let copyBlock = try createBlock(self, "append.copy");
    try emitBr(self, tag, doneBlock, copyBlock);

    try switchToAndSeal(self, copyBlock);
    let newPtrReg = nextReg(self);
    emitLoadW64At(self, newPtrReg, result, RESULT_VAL_OFFSET);

    // Copy old data byte-by-byte.
    let oldPtrReg = loadSlicePtr(self, sliceReg);
    let copyBytes = emitTypedBinOp(self, il::BinOp::Mul, il::Type::W32, lenVal, il::Val::Imm(stride as i64));
    try emitByteCopyLoop(self, newPtrReg, oldPtrReg, copyBytes, "append");



    // Increment len.
    let newLen = emitTypedBinOp(self, il::BinOp::Add, il::Type::W32, lenVal, il::Val::Imm(1));
    emitStoreW32At(self, newLen, sliceReg, SLICE_LEN_OFFSET);

    return il::Val::Reg(sliceReg);
    // Return the append result.
    emitStoreW64At(self, il::Val::Imm(0), result, 0);
    try emitStore(self, result, RESULT_VAL_OFFSET, *info.returnType, il::Val::Reg(sliceReg));
    try emitJmp(self, doneBlock);

    try switchToAndSeal(self, doneBlock);
    return il::Val::Reg(result);
}

/// Lower `slice.delete(index)`.
///
/// Bounds-check the index, shift elements after it by one stride

lib/std/lang/parser.rad +22 -22

        return node(p, ast::NodeValue::ArrayRepeatLit(
            ast::ArrayRepeatLit { item: firstExpr, count }
        ));
    }
    // Regular array literal: `[a, b, ...]`.
    let mut items = ast::nodeSlice(p.arena, 64).append(firstExpr, p.allocator);
    let mut items = try! ast::nodeSlice(p.arena, 64).append(firstExpr, p.allocator);

    while consume(p, scanner::TokenKind::Comma) and not check(p, scanner::TokenKind::RBracket) {
        let elem = try parseNormalExpr(p);
        items.append(elem, p.allocator);
        try! items.append(elem, p.allocator);
    }
    try expect(p, scanner::TokenKind::RBracket, "expected `]` after array elements");

    return node(p, ast::NodeValue::ArrayLit(items));
}


    if kind == ast::Builtin::SliceOf {
        // Parse comma-separated expressions until closing paren.
        // Argument count validation is done in semantic analysis.
        while not check(p, scanner::TokenKind::RParen) {
            args.append(try parseExpr(p), p.allocator);
            try! args.append(try parseExpr(p), p.allocator);
            if not consume(p, scanner::TokenKind::Comma) {
                break;
            }
        }
    } else {
        args.append(try parseType(p), p.allocator);
        try! args.append(try parseType(p), p.allocator);
    }
    try expect(p, scanner::TokenKind::RParen, "expected `)` after builtin argument");

    return node(p, ast::NodeValue::BuiltinCall { kind, args });
}

/// Parse leading attributes and declaration modifiers.
unsafe fn parseAttributes(p: &mut Parser) -> ?ast::Attributes {
    let mut attrs = ast::nodeSlice(p.arena, 4);

    if let attr = tryParseAnnotation(p) {
        attrs.append(attr, p.allocator);
        try! attrs.append(attr, p.allocator);
    }
    if consume(p, scanner::TokenKind::Export) {
        attrs.append(nodeAttribute(p, ast::Attribute::Export), p.allocator);
        try! attrs.append(nodeAttribute(p, ast::Attribute::Export), p.allocator);
    }
    if consume(p, scanner::TokenKind::Unsafe) {
        attrs.append(nodeAttribute(p, ast::Attribute::Unsafe), p.allocator);
        try! attrs.append(nodeAttribute(p, ast::Attribute::Unsafe), p.allocator);
    }
    if attrs.len > 0 {
        return ast::Attributes { list: attrs };
    }
    return nil;

    throws (ParseError)
{
    let mut statements = ast::nodeSlice(p.arena, capacity);
    while not check(p, end) {
        let stmt = try parseStmt(p);
        statements.append(stmt, p.allocator);
        try! statements.append(stmt, p.allocator);

        if check(p, end) or check(p, scanner::TokenKind::Eof) {
            break;
        }
        if not consume(p, scanner::TokenKind::Semicolon) {

    return node(p, ast::NodeValue::Block(blk));
}

/// Create a block containing a single statement node.
unsafe fn mkBlockWith(p: &mut Parser, node: *ast::Node) -> ast::Block {
    let stmts = ast::nodeSlice(p.arena, 1).append(node, p.allocator);
    let stmts = try! ast::nodeSlice(p.arena, 1).append(node, p.allocator);
    return ast::Block { statements: stmts, isUnsafe: false };
}

/// Parse the branch that follows `else` in let-else style constructs.
///

        }
        let body = try parseBlock(p);
        let clause = node(p, ast::NodeValue::CatchClause(
            ast::CatchClause { binding, typeNode, body }
        ));
        catches.append(clause, p.allocator);
        try! catches.append(clause, p.allocator);
    }
    return node(p, ast::NodeValue::Try(
        ast::Try { expr, catches, shouldPanic, returnsOptional }
    ));
}

    let mut prongs = ast::nodeSlice(p.arena, 128);
    while not check(p, scanner::TokenKind::RBrace) and
          not check(p, scanner::TokenKind::Eof) // TODO: We shouldn't have to manually check for EOF.
    {
        let prongNode = try parseMatchProng(p);
        prongs.append(prongNode, p.allocator);
        try! prongs.append(prongNode, p.allocator);
        consume(p, scanner::TokenKind::Comma);
    }
    try expect(p, scanner::TokenKind::RBrace, "expected `}` after match prongs");

    return node(p, ast::NodeValue::Match(

    // Case prong: `case <pattern>, ... if <guard> => <body>`.
    if consume(p, scanner::TokenKind::Case) {
        let mut patterns = ast::nodeSlice(p.arena, 16);
        loop {
            let pattern = try parseMatchPattern(p);
            patterns.append(pattern, p.allocator);
            try! patterns.append(pattern, p.allocator);

            if not consume(p, scanner::TokenKind::Comma) {
                break;
            }
            // After a comma, check for tokens that start a new prong.

                set recordField = ast::NodeValue::RecordField {
                    field: nil, type, value: nil,
                };
            }
        }
        fields.append(node(p, recordField), p.allocator);
        try! fields.append(node(p, recordField), p.allocator);

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

    if not consume(p, scanner::TokenKind::Colon) {
        return derives;
    }
    loop {
        let t = try parseIdent(p, "expected trait name in derive list");
        derives.append(t, p.allocator);
        try! derives.append(t, p.allocator);

        if not consume(p, scanner::TokenKind::Plus) {
            break;
        }
    }

        if consume(p, scanner::TokenKind::DotDot) {
            set ignoreRest = true;
            break;
        }
        let field = try parseRecordLitField(p);
        fields.append(field, p.allocator);
        try! fields.append(field, p.allocator);

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

        let variant = node(p, ast::NodeValue::UnionDeclVariant(
            ast::UnionDeclVariant {
                name: variantName, index: variants.len as u32, value: explicitValue, type: payloadType,
            }
        ));
        variants.append(variant, p.allocator);
        try! variants.append(variant, p.allocator);

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

    try expect(p, scanner::TokenKind::LParen, "expected `(` after function name");
    let mut params = ast::nodeSlice(p.arena, 8);

    while not check(p, scanner::TokenKind::RParen) {
        let param = try parseFnParam(p);
        params.append(param, p.allocator);
        try! params.append(param, p.allocator);

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

            // Keep existing attributes unchanged.
        } else {
            let mut list = ast::nodeSlice(p.arena, 4);
            if let a = attrs {
                for i in 0..a.list.len {
                    list.append(a.list[i], p.allocator);
                    try! list.append(a.list[i], p.allocator);
                }
            }
            let attrNode = nodeAttribute(p, ast::Attribute::Extern);
            list.append(attrNode, p.allocator);
            try! list.append(attrNode, p.allocator);
            set fnAttrs = ast::Attributes { list };
        }
    } else {
        set body = try parseBlock(p);
    }

    let mut methods = ast::nodeSlice(p.arena, ast::MAX_TRAIT_METHODS);
    while not check(p, scanner::TokenKind::RBrace) and
          not check(p, scanner::TokenKind::Eof)
    {
        let method = try parseTraitMethodSig(p);
        methods.append(method, p.allocator);
        try! methods.append(method, p.allocator);
    }
    try expect(p, scanner::TokenKind::RBrace, "expected `}` after trait methods");

    return node(p, ast::NodeValue::TraitDecl { name, supertraits, methods, attrs });
}

    {
        let attrs = parseAttributes(p);
        try expect(p, scanner::TokenKind::Fn, "expected `fn`");
        let method = try parseMethodDecl(p, attrs);

        methods.append(method, p.allocator);
        try! methods.append(method, p.allocator);
    }
    try expect(p, scanner::TokenKind::RBrace, "expected `}` after instance methods");

    return node(p, ast::NodeValue::InstanceDecl { traitName, targetType, methods });
}

    try expect(p, open, listExpectMessage(open));
    let mut items = ast::nodeSlice(p.arena, 8);

    while not check(p, close) {
        let item = try parseItem(p);
        items.append(item, p.allocator);
        try! items.append(item, p.allocator);

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

lib/std/lang/resolver.rad +49 -32

        /// Method index in the v-table.
        methodIndex: u32,
    },
    /// Standalone method call metadata.
    MethodCall { method: *unsafe MethodEntry },
    /// Slice `.append(val, allocator)` method call.
    /// Slice `.append(value, allocator)` with the allocator's thrown errors.
    SliceAppend { elemType: *Type },
    /// Slice `.delete(index)` method call.
    SliceDelete { elemType: *Type },
}


    for paramNode in decl.sig.params {
        let paramTy = try infer(self, paramNode) catch e {
            exitFn(self);
            throw e;
        };
        paramTypes.append(allocType(self, paramTy), a);
        try! paramTypes.append(allocType(self, paramTy), a);
    }

    if decl.sig.throwList.len > MAX_FN_THROWS {
        exitFn(self);
        throw emitError(self, node, ErrorKind::FnThrowOverflow(CountMismatch {

    for throwNode in decl.sig.throwList {
        let throwTy = try infer(self, throwNode) catch e {
            exitFn(self);
            throw e;
        };
        throwList.append(allocType(self, throwTy), a);
        try! throwList.append(allocType(self, throwTy), a);
        try ensureStorableType(self, throwNode, throwTy);
    }
    exitFn(self);
    set fnType.paramTypes = &paramTypes[..];
    set fnType.throwList = &throwList[..];


        // Compute field offset by aligning to field's alignment.
        let fieldLayout = getTypeLayout(fieldType);
        set currentOffset = mem::alignUp(currentOffset, fieldLayout.alignment);

        result.append(RecordField { name: fieldName, fieldType, offset: currentOffset as i32 }, a);
        try! result.append(RecordField { name: fieldName, fieldType, offset: currentOffset as i32 }, a);

        // Advance offset past this field.
        set currentOffset += fieldLayout.size;

        // Track max alignment for record layout.

        // Copy inherited methods into this trait's method table.
        for inherited in superTrait.methods {
            if let _ = findTraitMethod(traitType, inherited.name) {
                throw emitError(self, superNode, ErrorKind::DuplicateBinding(inherited.name));
            }
            traitType.methods.append(TraitMethod {
            try! traitType.methods.append(TraitMethod {
                name: inherited.name,
                fnType: inherited.fnType,
                mutable: inherited.mutable,
                receiverClass: inherited.receiverClass,
                index: traitType.methods.len as u32,
            }, a);
        }
        traitType.supertraits.append(superTrait, a);
        try! traitType.supertraits.append(superTrait, a);
    }

    if traitType.methods.len + methods.len > ast::MAX_TRAIT_METHODS {
        throw emitError(self, node, ErrorKind::TraitMethodOverflow(CountMismatch {
            expected: ast::MAX_TRAIT_METHODS,

                actual: sig.params.len,
            }));
        }
        for paramNode in sig.params {
            let paramTy = try infer(self, paramNode);
            paramTypes.append(allocType(self, paramTy), a);
            try! paramTypes.append(allocType(self, paramTy), a);
        }
        if let ret = sig.returnType {
            set retType = allocType(self, try infer(self, ret));
        }
        // Resolve throws list.

                actual: sig.throwList.len,
            }));
        }
        for throwNode in sig.throwList {
            let throwTy = try infer(self, throwNode);
            throwList.append(allocType(self, throwTy), a);
            try! throwList.append(allocType(self, throwTy), a);
        }
        let fnType = FnType {
            paramTypes: &paramTypes[..],
            returnType: retType,
            throwList: &throwList[..],
            isUnsafe: ast::hasAttribute(attrMask, ast::Attribute::Unsafe),
        };
        traitType.methods.append(TraitMethod {
        try! traitType.methods.append(TraitMethod {
            name: methodName,
            fnType: allocFnType(self, fnType),
            mutable,
            receiverClass,
            index: traitType.methods.len as u32,


        // Build final function type: receiver plus trait's canonical types.
        let a = alloc::arenaAllocator(&mut self.arena);
        // TODO: Improve this pattern, maybe via something like `(&[]).append(..)`?
        let mut paramTypes: *mut [*Type] = &mut [];
        paramTypes.append(allocType(self, receiverPtrType), a);
        try! paramTypes.append(allocType(self, receiverPtrType), a);

        for ty in tm.fnType.paramTypes {
            paramTypes.append(ty, a);
            try! paramTypes.append(ty, a);
        }
        let fnType = FnType {
            paramTypes: &paramTypes[..],
            returnType: tm.fnType.returnType,
            throwList: tm.fnType.throwList,

    let receiverPtrType = Type::Pointer {
        class: receiverClass,
        target: allocType(self, concreteType),
        mutable: receiverMut,
    };
    paramTypes.append(allocType(self, receiverPtrType), a);
    try! paramTypes.append(allocType(self, receiverPtrType), a);

    for paramNode in sig.params {
        let case ast::NodeValue::FnParam(param) = paramNode.value
            else throw emitError(self, paramNode, ErrorKind::ExpectedIdentifier);
        let paramTy = try resolveValueType(self, param.type);
        paramTypes.append(allocType(self, paramTy), a);
        try! paramTypes.append(allocType(self, paramTy), a);
    }

    // Resolve return type.
    let mut returnType = Type::Void;
    if let retNode = sig.returnType {


    // Resolve throw list.
    let mut throwTypes: *mut [*Type] = &mut [];
    for throwNode in sig.throwList {
        let throwTy = try resolveValueType(self, throwNode);
        throwTypes.append(allocType(self, throwTy), a);
        try! throwTypes.append(allocType(self, throwTy), a);
    }

    let retTypePtr = allocType(self, returnType);
    let throwList = &throwTypes[..];


        let tag = variantTag(variantDecl, &mut iota);
        // Create a symbol for this variant.
        let data = SymbolData::Variant { type: variantType, decl: node, ordinal: i, index: tag };
        let variantSym = allocSymbol(self, data, variantName, variantNode, 0);

        variants.append(UnionVariant {
        try! variants.append(UnionVariant {
            name: variantName,
            valueType: variantType,
            symbol: variantSym,
        }, a);
    }


        if let case Type::Slice { item, mutable, .. } = subjectTy {
            let methodName = try nodeName(self, access.child);
            if methodName == "append" {
                return try resolveSliceAppend(
                    self, node, access.parent, parentTy, call.args, item, mutable
                    self, node, call, parentTy, item, mutable, ctx
                );
            }
            if methodName == "delete" {
                return try resolveSliceDelete(
                    self, node, access.parent, call.args, item, mutable

    {
        return false;
    }
    let case Type::Fn(callback) = func.fieldType else return false;
    let case Type::Pointer { target, .. } = ctx.fieldType else return false;
    if *target <> Type::Opaque or callback.paramTypes.len <> 3 or callback.throwList.len <> 0 {
    if *target <> Type::Opaque or callback.paramTypes.len <> 3 or callback.throwList.len == 0 {
        return false;
    }
    if not typesEqual(*callback.paramTypes[0], ctx.fieldType) or
       *callback.paramTypes[1] <> Type::U32 or *callback.paramTypes[2] <> Type::U32
    {

    let case Type::Pointer { class, target: result, mutable } = *callback.returnType
        else return false;
    return class == types::PointerClass::Owned and mutable and *result == Type::Opaque;
}

/// Resolve `slice.append(val, allocator)`.
/// Resolve `slice.append(value, allocator)` with its allocation error.
unsafe fn resolveSliceAppend(
    self: &mut Resolver,
    node: *ast::Node,
    parent: *ast::Node,
    call: ast::Call,
    parentType: Type,
    args: *[*ast::Node],
    elemType: *Type,
    mutable: bool
    mutable: bool,
    ctx: CallCtx,
) -> Type throws (ResolveError) {
    let case ast::NodeValue::FieldAccess(access) = call.callee.value
        else panic "resolveSliceAppend: expected method call";
    if not mutable {
        throw emitError(self, parent, ErrorKind::ImmutableBinding);
        throw emitError(self, access.parent, ErrorKind::ImmutableBinding);
    }
    if args.len <> 2 {
    let count: u32 = 2;
    let args = call.args;
    if args.len <> count {
        throw emitError(self, node, ErrorKind::FnArgCountMismatch(CountMismatch {
            expected: 2,
            actual: args.len as u32,
            expected: count,
            actual: args.len,
        }));
    }
    // First argument must be assignable to the element type.
    try checkAssignable(self, args[0], *elemType);
    let params = try! alloc::allocSlice(&mut self.arena, @sizeOf(*Type), @alignOf(*Type), count) as *mut [*Type];
    set params[0] = elemType;
    // The allocator stores its callback and context at fixed offsets.
    let allocatorTy = try infer(self, args[1]);
    if let case Type::Nominal(info) = allocatorTy {
        try ensureNominalResolved(self, info, args[1]);
    }
    try ensureTypeResolved(self, allocatorTy, args[1]);
    if not isSliceAllocator(allocatorTy) {
        throw emitError(self, args[1], ErrorKind::InvalidSliceAllocator);
    }
    let case Type::Nominal(NominalType::Record(rec)) = allocatorTy else panic;
    let case Type::Fn(callback) = rec.fields[0].fieldType else panic;
    set params[1] = allocType(self, allocatorTy);
    let info = allocFnType(self, FnType {
        paramTypes: params,
        returnType: allocType(self, parentType),
        throwList: callback.throwList,
        isUnsafe: false,
    });
    setNodeType(self, call.callee, Type::Fn(info));
    if ctx == CallCtx::Normal {
        throw emitError(self, node, ErrorKind::MissingTry);
    }
    set self.nodeData.entries[node.id].extra = NodeExtra::SliceAppend { elemType };

    // Return the parent's type so the caller can rebind:
    // Return the parent's type so the caller can rebind.
    return setNodeType(self, node, parentType);
}

/// Resolve `slice.delete(index)`.
unsafe fn resolveSliceDelete(

                }));
            }

            for paramNode in t.params {
                let paramTy = try resolveValueType(self, paramNode);
                paramTypes.append(allocType(self, paramTy), a);
                try! paramTypes.append(allocType(self, paramTy), a);
            }
            for tyNode in t.throwList {
                let throwTy = try resolveValueType(self, tyNode);
                try ensureStorableType(self, tyNode, throwTy);
                throwList.append(allocType(self, throwTy), a);
                try! throwList.append(allocType(self, throwTy), a);
            }
            let mut retType = allocType(self, Type::Void);
            if let ret = t.returnType {
                let resolvedRet = try resolveValueType(self, ret);
                try ensureStorableType(self, ret, resolvedRet);

export unsafe fn resolveExpr(
    self: &mut Resolver, expr: *ast::Node, arena: &mut ast::NodeArena
) -> Diagnostics throws (ResolveError) {
    let a = alloc::arenaAllocator(&mut arena.arena);
    let exprStmt = ast::synthNode(arena, ast::NodeValue::ExprStmt(expr));
    let bodyStmts = ast::nodeSlice(arena, 1).append(exprStmt, a);
    let bodyStmts = try! ast::nodeSlice(arena, 1).append(exprStmt, a);
    let module = ast::synthFnModule(arena, ANALYZE_EXPR_FN_NAME, bodyStmts);

    let case ast::NodeValue::Block(block) = module.modBody.value
        else panic "resolveExpr: expected block for module body";
    enterScope(self, module.modBody);

lib/std/lang/resolver/printer.rad +1 -1

        }
        case super::ErrorKind::ExpectedPointer => {
            io::print("expected pointer type");
        }
        case super::ErrorKind::InvalidSliceAllocator => {
            io::print("expected allocator with func callback and matching opaque ctx pointer");
            io::print("expected allocator with throwing func callback and matching opaque ctx pointer");
        }
        case super::ErrorKind::ExpectedRecord => {
            io::print("expected record type");
        }
        case super::ErrorKind::ExpectedIndexable => {

lib/std/lang/resolver/tests.rad +32 -8

}

/// Test `.append()` on immutable slice produces an error.
@test unsafe fn testResolveSliceAppendImmutable() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record A { func: fn(*mut opaque, u32, u32) -> *mut opaque, ctx: *mut opaque } fn f(s: *[i32], a: A) { s.append(1, a); }";
    let program = "union E: Copy { Exhausted } record A { func: fn(*mut opaque, u32, u32) -> *mut opaque throws (E), ctx: *mut opaque } fn f(s: *[i32], a: A) { try! s.append(1, a); }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::ImmutableBinding = err.kind
        else throw testing::TestError::Failed;
}

/// Test `.append()` with wrong argument count produces an error.
@test unsafe fn testResolveSliceAppendWrongArgCount() throws (testing::TestError) {
    // Too few arguments.
    {
        let mut a = testResolver();
        let program = "fn f(s: *mut [i32]) { s.append(1); }";
        let program = "fn f(s: *mut [i32]) { try! s.append(1); }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::FnArgCountMismatch(m) = err.kind
            else throw testing::TestError::Failed;
        try testing::expect(m.expected == 2);
        try testing::expect(m.actual == 1);
    }
    // Too many arguments.
    {
        let mut a = testResolver();
        let program = "record A { func: fn(*mut opaque, u32, u32) -> *mut opaque, ctx: *mut opaque } fn f(s: *mut [i32], a: A) { s.append(1, a, 0); }";
        let program = "union E: Copy { Exhausted } record A { func: fn(*mut opaque, u32, u32) -> *mut opaque throws (E), ctx: *mut opaque } fn f(s: *mut [i32], a: A) { try! s.append(1, a, 0); }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::FnArgCountMismatch(m) = err.kind
            else throw testing::TestError::Failed;
        try testing::expect(m.expected == 2);

}

/// Test `.append()` with correct arguments succeeds.
@test unsafe fn testResolveSliceAppendCorrect() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record A { func: fn(*mut opaque, u32, u32) -> *mut opaque, ctx: *mut opaque } fn f(s: *mut [i32], a: A) { s.append(1, a); }";
    let program = "union E: Copy { Exhausted } record A { func: fn(*mut opaque, u32, u32) -> *mut opaque throws (E), ctx: *mut opaque } fn f(s: *mut [i32], a: A) { try! s.append(1, a); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test `.append()` with wrong element type produces an error.
@test unsafe fn testResolveSliceAppendWrongElemType() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record A { func: fn(*mut opaque, u32, u32) -> *mut opaque, ctx: *mut opaque } fn f(s: *mut [i32], a: A) { s.append(true, a); }";
    let program = "union E: Copy { Exhausted } record A { func: fn(*mut opaque, u32, u32) -> *mut opaque throws (E), ctx: *mut opaque } fn f(s: *mut [i32], a: A) { try! s.append(true, a); }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

        "record A { ctx: *mut opaque, func: fn(*mut opaque, u32, u32) -> *mut opaque } fn run(s: *mut [u8], a: A) { s.append(1, a); }",
        "record A { func: u64, ctx: u64 } fn run(s: *mut [u8], a: A) { s.append(1, a); }",
        "record A { func: fn(*mut opaque, u64, u32) -> *mut opaque, ctx: *mut opaque } fn run(s: *mut [u8], a: A) { s.append(1, a); }",
        "record A { func: fn(*mut opaque, u32, u32) -> *opaque, ctx: *mut opaque } fn run(s: *mut [u8], a: A) { s.append(1, a); }",
        "record A { func: fn(*mut opaque, u32, u32) -> *mut opaque, ctx: u64 } fn run(s: *mut [u8], a: A) { s.append(1, a); }",
        "union E: Copy { Bad } record A { func: fn(*mut opaque, u32, u32) -> *mut opaque throws (E), ctx: *mut opaque } fn run(s: *mut [u8], a: A) { s.append(1, a); }",
        "record A { func: fn(*mut opaque, u32, u32) -> *mut opaque, ctx: *mut opaque } fn run(s: *mut [u8], a: A) { try! s.append(1, a); }",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::InvalidSliceAllocator);
    }
}

/// Slice allocators can use raw context pointers.
@test unsafe fn testSliceAppendRawContextAllowed() throws (testing::TestError) {
    try expectAnalyzeOk("record A: Copy { func: unsafe fn(*unsafe mut opaque, u32, u32) -> *mut opaque, ctx: *unsafe mut opaque } fn run(s: *mut [u8], a: A) { s.append(1, a); }");
    try expectAnalyzeOk("union E: Copy { Exhausted } record A: Copy { func: unsafe fn(*unsafe mut opaque, u32, u32) -> *mut opaque throws (E), ctx: *unsafe mut opaque } fn run(s: *mut [u8], a: A) { try! s.append(1, a); }");
}

/// A live pattern reference protects its payload from writes through copied pointers.
@test unsafe fn testPatternPayloadPointerAliasesRejected() throws (testing::TestError) {
    let programs = &[


/// Slice mutations must preserve storage held by a local reference.
@test unsafe fn testLocalReferenceSliceMutationRejected() throws (testing::TestError) {
    let programs = &[
        "fn run(s: *mut [u8]) { let p: &u8 = &s[0]; s.delete(0); }",
        "record A: Copy { func: unsafe fn(*unsafe mut opaque, u32, u32) -> *mut opaque, ctx: *unsafe mut opaque } fn run(s: *mut [u8], a: A) { let p: &u8 = &s[0]; s.append(1, a); }",
        "union E: Copy { Exhausted } record A: Copy { func: unsafe fn(*unsafe mut opaque, u32, u32) -> *mut opaque throws (E), ctx: *unsafe mut opaque } fn run(s: *mut [u8], a: A) { let p: &u8 = &s[0]; try! s.append(1, a); }",
    ];
    for program in programs {
        let mut a = testResolver();
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::BorrowConflict("s"));

@test unsafe fn testLocalReferenceDeclarationContext() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "let n: u32 = 1; let p: &u32 = &n;");
    try expectErrorKind(&result, super::ErrorKind::InvalidRefPosition);
}

/// Allocating append requires an explicit error handler.
@test unsafe fn testSliceAppendRequiresTry() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union E: Copy { Full } record A { func: fn(*mut opaque, u32, u32) -> *mut opaque throws (E), ctx: *mut opaque } fn run(s: *mut [u8], a: A) { s.append(1, a); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::MissingTry);
}

/// Append propagation requires every allocator error in the caller's throw list.
@test unsafe fn testSliceAppendIncompatibleError() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union E: Copy { Full } union F: Copy { Invalid } record A { func: fn(*mut opaque, u32, u32) -> *mut opaque throws (E, F), ctx: *mut opaque } fn run(s: *mut [u8], a: A) throws (E) { try s.append(1, a); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::TryIncompatibleError);
}

/// Typed catches must cover all errors from the allocator.
@test unsafe fn testSliceAppendIncompleteCatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union E: Copy { Full } union F: Copy { Invalid } record A { func: fn(*mut opaque, u32, u32) -> *mut opaque throws (E, F), ctx: *mut opaque } fn run(s: *mut [u8], a: A) { try s.append(1, a) catch e as E {}; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::TryCatchNonExhaustive);
}

seed/radiance.rv64 +0 -0

Binary file changed.

seed/radiance.rv64.git +1 -1

1		-	cbc895eb5c6c569c7648e51c5e4ff0579de8b925415ceb368100d07370b9fd7e
	1	+	dee95968ebbc34ae4674a5b576baf5f0c7b8f055b2fa45b36c2aca09c2cfe41c

test/tests/slice.append.errors.rad added +89 -0

1	+	//! returns: 0
2	+	//! Slice append preserves allocator error types and payloads.
3	+
4	+	/// Allocation denial with a diagnostic value.
5	+	union Denied: Copy {
6	+	/// Bytes requested by the caller.
7	+	Request(u32),
8	+	}
9	+
10	+	/// Allocation state failure with a large payload.
11	+	record Unavailable: Copy {
12	+	/// First diagnostic word.
13	+	first: u64,
14	+	/// Second diagnostic word.
15	+	second: u64,
16	+	/// Third diagnostic word.
17	+	third: u64,
18	+	}
19	+
20	+	/// Allocator with two independent error types.
21	+	record Allocator: Copy {
22	+	/// Allocation function.
23	+	func: unsafe fn(unsafe mut opaque, u32, u32) -> mut opaque throws (Denied, Unavailable),
24	+	/// Error selector and call count.
25	+	ctx: *unsafe mut opaque,
26	+	}
27	+
28	+	/// Select which error to report.
29	+	record State {
30	+	/// Select the large error payload.
31	+	unavailable: bool,
32	+	/// Number of allocation calls.
33	+	calls: u32,
34	+	}
35	+
36	+	/// Return an error with its payload.
37	+	unsafe fn reject(ctx: unsafe mut opaque, size: u32, alignment: u32) -> mut opaque throws (Denied, Unavailable) {
38	+	let state = ctx as *unsafe mut State;
39	+	set state.calls += 1;
40	+	if state.unavailable {
41	+	throw Unavailable { first: 11, second: 22, third: 33 };
42	+	}
43	+	throw Denied::Request(size);
44	+	}
45	+
46	+	/// Propagate each error from append.
47	+	fn append(items: &mut *mut [u32], a: Allocator) throws (Denied, Unavailable) {
48	+	try items.append(7, a);
49	+	}
50	+
51	+	@default unsafe fn main() -> i32 {
52	+	static state: State = State { unavailable: false, calls: 0 };
53	+	let a = Allocator { func: reject, ctx: &mut state as *unsafe mut opaque };
54	+	let mut items: *mut [u32] = &mut [];
55	+	let mut caught: u32 = 0;
56	+	try append(&mut items, a) catch e as Denied {
57	+	let case Denied::Request(size) = e else panic;
58	+	assert size == 4;
59	+	set caught = 1;
60	+	} catch e as Unavailable {
61	+	panic "main: unexpected error";
62	+	};
63	+	assert caught == 1;
64	+	assert items.len == 0;
65	+	assert items.cap == 0;
66	+	set state.unavailable = true;
67	+	try items.append(8, a) catch e as Denied {
68	+	panic "main: unexpected error";
69	+	} catch e as Unavailable {
70	+	assert e.first == 11;
71	+	assert e.second == 22;
72	+	assert e.third == 33;
73	+	set caught = 2;
74	+	};
75	+	assert caught == 2;
76	+	assert items.len == 0;
77	+	assert items.cap == 0;
78	+	let absent = try? items.append(9, a);
79	+	assert absent == nil;
80	+	assert state.calls == 3;
81	+	static storage: [u32; 1] = [0];
82	+	let mut reserved: *mut [u32] = &mut storage[..0];
83	+	let present = try? reserved.append(10, a);
84	+	assert present <> nil;
85	+	assert reserved.len == 1;
86	+	assert reserved[0] == 10;
87	+	assert state.calls == 3;
88	+	return 0;
89	+	}

test/tests/slice.append.failure.rad added +43 -0

1	+	//! returns: 0
2	+	//! Failed allocation leaves a slice unchanged.
3	+
4	+	/// Allocation failures.
5	+	union AllocError: Copy {
6	+	/// The allocator cannot provide storage.
7	+	OutOfMemory,
8	+	}
9	+
10	+	/// Allocation callback and context.
11	+	record Allocator: Copy {
12	+	/// Fallible allocation function.
13	+	func: unsafe fn(unsafe mut opaque, u32, u32) -> mut opaque throws (AllocError),
14	+	/// Callback state.
15	+	ctx: *unsafe mut opaque,
16	+	}
17	+
18	+	/// Reject every allocation request.
19	+	unsafe fn reject(ctx: unsafe mut opaque, size: u32, alignment: u32) -> mut opaque throws (AllocError) {
20	+	throw AllocError::OutOfMemory;
21	+	}
22	+
23	+	@default unsafe fn main() -> i32 {
24	+	static storage: [i32; 2] = [11, 22];
25	+	let a = Allocator { func: reject, ctx: &mut storage as *unsafe mut opaque };
26	+	let mut items: mut [i32] = (&mut storage[..1]) as mut [i32];
27	+	try! items.append(33, a);
28	+	assert items.len == 2;
29	+	assert items[1] == 33;
30	+	let ptr = &items[0] as *opaque;
31	+	let mut failed = false;
32	+	try items.append(44, a) catch error as AllocError {
33	+	assert error == AllocError::OutOfMemory;
34	+	set failed = true;
35	+	};
36	+	assert failed;
37	+	assert (&items[0] as *opaque) == ptr;
38	+	assert items.len == 2;
39	+	assert items.cap == 2;
40	+	assert items[0] == 11;
41	+	assert items[1] == 33;
42	+	return 0;
43	+	}

test/tests/slice.append.rad +12 -184

//! returns: 0
//! Test slice .append() method with inline allocator.
//! Allocating append returns the updated slice or the allocator's error.

/// Simple bump allocator for testing.
record Arena {
    data: *mut [u8],
    offset: u32,
/// Allocation failures.
union Error: Copy {
    /// Diagnostic payload from the allocator.
    Failed(u64),
}

fn newArena(data: *mut [u8]) -> Arena {
    return Arena { data, offset: 0 };
}

fn arenaAlloc(arena: &mut Arena, size: u32, al: u32) -> *mut opaque {
    let aligned = (arena.offset + al - 1) / al * al;
    let newOffset = aligned + size;

    assert newOffset <= arena.data.len as u32;

    let base: *mut u8 = &mut arena.data[aligned];
    set arena.offset = newOffset;

    return base as *mut opaque;
}

/// Allocator record matching the compiler's expected layout.
/// Allocation callback and context.
record Allocator: Copy {
    func: unsafe fn(*unsafe mut opaque, u32, u32) -> *mut opaque,
    /// Fallible allocation function.
    func: unsafe fn(*unsafe mut opaque, u32, u32) -> *mut opaque throws (Error),
    /// Allocation state.
    ctx: *unsafe mut opaque,
}

unsafe fn arenaAllocFn(ctx: *unsafe mut opaque, size: u32, al: u32) -> *mut opaque {
    let arena = ctx as *unsafe mut Arena;
    return arenaAlloc(&mut *arena, size, al);
}

unsafe fn arenaAllocator(arena: &mut Arena) -> Allocator {
    return Allocator {
        func: arenaAllocFn,
        ctx: (arena as *unsafe mut Arena) as *unsafe mut opaque,
    };
}

unsafe static BUF: [u8; 4096] = undefined;

@default unsafe fn main() -> i32 {
    static arena: Arena = undefined;
    set arena = newArena(&mut BUF[..]);
    let a = arenaAllocator(&mut arena);

    // Allocate initial capacity of 4.
    let ptr = arenaAlloc(&mut arena, @sizeOf(i32) * 4, @alignOf(i32));
    let mut nums = @sliceOf(ptr as *mut i32, 0, 4);

    // Append within capacity.
    nums.append(10, a);
    nums.append(20, a);
    nums.append(30, a);

    if nums.len <> 3 {
        return 1;
    }
    if nums.cap <> 4 {
        return 2;
    }
    if nums[0] <> 10 {
        return 3;
    }
    if nums[1] <> 20 {
        return 4;
    }
    if nums[2] <> 30 {
        return 5;
    }

    // Append to fill capacity.
    nums.append(40, a);

    if nums.len <> 4 {
        return 6;
    }
    if nums.cap <> 4 {
        return 7;
    }

    // Append past capacity -- triggers growth.
    nums.append(50, a);

    if nums.len <> 5 {
        return 8;
    }
    // Cap should have grown (cap * 2 | 1 = 4 * 2 | 1 = 9).
    if nums.cap <> 9 {
        return 9;
    }
    if nums[4] <> 50 {
        return 10;
    }

    // Verify old elements survived the copy.
    if nums[0] <> 10 {
        return 11;
    }
    if nums[3] <> 40 {
        return 12;
    }

    // Append from empty (cap == 0 triggers growth with cap = 1).
    let mut empty: *mut [i32] = &mut [];
    empty.append(99, a);

    if empty.len <> 1 {
        return 13;
    }
    if empty.cap <> 1 {
        return 14;
    }
    if empty[0] <> 99 {
        return 15;
    }

    // Sum all elements in nums.
    let mut sum: i32 = 0;
    for n in nums {
        set sum += n;
    }
    if sum <> 150 {
        return 16;
    }

    // Test append with u8 elements (stride = 1).
    let bytePtr = arenaAlloc(&mut arena, 2, 1);
    let mut bytes = @sliceOf(bytePtr as *mut u8, 0, 2);
    bytes.append(0xAB, a);
    bytes.append(0xCD, a);

    if bytes.len <> 2 {
        return 17;
    }
    if bytes[0] <> 0xAB {
        return 18;
    }
    if bytes[1] <> 0xCD {
        return 19;
    }

    // Trigger growth on u8 slice.
    bytes.append(0xEF, a);

    if bytes.len <> 3 {
        return 20;
    }
    if bytes.cap <> 5 {
        return 21;
    }
    if bytes[2] <> 0xEF {
        return 22;
    }
    // Verify old u8 elements survived.
    if bytes[0] <> 0xAB {
        return 23;
    }

    // Test that .append() returns the slice, allowing rebinding.
    let ptr2 = arenaAlloc(&mut arena, @sizeOf(i32) * 2, @alignOf(i32));
    let mut vals = @sliceOf(ptr2 as *mut i32, 0, 2);

    // Append within capacity, rebind via return value.
    set vals = vals.append(42, a);
    assert vals.len == 1;
    assert vals[0] == 42;

    set vals = vals.append(43, a);
    assert vals.len == 2;

    // Append past capacity -- triggers growth and returns updated slice.
    let oldPtr = &vals[0] as *opaque;
    set vals = vals.append(44, a);
    assert vals.len == 3;
    assert vals.cap == 5;

    // After growth, the data pointer should have changed.
    let newPtr = &vals[0] as *opaque;
    assert oldPtr <> newPtr;

    // Verify all elements survived.
    assert vals[0] == 42;
    assert vals[1] == 43;
    assert vals[2] == 44;

    return 0;
/// Append and propagate the allocator error.
fn append(items: *mut [i32], value: i32, a: Allocator) -> *mut [i32] throws (Error) {
    return try items.append(value, a);
}

test/tests/slice.append.ril +69 -794

data mut $BUF align 1 {
    undef * 4096;
}

data mut $main$nominal$arena align 8 {
    undef * 24;
}

fn w64 $newArena(w64 %0, w64 %1) {
  @entry0
    reserve %2 24 8;
    blit %2 %1 16;
    store w32 0 %2 16;
    blit %0 %2 24;
    ret %0;
}

fn w64 $arenaAlloc(w64 %0, w32 %1, w32 %2) {
  @entry0
    load w32 %3 %0 16;
    add w32 %4 %3 %2;
    sub w32 %5 %4 1;
    udiv w32 %6 %5 %2;
    mul w32 %7 %6 %2;
    add w32 %8 %7 %1;
    load w32 %9 %0 8;
    br.ult w32 %9 %8 @assert.fail1 @assert.ok2;
  @assert.fail1
    unreachable;
  @assert.ok2
    load w32 %10 %0 8;
    br.ult w32 %7 %10 @guard#pass3 @guard#trap4;
  @guard#pass3
    load w64 %11 %0 0;
    add w64 %12 %11 %7;
    store w32 %8 %0 16;
    ret %12;
  @guard#trap4
    ebreak;
    unreachable;
}

fn w64 $arenaAllocFn(w64 %0, w32 %1, w32 %2) {
  @entry0
    call w64 %3 $arenaAlloc(%0, %1, %2);
    ret %3;
}

fn w64 $arenaAllocator(w64 %0, w64 %1) {
fn w64 $append(w64 %0, w64 %1, w32 %2, w64 %3) {
  @entry0
    reserve %2 16 8;
    copy %3 $arenaAllocFn;
    store w64 %3 %2 0;
    store w64 %1 %2 8;
    blit %0 %2 16;
    ret %0;
}

fn w32 $main() {
  @entry0
    copy %0 $BUF;
    reserve %1 16 8;
    store w64 %0 %1 0;
    store w32 4096 %1 8;
    store w32 4096 %1 12;
    reserve %2 24 8;
    call w64 %3 $newArena(%2, %1);
    copy %4 $main$nominal$arena;
    blit %4 %3 24;
    copy %5 $main$nominal$arena;
    reserve %6 16 8;
    call w64 %7 $arenaAllocator(%6, %5);
    copy %8 $main$nominal$arena;
    mul w32 %9 4 4;
    call w64 %10 $arenaAlloc(%8, %9, 4);
    reserve %11 16 8;
    store w64 %10 %11 0;
    store w32 0 %11 8;
    store w32 4 %11 12;
    load w32 %12 %11 8;
    load w32 %13 %11 12;
    br.ult w32 %12 %13 @append.store1 @append.grow2;
    reserve %4 24 8;
    load w32 %5 %1 8;
    load w32 %6 %1 12;
    br.ult w32 %5 %6 @append.store1 @append.grow3;
  @append.store1
    load w64 %27 %11 0;
    mul w64 %28 %12 4;
    add w64 %29 %27 %28;
    store w32 10 %29 0;
    add w32 %30 %12 1;
    store w32 %30 %11 8;
    load w32 %35 %11 8;
    load w32 %36 %11 12;
    br.ult w32 %35 %36 @append.store6 @append.grow7;
  @append.grow2
    shl w32 %14 %13 1;
    or w32 %15 %14 1;
    load w64 %16 %7 0;
    load w64 %17 %7 8;
    mul w32 %18 %15 4;
    call w64 %19 %16(%17, %18, 4);
    load w64 %20 %11 0;
    mul w32 %21 %12 4;
    jmp @append3(0);
  @append3(w32 %22)
    br.ult w32 %22 %21 @append4 @append5;
  @append4
    add w64 %23 %20 %22;
    load w8 %24 %23 0;
    add w64 %25 %19 %22;
    store w8 %24 %25 0;
    add w32 %26 %22 1;
    jmp @append3(%26);
  @append5
    store w64 %19 %11 0;
    store w32 %15 %11 12;
    jmp @append.store1;
  @append.store6
    load w64 %50 %11 0;
    mul w64 %51 %35 4;
    add w64 %52 %50 %51;
    store w32 20 %52 0;
    add w32 %53 %35 1;
    store w32 %53 %11 8;
    load w32 %58 %11 8;
    load w32 %59 %11 12;
    br.ult w32 %58 %59 @append.store11 @append.grow12;
  @append.grow7
    shl w32 %37 %36 1;
    or w32 %38 %37 1;
    load w64 %39 %7 0;
    load w64 %40 %7 8;
    mul w32 %41 %38 4;
    call w64 %42 %39(%40, %41, 4);
    load w64 %43 %11 0;
    mul w32 %44 %35 4;
    jmp @append8(0);
  @append8(w32 %45)
    br.ult w32 %45 %44 @append9 @append10;
    load w64 %21 %1 0;
    mul w64 %22 %5 4;
    add w64 %23 %21 %22;
    store w32 %2 %23 0;
    add w32 %24 %5 1;
    store w32 %24 %1 8;
    store w64 0 %4 0;
    add w64 %25 %4 8;
    blit %25 %1 16;
    jmp @append.done2;
  @append.done2
    load w64 %26 %4 0;
    reserve %27 16 8;
    br.ne w32 %26 0 @err11 @ok10;
  @append.grow3
    br.ult w32 %6 536870912 @guard#pass4 @guard#trap5;
  @guard#pass4
    shl w32 %7 %6 1;
    or w32 %8 %7 1;
    load w64 %9 %3 0;
    load w64 %10 %3 8;
    mul w32 %11 %8 4;
    call w64 %9(%4, %10, %11, 4);
    load w64 %12 %4 0;
    br.ne w32 %12 0 @append.done2 @append.copy6;
  @guard#trap5
    ebreak;
    unreachable;
  @append.copy6
    load w64 %13 %4 8;
    load w64 %14 %1 0;
    mul w32 %15 %5 4;
    jmp @append7(0);
  @append7(w32 %16)
    br.ult w32 %16 %15 @append8 @append9;
  @append8
    add w64 %17 %14 %16;
    load w8 %18 %17 0;
    add w64 %19 %13 %16;
    store w8 %18 %19 0;
    add w32 %20 %16 1;
    jmp @append7(%20);
  @append9
    add w64 %46 %43 %45;
    load w8 %47 %46 0;
    add w64 %48 %42 %45;
    store w8 %47 %48 0;
    add w32 %49 %45 1;
    jmp @append8(%49);
  @append10
    store w64 %42 %11 0;
    store w32 %38 %11 12;
    jmp @append.store6;
  @append.store11
    load w64 %73 %11 0;
    mul w64 %74 %58 4;
    add w64 %75 %73 %74;
    store w32 30 %75 0;
    add w32 %76 %58 1;
    store w32 %76 %11 8;
    load w32 %79 %11 8;
    br.ne w32 %79 3 @then16 @merge17;
  @append.grow12
    shl w32 %60 %59 1;
    or w32 %61 %60 1;
    load w64 %62 %7 0;
    load w64 %63 %7 8;
    mul w32 %64 %61 4;
    call w64 %65 %62(%63, %64, 4);
    load w64 %66 %11 0;
    mul w32 %67 %58 4;
    jmp @append13(0);
  @append13(w32 %68)
    br.ult w32 %68 %67 @append14 @append15;
  @append14
    add w64 %69 %66 %68;
    load w8 %70 %69 0;
    add w64 %71 %65 %68;
    store w8 %70 %71 0;
    add w32 %72 %68 1;
    jmp @append13(%72);
  @append15
    store w64 %65 %11 0;
    store w32 %61 %11 12;
    jmp @append.store11;
  @then16
    ret 1;
  @merge17
    load w32 %80 %11 12;
    br.ne w32 %80 4 @then18 @merge19;
  @then18
    ret 2;
  @merge19
    load w32 %81 %11 8;
    br.ult w32 0 %81 @guard#pass22 @guard#trap23;
  @then20
    ret 3;
  @merge21
    load w32 %84 %11 8;
    br.ult w32 1 %84 @guard#pass26 @guard#trap27;
  @guard#pass22
    load w64 %82 %11 0;
    sload w32 %83 %82 0;
    br.ne w32 %83 10 @then20 @merge21;
  @guard#trap23
    ebreak;
    unreachable;
  @then24
    ret 4;
  @merge25
    load w32 %89 %11 8;
    br.ult w32 2 %89 @guard#pass30 @guard#trap31;
  @guard#pass26
    load w64 %85 %11 0;
    mul w64 %86 1 4;
    add w64 %87 %85 %86;
    sload w32 %88 %87 0;
    br.ne w32 %88 20 @then24 @merge25;
  @guard#trap27
    ebreak;
    unreachable;
  @then28
    ret 5;
  @merge29
    load w32 %96 %11 8;
    load w32 %97 %11 12;
    br.ult w32 %96 %97 @append.store32 @append.grow33;
  @guard#pass30
    load w64 %90 %11 0;
    mul w64 %91 2 4;
    add w64 %92 %90 %91;
    sload w32 %93 %92 0;
    br.ne w32 %93 30 @then28 @merge29;
  @guard#trap31
    ebreak;
    unreachable;
  @append.store32
    load w64 %111 %11 0;
    mul w64 %112 %96 4;
    add w64 %113 %111 %112;
    store w32 40 %113 0;
    add w32 %114 %96 1;
    store w32 %114 %11 8;
    load w32 %117 %11 8;
    br.ne w32 %117 4 @then37 @merge38;
  @append.grow33
    shl w32 %98 %97 1;
    or w32 %99 %98 1;
    load w64 %100 %7 0;
    load w64 %101 %7 8;
    mul w32 %102 %99 4;
    call w64 %103 %100(%101, %102, 4);
    load w64 %104 %11 0;
    mul w32 %105 %96 4;
    jmp @append34(0);
  @append34(w32 %106)
    br.ult w32 %106 %105 @append35 @append36;
  @append35
    add w64 %107 %104 %106;
    load w8 %108 %107 0;
    add w64 %109 %103 %106;
    store w8 %108 %109 0;
    add w32 %110 %106 1;
    jmp @append34(%110);
  @append36
    store w64 %103 %11 0;
    store w32 %99 %11 12;
    jmp @append.store32;
  @then37
    ret 6;
  @merge38
    load w32 %118 %11 12;
    br.ne w32 %118 4 @then39 @merge40;
  @then39
    ret 7;
  @merge40
    load w32 %121 %11 8;
    load w32 %122 %11 12;
    br.ult w32 %121 %122 @append.store41 @append.grow42;
  @append.store41
    load w64 %136 %11 0;
    mul w64 %137 %121 4;
    add w64 %138 %136 %137;
    store w32 50 %138 0;
    add w32 %139 %121 1;
    store w32 %139 %11 8;
    load w32 %142 %11 8;
    br.ne w32 %142 5 @then46 @merge47;
  @append.grow42
    shl w32 %123 %122 1;
    or w32 %124 %123 1;
    load w64 %125 %7 0;
    load w64 %126 %7 8;
    mul w32 %127 %124 4;
    call w64 %128 %125(%126, %127, 4);
    load w64 %129 %11 0;
    mul w32 %130 %121 4;
    jmp @append43(0);
  @append43(w32 %131)
    br.ult w32 %131 %130 @append44 @append45;
  @append44
    add w64 %132 %129 %131;
    load w8 %133 %132 0;
    add w64 %134 %128 %131;
    store w8 %133 %134 0;
    add w32 %135 %131 1;
    jmp @append43(%135);
  @append45
    store w64 %128 %11 0;
    store w32 %124 %11 12;
    jmp @append.store41;
  @then46
    ret 8;
  @merge47
    load w32 %143 %11 12;
    br.ne w32 %143 9 @then48 @merge49;
  @then48
    ret 9;
  @merge49
    load w32 %144 %11 8;
    br.ult w32 4 %144 @guard#pass52 @guard#trap53;
  @then50
    ret 10;
  @merge51
    load w32 %149 %11 8;
    br.ult w32 0 %149 @guard#pass56 @guard#trap57;
  @guard#pass52
    load w64 %145 %11 0;
    mul w64 %146 4 4;
    add w64 %147 %145 %146;
    sload w32 %148 %147 0;
    br.ne w32 %148 50 @then50 @merge51;
  @guard#trap53
    ebreak;
    unreachable;
  @then54
    ret 11;
  @merge55
    load w32 %152 %11 8;
    br.ult w32 3 %152 @guard#pass60 @guard#trap61;
  @guard#pass56
    load w64 %150 %11 0;
    sload w32 %151 %150 0;
    br.ne w32 %151 10 @then54 @merge55;
  @guard#trap57
    ebreak;
    unreachable;
  @then58
    ret 12;
  @merge59
    reserve %157 16 8;
    store w64 0 %157 0;
    store w32 0 %157 8;
    store w32 0 %157 12;
    load w32 %160 %157 8;
    load w32 %161 %157 12;
    br.ult w32 %160 %161 @append.store62 @append.grow63;
  @guard#pass60
    load w64 %153 %11 0;
    mul w64 %154 3 4;
    add w64 %155 %153 %154;
    sload w32 %156 %155 0;
    br.ne w32 %156 40 @then58 @merge59;
  @guard#trap61
    ebreak;
    unreachable;
  @append.store62
    load w64 %175 %157 0;
    mul w64 %176 %160 4;
    add w64 %177 %175 %176;
    store w32 99 %177 0;
    add w32 %178 %160 1;
    store w32 %178 %157 8;
    load w32 %181 %157 8;
    br.ne w32 %181 1 @then67 @merge68;
  @append.grow63
    shl w32 %162 %161 1;
    or w32 %163 %162 1;
    load w64 %164 %7 0;
    load w64 %165 %7 8;
    mul w32 %166 %163 4;
    call w64 %167 %164(%165, %166, 4);
    load w64 %168 %157 0;
    mul w32 %169 %160 4;
    jmp @append64(0);
  @append64(w32 %170)
    br.ult w32 %170 %169 @append65 @append66;
  @append65
    add w64 %171 %168 %170;
    load w8 %172 %171 0;
    add w64 %173 %167 %170;
    store w8 %172 %173 0;
    add w32 %174 %170 1;
    jmp @append64(%174);
  @append66
    store w64 %167 %157 0;
    store w32 %163 %157 12;
    jmp @append.store62;
  @then67
    ret 13;
  @merge68
    load w32 %182 %157 12;
    br.ne w32 %182 1 @then69 @merge70;
  @then69
    ret 14;
  @merge70
    load w32 %183 %157 8;
    br.ult w32 0 %183 @guard#pass73 @guard#trap74;
  @then71
    ret 15;
  @merge72
    load w32 %188 %11 8;
    load w64 %189 %11 0;
    jmp @loop75(0, 0);
  @guard#pass73
    load w64 %184 %157 0;
    sload w32 %185 %184 0;
    br.ne w32 %185 99 @then71 @merge72;
  @guard#trap74
    ebreak;
    unreachable;
  @loop75(w32 %190, w32 %194)
    br.slt w32 %190 %188 @body76 @merge77;
  @body76
    mul w64 %191 %190 4;
    add w64 %192 %189 %191;
    sload w32 %193 %192 0;
    add w32 %195 %194 %193;
    add w32 %196 %190 1;
    jmp @loop75(%196, %195);
  @merge77
    br.ne w32 %194 150 @then78 @merge79;
  @then78
    ret 16;
  @merge79
    copy %197 $main$nominal$arena;
    call w64 %198 $arenaAlloc(%197, 2, 1);
    reserve %199 16 8;
    store w64 %198 %199 0;
    store w32 0 %199 8;
    store w32 2 %199 12;
    load w32 %203 %199 8;
    load w32 %204 %199 12;
    br.ult w32 %203 %204 @append.store80 @append.grow81;
  @append.store80
    load w64 %218 %199 0;
    add w64 %219 %218 %203;
    store w8 171 %219 0;
    add w32 %220 %203 1;
    store w32 %220 %199 8;
    load w32 %225 %199 8;
    load w32 %226 %199 12;
    br.ult w32 %225 %226 @append.store85 @append.grow86;
  @append.grow81
    shl w32 %205 %204 1;
    or w32 %206 %205 1;
    load w64 %207 %7 0;
    load w64 %208 %7 8;
    mul w32 %209 %206 1;
    call w64 %210 %207(%208, %209, 1);
    load w64 %211 %199 0;
    mul w32 %212 %203 1;
    jmp @append82(0);
  @append82(w32 %213)
    br.ult w32 %213 %212 @append83 @append84;
  @append83
    add w64 %214 %211 %213;
    load w8 %215 %214 0;
    add w64 %216 %210 %213;
    store w8 %215 %216 0;
    add w32 %217 %213 1;
    jmp @append82(%217);
  @append84
    store w64 %210 %199 0;
    store w32 %206 %199 12;
    jmp @append.store80;
  @append.store85
    load w64 %240 %199 0;
    add w64 %241 %240 %225;
    store w8 205 %241 0;
    add w32 %242 %225 1;
    store w32 %242 %199 8;
    load w32 %245 %199 8;
    br.ne w32 %245 2 @then90 @merge91;
  @append.grow86
    shl w32 %227 %226 1;
    or w32 %228 %227 1;
    load w64 %229 %7 0;
    load w64 %230 %7 8;
    mul w32 %231 %228 1;
    call w64 %232 %229(%230, %231, 1);
    load w64 %233 %199 0;
    mul w32 %234 %225 1;
    jmp @append87(0);
  @append87(w32 %235)
    br.ult w32 %235 %234 @append88 @append89;
  @append88
    add w64 %236 %233 %235;
    load w8 %237 %236 0;
    add w64 %238 %232 %235;
    store w8 %237 %238 0;
    add w32 %239 %235 1;
    jmp @append87(%239);
  @append89
    store w64 %232 %199 0;
    store w32 %228 %199 12;
    jmp @append.store85;
  @then90
    ret 17;
  @merge91
    load w32 %246 %199 8;
    br.ult w32 0 %246 @guard#pass94 @guard#trap95;
  @then92
    ret 18;
  @merge93
    load w32 %249 %199 8;
    br.ult w32 1 %249 @guard#pass98 @guard#trap99;
  @guard#pass94
    load w64 %247 %199 0;
    load w8 %248 %247 0;
    br.ne w8 %248 171 @then92 @merge93;
  @guard#trap95
    ebreak;
    unreachable;
  @then96
    ret 19;
  @merge97
    load w32 %255 %199 8;
    load w32 %256 %199 12;
    br.ult w32 %255 %256 @append.store100 @append.grow101;
  @guard#pass98
    load w64 %250 %199 0;
    add w64 %251 %250 1;
    load w8 %252 %251 0;
    br.ne w8 %252 205 @then96 @merge97;
  @guard#trap99
    ebreak;
    unreachable;
  @append.store100
    load w64 %270 %199 0;
    add w64 %271 %270 %255;
    store w8 239 %271 0;
    add w32 %272 %255 1;
    store w32 %272 %199 8;
    load w32 %275 %199 8;
    br.ne w32 %275 3 @then105 @merge106;
  @append.grow101
    shl w32 %257 %256 1;
    or w32 %258 %257 1;
    load w64 %259 %7 0;
    load w64 %260 %7 8;
    mul w32 %261 %258 1;
    call w64 %262 %259(%260, %261, 1);
    load w64 %263 %199 0;
    mul w32 %264 %255 1;
    jmp @append102(0);
  @append102(w32 %265)
    br.ult w32 %265 %264 @append103 @append104;
  @append103
    add w64 %266 %263 %265;
    load w8 %267 %266 0;
    add w64 %268 %262 %265;
    store w8 %267 %268 0;
    add w32 %269 %265 1;
    jmp @append102(%269);
  @append104
    store w64 %262 %199 0;
    store w32 %258 %199 12;
    jmp @append.store100;
  @then105
    ret 20;
  @merge106
    load w32 %276 %199 12;
    br.ne w32 %276 5 @then107 @merge108;
  @then107
    ret 21;
  @merge108
    load w32 %277 %199 8;
    br.ult w32 2 %277 @guard#pass111 @guard#trap112;
  @then109
    ret 22;
  @merge110
    load w32 %281 %199 8;
    br.ult w32 0 %281 @guard#pass115 @guard#trap116;
  @guard#pass111
    load w64 %278 %199 0;
    add w64 %279 %278 2;
    load w8 %280 %279 0;
    br.ne w8 %280 239 @then109 @merge110;
  @guard#trap112
    ebreak;
    unreachable;
  @then113
    ret 23;
  @merge114
    copy %284 $main$nominal$arena;
    mul w32 %285 4 2;
    call w64 %286 $arenaAlloc(%284, %285, 4);
    reserve %287 16 8;
    store w64 %286 %287 0;
    store w32 0 %287 8;
    store w32 2 %287 12;
    load w32 %290 %287 8;
    load w32 %291 %287 12;
    br.ult w32 %290 %291 @append.store117 @append.grow118;
  @guard#pass115
    load w64 %282 %199 0;
    load w8 %283 %282 0;
    br.ne w8 %283 171 @then113 @merge114;
  @guard#trap116
    ebreak;
    unreachable;
  @append.store117
    load w64 %305 %287 0;
    mul w64 %306 %290 4;
    add w64 %307 %305 %306;
    store w32 42 %307 0;
    add w32 %308 %290 1;
    store w32 %308 %287 8;
    blit %287 %287 16;
    load w32 %311 %287 8;
    br.eq w32 %311 1 @assert.ok123 @assert.fail122;
  @append.grow118
    shl w32 %292 %291 1;
    or w32 %293 %292 1;
    load w64 %294 %7 0;
    load w64 %295 %7 8;
    mul w32 %296 %293 4;
    call w64 %297 %294(%295, %296, 4);
    load w64 %298 %287 0;
    mul w32 %299 %290 4;
    jmp @append119(0);
  @append119(w32 %300)
    br.ult w32 %300 %299 @append120 @append121;
  @append120
    add w64 %301 %298 %300;
    load w8 %302 %301 0;
    add w64 %303 %297 %300;
    store w8 %302 %303 0;
    add w32 %304 %300 1;
    jmp @append119(%304);
  @append121
    store w64 %297 %287 0;
    store w32 %293 %287 12;
    jmp @append.store117;
  @assert.fail122
    unreachable;
  @assert.ok123
    load w32 %312 %287 8;
    br.ult w32 0 %312 @guard#pass126 @guard#trap127;
  @assert.fail124
    unreachable;
  @assert.ok125
    load w32 %317 %287 8;
    load w32 %318 %287 12;
    br.ult w32 %317 %318 @append.store128 @append.grow129;
  @guard#pass126
    load w64 %313 %287 0;
    sload w32 %314 %313 0;
    br.eq w32 %314 42 @assert.ok125 @assert.fail124;
  @guard#trap127
    ebreak;
    unreachable;
  @append.store128
    load w64 %332 %287 0;
    mul w64 %333 %317 4;
    add w64 %334 %332 %333;
    store w32 43 %334 0;
    add w32 %335 %317 1;
    store w32 %335 %287 8;
    blit %287 %287 16;
    load w32 %338 %287 8;
    br.eq w32 %338 2 @assert.ok134 @assert.fail133;
  @append.grow129
    shl w32 %319 %318 1;
    or w32 %320 %319 1;
    load w64 %321 %7 0;
    load w64 %322 %7 8;
    mul w32 %323 %320 4;
    call w64 %324 %321(%322, %323, 4);
    load w64 %325 %287 0;
    mul w32 %326 %317 4;
    jmp @append130(0);
  @append130(w32 %327)
    br.ult w32 %327 %326 @append131 @append132;
  @append131
    add w64 %328 %325 %327;
    load w8 %329 %328 0;
    add w64 %330 %324 %327;
    store w8 %329 %330 0;
    add w32 %331 %327 1;
    jmp @append130(%331);
  @append132
    store w64 %324 %287 0;
    store w32 %320 %287 12;
    jmp @append.store128;
  @assert.fail133
    unreachable;
  @assert.ok134
    load w32 %339 %287 8;
    br.ult w32 0 %339 @guard#pass135 @guard#trap136;
  @guard#pass135
    load w64 %340 %287 0;
    load w32 %343 %287 8;
    load w32 %344 %287 12;
    br.ult w32 %343 %344 @append.store137 @append.grow138;
  @guard#trap136
    ebreak;
    unreachable;
  @append.store137
    load w64 %358 %287 0;
    mul w64 %359 %343 4;
    add w64 %360 %358 %359;
    store w32 44 %360 0;
    add w32 %361 %343 1;
    store w32 %361 %287 8;
    blit %287 %287 16;
    load w32 %364 %287 8;
    br.eq w32 %364 3 @assert.ok143 @assert.fail142;
  @append.grow138
    shl w32 %345 %344 1;
    or w32 %346 %345 1;
    load w64 %347 %7 0;
    load w64 %348 %7 8;
    mul w32 %349 %346 4;
    call w64 %350 %347(%348, %349, 4);
    load w64 %351 %287 0;
    mul w32 %352 %343 4;
    jmp @append139(0);
  @append139(w32 %353)
    br.ult w32 %353 %352 @append140 @append141;
  @append140
    add w64 %354 %351 %353;
    load w8 %355 %354 0;
    add w64 %356 %350 %353;
    store w8 %355 %356 0;
    add w32 %357 %353 1;
    jmp @append139(%357);
  @append141
    store w64 %350 %287 0;
    store w32 %346 %287 12;
    jmp @append.store137;
  @assert.fail142
    unreachable;
  @assert.ok143
    load w32 %365 %287 12;
    br.eq w32 %365 5 @assert.ok145 @assert.fail144;
  @assert.fail144
    unreachable;
  @assert.ok145
    load w32 %366 %287 8;
    br.ult w32 0 %366 @guard#pass146 @guard#trap147;
  @guard#pass146
    load w64 %367 %287 0;
    br.ne w64 %340 %367 @assert.ok149 @assert.fail148;
  @guard#trap147
    ebreak;
    unreachable;
  @assert.fail148
    unreachable;
  @assert.ok149
    load w32 %370 %287 8;
    br.ult w32 0 %370 @guard#pass152 @guard#trap153;
  @assert.fail150
    unreachable;
  @assert.ok151
    load w32 %373 %287 8;
    br.ult w32 1 %373 @guard#pass156 @guard#trap157;
  @guard#pass152
    load w64 %371 %287 0;
    sload w32 %372 %371 0;
    br.eq w32 %372 42 @assert.ok151 @assert.fail150;
  @guard#trap153
    ebreak;
    unreachable;
  @assert.fail154
    unreachable;
  @assert.ok155
    load w32 %378 %287 8;
    br.ult w32 2 %378 @guard#pass160 @guard#trap161;
  @guard#pass156
    load w64 %374 %287 0;
    mul w64 %375 1 4;
    add w64 %376 %374 %375;
    sload w32 %377 %376 0;
    br.eq w32 %377 43 @assert.ok155 @assert.fail154;
  @guard#trap157
    ebreak;
    unreachable;
  @assert.fail158
    unreachable;
  @assert.ok159
    ret 0;
  @guard#pass160
    load w64 %379 %287 0;
    mul w64 %380 2 4;
    add w64 %381 %379 %380;
    sload w32 %382 %381 0;
    br.eq w32 %382 44 @assert.ok159 @assert.fail158;
  @guard#trap161
    ebreak;
    unreachable;
    store w64 %13 %1 0;
    store w32 %8 %1 12;
    jmp @append.store1;
  @ok10
    add w64 %28 %4 8;
    blit %27 %28 16;
    jmp @merge12;
  @err11
    reserve %29 24 8;
    store w64 %26 %29 0;
    add w64 %30 %4 8;
    add w64 %31 %29 8;
    blit %31 %30 16;
    blit %0 %29 24;
    ret %0;
  @merge12
    reserve %32 24 8;
    store w64 0 %32 0;
    add w64 %33 %32 8;
    blit %33 %27 16;
    blit %0 %32 24;
    ret %0;
}

test/tests/slice.append.values.rad added +198 -0

1	+	//! returns: 0
2	+	//! Test slice .append() method with inline allocator.
3	+
4	+	/// Allocation failures.
5	+	union AllocError: Copy {
6	+	/// The allocator cannot provide storage.
7	+	OutOfMemory,
8	+	}
9	+
10	+	/// Simple bump allocator for testing.
11	+	record Arena {
12	+	data: *mut [u8],
13	+	offset: u32,
14	+	}
15	+
16	+	fn newArena(data: *mut [u8]) -> Arena {
17	+	return Arena { data, offset: 0 };
18	+	}
19	+
20	+	fn arenaAlloc(arena: &mut Arena, size: u32, al: u32) -> *mut opaque {
21	+	let aligned = (arena.offset + al - 1) / al * al;
22	+	let newOffset = aligned + size;
23	+
24	+	assert newOffset <= arena.data.len as u32;
25	+
26	+	let base: *mut u8 = &mut arena.data[aligned];
27	+	set arena.offset = newOffset;
28	+
29	+	return base as *mut opaque;
30	+	}
31	+
32	+	/// Allocator record matching the compiler's expected layout.
33	+	record Allocator: Copy {
34	+	func: unsafe fn(unsafe mut opaque, u32, u32) -> mut opaque throws (AllocError),
35	+	ctx: *unsafe mut opaque,
36	+	}
37	+
38	+	unsafe fn arenaAllocFn(ctx: unsafe mut opaque, size: u32, al: u32) -> mut opaque throws (AllocError) {
39	+	let arena = ctx as *unsafe mut Arena;
40	+	return arenaAlloc(&mut *arena, size, al);
41	+	}
42	+
43	+	unsafe fn arenaAllocator(arena: &mut Arena) -> Allocator {
44	+	return Allocator {
45	+	func: arenaAllocFn,
46	+	ctx: (arena as unsafe mut Arena) as unsafe mut opaque,
47	+	};
48	+	}
49	+
50	+	unsafe static BUF: [u8; 4096] = undefined;
51	+
52	+	@default unsafe fn main() -> i32 {
53	+	static arena: Arena = undefined;
54	+	set arena = newArena(&mut BUF[..]);
55	+	let a = arenaAllocator(&mut arena);
56	+
57	+	// Allocate initial capacity of 4.
58	+	let ptr = arenaAlloc(&mut arena, @sizeOf(i32) * 4, @alignOf(i32));
59	+	let mut nums = @sliceOf(ptr as *mut i32, 0, 4);
60	+
61	+	// Append within capacity.
62	+	try! nums.append(10, a);
63	+	try! nums.append(20, a);
64	+	try! nums.append(30, a);
65	+
66	+	if nums.len <> 3 {
67	+	return 1;
68	+	}
69	+	if nums.cap <> 4 {
70	+	return 2;
71	+	}
72	+	if nums[0] <> 10 {
73	+	return 3;
74	+	}
75	+	if nums[1] <> 20 {
76	+	return 4;
77	+	}
78	+	if nums[2] <> 30 {
79	+	return 5;
80	+	}
81	+
82	+	// Append to fill capacity.
83	+	try! nums.append(40, a);
84	+
85	+	if nums.len <> 4 {
86	+	return 6;
87	+	}
88	+	if nums.cap <> 4 {
89	+	return 7;
90	+	}
91	+
92	+	// Append past capacity -- triggers growth.
93	+	try! nums.append(50, a);
94	+
95	+	if nums.len <> 5 {
96	+	return 8;
97	+	}
98	+	// Cap should have grown (cap * 2 \| 1 = 4 * 2 \| 1 = 9).
99	+	if nums.cap <> 9 {
100	+	return 9;
101	+	}
102	+	if nums[4] <> 50 {
103	+	return 10;
104	+	}
105	+
106	+	// Verify old elements survived the copy.
107	+	if nums[0] <> 10 {
108	+	return 11;
109	+	}
110	+	if nums[3] <> 40 {
111	+	return 12;
112	+	}
113	+
114	+	// Append from empty (cap == 0 triggers growth with cap = 1).
115	+	let mut empty: *mut [i32] = &mut [];
116	+	try! empty.append(99, a);
117	+
118	+	if empty.len <> 1 {
119	+	return 13;
120	+	}
121	+	if empty.cap <> 1 {
122	+	return 14;
123	+	}
124	+	if empty[0] <> 99 {
125	+	return 15;
126	+	}
127	+
128	+	// Sum all elements in nums.
129	+	let mut sum: i32 = 0;
130	+	for n in nums {
131	+	set sum += n;
132	+	}
133	+	if sum <> 150 {
134	+	return 16;
135	+	}
136	+
137	+	// Test append with u8 elements (stride = 1).
138	+	let bytePtr = arenaAlloc(&mut arena, 2, 1);
139	+	let mut bytes = @sliceOf(bytePtr as *mut u8, 0, 2);
140	+	try! bytes.append(0xAB, a);
141	+	try! bytes.append(0xCD, a);
142	+
143	+	if bytes.len <> 2 {
144	+	return 17;
145	+	}
146	+	if bytes[0] <> 0xAB {
147	+	return 18;
148	+	}
149	+	if bytes[1] <> 0xCD {
150	+	return 19;
151	+	}
152	+
153	+	// Trigger growth on u8 slice.
154	+	try! bytes.append(0xEF, a);
155	+
156	+	if bytes.len <> 3 {
157	+	return 20;
158	+	}
159	+	if bytes.cap <> 5 {
160	+	return 21;
161	+	}
162	+	if bytes[2] <> 0xEF {
163	+	return 22;
164	+	}
165	+	// Verify old u8 elements survived.
166	+	if bytes[0] <> 0xAB {
167	+	return 23;
168	+	}
169	+
170	+	// Test that .append() returns the slice, allowing rebinding.
171	+	let ptr2 = arenaAlloc(&mut arena, @sizeOf(i32) * 2, @alignOf(i32));
172	+	let mut vals = @sliceOf(ptr2 as *mut i32, 0, 2);
173	+
174	+	// Append within capacity, rebind via return value.
175	+	set vals = try! vals.append(42, a);
176	+	assert vals.len == 1;
177	+	assert vals[0] == 42;
178	+
179	+	set vals = try! vals.append(43, a);
180	+	assert vals.len == 2;
181	+
182	+	// Append past capacity -- triggers growth and returns updated slice.
183	+	let oldPtr = &vals[0] as *opaque;
184	+	set vals = try! vals.append(44, a);
185	+	assert vals.len == 3;
186	+	assert vals.cap == 5;
187	+
188	+	// After growth, the data pointer should have changed.
189	+	let newPtr = &vals[0] as *opaque;
190	+	assert oldPtr <> newPtr;
191	+
192	+	// Verify all elements survived.
193	+	assert vals[0] == 42;
194	+	assert vals[1] == 43;
195	+	assert vals[2] == 44;
196	+
197	+	return 0;
198	+	}

test/tests/slice.range.capacity.rad +11 -5

//! returns: 0
//! Slice ranges retain the backing capacity after their start offset.

/// Allocation failures.
union AllocError: Copy {
    /// The allocator cannot provide storage.
    OutOfMemory,
}

/// Allocator interface used by append.
record Allocator: Copy {
    /// Allocation callback.
    func: unsafe fn(*unsafe mut opaque, u32, u32) -> *mut opaque,
    func: unsafe fn(*unsafe mut opaque, u32, u32) -> *mut opaque throws (AllocError),
    /// Callback context.
    ctx: *unsafe mut opaque,
}

/// Reject allocation when append must use existing storage.
unsafe fn rejectAlloc(ctx: *unsafe mut opaque, size: u32, alignment: u32) -> *mut opaque {
unsafe fn rejectAlloc(ctx: *unsafe mut opaque, size: u32, alignment: u32) -> *mut opaque throws (AllocError) {
    panic "rejectAlloc: unexpected allocation";
}

/// Check dynamic range bounds and nested slice capacity.
fn checkRange(storage: *mut [i32], start: u32, end: u32) {

    assert end.cap == 0;
    checkRange((&mut storage[..2]) as *mut [i32], 1, 2);
    checkRange((&mut storage[..]) as *mut [i32], 4, 4);
    let mut items: *mut [i32] = &mut storage[1..1];
    let allocator = Allocator { func: rejectAlloc, ctx: &mut storage as *unsafe mut opaque };
    items.append(50, allocator);
    items.append(60, allocator);
    items.append(70, allocator);
    try! items.append(50, allocator);
    try! items.append(60, allocator);
    try! items.append(70, allocator);
    assert items.len == 3;
    assert items.cap == 3;
    assert items[0] == 50;
    assert items[2] == 70;
    return 0;

655	655		}
656	656		set funcPath[desc.modPath.len - 1] = desc.fnName;
657	657		let funcArg = synthScopeAccess(arena, &funcPath[..desc.modPath.len]);
658	658
659	659		let a = alloc::arenaAllocator(&mut arena.arena);
660		-	let args = ast::nodeSlice(arena, 3)
661		-	.append(modArg, a)
662		-	.append(nameArg, a)
663		-	.append(funcArg, a);
	660	+	let args = ast::nodeSlice(arena, 3);
	661	+	try! args.append(modArg, a);
	662	+	try! args.append(nameArg, a);
	663	+	try! args.append(funcArg, a);
664	664
665	665		return ast::synthNode(arena, ast::NodeValue::Call(ast::Call { callee, args }));
666	666		}
667	667
668	668		/// Inject a test runner into the entry package's root module.

720	720		unsafe fn synthTestMainFn(arena: &mut ast::NodeArena, tests: &[TestDesc]) -> *ast::Node {
721	721		// Build array literal: `[testing::test(...), ...]`.
722	722		let a = alloc::arenaAllocator(&mut arena.arena);
723	723		let mut elements = ast::nodeSlice(arena, tests.len as u32);
724	724		for i in 0..tests.len {
725		-	elements.append(synthTestCall(arena, &tests[i]), a);
	725	+	try! elements.append(synthTestCall(arena, &tests[i]), a);
726	726		}
727	727		let arrayLit = ast::synthNode(arena, ast::NodeValue::ArrayLit(elements));
728	728
729	729		// Build: `&[...]`.
730	730		let testsRef = ast::synthNode(arena, ast::NodeValue::AddressOf(ast::AddressOf {
731	731		target: arrayLit, mutable: false,
732	732		}));
733	733
734	734		// Build: `testing::runAllTests(&[...])`.
735	735		let runFn = synthScopeAccess(arena, &["testing", "runAllTests"]);
736		-	let callArgs = ast::nodeSlice(arena, 1).append(testsRef, a);
	736	+	let callArgs = try! ast::nodeSlice(arena, 1).append(testsRef, a);
737	737		let callExpr = ast::synthNode(arena, ast::NodeValue::Call(ast::Call {
738	738		callee: runFn, args: callArgs,
739	739		}));
740	740
741	741		// Build: `return testing::runAllTests(&[...]);`
742	742		let retStmt = ast::synthNode(arena, ast::NodeValue::Return { value: callExpr });
743		-	let bodyStmts = ast::nodeSlice(arena, 1).append(retStmt, a);
	743	+	let bodyStmts = try! ast::nodeSlice(arena, 1).append(retStmt, a);
744	744		let fnBody = ast::synthNode(arena, ast::NodeValue::Block(ast::Block { statements: bodyStmts, isUnsafe: false }));
745	745
746	746		// Build: `unsafe fn #testMain() -> i32`
747	747		let fnName = ast::synthNode(arena, ast::NodeValue::Ident(strings::intern(&mut STRING_POOL, "#testMain")));
748	748		let returnType = ast::synthNode(arena, ast::NodeValue::TypeSig(ast::TypeSig::Integer {

755	755		};
756	756
757	757		// Entry and function safety attributes.
758	758		let attrNode = ast::synthNode(arena, ast::NodeValue::Attribute(ast::Attribute::Default));
759	759		let unsafeAttr = ast::synthNode(arena, ast::NodeValue::Attribute(ast::Attribute::Unsafe));
760		-	let attrList = ast::nodeSlice(arena, 2).append(attrNode, a).append(unsafeAttr, a);
	760	+	let attrList = try! ast::nodeSlice(arena, 2).append(attrNode, a);
	761	+	try! attrList.append(unsafeAttr, a);
761	762		let fnAttrs = ast::Attributes { list: attrList };
762	763
763	764		return ast::synthNode(arena, ast::NodeValue::FnDecl(ast::FnDecl {
764	765		name: fnName, sig: fnSig, body: fnBody, attrs: fnAttrs,
765	766		}));

775	776		panic "injectIntoBlock: expected Block node";
776	777		};
777	778		let allocator = alloc::arenaAllocator(&mut arena.arena);
778	779		let mut stmts = ast::nodeSlice(arena, block.statements.len + 1);
779	780		for stmt in block.statements {
780		-	stmts.append(stmt, allocator);
	781	+	try! stmts.append(stmt, allocator);
781	782		}
782		-	stmts.append(decl, allocator);
	783	+	try! stmts.append(decl, allocator);
783	784		return ast::allocNode(arena, blockNode.span, ast::NodeValue::Block(
784	785		ast::Block { statements: stmts, isUnsafe: block.isUnsafe }
785	786		));
786	787		}
787	788

867	867		let fnBody: *Node = synthNode(arena, NodeValue::Block(Block { statements: bodyStmts, isUnsafe: false }));
868	868		let fnDecl = synthNode(arena, NodeValue::FnDecl(FnDecl {
869	869		name: fnName, sig: fnSig, body: fnBody, attrs: nil,
870	870		}));
871	871		let mut rootStmts: mut [Node] = &mut [];
872		-	rootStmts.append(fnDecl, a);
	872	+	try! rootStmts.append(fnDecl, a);
873	873		let modBody = synthNode(arena, NodeValue::Block(Block { statements: rootStmts, isUnsafe: false }));
874	874
875	875		return SynthFnMod { modBody, fnBody };
876	876		}

13	13		let idx = a.symbols.len;
14	14		let offset: i32 = a.data.len as i32
15	15		if a.section == super::Section::Data
16	16		else a.text.len as i32 * rv64::INSTR_SIZE;
17	17
18		-	a.symbols.append(super::Symbol {
	18	+	try! a.symbols.append(super::Symbol {
19	19		name,
20	20		section: a.section,
21	21		offset,
22	22		isExported: dict::get(&a.exportMap, name) <> nil,
23	23		}, alloc::arenaAllocator(a.arena));
24	24		dict::insert(&mut a.symbolMap, name, idx as i32);
25	25		}
26	26
27	27		/// Append one encoded instruction word to the text section.
28	28		export unsafe fn emitText(a: &mut super::Assembler, word: u32) throws (super::Error) {
29		-	a.text.append(word, alloc::arenaAllocator(a.arena));
	29	+	try a.text.append(word, alloc::arenaAllocator(a.arena)) catch {
	30	+	throw super::Error::TextOverflow;
	31	+	};
30	32		}
31	33
32	34		/// Append `words` no-op instructions to the text section.
33	35		export unsafe fn emitTextPadding(a: &mut super::Assembler, words: u32) throws (super::Error) {
34	36		for _ in 0..words {

36	38		}
37	39		}
38	40
39	41		/// Append one byte to the data section.
40	42		export unsafe fn emitByte(a: &mut super::Assembler, byte: u8) throws (super::Error) {
41		-	a.data.append(byte, alloc::arenaAllocator(a.arena));
	43	+	try a.data.append(byte, alloc::arenaAllocator(a.arena)) catch {
	44	+	throw super::Error::DataOverflow;
	45	+	};
42	46		}
43	47
44	48		/// Emit a little-endian integer with `bytes` bytes.
45	49		unsafe fn emitDataInt(a: &mut super::Assembler, bits: u64, bytes: u32) throws (super::Error) {
46	50		for i in 0..bytes {

78	82		}
79	83		}
80	84
81	85		/// Record a pending symbol fixup.
82	86		unsafe fn recordFixup(a: &mut super::Assembler, symbol: *[u8], info: super::FixupInfo) {
83		-	a.fixups.append(super::Fixup { symbol, info }, alloc::arenaAllocator(a.arena));
	87	+	try! a.fixups.append(super::Fixup { symbol, info }, alloc::arenaAllocator(a.arena));
84	88		}
85	89
86	90		/// Record a text fixup that must be resolved after all program text is known.
87	91		unsafe fn recordExternalFixup(a: &mut super::Assembler, fixup: super::Fixup) {
88		-	a.externalFixups.append(fixup, alloc::arenaAllocator(a.arena));
	92	+	try! a.externalFixups.append(fixup, alloc::arenaAllocator(a.arena));
89	93		}
90	94
91	95		/// Record a text-section symbol fixup and reserve its instruction words.
92	96		export unsafe fn recordTextFixup(a: &mut super::Assembler, symbol: *[u8], info: super::FixupInfo, words: u32) throws (super::Error) {
93	97		recordFixup(a, symbol, info);

201	201		let pendingBranchesBuf = pendingBranches as *mut [PendingBranch];
202	202		let pendingCallsBuf = pendingCalls as *mut [PendingCall];
203	203		let pendingJumpsBuf = pendingJumps as *mut [PendingJump];
204	204		let pendingAddrLoadsBuf = pendingAddrLoads as *mut [PendingAddrLoad];
205	205		let funcsBuf = funcs as *mut [types::FuncAddr];
	206	+
206	207		return Emitter {
207	208		allocator: alloc::arenaAllocator(arena),
208	209		code: code as *mut [u32],
209	210		codeLen: 0,
210	211		pendingBranches: &mut pendingBranchesBuf[..0],

263	264		recordFuncAt(e, name, codeLen);
264	265		}
265	266
266	267		/// Record a function's start position at `index` for printing.
267	268		export fn recordFuncAt(e: &mut Emitter, name: *[u8], index: u32) {
268		-	e.funcs.append(types::FuncAddr { name, index }, e.allocator);
	269	+	try! e.funcs.append(types::FuncAddr { name, index }, e.allocator);
269	270		}
270	271
271	272		/// Record a local branch needing later patching.
272	273		/// Unconditional jumps use a single slot (J-type, +-1MB range).
273	274		/// Conditional branches use two slots (B-type has only +-4KB range,
274	275		/// so large functions may need the inverted-branch + JAL fallback).
275	276		export fn recordBranch(e: &mut Emitter, targetBlock: u32, kind: BranchKind) {
276		-	e.pendingBranches.append(PendingBranch {
	277	+	try! e.pendingBranches.append(PendingBranch {
277	278		index: e.codeLen,
278	279		target: targetBlock,
279	280		kind: kind,
280	281		}, e.allocator);
281	282

289	290
290	291		/// Record a function call needing later patching.
291	292		/// Emits placeholder instructions that will be patched later.
292	293		/// Uses two slots to support long-distance calls.
293	294		export fn recordCall(e: &mut Emitter, target: *[u8]) {
294		-	e.pendingCalls.append(PendingCall {
	295	+	try! e.pendingCalls.append(PendingCall {
295	296		index: e.codeLen,
296	297		target,
297	298		}, e.allocator);
298	299
299	300		emit(e, encode::nop()); // Placeholder for AUIPC.
300	301		emit(e, encode::nop()); // Placeholder for JALR.
301	302		}
302	303
303	304		/// Record a jump emitted by assembly that needs whole-program patching.
304	305		export fn recordJumpAt(e: &mut Emitter, target: *[u8], rd: gen::Reg, index: u32) {
305		-	e.pendingJumps.append(PendingJump {
	306	+	try! e.pendingJumps.append(PendingJump {
306	307		index,
307	308		target,
308	309		rd,
309	310		}, e.allocator);
310	311		}

320	321		emit(e, encode::nop()); // Placeholder for ADDI.
321	322		}
322	323
323	324		/// Record a function address load already reserved by assembly.
324	325		export fn recordAddrLoadAt(e: &mut Emitter, target: *[u8], rd: gen::Reg, index: u32) {
325		-	e.pendingAddrLoads.append(PendingAddrLoad {
	326	+	try! e.pendingAddrLoads.append(PendingAddrLoad {
326	327		index,
327	328		target,
328	329		rd: rd,
329	330		isData: false,
330	331		}, e.allocator);
331	332		}
332	333
333	334		/// Record a data address load needing later patching.
334	335		/// Uses an absolute 32-bit load sequence matching the current data memory map.
335	336		export fn recordDataAddrLoad(e: &mut Emitter, target: *[u8], rd: gen::Reg) {
336		-	e.pendingAddrLoads.append(PendingAddrLoad {
	337	+	try! e.pendingAddrLoads.append(PendingAddrLoad {
337	338		index: e.codeLen,
338	339		target,
339	340		rd: rd,
340	341		isData: true,
341	342		}, e.allocator);

108	108		///
109	109		/// Bundles an allocation function with an opaque context pointer so that
110	110		/// any allocation strategy (arena, free-list, mmap, pool) can be used
111	111		/// through a uniform interface. The `func` field is called with the context
112	112		/// pointer, a byte size and an alignment, and must return a pointer to
113		-	/// the allocated memory or panic on failure.
	113	+	/// the allocated memory or throw `AllocError` on failure.
114	114		export record Allocator: Copy {
115	115		/// Allocation function. Returns a pointer to `size` bytes
116		-	/// aligned to `alignment`, or panics on failure.
117		-	func: unsafe fn(unsafe mut opaque, u32, u32) -> mut opaque,
	116	+	/// aligned to `alignment`, or throws `AllocError` on failure.
	117	+	func: unsafe fn(unsafe mut opaque, u32, u32) -> mut opaque throws (AllocError),
118	118		/// Opaque context pointer passed to `func`.
119	119		ctx: *unsafe mut opaque,
120	120		}
121	121
122	122		/// Create an allocator whose arena must outlive all uses of the allocator.

126	126		ctx: (arena as unsafe mut Arena) as unsafe mut opaque,
127	127		};
128	128		}
129	129
130	130		/// Arena allocation function conforming to the `Allocator` interface.
131		-	unsafe fn arenaAllocFn(ctx: unsafe mut opaque, size: u32, alignment: u32) -> mut opaque {
	131	+	unsafe fn arenaAllocFn(ctx: unsafe mut opaque, size: u32, alignment: u32) -> mut opaque throws (AllocError) {
132	132		let arena = ctx as *unsafe mut Arena;
133		-	return try! alloc(arena, size, alignment);
	133	+	return try alloc(arena, size, alignment);
134	134		}
135	135
136	136		/// Allocate raw storage that remains valid until the arena is reset.
137	137		export unsafe fn allocRaw(arena: &mut Arena, size: u32, alignment: u32) -> *unsafe mut opaque throws (AllocError) {
138	138		let owner = try alloc(arena, size, alignment);

109	109		static STORAGE: [u8; 256] = [0; 256];
110	110		let mut arena = super::new(&mut STORAGE[..]);
111	111		let a = super::arenaAllocator(&mut arena);
112	112
113	113		// Allocate through the Allocator indirection.
114		-	let p1 = a.func(a.ctx, 16, 4);
	114	+	let p1 = try! a.func(a.ctx, 16, 4);
115	115		try testing::expect(super::used(&arena) == 16);
116	116
117		-	let p2 = a.func(a.ctx, 8, 8);
	117	+	let p2 = try! a.func(a.ctx, 8, 8);
118	118		try testing::expect(super::used(&arena) == 24);
119	119
120	120		// Verify the pointers are distinct.
121	121		try testing::expect(p1 as u64 <> p2 as u64);
122	122		}
	123	+
	124	+	/// Append reports arena exhaustion and preserves the slice and arena state.
	125	+	@test unsafe fn testAllocatorAppendExhausted() throws (testing::TestError) {
	126	+	static storage: [u8; 4] = [0; 4];
	127	+	let mut arena = super::new(&mut storage[..]);
	128	+	let a = super::arenaAllocator(&mut arena);
	129	+	let mut items: *mut [u32] = &mut [];
	130	+	try! items.append(42, a);
	131	+	let mut caught = false;
	132	+	try items.append(99, a) catch error as super::AllocError {
	133	+	try testing::expect(error == super::AllocError::OutOfMemory);
	134	+	set caught = true;
	135	+	};
	136	+	try testing::expect(caught);
	137	+	try testing::expect(items.len == 1);
	138	+	try testing::expect(items.cap == 1);
	139	+	try testing::expect(items[0] == 42);
	140	+	try testing::expect(arena.offset == 4);
	141	+	}

1143	1144		set values[i] = il::DataValue {
1144	1145		item: il::DataItem::Fn(methodNames[i]),
1145	1146		count: 1,
1146	1147		};
1147	1148		}
1148		-	self.data.append(il::Data {
	1149	+	try! self.data.append(il::Data {
1149	1150		name: vName,
1150	1151		size: traitInfo.methods.len as u32 * resolver::PTR_SIZE,
1151	1152		alignment: resolver::PTR_SIZE,
1152	1153		readOnly: true,
1153	1154		isZeroInit: false,

93	93		use std::lang::types;
94	94		use std::mem;
95	95		use std::lang::ast;
96	96		use std::lang::il;
97	97		use std::lang::module;
	98	+	use std::lang::parser;
98	99		use std::lang::resolver;
99	100
100	101		// TODO: Search for all `_ as i32` to ensure that casts from u32 to i32 don't
101	102		// happen, since they are potentially truncating values.
102	103

349	350		}
350	351		}
351	352		let tag = self.errTagCounter;
352	353
353	354		set self.errTagCounter += 1;
354		-	self.errTags.append(ErrTagEntry { ty: errType, tag }, self.allocator);
	355	+	try! self.errTags.append(ErrTagEntry { ty: errType, tag }, self.allocator);
355	356
356	357		return tag;
357	358		}
358	359
359	360		/// Emit one function to the active output.
360	361		unsafe fn emitFunction(self: &mut Lowerer, func: *unsafe il::Fn, role: FnRole) {
361	362		match self.output {
362	363		case FnOutput::Accumulate(accumulated) => {
363	364		let mut fns = accumulated;
364		-	fns.append(func, self.allocator);
	365	+	try! fns.append(func, self.allocator);
365	366		set self.output = FnOutput::Accumulate(fns);
366	367		}
367	368		case FnOutput::Stream(sink) => {
368	369		sink.emitFn(sink.ctx, func, role);
369	370		}

420	421		return true;
421	422		}
422	423
423	424		/// Append a data value to the builder.
424	425		fn dataBuilderPush(b: &mut DataValueBuilder, value: il::DataValue) {
425		-	b.values.append(value, b.allocator);
	426	+	try! b.values.append(value, b.allocator);
426	427
427	428		if value.count > 0 and not dataIsZero(value.item) {
428	429		set b.zeroInit = false;
429	430		}
430	431		}

906	907
907	908		/// Register a function symbol with its qualified name.
908	909		/// Called when lowering function declarations, so cross-package calls can find
909	910		/// the function by name.
910	911		fn registerFnSym(self: &mut Lowerer, sym: unsafe resolver::Symbol, qualName: [u8]) {
911		-	self.fnSyms.append(FnSymEntry { sym, qualName }, self.allocator);
	912	+	try! self.fnSyms.append(FnSymEntry { sym, qualName }, self.allocator);
912	913		}
913	914
914	915		/// Look up a function's qualified name by its symbol.
915	916		/// Returns `nil` if the symbol wasn't registered (e.g. callee's module is not yet lowered).
916	917		// TODO: This is kind of dubious as an optimization, if it depends on the order

1351	1352		let qualName = qualifyName(self, nil, sym.name);
1352	1353		let mut b = dataBuilder(self.allocator);
1353	1354		try lowerConstDataInto(self, value, data.ty, layout.size, qualName, &mut b);
1354	1355		let result = dataBuilderFinish(b);
1355	1356
1356		-	self.data.append(il::Data {
	1357	+	try! self.data.append(il::Data {
1357	1358		name: qualName,
1358	1359		size: layout.size,
1359	1360		alignment: layout.alignment,
1360	1361		readOnly,
1361	1362		isZeroInit: not readOnly and result.zeroInit,

1762	1763		values: *[il::DataValue],
1763	1764		dataPrefix: *[u8]
1764	1765		) -> *[u8] throws (LowerError) {
1765	1766		let dataCount = self.data.len;
1766	1767		let name = try nextDeclDataName(self, dataPrefix, dataCount, "literal");
1767		-	self.data.append(il::Data {
	1768	+	try! self.data.append(il::Data {
1768	1769		name,
1769	1770		size,
1770	1771		alignment,
1771	1772		readOnly,
1772	1773		isZeroInit: not readOnly and dataValuesAreZeroInit(values),

1894	1895		}
1895	1896		if let name = found {
1896	1897		set dataName = name;
1897	1898		} else {
1898	1899		set dataName = try nextDataName(self);
1899		-	self.low.data.append(il::Data {
	1900	+	try! self.low.data.append(il::Data {
1900	1901		name: dataName,
1901	1902		size,
1902	1903		alignment,
1903	1904		readOnly,
1904	1905		isZeroInit: not readOnly and result.zeroInit,

2039	2040		let vars = try! alloc::allocRawSlice(self.low.fnArena, @sizeOf(?il::Val), @alignOf(?il::Val), varCount) as *unsafe mut [?il::Val];
2040	2041
2041	2042		for i in 0..varCount {
2042	2043		set vars[i] = nil;
2043	2044		}
2044		-	self.blockData.append(BlockData {
	2045	+	try! self.blockData.append(BlockData {
2045	2046		label,
2046	2047		params: &mut [],
2047	2048		paramVars: &mut [],
2048	2049		instrs: &mut [],
2049	2050		locs: &mut [],

2062	2063		labelBase: *[u8],
2063	2064		param: il::Param
2064	2065		) -> BlockId throws (LowerError) {
2065	2066		let block = try createBlock(self, labelBase);
2066	2067		let blk = getBlockMut(self, block);
2067		-	blk.params.append(param, self.allocator);
	2068	+	try! blk.params.append(param, self.allocator);
2068	2069
2069	2070		return block;
2070	2071		}
2071	2072
2072	2073		/// Switch to building a different block.

2136	2137		else => {},
2137	2138		}
2138	2139		}
2139	2140		// Record source location alongside instruction when enabled.
2140	2141		if self.low.options.debug {
2141		-	block.locs.append(self.srcLoc, self.allocator);
	2142	+	try! block.locs.append(self.srcLoc, self.allocator);
2142	2143		}
2143		-	block.instrs.append(instr, self.allocator);
	2144	+	try! block.instrs.append(instr, self.allocator);
2144	2145		}
2145	2146
2146	2147		/// Emit an unconditional jump to `target`.
2147	2148		unsafe fn emitJmp(self: &mut FnLowerer, target: BlockId) throws (LowerError) {
2148	2149		emit(self, il::Instr::Jmp { target: *target, args: &mut [] });

2614	2615		for i in 0..preds.len {
2615	2616		if preds[i] == *pred { // Avoid duplicate predecessor entries.
2616	2617		return;
2617	2618		}
2618	2619		}
2619		-	preds.append(*pred, self.allocator);
	2620	+	try! preds.append(*pred, self.allocator);
2620	2621		}
2621	2622
2622	2623		/// Finalize all blocks and return the block array.
2623	2624		unsafe fn finalizeBlocks(self: &mut FnLowerer) -> *unsafe [il::Block] throws (LowerError) {
2624	2625		let blockCount = self.blockData.len;

2791	2792		type: il::Type,
2792	2793		mutable: bool,
2793	2794		val: il::Val
2794	2795		) -> Var {
2795	2796		let id = self.vars.len;
2796		-	self.vars.append(VarData { name, type, mutable, addressTaken: false }, self.allocator);
	2797	+	try! self.vars.append(VarData { name, type, mutable, addressTaken: false }, self.allocator);
2797	2798
2798	2799		let v = Var(id);
2799	2800		if self.currentBlock <> nil {
2800	2801		defVar(self, v, val);
2801	2802		}

2921	2922
2922	2923		// Create block parameter and add it to the block.
2923	2924		let param = il::Param { value: reg, type };
2924	2925		let blk = getBlockMut(self, block);
2925	2926		let paramIdx = blk.paramVars.len;
2926		-	blk.params.append(param, self.allocator);
2927		-	blk.paramVars.append(*v, self.allocator); // Associate variable with parameter.
	2927	+	try! blk.params.append(param, self.allocator);
	2928	+	try! blk.paramVars.append(*v, self.allocator); // Associate variable with parameter.
2928	2929
2929	2930		// Record that this variable's value in this block is now the parameter register.
2930	2931		// This must happen before the predecessor loop to handle self-referential loops.
2931	2932		set blk.vars[*v] = il::Val::Reg(reg);
2932	2933

3130	3131		} else {
3131	3132		set name = try paramName(&astParams[i].value);
3132	3133		}
3133	3134		let v = newVar(self, name, type, false, il::Val::Undef);
3134	3135
3135		-	self.params.append(FnParamBinding { var: v, reg }, self.allocator);
	3136	+	try! self.params.append(FnParamBinding { var: v, reg }, self.allocator);
3136	3137		}
3137	3138		return params;
3138	3139		}
3139	3140
3140	3141		/// Resolve match subject.

3591	3592		set blocks[i] = try createBlock(self, "case");
3592	3593		for pat in pats {
3593	3594		let cv = resolver::constValueEntry(self.low.resolver, pat)
3594	3595		else throw LowerError::MissingConst(pat);
3595	3596
3596		-	cases.append(il::SwitchCase {
	3597	+	try! cases.append(il::SwitchCase {
3597	3598		value: constToScalar(cv),
3598	3599		target: *blocks[i],
3599	3600		args: &mut []
3600	3601		}, self.allocator);
3601	3602		}

6279	6280		// if successful, or an optional of it, if using `try?`.
6280	6281		let tryExprTy = try typeOf(self, node);
6281	6282		// Check for trait method dispatch or standalone method call.
6282	6283		let mut resVal: il::Val = undefined;
6283	6284		let callNodeExtra = resolver::nodeData(self.low.resolver, t.expr).extra;
6284		-	if let case resolver::NodeExtra::TraitMethodCall {
	6285	+	if let case resolver::NodeExtra::SliceAppend { elemType } = callNodeExtra {
	6286	+	set resVal = try lowerSliceAppend(self, callExpr, elemType);
	6287	+	} else if let case resolver::NodeExtra::TraitMethodCall {
6285	6288		traitInfo, methodIndex
6286	6289		} = callNodeExtra {
6287	6290		set resVal = try lowerTraitMethodCall(self, t.expr, callExpr, traitInfo, methodIndex);
6288	6291		} else if let case resolver::NodeExtra::MethodCall { method } = callNodeExtra {
6289	6292		set resVal = try lowerMethodCall(self, t.expr, callExpr, method);

6436	6439
6437	6440		if let typeNode = clause.typeNode {
6438	6441		let errTy = try typeOf(self, typeNode);
6439	6442		set errTypes[i] = errTy;
6440	6443
6441		-	cases.append(il::SwitchCase {
	6444	+	try! cases.append(il::SwitchCase {
6442	6445		value: getOrAssignErrorTag(self.low, errTy) as i64,
6443	6446		target: *blocks[i],
6444	6447		args: &mut []
6445	6448		}, self.allocator);
6446	6449		} else {

6537	6540		// Now all predecessors of header are known, seal it.
6538	6541		try sealBlock(self, header);
6539	6542		try switchToAndSeal(self, done);
6540	6543		}
6541	6544
6542		-	/// Lower `slice.append(val, allocator)`.
	6545	+	/// Lower `slice.append(val, allocator)` and return its result aggregate.
6543	6546		///
6544	6547		/// Emits inline grow-if-needed logic:
6545	6548		///
6546	6549		/// load len, cap from slice header
6547	6550		/// if len < cap: jmp @store
6548	6551		/// else: jmp @grow
6549	6552		///
6550	6553		/// @grow:
6551		-	/// newCap = max(cap * 2, 1)
6552		-	/// call allocator.func(allocator.ctx, newCap * stride, alignment)
	6554	+	/// limit = U32_MAX / stride
	6555	+	/// trap if cap > (limit - 1) / 2
	6556	+	/// newCap = cap * 2 + 1
	6557	+	/// bytes = newCap * stride
	6558	+	/// call allocator.func(allocator.ctx, bytes, alignment)
	6559	+	/// if allocation failed: return error result
6553	6560		/// copy old data to new pointer
6554	6561		/// update slice ptr and cap
6555	6562		/// jmp @store
6556	6563		///
6557	6564		/// @store:
6558	6565		/// store element at ptr + len * stride
6559	6566		/// increment len
	6567	+	/// return success result
6560	6568		///
6561		-	unsafe fn lowerSliceAppend(self: &mut FnLowerer, call: ast::Call, elemType: *resolver::Type) -> il::Val throws (LowerError) {
	6569	+	/// The slice header changes only after allocation succeeds.
	6570	+	unsafe fn lowerSliceAppend(
	6571	+	self: &mut FnLowerer,
	6572	+	call: ast::Call,
	6573	+	elemType: *resolver::Type,
	6574	+	) -> il::Val throws (LowerError) {
6562	6575		let case ast::NodeValue::FieldAccess(access) = call.callee.value
6563	6576		else throw LowerError::MissingMetadata;
	6577	+	let case resolver::Type::Fn(info) = try typeOf(self, call.callee)
	6578	+	else throw LowerError::ExpectedFunction;
	6579	+
	6580	+	let result = emitReserveLayout(self, resolver::getResultLayout(*info.returnType, info.throwList));
6564	6581
6565	6582		// Get the address of the slice header.
6566	6583		let sliceVal = try lowerExpr(self, access.parent);
6567	6584		let sliceReg = emitValToReg(self, sliceVal);
6568	6585

6579	6596		let lenVal = loadSliceLen(self, sliceReg);
6580	6597		let capVal = loadSliceCap(self, sliceReg);
6581	6598
6582	6599		// Branch: if length is smaller than capacity, go to @store else @grow.
6583	6600		let storeBlock = try createBlock(self, "append.store");
	6601	+	let doneBlock = try createBlock(self, "append.done");
6584	6602		let growBlock = try createBlock(self, "append.grow");
6585	6603		try emitBrCmp(self, il::CmpOp::Ult, il::Type::W32, lenVal, capVal, storeBlock, growBlock);
6586	6604		try switchToAndSeal(self, growBlock);
6587	6605
6588	6606		// -- @grow block ----------------------------------------------------------
6589	6607
6590		-	// `newCap = max(cap * 2, 1)`.
6591		-	// We are only here when at capacity, so we use `or` with `1` to ensure at least capacity `1`.
	6608	+	// Each allocation size and slice length must fit in u32.
	6609	+	let limit = parser::U32_MAX / stride;
	6610	+	try emitTrapUnlessCmp(self, il::CmpOp::Ult, il::Type::W32, capVal, il::Val::Imm(((limit - 1) / 2 + 1) as i64));
	6611	+
	6612	+	// Grow capacity to `cap * 2 + 1`.
6592	6613		let doubledVal = emitTypedBinOp(self, il::BinOp::Shl, il::Type::W32, capVal, il::Val::Imm(1));
6593	6614		let newCapVal = emitTypedBinOp(self, il::BinOp::Or, il::Type::W32, doubledVal, il::Val::Imm(1));
6594	6615
6595	6616		// Call allocator: `a.func(a.ctx, newCap * stride, alignment)`.
6596	6617		let allocFnReg = nextReg(self);

6598	6619
6599	6620		let allocCtxReg = nextReg(self);
6600	6621		emitLoadW64At(self, allocCtxReg, allocReg, 8);
6601	6622
6602	6623		let byteSize = emitTypedBinOp(self, il::BinOp::Mul, il::Type::W32, newCapVal, il::Val::Imm(stride as i64));
6603		-	let args = try allocVals(self, 3);
6604	6624
6605		-	set args[0] = il::Val::Reg(allocCtxReg);
6606		-	set args[1] = byteSize;
6607		-	set args[2] = il::Val::Imm(alignment as i64);
	6625	+	let args = try allocVals(self, 4);
	6626	+
	6627	+	// The append result fits the allocation pointer and the shared error types.
	6628	+	set args[0] = il::Val::Reg(result);
	6629	+	set args[1] = il::Val::Reg(allocCtxReg);
	6630	+	set args[2] = byteSize;
	6631	+	set args[3] = il::Val::Imm(alignment as i64);
6608	6632
6609		-	let newPtrReg = nextReg(self);
6610	6633		emit(self, il::Instr::Call {
6611	6634		retTy: il::Type::W64,
6612		-	dst: newPtrReg,
	6635	+	dst: nil,
6613	6636		func: il::Val::Reg(allocFnReg),
6614	6637		args,
6615	6638		});
6616	6639
	6640	+	let tag = resultTagReg(self, result);
	6641	+	let copyBlock = try createBlock(self, "append.copy");
	6642	+	try emitBr(self, tag, doneBlock, copyBlock);
	6643	+
	6644	+	try switchToAndSeal(self, copyBlock);
	6645	+	let newPtrReg = nextReg(self);
	6646	+	emitLoadW64At(self, newPtrReg, result, RESULT_VAL_OFFSET);
	6647	+
6617	6648		// Copy old data byte-by-byte.
6618	6649		let oldPtrReg = loadSlicePtr(self, sliceReg);
6619	6650		let copyBytes = emitTypedBinOp(self, il::BinOp::Mul, il::Type::W32, lenVal, il::Val::Imm(stride as i64));
6620	6651		try emitByteCopyLoop(self, newPtrReg, oldPtrReg, copyBytes, "append");
6621	6652