radiance · commit

compiler/radiance.rad +15 -15

    let mut idx: u32 = 0;

    while idx < args.len {
        let arg = args[idx];
        if mem::eq(arg, "-pkg") {
            idx = idx + 1;
            idx += 1;
            if idx >= args.len {
                io::printError("radiance: `-pkg` requires a package name\n");
                throw Error::Other;
            }
            if pkgCount >= MAX_PACKAGES {
                io::printError("radiance: too many packages specified\n");
                throw Error::Other;
            }
            pkgNames[pkgCount] = args[idx];
            currentPkgIdx = pkgCount;
            pkgCount = pkgCount + 1;
            pkgCount += 1;
        } else if mem::eq(arg, "-mod") {
            idx = idx + 1;
            idx += 1;
            if idx >= args.len {
                io::printError("radiance: `-mod` requires a module path\n");
                throw Error::Other;
            }
            let pkgIdx = currentPkgIdx else {

            if moduleCounts[pkgIdx] >= MAX_LOADED_MODULES {
                io::printError("radiance: too many modules specified for package\n");
                throw Error::Other;
            }
            modulePaths[pkgIdx][moduleCounts[pkgIdx]] = args[idx];
            moduleCounts[pkgIdx] = moduleCounts[pkgIdx] + 1;
            moduleCounts[pkgIdx] += 1;
        } else if mem::eq(arg, "-entry") {
            idx = idx + 1;
            idx += 1;
            if idx >= args.len {
                io::printError("radiance: `-entry` requires a package name\n");
                throw Error::Other;
            }
            entryPkgName = args[idx];
        } else if mem::eq(arg, "-test") {
            buildTest = true;
        } else if mem::eq(arg, "-debug") {
            debugEnabled = true;
        } else if mem::eq(arg, "-o") {
            idx = idx + 1;
            idx += 1;
            if idx >= args.len {
                io::printError("radiance: `-o` requires an output path\n");
                throw Error::Other;
            }
            outputPath = args[idx];
        } else if mem::eq(arg, "-dump") {
            idx = idx + 1;
            idx += 1;
            if idx >= args.len {
                io::printError("radiance: `-dump` requires a mode (eg. ast)\n");
                throw Error::Other;
            }
            let mode = args[idx];

            io::printError("radiance: unknown argument `");
            io::printError(arg);
            io::printError("`\n");
            throw Error::Other;
        }
        idx = idx + 1;
        idx += 1;
    }
    if pkgCount == 0 {
        io::printError("radiance: no package specified\n");
        throw Error::Other;
    }

        let stmt = block.statements.list[i];
        if let case ast::NodeValue::FnDecl(decl) = stmt.value {
            if let fnName = getTestFnName(&decl) {
                if *testCount < tests.len {
                    tests[*testCount] = TestDesc { modPath, fnName };
                    *testCount = *testCount + 1;
                    *testCount += 1;
                } else {
                    panic "collectModuleTests: too many tests";
                }
            }
        }

        return;
    }
    let mut path: [u8; MAX_PATH_LEN] = undefined;
    let mut pos: u32 = 0;

    pos = pos + try! mem::copy(&mut path[pos..], basePath);
    pos = pos + try! mem::copy(&mut path[pos..], ext);
    pos += try! mem::copy(&mut path[pos..], basePath);
    pos += try! mem::copy(&mut path[pos..], ext);
    path[pos] = 0; // Null-terminate for syscall.

    if not unix::writeFile(&path[..pos], data) {
        io::printError("radiance: fatal: failed to write data file\n");
        throw Error::Other;

    for i in 0..entries.len {
        let entry = &entries[i];
        let modEntry = module::get(graph, entry.moduleId) else {
            panic "writeDebugInfo: module not found for debug entry";
        };
        pos = pos + try! mem::copy(&mut buf[pos..], @sliceOf(&entry.pc as *u8, 4));
        pos = pos + try! mem::copy(&mut buf[pos..], @sliceOf(&entry.offset as *u8, 4));
        pos = pos + try! mem::copy(&mut buf[pos..], modEntry.filePath);
        pos += try! mem::copy(&mut buf[pos..], @sliceOf(&entry.pc as *u8, 4));
        pos += try! mem::copy(&mut buf[pos..], @sliceOf(&entry.offset as *u8, 4));
        pos += try! mem::copy(&mut buf[pos..], modEntry.filePath);

        buf[pos] = 0;
        pos = pos + 1;
        pos += 1;
    }
    try writeDataWithExt(&buf[..pos], basePath, DEBUG_EXT);
}

/// Run the resolver on the parsed modules.

lib/std/arch/rv64.rad +9 -9

    for i in 0..program.data.len {
        let data = &program.data[i];
        if data.readOnly == readOnly and not data.isUndefined {
            offset = mem::alignUp(offset, data.alignment);
            syms[*count] = DataSym { name: data.name, addr: base + offset };
            *count = *count + 1;
            offset = offset + data.size;
            *count += 1;
            offset += data.size;
        }
    }
    // Uninitialized data after.
    for i in 0..program.data.len {
        let data = &program.data[i];
        if data.readOnly == readOnly and data.isUndefined {
            offset = mem::alignUp(offset, data.alignment);
            syms[*count] = DataSym { name: data.name, addr: base + offset };
            *count = *count + 1;
            offset = offset + data.size;
            *count += 1;
            offset += data.size;
        }
    }
    return offset;
}


                    match v.item {
                        case il::DataItem::Val { typ, val } => {
                            let size = il::typeSize(typ);
                            let valPtr = &val as *u8;
                            try! mem::copy(&mut buf[offset..], @sliceOf(valPtr, size));
                            offset = offset + size;
                            offset += size;
                        },
                        case il::DataItem::Sym(name) => {
                            let addr = lookupDataSymAddr(dataSyms, name) else {
                                panic "emitSection: data symbol not found";
                            };

                            let hiPtr = &hi as *u8;

                            try! mem::copy(&mut buf[offset..], @sliceOf(loPtr, 4));
                            try! mem::copy(&mut buf[(offset + 4)..], @sliceOf(hiPtr, 4));

                            offset = offset + 8;
                            offset += 8;
                        },
                        case il::DataItem::Fn(name) => {
                            let addr = codeBase + labels::funcOffset(fnLabels, name) as u32;
                            let lo: u32 = addr;
                            let hi: u32 = 0;

                            let hiPtr = &hi as *u8;

                            try! mem::copy(&mut buf[offset..], @sliceOf(loPtr, 4));
                            try! mem::copy(&mut buf[(offset + 4)..], @sliceOf(hiPtr, 4));

                            offset = offset + 8;
                            offset += 8;
                        },
                        case il::DataItem::Str(s) => {
                            try! mem::copy(&mut buf[offset..], s);
                            offset = offset + s.len;
                            offset += s.len;
                        },
                        case il::DataItem::Undef => {
                            buf[offset] = 0;
                            offset = offset + 1;
                            offset += 1;
                        },
                    }
                }
            }
        }

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

        if (usedCalleeSaved & (1 << i)) != 0 {
            frame.savedRegs[frame.savedRegsLen] = SavedReg {
                reg: super::CALLEE_SAVED[i],
                offset,
            };
            frame.savedRegsLen = frame.savedRegsLen + 1;
            offset = offset - super::DWORD_SIZE;
            frame.savedRegsLen += 1;
            offset -= super::DWORD_SIZE;
        }
    }
    return frame;
}


pub fn emit(e: *mut Emitter, instr: u32) {
    if e.codeLen >= e.code.len {
        panic "emit: code buffer full";
    }
    e.code[e.codeLen] = instr;
    e.codeLen = e.codeLen + 1;
    e.codeLen += 1;
}

/// Compute branch offset to a function by name.
pub fn branchOffsetToFunc(e: *Emitter, srcIndex: u32, name: *[u8]) -> i32 {
    return labels::branchToFunc(&e.labels, srcIndex, name, super::INSTR_SIZE);

pub fn recordFunc(e: *mut Emitter, name: *[u8]) {
    if e.funcsLen >= e.funcs.len {
        panic "recordFunc: funcs buffer full";
    }
    e.funcs[e.funcsLen] = FuncAddr { name, index: e.codeLen };
    e.funcsLen = e.funcsLen + 1;
    e.funcsLen += 1;
}

/// Record a local branch needing later patching.
/// Emits two placeholder instructions that will be patched later.
pub fn recordBranch(e: *mut Emitter, targetBlock: u32, kind: BranchKind) {

    e.pendingBranches[e.pendingBranchesLen] = PendingBranch {
        index: e.codeLen,
        target: targetBlock,
        kind: kind,
    };
    e.pendingBranchesLen = e.pendingBranchesLen + 1;
    e.pendingBranchesLen += 1;

    emit(e, encode::nop()); // Placeholder for branch/auipc.
    emit(e, encode::nop()); // Placeholder for nop/jal/jalr.
}


    }
    e.pendingCalls[e.pendingCallsLen] = PendingCall {
        index: e.codeLen,
        target,
    };
    e.pendingCallsLen = e.pendingCallsLen + 1;
    e.pendingCallsLen += 1;

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


    e.pendingAddrLoads[e.pendingAddrLoadsLen] = PendingAddrLoad {
        index: e.codeLen,
        target,
        rd: rd,
    };
    e.pendingAddrLoadsLen = e.pendingAddrLoadsLen + 1;
    e.pendingAddrLoadsLen += 1;

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


    let lo = imm & 0xFFF;
    let mut hi = (imm >> 12) & 0xFFFFF;
    // If `lo`'s sign bit is set, it will be sign-extended to negative.
    // Compensate by incrementing `hi`.
    if (lo & 0x800) != 0 {
        hi = hi + 1;
        hi += 1;
        return SplitImm { hi, lo: lo | 0xFFFFF000 as i32 };
    }
    return SplitImm { hi, lo };
}


    e.debugEntries[e.debugEntriesLen] = DebugEntry {
        pc,
        moduleId: loc.moduleId,
        offset: loc.offset,
    };
    e.debugEntriesLen = e.debugEntriesLen + 1;
    e.debugEntriesLen += 1;
}

/// Get debug entries as a slice.
pub fn getDebugEntries(e: *Emitter) -> *[DebugEntry] {
    return &e.debugEntries[..e.debugEntriesLen];

lib/std/arch/rv64/isel.rad +11 -11

        for i in 0..block.instrs.len {
            match block.instrs.list[i] {
                case il::Instr::Reserve { size, alignment, .. } => {
                    if let case il::Val::Imm(sz) = size {
                        offset = mem::alignUpI32(offset, alignment as i32);
                        offset = offset + (sz as i32);
                        offset += (sz as i32);
                    }
                },
                else => {},
            }
        }

                    emit::emitLd(s.e, super::SCRATCH1, super::SCRATCH1, offset);
                } else {
                    emit::emitLd(s.e, super::SCRATCH1, rsrc, offset);
                }
                emit::emitSd(s.e, super::SCRATCH1, rdst, offset);
                offset = offset + super::DWORD_SIZE;
                remaining = remaining - super::DWORD_SIZE;
                offset += super::DWORD_SIZE;
                remaining -= super::DWORD_SIZE;
            }
            if remaining >= super::WORD_SIZE {
                if offset > super::MAX_IMM - super::WORD_SIZE {
                    emit::emitAddImm(s.e, rsrc, rsrc, offset);
                    if rdst.n != rsrc.n {

                    emit::emitLw(s.e, super::SCRATCH1, super::SCRATCH1, offset);
                } else {
                    emit::emitLw(s.e, super::SCRATCH1, rsrc, offset);
                }
                emit::emitSw(s.e, super::SCRATCH1, rdst, offset);
                offset = offset + super::WORD_SIZE;
                remaining = remaining - super::WORD_SIZE;
                offset += super::WORD_SIZE;
                remaining -= super::WORD_SIZE;
            }
            while remaining > 0 {
                if offset > super::MAX_IMM - 1 {
                    emit::emitAddImm(s.e, rsrc, rsrc, offset);
                    if rdst.n != rsrc.n {

                    emit::emitLb(s.e, super::SCRATCH1, super::SCRATCH1, offset);
                } else {
                    emit::emitLb(s.e, super::SCRATCH1, rsrc, offset);
                }
                emit::emitSb(s.e, super::SCRATCH1, rdst, offset);
                offset = offset + 1;
                remaining = remaining - 1;
                offset += 1;
                remaining -= 1;
            }
            // Restore base registers if they were advanced (never happens
            // in the both-spilled case since size <= MAX_IMM).
            if not bothSpilled {
                let advanced = size as i32 - offset;

            match args[i] {
                case il::Val::Reg(r) => {
                    if let _ = regalloc::spill::spillSlot(&s.ralloc.spill, r) {
                        // Spilled value needs load, not a register move.
                        pending[i] = true;
                        numPending = numPending + 1;
                        numPending += 1;
                    } else {
                        let src = getReg(s, r);
                        if src != dst {
                            // Register-to-register move needed.
                            srcRegs[i] = src;
                            isRegMove[i] = true;
                            pending[i] = true;
                            numPending = numPending + 1;
                            numPending += 1;
                        } else {
                            // No move needed.
                        }
                    }
                },
                case il::Val::Imm(_), il::Val::DataSym(_), il::Val::FnAddr(_) => {
                    pending[i] = true;
                    numPending = numPending + 1;
                    numPending += 1;
                },
                case il::Val::Undef => {
                    // Undefined values don't need any move.
                }
            }

                        // Load immediate, symbol, or spilled value.
                        loadVal(s, dst, args[i]);
                    }
                    found = true;
                    pending[i] = false;
                    numPending = numPending - 1;
                    numPending -= 1;

                    break;
                }
            }
        }

lib/std/arch/rv64/printer.rad +1 -1

fn writeMnem(out: *mut sexpr::Output, m: *[u8]) {
    write(out, m);
    let mut i = m.len;
    while i < MNEMONIC_WIDTH {
        write(out, " ");
        i = i + 1;
        i += 1;
    }
}

////////////////////////////////
// Instruction Format Helpers //

lib/std/arch/rv64/tests/aggregate.return.rad +2 -2

fn testAggregateReturnInLoop() -> i32 {
    let mut total: u32 = 0;
    let mut idx: u32 = 0;
    while idx < 5 {
        let p: Pair = makePair(idx, idx + 10);
        total = total + p.a + p.b;
        idx = idx + 1;
        total += p.a + p.b;
        idx += 1;
    }
    // total = sum(i + i+10 for i in 0..5) = sum(2i+10) = 2*(0+1+2+3+4) + 50 = 20 + 50 = 70
    if total != 70 {
        return 1;
    }

lib/std/arch/rv64/tests/arith.assignment.rad +7 -7

6	6
7	7		// Test addition.
8	8		c = a + b; // c = 9
9	9
10	10		// Test subtraction.
11		-	c = c - b; // c = 6
	11	+	c -= b; // c = 6
12	12
13	13		// Test multiplication.
14		-	c = c * b; // c = 18
	14	+	c *= b; // c = 18
15	15
16	16		// Test division.
17		-	c = c / b; // c = 6
	17	+	c /= b; // c = 6
18	18
19	19		// Test mixed operations.
20	20		d = a * b + c / b; // d = 18 + 2 = 20
21		-	d = d + a * b / a; // d = 20 + 3 = 23
22		-	d = d + (b * a - c); // d = 23 + (18 - 6) = 35
23		-	d = d + (c - a / b); // d = 35 + (6 - 2) = 39
24		-	d = d + 3; // d = 42
	21	+	d += a * b / a; // d = 20 + 3 = 23
	22	+	d += (b * a - c); // d = 23 + (18 - 6) = 35
	23	+	d += (c - a / b); // d = 35 + (6 - 2) = 39
	24	+	d += 3; // d = 42
25	25
26	26		return (d) - 42;
27	27		}

lib/std/arch/rv64/tests/array.index.assign.rad +5 -5

    arr[3] = 40;
    arr[4] = 50;

    let mut sum: i32 = 0;

    sum = sum + arr[0];
    sum = sum + arr[1];
    sum = sum + arr[2];
    sum = sum + arr[3];
    sum = sum - arr[4];
    sum += arr[0];
    sum += arr[1];
    sum += arr[2];
    sum += arr[3];
    sum -= arr[4];

    if sum != 50 {
        return 1;
    }
    return 0;

lib/std/arch/rv64/tests/array.index.rad +4 -4


@default fn main() -> i32 {
    let mut arr: [i32; 4] = [10, 20, 30, 40];
    let mut sum: i32 = 0;

    sum = sum + arr[0];
    sum = sum + arr[1];
    sum = sum + arr[2];
    sum = sum + arr[3];
    sum += arr[0];
    sum += arr[1];
    sum += arr[2];
    sum += arr[3];

    return (sum) - 100;
}

lib/std/arch/rv64/tests/array.length.rad +2 -2

    let mut ary: [i32; 7] = [1, 2, 3, 4, 5, 6, 7];
    let mut sum: i32 = 0;
    let mut i: u32 = 0;

    while (i < ary.len) {
        sum = sum + ary[i];
        i = i + 1;
        sum += ary[i];
        i += 1;
    }
    return (sum) - 28;
}

lib/std/arch/rv64/tests/array.math.rad +4 -4


fn sumMatrix(mat: [[i32; 3]; 2]) -> i32 {
    let mut sum: i32 = 0;
    for vec in mat {
        for x in vec {
            sum = sum + x;
            sum += x;
        }
    }
    return sum;
}

fn sumMatrixTransposed(mat: [[i32; 2]; 3]) -> i32 {
    let mut sum: i32 = 0;
    for vec in (mat) {
        for x in (vec) {
            sum = sum + x;
            sum += x;
        }
    }
    return sum;
}



    while (i < matrix.len) {
        let mut j: u32 = 0;
        while (j < matrix[i].len) {
            result[j][i] = matrix[i][j];
            j = j + 1;
            j += 1;
        }
        i = i + 1;
        i += 1;
    }
    return result;
}

@default fn main() -> i32 {

lib/std/arch/rv64/tests/array.record.elements.rad +5 -5

fn sumPoints(points: [Point; 4]) -> i32 {
    let mut sum: i32 = 0;
    let mut i: u32 = 0;

    while (i < 4) {
        sum = sum + points[i].x + points[i].y;
        i = i + 1;
        sum += points[i].x + points[i].y;
        i += 1;
    }
    return sum;
}

fn shiftPoints(points: [Point; 4], dx: i32, dy: i32) -> [Point; 4] {

41	41		while (i < 4) {
42	42		result[i] = Point {
43	43		x: points[i].x + dx,
44	44		y: points[i].y + dy
45	45		};
46		-	i = i + 1;
	46	+	i += 1;
47	47		}
48	48		return result;
49	49		}
50	50
51	51		@default fn main() -> i32 {

    let mut shifted: [Point; 4] = shiftPoints(points, 1, 1);
    // Calculate distance between original and shifted array elements.
    let mut distance: i32 = 0;
    let mut i: u32 = 0;
    while (i < points.len) {
        distance = distance + calculateDistance(points[i], shifted[i]);
        i = i + 1;
        distance += calculateDistance(points[i], shifted[i]);
        i += 1;
    }
    return total + distance + shifted[3].x - points[0].y;
}

lib/std/arch/rv64/tests/assign.mutable.rad +5 -5

fn testBasicAliasing() -> i32 {
    let mut x: i32 = 10;
    let mut y: i32 = x;  // y aliases x's value

    x = 20;          // Modify x
    y = y + 5;       // Modify y independently
    y += 5;       // Modify y independently

    return x + y;    // Should be 20 + 15 = 35
}

/// Struct aliasing and field mutation.

    let mut result: i32 = 0;
    let mut temp: i32 = 10;
    result = temp;      // First assignment

    temp = 20;          // Overwrite temp
    result = result + temp; // result = 10 + 20 = 30
    result += temp; // result = 10 + 20 = 30

    // Create new scope with same variable name
    if true {
        let mut temp: i32 = 50;   // Shadow outer temp
        result = result + temp; // result = 30 + 50 = 80
        result += temp; // result = 30 + 50 = 80
        temp = 60;        // Modify inner temp
        result = result + temp; // result = 80 + 60 = 140
        result += temp; // result = 80 + 60 = 140
    }
    result = result + temp;   // Should use outer temp (20)
    result += temp;   // Should use outer temp (20)

    return result;            // 140 + 20 = 160
}

/// Array of structs with aliasing.

lib/std/arch/rv64/tests/assign.rad +3 -3

1	1		@default fn main() -> i32 {
2	2		let mut i: i32 = 36;
3		-	i = i + 1; // 37
4		-	i = i + 2; // 39
5		-	i = i + 3; // 42
	3	+	i += 1; // 37
	4	+	i += 2; // 39
	5	+	i += 3; // 42
6	6
7	7		return i - 42;
8	8		}

lib/std/arch/rv64/tests/assign.shadow.mutable.rad +4 -4

    let mut result: i32 = 0;
    let mut temp: i32 = 10;
    result = temp;

    temp = 20;
    result = result + temp;
    result += temp;

    if true {
        let mut temp: i32 = 50;
        result = result + temp;
        result += temp;
        temp = 60;
        result = result + temp;
        result += temp;
    }
    // Must refer to outer `temp` (20), not inner shadowed `temp` (60).
    result = result + temp;
    result += temp;

    return result;
}

@default fn main() -> i32 {

lib/std/arch/rv64/tests/bool.short.circuit.rad +1 -1

//! Test short-circuiting behavior of 'and' and 'or' operators.
fn modify(counter: *mut i32, ret: bool) -> bool {
    *counter = *counter + 1;
    *counter += 1;
    return ret;
}

@default fn main() -> i32 {
    // Test 'and' short-circuits when first operand is false.

lib/std/arch/rv64/tests/builtin.sliceof.mut.rad +8 -8


    // Create a mutable slice from the pointer and length
    let slice: *mut [i32] = @sliceOf(ptr, 4);

    // Double each element via the slice
    slice[0] = slice[0] * 2;
    slice[1] = slice[1] * 2;
    slice[2] = slice[2] * 2;
    slice[3] = slice[3] * 2;
    slice[0] *= 2;
    slice[1] *= 2;
    slice[2] *= 2;
    slice[3] *= 2;

    // Sum the modified elements
    let mut sum: i32 = 0;
    sum = sum + slice[0];
    sum = sum + slice[1];
    sum = sum + slice[2];
    sum = sum + slice[3];
    sum += slice[0];
    sum += slice[1];
    sum += slice[2];
    sum += slice[3];

    return (sum) - 200;
}

lib/std/arch/rv64/tests/builtin.sliceof.rad +4 -4

    // Create a slice from the pointer and length
    let slice: *[i32] = @sliceOf(ptr, 4);

    // Access elements via the slice and sum them
    let mut sum: i32 = 0;
    sum = sum + slice[0];
    sum = sum + slice[1];
    sum = sum + slice[2];
    sum = sum + slice[3];
    sum += slice[0];
    sum += slice[1];
    sum += slice[2];
    sum += slice[3];

    return sum;
}

lib/std/arch/rv64/tests/call.clobber.rad +1 -1

//! Test that values live across function calls are not clobbered.
fn modify(counter: *mut i32, ret: bool) -> bool {
    *counter = *counter + 1;
    *counter += 1;
    return ret;
}

@default fn main() -> i32 {
    let mut x: i32 = 0;

lib/std/arch/rv64/tests/cond.for.else.break.rad +2 -2

@default fn main() -> i32 {
    let mut i: i32 = 0;
    let xs: [i32; 7] = [1, 2, 3, 4, 5, 6, 7];

    for x in (xs) {
        i = i + x;
        i += x;
        if (i >= 10) {
            break; // This should skip the else clause.
        }
    } else {
        i = i + 100; // This should NOT run because we break.
        i += 100; // This should NOT run because we break.
    }
    return (i) - 10;
}

lib/std/arch/rv64/tests/cond.for.indexed.rad +1 -1

@default fn main() -> u32 {
    let arr: [u32; 3] = [10, 20, 30];
    let mut sum: u32 = 0;

    for value, index in arr {
        sum = sum + value + index;
        sum += value + index;
    }
    return (sum) - 63;
    //  (10+0) + (20+1) + (30+2) = 10 + 21 + 32 = 63
}

lib/std/arch/rv64/tests/cond.for.rad +1 -1

2	2		@default fn main() -> i32 {
3	3		let mut i: i32 = 0;
4	4		let xs: [i32; 7] = [1, 2, 3, 4, 5, 6, 7];
5	5
6	6		for x in (xs) {
7		-	i = i + x;
	7	+	i += x;
8	8		}
9	9		return (i) - 28;
10	10		}

lib/std/arch/rv64/tests/cond.for.range.indexed.rad +2 -2

5	5		// Test range iteration with index.
6	6		// val: 5, 6, 7, 8
7	7		// idx: 0, 1, 2, 3
8	8		// sum: (5+0) + (6+1) + (7+2) + (8+3) = 5 + 7 + 9 + 11 = 32
9	9		for val, idx in 5..9 {
10		-	sum = sum + val + idx as i32;
	10	+	sum += val + idx as i32;
11	11		}
12	12
13	13		// Test that value starts from a non-zero offset while index starts at 0.
14	14		// val: 10, 11
15	15		// idx: 0, 1
16	16		// sum: 32 + (10-0) + (11-1) = 32 + 10 + 10 = 52
17	17		for v, i in 10..12 {
18		-	sum = sum + v - i as i32;
	18	+	sum += v - i as i32;
19	19		}
20	20
21	21		return (sum) - 52;
22	22		}

lib/std/arch/rv64/tests/cond.for.range.rad +1 -1

2	2		@default fn main() -> i32 {
3	3		let xs: [i32; 4] = [3, 4, 5, 6];
4	4		let mut sum: i32 = 0;
5	5
6	6		for i in 0..xs.len {
7		-	sum = sum + xs[i];
	7	+	sum += xs[i];
8	8		}
9	9		return (sum) - 18;
10	10		}

lib/std/arch/rv64/tests/cond.for.unsigned.range.rad +3 -3

    let start: u32 = 2147483647;
    let end: u32 = 2147483648;
    let mut count: i32 = 0;

    for i in start..end {
        count = count + 1;
        count += 1;
    }
    if count != 1 {
        return 1;
    }


    let start2: u32 = 2147483648;
    let end2: u32 = 2147483651;
    let mut count2: i32 = 0;

    for i in start2..end2 {
        count2 = count2 + 1;
        count2 += 1;
    }
    if count2 != 3 {
        return 2;
    }

    // Signed range still uses signed ordering.
    let mut sum: i32 = 0;
    for i in -2..2 {
        sum = sum + i;
        sum += i;
    }
    if sum != -2 {
        return 3;
    }


lib/std/arch/rv64/tests/cond.forever.break.continue.rad +1 -1

@default fn main() -> i32 {
    let mut i: i32 = 0;

    loop {
        if (i < 42) {
            i = i + 1;
            i += 1;
            continue;
        }
        break;
    }
    return (i) - 42;

lib/std/arch/rv64/tests/cond.forever.break.rad +2 -2

4	4		loop {
5	5		loop {
6	6		if (i > 39) {
7	7		break;
8	8		}
9		-	i = i + 1;
	9	+	i += 1;
10	10		}
11		-	i = i + 2;
	11	+	i += 2;
12	12		break;
13	13		}
14	14		return (i) - 42;
15	15		}

lib/std/arch/rv64/tests/cond.if.else.rad +1 -1

2	2		let mut i: i32 = 41;
3	3
4	4		if (i == 42) {
5	5		return (1) - 42;
6	6		} else {
7		-	i = i + 1;
	7	+	i += 1;
8	8		}
9	9
10	10		if (i == 42) {
11	11		return (42) - 42;
12	12		} else {

lib/std/arch/rv64/tests/cond.if.elseif.rad +2 -2

4	4		if (i == 42) {
5	5		return (1) - 42;
6	6		} else if (i == 41) {
7	7		return (1) - 42;
8	8		} else if (i == 40) {
9		-	i = i + 2;
	9	+	i += 2;
10	10		} else {
11		-	i = i + 1;
	11	+	i += 1;
12	12		}
13	13
14	14		if (i == 42) {
15	15		return (42) - 42;
16	16		} else if (i == 41) {

lib/std/arch/rv64/tests/cond.while.else.break.rad +2 -2


@default fn main() -> i32 {
    let mut i: i32 = 0;

    while (i < 100) {
        i = i + 1;
        i += 1;
        if (i == 42) {
            break; // This should skip the else clause.
        }
    } else {
        i = i + 100; // This should NOT run because we break.
        i += 100; // This should NOT run because we break.
    }
    return (i) - 42;
}

lib/std/arch/rv64/tests/cond.while.rad +1 -1

1	1		@default fn main() -> i32 {
2	2		let mut i: i32 = 0;
3	3
4	4		while (i < 42) {
5		-	i = i + 1;
	5	+	i += 1;
6	6		}
7	7		return (i) - 42;
8	8		}

lib/std/arch/rv64/tests/const.array.copy.mutate.rad +1 -1

const SEED: [i32; 4] = [1, 2, 3, 4];

fn crunch() -> i32 {
    let mut working: [i32; 4] = SEED;

    working[0] = working[0] + 5;
    working[0] += 5;
    working[3] = working[1] + working[2];

    return working[0] + working[3];
}


lib/std/arch/rv64/tests/const.array.rad +1 -1

const NUMBERS: [i32; 4] = [1, 2, 3, 4];

@default fn main() -> i32 {
    let mut sum: i32 = 0;
    for n in (NUMBERS) {
        sum = sum + n;
        sum += n;
    }
    return (sum) - 10;
}

lib/std/arch/rv64/tests/const.record.array.rad +1 -1


fn sumPoints(points: [Point; 3]) -> i32 {
    let mut sum: i32 = 0;

    for p in (points) {
        sum = sum + p.x + p.y;
        sum += p.x + p.y;
    }
    return sum;
}

// Array of structs as a function parameter

lib/std/arch/rv64/tests/const.record.array.simple.rad +3 -3

14	14
15	15		@default fn main() -> i32 {
16	16		let mut sum: i32 = 0;
17	17
18	18		// Add all points' x and y values
19		-	sum = sum + POINTS[0].x + POINTS[0].y; // 1 + 2 = 3
20		-	sum = sum + POINTS[1].x + POINTS[1].y; // 3 + 4 = 7
21		-	sum = sum + POINTS[2].x + POINTS[2].y; // 5 + 6 = 11
	19	+	sum += POINTS[0].x + POINTS[0].y; // 1 + 2 = 3
	20	+	sum += POINTS[1].x + POINTS[1].y; // 3 + 4 = 7
	21	+	sum += POINTS[2].x + POINTS[2].y; // 5 + 6 = 11
22	22
23	23		return (sum) - 21; // 3 + 7 + 11 = 21
24	24		}

lib/std/arch/rv64/tests/error.try.optional.rad +2 -2


    // Test 7: try? in while-let loop
    let mut count: u32 = 0;
    let mut iter: u32 = 0;
    while let value = try? maybeValue(iter) {
        count = count + value;
        iter = iter + 1;
        count += value;
        iter += 1;
    }
    if count != 6 {
        return 13;
    }


lib/std/arch/rv64/tests/error.try.rad +7 -7


fn shortCircuit(flag: bool) -> u32 throws (TestError) {
    let mut counter: u32 = 1;

    if flag {
        counter = counter + try returnsErr(2);
        counter += try returnsErr(2);
    } else {
        try returnsErr(0);
        counter = counter + 100;
        counter += 100;
    }
    return counter;
}

fn aggregateTwo() -> u32 throws (TestError) {

    let mut total: u32 = 0;
    let mut idx: u32 = 0;
    while idx < 3 {
        if failMid {
            if idx == 1 {
                total = total + try returnsErr(0);
                total += try returnsErr(0);
            } else {
                total = total + try returnsErr(2);
                total += try returnsErr(2);
            }
        } else {
            total = total + try returnsErr(2);
            total += try returnsErr(2);
        }
        idx = idx + 1;
        idx += 1;
    }
    return total;
}

fn structSuccess(state: *mut ResultSink) -> u32 throws (TestError) {
    let value: u32 = try returnsOk();
    state.last = value;
    state.count = state.count + 1;
    state.count += 1;
    return value;
}

fn structFailure(state: *mut ResultSink) -> u32 throws (TestError) {
    try returnsErr(1);

lib/std/arch/rv64/tests/loop.complex.flow.rad +2 -2

        match result {
            case Result::Ok(v) => {
                sum = v;
            },
            case Result::Err(e) => {
                errCount = errCount + 1;
                errCount += 1;
            },
        }
        i = i + 1;
        i += 1;
    }

    // val sequence: -2, -1, 0, 1, 2, 3
    // Err for val <= 0: errCount = 3 (for -2, -1, 0)
    // Ok for val > 0: sum = 0 + 1 + 2 + 3 = 6

lib/std/arch/rv64/tests/loop.sealblock.rad +4 -4

@default fn main() -> i32 {
    // Simple loop with mutable variable.
    let mut sum: i32 = 0;
    let mut i: i32 = 0;
    while i < 5 {
        sum = sum + i;
        i = i + 1;
        sum += i;
        i += 1;
    }
    // sum = 0 + 1 + 2 + 3 + 4 = 10
    if sum != 10 {
        return 1;
    }

    // For loop with mutable variable.
    let mut count: i32 = 0;
    for j in 0..4 {
        count = count + 1;
        count += 1;
    }
    if count != 4 {
        return 2;
    }

    // Nested pattern: mutable var with function call in loop.
    let mut total: i32 = 0;
    for k in 0..3 {
        total = total + addOne(k);
        total += addOne(k);
    }
    // total = 1 + 2 + 3 = 6
    if total != 6 {
        return 3;
    }

lib/std/arch/rv64/tests/match.mutref.push.rad +1 -1

    Yes,
}

fn pushItem(list: *mut U32List, value: u32) {
    list.data[list.len] = value;
    list.len = list.len + 1;
    list.len += 1;
}

fn addToUnsealedBlock(state: *mut Sealed, value: u32) -> bool {
    match state {
        case Sealed::No { items } => {

lib/std/arch/rv64/tests/mutref.loop.bug.rad +3 -3

fn testZeroIter(n: u32) -> u32 {
    let mut val: u32 = 42;
    let mut i: u32 = 0;
    while i < n {
        set(&mut val, val + 1);
        i = i + 1;
        i += 1;
    }
    return val;
}

/// Multiple iterations: accumulate via &mut pointer in a loop.
fn testMultiIter() -> u32 {
    let mut acc: u32 = 0;
    let mut i: u32 = 0;
    while i < 5 {
        set(&mut acc, acc + i);
        i = i + 1;
        i += 1;
    }
    return acc;
}

/// Multiple address-taken variables in the same loop.

44	44		let mut b: u32 = 100;
45	45		let mut i: u32 = 0;
46	46		while i < 3 {
47	47		set(&mut a, a + 1);
48	48		set(&mut b, b - 1);
49		-	i = i + 1;
	49	+	i += 1;
50	50		}
51	51		return a + b;
52	52		}
53	53
54	54		@default fn main() -> i32 {

lib/std/arch/rv64/tests/opt.record.rad +1 -1

        return 0;
    }

    let wrapper = Wrapper { opt: 7 };
    if let value = wrapper.opt {
        total = total + value;
        total += value;
    } else {
        return 0;
    }

    let call = take_optional(9);

lib/std/arch/rv64/tests/opt.while.let.complex.rad +1 -1

@default fn main() -> i32 {
    let mut cur: u32 = 7;
    let mut sum: u32 = 0;

    while let x = decr(cur); x > 1 {
        sum = sum + x;
        sum += x;
        cur = x;
    }

    // sum should be 6 + 5 + 4 + 3 + 2 = 20
    if sum != 20 {

lib/std/arch/rv64/tests/placeholder.comprehensive.rad +1 -1


    // Test 4: for loop with placeholder for value
    let arr: [i32; 3] = [1, 2, 3];
    let mut count: i32 = 0;
    for _ in &arr[..] {
        count = count + 1;
        count += 1;
    }
    if count != 3 {
        return 3;
    }
    return 0;

lib/std/arch/rv64/tests/prog.ackermann.rad +13 -13

    if m == 3 {
        // 2^(n+3) - 3
        let mut power: i32 = 1;
        let mut i: u32 = 0;
        while i < n + 3 {
            power = power * 2;
            i = i + 1;
            power *= 2;
            i += 1;
        }
        return power - 3;
    }
    // For m >= 4, fall back to recursion (only safe for very small n).
    if n == 0 {

/// Power of 2 helper.
fn pow2(exp: u32) -> i32 {
    let mut result: i32 = 1;
    let mut i: u32 = 0;
    while i < exp {
        result = result * 2;
        i = i + 1;
        result *= 2;
        i += 1;
    }
    return result;
}

/// Test known small values using the recursive implementation.

124	124		while n < 50 {
125	125		let expected: i32 = n as i32 + 1;
126	126		if ackMemo(0, n) != expected {
127	127		return 1;
128	128		}
129		-	n = n + 1;
	129	+	n += 1;
130	130		}
131	131
132	132		// Verify m=1 row.
133	133		n = 0;
134	134		while n < 50 {
135	135		let expected: i32 = n as i32 + 2;
136	136		if ackMemo(1, n) != expected {
137	137		return 2;
138	138		}
139		-	n = n + 1;
	139	+	n += 1;
140	140		}
141	141
142	142		// Verify m=2 row.
143	143		n = 0;
144	144		while n < 50 {
145	145		let expected: i32 = (2 * n + 3) as i32;
146	146		if ackMemo(2, n) != expected {
147	147		return 3;
148	148		}
149		-	n = n + 1;
	149	+	n += 1;
150	150		}
151	151
152	152		// Verify m=3 row for small n.
153	153		// A(3,0)=5, A(3,1)=13, A(3,2)=29, A(3,3)=61, A(3,4)=125
154	154		if ackMemo(3, 0) != 5 {

            let r: i32 = ack(m, n);
            let memoR: i32 = ackMemo(m, n);
            if r != memoR {
                return (m * 20 + n) as i32 + 1;
            }
            n = n + 1;
            n += 1;
        }
        m = m + 1;
        m += 1;
    }
    return 0;
}

/// Test the Ackermann inverse property: A(m, n) > n for all m, n.

214	214		// A(m, n) < A(m, n+1) (strictly increasing in n).
215	215		let valNext: i32 = ackMemo(m, n + 1);
216	216		if valNext <= val {
217	217		return 2;
218	218		}
219		-	n = n + 1;
	219	+	n += 1;
220	220		}
221		-	m = m + 1;
	221	+	m += 1;
222	222		}
223	223
224	224		// A(m, n) < A(m+1, n) (strictly increasing in m).
225	225		let mut m2: u32 = 0;
226	226		while m2 < 3 {

229	229		let lower: i32 = ackMemo(m2, n2);
230	230		let upper: i32 = ackMemo(m2 + 1, n2);
231	231		if upper <= lower {
232	232		return 3;
233	233		}
234		-	n2 = n2 + 1;
	234	+	n2 += 1;
235	235		}
236		-	m2 = m2 + 1;
	236	+	m2 += 1;
237	237		}
238	238
239	239		return 0;
240	240		}
241	241

lib/std/arch/rv64/tests/prog.bignum.rad +14 -14

fn bnFromU32(dst: *mut [u32], val: u32) {
    dst[0] = val;
    let mut i: u32 = 1;
    while i < LIMBS {
        dst[i] = 0;
        i = i + 1;
        i += 1;
    }
}

/// Set a big number to zero.
fn bnZero(dst: *mut [u32]) {
    let mut i: u32 = 0;
    while i < LIMBS {
        dst[i] = 0;
        i = i + 1;
        i += 1;
    }
}

/// Copy src to dst.
fn bnCopy(dst: *mut [u32], src: *[u32]) {
    let mut i: u32 = 0;
    while i < LIMBS {
        dst[i] = src[i];
        i = i + 1;
        i += 1;
    }
}

/// Compare two big numbers. Returns 0 if equal, 1 if a > b, -1 if a < b.
fn bnCmp(a: *[u32], b: *[u32]) -> i32 {

            return -1;
        }
        if i == 0 {
            break;
        }
        i = i - 1;
        i -= 1;
    }
    return 0;
}

/// Add two big numbers: dst = a + b. Returns carry (0 or 1).

        if sum < sumLo {
            carry2 = 1;
        }
        dst[i] = sum;
        carry = carry1 + carry2;
        i = i + 1;
        i += 1;
    }
    return carry;
}

/// Subtract two big numbers: dst = a - b. Returns borrow (0 or 1).

        if result > diff {
            borrow2 = 1;
        }
        dst[i] = result;
        borrow = borrow1 + borrow2;
        i = i + 1;
        i += 1;
    }
    return borrow;
}

/// Multiply two LIMBS-word numbers, producing a 2*LIMBS-word result in wide.
fn bnMul(wide: *mut [u32], a: *[u32], b: *[u32]) {
    let mut i: u32 = 0;
    while i < LIMBS * 2 {
        wide[i] = 0;
        i = i + 1;
        i += 1;
    }

    i = 0;
    while i < LIMBS {
        let mut carry: u32 = 0;

                c2 = 1;
            }
            wide[i + j] = sum2;
            carry = hi + c1 + c2;

            j = j + 1;
            j += 1;
        }
        wide[i + LIMBS] = wide[i + LIMBS] + carry;
        i = i + 1;
        wide[i + LIMBS] += carry;
        i += 1;
    }
}

/// Left shift a big number by 1 bit.
fn bnShl1(dst: *mut [u32], src: *[u32]) {

    let mut i: u32 = 0;
    while i < LIMBS {
        let newCarry: u32 = src[i] >> 31;
        dst[i] = (src[i] << 1) | carry;
        carry = newCarry;
        i = i + 1;
        i += 1;
    }
}

/// Right shift a big number by 1 bit.
fn bnShr1(dst: *mut [u32], src: *[u32]) {
    let mut carry: u32 = 0;
    let mut i: u32 = LIMBS;
    while i > 0 {
        i = i - 1;
        i -= 1;
        let newCarry: u32 = src[i] & 1;
        dst[i] = (src[i] >> 1) | (carry << 31);
        carry = newCarry;
    }
}

    let mut i: u32 = 2;
    while i <= 48 {
        bnAdd(&mut fibC[..], &fibA[..], &fibB[..]);
        bnCopy(&mut fibA[..], &fibB[..]);
        bnCopy(&mut fibB[..], &fibC[..]);
        i = i + 1;
        i += 1;
    }

    if fibB[0] != 0x1E8D0A40 {
        return 1;
    }

407	407		i = 2;
408	408		while i <= 47 {
409	409		bnAdd(&mut fc[..], &fa[..], &fb[..]);
410	410		bnCopy(&mut fa[..], &fb[..]);
411	411		bnCopy(&mut fb[..], &fc[..]);
412		-	i = i + 1;
	412	+	i += 1;
413	413		}
414	414		bnAdd(&mut fc[..], &fa[..], &fb[..]);
415	415		if bnCmp(&fc[..], &fibB[..]) != 0 {
416	416		return 3;
417	417		}

lib/std/arch/rv64/tests/prog.bubblesort.rad +3 -3

                let tmp: i32 = data[i];
                data[i] = data[i + 1];
                data[i + 1] = tmp;
                swapped = true;
            }
            i = i + 1;
            i += 1;
        }
        if not swapped {
            // Already sorted, early exit.
            return;
        }
        n = n - 1;
        n -= 1;
    }
}

/// Verify the array is sorted in ascending order.
fn isSorted(data: *[i32]) -> bool {


/// Compute the sum of all elements.
fn sum(data: *[i32]) -> i32 {
    let mut total: i32 = 0;
    for val in data {
        total = total + val;
        total += val;
    }
    return total;
}

/// Verify specific positions in the sorted output.

lib/std/arch/rv64/tests/prog.cordic.rad +11 -11

37	37		while i < ITERATIONS {
38	38		let dx: i32 = x >> i as i32;
39	39		let dy: i32 = y >> i as i32;
40	40
41	41		if z >= 0 {
42		-	x = x - dy;
43		-	y = y + dx;
44		-	z = z - atanTable[i];
	42	+	x -= dy;
	43	+	y += dx;
	44	+	z -= atanTable[i];
45	45		} else {
46		-	x = x + dy;
47		-	y = y - dx;
48		-	z = z + atanTable[i];
	46	+	x += dy;
	47	+	y -= dx;
	48	+	z += atanTable[i];
49	49		}
50		-	i = i + 1;
	50	+	i += 1;
51	51		}
52	52
53	53		return CosSin { cos: x, sin: y };
54	54		}
55	55

57	57		fn cosSin(angle: i32, atanTable: *[i32]) -> CosSin {
58	58		let mut a: i32 = angle;
59	59
60	60		// Reduce to [-pi, pi].
61	61		while a > PI {
62		-	a = a - 2 * PI;
	62	+	a -= 2 * PI;
63	63		}
64	64		while a < 0 - PI {
65		-	a = a + 2 * PI;
	65	+	a += 2 * PI;
66	66		}
67	67
68	68		// If in [pi/2, pi], use cos(a) = -cos(pi-a), sin(a) = sin(pi-a).
69	69		if a > HALF_PI {
70	70		let r: CosSin = cordicRotate(PI - a, atanTable);


        // Allow ~2% error due to fixed-point precision.
        if err > 1311 {
            return 1;
        }
        i = i + step;
        i += step;
    }
    return 0;
}

/// Test symmetry: sin(-x) = -sin(x), cos(-x) = cos(x).

        }
        // sin(-x) should equal -sin(x).
        if abs(rPos.sin + rNeg.sin) > 655 {
            return 2;
        }
        i = i + 1;
        i += 1;
    }
    return 0;
}

/// Test specific known value: cos(pi/3) = 0.5, sin(pi/3) = 0.866.

lib/std/arch/rv64/tests/prog.crc32.rad +5 -5

10	10		let mut j: u32 = 0;
11	11		while j < 8 {
12	12		if crc & 1 == 1 {
13	13		crc = (crc >> 1) ^ 0xEDB88320;
14	14		} else {
15		-	crc = crc >> 1;
	15	+	crc >>= 1;
16	16		}
17		-	j = j + 1;
	17	+	j += 1;
18	18		}
19	19		table[i] = crc;
20		-	i = i + 1;
	20	+	i += 1;
21	21		}
22	22		}
23	23
24	24		/// Compute CRC-32 of a byte slice.
25	25		fn crc32(table: [u32], data: [u8]) -> u32 {

    let mut i: u32 = 0;
    while i < data.len {
        let byte: u8 = data[i];
        let index: u32 = (crc ^ byte as u32) & 0xFF;
        crc = (crc >> 8) ^ table[index];
        i = i + 1;
        i += 1;
    }
    return crc ^ 0xFFFFFFFF;
}

/// Test the lookup table has been built correctly.

    // Build a 32-byte buffer with values 0..31.
    let mut buf: [u8; 32] = [0; 32];
    let mut i: u32 = 0;
    while i < 32 {
        buf[i] = i as u8;
        i = i + 1;
        i += 1;
    }
    let crcFull = crc32(table, &buf[..]);

    // CRC should be non-zero and deterministic.
    if crcFull == 0 {

lib/std/arch/rv64/tests/prog.dijkstra.rad +12 -12

    }
}

fn heapPush(g: *mut Graph, dist: u32, node: u32) {
    g.heap[g.heapSize] = HeapEntry { dist, node };
    g.heapSize = g.heapSize + 1;
    g.heapSize += 1;
    siftUp(g, g.heapSize - 1);
}

/// Pop from the heap. Returns nil if the heap is empty.
fn heapPop(g: *mut Graph) -> ?HeapEntry {
    if g.heapSize == 0 {
        return nil;
    }
    let result: HeapEntry = g.heap[0];
    g.heapSize = g.heapSize - 1;
    g.heapSize -= 1;
    g.heap[0] = g.heap[g.heapSize];
    if g.heapSize > 0 {
        siftDown(g, 0);
    }
    return result;

    let mut i: u32 = 0;
    while i < MAX_NODES {
        let mut j: u32 = 0;
        while j < MAX_NODES {
            g.adj[i][j] = INF;
            j = j + 1;
            j += 1;
        }
        g.dist[i] = INF;
        g.prev[i] = -1;
        g.visited[i] = false;
        i = i + 1;
        i += 1;
    }
    g.heapSize = 0;
}

/// Get the predecessor as an optional; -1 means no predecessor.

                    g.dist[v] = newDist;
                    g.prev[v] = u as i32;
                    heapPush(g, newDist, v);
                }
            }
            v = v + 1;
            v += 1;
        }
    }
}

/// Reconstruct the shortest path from source to target.
fn reconstructPath(g: *Graph, target: u32, path: *mut [u32]) -> u32 {
    let mut len: u32 = 0;

    path[len] = target;
    len = len + 1;
    len += 1;

    let mut cur: ?u32 = getPrev(g, target);
    while let node = cur {
        path[len] = node;
        len = len + 1;
        len += 1;
        cur = getPrev(g, node);
    }

    // Reverse the path.
    let mut a: u32 = 0;
    let mut b: u32 = len - 1;
    while a < b {
        let tmp: u32 = path[a];
        path[a] = path[b];
        path[b] = tmp;
        a = a + 1;
        b = b - 1;
        a += 1;
        b -= 1;
    }
    return len;
}

fn testLinear(g: *mut Graph) -> i32 {

259	259		if i > j {
260	260		diff = i - j;
261	261		}
262	262		addEdge(g, i, j, diff * 3 + 1);
263	263		}
264		-	j = j + 1;
	264	+	j += 1;
265	265		}
266		-	i = i + 1;
	266	+	i += 1;
267	267		}
268	268
269	269		dijkstra(g, 0);
270	270
271	271		let mut k: u32 = 1;
272	272		while k < 8 {
273	273		let expected: u32 = k * 3 + 1;
274	274		if g.dist[k] != expected {
275	275		return k as i32;
276	276		}
277		-	k = k + 1;
	277	+	k += 1;
278	278		}
279	279
280	280		return 0;
281	281		}
282	282

lib/std/arch/rv64/tests/prog.eval.rad +1 -1


/// Allocate a new node, returning its index.
fn newNode(pool: *mut Pool, expr: Expr) -> u32 {
    let idx = pool.count;
    pool.nodes[idx] = expr;
    pool.count = pool.count + 1;
    pool.count += 1;
    return idx;
}

/// Convenience constructors.
fn num(pool: *mut Pool, n: i32) -> u32 {

lib/std/arch/rv64/tests/prog.hanoi.rad +3 -3


/// Record a move.
fn recordMove(ml: *mut MoveLog, disk: u32, from: u32, to: u32) {
    if ml.count < MAX_MOVES {
        ml.moves[ml.count] = Move { disk, from, to };
        ml.count = ml.count + 1;
        ml.count += 1;
    }
}

/// Solve Tower of Hanoi recursively.
/// Move `n` disks from peg `from` to peg `to` using `aux` as auxiliary.

            return 1;
        }
        if d == 0 {
            break;
        }
        d = d - 1;
        d -= 1;
    }

    // Replay all moves.
    let mut i: u32 = 0;
    while i < ml.count {

            return 2;
        }
        if not pegPush(&mut pegs, m.to, disk) {
            return 3;
        }
        i = i + 1;
        i += 1;
    }

    // All disks should be on peg 1.
    if pegs.top[0] != 0 {
        return 4;

lib/std/arch/rv64/tests/prog.huffman.rad +16 -16

}

fn newLeaf(s: *mut HuffState, freq: u32, symbol: u32) -> u32 {
    let idx: u32 = s.nodeCount;
    s.nodes[idx] = HNode { freq, kind: HNodeKind::Leaf(symbol), left: NIL, right: NIL };
    s.nodeCount = s.nodeCount + 1;
    s.nodeCount += 1;
    return idx;
}

fn newInterior(s: *mut HuffState, freq: u32, left: u32, right: u32) -> u32 {
    let idx: u32 = s.nodeCount;
    s.nodes[idx] = HNode { freq, kind: HNodeKind::Interior, left, right };
    s.nodeCount = s.nodeCount + 1;
    s.nodeCount += 1;
    return idx;
}

/// Get the symbol from a node, or nil if it's an interior node.
fn nodeSymbol(node: *HNode) -> ?u32 {

    }
}

fn heapPush(s: *mut HuffState, nodeIdx: u32) {
    s.heap[s.heapSize] = nodeIdx;
    s.heapSize = s.heapSize + 1;
    s.heapSize += 1;
    siftUp(s, s.heapSize - 1);
}

fn heapPop(s: *mut HuffState) -> u32 {
    let result: u32 = s.heap[0];
    s.heapSize = s.heapSize - 1;
    s.heapSize -= 1;
    s.heap[0] = s.heap[s.heapSize];
    if s.heapSize > 0 {
        siftDown(s, 0);
    }
    return result;


fn writeBit(s: *mut HuffState, bit: u32) {
    let byteIdx: u32 = s.bitCount / 8;
    let bitIdx: u32 = 7 - (s.bitCount % 8);
    if bit == 1 {
        s.bitstream[byteIdx] = s.bitstream[byteIdx] | (1 as u8 << bitIdx as u8);
        s.bitstream[byteIdx] |= (1 as u8 << bitIdx as u8);
    }
    s.bitCount = s.bitCount + 1;
    s.bitCount += 1;
}

fn readBit(s: *HuffState, pos: u32) -> u32 {
    let byteIdx: u32 = pos / 8;
    let bitIdx: u32 = 7 - (pos % 8);

fn encode(s: *mut HuffState, msg: *[u32]) {
    s.bitCount = 0;
    let mut i: u32 = 0;
    while i < MAX_BITS {
        s.bitstream[i] = 0;
        i = i + 1;
        i += 1;
    }


    for sym in msg {
        let bits: u32 = s.codeBits[sym];
        let len: u32 = s.codeLen[sym];
        let mut b: u32 = 0;
        while b < len {
            let bit: u32 = (bits >> (len - 1 - b)) & 1;
            writeBit(s, bit);
            b = b + 1;
            b += 1;
        }
    }
}

fn decode(s: *HuffState, root: u32, numSymbols: u32, out: *mut [u32]) -> u32 {

    while decoded < numSymbols {
        let mut cur: u32 = root;
        // Walk the tree until we find a leaf.
        while nodeSymbol(&s.nodes[cur]) == nil {
            let bit: u32 = readBit(s, bitPos);
            bitPos = bitPos + 1;
            bitPos += 1;
            if bit == 0 {
                cur = s.nodes[cur].left;
            } else {
                cur = s.nodes[cur].right;
            }
        }
        let sym = nodeSymbol(&s.nodes[cur]) else {
            return decoded;
        };
        out[decoded] = sym;
        decoded = decoded + 1;
        decoded += 1;
    }
    return decoded;
}

fn resetCodes(s: *mut HuffState) {
    let mut i: u32 = 0;
    while i < MAX_SYMBOLS {
        s.codeBits[i] = 0;
        s.codeLen[i] = 0;
        i = i + 1;
        i += 1;
    }
}

fn testBasic(s: *mut HuffState) -> i32 {
    let freqs: [u32; 5] = [5, 9, 12, 13, 16];

    let mut i: u32 = 0;
    while i < 5 {
        if s.codeLen[i] == 0 {
            return 2;
        }
        i = i + 1;
        i += 1;
    }

    // No two symbols at the same depth should have the same code.
    let mut a: u32 = 0;
    while a < 5 {

259	259		if s.codeLen[a] == s.codeLen[b] {
260	260		if s.codeBits[a] == s.codeBits[b] {
261	261		return 3;
262	262		}
263	263		}
264		-	b = b + 1;
	264	+	b += 1;
265	265		}
266		-	a = a + 1;
	266	+	a += 1;
267	267		}
268	268
269	269		return 0;
270	270		}
271	271

    while i < 6 {
        if s.codeLen[i] > 0 and s.codeLen[i] < shortestLen {
            shortestLen = s.codeLen[i];
            shortestSym = i;
        }
        i = i + 1;
        i += 1;
    }
    if shortestSym != 0 {
        return 1;
    }


351	351		let mut i: u32 = 0;
352	352		while i < 8 {
353	353		if s.codeLen[i] != 3 {
354	354		return 2;
355	355		}
356		-	i = i + 1;
	356	+	i += 1;
357	357		}
358	358
359	359		let msg: [u32; 8] = [0, 1, 2, 3, 4, 5, 6, 7];
360	360		encode(s, &msg[..]);
361	361

lib/std/arch/rv64/tests/prog.hybridsort.rad +5 -5

    while i < data.len {
        let key = data[i];
        let mut j: i32 = i as i32 - 1;
        while j >= 0 and data[j as u32] > key {
            data[(j + 1) as u32] = data[j as u32];
            j = j - 1;
            j -= 1;
        }
        data[(j + 1) as u32] = key;
        i = i + 1;
        i += 1;
    }
}

/// Selection sort on the given array.
fn selectionSort(data: *mut [i32]) {

        let mut j: u32 = i + 1;
        while j < data.len {
            if data[j] < data[minIdx] {
                minIdx = j;
            }
            j = j + 1;
            j += 1;
        }
        if minIdx != i {
            let tmp = data[i];
            data[i] = data[minIdx];
            data[minIdx] = tmp;
        }
        i = i + 1;
        i += 1;
    }
}

/// Check that an array is sorted in ascending order.
fn isSorted(data: *[i32]) -> bool {


/// Compute sum of all elements.
fn sum(data: *[i32]) -> i32 {
    let mut total: i32 = 0;
    for val in data {
        total = total + val;
        total += val;
    }
    return total;
}

/// Compare two arrays element by element.

lib/std/arch/rv64/tests/prog.linkedlist.rad +6 -6

}

/// Allocate a node from the pool. Returns its index.
fn alloc(list: *mut List, value: i32) -> u32 {
    let idx = list.free;
    list.free = list.free + 1;
    list.free += 1;
    list.pool[idx] = Node { value, next: nil };
    return idx;
}

/// Push a value onto the front of the list.

/// Get the length of the list.
fn length(list: *List) -> u32 {
    let mut count: u32 = 0;
    let mut cur = list.head;
    while let idx = cur {
        count = count + 1;
        count += 1;
        cur = list.pool[idx].next;
    }
    return count;
}


    while let idx = cur {
        if i == index {
            return list.pool[idx].value;
        }
        cur = list.pool[idx].next;
        i = i + 1;
        i += 1;
    }
    return nil;
}

/// Reverse the linked list in-place.

/// Compute the sum of all values in the list.
fn sum(list: *List) -> i32 {
    let mut total: i32 = 0;
    let mut cur = list.head;
    while let idx = cur {
        total = total + list.pool[idx].value;
        total += list.pool[idx].value;
        cur = list.pool[idx].next;
    }
    return total;
}



    // Push 32 elements.
    let mut i: u32 = 0;
    while i < 32 {
        push(list, i as i32 * 3);
        i = i + 1;
        i += 1;
    }

    if length(list) != 32 {
        return 1;
    }

        };
        let expected = j as i32 * 3;
        if v != expected {
            return 6;
        }
        j = j + 1;
        j += 1;
    }

    if length(list) != 0 {
        return 7;
    }

lib/std/arch/rv64/tests/prog.lzw.rad +19 -19

fn initEncDict(s: *mut LzwState) {
    s.encDictSize = INIT_DICT;
    let mut i: u32 = 0;
    while i < 256 {
        s.encDict[i] = DictEntry { prefix: 0xFFFF, suffix: i as u8 };
        i = i + 1;
        i += 1;
    }
}

fn initDecDict(s: *mut LzwState) {
    s.decDictSize = INIT_DICT;
    let mut i: u32 = 0;
    while i < 256 {
        s.decDict[i] = DictEntry { prefix: 0xFFFF, suffix: i as u8 };
        i = i + 1;
        i += 1;
    }
}

fn dictLookup(s: *LzwState, prefix: u32, suffix: u8) -> u32 {
    let mut i: u32 = 0;
    while i < s.encDictSize {
        if s.encDict[i].prefix == prefix and s.encDict[i].suffix == suffix {
            return i;
        }
        i = i + 1;
        i += 1;
    }
    return 0xFFFFFFFF;
}

fn dictAdd(s: *mut LzwState, prefix: u32, suffix: u8) {
    if s.encDictSize < MAX_DICT {
        s.encDict[s.encDictSize] = DictEntry { prefix, suffix };
        s.encDictSize = s.encDictSize + 1;
        s.encDictSize += 1;
    }
}

fn emitCode(s: *mut LzwState, code: u32) {
    s.encoded[s.encLen] = code;
    s.encLen = s.encLen + 1;
    s.encLen += 1;
}

fn encode(s: *mut LzwState, data: *[u8]) {
    initEncDict(s);
    s.encLen = 0;

        } else {
            emitCode(s, w);
            dictAdd(s, w, c);
            w = c as u32;
        }
        i = i + 1;
        i += 1;
    }
    emitCode(s, w);
    emitCode(s, EOI_CODE);
}

fn decodeString(s: *mut LzwState, code: u32) -> u32 {
    let mut len: u32 = 0;
    let mut c: u32 = code;
    while c != 0xFFFF and c < s.decDictSize {
        s.temp[len] = s.decDict[c].suffix;
        len = len + 1;
        len += 1;
        c = s.decDict[c].prefix;
    }
    let mut a: u32 = 0;
    let mut b: u32 = len - 1;
    while a < b {
        let tmp: u8 = s.temp[a];
        s.temp[a] = s.temp[b];
        s.temp[b] = tmp;
        a = a + 1;
        b = b - 1;
        a += 1;
        b -= 1;
    }
    return len;
}

fn firstByte(s: *LzwState, code: u32) -> u8 {

}

fn decDictAdd(s: *mut LzwState, prefix: u32, suffix: u8) {
    if s.decDictSize < MAX_DICT {
        s.decDict[s.decDictSize] = DictEntry { prefix, suffix };
        s.decDictSize = s.decDictSize + 1;
        s.decDictSize += 1;
    }
}

fn outputByte(s: *mut LzwState, b: u8) {
    s.decoded[s.decLen] = b;
    s.decLen = s.decLen + 1;
    s.decLen += 1;
}

fn decode(s: *mut LzwState) {
    initDecDict(s);
    s.decLen = 0;

        return;
    }

    let mut pos: u32 = 0;
    let mut code: u32 = s.encoded[pos];
    pos = pos + 1;
    pos += 1;

    if code == EOI_CODE {
        return;
    }

    outputByte(s, code as u8);
    let mut prevCode: u32 = code;

    while pos < s.encLen {
        code = s.encoded[pos];
        pos = pos + 1;
        pos += 1;

        if code == EOI_CODE {
            return;
        }

        if code < s.decDictSize {
            let len: u32 = decodeString(s, code);
            let mut i: u32 = 0;
            while i < len {
                outputByte(s, s.temp[i]);
                i = i + 1;
                i += 1;
            }
            decDictAdd(s, prevCode, s.temp[0]);
        } else {
            let fb: u8 = firstByte(s, prevCode);
            let len: u32 = decodeString(s, prevCode);
            let mut i: u32 = 0;
            while i < len {
                outputByte(s, s.temp[i]);
                i = i + 1;
                i += 1;
            }
            outputByte(s, fb);
            decDictAdd(s, prevCode, fb);
        }
        prevCode = code;

    decode(s);
    if s.decLen != 10 { return 2; }
    let mut i: u32 = 0;
    while i < 10 {
        if s.decoded[i] != data[i] { return 3; }
        i = i + 1;
        i += 1;
    }
    return 0;
}

fn testDistinct(s: *mut LzwState) -> i32 {

    decode(s);
    if s.decLen != 16 { return 1; }
    let mut i: u32 = 0;
    while i < 16 {
        if s.decoded[i] != data[i] { return 2; }
        i = i + 1;
        i += 1;
    }
    return 0;
}

fn testRepetitive(s: *mut LzwState) -> i32 {

    decode(s);
    if s.decLen != 64 { return 2; }
    let mut i: u32 = 0;
    while i < 64 {
        if s.decoded[i] != 65 { return 3; }
        i = i + 1;
        i += 1;
    }
    return 0;
}

fn testMixed(s: *mut LzwState) -> i32 {

236	236		decode(s);
237	237		if s.decLen != 24 { return 1; }
238	238		let mut i: u32 = 0;
239	239		while i < 24 {
240	240		if s.decoded[i] != data[i] { return 2; }
241		-	i = i + 1;
	241	+	i += 1;
242	242		}
243	243
244	244		if s.encLen - 1 >= 24 { return 3; }
245	245
246	246		return 0;

lib/std/arch/rv64/tests/prog.matmul.rad +10 -10

16	16		let mut j: u32 = 0;
17	17		while j < N {
18	18		let mut sum: i32 = 0;
19	19		let mut k: u32 = 0;
20	20		while k < N {
21		-	sum = sum + a.rows[i][k] * b.rows[k][j];
22		-	k = k + 1;
	21	+	sum += a.rows[i][k] * b.rows[k][j];
	22	+	k += 1;
23	23		}
24	24		c.rows[i][j] = sum;
25		-	j = j + 1;
	25	+	j += 1;
26	26		}
27		-	i = i + 1;
	27	+	i += 1;
28	28		}
29	29		}
30	30
31	31		/// Verify c matches expected.
32	32		fn verifyResult(c: Mat4, expected: Mat4) -> i32 {

        let mut j: u32 = 0;
        while j < N {
            if c.rows[i][j] != expected.rows[i][j] {
                return (i * N + j) as i32 + 1;
            }
            j = j + 1;
            j += 1;
        }
        i = i + 1;
        i += 1;
    }
    return 0;
}

/// Compute the trace (sum of diagonal) of a matrix.
fn trace(m: *Mat4) -> i32 {
    let mut sum: i32 = 0;
    let mut i: u32 = 0;
    while i < N {
        sum = sum + m.rows[i][i];
        i = i + 1;
        sum += m.rows[i][i];
        i += 1;
    }
    return sum;
}

/// Zero out a matrix.

    let mut i: u32 = 0;
    while i < N {
        let mut j: u32 = 0;
        while j < N {
            m.rows[i][j] = 0;
            j = j + 1;
            j += 1;
        }
        i = i + 1;
        i += 1;
    }
}

/// Multiply matrices multiple times to test repeated computation.
fn testRepeatedMultiply(c: *mut Mat4, a: *Mat4, b: *Mat4) -> i32 {

lib/std/arch/rv64/tests/prog.mersenne.rad +22 -22

28	28		let lh: u32 = clo * hi;
29	29		let hl: u32 = chi * lo;
30	30
31	31		let result: u32 = ll + ((lh + hl) << 16) + i;
32	32		s.mt[i] = result;
33		-	i = i + 1;
	33	+	i += 1;
34	34		}
35	35		s.mti = N;
36	36		}
37	37
38	38		fn generateNumbers(s: *mut MtState) {

43	43		let mut mag: u32 = 0;
44	44		if y & 1 == 1 {
45	45		mag = MATRIX_A;
46	46		}
47	47		s.mt[i] = s.mt[i + M] ^ (y >> 1) ^ mag;
48		-	i = i + 1;
	48	+	i += 1;
49	49		}
50	50
51	51		while i < N - 1 {
52	52		let y: u32 = (s.mt[i] & UPPER_MASK) \| (s.mt[i + 1] & LOWER_MASK);
53	53		let mut mag: u32 = 0;
54	54		if y & 1 == 1 {
55	55		mag = MATRIX_A;
56	56		}
57	57		s.mt[i] = s.mt[i + M - N] ^ (y >> 1) ^ mag;
58		-	i = i + 1;
	58	+	i += 1;
59	59		}
60	60
61	61		let y: u32 = (s.mt[N - 1] & UPPER_MASK) \| (s.mt[0] & LOWER_MASK);
62	62		let mut mag: u32 = 0;
63	63		if y & 1 == 1 {

72	72		if s.mti >= N {
73	73		generateNumbers(s);
74	74		}
75	75
76	76		let mut y: u32 = s.mt[s.mti];
77		-	s.mti = s.mti + 1;
	77	+	s.mti += 1;
78	78
79		-	y = y ^ (y >> 11);
80		-	y = y ^ ((y << 7) & 0x9D2C5680);
81		-	y = y ^ ((y << 15) & 0xEFC60000);
82		-	y = y ^ (y >> 18);
	79	+	y ^= (y >> 11);
	80	+	y ^= ((y << 7) & 0x9D2C5680);
	81	+	y ^= ((y << 15) & 0xEFC60000);
	82	+	y ^= (y >> 18);
83	83
84	84		return y;
85	85		}
86	86
87	87		fn testKnownSequence(s: *mut MtState) -> i32 {

110	110
111	111		let mut first: [u32; 10] = [0; 10];
112	112		let mut i: u32 = 0;
113	113		while i < 10 {
114	114		first[i] = mtNext(s);
115		-	i = i + 1;
	115	+	i += 1;
116	116		}
117	117
118	118		mtInit(s, 42);
119	119
120	120		i = 0;
121	121		while i < 10 {
122	122		let v: u32 = mtNext(s);
123	123		if v != first[i] { return i as i32 + 1; }
124		-	i = i + 1;
	124	+	i += 1;
125	125		}
126	126
127	127		return 0;
128	128		}
129	129


    let mut i: u32 = 0;
    while i < NUM_SAMPLES {
        let val: u32 = mtNext(s);
        let bin: u32 = val >> 28;
        bins[bin] = bins[bin] + 1;
        i = i + 1;
        bins[bin] += 1;
        i += 1;
    }

    let mut chi2Scaled: u32 = 0;
    let mut b: u32 = 0;
    while b < NUM_BINS {
        let obs: i32 = bins[b] as i32;
        let exp: i32 = EXPECTED as i32;
        let diff: i32 = obs - exp;
        chi2Scaled = chi2Scaled + (diff * diff) as u32;
        b = b + 1;
        chi2Scaled += (diff * diff) as u32;
        b += 1;
    }

    if chi2Scaled > 5000 { return 1; }

    b = 0;
    while b < NUM_BINS {
        if bins[b] == 0 { return 2; }
        b = b + 1;
        b += 1;
    }

    b = 0;
    while b < NUM_BINS {
        if bins[b] > NUM_SAMPLES / 2 { return 3; }
        b = b + 1;
        b += 1;
    }

    return 0;
}



    let mut last: u32 = 0;
    let mut i: u32 = 0;
    while i < 700 {
        last = mtNext(s);
        i = i + 1;
        i += 1;
    }

    mtInit(s, 7);
    let mut last2: u32 = 0;
    i = 0;
    while i < 700 {
        last2 = mtNext(s);
        i = i + 1;
        i += 1;
    }

    if last != last2 { return 1; }

    let mut more: u32 = 0;
    i = 0;
    while i < 700 {
        more = mtNext(s);
        i = i + 1;
        i += 1;
    }
    if more == 0 { return 2; }

    return 0;
}

    let mut andAll: u32 = 0xFFFFFFFF;

    let mut i: u32 = 0;
    while i < 200 {
        let v: u32 = mtNext(s);
        orAll = orAll | v;
        andAll = andAll & v;
        i = i + 1;
        orAll |= v;
        andAll &= v;
        i += 1;
    }

    if orAll != 0xFFFFFFFF { return 1; }
    if andAll == 0xFFFFFFFF { return 2; }
    if andAll != 0 { return 3; }

lib/std/arch/rv64/tests/prog.nqueens.rad +9 -9

        let rowDiff: i32 = row as i32 - i as i32;
        let colDiff: i32 = col as i32 - qcol;
        if colDiff == rowDiff or colDiff == 0 - rowDiff {
            return false;
        }
        i = i + 1;
        i += 1;
    }
    return true;
}

fn solve(b: *mut Board, row: u32) {
    if row == b.boardSize {
        b.solutionCount = b.solutionCount + 1;
        b.solutionCount += 1;
        return;
    }
    let mut col: u32 = 0;
    while col < b.boardSize {
        if isSafe(b, row, col) {
            b.queens[row] = col as i32;
            solve(b, row + 1);
            b.queens[row] = -1;
        }
        col = col + 1;
        col += 1;
    }
}

fn resetBoard(b: *mut Board) {
    let mut i: u32 = 0;
    while i < MAX_N {
        b.queens[i] = -1;
        i = i + 1;
        i += 1;
    }
    b.solutionCount = 0;
}

fn solveNQueens(b: *mut Board, n: u32) -> u32 {

    while n <= 8 {
        let count: u32 = solveNQueens(b, n);
        if count != expected[n] {
            return n as i32;
        }
        n = n + 1;
        n += 1;
    }
    return 0;
}

fn testKnownSolution() -> i32 {

            let rowDiff: i32 = j as i32 - i as i32;
            let colDiff: i32 = solution[j] - solution[i];
            if colDiff == rowDiff or colDiff == 0 - rowDiff {
                return 2;
            }
            j = j + 1;
            j += 1;
        }
        i = i + 1;
        i += 1;
    }

    let mut used: [bool; 8] = [false; 8];
    let mut k: u32 = 0;
    while k < 8 {
        let col: u32 = solution[k] as u32;
        if used[col] {
            return 3;
        }
        used[col] = true;
        k = k + 1;
        k += 1;
    }

    return 0;
}


121	121		let expected: [u32; 9] = [0, 1, 0, 0, 2, 10, 4, 40, 92];
122	122
123	123		let mut n: u32 = 4;
124	124		while n <= 8 {
125	125		if expected[n] == 0 { return 1; }
126		-	n = n + 1;
	126	+	n += 1;
127	127		}
128	128
129	129		if expected[2] != 0 { return 2; }
130	130		if expected[3] != 0 { return 3; }
131	131		if expected[7] <= expected[6] { return 4; }

lib/std/arch/rv64/tests/prog.rbtree.rad +11 -11

    inorderCount: u32,
}

fn allocNode(t: *mut RBTree, key: i32) -> u32 {
    let idx: u32 = t.poolNext;
    t.poolNext = t.poolNext + 1;
    t.poolNext += 1;
    t.pool[idx] = RBNode { key, color: RED, left: NIL, right: NIL, parent: NIL };
    return idx;
}

fn rotateLeft(t: *mut RBTree, x: u32) {

    if x == NIL {
        return;
    }
    inorderWalk(t, t.pool[x].left);
    t.inorder[t.inorderCount] = t.pool[x].key;
    t.inorderCount = t.inorderCount + 1;
    t.inorderCount += 1;
    inorderWalk(t, t.pool[x].right);
}

fn countNodes(t: *RBTree, x: u32) -> u32 {
    if x == NIL {


fn resetTree(t: *mut RBTree) {
    let mut i: u32 = 0;
    while i < POOL_SIZE {
        t.pool[i] = RBNode { key: 0, color: BLACK, left: NIL, right: NIL, parent: NIL };
        i = i + 1;
        i += 1;
    }
    t.poolNext = 1;
    t.root = NIL;
    t.inorderCount = 0;
}

    resetTree(t);

    let mut i: i32 = 0;
    while i < 32 {
        insert(t, i);
        i = i + 1;
        i += 1;
    }

    if countNodes(t, t.root) != 32 { return 1; }
    if t.pool[t.root].color != BLACK { return 2; }


    inorderWalk(t, t.root);
    if t.inorderCount != 32 { return 5; }
    let mut j: u32 = 0;
    while j < 32 {
        if t.inorder[j] != j as i32 { return 6; }
        j = j + 1;
        j += 1;
    }

    return 0;
}


    while i >= 0 {
        insert(t, i);
        if i == 0 {
            break;
        }
        i = i - 1;
        i -= 1;
    }

    if countNodes(t, t.root) != 32 { return 1; }
    if blackHeight(t, t.root) == -1 { return 2; }
    if not noRedRed(t, t.root) { return 3; }

    t.inorderCount = 0;
    inorderWalk(t, t.root);
    let mut j: u32 = 0;
    while j < 32 {
        if t.inorder[j] != j as i32 { return 4; }
        j = j + 1;
        j += 1;
    }

    return 0;
}


        seed = (seed * 1103515245 + 12345) & 0x7FFFFFFF;
        let val: u32 = seed % 48;
        if not inserted[val] {
            insert(t, val as i32);
            inserted[val] = true;
            count = count + 1;
            count += 1;
        }
    }

    if countNodes(t, t.root) != 48 { return 1; }
    if blackHeight(t, t.root) == -1 { return 2; }
    if not noRedRed(t, t.root) { return 3; }

    let mut i: i32 = 0;
    while i < 48 {
        if not search(t, i) { return 4; }
        i = i + 1;
        i += 1;
    }

    if search(t, -1) { return 5; }
    if search(t, 48) { return 6; }
    if search(t, 100) { return 7; }

    inorderWalk(t, t.root);
    if t.inorderCount != 48 { return 8; }
    let mut j: u32 = 0;
    while j < 48 {
        if t.inorder[j] != j as i32 { return 9; }
        j = j + 1;
        j += 1;
    }

    return 0;
}


315	315		resetTree(t);
316	316
317	317		let mut i: i32 = 0;
318	318		while i < 63 {
319	319		insert(t, i);
320		-	i = i + 1;
	320	+	i += 1;
321	321		}
322	322
323	323		let bh: i32 = blackHeight(t, t.root);
324	324		if bh < 3 { return 1; }
325	325		if bh > 7 { return 2; }

lib/std/arch/rv64/tests/prog.regex.rad +16 -16

}

fn newState(nfa: *mut NfaState) -> u32 {
    let s: u32 = nfa.stateCount;
    nfa.stateFirst[s] = NIL;
    nfa.stateCount = nfa.stateCount + 1;
    nfa.stateCount += 1;
    return s;
}

fn addTrans(nfa: *mut NfaState, from: u32, kind: u32, ch: u8, to: u32) {
    let idx: u32 = nfa.transCount;
    nfa.trans[idx] = Trans { kind, ch, to };
    nfa.transNext[idx] = nfa.stateFirst[from];
    nfa.stateFirst[from] = idx;
    nfa.transCount = nfa.transCount + 1;
    nfa.transCount += 1;
}

fn pushFrag(nfa: *mut NfaState, f: Frag) {
    nfa.fragStack[nfa.fragTop] = f;
    nfa.fragTop = nfa.fragTop + 1;
    nfa.fragTop += 1;
}

fn popFrag(nfa: *mut NfaState) -> Frag {
    nfa.fragTop = nfa.fragTop - 1;
    nfa.fragTop -= 1;
    return nfa.fragStack[nfa.fragTop];
}

fn setEmpty(s: *mut [u32]) {
    s[0] = 0;

}

fn setAdd(s: *mut [u32], bit: u32) {
    let word: u32 = bit / 32;
    let pos: u32 = bit % 32;
    s[word] = s[word] | (1 << pos);
    s[word] |= (1 << pos);
}

fn setHas(s: *[u32], bit: u32) -> bool {
    let word: u32 = bit / 32;
    let pos: u32 = bit % 32;

                        }
                    }
                    t = nfa.transNext[t];
                }
            }
            s = s + 1;
            s += 1;
        }
    }

    setCopy(states, nfa.closure);
}

    nfa.transCount = 0;
    nfa.fragTop = 0;
    let mut i: u32 = 0;
    while i < MAX_STATES {
        nfa.stateFirst[i] = NIL;
        i = i + 1;
        i += 1;
    }
    i = 0;
    while i < MAX_TRANSITIONS {
        nfa.transNext[i] = NIL;
        i = i + 1;
        i += 1;
    }
}

fn compile(nfa: *mut NfaState, pattern: *[u8]) -> u32 {
    resetNFA(nfa);

                addTrans(nfa, s, TRANS_EPSILON, 0, body);
                addTrans(nfa, s, TRANS_EPSILON, 0, e);
                addTrans(nfa, body, TRANS_EPSILON, 0, e);

                pushFrag(nfa, Frag { start: s, endState: e });
                i = i + 2;
                i += 2;
                continue;
            }
            if nextCh == 43 {
                let s: u32 = newState(nfa);
                let m: u32 = newState(nfa);

                    addTrans(nfa, m, TRANS_CHAR, ch, m);
                }
                addTrans(nfa, m, TRANS_EPSILON, 0, e);

                pushFrag(nfa, Frag { start: s, endState: e });
                i = i + 2;
                i += 2;
                continue;
            }
            if nextCh == 63 {
                let s: u32 = newState(nfa);
                let m: u32 = newState(nfa);

                }
                addTrans(nfa, s, TRANS_EPSILON, 0, e);
                addTrans(nfa, m, TRANS_EPSILON, 0, e);

                pushFrag(nfa, Frag { start: s, endState: e });
                i = i + 2;
                i += 2;
                continue;
            }
        }

        let s: u32 = newState(nfa);

            addTrans(nfa, s, TRANS_DOT, 0, e);
        } else {
            addTrans(nfa, s, TRANS_CHAR, ch, e);
        }
        pushFrag(nfa, Frag { start: s, endState: e });
        i = i + 1;
        i += 1;
    }

    if nfa.fragTop == 0 {
        let s: u32 = newState(nfa);
        nfa.acceptState = s;

    let numFrags: u32 = nfa.fragTop;
    let mut frags: [Frag; 64] = [Frag { start: 0, endState: 0 }; 64];
    let mut k: u32 = 0;
    while k < numFrags {
        frags[numFrags - 1 - k] = popFrag(nfa);
        k = k + 1;
        k += 1;
    }

    let mut j: u32 = 0;
    while j < numFrags - 1 {
        addTrans(nfa, frags[j].endState, TRANS_EPSILON, 0, frags[j + 1].start);
        j = j + 1;
        j += 1;
    }

    nfa.acceptState = frags[numFrags - 1].endState;
    return frags[0].start;
}

                        setAdd(nfa.nextSet, nfa.trans[t].to);
                    }
                    t = nfa.transNext[t];
                }
            }
            s = s + 1;
            s += 1;
        }

        epsilonClosure(nfa, nfa.nextSet);
        setCopy(nfa.current, nfa.nextSet);

        if setIsEmpty(nfa.current) {
            return false;
        }
        i = i + 1;
        i += 1;
    }

    return setHas(nfa.current, nfa.acceptState);
}


lib/std/arch/rv64/tests/prog.sha256.rad +14 -14

fn prepareSchedule(s: *mut Sha256, block: *[u32]) {
    // Copy the first 16 words directly.
    let mut i: u32 = 0;
    while i < 16 {
        s.w[i] = block[i];
        i = i + 1;
        i += 1;
    }
    // Extend to 64 words.
    while i < 64 {
        s.w[i] = ssig1(s.w[i - 2]) + s.w[i - 7] + ssig0(s.w[i - 15]) + s.w[i - 16];
        i = i + 1;
        i += 1;
    }
}

/// Run the 64-round compression function.
fn compress(s: *mut Sha256, k: *[u32]) {

86	86		e = d + t1;
87	87		d = c;
88	88		c = b;
89	89		b = a;
90	90		a = t1 + t2;
91		-	i = i + 1;
	91	+	i += 1;
92	92		}
93	93
94		-	s.h[0] = s.h[0] + a;
95		-	s.h[1] = s.h[1] + b;
96		-	s.h[2] = s.h[2] + c;
97		-	s.h[3] = s.h[3] + d;
98		-	s.h[4] = s.h[4] + e;
99		-	s.h[5] = s.h[5] + f;
100		-	s.h[6] = s.h[6] + g;
101		-	s.h[7] = s.h[7] + hh;
	94	+	s.h[0] += a;
	95	+	s.h[1] += b;
	96	+	s.h[2] += c;
	97	+	s.h[3] += d;
	98	+	s.h[4] += e;
	99	+	s.h[5] += f;
	100	+	s.h[6] += g;
	101	+	s.h[7] += hh;
102	102		}
103	103
104	104		/// Reset hash state to initial values.
105	105		fn resetHash(s: *mut Sha256) {
106	106		let mut i: u32 = 0;
107	107		while i < 8 {
108	108		s.h[i] = INIT_H[i];
109		-	i = i + 1;
	109	+	i += 1;
110	110		}
111	111		}
112	112
113	113		/// Pad and hash a short message (up to 55 bytes, fits in one 512-bit block).
114	114		fn hashMessage(s: mut Sha256, k: [u32], msg: *[u8]) -> i32 {


    // Copy message.
    let mut i: u32 = 0;
    while i < msg.len {
        blockBytes[i] = msg[i];
        i = i + 1;
        i += 1;
    }

    // Append the 1-bit (0x80).
    blockBytes[msg.len] = 0x80;


        let base = w * 4;
        block[w] = (blockBytes[base] as u32 << 24)
                  | (blockBytes[base + 1] as u32 << 16)
                  | (blockBytes[base + 2] as u32 << 8)
                  | (blockBytes[base + 3] as u32);
        w = w + 1;
        w += 1;
    }

    resetHash(s);
    prepareSchedule(s, &block[..]);
    compress(s, k);

lib/std/arch/rv64/tests/prog.sieve.rad +4 -4

/// Mark all multiples of p as composite.
fn markMultiples(sieve: *mut [bool], p: u32) {
    let mut i: u32 = p * p;
    while i < sieve.len {
        sieve[i] = true;
        i = i + p;
        i += p;
    }
}

/// Run the sieve algorithm.
fn runSieve(sieve: *mut [bool]) {

    let mut p: u32 = 2;
    while p * p < sieve.len {
        if not sieve[p] {
            markMultiples(sieve, p);
        }
        p = p + 1;
        p += 1;
    }
}

/// Count the number of primes found.
fn countPrimes(sieve: *[bool]) -> u32 {
    let mut count: u32 = 0;
    for composite in sieve {
        if not composite {
            count = count + 1;
            count += 1;
        }
    }
    return count;
}


    let mut count: u32 = 0;
    for composite, idx in sieve {
        if not composite {
            if count < primes.len {
                primes[count] = idx;
                count = count + 1;
                count += 1;
            }
        }
    }
    return count;
}

lib/std/arch/rv64/tests/prog.symtab.rad +11 -11

}

/// Push a new scope.
fn pushScope(tab: *mut SymTab) {
    tab.scopes[tab.scopeDepth] = ScopeMarker { symbolCount: tab.symbolCount };
    tab.scopeDepth = tab.scopeDepth + 1;
    tab.scopeDepth += 1;
}

/// Pop the current scope, removing all symbols defined in it.
fn popScope(tab: *mut SymTab) {
    if tab.scopeDepth == 0 {
        return;
    }
    tab.scopeDepth = tab.scopeDepth - 1;
    tab.scopeDepth -= 1;
    let marker = tab.scopes[tab.scopeDepth];

    // Remove symbols added in this scope (in reverse order).
    while tab.symbolCount > marker.symbolCount {
        tab.symbolCount = tab.symbolCount - 1;
        tab.symbolCount -= 1;
        let sym = tab.symbols[tab.symbolCount];
        let bucket = sym.nameHash % HASH_SIZE;

        // Remove from hash chain.
        tab.buckets[bucket] = sym.next;

        depth: tab.scopeDepth,
        next: tab.buckets[bucket],
        shadow: shadowIdx,
    };
    tab.buckets[bucket] = idx;
    tab.symbolCount = tab.symbolCount + 1;
    tab.symbolCount += 1;
    return idx;
}

/// Look up a symbol by name. Returns the value if found.
fn lookup(tab: *SymTab, name: *[u8]) -> ?i32 {

    // Define x at each of 8 scope levels.
    let mut i: u32 = 0;
    while i < 8 {
        pushScope(tab);
        define(tab, "x", i as i32 * 10);
        i = i + 1;
        i += 1;
    }

    // x should be the innermost value.
    let x = lookup(tab, "x") else {
        return 1;

        };
        let expected = (i - 1) as i32 * 10;
        if val != expected {
            return 4;
        }
        i = i - 1;
        i -= 1;
    }

    popScope(tab);
    return 0;
}


    // Verify all of them.
    let mut sum: i32 = 0;
    for name, i in names {
        if let val = lookup(tab, name) {
            sum = sum + val;
            sum += val;
        } else {
            return 1;
        }
    }


            return 1;
        };
        if not update(tab, "counter", cur + 1) {
            return 2;
        }
        i = i + 1;
        i += 1;
    }

    let final_val = lookup(tab, "counter") else {
        return 3;
    };

        let result = lookup(tab, name);
        if let exp = expected[i] {
            // We expect a value.
            if let r = result {
                if r != exp {
                    failures = failures + 1;
                    failures += 1;
                }
            } else {
                failures = failures + 1;
                failures += 1;
            }
        } else {
            // We expect nil.
            if let _ = result {
                failures = failures + 1;
                failures += 1;
            }
        }
    }

    if failures != 0 {

lib/std/arch/rv64/tests/prog.tokenizer.rad +6 -6

}

/// Advance the lexer by one character.
fn advance(lex: *mut Lexer) {
    if lex.pos < lex.source.len {
        lex.pos = lex.pos + 1;
        lex.pos += 1;
    }
}

/// Skip whitespace characters.
fn skipWhitespace(lex: *mut Lexer) {

            case Token::Invalid(_) => {
                return false;
            }
            case Token::Eof => {
                list.tokens[list.count] = tok;
                list.count = list.count + 1;
                list.count += 1;
                done = true;
            }
            else => {
                if list.count >= list.tokens.len - 1 {
                    return false;
                }
                list.tokens[list.count] = tok;
                list.count = list.count + 1;
                list.count += 1;
            }
        }
    }
    return true;
}

/// Allocate a new expression node.
fn newExpr(pool: *mut ExprPool, expr: Expr) -> u32 {
    let idx = pool.count;
    pool.nodes[idx] = expr;
    pool.count = pool.count + 1;
    pool.count += 1;
    return idx;
}

/// Get the current token in the parser.
fn currentToken(p: *Parser) -> Token {

}

/// Advance the parser to the next token.
fn advanceParser(p: *mut Parser) {
    if p.pos < p.tokenCount {
        p.pos = p.pos + 1;
        p.pos += 1;
    }
}

/// Parse a primary expression (number, parenthesized expression, or unary minus).
fn parsePrimary(p: *mut Parser) -> ?u32 {

    let mut numCount: u32 = 0;
    let slice = &tokenBuf[0..list.count];
    for tok in slice {
        match tok {
            case Token::Number(_) => {
                numCount = numCount + 1;
                numCount += 1;
            }
            else => {}
        }
    }
    if numCount != 3 {

lib/std/arch/rv64/tests/prog.vm.rad +5 -5

fn push(vm: *mut VM, value: i32) throws (VmError) {
    if vm.sp >= MAX_STACK {
        throw VmError::StackOverflow;
    }
    vm.stack[vm.sp] = value;
    vm.sp = vm.sp + 1;
    vm.sp += 1;
}

/// Pop a value from the stack.
fn pop(vm: *mut VM) -> i32 throws (VmError) {
    if vm.sp == 0 {
        throw VmError::StackUnderflow;
    }
    vm.sp = vm.sp - 1;
    vm.sp -= 1;
    return vm.stack[vm.sp];
}

/// Peek at the top of the stack without removing.
fn peek(vm: *VM) -> i32 throws (VmError) {


/// Execute the bytecode program.
fn execute(vm: *mut VM) -> i32 throws (VmError) {
    while vm.pc < vm.codeLen {
        let instr = vm.code[vm.pc];
        vm.pc = vm.pc + 1;
        vm.pc += 1;

        match instr {
            case Op::Push(val) => {
                try push(vm, val);
            }

                let mut base: u32 = 0;
                if vm.frameCount > 0 {
                    base = vm.frames[vm.frameCount - 1].localBase + MAX_LOCALS;
                }
                vm.frames[vm.frameCount] = Frame { returnAddr: vm.pc, localBase: base };
                vm.frameCount = vm.frameCount + 1;
                vm.frameCount += 1;
                vm.pc = target;
            }
            case Op::Ret => {
                if vm.frameCount == 0 {
                    throw VmError::InvalidPC;
                }
                vm.frameCount = vm.frameCount - 1;
                vm.frameCount -= 1;
                vm.pc = vm.frames[vm.frameCount].returnAddr;
            }
            case Op::Halt => {
                return try pop(vm);
            }

lib/std/arch/rv64/tests/ptr.mutate.rad +2 -2

fn mutate1(ptr: *mut i32) {
    *ptr = 39;
}

fn mutate2(ptr: *mut i32) {
    *ptr = *ptr + 2;
    *ptr = *ptr + 1;
    *ptr += 2;
    *ptr += 1;
}

@default fn main() -> i32 {
    let mut ptr: i32 = 0;


lib/std/arch/rv64/tests/record.array.elements.rad +5 -5

fn vectorSum(vec: Vector) -> i32 {
    let mut sum: i32 = 0;
    let mut i: u32 = 0;

    while (i < vec.data.len) {
        sum = sum + vec.data[i];
        i = i + 1;
        sum += vec.data[i];
        i += 1;
    }
    return sum;
}

fn vectorScale(vec: Vector, scale: i32) -> Vector {
    let mut result: Vector = Vector { data: [0, 0, 0, 0] };
    let mut i: u32 = 0;

    while (i < vec.data.len) {
        result.data[i] = vec.data[i] * scale;
        i = i + 1;
        i += 1;
    }
    return result;
}

// Sum of the diagonal elements.
fn matrixTrace(mat: Matrix) -> i32 {
    let mut sum: i32 = 0;
    let mut i: u32 = 0;

    while (i < mat.rows.len) {
        sum = sum + mat.rows[i].data[i];
        i = i + 1;
        sum += mat.rows[i].data[i];
        i += 1;
    }
    return sum;
}

@default fn main() -> i32 {

lib/std/arch/rv64/tests/record.field.assign.rad +1 -1

4	4		@default fn main() -> i32 {
5	5		let mut v: Vector = Vector { x: 3, y: 2 };
6	6
7	7		v.x = 40;
8	8		v.y = 1;
9		-	v.y = v.y * 2;
	9	+	v.y *= 2;
10	10
11	11		return (v.x + v.y) - 42;
12	12		}

lib/std/arch/rv64/tests/ref.immut.loop.bug.rad +1 -1

fn testZeroIter(n: u32) -> u32 {
    let val: u32 = 42;
    let mut i: u32 = 0;
    while i < n {
        let _ = read(&val);
        i = i + 1;
        i += 1;
    }
    return val;
}

@default fn main() -> i32 {

lib/std/arch/rv64/tests/reserve.loop.rad +2 -2

3	3		@default fn main() -> i32 {
4	4		let mut total: i32 = 0;
5	5		let mut i: i32 = 0;
6	6		while i < 10000 {
7	7		let p: Pair = Pair { a: i, b: i + 1 };
8		-	total = total + p.a + p.b;
9		-	i = i + 1;
	8	+	total += p.a + p.b;
	9	+	i += 1;
10	10		}
11	11		// Expected: sum(i) + sum(i+1) for i=0..9999
12	12		// = 2 * 9999*10000/2 + 10000 = 99990000 + 10000 = 100000000
13	13		if total != 100000000 {
14	14		return 1;

lib/std/arch/rv64/tests/spill.blockarg.clobber.rad +11 -11


fn prepareSchedule(s: *mut State, block: *[u32]) {
    let mut i: u32 = 0;
    while i < 16 {
        s.w[i] = block[i];
        i = i + 1;
        i += 1;
    }
    while i < 64 {
        s.w[i] = ssig1(s.w[i - 2]) + s.w[i - 7] + ssig0(s.w[i - 15]) + s.w[i - 16];
        i = i + 1;
        i += 1;
    }
}

/// SHA-256 compression: 64 rounds with 8 rotating working variables.
/// Exercises heavy register pressure and spilled block-argument shuffles.

71	71		e = d + t1;
72	72		d = c;
73	73		c = b;
74	74		b = a;
75	75		a = t1 + t2;
76		-	i = i + 1;
	76	+	i += 1;
77	77		}
78	78
79		-	s.h[0] = s.h[0] + a;
80		-	s.h[1] = s.h[1] + b;
81		-	s.h[2] = s.h[2] + c;
82		-	s.h[3] = s.h[3] + d;
83		-	s.h[4] = s.h[4] + e;
84		-	s.h[5] = s.h[5] + f;
85		-	s.h[6] = s.h[6] + g;
86		-	s.h[7] = s.h[7] + hh;
	79	+	s.h[0] += a;
	80	+	s.h[1] += b;
	81	+	s.h[2] += c;
	82	+	s.h[3] += d;
	83	+	s.h[4] += e;
	84	+	s.h[5] += f;
	85	+	s.h[6] += g;
	86	+	s.h[7] += hh;
87	87		}
88	88
89	89		@default fn main() -> i32 {
90	90		let k: [u32; 64] = [
91	91		0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5,

lib/std/arch/rv64/tests/spill.loop.rad +1 -1

    let mut currentOffset: u32 = 0;
    let mut maxAlignment: u32 = 1;
    for i in 0..tags.len {
        let layout = getLayout(tags[i]);
        currentOffset = alignUp(currentOffset, layout.alignment);
        currentOffset = currentOffset + layout.size;
        currentOffset += layout.size;
        maxAlignment = max(maxAlignment, layout.alignment);
    }
    return Layout {
        size: alignUp(currentOffset, maxAlignment),
        alignment: maxAlignment,

lib/std/arch/rv64/tests/static.array.mutate.rad +1 -1

//! Test mutating a static array.

static BUFFER: [i32; 3] = [1, 2, 3];

fn bump(slot: u32, amount: i32) -> i32 {
    BUFFER[slot] = BUFFER[slot] + amount;
    BUFFER[slot] += amount;
    return BUFFER[0] + BUFFER[1] + BUFFER[2];
}

@default fn main() -> i32 {
    let a: i32 = bump(0, 4);

lib/std/arch/rv64/tests/static.basic.rad +2 -2

static GLOBAL: i32 = 0;

fn updateCounter(i: i32) -> i32 {
    static counter: i32 = 0;

    counter = counter + i;
    GLOBAL = GLOBAL + i * 10;
    counter += i;
    GLOBAL += i * 10;

    return counter;
}

@default fn main() -> i32 {

lib/std/arch/rv64/tests/static.record.array.rad +2 -2

    values: [5, 1, 9, 2],
    bias: 4,
};

fn rebalance() -> i32 {
    TABLE.values[0] = TABLE.values[0] + TABLE.bias;
    TABLE.values[3] = TABLE.values[3] + 1;
    TABLE.values[0] += TABLE.bias;
    TABLE.values[3] += 1;
    return TABLE.values[0] + TABLE.values[3] + TABLE.bias;
}

@default fn main() -> i32 {
    let first: i32 = rebalance();

lib/std/arch/rv64/tests/static.slice.offset.rad +1 -1

    TBL.scratch = &mut SCRATCH[..];
    TBL.entries = &mut STORAGE[..];
    TBL.len     = 0;

    TBL.entries[TBL.len] = Entry { a: 7, b: 9 };
    TBL.len               = TBL.len + 1;
    TBL.len += 1;

    if STORAGE[0].a != 7 or STORAGE[0].b != 9 {
        return 1;
    }
    if SCRATCH[0].a != 0 or SCRATCH[0].b != 0 {

lib/std/arch/rv64/tests/union.payload.mutref.rad +1 -1


fn addItemViaMatchRef(blk: *mut Block, val: u32) -> bool {
    match &mut blk.state {
        case Sealed::No { items } => {
            items.data[items.len] = val;
            items.len = items.len + 1;
            items.len += 1;
            return true;
        },
        case Sealed::Yes => {
            return false;
        },

lib/std/arch/rv64/tests/var.infer.rad +1 -1

@default fn main() -> i32 {
    let inferredFlag = alwaysTrue();
    if not (inferredFlag) { panic "assert"; }

    let mut counter = returnsCount();
    counter = counter + 1;
    counter += 1;
    if not (counter == 6) { panic "assert"; }

    let pair = loadPair();
    let left = pair.left;


lib/std/collections/dict.rad +1 -1

        if entry.key.len == 0 {
            if m.count >= m.entries.len / 2 {
                panic "dict::insert: table full";
            }
            m.entries[idx] = Entry { key, value };
            m.count = m.count + 1;
            m.count += 1;
            return;
        }
        if mem::eq(entry.key, key) {
            m.entries[idx].value = value;
            return;

lib/std/fmt.rad +14 -14

    let mut x: u32 = val;
    let mut i: u32 = buffer.len;

    // Handle the zero case separately to ensure a single '0' is written.
    if x == 0 {
        i = i - 1;
        i -= 1;
        buffer[i] = '0';
    } else {
        // Write digits backwards from the end of the buffer.
        while x != 0 {
            i = i - 1;
            i -= 1;
            buffer[i] = ('0' + (x % 10) as u8);
            x = x / 10;
            x /= 10;
        }
    }
    // Return the slice from the start of the written number to
    // the end of the buffer.
    return &buffer[i..];

    } else {
        x = val as u32;
    }
    // Handle the zero case separately to ensure a single '0' is written.
    if x == 0 {
        i = i - 1;
        i -= 1;
        buffer[i] = '0';
    } else {
        // Write digits backwards from the end of the buffer.
        while x != 0 {
            i = i - 1;
            i -= 1;
            buffer[i] = '0' + (x % 10) as u8;
            x = x / 10;
            x /= 10;
        }
        // Add the negative sign if needed.
        if neg {
            i = i - 1;
            i -= 1;
            buffer[i] = '-';
        }
    }
    return &buffer[i..];
}

76	76
77	77		let mut x: u64 = val;
78	78		let mut i: u32 = buffer.len;
79	79
80	80		if x == 0 {
81		-	i = i - 1;
	81	+	i -= 1;
82	82		buffer[i] = '0';
83	83		} else {
84	84		while x != 0 {
85		-	i = i - 1;
	85	+	i -= 1;
86	86		buffer[i] = ('0' + (x % 10) as u8);
87		-	x = x / 10;
	87	+	x /= 10;
88	88		}
89	89		}
90	90		return &buffer[i..];
91	91		}
92	92

102	102		x = -val as u64;
103	103		} else {
104	104		x = val as u64;
105	105		}
106	106		if x == 0 {
107		-	i = i - 1;
	107	+	i -= 1;
108	108		buffer[i] = '0';
109	109		} else {
110	110		while x != 0 {
111		-	i = i - 1;
	111	+	i -= 1;
112	112		buffer[i] = '0' + (x % 10) as u8;
113		-	x = x / 10;
	113	+	x /= 10;
114	114		}
115	115		if neg {
116		-	i = i - 1;
	116	+	i -= 1;
117	117		buffer[i] = '-';
118	118		}
119	119		}
120	120		return &buffer[i..];
121	121		}

lib/std/io.rad +1 -1

        }
        if n > chunk.len {
            total = buf.len;
            break;
        }
        total = total + n;
        total += n;
    }
    return &buf[..total];
}

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

}

/// Commits `size` bytes of allocation, advancing the offset.
/// Use after writing to the buffer returned by [`remainingBuf`].
pub fn commit(arena: *mut Arena, size: u32) {
    arena.offset = arena.offset + size;
    arena.offset += size;
}

/// Allocate a slice of `count` elements, each of `size` bytes with given alignment.
///
/// Returns a type-erased slice that should be cast to the appropriate `*[T]`.

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

pub fn nodeListPush(self: *mut NodeList, node: *Node) -> u32 {
    if self.len >= self.list.len {
        panic "nodeListPush: out of space";
    }
    self.list[self.len] = node;
    self.len = self.len + 1;
    self.len += 1;

    return self.len;
}

/// Grow a node list's backing storage by `extra` slots.

lib/std/lang/ast/printer.rad +4 -4

        case super::NodeValue::ArrayRepeatLit(rep) =>
            return sexpr::list(a, "array-repeat", &[toExpr(a, rep.item), toExpr(a, rep.count)]),
        case super::NodeValue::RecordLit(lit) => {
            let mut total: u32 = lit.fields.len;
            if let _ = lit.typeName {
                total = total + 1;
                total += 1;
            }
            let buf = try! sexpr::allocExprs(a, total);
            let mut idx: u32 = 0;
            if let tn = lit.typeName {
                buf[idx] = toExpr(a, tn); idx = idx + 1;

            let mut head = "catch";
            let mut children: [sexpr::Expr; 3] = undefined;
            let mut len: u32 = 0;
            if let b = clause.binding {
                children[len] = toExpr(a, b);
                len = len + 1;
                len += 1;
            }
            if let t = clause.typeNode {
                children[len] = toExpr(a, t);
                len = len + 1;
                len += 1;
            }
            children[len] = toExpr(a, clause.body);
            len = len + 1;
            len += 1;
            return sexpr::list(a, head, &children[..len]);
        }
        case super::NodeValue::Block(blk) => {
            let children = nodeListToExprs(a, &blk.statements);
            return sexpr::block(a, "block", &[], children);

lib/std/lang/gen/bitset.rad +11 -11

62	62		return;
63	63		}
64	64		let word = n / 32;
65	65		let b = n % 32;
66	66
67		-	bs.bits[word] = bs.bits[word] \| (1 << b);
	67	+	bs.bits[word] \|= (1 << b);
68	68		}
69	69
70	70		/// Clear bit `n` in the bitset.
71	71		pub fn clear(bs: *mut Bitset, n: u32) {
72	72		if n >= bs.len {
73	73		return;
74	74		}
75	75		let word = n / 32;
76	76		let b = n % 32;
77	77
78		-	bs.bits[word] = bs.bits[word] & ~(1 << b);
	78	+	bs.bits[word] &= ~(1 << b);
79	79		}
80	80
81	81		/// Check if bit `n` is set.
82	82		pub fn contains(bs: *Bitset, n: u32) -> bool {
83	83		if n >= bs.len {

/// Count the number of set bits.
pub fn count(bs: *Bitset) -> u32 {
    let mut total: u32 = 0;
    let numWords = wordsFor(bs.len);
    for i in 0..numWords {
        total = total + popCount(bs.bits[i]);
        total += popCount(bs.bits[i]);
    }
    return total;
}

/// Population count for a 32-bit word.
fn popCount(x: u32) -> u32 {
    let mut n = x;
    n = n - ((n >> 1) & 0x55555555);
    n -= ((n >> 1) & 0x55555555);
    n = (n & 0x33333333) + ((n >> 2) & 0x33333333);
    n = (n + (n >> 4)) & 0x0F0F0F0F;
    n = n + (n >> 8);
    n = n + (n >> 16);
    n += (n >> 8);
    n += (n >> 16);

    return n & 0x3F;
}

/// Union: `dst = dst | src`.
pub fn union_(dst: *mut Bitset, src: *Bitset) {
    let numWords = wordsFor(dst.len);
    let srcWords = wordsFor(src.len);
    let minWords = min(numWords, srcWords);
    for i in 0..minWords {
        dst.bits[i] = dst.bits[i] | src.bits[i];
        dst.bits[i] |= src.bits[i];
    }
}

/// Subtract: `dst = dst - src`.
pub fn subtract(dst: *mut Bitset, src: *Bitset) {
    let numWords = wordsFor(dst.len);
    let srcWords = wordsFor(src.len);
    let minWords = min(numWords, srcWords);
    for i in 0..minWords {
        dst.bits[i] = dst.bits[i] & ~src.bits[i];
        dst.bits[i] &= ~src.bits[i];
    }
}

/// Check if two bitsets are equal.
pub fn eq(a: *Bitset, b: *Bitset) -> bool {

    let numWords = wordsFor(it.bs.len);
    while it.wordIdx < numWords {
        let word = it.bs.bits[it.wordIdx];
        // Skip empty words entirely.
        if word == 0 and it.bitIdx == 0 {
            it.wordIdx = it.wordIdx + 1;
            it.wordIdx += 1;
        } else {
            while it.bitIdx < 32 {
                let n = it.wordIdx * 32 + it.bitIdx;
                if n >= it.bs.len {
                    return nil;
                }
                it.bitIdx = it.bitIdx + 1;
                it.bitIdx += 1;
                if (word & (1 << (it.bitIdx - 1))) != 0 {
                    return n;
                }
            }
            it.wordIdx = it.wordIdx + 1;
            it.wordIdx += 1;
            it.bitIdx = 0;
        }
    }
    return nil;
}

lib/std/lang/gen/bitset/tests.rad +2 -2

    let mut it = super::iter(&bs);
    let mut count: u32 = 0;
    let mut sum: u32 = 0;

    while let n = super::iterNext(&mut it) {
        count = count + 1;
        sum = sum + n;
        count += 1;
        sum += n;
    }

    try testing::expect(count == 4);
    try testing::expect(sum == 3 + 31 + 32 + 50);
}

lib/std/lang/gen/labels.rad +1 -1

pub fn recordBlock(l: *mut Labels, blockIdx: u32, offset: i32) {
    if blockIdx >= l.blockOffsets.len {
        panic "recordBlock: block index out of range";
    }
    l.blockOffsets[blockIdx] = offset;
    l.blockCount = l.blockCount + 1;
    l.blockCount += 1;
}

/// Look up a block's byte offset by index. O(1).
pub fn blockOffset(l: *Labels, blockIdx: u32) -> i32 {
    if blockIdx >= l.blockCount {

lib/std/lang/gen/regalloc/assign.rad +4 -4

            let pred = &blkEnd[block.preds[0]];
            for k in 0..pred.n {
                if bitset::contains(&live.liveIn[b], pred.virtRegs[k]) {
                    current.virtRegs[current.n] = pred.virtRegs[k];
                    current.physRegs[current.n] = pred.physRegs[k];
                    current.n = current.n + 1;
                    current.n += 1;
                    bitset::set(&mut usedRegs, pred.physRegs[k] as u32);
                }
            }
        }


    let mut usedCalleeSaved: u32 = 0;
    for i in 0..maxReg {
        if let phys = assignments[i] {
            for j in 0..config.calleeSaved.len {
                if phys == config.calleeSaved[j] {
                    usedCalleeSaved = usedCalleeSaved | (1 << j);
                    usedCalleeSaved |= (1 << j);
                }
            }
        }
    }


    if rmap.n >= MAX_ACTIVE {
        panic "rmapSet: register map overflow";
    }
    rmap.virtRegs[rmap.n] = virtReg;
    rmap.physRegs[rmap.n] = physReg;
    rmap.n = rmap.n + 1;
    rmap.n += 1;
}

/// Remove a mapping from register map.
fn rmapRemove(rmap: *mut RegMap, virtReg: u32) {
    for i in 0..rmap.n {
        if rmap.virtRegs[i] == virtReg {
            // Swap with last and decrement.
            rmap.n = rmap.n - 1;
            rmap.n -= 1;
            if i < rmap.n {
                rmap.virtRegs[i] = rmap.virtRegs[rmap.n];
                rmap.physRegs[i] = rmap.physRegs[rmap.n];
            }
            return;

lib/std/lang/gen/regalloc/liveness.rad +1 -1

        changed = false;

        // Process blocks in reverse order (approximates post-order).
        let mut b = blockCount;
        while b > 0 {
            b = b - 1;
            b -= 1;
            let block = &func.blocks[b];

            // Compute new `liveOut` as union of successor `liveIn` sets.
            bitset::clearAll(&mut scratch);
            addSuccessorLiveIn(func, block, liveIn, &mut scratch);

lib/std/lang/gen/regalloc/spill.rad +5 -5

        bitset::copy(&mut scratch, &live.liveOut[b]);

        // Walk instructions backwards.
        let mut i = block.instrs.len;
        while i > 0 {
            i = i - 1;
            i -= 1;
            let instr = block.instrs.list[i];

            // Limit register pressure before processing this instruction.
            limitPressure(&mut scratch, &mut spilled, costs, numRegs);


    let mut frameSize: i32 = 0;
    let mut it = bitset::iter(&spilled);

    while let n = bitset::iterNext(&mut it) {
        slots[n] = frameSize;
        frameSize = frameSize + slotSize as i32;
        frameSize += slotSize as i32;
    }
    return SpillInfo { slots, frameSize, calleeClass, maxReg };
}

/// Calculate spill costs for all registers, weighted by loop depth.

    for i in 1..c.n {
        let key = c.entries[i];
        let mut j: u32 = i;
        while j > 0 and c.entries[j - 1].cost > key.cost {
            c.entries[j] = c.entries[j - 1];
            j = j - 1;
            j -= 1;
        }
        c.entries[j] = key;
    }
    let mut toSpill = excess;
    if toSpill > c.n {

        if c.n >= MAX_CANDIDATES {
            panic "collectCandidates: too many live values";
        }
        if reg < costs.len {
            c.entries[c.n] = CostEntry { reg, cost: costs[reg].defs + costs[reg].uses };
            c.n = c.n + 1;
            c.n += 1;
        }
    }
    return c;
}


        if not isCallDst(callDst, n) and n < costs.len {
            candidates[numCandidates] = CostEntry {
                reg: n,
                cost: costs[n].defs + costs[n].uses,
            };
            numCandidates = numCandidates + 1;
            numCandidates += 1;
        }
    }
    // Spill cheapest candidates if crossing count exceeds callee-saved capacity.
    if numCandidates > numCalleeSaved {
        let mut c = Candidates { entries: candidates, n: numCandidates };

lib/std/lang/il.rad +4 -4


/// Format a qualified symbol name: `pkg::mod::path::name`.
pub fn formatQualifiedName(arena: *mut alloc::Arena, path: *[*[u8]], name: *[u8]) -> *[u8] {
    let mut totalLen: u32 = name.len;
    for segment in path {
        totalLen = totalLen + segment.len + PATH_SEPARATOR.len;
        totalLen += segment.len + PATH_SEPARATOR.len;
    }
    let buf = try! alloc::allocSlice(arena, 1, 1, totalLen) as *mut [u8];
    let mut pos: u32 = 0;

    for segment in path {
        pos = pos + try! mem::copy(&mut buf[pos..], segment);
        pos = pos + try! mem::copy(&mut buf[pos..], PATH_SEPARATOR);
        pos += try! mem::copy(&mut buf[pos..], segment);
        pos += try! mem::copy(&mut buf[pos..], PATH_SEPARATOR);
    }
    try! mem::copy(&mut buf[pos..], name);

    return &buf[..totalLen];
}

pub fn instrListPush(self: *mut InstrList, instr: Instr) {
    if self.len >= self.list.len {
        panic "instrListPush: out of space";
    }
    self.list[self.len] = instr;
    self.len = self.len + 1;
    self.len += 1;
}

///////////////////////
// Utility Functions //
///////////////////////

lib/std/lang/lower.rad +23 -23

        if self.errTags[i].ty == errType {
            return self.errTags[i].tag;
        }
    }
    let tag = self.errTagCounter;
    self.errTagCounter = self.errTagCounter + 1;
    self.errTagCounter += 1;

    if self.errTagsLen >= self.errTags.len {
        self.errTags = try! alloc::growSlice(
            self.arena,
            self.errTags as *mut [opaque],

            @sizeOf(ErrTagEntry),
            @alignOf(ErrTagEntry)
        ) as *mut [ErrTagEntry];
    }
    self.errTags[self.errTagsLen] = ErrTagEntry { ty: errType, tag };
    self.errTagsLen = self.errTagsLen + 1;
    self.errTagsLen += 1;

    return tag;
}

/// Builder for accumulating data values during constant lowering.

            b.arena, b.values, b.len,
            @sizeOf(il::DataValue), @alignOf(il::DataValue)
        ) as *mut [il::DataValue];
    }
    b.values[b.len] = value;
    b.len = b.len + 1;
    b.len += 1;

    if value.item != il::DataItem::Undef {
        b.allUndef = false;
    }
}

fn registerFnSym(self: *mut Lowerer, sym: *resolver::Symbol, qualName: *[u8]) {
    if self.fnSymsLen >= self.fnSyms.len {
        panic "registerFnSym: symbol table full";
    }
    self.fnSyms[self.fnSymsLen] = FnSymEntry { sym, qualName };
    self.fnSymsLen = self.fnSymsLen + 1;
    self.fnSymsLen += 1;
}

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

}

/// Generate a unique label by appending the global counter to the base.
fn nextLabel(self: *mut FnLowerer, base: *[u8]) -> *[u8] throws (LowerError) {
    let idx = self.labelCounter;
    self.labelCounter = self.labelCounter + 1;
    self.labelCounter += 1;

    return try labelWithSuffix(self, base, idx);
}

///////////////////////////////

            self.arena, self.data, self.dataCount,
            @sizeOf(il::Data), @alignOf(il::Data)
        ) as *mut [il::Data];
    }
    self.data[self.dataCount] = data;
    self.dataCount = self.dataCount + 1;
    self.dataCount += 1;
}

/// Add a function to the lowerer's function list.
fn pushFn(self: *mut Lowerer, f: *il::Fn) throws (LowerError) {
    if self.fnCount >= self.fns.len {

            self.arena, self.fns, self.fnCount,
            @sizeOf(*il::Fn), @alignOf(*il::Fn)
        ) as *mut [*il::Fn];
    }
    self.fns[self.fnCount] = f;
    self.fnCount = self.fnCount + 1;
    self.fnCount += 1;
}

/// Find an existing string data entry with matching content.
// TODO: Optimize with hash table or remove?
fn findStringData(self: *Lowerer, s: *[u8]) -> ?*[u8] {

}

/// Generate a unique data name for inline literals, eg. `fnName/N`
fn nextDataName(self: *mut FnLowerer) -> *[u8] throws (LowerError) {
    let counter = self.dataCounter;
    self.dataCounter = self.dataCounter + 1;
    self.dataCounter += 1;
    return try labelWithSuffix(self, self.fnName, counter);
}

/// Get the next available SSA register.
fn nextReg(self: *mut FnLowerer) -> il::Reg {
    let reg = il::Reg { n: self.regCounter };
    self.regCounter = self.regCounter + 1;
    self.regCounter += 1;
    return reg;
}

/// Initialize a growable parameter list.
fn paramList(self: *mut FnLowerer, cap: u32) -> BlockParams throws (LowerError) {

            self.low.arena, list.list, list.len,
            @sizeOf(il::Param), @alignOf(il::Param)
        ) as *mut [il::Param];
    }
    list.list[list.len] = param;
    list.len = list.len + 1;
    list.len += 1;
}

/// Remove the last block parameter and its associated variable.
/// Used when detecting a trivial phi that can be eliminated.
fn removeLastBlockParam(self: *mut FnLowerer, block: BlockId) {
    let blk = getBlockMut(self, block);
    if blk.params.len > 0 {
        blk.params.len = blk.params.len - 1;
        blk.params.len -= 1;
    }
    if blk.paramVars.len > 0 {
        blk.paramVars.len = blk.paramVars.len - 1;
        blk.paramVars.len -= 1;
    }
}

/// Rewrite cached SSA values for a variable across all blocks, and also
/// rewrite any terminator arguments that reference the provisional register.

            self.low.arena, list.list, list.len,
            @sizeOf(u32), @alignOf(u32)
        ) as *mut [u32];
    }
    list.list[list.len] = value;
    list.len = list.len + 1;
    list.len += 1;
}

////////////////////////////
// Basic Block Management //
////////////////////////////

        preds,
        vars,
        sealState: Sealed::No { incompleteVars: try u32List(self, 0) },
        loopDepth: self.loopDepth,
    };
    self.blockCount = self.blockCount + 1;
    self.blockCount += 1;

    return id;
}

/// Create a new block with a single parameter.

                self.low.arena, block.locs, block.locsLen,
                @sizeOf(il::SrcLoc), @alignOf(il::SrcLoc)
            ) as *mut [il::SrcLoc];
        }
        block.locs[block.locsLen] = self.srcLoc;
        block.locsLen = block.locsLen + 1;
        block.locsLen += 1;
    }
    il::instrListPush(instrs, instr);
}

/// Emit an unconditional jump to `target`.

            instrs: data.instrs,
            locs: &data.locs[..data.locsLen],
            preds,
            loopDepth: data.loopDepth,
        };
        count = count + 1;
        count += 1;
    }
    return &blocks[..count];
}

/////////////////////

    }
    let slot = &mut self.loopStack[self.loopDepth];

    slot.breakTarget = breakBlock;
    slot.continueTarget = continueBlock;
    self.loopDepth = self.loopDepth + 1;
    self.loopDepth += 1;
}

/// Exit the current loop context.
fn exitLoop(self: *mut FnLowerer) {
    if self.loopDepth == 0 {
        panic "exitLoop: loopDepth is zero";
    }
    self.loopDepth = self.loopDepth - 1;
    self.loopDepth -= 1;
}

/// Get the current loop context.
fn currentLoop(self: *mut FnLowerer) -> ?*mut LoopCtx {
    if self.loopDepth == 0 {

    if self.varsLen >= self.vars.len {
        panic "newVar: out of capacity";
    }
    let id = self.varsLen;
    self.vars[id] = VarData { name, type, mutable, addressTaken: false };
    self.varsLen = self.varsLen + 1;
    self.varsLen += 1;

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

/// Look up a variable by name in the current scope.
/// Searches from most recently declared to first, enabling shadowing.
fn lookupVarByName(self: *FnLowerer, name: *[u8]) -> ?Var {
    let mut id = self.varsLen;
    while id > 0 {
        id = id - 1;
        id -= 1;
        if let varName = self.vars[id].name {
            if mem::eq(varName, name) {
                return Var { id };
            }
        }

            throw LowerError::ExpectedIdentifier;
        };
        let v = newVar(self, name, type, false, il::Val::Undef);

        self.params[self.paramsLen] = FnParamBinding { var: v, reg };
        self.paramsLen = self.paramsLen + 1;
        self.paramsLen += 1;
    }
    return params;
}

/// Resolve match subject.

                    cases[caseIdx] = il::SwitchCase {
                        value: constToScalar(cv),
                        target: blocks[i].n,
                        args: &mut []
                    };
                    caseIdx = caseIdx + 1;
                    caseIdx += 1;
                }
            }
        }
        try addPredecessor(self, blocks[i], entry);
    }

            cases[caseIdx] = il::SwitchCase {
                value: getOrAssignErrorTag(self.low, errTy) as i64,
                target: blocks[i].n,
                args: &mut []
            };
            caseIdx = caseIdx + 1;
            caseIdx += 1;
        } else {
            errTypes[i] = nil;
            defaultIdx = i;
        }
    }

lib/std/lang/lower/tests/assign.loop.rad +2 -2

/// Assignment in a loop, accumulating a value.
fn assignLoop(n: i32) -> i32 {
    let mut sum: i32 = 0;
    let mut i: i32 = 0;
    while i < n {
        sum = sum + i;
        i = i + 1;
        sum += i;
        i += 1;
    }
    return sum;
}

lib/std/lang/lower/tests/assign.multi.var.rad +1 -1

fn assignMultiVar() -> i32 {
    let mut a: i32 = 1;
    let mut b: i32 = 2;
    a = 10;
    b = 20;
    a = a + b;
    a += b;
    return a;
}

lib/std/lang/lower/tests/assign.param.rad +2 -2

/// Assignment overwriting a parameter value.
fn assignParam(x: i32) -> i32 {
    let mut y: i32 = x;
    y = y + 1;
    y = y * 2;
    y += 1;
    y *= 2;
    return y;
}

lib/std/lang/lower/tests/assign.self.ref.rad +2 -2

/// Assignment where the new value depends on the old value.
fn assignSelfRef() -> i32 {
    let mut x: i32 = 1;
    x = x + x;
    x = x * x;
    x += x;
    x *= x;
    return x;
}

lib/std/lang/lower/tests/average.rad +1 -1

/// Compute the sum of a list of numbers.
fn average(numbers: *[u32]) -> u32 {
    let mut sum: u32 = 0;

    for i in numbers {
        sum = sum + i;
        sum += i;
    }
    return sum / numbers.len;
}

lib/std/lang/lower/tests/loop.break.rad +1 -1

2	2		let mut i: i32 = 0;
3	3		loop {
4	4		if i >= n {
5	5		break;
6	6		}
7		-	i = i + 1;
	7	+	i += 1;
8	8		}
9	9		return i;
10	10		}

lib/std/lang/lower/tests/loop.continue.rad +2 -2

fn loopContinue(n: i32) -> i32 {
    let mut i: i32 = 0;
    let mut sum: i32 = 0;
    while i < n {
        i = i + 1;
        i += 1;
        if i == 3 {
            continue;
        }
        sum = sum + i;
        sum += i;
    }
    return sum;
}

lib/std/lang/lower/tests/loop.for.array.rad +1 -1

/// Iterates over an array with index binding and sums elements.
fn forArrayIndexed(arr: [i32; 3]) -> i32 {
    let mut sum: i32 = 0;
    for elem, idx in arr {
        sum = sum + elem + idx as i32;
        sum += elem + idx as i32;
    }
    return sum;
}

lib/std/lang/lower/tests/loop.for.array.ril +2 -2

    br.slt w32 %1 3 @body2 @merge3;
  @body2
    mul w64 %2 %1 4;
    add w64 %3 %0 %2;
    sload w32 %4 %3 0;
    add w32 %6 %5 %4;
    add w32 %7 %6 %1;
    add w32 %6 %4 %1;
    add w32 %7 %5 %6;
    jmp @step4;
  @merge3
    ret %5;
  @step4
    add w32 %8 %1 1;

lib/std/lang/lower/tests/loop.for.continue.rad +2 -2

    let mut sum: u32 = 0;
    for i in 0..n {
        if i == 2 {
            continue;
        }
        sum = sum + i;
        sum += i;
    }
    return sum;
}

fn forContinueArray(arr: [i32; 4]) -> i32 {
    let mut sum: i32 = 0;
    for elem in arr {
        if elem == 0 {
            continue;
        }
        sum = sum + elem;
        sum += elem;
    }
    return sum;
}

lib/std/lang/lower/tests/loop.for.indexed.rad +1 -1

fn loopForIndexed(n: i32) -> i32 {
    let mut sum: i32 = 0;
    for val, idx in 0..n {
        sum = sum + val + idx as i32;
        sum += val + idx as i32;
    }
    return sum;
}

lib/std/lang/lower/tests/loop.for.indexed.ril +4 -4

fn w32 $loopForIndexed(w32 %0) {
  @entry0
    jmp @loop1(0, 0, 0);
  @loop1(w32 %1, w32 %2, w32 %4)
  @loop1(w32 %1, w32 %2, w32 %3)
    br.slt w32 %1 %0 @body2 @merge3;
  @body2
    add w32 %3 %2 %1;
    add w32 %5 %3 %4;
    add w32 %4 %1 %3;
    add w32 %5 %2 %4;
    jmp @step4;
  @merge3
    ret %2;
  @step4
    add w32 %6 %1 1;
    add w32 %7 %4 1;
    add w32 %7 %3 1;
    jmp @loop1(%6, %5, %7);
}

lib/std/lang/lower/tests/loop.for.placeholder.rad +2 -2

// Test for loop with placeholder binding

fn forPlaceholder(n: u32) -> u32 {
    let mut count: u32 = 0;
    for _ in 0..n {
        count = count + 1;
        count += 1;
    }
    return count;
}

fn forPlaceholderArray(arr: [i32; 4]) -> i32 {
    let mut count: i32 = 0;
    for _ in arr {
        count = count + 1;
        count += 1;
    }
    return count;
}

lib/std/lang/lower/tests/loop.for.rad +1 -1

fn loopFor(n: i32) -> i32 {
    let mut sum: i32 = 0;
    for i in 0..n {
        sum = sum + i;
        sum += i;
    }
    return sum;
}

lib/std/lang/lower/tests/loop.for.slice.rad +1 -1

/// Iterates over a slice with index binding and sums elements.
fn forSliceIndexed(s: *[i32]) -> i32 {
    let mut sum: i32 = 0;
    for elem, idx in s {
        sum = sum + elem + idx as i32;
        sum += elem + idx as i32;
    }
    return sum;
}

lib/std/lang/lower/tests/loop.for.slice.ril +2 -2

    br.slt w32 %3 %1 @body2 @merge3;
  @body2
    mul w64 %4 %3 4;
    add w64 %5 %2 %4;
    sload w32 %6 %5 0;
    add w32 %8 %7 %6;
    add w32 %9 %8 %3;
    add w32 %8 %6 %3;
    add w32 %9 %7 %8;
    jmp @step4;
  @merge3
    ret %7;
  @step4
    add w32 %10 %3 1;

lib/std/lang/lower/tests/loop.for.unsigned.range.rad +2 -2

fn loopForUnsignedRange(start: u32, end: u32) -> u32 {
    let mut count: u32 = 0;
    for _ in start..end {
        count = count + 1;
        count += 1;
    }
    return count;
}

fn loopForSignedRange(start: i32, end: i32) -> i32 {
    let mut count: i32 = 0;
    for _ in start..end {
        count = count + 1;
        count += 1;
    }
    return count;
}

lib/std/lang/lower/tests/loop.nested.break.rad +3 -3

    let mut i: i32 = 0;

    loop {
        let mut j: i32 = 0;
        loop {
            result = result + 1;
            j = j + 1;
            result += 1;
            j += 1;
            if j >= n {
                break;
            }
        }
        i = i + 1;
        i += 1;
        if i >= n {
            break;
        }
    }
    return result;

lib/std/lang/lower/tests/loop.nested.continue.rad +3 -3

fn nestedContinue(n: i32) -> i32 {
    let mut result: i32 = 0;
    let mut i: i32 = 0;

    while i < n {
        i = i + 1;
        i += 1;
        if i == 2 {
            continue;
        }
        let mut j: i32 = 0;
        while j < n {
            j = j + 1;
            j += 1;
            if j == 1 {
                continue;
            }
            result = result + 1;
            result += 1;
        }
    }
    return result;
}

lib/std/lang/lower/tests/loop.return.rad +1 -1

1	1		fn loopReturn() -> i32 {
2	2		let mut i: i32 = 0;
3	3		loop {
4		-	i = i + 1;
	4	+	i += 1;
5	5		if i == 10 {
6	6		return i;
7	7		}
8	8		}
9	9		}

lib/std/lang/lower/tests/loop.while.nested.shortcircuit.rad +3 -3

    let mut outer: i32 = 0;
    let mut total: i32 = 0;
    while outer < n {
        let mut inner: i32 = outer;
        while inner > 0 and inner < 100 {
            inner = inner - 1;
            inner -= 1;
        }
        total = total + outer;
        outer = outer + 1;
        total += outer;
        outer += 1;
    }
    return total;
}

lib/std/lang/lower/tests/loop.while.rad +2 -2

fn loopWhile(n: i32) -> i32 {
    let mut i: i32 = 0;
    let mut sum: i32 = 0;
    while i < n {
        sum = sum + i;
        i = i + 1;
        sum += i;
        i += 1;
    }
    return sum;
}

lib/std/lang/lower/tests/loop.whilelet.case.rad +1 -1

fn whileLetCase(x: i32) -> i32 {
    let mut cur: i32 = x;
    let mut steps: i32 = 0;
    while let case 0 = cur {
        cur = 1;
        steps = steps + 1;
        steps += 1;
    }
    return steps;
}

lib/std/lang/lower/tests/loop.whilelet.guard.rad +1 -1

fn whileLetCaseGuard(x: i32) -> i32 {
    let mut cur: i32 = x;
    let mut steps: i32 = 0;
    while let case 0 = cur; steps < 3 {
        cur = 0;
        steps = steps + 1;
        steps += 1;
    }
    return steps;
}

lib/std/lang/lower/tests/loop.whilelet.optional.rad +1 -1

// Returns the iteration count for a single guarded loop.
fn whileLetOptional(p: ?*i32) -> i32 {
    let mut steps: i32 = 0;
    while let _ = p {
        steps = steps + 1;
        steps += 1;
        break;
    }
    return steps;
}

lib/std/lang/lower/tests/loop.whilelet.union.rad +1 -1

/// Sum values from a linked iteration using while-let case with binding.
fn sumWhileLet(x: Option) -> u32 {
    let mut opt = x;
    let mut sum: u32 = 0;
    while let case Option::Some(val) = opt {
        sum = sum + val;
        sum += val;
        opt = Option::None;
    }
    return sum;
}

lib/std/lang/lower/tests/mutref.loop.rad +1 -1

fn test() -> i32 {
    let mut maxReg: u32 = 0;
    let mut i: u32 = 0;
    while i < 3 {
        callback(i, &mut maxReg as *mut opaque);
        i = i + 1;
        i += 1;
    }
    return maxReg as i32;
}

lib/std/lang/lower/tests/mutref.scalar.rad +1 -1

fn modify(counter: *mut i32, ret: bool) -> bool {
    *counter = *counter + 1;
    *counter += 1;
    return ret;
}

fn test() -> i32 {
    let mut x: i32 = 0;

lib/std/lang/lower/tests/reserve.loop.rad +2 -2

fn reserveInLoop(n: i32) -> i32 {
    let mut sum: i32 = 0;
    let mut i: i32 = 0;
    while i < n {
        let p: Pair = Pair { a: i, b: i + 1 };
        sum = sum + p.a + p.b;
        i = i + 1;
        sum += p.a + p.b;
        i += 1;
    }
    return sum;
}

lib/std/lang/lower/tests/reserve.loop.ril +3 -3

    reserve %3 8 4;
    store w32 %1 %3 0;
    add w32 %4 %1 1;
    store w32 %4 %3 4;
    sload w32 %6 %3 0;
    add w32 %7 %5 %6;
    sload w32 %8 %3 4;
    add w32 %9 %7 %8;
    sload w32 %7 %3 4;
    add w32 %8 %6 %7;
    add w32 %9 %5 %8;
    add w32 %10 %1 1;
    jmp @while1(%10, %2, %9);
  @merge3
    ret %5;
}

lib/std/lang/lower/tests/slice.mutable.rad +1 -1

fn mutSliceStore(s: *mut [i32], idx: u32, val: i32) {
    s[idx] = val;
}

fn mutSliceIncrement(s: *mut [i32], idx: u32) {
    s[idx] = s[idx] + 1;
    s[idx] += 1;
}

fn mutSliceSwap(s: *mut [i32], i: u32, j: u32) {
    let tmp = s[i];
    s[i] = s[j];

lib/std/lang/lower/tests/static.assign.rad +1 -1

/// Test static variable assignment.
static COUNTER: i32 = 0;

fn increment() -> i32 {
    COUNTER = COUNTER + 1;
    COUNTER += 1;
    return COUNTER;
}

lib/std/lang/lower/tests/static.local.decl.rad +1 -1

/// Test lowering of function-local static and const declarations.
fn localStaticAndConst() -> i32 {
    static LOCAL: i32 = 7;
    const ADD: i32 = 5;

    LOCAL = LOCAL + ADD;
    LOCAL += ADD;
    return LOCAL;
}

lib/std/lang/lower/tests/union.match.ref.rad +1 -1


/// While-let on a mutable union reference.
fn whileLetRef(ptr: *mut Option) -> u32 {
    let mut sum: u32 = 0;
    while let case Option::Some(val) = ptr {
        sum = sum + *val;
        sum += *val;
        *ptr = Option::None;
    }
    return sum;
}


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

    for i in 0..filePath.len {
        if filePath[i] == PATH_SEP {
            if i > last {
                debug::assertMsg(count < components.len, "parsePath: output slice is large enough");
                components[count] = &filePath[last..i];
                count = count + 1;
                count += 1;
            }
            last = i + 1;
        }
    }
    if last >= filePath.len {

    if let name = trimExtension(&filePath[last..]) {
        components[count] = name;
    } else {
        return nil;
    };
    count = count + 1;
    count += 1;

    return count;
}

/// Register a module from a file path, creating the full hierarchy as needed.

fn allocModule(graph: *mut ModuleGraph, packageId: u16, name: *[u8], filePath: *[u8]) -> *mut ModuleEntry throws (ModuleError) {
    if graph.entriesLen >= graph.entries.len {
        throw ModuleError::CapacityExceeded;
    }
    let idx = graph.entriesLen;
    graph.entriesLen = graph.entriesLen + 1;
    graph.entriesLen += 1;

    // TODO: This is a common pattern that needs better syntax.
    let m = &mut graph.entries[idx];
    *m = ModuleEntry {
        id: idx as u16,

fn appendPathSegment(entry: *mut ModuleEntry, segment: *[u8]) throws (ModuleError) {
    if entry.pathDepth >= entry.path.len {
        throw ModuleError::PathTooDeep;
    }
    entry.path[entry.pathDepth] = segment;
    entry.pathDepth = entry.pathDepth + 1;
    entry.pathDepth += 1;
}

/// Append a child identifier to the parent's child list.
fn addChild(parent: *mut ModuleEntry, childId: u16) -> u16 throws (ModuleError) {
    if parent.childrenLen >= parent.children.len {
        throw ModuleError::CapacityExceeded;
    }
    parent.children[parent.childrenLen] = childId;
    parent.childrenLen = parent.childrenLen + 1;
    parent.childrenLen += 1;

    return childId;
}

/// Check if `id` points at an allocated entry.

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

    if start + 1 < text.len and text[start] == '0' {
        let prefix = text[start + 1];
        if prefix == 'x' or prefix == 'X' {
            radix = 16;
            radixType = ast::Radix::Hex;
            start = start + 2;
            start += 2;
        } else if prefix == 'b' or prefix == 'B' {
            radix = 2;
            radixType = ast::Radix::Binary;
            start = start + 2;
            start += 2;
        }
        if start >= text.len {
            throw failParsing(p, "integer literal prefix must be followed by digits");
        }
    }

            throw failParsing(p, "invalid digit in integer literal");
        };
        if value > (U64_MAX / radix64) {
            throw failParsing(p, "integer literal overflow");
        }
        value = value * radix64;
        value *= radix64;

        if value > U64_MAX - (digit as u64) {
            throw failParsing(p, "integer literal overflow");
        }
        value = value + (digit as u64);
        value += (digit as u64);
    }
    return ast::IntLiteral {
        text, magnitude: value, radix: radixType, signed, negative,
    };
}

299	299		case '\\' => dst[j] = '\\',
300	300		case '"' => dst[j] = '"',
301	301		case '0' => dst[j] = 0,
302	302		else => dst[j] = raw[i + 1],
303	303		}
304		-	i = i + 2;
	304	+	i += 2;
305	305		} else {
306	306		dst[j] = raw[i];
307		-	i = i + 1;
	307	+	i += 1;
308	308		}
309		-	j = j + 1;
	309	+	j += 1;
310	310		}
311	311		return j;
312	312		}
313	313
314	314		/// Emit a single attribute node.

    debug::assert(message.len > 0);

    // Ignore errors once the error list is full.
    if p.errors.count < p.errors.list.len {
        p.errors.list[p.errors.count] = Error { message, token };
        p.errors.count = p.errors.count + 1;
        p.errors.count += 1;
    }
}

/// Fail the parsing process with the given error.
fn failParsing(p: *mut Parser, err: *[u8]) -> ParseError {

lib/std/lang/resolver.rad +14 -14

    // Don't record more than one error per node.
    if let n = node; errorForNode(self, n) != nil {
        return ResolveError::Failure;
    }
    self.errors.list[self.errors.listLen] = Error { kind, node, moduleId: self.currentMod };
    self.errors.listLen = self.errors.listLen + 1;
    self.errors.listLen += 1;

    return ResolveError::Failure;
}

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

{
    if self.loopDepth >= MAX_LOOP_DEPTH {
        panic "visitLoop: loop nesting depth exceeded";
    }
    self.loopStack[self.loopDepth] = LoopCtx { hasBreak: false };
    self.loopDepth = self.loopDepth + 1;
    self.loopDepth += 1;

    let ty = try infer(self, body) catch {
        if self.loopDepth == 0 {
            panic "visitLoop: loop depth underflow";
        }
        self.loopDepth = self.loopDepth - 1;
        self.loopDepth -= 1;
        throw ResolveError::Failure;
    };
    // Pop and check if break was encountered.
    self.loopDepth = self.loopDepth - 1;
    self.loopDepth -= 1;

    if self.loopStack[self.loopDepth].hasBreak {
        return Type::Void;
    }
    return Type::Never;

    // Propagate module ID to the symbol for fast lookup.
    if let modId = scope.moduleId {
        sym.moduleId = modId;
    }
    scope.symbols[scope.symbolsLen] = sym;
    scope.symbolsLen = scope.symbolsLen + 1;
    scope.symbolsLen += 1;
}

/// Bind a value identifier in the current scope.
/// Returns `nil` if the identifier is a placeholder (`_`).
fn bindValueIdent(


    for i in 0..attrNodes.len {
        let node = attrNodes.list[i];
        let case ast::NodeValue::Attribute(attr) = node.value
            else panic "resolveAttributes: invalid attribute node";
        mask = mask | (attr as u32);
        mask |= (attr as u32);
    }
    return mask;
}

/// Ensure the `default` attribute is only applied to functions.

        let paramTy = try infer(self, paramNode) catch {
            exitFn(self);
            throw ResolveError::Failure;
        };
        fnType.paramTypes[fnType.paramTypesLen] = allocType(self, paramTy);
        fnType.paramTypesLen = fnType.paramTypesLen + 1;
        fnType.paramTypesLen += 1;
    }

    for i in 0..decl.sig.throwList.len {
        if fnType.throwListLen >= fnType.throwList.len {
            break;

        let throwTy = try infer(self, throwNode) catch {
            exitFn(self);
            throw ResolveError::Failure;
        };
        fnType.throwList[fnType.throwListLen] = allocType(self, throwTy);
        fnType.throwListLen = fnType.throwListLen + 1;
        fnType.throwListLen += 1;
    }
    exitFn(self);

    // Bind the function name.
    let ty = Type::Fn(allocFnType(self, fnType));

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

        result[fieldsLen] = RecordField { name: fieldName, fieldType, offset: currentOffset as i32 };
        fieldsLen = fieldsLen + 1;
        fieldsLen += 1;

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

        // Track max alignment for record layout.
        maxAlignment = max(maxAlignment, fieldLayout.alignment);
    }
    // Compute cached layout.

        variants[variantCount] = UnionVariant {
            name: variantName,
            valueType: variantType,
            symbol: variantSym,
        };
        variantCount = variantCount + 1;
        variantCount += 1;
    }
    // Compute cached layout values.
    let tagSize: u32 = 1;
    let mut maxVarSize: u32 = 0;
    let mut maxVarAlign: u32 = 1;

                    if let case NodeExtra::UnionVariant { ordinal: ix, .. } = self.nodeData.entries[pattern.id].extra {
                        if covered[ix] {
                            throw emitError(self, pattern, ErrorKind::DuplicateMatchPattern);
                        }
                        covered[ix] = true;
                        coveredCount = coveredCount + 1;
                        coveredCount += 1;
                    }
                }
            }
        }
    }


            for i in 0..t.params.len {
                let paramTy = try infer(self, t.params.list[i]);

                fnType.paramTypes[fnType.paramTypesLen] = allocType(self, paramTy);
                fnType.paramTypesLen = fnType.paramTypesLen + 1;
                fnType.paramTypesLen += 1;
            }
            for i in 0..t.throwList.len {
                let tyNode = t.throwList.list[i];
                let throwTy = try infer(self, tyNode);

                fnType.throwList[fnType.throwListLen] = allocType(self, throwTy);
                fnType.throwListLen = fnType.throwListLen + 1;
                fnType.throwListLen += 1;
            }
            if let ret = t.returnType {
                fnType.returnType = allocType(self, try infer(self, ret));
            } else {
                fnType.returnType = allocType(self, Type::Void);

lib/std/lang/scanner.rad +3 -3

    return s.source[s.cursor + 1];
}

/// Advance scanner and return the character that was consumed.
fn advance(s: *mut Scanner) -> u8 {
    s.cursor = s.cursor + 1;
    s.cursor += 1;
    return s.source[s.cursor - 1];
}

/// Consume the expected character if it matches the current position.
fn consume(s: *mut Scanner, expected: u8) -> bool {

712	712		return nil;
713	713		}
714	714		for ch in &source[..offset] {
715	715		if ch == '\n' {
716	716		c = 1;
717		-	l = l + 1;
	717	+	l += 1;
718	718		} else {
719		-	c = c + 1;
	719	+	c += 1;
720	720		}
721	721		}
722	722		return Location { file, line: l, col: c };
723	723		}

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

            if toWrite > remaining {
                toWrite = remaining;
            }
            for i in 0..toWrite {
                buf[*pos] = s[i];
                *pos = *pos + 1;
                *pos += 1;
            }
        }
    }
}


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

        case Lookup::Empty(idx) => {
            if sp.count >= TABLE_SIZE / 2 {
                panic "intern: string pool is full";
            }
            sp.table[idx] = str;
            sp.count = sp.count + 1;
            sp.count += 1;

            return str;
        }
    }
}

lib/std/mem.rad +2 -2

/// Count number of set bits in a 32-bit value.
pub fn popCount(x: u32) -> i32 {
    let mut n = x;
    let mut count: i32 = 0;
    while n != 0 {
        count = count + (n & 1) as i32;
        n = n >> 1;
        count += (n & 1) as i32;
        n >>= 1;
    }
    return count;
}

/// Check whether two byte slices have the same length and contents.

lib/std/sys/unix.rad +2 -2

            return n;
        }
        if n == 0 {
            break;
        }
        total = total + n as u32;
        total += n as u32;
    }
    return total as i32;
}

/// Writes to a file descriptor from the provided buffer.

        let n = write(fd, chunk);
        if n <= 0 {
            close(fd);
            return false;
        }
        written = written + n as u32;
        written += n as u32;
    }
    close(fd);

    return true;
}

lib/std/testing.rad +2 -2

    try testFn() catch {
        success = false;
    };
    if success {
        io::printLn("ok");
        ctx.passed = ctx.passed + 1;
        ctx.passed += 1;
    } else {
        io::printLn("FAILED");
        ctx.failed = ctx.failed + 1;
        ctx.failed += 1;
    }
}

fn printTestSummary(ctx: *Ctx) {
    if (ctx.failed > 0) {

lib/std/vec.rad +2 -2

    let off: u32 = vec.len * vec.stride;
    let dst: *mut u8 = &mut vec.data[off];
    let src: *u8 = elem as *u8;

    copyBytes(dst, src, vec.stride);
    vec.len = vec.len + 1;
    vec.len += 1;

    return true;
}

/// Pop an element from the end of the vector.

/// Returns false if the vector is empty.
pub fn pop(vec: *mut RawVec, out: *mut opaque) -> bool {
    if vec.len == 0 {
        return false;
    }
    vec.len = vec.len - 1;
    vec.len -= 1;

    let off: u32 = vec.len * vec.stride;
    let src: *u8 = &vec.data[off];
    let dst: *mut u8 = out as *mut u8;


test/lower/lower-test.rad +2 -2


    while i < line.len and line[i] != ';' {
        if line[i] != ' ' and line[i] != '\t' {
            end = i + 1;
        }
        i = i + 1;
        i += 1;
    }
    return &line[..end];
}

/// Get next line from string at offset. Returns the line and updates offset past newline.
fn nextLine(s: *[u8], offset: *mut u32) -> *[u8] {
    let start = *offset;
    let mut i = start;

    while i < s.len and s[i] != '\n' {
        i = i + 1;
        i += 1;
    }
    let line = &s[start..i];
    if i < s.len {
        *offset = i + 1;
    } else {

520	520		let stmt = block.statements.list[i];
521	521		if let case ast::NodeValue::FnDecl(decl) = stmt.value {
522	522		if let fnName = getTestFnName(&decl) {
523	523		if *testCount < tests.len {
524	524		tests[*testCount] = TestDesc { modPath, fnName };
525		-	testCount = testCount + 1;
	525	+	*testCount += 1;
526	526		} else {
527	527		panic "collectModuleTests: too many tests";
528	528		}
529	529		}
530	530		}

690	690		return;
691	691		}
692	692		let mut path: [u8; MAX_PATH_LEN] = undefined;
693	693		let mut pos: u32 = 0;
694	694
695		-	pos = pos + try! mem::copy(&mut path[pos..], basePath);
696		-	pos = pos + try! mem::copy(&mut path[pos..], ext);
	695	+	pos += try! mem::copy(&mut path[pos..], basePath);
	696	+	pos += try! mem::copy(&mut path[pos..], ext);
697	697		path[pos] = 0; // Null-terminate for syscall.
698	698
699	699		if not unix::writeFile(&path[..pos], data) {
700	700		io::printError("radiance: fatal: failed to write data file\n");
701	701		throw Error::Other;

721	721		for i in 0..entries.len {
722	722		let entry = &entries[i];
723	723		let modEntry = module::get(graph, entry.moduleId) else {
724	724		panic "writeDebugInfo: module not found for debug entry";
725	725		};
726		-	pos = pos + try! mem::copy(&mut buf[pos..], @sliceOf(&entry.pc as *u8, 4));
727		-	pos = pos + try! mem::copy(&mut buf[pos..], @sliceOf(&entry.offset as *u8, 4));
728		-	pos = pos + try! mem::copy(&mut buf[pos..], modEntry.filePath);
	726	+	pos += try! mem::copy(&mut buf[pos..], @sliceOf(&entry.pc as *u8, 4));
	727	+	pos += try! mem::copy(&mut buf[pos..], @sliceOf(&entry.offset as *u8, 4));
	728	+	pos += try! mem::copy(&mut buf[pos..], modEntry.filePath);
729	729
730	730		buf[pos] = 0;
731		-	pos = pos + 1;
	731	+	pos += 1;
732	732		}
733	733		try writeDataWithExt(&buf[..pos], basePath, DEBUG_EXT);
734	734		}
735	735
736	736		/// Run the resolver on the parsed modules.

167	167		if (usedCalleeSaved & (1 << i)) != 0 {
168	168		frame.savedRegs[frame.savedRegsLen] = SavedReg {
169	169		reg: super::CALLEE_SAVED[i],
170	170		offset,
171	171		};
172		-	frame.savedRegsLen = frame.savedRegsLen + 1;
173		-	offset = offset - super::DWORD_SIZE;
	172	+	frame.savedRegsLen += 1;
	173	+	offset -= super::DWORD_SIZE;
174	174		}
175	175		}
176	176		return frame;
177	177		}
178	178

248	248		pub fn recordFunc(e: mut Emitter, name: [u8]) {
249	249		if e.funcsLen >= e.funcs.len {
250	250		panic "recordFunc: funcs buffer full";
251	251		}
252	252		e.funcs[e.funcsLen] = FuncAddr { name, index: e.codeLen };
253		-	e.funcsLen = e.funcsLen + 1;
	253	+	e.funcsLen += 1;
254	254		}
255	255
256	256		/// Record a local branch needing later patching.
257	257		/// Emits two placeholder instructions that will be patched later.
258	258		pub fn recordBranch(e: *mut Emitter, targetBlock: u32, kind: BranchKind) {

220	220		let mut idx: u32 = 0;
221	221
222	222		while idx < args.len {
223	223		let arg = args[idx];
224	224		if mem::eq(arg, "-pkg") {
225		-	idx = idx + 1;
	225	+	idx += 1;
226	226		if idx >= args.len {
227	227		io::printError("radiance: `-pkg` requires a package name\n");
228	228		throw Error::Other;
229	229		}
230	230		if pkgCount >= MAX_PACKAGES {
231	231		io::printError("radiance: too many packages specified\n");
232	232		throw Error::Other;
233	233		}
234	234		pkgNames[pkgCount] = args[idx];
235	235		currentPkgIdx = pkgCount;
236		-	pkgCount = pkgCount + 1;
	236	+	pkgCount += 1;
237	237		} else if mem::eq(arg, "-mod") {
238		-	idx = idx + 1;
	238	+	idx += 1;
239	239		if idx >= args.len {
240	240		io::printError("radiance: `-mod` requires a module path\n");
241	241		throw Error::Other;
242	242		}
243	243		let pkgIdx = currentPkgIdx else {

247	247		if moduleCounts[pkgIdx] >= MAX_LOADED_MODULES {
248	248		io::printError("radiance: too many modules specified for package\n");
249	249		throw Error::Other;
250	250		}
251	251		modulePaths[pkgIdx][moduleCounts[pkgIdx]] = args[idx];
252		-	moduleCounts[pkgIdx] = moduleCounts[pkgIdx] + 1;
	252	+	moduleCounts[pkgIdx] += 1;
253	253		} else if mem::eq(arg, "-entry") {
254		-	idx = idx + 1;
	254	+	idx += 1;
255	255		if idx >= args.len {
256	256		io::printError("radiance: `-entry` requires a package name\n");
257	257		throw Error::Other;
258	258		}
259	259		entryPkgName = args[idx];
260	260		} else if mem::eq(arg, "-test") {
261	261		buildTest = true;
262	262		} else if mem::eq(arg, "-debug") {
263	263		debugEnabled = true;
264	264		} else if mem::eq(arg, "-o") {
265		-	idx = idx + 1;
	265	+	idx += 1;
266	266		if idx >= args.len {
267	267		io::printError("radiance: `-o` requires an output path\n");
268	268		throw Error::Other;
269	269		}
270	270		outputPath = args[idx];
271	271		} else if mem::eq(arg, "-dump") {
272		-	idx = idx + 1;
	272	+	idx += 1;
273	273		if idx >= args.len {
274	274		io::printError("radiance: `-dump` requires a mode (eg. ast)\n");
275	275		throw Error::Other;
276	276		}
277	277		let mode = args[idx];

293	293		io::printError("radiance: unknown argument `");
294	294		io::printError(arg);
295	295		io::printError("`\n");
296	296		throw Error::Other;
297	297		}
298		-	idx = idx + 1;
	298	+	idx += 1;
299	299		}
300	300		if pkgCount == 0 {
301	301		io::printError("radiance: no package specified\n");
302	302		throw Error::Other;
303	303		}

197	197		for i in 0..program.data.len {
198	198		let data = &program.data[i];
199	199		if data.readOnly == readOnly and not data.isUndefined {
200	200		offset = mem::alignUp(offset, data.alignment);
201	201		syms[*count] = DataSym { name: data.name, addr: base + offset };
202		-	count = count + 1;
203		-	offset = offset + data.size;
	202	+	*count += 1;
	203	+	offset += data.size;
204	204		}
205	205		}
206	206		// Uninitialized data after.
207	207		for i in 0..program.data.len {
208	208		let data = &program.data[i];
209	209		if data.readOnly == readOnly and data.isUndefined {
210	210		offset = mem::alignUp(offset, data.alignment);
211	211		syms[*count] = DataSym { name: data.name, addr: base + offset };
212		-	count = count + 1;
213		-	offset = offset + data.size;
	212	+	*count += 1;
	213	+	offset += data.size;
214	214		}
215	215		}
216	216		return offset;
217	217		}
218	218

242	242		match v.item {
243	243		case il::DataItem::Val { typ, val } => {
244	244		let size = il::typeSize(typ);
245	245		let valPtr = &val as *u8;
246	246		try! mem::copy(&mut buf[offset..], @sliceOf(valPtr, size));
247		-	offset = offset + size;
	247	+	offset += size;
248	248		},
249	249		case il::DataItem::Sym(name) => {
250	250		let addr = lookupDataSymAddr(dataSyms, name) else {
251	251		panic "emitSection: data symbol not found";
252	252		};

259	259		let hiPtr = &hi as *u8;
260	260
261	261		try! mem::copy(&mut buf[offset..], @sliceOf(loPtr, 4));
262	262		try! mem::copy(&mut buf[(offset + 4)..], @sliceOf(hiPtr, 4));
263	263
264		-	offset = offset + 8;
	264	+	offset += 8;
265	265		},
266	266		case il::DataItem::Fn(name) => {
267	267		let addr = codeBase + labels::funcOffset(fnLabels, name) as u32;
268	268		let lo: u32 = addr;
269	269		let hi: u32 = 0;

217	217		pub fn emit(e: *mut Emitter, instr: u32) {
218	218		if e.codeLen >= e.code.len {
219	219		panic "emit: code buffer full";
220	220		}
221	221		e.code[e.codeLen] = instr;
222		-	e.codeLen = e.codeLen + 1;
	222	+	e.codeLen += 1;
223	223		}
224	224
225	225		/// Compute branch offset to a function by name.
226	226		pub fn branchOffsetToFunc(e: Emitter, srcIndex: u32, name: [u8]) -> i32 {
227	227		return labels::branchToFunc(&e.labels, srcIndex, name, super::INSTR_SIZE);

262	262		e.pendingBranches[e.pendingBranchesLen] = PendingBranch {
263	263		index: e.codeLen,
264	264		target: targetBlock,
265	265		kind: kind,
266	266		};
267		-	e.pendingBranchesLen = e.pendingBranchesLen + 1;
	267	+	e.pendingBranchesLen += 1;
268	268
269	269		emit(e, encode::nop()); // Placeholder for branch/auipc.
270	270		emit(e, encode::nop()); // Placeholder for nop/jal/jalr.
271	271		}
272	272

279	279		}
280	280		e.pendingCalls[e.pendingCallsLen] = PendingCall {
281	281		index: e.codeLen,
282	282		target,
283	283		};
284		-	e.pendingCallsLen = e.pendingCallsLen + 1;
	284	+	e.pendingCallsLen += 1;
285	285
286	286		emit(e, encode::nop()); // Placeholder for AUIPC.
287	287		emit(e, encode::nop()); // Placeholder for JALR.
288	288		}
289	289

297	297		e.pendingAddrLoads[e.pendingAddrLoadsLen] = PendingAddrLoad {
298	298		index: e.codeLen,
299	299		target,
300	300		rd: rd,
301	301		};
302		-	e.pendingAddrLoadsLen = e.pendingAddrLoadsLen + 1;
	302	+	e.pendingAddrLoadsLen += 1;
303	303
304	304		emit(e, encode::nop()); // Placeholder for AUIPC.
305	305		emit(e, encode::nop()); // Placeholder for ADDI.
306	306		}
307	307

958	958		// Load immediate, symbol, or spilled value.
959	959		loadVal(s, dst, args[i]);
960	960		}
961	961		found = true;
962	962		pending[i] = false;
963		-	numPending = numPending - 1;
	963	+	numPending -= 1;
964	964
965	965		break;
966	966		}
967	967		}
968	968		}

430	430		let lo = imm & 0xFFF;
431	431		let mut hi = (imm >> 12) & 0xFFFFF;
432	432		// If `lo`'s sign bit is set, it will be sign-extended to negative.
433	433		// Compensate by incrementing `hi`.
434	434		if (lo & 0x800) != 0 {
435		-	hi = hi + 1;
	435	+	hi += 1;
436	436		return SplitImm { hi, lo: lo \| 0xFFFFF000 as i32 };
437	437		}
438	438		return SplitImm { hi, lo };
439	439		}
440	440

685	685		e.debugEntries[e.debugEntriesLen] = DebugEntry {
686	686		pc,
687	687		moduleId: loc.moduleId,
688	688		offset: loc.offset,
689	689		};
690		-	e.debugEntriesLen = e.debugEntriesLen + 1;
	690	+	e.debugEntriesLen += 1;
691	691		}
692	692
693	693		/// Get debug entries as a slice.
694	694		pub fn getDebugEntries(e: Emitter) -> [DebugEntry] {
695	695		return &e.debugEntries[..e.debugEntriesLen];

239	239		for i in 0..block.instrs.len {
240	240		match block.instrs.list[i] {
241	241		case il::Instr::Reserve { size, alignment, .. } => {
242	242		if let case il::Val::Imm(sz) = size {
243	243		offset = mem::alignUpI32(offset, alignment as i32);
244		-	offset = offset + (sz as i32);
	244	+	offset += (sz as i32);
245	245		}
246	246		},
247	247		else => {},
248	248		}
249	249		}

451	451		emit::emitLd(s.e, super::SCRATCH1, super::SCRATCH1, offset);
452	452		} else {
453	453		emit::emitLd(s.e, super::SCRATCH1, rsrc, offset);
454	454		}
455	455		emit::emitSd(s.e, super::SCRATCH1, rdst, offset);
456		-	offset = offset + super::DWORD_SIZE;
457		-	remaining = remaining - super::DWORD_SIZE;
	456	+	offset += super::DWORD_SIZE;
	457	+	remaining -= super::DWORD_SIZE;
458	458		}
459	459		if remaining >= super::WORD_SIZE {
460	460		if offset > super::MAX_IMM - super::WORD_SIZE {
461	461		emit::emitAddImm(s.e, rsrc, rsrc, offset);
462	462		if rdst.n != rsrc.n {

469	469		emit::emitLw(s.e, super::SCRATCH1, super::SCRATCH1, offset);
470	470		} else {
471	471		emit::emitLw(s.e, super::SCRATCH1, rsrc, offset);
472	472		}
473	473		emit::emitSw(s.e, super::SCRATCH1, rdst, offset);
474		-	offset = offset + super::WORD_SIZE;
475		-	remaining = remaining - super::WORD_SIZE;
	474	+	offset += super::WORD_SIZE;
	475	+	remaining -= super::WORD_SIZE;
476	476		}
477	477		while remaining > 0 {
478	478		if offset > super::MAX_IMM - 1 {
479	479		emit::emitAddImm(s.e, rsrc, rsrc, offset);
480	480		if rdst.n != rsrc.n {

487	487		emit::emitLb(s.e, super::SCRATCH1, super::SCRATCH1, offset);
488	488		} else {
489	489		emit::emitLb(s.e, super::SCRATCH1, rsrc, offset);
490	490		}
491	491		emit::emitSb(s.e, super::SCRATCH1, rdst, offset);
492		-	offset = offset + 1;
493		-	remaining = remaining - 1;
	492	+	offset += 1;
	493	+	remaining -= 1;
494	494		}
495	495		// Restore base registers if they were advanced (never happens
496	496		// in the both-spilled case since size <= MAX_IMM).
497	497		if not bothSpilled {
498	498		let advanced = size as i32 - offset;

903	903		match args[i] {
904	904		case il::Val::Reg(r) => {
905	905		if let _ = regalloc::spill::spillSlot(&s.ralloc.spill, r) {
906	906		// Spilled value needs load, not a register move.
907	907		pending[i] = true;
908		-	numPending = numPending + 1;
	908	+	numPending += 1;
909	909		} else {
910	910		let src = getReg(s, r);
911	911		if src != dst {
912	912		// Register-to-register move needed.
913	913		srcRegs[i] = src;
914	914		isRegMove[i] = true;
915	915		pending[i] = true;
916		-	numPending = numPending + 1;
	916	+	numPending += 1;
917	917		} else {
918	918		// No move needed.
919	919		}
920	920		}
921	921		},
922	922		case il::Val::Imm(_), il::Val::DataSym(_), il::Val::FnAddr(_) => {
923	923		pending[i] = true;
924		-	numPending = numPending + 1;
	924	+	numPending += 1;
925	925		},
926	926		case il::Val::Undef => {
927	927		// Undefined values don't need any move.
928	928		}
929	929		}

97	97		fn writeMnem(out: mut sexpr::Output, m: [u8]) {
98	98		write(out, m);
99	99		let mut i = m.len;
100	100		while i < MNEMONIC_WIDTH {
101	101		write(out, " ");
102		-	i = i + 1;
	102	+	i += 1;
103	103		}
104	104		}
105	105
106	106		////////////////////////////////
107	107		// Instruction Format Helpers //

100	100		fn testAggregateReturnInLoop() -> i32 {
101	101		let mut total: u32 = 0;
102	102		let mut idx: u32 = 0;
103	103		while idx < 5 {
104	104		let p: Pair = makePair(idx, idx + 10);
105		-	total = total + p.a + p.b;
106		-	idx = idx + 1;
	105	+	total += p.a + p.b;
	106	+	idx += 1;
107	107		}
108	108		// total = sum(i + i+10 for i in 0..5) = sum(2i+10) = 2*(0+1+2+3+4) + 50 = 20 + 50 = 70
109	109		if total != 70 {
110	110		return 1;
111	111		}

9	9		arr[3] = 40;
10	10		arr[4] = 50;
11	11
12	12		let mut sum: i32 = 0;
13	13
14		-	sum = sum + arr[0];
15		-	sum = sum + arr[1];
16		-	sum = sum + arr[2];
17		-	sum = sum + arr[3];
18		-	sum = sum - arr[4];
	14	+	sum += arr[0];
	15	+	sum += arr[1];
	16	+	sum += arr[2];
	17	+	sum += arr[3];
	18	+	sum -= arr[4];
19	19
20	20		if sum != 50 {
21	21		return 1;
22	22		}
23	23		return 0;

2	2
3	3		@default fn main() -> i32 {
4	4		let mut arr: [i32; 4] = [10, 20, 30, 40];
5	5		let mut sum: i32 = 0;
6	6
7		-	sum = sum + arr[0];
8		-	sum = sum + arr[1];
9		-	sum = sum + arr[2];
10		-	sum = sum + arr[3];
	7	+	sum += arr[0];
	8	+	sum += arr[1];
	9	+	sum += arr[2];
	10	+	sum += arr[3];
11	11
12	12		return (sum) - 100;
13	13		}

4	4		let mut ary: [i32; 7] = [1, 2, 3, 4, 5, 6, 7];
5	5		let mut sum: i32 = 0;
6	6		let mut i: u32 = 0;
7	7
8	8		while (i < ary.len) {
9		-	sum = sum + ary[i];
10		-	i = i + 1;
	9	+	sum += ary[i];
	10	+	i += 1;
11	11		}
12	12		return (sum) - 28;
13	13		}

3	3
4	4		fn sumMatrix(mat: [[i32; 3]; 2]) -> i32 {
5	5		let mut sum: i32 = 0;
6	6		for vec in mat {
7	7		for x in vec {
8		-	sum = sum + x;
	8	+	sum += x;
9	9		}
10	10		}
11	11		return sum;
12	12		}
13	13
14	14		fn sumMatrixTransposed(mat: [[i32; 2]; 3]) -> i32 {
15	15		let mut sum: i32 = 0;
16	16		for vec in (mat) {
17	17		for x in (vec) {
18		-	sum = sum + x;
	18	+	sum += x;
19	19		}
20	20		}
21	21		return sum;
22	22		}
23	23

28	28
29	29		while (i < matrix.len) {
30	30		let mut j: u32 = 0;
31	31		while (j < matrix[i].len) {
32	32		result[j][i] = matrix[i][j];
33		-	j = j + 1;
	33	+	j += 1;
34	34		}
35		-	i = i + 1;
	35	+	i += 1;
36	36		}
37	37		return result;
38	38		}
39	39
40	40		@default fn main() -> i32 {

22	22		fn sumPoints(points: [Point; 4]) -> i32 {
23	23		let mut sum: i32 = 0;
24	24		let mut i: u32 = 0;
25	25
26	26		while (i < 4) {
27		-	sum = sum + points[i].x + points[i].y;
28		-	i = i + 1;
	27	+	sum += points[i].x + points[i].y;
	28	+	i += 1;
29	29		}
30	30		return sum;
31	31		}
32	32
33	33		fn shiftPoints(points: [Point; 4], dx: i32, dy: i32) -> [Point; 4] {

63	63		let mut shifted: [Point; 4] = shiftPoints(points, 1, 1);
64	64		// Calculate distance between original and shifted array elements.
65	65		let mut distance: i32 = 0;
66	66		let mut i: u32 = 0;
67	67		while (i < points.len) {
68		-	distance = distance + calculateDistance(points[i], shifted[i]);
69		-	i = i + 1;
	68	+	distance += calculateDistance(points[i], shifted[i]);
	69	+	i += 1;
70	70		}
71	71		return total + distance + shifted[3].x - points[0].y;
72	72		}

16	16		fn testBasicAliasing() -> i32 {
17	17		let mut x: i32 = 10;
18	18		let mut y: i32 = x; // y aliases x's value
19	19
20	20		x = 20; // Modify x
21		-	y = y + 5; // Modify y independently
	21	+	y += 5; // Modify y independently
22	22
23	23		return x + y; // Should be 20 + 15 = 35
24	24		}
25	25
26	26		/// Struct aliasing and field mutation.

67	67		let mut result: i32 = 0;
68	68		let mut temp: i32 = 10;
69	69		result = temp; // First assignment
70	70
71	71		temp = 20; // Overwrite temp
72		-	result = result + temp; // result = 10 + 20 = 30
	72	+	result += temp; // result = 10 + 20 = 30
73	73
74	74		// Create new scope with same variable name
75	75		if true {
76	76		let mut temp: i32 = 50; // Shadow outer temp
77		-	result = result + temp; // result = 30 + 50 = 80
	77	+	result += temp; // result = 30 + 50 = 80
78	78		temp = 60; // Modify inner temp
79		-	result = result + temp; // result = 80 + 60 = 140
	79	+	result += temp; // result = 80 + 60 = 140
80	80		}
81		-	result = result + temp; // Should use outer temp (20)
	81	+	result += temp; // Should use outer temp (20)
82	82
83	83		return result; // 140 + 20 = 160
84	84		}
85	85
86	86		/// Array of structs with aliasing.

4	4		let mut result: i32 = 0;
5	5		let mut temp: i32 = 10;
6	6		result = temp;
7	7
8	8		temp = 20;
9		-	result = result + temp;
	9	+	result += temp;
10	10
11	11		if true {
12	12		let mut temp: i32 = 50;
13		-	result = result + temp;
	13	+	result += temp;
14	14		temp = 60;
15		-	result = result + temp;
	15	+	result += temp;
16	16		}
17	17		// Must refer to outer `temp` (20), not inner shadowed `temp` (60).
18		-	result = result + temp;
	18	+	result += temp;
19	19
20	20		return result;
21	21		}
22	22
23	23		@default fn main() -> i32 {

1	1		//! Test short-circuiting behavior of 'and' and 'or' operators.
2	2		fn modify(counter: *mut i32, ret: bool) -> bool {
3		-	counter = counter + 1;
	3	+	*counter += 1;
4	4		return ret;
5	5		}
6	6
7	7		@default fn main() -> i32 {
8	8		// Test 'and' short-circuits when first operand is false.