radiance · commit

compiler/radiance.rad +1 -1

    let options = lower::LowerOptions { debug: ctx.debug, buildTest: ctx.config.buildTest };
    let mut low = lower::lowerer(res, &ctx.graph, entryPkg.name, &mut res.arena, options);

    // Lower all packages except entry.
    for i in 0..ctx.packageCount {
        if i != entryIdx {
        if i <> entryIdx {
            try lowerPackage(ctx, res, &mut low, &mut ctx.packages[i], false);
        }
    }
    // Lower entry package.
    let defaultFn = try lowerPackage(ctx, res, &mut low, &mut ctx.packages[entryIdx], true);

lib/std/arch/rv64/decode.rad +7 -7

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

/// Extract I-type immediate (sign-extended).
export fn immI(instr: u32) -> i32 {
    let imm = instr >> 20;
    if (imm & 0x800) != 0 {
    if (imm & 0x800) <> 0 {
        return (imm | 0xFFFFF000) as i32;
    }
    return imm as i32;
}

/// Extract S-type immediate (sign-extended).
export fn immS(instr: u32) -> i32 {
    let lo = (instr >> 7) & 0x1F;
    let hi = (instr >> 25) & 0x7F;
    let imm = (hi << 5) | lo;
    if (imm & 0x800) != 0 {
    if (imm & 0x800) <> 0 {
        return (imm | 0xFFFFF000) as i32;
    }
    return imm as i32;
}


    let imm11 = (instr >> 7) & 0x1;
    let imm4_1 = (instr >> 8) & 0xF;
    let imm10_5 = (instr >> 25) & 0x3F;
    let imm12 = (instr >> 31) & 0x1;
    let imm = (imm12 << 12) | (imm11 << 11) | (imm10_5 << 5) | (imm4_1 << 1);
    if (imm & 0x1000) != 0 {
    if (imm & 0x1000) <> 0 {
        return (imm | 0xFFFFE000) as i32;
    }
    return imm as i32;
}


    let imm19_12 = (instr >> 12) & 0xFF;
    let imm11 = (instr >> 20) & 0x1;
    let imm10_1 = (instr >> 21) & 0x3FF;
    let imm20 = (instr >> 31) & 0x1;
    let imm = (imm20 << 20) | (imm19_12 << 12) | (imm11 << 11) | (imm10_1 << 1);
    if (imm & 0x100000) != 0 {
    if (imm & 0x100000) <> 0 {
        return (imm | 0xFFE00000) as i32;
    }
    return imm as i32;
}

/// Extract U-type immediate (upper 20 bits, sign-extended).
export fn immU(instr: u32) -> i32 {
    let imm = instr >> 12;
    if (imm & 0x80000) != 0 {
    if (imm & 0x80000) <> 0 {
        return (imm | 0xFFF00000) as i32;
    }
    return imm as i32;
}


                case encode::F3_OR   => return Instr::Ori { rd, rs1, imm },
                case encode::F3_AND  => return Instr::Andi { rd, rs1, imm },
                case encode::F3_SLL  => return Instr::Slli { rd, rs1, shamt: imm & 0x3F },
                case encode::F3_SRL  => {
                    let shamt = imm & 0x3F;
                    if (imm & 0x400) != 0 {
                    if (imm & 0x400) <> 0 {
                        return Instr::Srai { rd, rs1, shamt };
                    } else {
                        return Instr::Srli { rd, rs1, shamt };
                    }
                },

            match f3 {
                case encode::F3_ADD => return Instr::Addiw { rd, rs1, imm },
                case encode::F3_SLL => return Instr::Slliw { rd, rs1, shamt: imm & 0x1F },
                case encode::F3_SRL => {
                    let shamt = imm & 0x1F;
                    if (imm & 0x400) != 0 {
                    if (imm & 0x400) <> 0 {
                        return Instr::Sraiw { rd, rs1, shamt };
                    } else {
                        return Instr::Srliw { rd, rs1, shamt };
                    }
                },

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


    // Build list of callee-saved registers with offsets.
    let mut offset = totalSize - (super::DWORD_SIZE * 3);
    for reg, i in super::CALLEE_SAVED {
        // Check if this register is in use.
        if (usedCalleeSaved & (1 << i)) != 0 {
        if (usedCalleeSaved & (1 << i)) <> 0 {
            frame.savedRegs[frame.savedRegsLen] = SavedReg {
                reg,
                offset,
            };
            frame.savedRegsLen += 1;

export fn splitImm(imm: i32) -> SplitImm {
    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 {
    if (lo & 0x800) <> 0 {
        hi += 1;
        return SplitImm { hi, lo: lo | 0xFFFFF000 as i32 };
    }
    return SplitImm { hi, lo };
}

    // Check if the value fits in 32 bits (sign-extended).
    let lo32 = imm as i32;
    if lo32 as i64 == imm {
        let s = splitImm(lo32);
        emit(e, encode::lui(rd, s.hi));
        if s.lo != 0 {
        if s.lo <> 0 {
            emit(e, encode::addiw(rd, rd, s.lo));
        }
        return;
    }
    // Full 64-bit immediate: use only rd, no scratch registers.

lib/std/arch/rv64/encode.rad +3 -3

/// Branch if equal: `if (rs1 == rs2) pc += imm`.
export fn beq(rs1: gen::Reg, rs2: gen::Reg, imm: i32) -> u32 {
    return encodeB(OP_BRANCH, rs1, rs2, F3_BEQ, imm);
}

/// Branch if not equal: `if (rs1 != rs2) pc += imm`.
/// Branch if not equal: `if (rs1 <> rs2) pc += imm`.
export fn bne(rs1: gen::Reg, rs2: gen::Reg, imm: i32) -> u32 {
    return encodeB(OP_BRANCH, rs1, rs2, F3_BNE, imm);
}

/// Branch if less than (signed): `if (rs1 < rs2) pc += imm`.

/// Implemented as `sltiu rd, rs, 1`.
export fn seqz(rd: gen::Reg, rs: gen::Reg) -> u32 {
    return sltiu(rd, rs, 1);
}

/// Set if not equal to zero: `rd = (rs != 0) ? 1 : 0`.
/// Set if not equal to zero: `rd = (rs <> 0) ? 1 : 0`.
/// Implemented as `sltu rd, zero, rs`.
export fn snez(rd: gen::Reg, rs: gen::Reg) -> u32 {
    return sltu(rd, super::ZERO, rs);
}

/// Branch if equal to zero: `if (rs == 0) pc += imm`.
export fn beqz(rs: gen::Reg, imm: i32) -> u32 {
    return beq(rs, super::ZERO, imm);
}

/// Branch if not equal to zero: `if (rs != 0) pc += imm`.
/// Branch if not equal to zero: `if (rs <> 0) pc += imm`.
export fn bnez(rs: gen::Reg, imm: i32) -> u32 {
    return bne(rs, super::ZERO, imm);
}

/// Call: `jal ra, imm`.

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

    return rd;
}

/// Emit a move instruction if source and destination differ.
fn emitMv(s: *mut Selector, rd: gen::Reg, rs: gen::Reg) {
    if *rd != *rs {
    if *rd <> *rs {
        emit::emit(s.e, encode::mv(rd, rs));
    }
}

/// Emit zero-extension from a sub-word type to the full register width.

/// Resolve a value, trap if zero (unless known non-zero), and return the register.
fn resolveAndTrapIfZero(s: *mut Selector, b: il::Val) -> gen::Reg {
    let rs2 = resolveVal(s, super::SCRATCH2, b);
    let mut knownNonZero = false;
    if let case il::Val::Imm(imm) = b {
        knownNonZero = imm != 0;
        knownNonZero = imm <> 0;
    }
    if not knownNonZero {
        emit::emit(s.e, encode::bne(rs2, super::ZERO, super::INSTR_SIZE * 2));
        emit::emit(s.e, encode::ebreak());
    }


            // For large blits where both pointers are in real registers,
            // use an inline loop instead of unrolled LD/SD pairs.
            let dwordBytes = remaining & ~(super::DWORD_SIZE - 1);
            let canLoop = not bothSpilled
                and *rsrc != *super::SCRATCH1 and *rsrc != *super::SCRATCH2
                and *rdst != *super::SCRATCH1 and *rdst != *super::SCRATCH2;
                and *rsrc <> *super::SCRATCH1 and *rsrc <> *super::SCRATCH2
                and *rdst <> *super::SCRATCH1 and *rdst <> *super::SCRATCH2;

            if canLoop and dwordBytes >= super::BLIT_LOOP_THRESHOLD {
                emit::emitAddImm(s.e, super::SCRATCH1, rsrc, dwordBytes);

                let loopStart = s.e.codeLen;

                emit::emitLd(s.e, super::SCRATCH2, rsrc, 0);
                emit::emitSd(s.e, super::SCRATCH2, rdst, 0);
                emit::emit(s.e, encode::addi(rsrc, rsrc, super::DWORD_SIZE));

                if *rdst != *rsrc {
                if *rdst <> *rsrc {
                    emit::emit(s.e, encode::addi(rdst, rdst, super::DWORD_SIZE));
                }
                let brOff = (loopStart as i32 - s.e.codeLen as i32) * super::INSTR_SIZE;

                emit::emit(s.e, encode::bne(rsrc, super::SCRATCH1, brOff));

            // it does, advance the base registers by the accumulated
            // offset and reset to zero.
            while remaining >= super::DWORD_SIZE {
                if offset > super::MAX_IMM - super::DWORD_SIZE {
                    emit::emitAddImm(s.e, rsrc, rsrc, offset);
                    if *rdst != *rsrc {
                    if *rdst <> *rsrc {
                        emit::emitAddImm(s.e, rdst, rdst, offset);
                    }
                    offset = 0;
                }
                if let off = srcReload {

                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 != *rsrc {
                    if *rdst <> *rsrc {
                        emit::emitAddImm(s.e, rdst, rdst, offset);
                    }
                    offset = 0;
                }
                if let off = srcReload {

                remaining -= super::WORD_SIZE;
            }
            while remaining > 0 {
                if offset > super::MAX_IMM - 1 {
                    emit::emitAddImm(s.e, rsrc, rsrc, offset);
                    if *rdst != *rsrc {
                    if *rdst <> *rsrc {
                        emit::emitAddImm(s.e, rdst, rdst, offset);
                    }
                    offset = 0;
                }
                if let off = srcReload {

            }
            // Restore base registers if they were advanced (never happens
            // in the both-spilled case since size <= MAX_IMM).
            if not bothSpilled {
                let advanced = staticSize as i32 - offset;
                if advanced != 0 {
                if advanced <> 0 {
                    emit::emitAddImm(s.e, rsrc, rsrc, 0 - advanced);
                    if *rdst != *rsrc {
                    if *rdst <> *rsrc {
                        emit::emitAddImm(s.e, rdst, rdst, 0 - advanced);
                    }
                }
            }
        },

                let rs = resolveVal(s, super::SCRATCH1, v);
                emitMv(s, super::A0, rs);
            }
            // Skip the jump to epilogue if this RET is in the last block,
            // since the epilogue immediately follows.
            if frame.totalSize != 0 and blockIdx + 1 == frame.epilogueBlock {
            if frame.totalSize <> 0 and blockIdx + 1 == frame.epilogueBlock {
                // Epilogue is the next block; fallthrough is sufficient.
            } else {
                emit::emitReturn(s.e, frame);
            }
        },
        case il::Instr::Jmp { target, args } => {
            // Move arguments to target block's parameter registers.
            emitBlockArgs(s, func, target, args);
            // Skip branch if target is the next block (fallthrough).
            if target != blockIdx + 1 {
            if target <> blockIdx + 1 {
                emit::recordBranch(s.e, target, emit::BranchKind::Jump);
            }
        },
        case il::Instr::Br { op, typ, a, b, thenTarget, thenArgs, elseTarget, elseArgs } => {
            // Use zero register directly for immediate `0` operands.

                panic "selectInstr: both `then` and `else` have block arguments";
            } else if thenArgs.len > 0 {
                emit::recordBranch(s.e, elseTarget, emit::BranchKind::InvertedCond { op, rs1, rs2 });
                emitBlockArgs(s, func, thenTarget, thenArgs);
                // Skip trailing jump if then is the next block (fallthrough).
                if thenTarget != blockIdx + 1 {
                if thenTarget <> blockIdx + 1 {
                    emit::recordBranch(s.e, thenTarget, emit::BranchKind::Jump);
                }
            } else if thenTarget == blockIdx + 1 and elseArgs.len == 0 {
                // Then is the next block and no else args: invert the
                // condition to branch to else and fall through to then.
                emit::recordBranch(s.e, elseTarget, emit::BranchKind::InvertedCond { op, rs1, rs2 });
            } else {
                emit::recordBranch(s.e, thenTarget, emit::BranchKind::Cond { op, rs1, rs2 });
                emitBlockArgs(s, func, elseTarget, elseArgs);
                // Skip trailing jump if else is the next block (fallthrough).
                if elseTarget != blockIdx + 1 {
                if elseTarget <> blockIdx + 1 {
                    emit::recordBranch(s.e, elseTarget, emit::BranchKind::Jump);
                }
            }
        },
        case il::Instr::Switch { val, defaultTarget, defaultArgs, cases } => {

    // Number of pending moves.
    let mut numPending: u32 = 0;

    for i in 0..n {
        let dst = dsts[i];
        if dst != super::ZERO { // Skip entries with no destination.
        if dst <> super::ZERO { // Skip entries with no destination.
            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 += 1;
                    } else {
                        let src = getReg(s, r);
                        if src != dst {
                        if src <> dst {
                            // Register-to-register move needed.
                            srcRegs[i] = src;
                            isRegMove[i] = true;
                            pending[i] = true;
                            numPending += 1;

                let dst = dsts[i];
                let mut isReady = true;

                // Check if `dst` is used as source by any other pending register move.
                for j in 0..n {
                    if j != i and pending[j] and isRegMove[j] and srcRegs[j] == dst {
                    if j <> i and pending[j] and isRegMove[j] and srcRegs[j] == dst {
                        isReady = false;
                        break;
                    }
                }
                if isReady {

lib/std/fmt.rad +4 -4

23	23		if x == 0 {
24	24		i -= 1;
25	25		buffer[i] = '0';
26	26		} else {
27	27		// Write digits backwards from the end of the buffer.
28		-	while x != 0 {
	28	+	while x <> 0 {
29	29		i -= 1;
30	30		buffer[i] = ('0' + (x % 10) as u8);
31	31		x /= 10;
32	32		}
33	33		}

    if x == 0 {
        i -= 1;
        buffer[i] = '0';
    } else {
        // Write digits backwards from the end of the buffer.
        while x != 0 {
        while x <> 0 {
            i -= 1;
            buffer[i] = '0' + (x % 10) as u8;
            x /= 10;
        }
        // Add the negative sign if needed.

72	72
73	73		if x == 0 {
74	74		i -= 1;
75	75		buffer[i] = '0';
76	76		} else {
77		-	while x != 0 {
	77	+	while x <> 0 {
78	78		i -= 1;
79	79		buffer[i] = ('0' + (x % 10) as u8);
80	80		x /= 10;
81	81		}
82	82		}

92	92		let mut i: u32 = buffer.len;
93	93		if x == 0 {
94	94		i -= 1;
95	95		buffer[i] = '0';
96	96		} else {
97		-	while x != 0 {
	97	+	while x <> 0 {
98	98		i -= 1;
99	99		buffer[i] = '0' + (x % 10) as u8;
100	100		x /= 10;
101	101		}
102	102		if neg {

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


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

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

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

    return false;
}

/// Check if an attribute set includes the given attribute.
export fn hasAttribute(attrs: u32, attr: Attribute) -> bool {
    return (attrs & (attr as u32)) != 0;
    return (attrs & (attr as u32)) <> 0;
}

/// Signedness of an integer type.
export union Signedness {
    /// Signed, eg. `i8`.

    /// Right shift (`>>`).
    Shr,

    /// Equality comparison (`==`).
    Eq,
    /// Inequality comparison (`!=`).
    /// Inequality comparison (`<>`).
    Ne,
    /// Less-than comparison (`<`).
    Lt,
    /// Greater-than comparison (`>`).
    Gt,

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

        case super::BinaryOp::BitOr => return "|",
        case super::BinaryOp::BitXor => return "^",
        case super::BinaryOp::Shl => return "<<",
        case super::BinaryOp::Shr => return ">>",
        case super::BinaryOp::Eq => return "==",
        case super::BinaryOp::Ne => return "!=",
        case super::BinaryOp::Ne => return "<>",
        case super::BinaryOp::Lt => return "<",
        case super::BinaryOp::Gt => return ">",
        case super::BinaryOp::Lte => return "<=",
        case super::BinaryOp::Gte => return ">=",
        case super::BinaryOp::And => return "and",

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

        return false;
    }
    let word = n / 32;
    let b = n % 32;

    return (bs.bits[word] & (1 << b)) != 0;
    return (bs.bits[word] & (1 << b)) <> 0;
}

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

    let maxWords = max(numWordsA, numWordsB);

    for i in 0..maxWords {
        let wordA = a.bits[i] if i < numWordsA else 0;
        let wordB = b.bits[i] if i < numWordsB else 0;
        if wordA != wordB {
        if wordA <> wordB {
            return false;
        }
    }
    return true;
}

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

//!   REPEAT UNTIL changed == false
//!     changed = false
//!     FOR EACH BLOCK b IN POST-ORDER DO
//!       newOut = UNION(liveIn[succ] FOR EACH SUCCESSOR OF b)
//!       newIn = uses[b] | (newOut - defs[b])
//!       IF newIn != liveIn[b] OR newOut != liveOut[b] THEN
//!       IF newIn <> liveIn[b] OR newOut <> liveOut[b] THEN
//!         changed = true
//!         liveIn[b] = newIn
//!         liveOut[b] = newOut
//!
//! Usage:

) -> bool {
    let numWords = dst.bits.len;
    let mut changed = false;
    for i in 0..numWords {
        let newWord = uses.bits[i] | (liveOut.bits[i] & ~defs.bits[i]);
        if dst.bits[i] != newWord {
        if dst.bits[i] <> newWord {
            dst.bits[i] = newWord;
            changed = true;
        }
    }
    return changed;

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


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

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

/// Return the accumulated values.

    }
}

/// Compare two data value slices for structural equality.
fn dataValuesEq(a: *[il::DataValue], b: *[il::DataValue]) -> bool {
    if a.len != b.len {
    if a.len <> b.len {
        return false;
    }
    for i in 0..a.len {
        if a[i].count != b[i].count {
        if a[i].count <> b[i].count {
            return false;
        }
        if not dataItemEq(a[i].item, b[i].item) {
            return false;
        }

    switchToBlock(self, target);
}

/// Emit a conditional branch based on `cond`.
fn emitBr(self: *mut FnLowerer, cond: il::Reg, thenBlock: BlockId, elseBlock: BlockId) throws (LowerError) {
    assert thenBlock != elseBlock;
    assert thenBlock <> elseBlock;
    emit(self, il::Instr::Br {
        op: il::CmpOp::Ne,
        typ: il::Type::W32,
        a: il::Val::Reg(cond),
        b: il::Val::Imm(0),

    a: il::Val,
    b: il::Val,
    thenBlock: BlockId,
    elseBlock: BlockId
) throws (LowerError) {
    assert thenBlock != elseBlock;
    assert thenBlock <> elseBlock;
    emit(self, il::Instr::Br {
        op, typ, a, b,
        thenTarget: *thenBlock, thenArgs: &mut [],
        elseTarget: *elseBlock, elseArgs: &mut [],
    });


/// Add a predecessor edge from `pred` to `target`.
/// Must be called before the target block is sealed. Duplicates are ignored.
fn addPredecessor(self: *mut FnLowerer, target: BlockId, pred: BlockId) {
    let blk = getBlockMut(self, target);
    assert blk.sealState != Sealed::Yes, "addPredecessor: adding predecessor to sealed block";
    assert blk.sealState <> Sealed::Yes, "addPredecessor: adding predecessor to sealed block";
    let preds = &mut blk.preds;
    for i in 0..preds.len {
        if preds[i] == *pred { // Avoid duplicate predecessor entries.
            return;
        }

    self.loopDepth += 1;
}

/// Exit the current loop context.
fn exitLoop(self: *mut FnLowerer) {
    assert self.loopDepth != 0, "exitLoop: loopDepth is zero";
    assert self.loopDepth <> 0, "exitLoop: loopDepth is zero";
    self.loopDepth -= 1;
}

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

) -> Var {
    let id = self.vars.len;
    self.vars.append(VarData { name, type, mutable, addressTaken: false }, self.allocator);

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


        }
        // Single predecessor means no merge needed, variable is implicitly
        // available without a block parameter.
        if blk.preds.len == 1 {
            let pred = BlockId(blk.preds[0]);
            if *pred != *block {
            if *pred <> *block {
                let val = try useVarInBlock(self, pred, v);
                blk.vars[*v] = val; // Cache.
                return val;
            }
        }

///
/// This function creates a fresh register `%1` as a block parameter, then patches
/// each predecessor's jump to pass its value of `x` as an argument.
fn createBlockParam(self: *mut FnLowerer, block: BlockId, v: Var) -> il::Val throws (LowerError) {
    // Entry block must not have block parameters.
    assert block != self.entryBlock, "createBlockParam: entry block must not have block parameters";
    assert block <> self.entryBlock, "createBlockParam: entry block must not have block parameters";
    // Allocate a register to hold the merged value.
    let reg = nextReg(self);
    let type = getVar(self, v).type;

    // Create block parameter and add it to the block.

    for predId in blk.preds {
        let pred = BlockId(predId);
        // This may recursively trigger more block arg resolution if the
        // predecessor also needs to look up the variable from its predecessors.
        let val = try useVarInBlock(self, pred, v);
        assert val != il::Val::Undef, "createBlockParam: predecessor provides undef value for block parameter";
        assert val <> il::Val::Undef, "createBlockParam: predecessor provides undef value for block parameter";
        patchTerminatorArg(self, pred, *block, paramIdx, val);
    }
}

/// Check if a block parameter is trivial, i.e. all predecessors provide

        // itself. We skip self-references when checking for trivial phis.
        if let reg = paramReg {
            if val == reg {
                // Self-reference, skip this predecessor.
            } else if let sv = sameVal {
                if val != sv {
                if val <> sv {
                    // Multiple different values, not trivial.
                    return nil;
                }
            } else {
                sameVal = val;

    self: *mut FnLowerer,
    fnType: resolver::FnType,
    astParams: *mut [*ast::Node],
    receiverName: ?*ast::Node
) -> *[il::Param] throws (LowerError) {
    let offset: u32 = 1 if self.returnReg != nil else 0;
    let offset: u32 = 1 if self.returnReg <> nil else 0;
    let totalLen = fnType.paramTypes.len as u32 + offset;
    if totalLen == 0 {
        return &[];
    }
    assert fnType.paramTypes.len as u32 <= resolver::MAX_FN_PARAMS;

        case resolver::Type::Optional(_) => return tvalTagReg(self, reg),
        else => return reg,
    }
}

/// Lower an optional nil check (`opt == nil` or `opt != nil`).
/// Lower an optional nil check (`opt == nil` or `opt <> nil`).
fn lowerNilCheck(self: *mut FnLowerer, opt: *ast::Node, isEq: bool) -> il::Val throws (LowerError) {
    let optTy = try typeOf(self, opt);
    // Handle `nil == nil` or `nil != nil`.
    // Handle `nil == nil` or `nil <> nil`.
    if optTy == resolver::Type::Nil {
        return il::Val::Imm(1) if isEq else il::Val::Imm(0);
    }
    let val = try lowerExpr(self, opt);
    let cmpReg = try optionalNilReg(self, val, optTy);

        let prongScope = enterVarScope(self);
        let case ast::NodeValue::MatchProng(prong) = prongNode.value
            else panic "lowerMatch: expected match prong";

        let isLastArm = i + 1 == prongs.len;
        let hasGuard = prong.guard != nil;
        let hasGuard = prong.guard <> nil;
        let catchAll = resolver::isProngCatchAll(self.low.resolver, prongNode);

        // Entry block: guard block if present, otherwise the body block.
        // The guard block must be created before the body block so that
        // block indices are in reverse post-order (RPO), which the register

        }

        // Evaluate guard if present; can still fail to next arm.
        if let g = prong.guard {
            try emitCondBranch(self, g, bodyBlock, nextArm);
        } else if *currentBlock(self) != *bodyBlock {
        } else if *currentBlock(self) <> *bodyBlock {
            // Nested tests changed the current block. Create a new body block
            // after the nest blocks to maintain RPO ordering, and jump to it.
            bodyBlock = try createBlock(self, bodyLabel);
            try emitJmp(self, bodyBlock);
        }

) throws (LowerError) {
    // If guard present, pattern match jumps to @guard, then guard evaluation
    // jumps to `successBlock` or `failBlock`. Otherwise, jump directly to
    // `successBlock`.
    let mut targetBlock: BlockId = undefined;
    if pat.guard != nil {
    if pat.guard <> nil {
        targetBlock = try createBlock(self, "guard");
        *successBlock = try createBlock(self, successLabel);
    } else {
        targetBlock = *successBlock;
    }

    }
    // Handle guard: on success jump to `successBlock`, on failure jump to `failBlock`.
    if let g = pat.guard {
        try emitCondBranch(self, g, *successBlock, failBlock);
        try switchToAndSeal(self, *successBlock);
    } else if *currentBlock(self) != *targetBlock {
    } else if *currentBlock(self) <> *targetBlock {
        // Nested tests changed the current block. Create a new success block
        // after the nest blocks to maintain RPO ordering, and jump to it.
        *successBlock = try createBlock(self, successLabel);

        try emitJmp(self, *successBlock);

    };
    let case resolver::SymbolData::Variant { type: payloadType, index, .. } = sym.data else {
        return nil;
    };
    // Only void variants can use tag-only comparison.
    if payloadType != resolver::Type::Void {
    if payloadType <> resolver::Type::Void {
        return nil;
    }
    return index as i64;
}


    } else {
        emitStoreW64At(self, il::Val::Imm(tag), dst, TVAL_TAG_OFFSET);
    }

    if let val = payload {
        if payloadType != resolver::Type::Void {
        if payloadType <> resolver::Type::Void {
            try emitStore(self, dst, valOffset, payloadType, val);
        }
    }
    return il::Val::Reg(dst);
}

    let tagB = loadTag(self, b, offset + TVAL_TAG_OFFSET, il::Type::W8);

    // For simple inner types (no unions/nested optionals), use branchless comparison.
    // Unions and nested optionals may contain uninitialized payload bytes
    // when nil, so they need a guarded comparison.
    let isUnion = unionInfoFromType(inner) != nil;
    let isUnion = unionInfoFromType(inner) <> nil;
    let mut isOptional = false;
    if let case resolver::Type::Optional(_) = inner {
        isOptional = true;
    }
    if not isUnion and not isOptional {

    let tagBlock = try createBlock(self, "eq#tag");

    // Compare tags: if they differ, jump to merge with `false`; otherwise check payloads.
    let falseArgs = try allocVal(self, il::Val::Imm(0));

    assert tagBlock != mergeBlock;
    assert tagBlock <> mergeBlock;

    // TODO: Use the helper once the compiler supports more than eight function params.
    emit(self, il::Instr::Br {
        op: il::CmpOp::Eq, typ: il::Type::W8, a: tagA, b: tagB,
        thenTarget: *tagBlock, thenArgs: &mut [],

    let unionInfo = unionInfoFromType(unionTy) else {
        throw LowerError::MissingMetadata;
    };
    let valOffset = unionInfo.valOffset as i32;
    let mut payloadVal: ?il::Val = nil;
    if payloadType != resolver::Type::Void {
    if payloadType <> resolver::Type::Void {
        let case resolver::Type::Nominal(payloadNominal) = payloadType else {
            throw LowerError::MissingMetadata;
        };
        payloadVal = try lowerRecordCtor(self, payloadNominal, call.args);
    }

    // value. Otherwise, we have to compute it.
    let mut count = endVal;

    // Only compute range offset and count if the start value is not
    // statically known to be zero.
    if startVal != il::Val::Imm(0) {
    if startVal <> il::Val::Imm(0) {
        // Offset the data pointer by the start value.
        dataReg = emitElem(
            self, resolver::getTypeLayout(*info.itemType).size, dataReg, startVal
        );
        // Compute the count as `end - start`.

            let endVal = try lowerExpr(self, endExpr);
            let iterType = ilType(self.low, *valType);
            let valVar = newVar(self, bindingName, iterType, false, startVal);

            let mut indexVar: ?Var = nil;
            if indexName != nil { // Optional index always starts at zero.
            if indexName <> nil { // Optional index always starts at zero.
                indexVar = newVar(self, indexName, il::Type::W32, false, il::Val::Imm(0));
            }
            let iter = ForIter::Range {
                valVar, indexVar, endVal, valType: iterType,
                unsigned: isUnsignedType(*valType),

            // Declare index value binidng.
            let idxVar = newVar(self, indexName, il::Type::W32, false, il::Val::Imm(0));

            // Declare element value binding.
            let mut valVar: ?Var = nil;
            if bindingName != nil {
            if bindingName <> nil {
                valVar = newVar(
                    self,
                    bindingName,
                    ilType(self.low, *elemType),
                    false,

        }
    }
    // Lower operands.
    let a = try lowerExpr(self, binop.left);
    let b = try lowerExpr(self, binop.right);
    let isComparison = cmpOpFrom(binop.op, false) != nil;
    let isComparison = cmpOpFrom(binop.op, false) <> nil;

    // The result type for comparisons is always `bool`, while for arithmetic
    // operations, it's the operand type. We set this appropriately here.
    let nodeTy = try typeOf(self, node);
    let mut resultTy = nodeTy;

    }
}

/// Lower a `@sliceOf(ptr, len)` or `@sliceOf(ptr, len, cap)` builtin call.
fn lowerSliceOf(self: *mut FnLowerer, node: *ast::Node, args: *mut [*ast::Node]) -> il::Val throws (LowerError) {
    if args.len != 2 and args.len != 3 {
    if args.len <> 2 and args.len <> 3 {
        throw LowerError::InvalidArgCount;
    }
    let sliceTy = try typeOf(self, node);
    let case resolver::Type::Slice { item, mutable } = sliceTy else {
        throw LowerError::ExpectedSliceOrArray;

        // Extract the success payload. If the result type differs from the payload
        // type (e.g. `try?` wrapping `T` into `?T`), wrap the value.
        let payloadVal = tvalPayloadVal(self, base, okValueTy, RESULT_VAL_OFFSET);
        let mut okVal = payloadVal;

        if t.returnsOptional and tryExprTy != okValueTy {
        if t.returnsOptional and tryExprTy <> okValueTy {
            okVal = try wrapInOptional(self, payloadVal, tryExprTy);
        }
        try emitStore(self, slot, 0, tryExprTy, okVal);
    }
    // Jump to merge block if unterminated.

        // `try ... catch` -- handle the error.
        let firstNode = t.catches[0];
        let case ast::NodeValue::CatchClause(first) = firstNode.value
            else panic "lowerTry: expected CatchClause";

        if first.typeNode != nil or t.catches.len > 1 {
        if first.typeNode <> nil or t.catches.len > 1 {
            // Typed multi-catch: switch on global error tag.
            try lowerMultiCatch(self, t.catches, calleeInfo, base, tagReg, &mut mergeBlock);
        } else {
            // Single untyped catch clause.
            let savedVarsLen = enterVarScope(self);

            args,
        });
        return il::Val::Reg(dst);
    }
    let mut dst: ?il::Reg = nil;
    if retTy != resolver::Type::Void {
    if retTy <> resolver::Type::Void {
        dst = nextReg(self);
    }
    emit(self, il::Instr::Call {
        retTy: ilType(self.low, retTy),
        dst,

    }
}

/// Lower an ecall intrinsic: `ecall(num, a0, a1, a2, a3) -> i32`.
fn lowerEcall(self: *mut FnLowerer, call: ast::Call) -> il::Val throws (LowerError) {
    if call.args.len != 5 {
    if call.args.len <> 5 {
        throw LowerError::InvalidArgCount;
    }
    let num = try lowerExpr(self, call.args[0]);
    let a0 = try lowerExpr(self, call.args[1]);
    let a1 = try lowerExpr(self, call.args[2]);

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

/// Lower an ebreak intrinsic: `ebreak()`.
fn lowerEbreak(self: *mut FnLowerer, call: ast::Call) -> il::Val throws (LowerError) {
    if call.args.len != 0 {
    if call.args.len <> 0 {
        throw LowerError::InvalidArgCount;
    }
    emit(self, il::Instr::Ebreak);

    return il::Val::Undef;

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

    if path.len < SOURCE_EXT.len {
        return nil;
    }
    let extStart = path.len - SOURCE_EXT.len;
    for ext, i in SOURCE_EXT {
        if path[extStart + i] != ext {
        if path[extStart + i] <> ext {
            return nil;
        }
    }
    return &path[..extStart];
}

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

            return { op: ast::BinaryOp::BitXor, prec: 3 },
        case scanner::TokenKind::Pipe =>
            return { op: ast::BinaryOp::BitOr, prec: 2 },
        case scanner::TokenKind::EqualEqual =>
            return { op: ast::BinaryOp::Eq, prec: 1 },
        case scanner::TokenKind::BangEqual =>
        case scanner::TokenKind::LtGt =>
            return { op: ast::BinaryOp::Ne, prec: 1 },
        case scanner::TokenKind::Lt =>
            return { op: ast::BinaryOp::Lt, prec: 1 },
        case scanner::TokenKind::Gt =>
            return { op: ast::BinaryOp::Gt, prec: 1 },

fn parseCondExpr(p: *mut Parser, thenExpr: *ast::Node) -> *ast::Node
    throws (ParseError)
{
    // Only parse conditional expressions in normal context.
    // In conditional context, `if` is used for guards.
    if p.context != Context::Normal {
    if p.context <> Context::Normal {
        return thenExpr;
    }
    if not consume(p, scanner::TokenKind::If) {
        return thenExpr;
    }

                result = try parseSubscriptOrSlice(p, result);
            }
            case scanner::TokenKind::LParen => {
                result = try parseCall(p, result);
            }
            case scanner::TokenKind::LBrace if p.context != Context::Condition => {
            case scanner::TokenKind::LBrace if p.context <> Context::Condition => {
                result = try parseRecordLit(p, result);
            }
            else => {
                break;
            }

            return try parseRangeExpr(p, nil);
        }
        case scanner::TokenKind::LBrace => {
            // Anonymous record literal: { x: 1, y: 2 }.
            // Only allowed in normal context, not in conditions.
            if p.context != Context::Normal {
            if p.context <> Context::Normal {
                throw failParsing(p, "unexpected `{` in this context");
            }
            return try parseRecordLit(p, nil);
        }
        else => {

{
    // TODO: Why is `parseStmt` checking for attributes?
    // We should have a `parseDecl` which is top-level, and `parseStmt` which
    // is inside functions.
    let attrs = parseAttributes(p);
    if attrs != nil {
    if attrs <> nil {
        let allowed: bool =
            p.current.kind == scanner::TokenKind::Fn or
            p.current.kind == scanner::TokenKind::Union or
            p.current.kind == scanner::TokenKind::Record or
            p.current.kind == scanner::TokenKind::Mod or


                let field = try parseNameTypeValue(p);
                let type = field.type else {
                    throw failParsing(p, "expected type annotation in record field");
                };
                if field.alignment != nil {
                if field.alignment <> nil {
                    throw failParsing(p, "record fields cannot specify alignment");
                }
                if field.value != nil and mode != RecordFieldMode::Labeled {
                if field.value <> nil and mode <> RecordFieldMode::Labeled {
                    throw failParsing(p, "record fields cannot have initializers");
                }
                recordField = ast::NodeValue::RecordField {
                    field: field.name, type, value: field.value,
                };

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

@test fn testParseStringEscape() throws (testing::TestError) {
    // Tab and newline.
    let r1 = try! parseExprStr("\"hello\\tworld\\n\"");
    let case ast::NodeValue::String(s1) = r1.value if s1.len == 12
        else throw testing::TestError::Failed;
    if s1[5] != '\t' {
    if s1[5] <> '\t' {
        throw testing::TestError::Failed;
    }
    if s1[11] != '\n' {
    if s1[11] <> '\n' {
        throw testing::TestError::Failed;
    }

    // Escaped quote.
    let r2 = try! parseExprStr("\"\\\"\"");
    let case ast::NodeValue::String(s2) = r2.value if s2.len == 1
        else throw testing::TestError::Failed;
    if s2[0] != '"' {
    if s2[0] <> '"' {
        throw testing::TestError::Failed;
    }

    // Escaped backslash.
    let r3 = try! parseExprStr("\"\\\\\"");
    let case ast::NodeValue::String(s3) = r3.value if s3.len == 1
        else throw testing::TestError::Failed;
    if s3[0] != '\\' {
    if s3[0] <> '\\' {
        throw testing::TestError::Failed;
    }

    // Mixed escapes.
    let r4 = try! parseExprStr("\"a\\nb\\tc\"");
    let case ast::NodeValue::String(s4) = r4.value if s4.len == 5
        else throw testing::TestError::Failed;
    if s4[0] != 'a' {
    if s4[0] <> 'a' {
        throw testing::TestError::Failed;
    }
    if s4[1] != '\n' {
    if s4[1] <> '\n' {
        throw testing::TestError::Failed;
    }
    if s4[2] != 'b' {
    if s4[2] <> 'b' {
        throw testing::TestError::Failed;
    }
    if s4[3] != '\t' {
    if s4[3] <> '\t' {
        throw testing::TestError::Failed;
    }
    if s4[4] != 'c' {
    if s4[4] <> 'c' {
        throw testing::TestError::Failed;
    }
}

/// Test parsing placeholder/underscore.

@test fn testParseLetCaseElseWithGuard() throws (testing::TestError) {
    let root = try! parseStmtStr("let case Variant(x) = opt if x > 0 else { return };");
    let case ast::NodeValue::LetElse(letElse) = root.value
        else throw testing::TestError::Failed;

    try testing::expect(letElse.pattern.guard != nil);
    try testing::expect(letElse.pattern.guard <> nil);

    let guardNode = letElse.pattern.guard else throw testing::TestError::Failed;
    let case ast::NodeValue::BinOp(cmp) = guardNode.value
        else throw testing::TestError::Failed;
    try testing::expect(cmp.op == ast::BinaryOp::Gt);

        else throw testing::TestError::Failed;
    let case ast::TypeSig::Pointer { valueType: ptrTarget, mutable: _ } = p1
        else throw testing::TestError::Failed;
    try expectIntType(ptrTarget, 1, ast::Signedness::Unsigned);

    try testing::expect(sig.returnType != nil);
    try testing::expect(sig.returnType <> nil);
}

/// Test parsing a function type with a throws clause.
@test fn testParseTypeFnThrows() throws (testing::TestError) {
    let node = try! parseTypeStr("fn (i32) -> bool throws (Error, Other)");

    let case ast::NodeValue::BinOp(op5) = modOp.value
        else throw testing::TestError::Failed;
    try testing::expect(op5.op == ast::BinaryOp::Mod);
}

/// Test parsing comparison binary operators (==, !=, <>).
/// Test parsing comparison binary operators (==, <>).
@test fn testParseBinOpEq() throws (testing::TestError) {
    let eq = try! parseExprStr("a == b");
    let case ast::NodeValue::BinOp(op1) = eq.value
        else throw testing::TestError::Failed;
    try testing::expect(op1.op == ast::BinaryOp::Eq);

    let ne = try! parseExprStr("x != y");
    let ne = try! parseExprStr("x <> y");
    let case ast::NodeValue::BinOp(op2) = ne.value
        else throw testing::TestError::Failed;
    try testing::expect(op2.op == ast::BinaryOp::Ne);

    let altNe = try! parseExprStr("x <> y");
    let case ast::NodeValue::BinOp(op3) = altNe.value
        else throw testing::TestError::Failed;
    try testing::expect(op3.op == ast::BinaryOp::Ne);
}

/// Test parsing comparison binary operators.
@test fn testParseBinOpGtLt() throws (testing::TestError) {
    let lt = try! parseExprStr("a < b");

    let case ast::NodeValue::UnionDeclVariant(var0) = v0.value
        else throw testing::TestError::Failed;
    try expectIdent(var0.name, "Ok");
    try testing::expect(var0.index == 0);
    try testing::expect(var0.type == nil);
    try testing::expect(var0.value != nil);
    try testing::expect(var0.value <> nil);

    let v1 = variants[1];
    let case ast::NodeValue::UnionDeclVariant(var1) = v1.value
        else throw testing::TestError::Failed;
    try expectIdent(var1.name, "Error");
    try testing::expect(var1.index == 1);
    try testing::expect(var1.value != nil);
    try testing::expect(var1.value <> nil);

    let v2 = variants[2];
    let case ast::NodeValue::UnionDeclVariant(var2) = v2.value
        else throw testing::TestError::Failed;
    try expectIdent(var2.name, "Pending");
    try testing::expect(var2.index == 2);
    try testing::expect(var2.value != nil);
    try testing::expect(var2.value <> nil);
}

/// Test parsing a union with payload and tag-only variants.
@test fn testParseEnumWithPayloads() throws (testing::TestError) {
    let node = try! parseStmtStr("union Result { Ok(bool), Error }");


    let v1 = variants[1];
    let case ast::NodeValue::UnionDeclVariant(var1) = v1.value
        else throw testing::TestError::Failed;
    try expectIdent(var1.name, "Some");
    try testing::expect(var1.type != nil);
    try testing::expect(var1.type <> nil);
}

/// Test parsing named record literals with named fields.
@test fn testParseNamedRecordLiteralNamed() throws (testing::TestError) {
    let r1 = try! parseExprStr("Point { x: 5, y: 10 }");

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

    // If our error list is full, just return an error without recording it.
    if self.errors.len >= self.errors.cap {
        return ResolveError::Failure;
    }
    // Don't record more than one error per node.
    if let n = node; errorForNode(self, n) != nil {
    if let n = node; errorForNode(self, n) <> nil {
        return ResolveError::Failure;
    }
    let idx = self.errors.len;
    self.errors = @sliceOf(self.errors.ptr, idx + 1, self.errors.cap);
    self.errors[idx] = Error { kind, node, moduleId: self.currentMod };

    assert self.loopDepth < MAX_LOOP_DEPTH, "visitLoop: loop nesting depth exceeded";
    self.loopStack[self.loopDepth] = LoopCtx { hasBreak: false };
    self.loopDepth += 1;

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

    let mut maxVarSize: u32 = 0;
    let mut maxVarAlign: u32 = 1;
    let mut isAllVoid: bool = true;

    for variant in variants {
        if variant.valueType != Type::Void {
        if variant.valueType <> Type::Void {
            isAllVoid = false;
            let payloadLayout = getTypeLayout(variant.valueType);
            maxVarSize = max(maxVarSize, payloadLayout.size);
            maxVarAlign = max(maxVarAlign, payloadLayout.alignment);
        }

    match to {
        case Type::Array(lhs) => {
            let case Type::Array(rhs) = from
                else return nil;

            if lhs.length != rhs.length {
            if lhs.length <> rhs.length {
                return nil;
            }
            // For array literals, check each element individually for
            // assignability.
            match rval.value {

                    return Coercion::TraitObject { traitInfo, inst };
                }
            }
            // Identity: same trait object.
            if let case Type::TraitObject { traitInfo: rhsTrait, mutable: rhsMutable } = from {
                if traitInfo != rhsTrait {
                if traitInfo <> rhsTrait {
                    return nil;
                }
                if lhsMutable and not rhsMutable {
                    return nil;
                }

                // For unsuffixed integer expressions (`Type::Int`), only
                // validate literals directly written by the programmer.
                // Folded results (e.g. `0 - 65`) may not fit the target
                // type but are valid wrapping arithmetic at runtime.
                if let value = constValueEntry(self, rval) {
                    if from != Type::Int or isNumberLiteral(rval) {
                    if from <> Type::Int or isNumberLiteral(rval) {
                        if validateConstIntRange(value, to) {
                            return Coercion::Identity;
                        }
                        return nil;
                    }

    return nil;
}

/// Check if two function type descriptors are structurally equivalent.
fn fnTypeEqual(a: *FnType, b: *FnType) -> bool {
    if a.paramTypes.len != b.paramTypes.len {
    if a.paramTypes.len <> b.paramTypes.len {
        return false;
    }
    if a.throwList.len != b.throwList.len {
    if a.throwList.len <> b.throwList.len {
        return false;
    }
    if not typesEqual(*a.returnType, *b.returnType) {
        return false;
    }

/// Check that a node's type is equal to the expected type.
fn checkEqual(self: *mut Resolver, node: *ast::Node, expected: Type) -> Type
    throws (ResolveError)
{
    let actualTy = try visit(self, node, expected);
    if actualTy != expected {
    if actualTy <> expected {
        throw emitTypeMismatch(self, node, TypeMismatch { expected, actual: actualTy });
    }
    return actualTy;
}


    node: *ast::Node,
    access: ast::Access,
    path: *[*[u8]],
    scope: *Scope
) -> *mut Symbol throws (ResolveError) {
    assert path.len != 0, "resolvePath: empty path";
    assert path.len <> 0, "resolvePath: empty path";
    // Start by finding the root of the path.
    let root = path[0];
    let sym = findInScopeRecursive(scope, root, isAnySymbol) else
        throw emitError(self, node, ErrorKind::UnresolvedSymbol(root));
    let suffix = &path[1..];

/// Ensure the `default` attribute is only applied to functions.
fn ensureDefaultAttrNotAllowed(self: *mut Resolver, node: *ast::Node, attrs: u32)
    throws (ResolveError)
{
    let defaultBit = ast::Attribute::Default as u32;
    if (attrs & defaultBit) != 0 {
    if (attrs & defaultBit) <> 0 {
        throw emitError(self, node, ErrorKind::DefaultAttrOnlyOnFn);
    }
}

/// Analyze a block node, allocating a nested lexical scope.

    if let a = decl.alignment {
        let case ast::NodeValue::Align { value } = a.value
            else panic "resolveLet: expected Align node";
        alignment = try checkSizeInt(self, value);
    }
    assert bindingTy != Type::Unknown;
    assert bindingTy <> Type::Unknown;

    // Alignment must be zero or a power of two.
    if alignment != 0 and (alignment & (alignment - 1)) != 0 {
    if alignment <> 0 and (alignment & (alignment - 1)) <> 0 {
        throw emitError(self, decl.value, ErrorKind::InvalidAlignmentValue(alignment));
    }
    let _ = try bindValueIdent(self, decl.ident, node, bindingTy, decl.mutable, alignment, 0);
    setNodeType(self, decl.value, bindingTy);


    }
}

/// Check that the argument count of a constructor pattern or call matches the record field count.
fn checkRecordArity(self: *mut Resolver, args: *mut [*ast::Node], recInfo: RecordType, pattern: *ast::Node) throws (ResolveError) {
    if args.len != recInfo.fields.len {
    if args.len <> recInfo.fields.len {
        throw emitError(self, pattern, ErrorKind::RecordFieldCountMismatch(CountMismatch {
            expected: recInfo.fields.len as u32,
            actual: args.len,
        }));
    }


        let bodyTy = try checkAssignable(self, body, Type::Void) catch e {
            exitFn(self);
            throw e;
        };
        if retTy != Type::Void and bodyTy != Type::Never {
        if retTy <> Type::Void and bodyTy <> Type::Never {
            exitFn(self);
            throw emitError(self, body, ErrorKind::FnMissingReturn);
        }
        exitFn(self);
    } else if not isExtern {

            else throw emitError(self, receiver, ErrorKind::TraitReceiverMismatch);
        let case ast::TypeSig::Nominal(nameNode) = innerSig
            else throw emitError(self, receiver, ErrorKind::TraitReceiverMismatch);
        let receiverTargetName = try nodeName(self, nameNode);

        if receiverTargetName != traitType.name {
        if receiverTargetName <> traitType.name {
            throw emitError(self, receiver, ErrorKind::TraitReceiverMismatch);
        }
        // Resolve parameter types and return type.
        let a = alloc::arenaAllocator(&mut self.arena);
        let mut paramTypes: *mut [*Type] = &mut [];

            mutable: receiverMut,
        };

        // Validate that the instance method's signature matches the
        // trait method's signature exactly (params, return type, throws).
        if sig.params.len != tm.fnType.paramTypes.len {
        if sig.params.len <> tm.fnType.paramTypes.len {
            throw emitError(self, methodNode, ErrorKind::FnArgCountMismatch(CountMismatch {
                expected: tm.fnType.paramTypes.len as u32,
                actual: sig.params.len,
            }));
        }

            throw emitTypeMismatch(self, methodNode, TypeMismatch {
                expected: *tm.fnType.returnType,
                actual: instanceRetTy,
            });
        }
        if sig.throwList.len != tm.fnType.throwList.len {
        if sig.throwList.len <> tm.fnType.throwList.len {
            throw emitError(self, methodNode, ErrorKind::FnThrowCountMismatch(CountMismatch {
                expected: tm.fnType.throwList.len as u32,
                actual: sig.throwList.len,
            }));
        }

    let retTy = *fnType.returnType;
    let bodyTy = try checkAssignable(self, body, Type::Void) catch e {
        exitFn(self);
        throw e;
    };
    if retTy != Type::Void and bodyTy != Type::Never {
    if retTy <> Type::Void and bodyTy <> Type::Never {
        exitFn(self);
        throw emitError(self, body, ErrorKind::FnMissingReturn);
    }
    exitFn(self);
}

                } else => {}
            }
        }
        case Type::Array(arrayInfo) => {
            if let case ast::NodeValue::ArrayLit(items) = pattern.value {
                if items.len as u32 != arrayInfo.length {
                if items.len as u32 <> arrayInfo.length {
                    throw emitError(self, pattern, ErrorKind::RecordFieldCountMismatch(
                        CountMismatch { expected: arrayInfo.length, actual: items.len as u32 }
                    ));
                }
                let elemTy = *arrayInfo.item;

    matchBy: MatchBy
) -> Type throws (ResolveError) {
    // Whether this prong is catch-all.
    let mut isCatchAll = false;

    if prong.guard != nil {
    if prong.guard <> nil {
        state.isConst = false;
    } else {
        match prong.arm {
            case ast::ProngArm::Binding(_),
                 ast::ProngArm::Else => isCatchAll = true,

        throw emitError(self, pattern, ErrorKind::Internal);
    };
    let variant = &unionType.variants[index];
    // If this variant has a payload, throw an error, since the user hasn't
    // provided one.
    if variant.valueType != Type::Void {
    if variant.valueType <> Type::Void {
        throw emitError(self, pattern, ErrorKind::UnionVariantPayloadMissing(variant.name));
    }
}

/// Validate and bind a union constructor call used as a `match` pattern.

    };
    let variant = &unionType.variants[index];
    // Copy variant index to the pattern node for the lowerer.
    setVariantInfo(self, pattern, index, tag);

    if variant.valueType != Type::Void {
    if variant.valueType <> Type::Void {
        try bindUnionPatternPayload(self, pattern, call, variant.name, variant.valueType, matchBy);
    } else {
        throw emitError(self, pattern, ErrorKind::UnionVariantPayloadUnexpected(variant.name));
    }
}

    kind: ast::Builtin,
    args: *mut [*ast::Node]
) -> Type throws (ResolveError) {
    // Handle `@sliceOf(ptr, len)` and `@sliceOf(ptr, len, cap)`.
    if kind == ast::Builtin::SliceOf {
        if args.len != 2 and args.len != 3 {
        if args.len <> 2 and args.len <> 3 {
            throw emitError(self, node, ErrorKind::BuiltinArgCountMismatch(CountMismatch {
                expected: 2,
                actual: args.len as u32,
            }));
        }

        if args.len == 3 {
            let _ = try checkAssignable(self, args[2], Type::U32);
        }
        return setNodeType(self, node, Type::Slice { item: target, mutable });
    }
    if args.len != 1 {
    if args.len <> 1 {
        throw emitError(self, node, ErrorKind::BuiltinArgCountMismatch(CountMismatch {
            expected: 1,
            actual: args.len as u32,
        }));
    }

    throws (ResolveError)
{
    if ctx == CallCtx::Normal and info.throwList.len > 0 {
        throw emitError(self, node, ErrorKind::MissingTry);
    }
    if call.args.len != info.paramTypes.len as u32 {
    if call.args.len <> info.paramTypes.len as u32 {
        throw emitError(self, node, ErrorKind::FnArgCountMismatch(CountMismatch {
            expected: info.paramTypes.len as u32,
            actual: call.args.len,
        }));
    }

    mutable: bool
) -> Type throws (ResolveError) {
    if not mutable {
        throw emitError(self, parent, ErrorKind::ImmutableBinding);
    }
    if args.len != 2 {
    if args.len <> 2 {
        throw emitError(self, node, ErrorKind::FnArgCountMismatch(CountMismatch {
            expected: 2,
            actual: args.len as u32,
        }));
    }

    mutable: bool
) -> Type throws (ResolveError) {
    if not mutable {
        throw emitError(self, parent, ErrorKind::ImmutableBinding);
    }
    if args.len != 1 {
    if args.len <> 1 {
        throw emitError(self, node, ErrorKind::FnArgCountMismatch(CountMismatch {
            expected: 1,
            actual: args.len as u32,
        }));
    }

                else => throw emitError(self, container, ErrorKind::ExpectedIndexable),
            }
            // RHS is either a fill value or a source slice.
            let rhsTy = try infer(self, assign.right);
            if let case Type::Slice { item: srcItem, .. } = rhsTy {
                if *srcItem != *item {
                if *srcItem <> *item {
                    throw emitTypeMismatch(self, assign.right, TypeMismatch { expected: *item, actual: *srcItem });
                }
            } else {
                try checkAssignable(self, assign.right, *item);
            }

    // Associate variant index with `call` node for the lowerer.
    setVariantInfo(self, node, index, tag);

    // Check if this variant expects a payload.
    let payloadType = variant.valueType;
    if payloadType != Type::Void {
    if payloadType <> Type::Void {
        let recInfo = getRecord(payloadType)
            else panic "resolveUnionVariantConstructor: payload is not a record";
        try checkRecordConstructorArgs(self, node, call.args, recInfo);
    } else {
        if call.args.len > 0 {

            else panic "resolveRecordLit: expected labeled field";
        let fieldName = try nodeName(self, label);
        let expected = recordType.fields[idx];
        let expectedName = expected.name else panic;

        if fieldName != expectedName {
        if fieldName <> expectedName {
            throw emitError(self, fieldNode, ErrorKind::RecordFieldOutOfOrder {
                field: fieldName,
                prev: expectedName,
            });
        }

    let targetInfo = hintInfo else {
        throw emitError(self, node, ErrorKind::CannotInferType);
    };

    // Check field count.
    if lit.fields.len != targetInfo.fields.len {
    if lit.fields.len <> targetInfo.fields.len {
        if lit.fields.len < targetInfo.fields.len {
            let missingName = targetInfo.fields[lit.fields.len].name else panic;
            throw emitError(self, node, ErrorKind::RecordFieldMissing(missingName));
        } else {
            throw emitError(self, node, ErrorKind::RecordFieldCountMismatch(CountMismatch {

            else panic "resolveAnonRecordLit: expected labeled field";
        let fieldName = try nodeName(self, label);
        let expected = targetInfo.fields[idx];
        let expectedName = expected.name else panic;

        if fieldName != expectedName {
        if fieldName <> expectedName {
            throw emitError(self, fieldNode, ErrorKind::RecordFieldOutOfOrder {
                field: fieldName,
                prev: expectedName,
            });
        }

            expectedTy = *ary.item;
        }
    };
    for itemNode in items {
        let itemTy = try visit(self, itemNode, expectedTy);
        assert itemTy != Type::Unknown;
        assert itemTy <> Type::Unknown;

        // Set the expected type to the first type we encounter.
        if expectedTy == Type::Unknown {
            expectedTy = itemTy;
        } else {

    throws (ResolveError)
{
    let targetTy = try infer(self, expr.type);
    let sourceTy = try visit(self, expr.value, targetTy);

    assert sourceTy != Type::Unknown;
    assert targetTy != Type::Unknown;
    assert sourceTy <> Type::Unknown;
    assert targetTy <> Type::Unknown;

    if isValidCast(sourceTy, targetTy) {
        // Propagate constant value through the cast, adjusting integer
        // metadata to match the target type.
        if let value = constValueEntry(self, expr.value) {

        if let e = range.end {
            let endTy = try checkNumeric(self, e);
            let mut resolvedTy = startTy;

            // Infer unsuffixed integer literals from the opposite bound.
            if startTy == Type::Int and endTy != Type::Int {
            if startTy == Type::Int and endTy <> Type::Int {
                let _ = try checkAssignable(self, s, endTy);
                resolvedTy = endTy;
            } else if endTy == Type::Int and startTy != Type::Int {
            } else if endTy == Type::Int and startTy <> Type::Int {
                let _ = try checkAssignable(self, e, startTy);
                resolvedTy = startTy;
            } else {
                let _ = try checkAssignable(self, e, startTy);
            }

/// Check that a `catch` body is assignable to the expected result type, but only
/// in expression context (`hint` is neither `Unknown` nor `Void`).
fn checkCatchBody(self: *mut Resolver, body: *ast::Node, resultTy: Type, hint: Type)
    throws (ResolveError)
{
    if hint != Type::Unknown and hint != Type::Void {
    if hint <> Type::Unknown and hint <> Type::Void {
        try checkAssignable(self, body, resultTy);
    }
}

/// Resolve catch clauses for a `try ... catch` expression.

    let firstNode = catches[0];
    let case ast::NodeValue::CatchClause(first) = firstNode.value else
        throw emitError(self, node, ErrorKind::UnexpectedNode(firstNode));

    // Typed catches: dispatch to dedicated handler.
    if first.typeNode != nil {
    if first.typeNode <> nil {
        return try resolveTypedCatches(self, node, catches, calleeInfo, resultTy, hint);
    }
    // Single untyped catch clause.
    if let binding = first.binding {
        if calleeInfo.throwList.len > 1 {

        else throw emitError(self, node, ErrorKind::UnexpectedReturn);
    let expected = *f.returnType;

    if let val = retVal {
        let _actualTy = try checkAssignable(self, val, expected);
    } else if expected != Type::Void {
    } else if expected <> Type::Void {
        throw emitTypeMismatch(self, node, TypeMismatch { expected, actual: Type::Void });
    }
    // In throwing functions, return values are wrapped in the success variant.
    if f.throwList.len > 0 {
        setNodeCoercion(self, node, Coercion::ResultWrap);

            return ConstValue::Int(ConstInt {
                magnitude: left.magnitude >> right.magnitude, bits, signed, negative: left.negative,
            });
        },
        case ast::BinaryOp::Eq  => return ConstValue::Bool(l == r),
        case ast::BinaryOp::Ne  => return ConstValue::Bool(l != r),
        case ast::BinaryOp::Ne  => return ConstValue::Bool(l <> r),
        case ast::BinaryOp::Lt  => return ConstValue::Bool(l < r),
        case ast::BinaryOp::Gt  => return ConstValue::Bool(l > r),
        case ast::BinaryOp::Lte => return ConstValue::Bool(l <= r),
        case ast::BinaryOp::Gte => return ConstValue::Bool(l >= r),
        case ast::BinaryOp::Add => return ConstValue::Int(constIntFromSigned(l + r, bits, signed)),

            match binop.op {
                case ast::BinaryOp::And => setNodeConstValue(self, node, ConstValue::Bool(l and r)),
                case ast::BinaryOp::Or => setNodeConstValue(self, node, ConstValue::Bool(l or r)),
                case ast::BinaryOp::Eq => setNodeConstValue(self, node, ConstValue::Bool(l == r)),
                case ast::BinaryOp::Ne,
                     ast::BinaryOp::Xor => setNodeConstValue(self, node, ConstValue::Bool(l != r)),
                     ast::BinaryOp::Xor => setNodeConstValue(self, node, ConstValue::Bool(l <> r)),
                else => {}
            }
        }
    }
}

lib/std/lang/resolver/tests.rad +5 -5

    throws (testing::TestError)
{
    let actual = super::typeFor(self, expr)
        else throw testing::TestError::Failed;

    if actual != expected {
    if actual <> expected {
        throw testing::TestError::Failed;
    }
}

/// Verify that an error represents a specific type mismatch.

    let nominalTy = try getTypeInScopeOf(&a, result.root, "R");
    let case super::NominalType::Record(recordType) = *nominalTy
        else throw testing::TestError::Failed;
    try testing::expect(recordType.labeled);
    try testing::expect(recordType.fields.len == 2);
    try testing::expect(recordType.fields[0].name != nil);
    try testing::expect(recordType.fields[1].name != nil);
    try testing::expect(recordType.fields[0].name <> nil);
    try testing::expect(recordType.fields[1].name <> nil);
}

@test fn testResolveRecordFieldAccessValid() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Pt { x: i32, y: u8 } let p = Pt { x: 1, y: 2 }; p.y;";

        let result = try resolveExprStr(&mut a, "5 == 5");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Bool);
    } {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "5 != 10");
        let result = try resolveExprStr(&mut a, "5 <> 10");
        try expectNoErrors(&result);
        try expectType(&a, result.root, super::Type::Bool);
    } {
        let mut a = testResolver();
        let result = try resolveExprStr(&mut a, "5 < 10");

    let case super::NominalType::Union(unionType) = *ty
        else throw testing::TestError::Failed;
    try testing::expect(unionType.variants.len == 2);
    try testing::expect(mem::eq(unionType.variants[0].name, "Ok"));
    try testing::expect(mem::eq(unionType.variants[1].name, "Error"));
    if getUnionVariantPayload(ty, "Ok") != super::Type::Void {
    if getUnionVariantPayload(ty, "Ok") <> super::Type::Void {
        throw testing::TestError::Failed;
    }
    let stmt = try getBlockStmt(result.root, 1);
    try expectExprStmtType(&a, stmt, super::Type::Nominal(ty));
    try expectNoErrors(&result);

lib/std/lang/scanner.rad +5 -10

    Caret,      // ^
    Tilde,      // ~
    Underscore, // _
    Question,   // ?
    Bang,       // !
    BangEqual,  // != or <>
    LtGt,       // <>
    Equal,      // =
    EqualEqual, // ==
    Gt,         // >
    GtEqual,    // >=
    Lt,         // <

285	285		while let ch = current(s) {
286	286		match ch {
287	287		case ' ', '\n', '\r', '\t' => advance(s),
288	288		case '/' => {
289	289		if let c = peek(s); c == '/' {
290		-	while let ch = current(s); ch != '\n' {
	290	+	while let ch = current(s); ch <> '\n' {
291	291		advance(s);
292	292		}
293	293		} else {
294	294		return;
295	295		}

    }
    return tok(s, TokenKind::Number);
}

fn scanDelimited(s: *mut Scanner, delim: u8, kind: TokenKind) -> ?Token {
    while let ch = current(s); ch != delim {
    while let ch = current(s); ch <> delim {
        if not isPrint(ch) {
            return invalid(s.token, "invalid character");
        }
        consume(s, '\\'); // Consume escapes
        advance(s);

                return tok(s, TokenKind::CaretEqual);
            }
            return tok(s, TokenKind::Caret);
        }
        case '~' => return tok(s, TokenKind::Tilde),
        case '!' => {
            if consume(s, '=') {
                return tok(s, TokenKind::BangEqual);
            }
            return tok(s, TokenKind::Bang);
        }
        case '!' => return tok(s, TokenKind::Bang),
        case '=' => {
            if consume(s, '>') {
                return tok(s, TokenKind::FatArrow);
            }
            if consume(s, '=') {

            }
            return tok(s, TokenKind::Equal);
        }
        case '<' => {
            if consume(s, '>') {
                return tok(s, TokenKind::BangEqual);
                return tok(s, TokenKind::LtGt);
            }
            if consume(s, '<') {
                if consume(s, '=') {
                    return tok(s, TokenKind::LtLtEqual);
                }

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

    try testing::expect(super::next(&mut s).kind == super::TokenKind::Eof);
}

@test fn testScanDoubleCharTokens() throws (testing::TestError) {
    let mut s = testScanner(
        "== != <> <= >= < > >> << -> =>"
        "== <> <= >= < > >> << -> =>"
    );
    try testing::expect(super::next(&mut s).kind == super::TokenKind::EqualEqual);
    try testing::expect(super::next(&mut s).kind == super::TokenKind::BangEqual);
    try testing::expect(super::next(&mut s).kind == super::TokenKind::BangEqual);
    try testing::expect(super::next(&mut s).kind == super::TokenKind::LtGt);
    try testing::expect(super::next(&mut s).kind == super::TokenKind::LtEqual);
    try testing::expect(super::next(&mut s).kind == super::TokenKind::GtEqual);
    try testing::expect(super::next(&mut s).kind == super::TokenKind::Lt);
    try testing::expect(super::next(&mut s).kind == super::TokenKind::Gt);
    try testing::expect(super::next(&mut s).kind == super::TokenKind::GtGt);

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

        case Expr::List { head, tail, multiline } => {
            write(out, "(");
            write(out, head);
            if multiline {
                for i in 0..tail.len {
                    if tail[i] != Expr::Null {
                    if tail[i] <> Expr::Null {
                        write(out, "\n");
                        indentTo(out, depth + 1);
                        printTo(tail[i], depth + 1, out);
                    }
                }
            } else {
                let mut first = head.len == 0;
                for i in 0..tail.len {
                    if tail[i] != Expr::Null {
                    if tail[i] <> Expr::Null {
                        if first {
                            first = false;
                        } else {
                            write(out, " ");
                        }

            write(out, ")");
        }
        case Expr::Vec { items } => {
            write(out, "[");
            for item, i in items {
                if item != Expr::Null {
                if item <> Expr::Null {
                    if i > 0 {
                        write(out, " ");
                    }
                    printTo(item, depth, out);
                }

        }
        case Expr::Block { name, items, children } => {
            write(out, "(");
            write(out, name);
            for i in 0..items.len {
                if items[i] != Expr::Null {
                if items[i] <> Expr::Null {
                    write(out, " ");
                    printTo(items[i], depth, out);
                }
            }
            for i in 0..children.len {
                if children[i] != Expr::Null {
                if children[i] <> Expr::Null {
                    write(out, "\n");
                    indentTo(out, depth + 1);
                    printTo(children[i], depth + 1, out);
                }
            }

lib/std/mem.rad +4 -4

    }
    if prefix.len > input.len {
        return nil;
    }
    for i in 0..prefix.len {
        if prefix[i] != input[i] {
        if prefix[i] <> input[i] {
            return nil;
        }
    }
    return &input[prefix.len..];
}


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

/// Check whether two byte slices have the same length and contents.
export fn eq(a: *[u8], b: *[u8]) -> bool {
    if a.len != b.len {
    if a.len <> b.len {
        return false;
    }
    for i in 0..a.len {
        if a[i] != b[i] {
        if a[i] <> b[i] {
            return false;
        }
    }
    return true;
}

test/runner.rad +4 -4

/// Strip comment from a line. Returns sub-slice up to ';', trimmed of trailing whitespace.
fn stripLine(line: *[u8]) -> *[u8] {
    let mut end: u32 = 0;
    let mut i: u32 = 0;

    while i < line.len and line[i] != ';' {
        if line[i] != ' ' and line[i] != '\t' {
    while i < line.len and line[i] <> ';' {
        if line[i] <> ' ' and line[i] <> '\t' {
            end = 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' {
    while i < s.len and s[i] <> '\n' {
        i += 1;
    }
    let line = &s[start..i];
    if i < s.len {
        *offset = i + 1;


/// Run a single test specified as an argument.
@default fn main(env: *sys::Env) -> i32 {
    let args = env.args;

    if args.len != 2 {
    if args.len <> 2 {
        io::printError("error: expected test file path as argument");
        return 1;
    }
    let sourcePath = args[1];
    io::print("test ");

test/tests/abi.sizes.rad +9 -9

142	142		return 0;
143	143		}
144	144
145	145		@default fn main() -> i32 {
146	146		let r1 = testByte();
147		-	if r1 != 0 {
	147	+	if r1 <> 0 {
148	148		return 10 + r1;
149	149		}
150	150
151	151		let r2 = testShort();
152		-	if r2 != 0 {
	152	+	if r2 <> 0 {
153	153		return 20 + r2;
154	154		}
155	155
156	156		let r3 = testWord();
157		-	if r3 != 0 {
	157	+	if r3 <> 0 {
158	158		return 30 + r3;
159	159		}
160	160
161	161		let r4 = testPair();
162		-	if r4 != 0 {
	162	+	if r4 <> 0 {
163	163		return 40 + r4;
164	164		}
165	165
166	166		let r5 = testTriple();
167		-	if r5 != 0 {
	167	+	if r5 <> 0 {
168	168		return 50 + r5;
169	169		}
170	170
171	171		let r6 = testIdentity();
172		-	if r6 != 0 {
	172	+	if r6 <> 0 {
173	173		return 60 + r6;
174	174		}
175	175
176	176		let r7 = testAddPairs();
177		-	if r7 != 0 {
	177	+	if r7 <> 0 {
178	178		return 70 + r7;
179	179		}
180	180
181	181		let r8 = testDoublePair();
182		-	if r8 != 0 {
	182	+	if r8 <> 0 {
183	183		return 80 + r8;
184	184		}
185	185
186	186		let r9 = testMultipleReturns();
187		-	if r9 != 0 {
	187	+	if r9 <> 0 {
188	188		return 90 + r9;
189	189		}
190	190		return 0;
191	191		}

test/tests/aggregate.return.rad +8 -8

    return 0;
}

@default fn main() -> i32 {
    let r1: i32 = testReturnDoesNotCorruptLocals();
    if r1 != 0 {
    if r1 <> 0 {
        return 10 + r1;
    }

    let r2: i32 = testMultipleReturns();
    if r2 != 0 {
    if r2 <> 0 {
        return 20 + r2;
    }

    let r3: i32 = testMutateReturnedAggregate();
    if r3 != 0 {
    if r3 <> 0 {
        return 30 + r3;
    }

    let r4: i32 = testAggregateReturnInLoop();
    if r4 != 0 {
    if r4 <> 0 {
        return 40 + r4;
    }

    let r5: i32 = testThrowingAggregateReturn();
    if r5 != 0 {
    if r5 <> 0 {
        return 50 + r5;
    }

    let r6: i32 = testThrowingAggregateCatch();
    if r6 != 0 {
    if r6 <> 0 {
        return 60 + r6;
    }

    let r7: i32 = testTripleReturn();
    if r7 != 0 {
    if r7 <> 0 {
        return 70 + r7;
    }

    let r8: i32 = testInterleavedCalls();
    if r8 != 0 {
    if r8 <> 0 {
        return 80 + r8;
    }
    return 0;
}

test/tests/arith.subword.rad +15 -15

fn testI8Overflow() -> bool {
    let a: i8 = 120;
    let b: i8 = 10;
    let result: i8 = a + b;
    // 120 + 10 = 130, which wraps to -126 in i8
    if result != -126 {
    if result <> -126 {
        return false;
    }
    return true;
}

fn testU8Overflow() -> bool {
    let a: u8 = 250;
    let b: u8 = 10;
    let result: u8 = a + b;
    // 250 + 10 = 260, which wraps to 4 in u8
    if result != 4 {
    if result <> 4 {
        return false;
    }
    return true;
}

fn testI8Subtraction() -> bool {
    let a: i8 = -100;
    let b: i8 = 50;
    let result: i8 = a - b;
    // -100 - 50 = -150, which wraps to 106 in i8
    if result != 106 {
    if result <> 106 {
        return false;
    }
    return true;
}

fn testU8Subtraction() -> bool {
    let a: u8 = 5;
    let b: u8 = 10;
    let result: u8 = a - b;
    // 5 - 10 = -5, which wraps to 251 in u8
    if result != 251 {
    if result <> 251 {
        return false;
    }
    return true;
}

fn testI16Overflow() -> bool {
    let a: i16 = 32000;
    let b: i16 = 1000;
    let result: i16 = a + b;
    // 32000 + 1000 = 33000, which wraps to -32536 in i16
    if result != -32536 {
    if result <> -32536 {
        return false;
    }
    return true;
}

fn testU16Overflow() -> bool {
    let a: u16 = 65530;
    let b: u16 = 10;
    let result: u16 = a + b;
    // 65530 + 10 = 65540, which wraps to 4 in u16
    if result != 4 {
    if result <> 4 {
        return false;
    }
    return true;
}

fn testI8Multiply() -> bool {
    let a: i8 = 15;
    let b: i8 = 10;
    let result: i8 = a * b;
    // 15 * 10 = 150, which wraps to -106 in i8
    if result != -106 {
    if result <> -106 {
        return false;
    }
    return true;
}

fn testU8Multiply() -> bool {
    let a: u8 = 20;
    let b: u8 = 15;
    let result: u8 = a * b;
    // 20 * 15 = 300, which wraps to 44 in u8
    if result != 44 {
    if result <> 44 {
        return false;
    }
    return true;
}


    let b: i8 = a + 1;
    // b should be -128 after overflow
    if b >= 0 {
        return false;
    }
    if b != -128 {
    if b <> -128 {
        return false;
    }
    return true;
}

fn testU8Comparison() -> bool {
    let a: u8 = 255;
    let b: u8 = a + 1 as u8;
    // b should be 0 after overflow
    if b != 0 {
    if b <> 0 {
        return false;
    }
    return true;
}

fn testNarrowingCast() -> bool {
    let x: i32 = 1000;
    let narrow: u8 = x as u8;
    // 1000 = 0x3E8, lower byte = 0xE8 = 232
    if narrow != 232 {
    if narrow <> 232 {
        return false;
    }
    return true;
}

fn testW32ShiftRight() -> bool {
    let max: u32 = 0xFFFFFFFF;
    let shifted: u32 = max >> 16;
    // Should be 0xFFFF = 65535
    if shifted != 65535 {
    if shifted <> 65535 {
        return false;
    }
    return true;
}

fn testI8NegOverflow() -> bool {
    let min: i8 = -128;
    let negated: i8 = -min;
    // RV64 should preserve i8 wrap behavior: -(-128) == -128
    if negated != -128 {
    if negated <> -128 {
        return false;
    }
    return true;
}

fn testU8BitNot() -> bool {
    let x: u8 = 0;
    let inverted: u8 = ~x;
    // 8-bit not of 0 is 0xFF.
    if inverted != 255 {
    if inverted <> 255 {
        return false;
    }
    return true;
}

fn testW32ShiftLargeImmediate() -> bool {
    let x: u32 = 1;
    let shifted: u32 = x << 40;
    // Shift amount should be masked to 5 bits for 32-bit shifts: 40 % 32 = 8.
    if shifted != 256 {
    if shifted <> 256 {
        return false;
    }
    return true;
}


test/tests/arith.w64.rad +19 -19


fn testI64Add() -> bool {
    let a: i64 = 100;
    let b: i64 = 200;
    let result: i64 = a + b;
    if result != 300 {
    if result <> 300 {
        return false;
    }
    return true;
}

fn testU64Add() -> bool {
    let a: u64 = 100;
    let b: u64 = 200;
    let result: u64 = a + b;
    if result != 300 {
    if result <> 300 {
        return false;
    }
    return true;
}

fn testI64Sub() -> bool {
    let a: i64 = 500;
    let b: i64 = 300;
    let result: i64 = a - b;
    if result != 200 {
    if result <> 200 {
        return false;
    }
    return true;
}

fn testI64Mul() -> bool {
    let a: i64 = 1000;
    let b: i64 = 2000;
    let result: i64 = a * b;
    if result != 2000000 {
    if result <> 2000000 {
        return false;
    }
    return true;
}

fn testI64Div() -> bool {
    let a: i64 = 1000;
    let b: i64 = 10;
    let result: i64 = a / b;
    if result != 100 {
    if result <> 100 {
        return false;
    }
    return true;
}

fn testU64Div() -> bool {
    let a: u64 = 1000;
    let b: u64 = 10;
    let result: u64 = a / b;
    if result != 100 {
    if result <> 100 {
        return false;
    }
    return true;
}

fn testI64Neg() -> bool {
    let a: i64 = 42;
    let result: i64 = -a;
    if result != -42 {
    if result <> -42 {
        return false;
    }
    return true;
}

fn testI64Shift() -> bool {
    let a: i64 = 1;
    let result: i64 = a << 40;
    if result != 1099511627776 {
    if result <> 1099511627776 {
        return false;
    }
    let back: i64 = result >> 40;
    if back != 1 {
    if back <> 1 {
        return false;
    }
    return true;
}

fn testU64Shift() -> bool {
    let a: u64 = 1;
    let shifted: u64 = a << 32;
    // Shift by 32 should NOT wrap like u32 would.
    let back: u64 = shifted >> 32;
    if back != 1 {
    if back <> 1 {
        return false;
    }
    return true;
}

fn testI64Bitwise() -> bool {
    let a: i64 = 0xFF00;
    let b: i64 = 0x0FF0;
    let andResult: i64 = a & b;
    if andResult != 0x0F00 {
    if andResult <> 0x0F00 {
        return false;
    }
    let orResult: i64 = a | b;
    if orResult != 0xFFF0 {
    if orResult <> 0xFFF0 {
        return false;
    }
    let xorResult: i64 = a ^ b;
    if xorResult != 0xF0F0 {
    if xorResult <> 0xF0F0 {
        return false;
    }
    return true;
}

fn testWidenI32ToI64() -> bool {
    let a: i32 = -42;
    let b: i64 = a as i64;
    if b != -42 {
    if b <> -42 {
        return false;
    }
    return true;
}


    let a: u32 = 0xFFFFFFFF;
    let b: u64 = a as u64;
    // Should zero-extend, not sign-extend.
    // If sign-extended, this would be a very large negative number in i64.
    let c: u64 = b >> 32;
    if c != 0 {
    if c <> 0 {
        return false;
    }
    return true;
}

fn testNarrowI64ToI32() -> bool {
    let a: i64 = 42;
    let b: i32 = a as i32;
    if b != 42 {
    if b <> 42 {
        return false;
    }
    return true;
}

fn testNarrowU64ToU32() -> bool {
    let a: u64 = 42;
    let b: u32 = a as u32;
    if b != 42 {
    if b <> 42 {
        return false;
    }
    return true;
}



fn testI64Modulo() -> bool {
    let a: i64 = 17;
    let b: i64 = 5;
    let result: i64 = a % b;
    if result != 2 {
    if result <> 2 {
        return false;
    }
    return true;
}

fn testU64Modulo() -> bool {
    let a: u64 = 17;
    let b: u64 = 5;
    let result: u64 = a % b;
    if result != 2 {
    if result <> 2 {
        return false;
    }
    return true;
}


test/tests/array.repeat.edge.rad +1 -1


/// Test large array initialization with repeat syntax.
fn testLargeArray() -> bool {
    let arr: [i32; 256] = [7; 256];
    for x in arr {
        if x != 7 {
        if x <> 7 {
            return false;
        }
    }
    return true;
}

test/tests/assert.basic.rad +1 -1


    // Assert with comparison.
    let x: i32 = 42;
    assert x == 42;
    assert x > 0;
    assert x != 0;
    assert x <> 0;

    // Assert with message.
    assert x == 42, "x should be 42";

    // Assert with block form.

test/tests/assign.mutable.rad +10 -10

           (level4.age + level4.score);
    // (11+21) + (12+22) + (13+23) + (14+24) = 32+34+36+38 = 140
}

@default fn main() -> i32 {
    if (testBasicAliasing() != 35) {
    if (testBasicAliasing() <> 35) {
        return 1; // Failure
    }
    if (testStructAliasing() != 155) {
    if (testStructAliasing() <> 155) {
        return 1; // Failure
    }
    if (testArrayAliasing() != 33) {
    if (testArrayAliasing() <> 33) {
        return 1; // Failure
    }
    if (testNestedStructArrayMutation() != 122) {
    if (testNestedStructArrayMutation() <> 122) {
        return 1; // Failure
    }
    if (testVariableOverwriting() != 160) {
    if (testVariableOverwriting() <> 160) {
        return 1; // Failure
    }
    if (testArrayOfStructsAliasing() != 152) {
    if (testArrayOfStructsAliasing() <> 152) {
        return 1; // Failure
    }
    if (testMutationChain() != 17) {
    if (testMutationChain() <> 17) {
        return 1; // Failure
    }
    if (testStructFieldReassignment() != 140) {
    if (testStructFieldReassignment() <> 140) {
        return 1; // Failure
    }
    if (testArrayIndexMutation() != 195) {
    if (testArrayIndexMutation() <> 195) {
        return 1; // Failure
    }
    if (testMultipleAssignmentLevels() != 140) {
    if (testMultipleAssignmentLevels() <> 140) {
        return 1; // Failure
    }
    return 0; // Success
}

test/tests/binop.cmp.rad +2 -2

    let a: i32 = 5;
    let b: i32 = 5;
    let c: i32 = 6;

    assert (a == b);
    assert a != c;
    assert a <> c;

    assert a == b;
    assert (a != c);
    assert (a <> c);

    assert (a < c);
    assert a >= b;
    assert c >= a;


test/tests/bool.comparison.array.rad +2 -2


fn arrayNotEqual() -> bool {
    let a1: [u32; 3] = [42, 8, 3];
    let a2: [u32; 3] = [42, 9, 3];

    return a1 != a2;
    return a1 <> a2;
}

fn arrayPointerNotEqual() -> bool {
    // Same array values, but different addresses.
    let a1: [u32; 3] = [9, 42, 3];
    let a2: [u32; 3] = [9, 42, 3];

    return &a1 != &a2;
    return &a1 <> &a2;
}

fn arrayPointerEqual() -> bool {
    let a1: [u32; 3] = [9, 42, 3];


test/tests/bool.comparison.nested.gen.rad +2 -2

    };
    let c2: Circle = Circle {
        center: Point { x: 15, y: 20 },
        radius: 5,
    };
    return c1 != c2;
    return c1 <> c2;
}

fn testNestedNotEqualRadius() -> bool {
    let c1: Circle = Circle {
        center: Point { x: 10, y: 20 },

    };
    let c2: Circle = Circle {
        center: Point { x: 10, y: 20 },
        radius: 10,
    };
    return c1 != c2;
    return c1 <> c2;
}

@default fn main() -> i32 {
    assert testNestedEqual();
    assert testNestedNotEqualCenter();

test/tests/bool.comparison.opt.rad +6 -6

    let opt1: ?i32 = 42;
    let opt2: ?u8 = 9;
    let opt3: ?bool = nil;

    return
        nil != opt1 and
        opt1 != nil and
        nil != opt2 and
        opt2 != nil and
        nil <> opt1 and
        opt1 <> nil and
        nil <> opt2 and
        opt2 <> nil and
        nil == opt3 and
        opt3 == nil;
}

fn testSelfComparisons() -> bool {

    let opt2: ?u8 = 9;

    return
        opt1 == 42 and
        opt2 == 9 and
        opt1 != 9 and
        opt2 != 42;
        opt1 <> 9 and
        opt2 <> 42;
}

fn testValueEqOpt() -> bool {
    let opt1: ?i32 = 42;
    let opt2: ?u8 = 9;

test/tests/bool.comparison.record.gen.rad +3 -3


fn testPointNotEqualX() -> bool {
    let p1: Point = Point { x: 10, y: 20 };
    let p2: Point = Point { x: 15, y: 20 };

    return p1 != p2;
    return p1 <> p2;
}

fn testPointNotEqualY() -> bool {
    let p1: Point = Point { x: 10, y: 20 };
    let p2: Point = Point { x: 10, y: 25 };

    return p1 != p2;
    return p1 <> p2;
}

fn testRectEqual() -> bool {
    let r1: Rect = Rect { width: 100, height: 50 };
    let r2: Rect = Rect { width: 100, height: 50 };


fn testRectNotEqual() -> bool {
    let r1: Rect = Rect { width: 100, height: 50 };
    let r2: Rect = Rect { width: 100, height: 60 };

    return r1 != r2;
    return r1 <> r2;
}

@default fn main() -> i32 {
    assert testPointEqual();
    assert testPointNotEqualX();

test/tests/bool.comparison.record.rad +2 -2

24	24
25	25		fn packedStructNotEqual() -> bool {
26	26		let mut s1: Packed = Packed { x: 39, y: 189 };
27	27		let mut s2: Packed = Packed { x: 39, y: 289 };
28	28
29		-	return s1 != s2;
	29	+	return s1 <> s2;
30	30		}
31	31
32	32		fn paddedStructEqual() -> bool {
33	33		let mut s1: Padded = Padded { a: 48, b: 183, c: 493, d: 8192, e: 99 };
34	34		let mut s2: Padded = Padded { a: 48, b: 183, c: 493, d: 8192, e: 99 };


fn paddedStructNotEqual() -> bool {
    let mut s1: Padded = Padded { a: 48, b: 183, c: 493, d: 8192, e: 99 };
    let mut s2: Padded = Padded { a: 48, b: 283, c: 493, d: 8192, e: 99 };

    return s1 != s2;
    return s1 <> s2;
}

@default fn main() -> bool {
    return packedStructEqual()
       and packedStructNotEqual()

test/tests/bool.comparison.slice.rad +14 -14

1	1		//! returns: 0
2	2		fn memEq(a: [u8], b: [u8]) -> bool {
3		-	if a.len != b.len {
	3	+	if a.len <> b.len {
4	4		return false;
5	5		}
6	6		for i in 0..a.len {
7		-	if a[i] != b[i] {
	7	+	if a[i] <> b[i] {
8	8		return false;
9	9		}
10	10		}
11	11		return true;
12	12		}

fn sliceI32(input: *[i32]) -> *[i32] {
    return input;
}

fn sliceEqualU32(a: *[u32], b: *[u32]) -> bool {
    if a.len != b.len {
    if a.len <> b.len {
        return false;
    }
    for i in 0..a.len {
        if a[i] != b[i] {
        if a[i] <> b[i] {
            return false;
        }
    }
    return true;
}

fn sliceEqualI32(a: *[i32], b: *[i32]) -> bool {
    if a.len != b.len {
    if a.len <> b.len {
        return false;
    }
    for i in 0..a.len {
        if a[i] != b[i] {
        if a[i] <> b[i] {
            return false;
        }
    }
    return true;
}

83	83		let a1: [u32; 3] = [42, 8, 3];
84	84
85	85		let s1: *[u32] = &a1[..2];
86	86		let s2: *[u32] = &a1[1..3];
87	87
88		-	return s1 != s2 and not sliceEqualU32(s1, s2);
	88	+	return s1 <> s2 and not sliceEqualU32(s1, s2);
89	89		}
90	90
91	91		fn sliceNotEqualSameArray2() -> bool {
92	92		let a1: [u32; 3] = [42, 8, 3];
93	93
94	94		let s1: *[u32] = &a1[..2];
95	95		let s2: *[u32] = &a1[..3];
96	96
97		-	return s1 != s2 and not sliceEqualU32(s1, s2);
	97	+	return s1 <> s2 and not sliceEqualU32(s1, s2);
98	98		}
99	99
100	100		fn sliceEqualDifferentArray() -> bool {
101	101		let a1: [u32; 3] = [42, 8, 3];
102	102		let a2: [u32; 3] = [42, 8, 3];
103	103
104	104		let s1: *[u32] = &a1[..];
105	105		let s2: *[u32] = &a2[..];
106	106
107		-	return sliceEqualU32(s1, s2) and s1 != s2;
	107	+	return sliceEqualU32(s1, s2) and s1 <> s2;
108	108		}
109	109
110	110		fn sliceEqualString1() -> bool {
111	111		let s1: *[u8] = "ABC";
112	112		let s2: *[u8] = "ABC";

163	163		fn sliceNotEqualU16() -> bool {
164	164		let a: [u16; 3] = [1, 2, 3];
165	165		let b: [u16; 3] = [1, 2, 4];
166	166		let s: *[u16] = &[1, 2, 3];
167	167
168		-	return s != &[1, 2, 4]
169		-	and s != &[1, 0, 3]
170		-	and &a[..] != &a[1..]
171		-	and &a[..] != &b[..]
172		-	and &a[..] != &[1, 3, 3];
	168	+	return s <> &[1, 2, 4]
	169	+	and s <> &[1, 0, 3]
	170	+	and &a[..] <> &a[1..]
	171	+	and &a[..] <> &b[..]
	172	+	and &a[..] <> &[1, 3, 3];
173	173		}
174	174
175	175		fn sliceReturnEqual() -> bool {
176	176		return memEq(sliceU8("ABC"), "ABC")
177	177		and sliceEqualI32(sliceI32(&[1, 2, 3]), &[1, 2, 3]);

test/tests/bool.comparison.slice.record.gen.rad +2 -2

8	8		record Line {
9	9		points: *[Point],
10	10		}
11	11
12	12		fn pointsEqual(a: [Point], b: [Point]) -> bool {
13		-	if a.len != b.len {
	13	+	if a.len <> b.len {
14	14		return false;
15	15		}
16	16		for i in 0..a.len {
17		-	if a[i].x != b[i].x or a[i].y != b[i].y {
	17	+	if a[i].x <> b[i].x or a[i].y <> b[i].y {
18	18		return false;
19	19		}
20	20		}
21	21		return true;
22	22		}

test/tests/bool.comparison.slice.union.gen.rad +4 -4

14	14		points(*[Point]),
15	15		sizes(*[Size]),
16	16		}
17	17
18	18		fn pointsEqual(a: [Point], b: [Point]) -> bool {
19		-	if a.len != b.len {
	19	+	if a.len <> b.len {
20	20		return false;
21	21		}
22	22		for i in 0..a.len {
23		-	if a[i].x != b[i].x or a[i].y != b[i].y {
	23	+	if a[i].x <> b[i].x or a[i].y <> b[i].y {
24	24		return false;
25	25		}
26	26		}
27	27		return true;
28	28		}
29	29
30	30		fn sizesEqual(a: [Size], b: [Size]) -> bool {
31		-	if a.len != b.len {
	31	+	if a.len <> b.len {
32	32		return false;
33	33		}
34	34		for i in 0..a.len {
35		-	if a[i].width != b[i].width or a[i].height != b[i].height {
	35	+	if a[i].width <> b[i].width or a[i].height <> b[i].height {
36	36		return false;
37	37		}
38	38		}
39	39		return true;
40	40		}

test/tests/bool.comparison.union.gen.rad +3 -3


fn testDifferentVariants() -> bool {
    let a: Status = Status::pending;
    let b: Status = Status::running(42);

    return a != b;
    return a <> b;
}

fn testSameVariantSamePayload() -> bool {
    let a: Status = Status::running(42);
    let b: Status = Status::running(42);


fn testSameVariantDifferentPayload() -> bool {
    let a: Status = Status::running(42);
    let b: Status = Status::running(99);

    return a != b;
    return a <> b;
}

fn testBoolPayloadSame() -> bool {
    let a: Status = Status::completed(true);
    let b: Status = Status::completed(true);


fn testBoolPayloadDifferent() -> bool {
    let a: Status = Status::completed(true);
    let b: Status = Status::completed(false);

    return a != b;
    return a <> b;
}

@default fn main() -> i32 {
    assert testSameVariantNoPayload();
    assert testDifferentVariants();

test/tests/bool.comparison.union.record.gen.rad +3 -3

}

fn testDifferentVariant() -> bool {
    let s1: Shape = Shape::circle(10);
    let s2: Shape = Shape::point(Point { x: 5, y: 5 });
    return s1 != s2;
    return s1 <> s2;
}

fn testSameVariantStructEqual() -> bool {
    let s1: Shape = Shape::point(Point { x: 10, y: 20 });
    let s2: Shape = Shape::point(Point { x: 10, y: 20 });

}

fn testSameVariantStructNotEqual() -> bool {
    let s1: Shape = Shape::point(Point { x: 10, y: 20 });
    let s2: Shape = Shape::point(Point { x: 10, y: 25 });
    return s1 != s2;
    return s1 <> s2;
}

fn testRectVariantEqual() -> bool {
    let s1: Shape = Shape::rect(Size { width: 100, height: 50 });
    let s2: Shape = Shape::rect(Size { width: 100, height: 50 });

}

fn testRectVariantNotEqual() -> bool {
    let s1: Shape = Shape::rect(Size { width: 100, height: 50 });
    let s2: Shape = Shape::rect(Size { width: 100, height: 60 });
    return s1 != s2;
    return s1 <> s2;
}

@default fn main() -> i32 {
    assert testSameVariantPrimitive();
    assert testDifferentVariant();

test/tests/bool.comparison.union.simple.gen.rad +1 -1

    let r1: Color = Color::red;
    let r2: Color = Color::red;
    let g: Color = Color::green;

    assert r1 == r2;
    assert r1 != g;
    assert r1 <> g;
    return 0;
}

test/tests/bool.operators.complex.rad +1 -1

    let b: i32 = 10;
    let c: i32 = 15;

    let expr1: bool = (a < b) and (b < c);
    let expr2: bool = (a < b) or (b > c);
    let expr3: bool = (a == b) or (b != c);
    let expr3: bool = (a == b) or (b <> c);
    let expr4: bool = (a >= b) and (b <= c);

    return expr1 and expr2 and expr3 and not expr4;
}

test/tests/cast.same.size.rad +2 -2

    // Eq/Ne used as values must compare at the declared width.
    let eqU8: bool = a == 255;
    assert eqU8;
    let eqI8: bool = b == -1;
    assert eqI8;
    let neU8: bool = a != 255;
    let neU8: bool = a <> 255;
    assert not neU8;
    let neI8: bool = b != -1;
    let neI8: bool = b <> -1;
    assert not neI8;
    return 0;
}

test/tests/cmp.rel.rad +1 -1

    return a == b;
}

/// Returns true when the arguments are not equal.
fn cmpNe(a: i32, b: i32) -> bool {
    return a != b;
    return a <> b;
}

/// Returns true when the first argument is less than the second.
fn cmpLt(a: i32, b: i32) -> bool {
    return a < b;

test/tests/cmp.unsigned.rad +1 -1

    return a == b;
}

/// Returns true when the arguments are not equal.
fn cmpNe(a: u32, b: u32) -> bool {
    return a != b;
    return a <> b;
}

/// Returns true when the first argument is less than the second.
fn cmpLt(a: u32, b: u32) -> bool {
    return a < b;

test/tests/cond.expr.aggregate.rad +2 -2

53	53		return 0;
54	54		}
55	55
56	56		@default fn main() -> i32 {
57	57		let r1 = testUnion();
58		-	if r1 != 0 {
	58	+	if r1 <> 0 {
59	59		return r1;
60	60		}
61	61		let r2 = testOptional();
62		-	if r2 != 0 {
	62	+	if r2 <> 0 {
63	63		return r2;
64	64		}
65	65		return 0;
66	66		}

test/tests/cond.expr.rad +5 -5

64	64		return 0;
65	65		}
66	66
67	67		@default fn main() -> i32 {
68	68		let r1 = testScalar();
69		-	if r1 != 0 {
	69	+	if r1 <> 0 {
70	70		return r1;
71	71		}
72	72		let r2 = testMin();
73		-	if r2 != 0 {
	73	+	if r2 <> 0 {
74	74		return r2;
75	75		}
76	76		let r3 = testFnArg();
77		-	if r3 != 0 {
	77	+	if r3 <> 0 {
78	78		return r3;
79	79		}
80	80		let r4 = testEnum();
81		-	if r4 != 0 {
	81	+	if r4 <> 0 {
82	82		return r4;
83	83		}
84	84		let r5 = testNested();
85		-	if r5 != 0 {
	85	+	if r5 <> 0 {
86	86		return r5;
87	87		}
88	88		return 0;
89	89		}

test/tests/cond.if.rad +1 -1

31	31		if a == a {
32	32		// Ignore.
33	33		} else {
34	34		return 7;
35	35		}
36		-	if a != b {
	36	+	if a <> b {
37	37		// Ignore.
38	38		} else {
39	39		return 8;
40	40		}
41	41

test/tests/const-expr-array-size.rad +1 -1


static DATA: [i32; TOTAL] = undefined;

@default fn main() -> i32 {
    // Verify the array has the expected length.
    if DATA.len != 12 { return 1; }
    if DATA.len <> 12 { return 1; }
    return 0;
}

test/tests/const-expr-refs.rad +10 -10

15	15		constant J: i32 = A ^ B;
16	16		constant K: i32 = A << 2;
17	17		constant L: i32 = B >> 1;
18	18
19	19		@default fn main() -> i32 {
20		-	if C != 30 { return 1; }
21		-	if D != 60 { return 2; }
22		-	if E != 50 { return 3; }
23		-	if F != 10 { return 4; }
24		-	if G != 1 { return 5; }
25		-	if H != 30 { return 6; }
26		-	if I != 0 { return 7; }
27		-	if J != 30 { return 8; }
28		-	if K != 40 { return 9; }
29		-	if L != 10 { return 10; }
	20	+	if C <> 30 { return 1; }
	21	+	if D <> 60 { return 2; }
	22	+	if E <> 50 { return 3; }
	23	+	if F <> 10 { return 4; }
	24	+	if G <> 1 { return 5; }
	25	+	if H <> 30 { return 6; }
	26	+	if I <> 0 { return 7; }
	27	+	if J <> 30 { return 8; }
	28	+	if K <> 40 { return 9; }
	29	+	if L <> 10 { return 10; }
30	30		return 0;
31	31		}

test/tests/ecall.i64.rad +1 -1


    // Write to stdout. The pointer is passed as i64.
    let n = ecall(64, 1, msg.ptr as i64, msg.len as i64, 0);

    // Return value should be 3 (bytes written).
    if n != 3 {
    if n <> 3 {
        return 1;
    }
    return 0;
}

test/tests/edge.cases.4.rad +1 -1

        else return 40;

    let case TypeSig::Integer { width: w2, .. } = sig
        else return 41;

    if w2 != 4 {
    if w2 <> 4 {
        return w2 as i32;
    }
    return 0;
}

test/tests/edge.cases.6.rad +3 -3

    ANALYZER.entries[idx] = entry;
    ANALYZER.len = idx + 1;
}

fn checkHeader(expected: *[Entry]) -> i32 {
    if ANALYZER.entries.ptr != expected.ptr or ANALYZER.entries.len != expected.len {
    if ANALYZER.entries.ptr <> expected.ptr or ANALYZER.entries.len <> expected.len {
        // Slice header got clobbered instead of the backing storage.
        return 1;
    }
    if ANALYZER.len != 1 {
    if ANALYZER.len <> 1 {
        // Bookkeeping field was overwritten by the bad store.
        return 2;
    }
    assert ANALYZER.pad0 == 0xDEADAAA0 and ANALYZER.pad1 == 0xDEADAAA1;

    let stored = STORAGE[0];
    if stored.a != 0xAAAA1111 or stored.b != 0xBBBB2222 or stored.c != 0xCCCC3333 or stored.d != 0xDDDD4444 or stored.e != 0xEEEE5555 or stored.f != 0x12345601 or stored.j != 0x12345605 or stored.t != 0x1234560F {
    if stored.a <> 0xAAAA1111 or stored.b <> 0xBBBB2222 or stored.c <> 0xCCCC3333 or stored.d <> 0xDDDD4444 or stored.e <> 0xEEEE5555 or stored.f <> 0x12345601 or stored.j <> 0x12345605 or stored.t <> 0x1234560F {
        // The write never hit the backing buffer.
        return 3;
    }
    return 0;
}

test/tests/error.catch.rad +1 -1

    let ptrErr: ?*i32 = try? returnsPtrErr();
    assert ptrErr == nil;

    // try? on success
    let optOk: ?u32 = try? returnsOk();
    assert optOk != nil;
    assert optOk <> nil;
    if let v = optOk {
        assert v == 21;
    }

    // try? on error

test/tests/error.multi.try.optional.rad +1 -1

    let r1 = try? failA();
    assert r1 == nil;

    // try? on success should produce the value.
    let r2 = try? succeed();
    assert r2 != nil;
    assert r2 <> nil;
    let val = r2 else {
        return 3;
    };
    assert val == 77;
    return 0;

test/tests/error.try.optional.rad +3 -3

}

@default fn main() -> i32 {
    // Test 1: try? on success returns Some(value)
    let result1: ?u32 = try? returnsOk();
    assert result1 != nil;
    assert result1 <> nil;
    if let x = result1 {
        assert x == 42;
    }

    // Test 2: try? on error returns nil

        return 6;
    }

    // Test 5: try? in non-throwing function
    let result5: ?u32 = nonThrowingCaller();
    assert result5 != nil;
    assert result5 <> nil;
    if let x = result5 {
        assert x == 42;
    }

    // Test 6: try? with record return type
    let result8: ?Point = try? returnsOkPoint();
    assert result8 != nil;
    assert result8 <> nil;
    if let p = result8 {
        assert p.x == 10;
        assert p.y == 20;
    }


test/tests/for.else.continue.rad +1 -1

        let name = fields[i].name
            else continue;
        if name.len == target.len {
            let mut eq = true;
            for j in 0..name.len {
                if name[j] != target[j] {
                if name[j] <> target[j] {
                    eq = false;
                }
            }
            if eq {
                return fields[i].value;

test/tests/if-let-mut.rad +6 -6

fn testIfLetMut() -> i32 {
    let opt = getOptional(10);

    if let mut v = opt {
        v = v + 5;
        if v != 15 {
        if v <> 15 {
            return 1;
        }
    } else {
        return 2;
    }

37	37
38	38		let mut v = opt else {
39	39		return 4;
40	40		};
41	41		v = v + 8;
42		-	if v != 50 {
	42	+	if v <> 50 {
43	43		return 5;
44	44		}
45	45		return 0;
46	46		}
47	47

    return 6;
}

@default fn main() -> i32 {
    let r1 = testIfLetMut();
    if r1 != 0 {
    if r1 <> 0 {
        return r1;
    }
    let r2 = testIfLetMutNil();
    if r2 != 0 {
    if r2 <> 0 {
        return r2;
    }
    let r3 = testLetMutElse();
    if r3 != 0 {
    if r3 <> 0 {
        return r3;
    }
    let r4 = testLetMutElseNil();
    if r4 != 0 {
    if r4 <> 0 {
        return r4;
    }
    return 0;
}

test/tests/index.u8.rad +5 -5

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

    // u8 index.
    let idx8: u8 = 2;
    if arr[idx8] != 42 {
    if arr[idx8] <> 42 {
        return 1;
    }
    // u16 index.
    let idx16: u16 = 3;
    if arr[idx16] != 30 {
    if arr[idx16] <> 30 {
        return 2;
    }
    // u32 index (already worked).
    let idx32: u32 = 0;
    if arr[idx32] != 10 {
    if arr[idx32] <> 10 {
        return 3;
    }
    // Unsuffixed integer literal index.
    if arr[1] != 20 {
    if arr[1] <> 20 {
        return 4;
    }
    // u8 index into slice.
    let s = &arr[..];
    let si: u8 = 1;
    if s[si] != 20 {
    if s[si] <> 20 {
        return 5;
    }
    return 0;
}

test/tests/integer.bitwise.basic.rad +6 -6

    let xorResult:    i32 = a ^ b;  // 0b01001
    let notResult:    i32 = ~a;     // 0b00011
    let lshiftResult: i32 = a << 1; // 0b11000
    let rshiftResult: i32 = a >> 2; // 0b00011

    if andResult    != 4   { return (1) - 42; }
    if orResult     != 13  { return (1) - 42; }
    if xorResult    != 9   { return (1) - 42; }
    if notResult    != -13 { return (1) - 42; }
    if lshiftResult != 24  { return (1) - 42; }
    if rshiftResult != 3   { return (1) - 42; }
    if andResult    <> 4   { return (1) - 42; }
    if orResult     <> 13  { return (1) - 42; }
    if xorResult    <> 9   { return (1) - 42; }
    if notResult    <> -13 { return (1) - 42; }
    if lshiftResult <> 24  { return (1) - 42; }
    if rshiftResult <> 3   { return (1) - 42; }

    return (42) - 42;
}

test/tests/large.blit.store.rad +3 -3

66	66		return 0;
67	67		}
68	68
69	69		@default fn main() -> i32 {
70	70		let r1 = storeLargeOffset();
71		-	if r1 != 0 {
	71	+	if r1 <> 0 {
72	72		return 10 + r1;
73	73		}
74	74
75	75		let r2 = copyBig();
76		-	if r2 != 0 {
	76	+	if r2 <> 0 {
77	77		return 20 + r2;
78	78		}
79	79
80	80		let r3 = copyIndependence();
81		-	if r3 != 0 {
	81	+	if r3 <> 0 {
82	82		return 30 + r3;
83	83		}
84	84
85	85		return 0;
86	86		}

test/tests/literal.w64.rad +9 -9

fn testU64MaxLiteral() -> bool {
    let x: u64 = 18446744073709551615;
    // Check low and high bits.
    let lo: u64 = x & 0xFFFFFFFF;
    let hi: u64 = x >> 32;
    if lo != 0xFFFFFFFF {
    if lo <> 0xFFFFFFFF {
        return false;
    }
    if hi != 0xFFFFFFFF {
    if hi <> 0xFFFFFFFF {
        return false;
    }
    return true;
}

fn testI64MaxLiteral() -> bool {
    let x: i64 = 9223372036854775807;
    let shifted: i64 = x >> 32;
    if shifted != 0x7FFFFFFF {
    if shifted <> 0x7FFFFFFF {
        return false;
    }
    return true;
}


    let x: i64 = -9223372036854775808;
    if x >= 0 {
        return false;
    }
    let shifted: i64 = x >> 63;
    if shifted != -1 {
    if shifted <> -1 {
        return false;
    }
    return true;
}

fn testHexW64Literal() -> bool {
    let x: u64 = 0xDEADBEEFCAFEBABE;
    let lo: u32 = x as u32;
    let hi: u32 = (x >> 32) as u32;
    if lo != 0xCAFEBABE {
    if lo <> 0xCAFEBABE {
        return false;
    }
    if hi != 0xDEADBEEF {
    if hi <> 0xDEADBEEF {
        return false;
    }
    return true;
}

fn testLargeI64Arith() -> bool {
    let a: i64 = 1000000000000;
    let b: i64 = 2000000000000;
    let result: i64 = a + b;
    if result != 3000000000000 {
    if result <> 3000000000000 {
        return false;
    }
    return true;
}

fn testU64Overflow32() -> bool {
    // 2^32 + 1 = 4294967297
    let x: u64 = 4294967297;
    let lo: u32 = x as u32;
    let hi: u32 = (x >> 32) as u32;
    if lo != 1 {
    if lo <> 1 {
        return false;
    }
    if hi != 1 {
    if hi <> 1 {
        return false;
    }
    return true;
}


test/tests/load.u32.high.rad +3 -3

    // Shift right by 1: if correctly zero-extended (0x80000000),
    // u32 shift gives 0x40000000.
    // If sign-extended to 64-bit and then shifted as u32 via `srliw`,
    // the *w variant only looks at low 32 bits, so this still works.
    let shifted = val >> 1;
    if shifted != 0x40000000 {
    if shifted <> 0x40000000 {
        return false;
    }
    return true;
}


    let val = arr[0];

    // If lw sign-extends, val in register is 0xFFFFFFFFFFFFFFFF.
    // Adding 1 as u32 (via addw): 0xFFFFFFFF + 1 = 0 (wraps). OK either way.
    // But comparing: val should equal 0xFFFFFFFF as u32.
    if val != 0xFFFFFFFF {
    if val <> 0xFFFFFFFF {
        return false;
    }

    // The key test: widening to u64 should give 0x00000000FFFFFFFF,
    // not 0xFFFFFFFFFFFFFFFF.
    let wide: u64 = val as u64;
    if wide != 0xFFFFFFFF {
    if wide <> 0xFFFFFFFF {
        return false;
    }

    return true;
}

test/tests/match.value.copy.rad +3 -3

75	75		return 0;
76	76		}
77	77
78	78		@default fn main() -> i32 {
79	79		let r1 = testLetCase();
80		-	if r1 != 0 {
	80	+	if r1 <> 0 {
81	81		return r1;
82	82		}
83	83		let r2 = testIfLetCase();
84		-	if r2 != 0 {
	84	+	if r2 <> 0 {
85	85		return r2;
86	86		}
87	87		let r3 = testMatch();
88		-	if r3 != 0 {
	88	+	if r3 <> 0 {
89	89		return r3;
90	90		}
91	91		return 0;
92	92		}

test/tests/memzero.result.bug.rad +1 -1

    try fallible(false) catch {
        guard = 0xDEAD;
    };
    guard = 0xDEADBEEF;

    if guard != 0xDEADBEEF {
    if guard <> 0xDEADBEEF {
        return 1; // Guard was clobbered by an overzealous memzero.
    }
    return 0;
}

test/tests/mutref.scalar.rad +1 -1

}

fn test() -> i32 {
    let mut x: i32 = 0;
    let r: bool = modify(&mut x, false);
    if x != 1 {
    if x <> 1 {
        return 1;
    }
    return 0;
}

test/tests/nil.cmp.rad +6 -6

// nil == nil is always true
fn nilEqNil() -> bool {
    return nil == nil;
}

// nil != nil is always false
// nil <> nil is always false
fn nilNeNil() -> bool {
    return nil != nil;
    return nil <> nil;
}

// nil == opt (reversed order, pointer optional)
fn nilEqOptPtr(a: ?*i32) -> bool {
    return nil == a;
}

// nil != opt (reversed order, pointer optional)
// nil <> opt (reversed order, pointer optional)
fn nilNeOptPtr(a: ?*i32) -> bool {
    return nil != a;
    return nil <> a;
}

// nil == opt (reversed order, aggregate optional)
fn nilEqOptAgg(a: ?i32) -> bool {
    return nil == a;
}

// nil != opt (reversed order, aggregate optional)
// nil <> opt (reversed order, aggregate optional)
fn nilNeOptAgg(a: ?i32) -> bool {
    return nil != a;
    return nil <> a;
}

test/tests/opt.nil.check.rad +4 -4

    let p = makeAlignedPtr();
    let opt: ?*u8 = p;

    // The pointer is not nil, but its low byte is 0x00.
    // A W8 comparison would wrongly say it's nil.
    assert opt != nil;
    assert opt <> nil;
    if let v = opt {
        // Good: correctly identified as non-nil.
        return 0;
    }
    return 2;

    let offset: u64 = 256 - (base % 256);
    // Create a slice starting at an address whose low byte is 0.
    let s: *[u8] = &arr[offset as u32 ..];

    let opt: ?*[u8] = s;
    assert opt != nil;
    assert opt <> nil;
    if let v = opt {
        return 0;
    }
    return 2;
}

@default fn main() -> i32 {
    let r1 = testOptionalPtrNilCheck();
    if r1 != 0 {
    if r1 <> 0 {
        return r1;
    }
    let r2 = testOptionalSliceNilCheck();
    if r2 != 0 {
    if r2 <> 0 {
        return 10 + r2;
    }
    return 0;
}

test/tests/opt.record.eq.rad +2 -2


@default fn main() -> bool {
    let outerA = Outer { item: Inner { start: 3, end: 9 } };
    let outerB = Outer { item: Inner { start: 3, end: 9 } };

    if outerA != outerB {
    if outerA <> outerB {
        return false;
    }

    let outerC = Outer { item: Inner { start: 4, end: 6 } };
    if outerA == outerC {


    optA = outerA;
    optB = outerB;
    optDiff = outerC;

    if optA != optB {
    if optA <> optB {
        return false;
    }
    if optA == optDiff {
        return false;
    }

test/tests/opt.slice.npo.rad +12 -12

21	21		fn checkWrap() -> u8 {
22	22		let arr: [u8; 3] = [1, 2, 3];
23	23		let s = &arr[..];
24	24		let opt: ?*[u8] = s;
25	25
26		-	assert opt != nil;
	26	+	assert opt <> nil;
27	27		return 0;
28	28		}
29	29
30	30		fn checkIfLet() -> u8 {
31	31		let arr: [u8; 3] = [10, 20, 30];


fn checkReturn() -> u8 {
    let a = returnNil();
    assert a == nil;
    let b = returnSome();
    assert b != nil;
    assert b <> nil;
    if let val = b {
        assert val[0] == 42;
    } else {
        return 53;
    }

112	112
113	113		let arr: [u8; 2] = [1, 2];
114	114		let s = &arr[..];
115	115		let c: ?*[u8] = s;
116	116
117		-	// some != nil
118		-	assert c != a;
	117	+	// some <> nil
	118	+	assert c <> a;
119	119
120	120		// some == some (same pointer)
121	121		let d: ?*[u8] = s;
122	122		assert c == d;
123	123
124	124		return 0;
125	125		}
126	126
127	127		@default fn main() -> u8 {
128	128		let r1 = checkSizes();
129		-	if r1 != 0 {
	129	+	if r1 <> 0 {
130	130		return r1;
131	131		}
132	132		let r2 = checkNil();
133		-	if r2 != 0 {
	133	+	if r2 <> 0 {
134	134		return r2;
135	135		}
136	136		let r3 = checkWrap();
137		-	if r3 != 0 {
	137	+	if r3 <> 0 {
138	138		return r3;
139	139		}
140	140		let r4 = checkIfLet();
141		-	if r4 != 0 {
	141	+	if r4 <> 0 {
142	142		return r4;
143	143		}
144	144		let r5 = checkLetElse();
145		-	if r5 != 0 {
	145	+	if r5 <> 0 {
146	146		return r5;
147	147		}
148	148		let r6 = checkReturn();
149		-	if r6 != 0 {
	149	+	if r6 <> 0 {
150	150		return r6;
151	151		}
152	152		let r7 = checkMatch();
153		-	if r7 != 0 {
	153	+	if r7 <> 0 {
154	154		return r7;
155	155		}
156	156		let r8 = checkEq();
157		-	if r8 != 0 {
	157	+	if r8 <> 0 {
158	158		return r8;
159	159		}
160	160		return 0;
161	161		}

test/tests/optional.ptr.eq.rad +2 -2

fn optPtrEq(a: ?*i32, b: ?*i32) -> bool {
    return a == b;
}

fn optPtrNeq(a: ?*i32, b: ?*i32) -> bool {
    return a != b;
    return a <> b;
}

fn optPtrEqNil(a: ?*i32) -> bool {
    return a == nil;
}

fn optPtrNeqNil(a: ?*i32) -> bool {
    return a != nil;
    return a <> nil;
}

test/tests/prog.ackermann.rad +5 -5

146	146		limit = 8;
147	147		}
148	148		while n <= limit {
149	149		let r: i32 = ack(m, n);
150	150		let memoR: i32 = ackMemo(m, n);
151		-	if r != memoR {
	151	+	if r <> memoR {
152	152		return (m * 20 + n) as i32 + 1;
153	153		}
154	154		n += 1;
155	155		}
156	156		m += 1;

    return 0;
}

@default fn main() -> i32 {
    let r1: i32 = testSmallRecursive();
    if r1 != 0 {
    if r1 <> 0 {
        return 10 + r1;
    }

    let r2: i32 = testMemoized();
    if r2 != 0 {
    if r2 <> 0 {
        return 30 + r2;
    }

    let r3: i32 = testCrossCheck();
    if r3 != 0 {
    if r3 <> 0 {
        return 50 + r3;
    }

    let r4: i32 = testMonotonicity();
    if r4 != 0 {
    if r4 <> 0 {
        return 70 + r4;
    }

    return 0;
}

test/tests/prog.bignum.rad +8 -8

383	383		return 0;
384	384		}
385	385
386	386		@default fn main() -> i32 {
387	387		let r1: i32 = testAdd();
388		-	if r1 != 0 {
	388	+	if r1 <> 0 {
389	389		return 10 + r1;
390	390		}
391	391
392	392		let r2: i32 = testSub();
393		-	if r2 != 0 {
	393	+	if r2 <> 0 {
394	394		return 20 + r2;
395	395		}
396	396
397	397		let r3: i32 = testMul();
398		-	if r3 != 0 {
	398	+	if r3 <> 0 {
399	399		return 30 + r3;
400	400		}
401	401
402	402		let r4: i32 = testAddSubIdentity();
403		-	if r4 != 0 {
	403	+	if r4 <> 0 {
404	404		return 40 + r4;
405	405		}
406	406
407	407		let r5: i32 = testShift();
408		-	if r5 != 0 {
	408	+	if r5 <> 0 {
409	409		return 50 + r5;
410	410		}
411	411
412	412		let r6: i32 = testLargeMultiply();
413		-	if r6 != 0 {
	413	+	if r6 <> 0 {
414	414		return 60 + r6;
415	415		}
416	416
417	417		let r7: i32 = testFibonacci();
418		-	if r7 != 0 {
	418	+	if r7 <> 0 {
419	419		return 70 + r7;
420	420		}
421	421
422	422		let r8: i32 = testCompare();
423		-	if r8 != 0 {
	423	+	if r8 <> 0 {
424	424		return 80 + r8;
425	425		}
426	426
427	427		return 0;
428	428		}

test/tests/prog.binsearch.rad +4 -4

fn testAllPresent(data: *[i32]) -> i32 {
    for value, index in data {
        let found = binarySearch(data, value) else {
            return index as i32 + 1;
        };
        if found != index {
        if found <> index {
            return index as i32 + 1;
        }
    }
    return 0;
}

90	90		3, 7, 11, 15, 22, 30, 35, 41, 50, 58,
91	91		63, 70, 77, 84, 90, 95, 100, 108, 115, 120
92	92		];
93	93
94	94		let r1 = testPresent(&sorted[..]);
95		-	if r1 != 0 {
	95	+	if r1 <> 0 {
96	96		return 10 + r1;
97	97		}
98	98
99	99		let r2 = testAbsent(&sorted[..]);
100		-	if r2 != 0 {
	100	+	if r2 <> 0 {
101	101		return 20 + r2;
102	102		}
103	103
104	104		let r3 = testAllPresent(&sorted[..]);
105		-	if r3 != 0 {
	105	+	if r3 <> 0 {
106	106		return 30 + r3;
107	107		}
108	108		return 0;
109	109		}

test/tests/prog.bubblesort.rad +1 -1

    let sumAfter = sum(&data[..]);
    assert sumBefore == sumAfter;

    // Check specific element positions.
    let r = verifyPositions(&data[..]);
    if r != 0 {
    if r <> 0 {
        return 10 + r;
    }
    return 0;
}

test/tests/prog.cordic.rad +7 -7


/// Fixed-point multiply: (a * b) >> 16, using half-word decomposition
/// to avoid 32-bit overflow.
fn fpmul(a: i32, b: i32) -> i32 {
    // Determine sign and work with magnitudes.
    let neg: bool = (a < 0) != (b < 0);
    let neg: bool = (a < 0) <> (b < 0);
    let mut ua: u32 = a as u32;
    if a < 0 {
        ua = (0 - a) as u32;
    }
    let mut ub: u32 = b as u32;

234	234		4, // atan(2^-14)
235	235		2 // atan(2^-15)
236	236		];
237	237
238	238		let r1: i32 = testZero(&atanTable[..]);
239		-	if r1 != 0 {
	239	+	if r1 <> 0 {
240	240		return 10 + r1;
241	241		}
242	242
243	243		let r2: i32 = testHalfPi(&atanTable[..]);
244		-	if r2 != 0 {
	244	+	if r2 <> 0 {
245	245		return 20 + r2;
246	246		}
247	247
248	248		let r3: i32 = testPi(&atanTable[..]);
249		-	if r3 != 0 {
	249	+	if r3 <> 0 {
250	250		return 30 + r3;
251	251		}
252	252
253	253		let r4: i32 = testPythagorean(&atanTable[..]);
254		-	if r4 != 0 {
	254	+	if r4 <> 0 {
255	255		return 40 + r4;
256	256		}
257	257
258	258		let r5: i32 = testSymmetry(&atanTable[..]);
259		-	if r5 != 0 {
	259	+	if r5 <> 0 {
260	260		return 50 + r5;
261	261		}
262	262
263	263		let r6: i32 = testPiThird(&atanTable[..]);
264		-	if r6 != 0 {
	264	+	if r6 <> 0 {
265	265		return 60 + r6;
266	266		}
267	267
268	268		return 0;
269	269		}

test/tests/prog.crc32.rad +4 -4

        i += 1;
    }
    let crcFull = crc32(table, &buf[..]);

    // CRC should be non-zero and deterministic.
    assert crcFull != 0;
    assert crcFull <> 0;

    // Recompute and verify it's the same.
    assert crc32(table, &buf[..]) == crcFull;

    // Known value for bytes 0..31: 0x91267E8A

86	86		@default fn main() -> i32 {
87	87		let mut table: [u32; 256] = [0; 256];
88	88		buildTable(&mut table[..]);
89	89
90	90		let r1 = testTable(&table[..]);
91		-	if r1 != 0 {
	91	+	if r1 <> 0 {
92	92		return 10 + r1;
93	93		}
94	94
95	95		let r2 = testKnownCRC(&table[..]);
96		-	if r2 != 0 {
	96	+	if r2 <> 0 {
97	97		return 20 + r2;
98	98		}
99	99
100	100		let r3 = testIncremental(&table[..]);
101		-	if r3 != 0 {
	101	+	if r3 <> 0 {
102	102		return 30 + r3;
103	103		}
104	104		return 0;
105	105		}

test/tests/prog.dijkstra.rad +11 -11

        }
        g.visited[u] = true;

        let mut v: u32 = 0;
        while v < g.numNodes {
            if g.adj[u][v] != INF and not g.visited[v] {
            if g.adj[u][v] <> INF and not g.visited[v] {
                let newDist: u32 = g.dist[u] + g.adj[u][v];
                if newDist < g.dist[v] {
                    g.dist[v] = newDist;
                    g.prev[v] = u as i32;
                    heapPush(g, newDist, v);

179	179
180	180		dijkstra(g, 0);
181	181
182	182		let expected: [u32; 5] = [0, 10, 20, 30, 40];
183	183		for exp, i in expected {
184		-	if g.dist[i] != exp {
	184	+	if g.dist[i] <> exp {
185	185		return i as i32 + 1;
186	186		}
187	187		}
188	188
189	189		let mut path: [u32; 16] = [0; 16];


    dijkstra(g, 0);

    let expected: [u32; 5] = [0, 1, 3, 4, 4];
    for exp, i in expected {
        if g.dist[i] != exp {
        if g.dist[i] <> exp {
            return i as i32 + 1;
        }
    }

    return 0;

241	241
242	242		let mut i: u32 = 0;
243	243		while i < 8 {
244	244		let mut j: u32 = 0;
245	245		while j < 8 {
246		-	if i != j {
	246	+	if i <> j {
247	247		let mut diff: u32 = j - i;
248	248		if i > j {
249	249		diff = i - j;
250	250		}
251	251		addEdge(g, i, j, diff * 3 + 1);

    dijkstra(g, 0);

    let mut k: u32 = 1;
    while k < 8 {
        let expected: u32 = k * 3 + 1;
        if g.dist[k] != expected {
        if g.dist[k] <> expected {
            return k as i32;
        }
        k += 1;
    }


329	329		heap: &mut heap[..],
330	330		heapSize: 0,
331	331		};
332	332
333	333		let r1: i32 = testLinear(&mut g);
334		-	if r1 != 0 {
	334	+	if r1 <> 0 {
335	335		return 10 + r1;
336	336		}
337	337
338	338		let r2: i32 = testShortcut(&mut g);
339		-	if r2 != 0 {
	339	+	if r2 <> 0 {
340	340		return 20 + r2;
341	341		}
342	342
343	343		let r3: i32 = testBidirectional(&mut g);
344		-	if r3 != 0 {
	344	+	if r3 <> 0 {
345	345		return 30 + r3;
346	346		}
347	347
348	348		let r4: i32 = testComplete(&mut g);
349		-	if r4 != 0 {
	349	+	if r4 <> 0 {
350	350		return 40 + r4;
351	351		}
352	352
353	353		let r5: i32 = testDisconnected(&mut g);
354		-	if r5 != 0 {
	354	+	if r5 <> 0 {
355	355		return 50 + r5;
356	356		}
357	357
358	358		let r6: i32 = testDiamond(&mut g);
359		-	if r6 != 0 {
	359	+	if r6 <> 0 {
360	360		return 60 + r6;
361	361		}
362	362
363	363		return 0;
364	364		}

test/tests/prog.eval.rad +7 -7

198	198
199	199		@default fn main() -> i32 {
200	200		let mut pool: Pool = Pool { nodes: [Expr::Num(0); 64], count: 0 };
201	201
202	202		let r1 = testSimpleAdd(&mut pool);
203		-	if r1 != 0 {
	203	+	if r1 <> 0 {
204	204		return 10 + r1;
205	205		}
206	206
207	207		let r2 = testNested(&mut pool);
208		-	if r2 != 0 {
	208	+	if r2 <> 0 {
209	209		return 20 + r2;
210	210		}
211	211
212	212		let r3 = testComplex(&mut pool);
213		-	if r3 != 0 {
	213	+	if r3 <> 0 {
214	214		return 30 + r3;
215	215		}
216	216
217	217		let r4 = testNeg(&mut pool);
218		-	if r4 != 0 {
	218	+	if r4 <> 0 {
219	219		return 40 + r4;
220	220		}
221	221
222	222		let r5 = testDeep(&mut pool);
223		-	if r5 != 0 {
	223	+	if r5 <> 0 {
224	224		return 50 + r5;
225	225		}
226	226
227	227		let r6 = testMixed(&mut pool);
228		-	if r6 != 0 {
	228	+	if r6 <> 0 {
229	229		return 60 + r6;
230	230		}
231	231
232	232		let r7 = testSingleNum(&mut pool);
233		-	if r7 != 0 {
	233	+	if r7 <> 0 {
234	234		return 70 + r7;
235	235		}
236	236		return 0;
237	237		}

test/tests/prog.hanoi.rad +3 -3


    // Solve: move all disks from peg 0 to peg 1 using peg 2.
    hanoi(&mut ml, NUM_DISKS, 0, 1, 2);

    let r1 = testMoveCount(&ml);
    if r1 != 0 {
    if r1 <> 0 {
        return 10 + r1;
    }

    let r2 = testSpecificMoves(&ml);
    if r2 != 0 {
    if r2 <> 0 {
        return 20 + r2;
    }

    let r3 = testSimulate(&ml);
    if r3 != 0 {
    if r3 <> 0 {
        return 30 + r3;
    }
    return 0;
}

test/tests/prog.huffman.rad +9 -9

        case HNodeKind::Leaf(sym) => {
            s.codeBits[sym] = code;
            s.codeLen[sym] = depth;
        }
        case HNodeKind::Interior => {
            if s.nodes[nodeIdx].left != NIL {
            if s.nodes[nodeIdx].left <> NIL {
                generateCodes(s, s.nodes[nodeIdx].left, code << 1, depth + 1);
            }
            if s.nodes[nodeIdx].right != NIL {
            if s.nodes[nodeIdx].right <> NIL {
                generateCodes(s, s.nodes[nodeIdx].right, (code << 1) | 1, depth + 1);
            }
        }
    }
}

    generateCodes(s, root, 0, 0);

    // All symbols should have non-zero code lengths.
    let mut i: u32 = 0;
    while i < 5 {
        assert s.codeLen[i] != 0;
        assert s.codeLen[i] <> 0;
        i += 1;
    }

    // No two symbols at the same depth should have the same code.
    let mut a: u32 = 0;
    while a < 5 {
        let mut b: u32 = a + 1;
        while b < 5 {
            if s.codeLen[a] == s.codeLen[b] {
                assert s.codeBits[a] != s.codeBits[b];
                assert s.codeBits[a] <> s.codeBits[b];
            }
            b += 1;
        }
        a += 1;
    }


    assert count == 16;

    // Verify round-trip.
    for expected, i in msg {
        if decoded[i] != expected {
        if decoded[i] <> expected {
            return i as i32 + 2;
        }
    }

    return 0;

368	368		bitstream: &mut bitstream[..],
369	369		bitCount: 0,
370	370		};
371	371
372	372		let r1: i32 = testBasic(&mut s);
373		-	if r1 != 0 {
	373	+	if r1 <> 0 {
374	374		return 10 + r1;
375	375		}
376	376
377	377		let r2: i32 = testRoundTrip(&mut s);
378		-	if r2 != 0 {
	378	+	if r2 <> 0 {
379	379		return 20 + r2;
380	380		}
381	381
382	382		let r3: i32 = testSkewed(&mut s);
383		-	if r3 != 0 {
	383	+	if r3 <> 0 {
384	384		return 30 + r3;
385	385		}
386	386
387	387		let r4: i32 = testUniform(&mut s);
388		-	if r4 != 0 {
	388	+	if r4 <> 0 {
389	389		return 40 + r4;
390	390		}
391	391
392	392		return 0;
393	393		}

test/tests/prog.hybridsort.rad +5 -5

            if data[j] < data[minIdx] {
                minIdx = j;
            }
            j += 1;
        }
        if minIdx != i {
        if minIdx <> i {
            let tmp = data[i];
            data[i] = data[minIdx];
            data[minIdx] = tmp;
        }
        i += 1;

}

/// Compare two arrays element by element.
fn arraysEqual(a: *[i32], b: *[i32]) -> i32 {
    for val, i in a {
        if val != b[i] {
        if val <> b[i] {
            return i as i32 + 1;
        }
    }
    return 0;
}

84	84		// Sorted: 2 3 6 8 10 14 19 25 27 33 39 41 45 48 53 56 62 67 72 74 81 88 91 97
85	85		let expected: [i32; 6] = [2, 3, 6, 41, 91, 97];
86	86		let indices: [u32; 6] = [0, 1, 2, 11, 22, 23];
87	87
88	88		for exp, i in expected {
89		-	if data[indices[i]] != exp {
	89	+	if data[indices[i]] <> exp {
90	90		return i as i32 + 1;
91	91		}
92	92		}
93	93		return 0;
94	94		}

    assert isSorted(&b[..]);
    assert sum(&b[..]) == origSum;

    // Both algorithms must produce the same result.
    let r = arraysEqual(&a[..], &b[..]);
    if r != 0 {
    if r <> 0 {
        return 10 + r;
    }

    // Verify specific sorted positions.
    let r2 = verifyPositions(&a[..]);
    if r2 != 0 {
    if r2 <> 0 {
        return 40 + r2;
    }
    return 0;
}

test/tests/prog.linkedlist.rad +7 -7

}

/// Test find.
fn testFind(list: *mut List) -> i32 {
    // 20 should be found.
    assert find(list, 20) != nil;
    assert find(list, 20) <> nil;
    // 10 should be found.
    assert find(list, 10) != nil;
    assert find(list, 10) <> nil;
    // 30 was popped, should not be found.
    assert find(list, 30) == nil;
    // 99 never inserted.
    assert find(list, 99) == nil;
    return 0;

248	248		free: 0,
249	249		head: nil,
250	250		};
251	251
252	252		let r1 = testPushLength(&mut list);
253		-	if r1 != 0 {
	253	+	if r1 <> 0 {
254	254		return 10 + r1;
255	255		}
256	256
257	257		let r2 = testPop(&mut list);
258		-	if r2 != 0 {
	258	+	if r2 <> 0 {
259	259		return 20 + r2;
260	260		}
261	261
262	262		let r3 = testFind(&mut list);
263		-	if r3 != 0 {
	263	+	if r3 <> 0 {
264	264		return 30 + r3;
265	265		}
266	266
267	267		let r4 = testReverse(&mut list);
268		-	if r4 != 0 {
	268	+	if r4 <> 0 {
269	269		return 40 + r4;
270	270		}
271	271
272	272		let r5 = testLargerList(&mut list);
273		-	if r5 != 0 {
	273	+	if r5 <> 0 {
274	274		return 50 + r5;
275	275		}
276	276		return 0;
277	277		}

test/tests/prog.lzw.rad +9 -9

    let mut i: u32 = 1;

    while i < data.len {
        let c: u8 = data[i];
        let wc: u32 = dictLookup(s, w, c);
        if wc != 0xFFFFFFFF {
        if wc <> 0xFFFFFFFF {
            w = wc;
        } else {
            emitCode(s, w);
            dictAdd(s, w, c);
            w = c as u32;

}

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 {
    while c <> 0xFFFF and c < s.decDictSize {
        s.temp[len] = s.decDict[c].suffix;
        len += 1;
        c = s.decDict[c].prefix;
    }
    let mut a: u32 = 0;

    return len;
}

fn firstByte(s: *LzwState, code: u32) -> u8 {
    let mut c: u32 = code;
    while s.decDict[c].prefix != 0xFFFF and s.decDict[c].prefix < s.decDictSize {
    while s.decDict[c].prefix <> 0xFFFF and s.decDict[c].prefix < s.decDictSize {
        c = s.decDict[c].prefix;
    }
    return s.decDict[c].suffix;
}


285	285		decLen: 0,
286	286		temp: &mut temp[..],
287	287		};
288	288
289	289		let r1: i32 = testSimple(&mut s);
290		-	if r1 != 0 { return 10 + r1; }
	290	+	if r1 <> 0 { return 10 + r1; }
291	291
292	292		let r2: i32 = testDistinct(&mut s);
293		-	if r2 != 0 { return 20 + r2; }
	293	+	if r2 <> 0 { return 20 + r2; }
294	294
295	295		let r3: i32 = testRepetitive(&mut s);
296		-	if r3 != 0 { return 30 + r3; }
	296	+	if r3 <> 0 { return 30 + r3; }
297	297
298	298		let r4: i32 = testMixed(&mut s);
299		-	if r4 != 0 { return 40 + r4; }
	299	+	if r4 <> 0 { return 40 + r4; }
300	300
301	301		let r5: i32 = testEmpty(&mut s);
302		-	if r5 != 0 { return 50 + r5; }
	302	+	if r5 <> 0 { return 50 + r5; }
303	303
304	304		let r6: i32 = testSingle(&mut s);
305		-	if r6 != 0 { return 60 + r6; }
	305	+	if r6 <> 0 { return 60 + r6; }
306	306
307	307		return 0;
308	308		}

test/tests/prog.matmul.rad +3 -3

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

110	110
111	111		let mut c = Mat4 { rows: [[0; 4]; 4] };
112	112		matmul(&mut c, &a, &b);
113	113
114	114		let r1 = verifyResult(&c, &expected);
115		-	if r1 != 0 {
	115	+	if r1 <> 0 {
116	116		return 10 + r1;
117	117		}
118	118
119	119		let r2 = testRepeatedMultiply(&mut c, &a, &b);
120		-	if r2 != 0 {
	120	+	if r2 <> 0 {
121	121		return 30 + r2;
122	122		}
123	123		return 0;
124	124		}

test/tests/prog.mersenne.rad +13 -13

119	119		mtInit(s, 42);
120	120
121	121		i = 0;
122	122		while i < 10 {
123	123		let v: u32 = mtNext(s);
124		-	if v != first[i] { return i as i32 + 1; }
	124	+	if v <> first[i] { return i as i32 + 1; }
125	125		i += 1;
126	126		}
127	127
128	128		return 0;
129	129		}

    let b: u32 = mtNext(s);

    mtInit(s, 3);
    let c: u32 = mtNext(s);

    assert a != b;
    assert b != c;
    assert a != c;
    assert a <> b;
    assert b <> c;
    assert a <> c;

    return 0;
}

fn testChiSquared(s: *mut MtState) -> i32 {


    assert chi2Scaled <= 5000;

    b = 0;
    while b < NUM_BINS {
        assert bins[b] != 0;
        assert bins[b] <> 0;
        b += 1;
    }

    b = 0;
    while b < NUM_BINS {

    i = 0;
    while i < 700 {
        more = mtNext(s);
        i += 1;
    }
    assert more != 0;
    assert more <> 0;

    return 0;
}

fn testBitCoverage(s: *mut MtState) -> i32 {

        andAll &= v;
        i += 1;
    }

    assert orAll == 0xFFFFFFFF;
    assert andAll != 0xFFFFFFFF;
    assert andAll <> 0xFFFFFFFF;
    assert andAll == 0;

    return 0;
}


247	247		mt: &mut mt[..],
248	248		mti: 625,
249	249		};
250	250
251	251		let r1: i32 = testKnownSequence(&mut s);
252		-	if r1 != 0 { return 10 + r1; }
	252	+	if r1 <> 0 { return 10 + r1; }
253	253
254	254		let r2: i32 = testDeterminism(&mut s);
255		-	if r2 != 0 { return 20 + r2; }
	255	+	if r2 <> 0 { return 20 + r2; }
256	256
257	257		let r3: i32 = testDifferentSeeds(&mut s);
258		-	if r3 != 0 { return 30 + r3; }
	258	+	if r3 <> 0 { return 30 + r3; }
259	259
260	260		let r4: i32 = testChiSquared(&mut s);
261		-	if r4 != 0 { return 40 + r4; }
	261	+	if r4 <> 0 { return 40 + r4; }
262	262
263	263		let r5: i32 = testRegeneration(&mut s);
264		-	if r5 != 0 { return 50 + r5; }
	264	+	if r5 <> 0 { return 50 + r5; }
265	265
266	266		let r6: i32 = testBitCoverage(&mut s);
267		-	if r6 != 0 { return 60 + r6; }
	267	+	if r6 <> 0 { return 60 + r6; }
268	268
269	269		return 0;
270	270		}

test/tests/prog.nqueens.rad +8 -8

fn testAllSizes(b: *mut Board) -> i32 {
    let expected: [u32; 9] = [0, 1, 0, 0, 2, 10, 4, 40, 92];
    let mut n: u32 = 1;
    while n <= 8 {
        let count: u32 = solveNQueens(b, n);
        if count != expected[n] {
        if count <> expected[n] {
            return n as i32;
        }
        n += 1;
    }
    return 0;


    let mut i: u32 = 0;
    while i < 8 {
        let mut j: u32 = i + 1;
        while j < 8 {
            assert solution[i] != solution[j];
            assert solution[i] <> solution[j];
            let rowDiff: i32 = j as i32 - i as i32;
            let colDiff: i32 = solution[j] - solution[i];
            assert colDiff != rowDiff and colDiff != 0 - rowDiff;
            assert colDiff <> rowDiff and colDiff <> 0 - rowDiff;
            j += 1;
        }
        i += 1;
    }


fn testProperties() -> i32 {
    let expected: [u32; 9] = [0, 1, 0, 0, 2, 10, 4, 40, 92];

    let mut n: u32 = 4;
    while n <= 8 {
        assert expected[n] != 0;
        assert expected[n] <> 0;
        n += 1;
    }

    assert expected[2] == 0;
    assert expected[3] == 0;

        solutionCount: 0,
        boardSize: 0,
    };

    let r1: i32 = testAllSizes(&mut b);
    if r1 != 0 { return 10 + r1; }
    if r1 <> 0 { return 10 + r1; }

    let r2: i32 = testKnownSolution();
    if r2 != 0 { return 20 + r2; }
    if r2 <> 0 { return 20 + r2; }

    let r3: i32 = testDeterminism(&mut b);
    if r3 != 0 { return 30 + r3; }
    if r3 <> 0 { return 30 + r3; }

    let r4: i32 = testProperties();
    if r4 != 0 { return 40 + r4; }
    if r4 <> 0 { return 40 + r4; }

    return 0;
}

test/tests/prog.rbtree.rad +12 -12

}

fn rotateLeft(t: *mut RBTree, x: u32) {
    let y: u32 = t.pool[x].right;
    t.pool[x].right = t.pool[y].left;
    if t.pool[y].left != NIL {
    if t.pool[y].left <> NIL {
        t.pool[t.pool[y].left].parent = x;
    }
    t.pool[y].parent = t.pool[x].parent;
    if t.pool[x].parent == NIL {
        t.root = y;

}

fn rotateRight(t: *mut RBTree, x: u32) {
    let y: u32 = t.pool[x].left;
    t.pool[x].left = t.pool[y].right;
    if t.pool[y].right != NIL {
    if t.pool[y].right <> NIL {
        t.pool[t.pool[y].right].parent = x;
    }
    t.pool[y].parent = t.pool[x].parent;
    if t.pool[x].parent == NIL {
        t.root = y;

fn insert(t: *mut RBTree, key: i32) {
    let z: u32 = allocNode(t, key);
    let mut y: u32 = NIL;
    let mut x: u32 = t.root;

    while x != NIL {
    while x <> NIL {
        y = x;
        if key < t.pool[x].key {
            x = t.pool[x].left;
        } else {
            x = t.pool[x].right;

    insertFixup(t, z);
}

fn search(t: *RBTree, key: i32) -> bool {
    let mut x: u32 = t.root;
    while x != NIL {
    while x <> NIL {
        if key == t.pool[x].key {
            return true;
        } else if key < t.pool[x].key {
            x = t.pool[x].left;
        } else {

    let rightBH: i32 = blackHeight(t, t.pool[x].right);

    if leftBH == -1 or rightBH == -1 {
        return -1;
    }
    if leftBH != rightBH {
    if leftBH <> rightBH {
        return -1;
    }

    if t.pool[x].color == BLACK {
        return leftBH + 1;


    assert countNodes(t, t.root) == 32;
    assert t.pool[t.root].color == BLACK;

    let bh: i32 = blackHeight(t, t.root);
    assert bh != -1;
    assert bh <> -1;

    assert noRedRed(t, t.root);

    t.inorderCount = 0;
    inorderWalk(t, t.root);

        }
        i -= 1;
    }

    assert countNodes(t, t.root) == 32;
    assert blackHeight(t, t.root) != -1;
    assert blackHeight(t, t.root) <> -1;
    assert noRedRed(t, t.root);

    t.inorderCount = 0;
    inorderWalk(t, t.root);
    let mut j: u32 = 0;

            count += 1;
        }
    }

    assert countNodes(t, t.root) == 48;
    assert blackHeight(t, t.root) != -1;
    assert blackHeight(t, t.root) <> -1;
    assert noRedRed(t, t.root);

    let mut i: i32 = 0;
    while i < 48 {
        assert search(t, i);

339	339		inorder: &mut inorder[..],
340	340		inorderCount: 0,
341	341		};
342	342
343	343		let r1: i32 = testAscending(&mut t);
344		-	if r1 != 0 { return 10 + r1; }
	344	+	if r1 <> 0 { return 10 + r1; }
345	345
346	346		let r2: i32 = testDescending(&mut t);
347		-	if r2 != 0 { return 20 + r2; }
	347	+	if r2 <> 0 { return 20 + r2; }
348	348
349	349		let r3: i32 = testRandom(&mut t);
350		-	if r3 != 0 { return 30 + r3; }
	350	+	if r3 <> 0 { return 30 + r3; }
351	351
352	352		let r4: i32 = testHeight(&mut t);
353		-	if r4 != 0 { return 50 + r4; }
	353	+	if r4 <> 0 { return 50 + r4; }
354	354
355	355		return 0;
356	356		}

test/tests/prog.regex.rad +9 -9

        changed = false;
        let mut s: u32 = 0;
        while s < nfa.stateCount {
            if setHas(nfa.closure, s) {
                let mut t: u32 = nfa.stateFirst[s];
                while t != NIL {
                while t <> NIL {
                    if nfa.trans[t].kind == TRANS_EPSILON {
                        if not setHas(nfa.closure, nfa.trans[t].to) {
                            setAdd(nfa.closure, nfa.trans[t].to);
                            changed = true;
                        }


        let mut s: u32 = 0;
        while s < nfa.stateCount {
            if setHas(nfa.current, s) {
                let mut t: u32 = nfa.stateFirst[s];
                while t != NIL {
                while t <> NIL {
                    if nfa.trans[t].kind == TRANS_CHAR and nfa.trans[t].ch == ch {
                        setAdd(nfa.nextSet, nfa.trans[t].to);
                    } else if nfa.trans[t].kind == TRANS_DOT {
                        setAdd(nfa.nextSet, nfa.trans[t].to);
                    }

371	371		fragStack: &mut fragStack[..],
372	372		fragTop: 0,
373	373		};
374	374
375	375		let r1: i32 = testLiteral(&mut nfa);
376		-	if r1 != 0 { return 10 + r1; }
	376	+	if r1 <> 0 { return 10 + r1; }
377	377
378	378		let r2: i32 = testStar(&mut nfa);
379		-	if r2 != 0 { return 20 + r2; }
	379	+	if r2 <> 0 { return 20 + r2; }
380	380
381	381		let r3: i32 = testPlus(&mut nfa);
382		-	if r3 != 0 { return 30 + r3; }
	382	+	if r3 <> 0 { return 30 + r3; }
383	383
384	384		let r4: i32 = testQuestion(&mut nfa);
385		-	if r4 != 0 { return 40 + r4; }
	385	+	if r4 <> 0 { return 40 + r4; }
386	386
387	387		let r5: i32 = testDot(&mut nfa);
388		-	if r5 != 0 { return 50 + r5; }
	388	+	if r5 <> 0 { return 50 + r5; }
389	389
390	390		let r6: i32 = testComplex(&mut nfa);
391		-	if r6 != 0 { return 60 + r6; }
	391	+	if r6 <> 0 { return 60 + r6; }
392	392
393	393		let r7: i32 = testDotStar(&mut nfa);
394		-	if r7 != 0 { return 70 + r7; }
	394	+	if r7 <> 0 { return 70 + r7; }
395	395
396	396		return 0;
397	397		}

test/tests/prog.sha256.rad +3 -3

233	233		];
234	234
235	235		let mut s: Sha256 = Sha256 { h: INIT_H, w: [0; 64] };
236	236
237	237		let r1 = testHelpers();
238		-	if r1 != 0 {
	238	+	if r1 <> 0 {
239	239		return 10 + r1;
240	240		}
241	241
242	242		let r2 = testEmpty(&mut s, &k[..]);
243		-	if r2 != 0 {
	243	+	if r2 <> 0 {
244	244		return 20 + r2;
245	245		}
246	246
247	247		let r3 = testAbc(&mut s, &k[..]);
248		-	if r3 != 0 {
	248	+	if r3 <> 0 {
249	249		return 30 + r3;
250	250		}
251	251		return 0;
252	252		}

test/tests/prog.sieve.rad +2 -2

@default fn main() -> i32 {
    let mut sieve: [bool; 256] = [false; 256];
    runSieve(&mut sieve[..]);

    let r1 = verifyKnownPrimes(&sieve[..]);
    if r1 != 0 {
    if r1 <> 0 {
        return 10 + r1;
    }

    // There are 54 primes <= 255 (2, 3, 5, ..., 251).
    assert countPrimes(&sieve[..]) == 54;

    let r3 = verifyCollected(&sieve[..]);
    if r3 != 0 {
    if r3 <> 0 {
        return 40 + r3;
    }
    return 0;
}

test/tests/prog.symtab.rad +13 -13


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

        // Restore shadowed symbol if any.
        if sym.shadow != NIL {
        if sym.shadow <> NIL {
            // The shadowed symbol is still in the symbols array;
            // re-link it into the hash chain.
            let shadowIdx = sym.shadow;
            tab.symbols[shadowIdx].next = tab.buckets[bucket];
            tab.buckets[bucket] = shadowIdx;

    let bucket = h % HASH_SIZE;

    // Check for shadowed symbol with same name.
    let mut shadowIdx: u32 = NIL;
    let mut cur = tab.buckets[bucket];
    while cur != NIL {
    while cur <> NIL {
        if tab.symbols[cur].nameHash == h {
            // Found existing symbol with same hash - shadow it.
            // Remove it from hash chain first.
            shadowIdx = cur;
            // Remove the shadowed symbol from the bucket chain.

fn lookup(tab: *SymTab, name: *[u8]) -> ?i32 {
    let h = hashName(name);
    let bucket = h % HASH_SIZE;
    let mut cur = tab.buckets[bucket];

    while cur != NIL {
    while cur <> NIL {
        if tab.symbols[cur].nameHash == h {
            return tab.symbols[cur].value;
        }
        cur = tab.symbols[cur].next;
    }

fn update(tab: *mut SymTab, name: *[u8], newValue: i32) -> bool {
    let h = hashName(name);
    let bucket = h % HASH_SIZE;
    let mut cur = tab.buckets[bucket];

    while cur != NIL {
    while cur <> NIL {
        if tab.symbols[cur].nameHash == h {
            tab.symbols[cur].value = newValue;
            return true;
        }
        cur = tab.symbols[cur].next;

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

                failures += 1;
            }
        }
    }

    if failures != 0 {
    if failures <> 0 {
        return failures as i32;
    }

    popScope(tab);
    popScope(tab);

        scopeDepth: 0,
        buckets: &mut buckets[..],
    };

    let r1 = testBasic(&mut tab);
    if r1 != 0 {
    if r1 <> 0 {
        return 10 + r1;
    }

    let r2 = testShadowing(&mut tab);
    if r2 != 0 {
    if r2 <> 0 {
        return 20 + r2;
    }

    let r3 = testDeepNesting(&mut tab);
    if r3 != 0 {
    if r3 <> 0 {
        return 30 + r3;
    }

    let r4 = testMultipleSymbols(&mut tab);
    if r4 != 0 {
    if r4 <> 0 {
        return 40 + r4;
    }

    let r5 = testUpdate(&mut tab);
    if r5 != 0 {
    if r5 <> 0 {
        return 50 + r5;
    }

    let r6 = testScopeIsolation(&mut tab);
    if r6 != 0 {
    if r6 <> 0 {
        return 60 + r6;
    }

    let r7 = testInterleaved(&mut tab);
    if r7 != 0 {
    if r7 <> 0 {
        return 70 + r7;
    }

    return 0;
}

test/tests/prog.tokenizer.rad +11 -11

@default fn main() -> i32 {
    let mut tokenBuf: [Token; 128] = [Token::Eof; 128];
    let mut exprBuf: [Expr; 128] = [Expr::Num(0); 128];

    let r1 = testNumber(&mut tokenBuf[..], &mut exprBuf[..]);
    if r1 != 0 {
    if r1 <> 0 {
        return 10 + r1;
    }

    let r2 = testAdd(&mut tokenBuf[..], &mut exprBuf[..]);
    if r2 != 0 {
    if r2 <> 0 {
        return 20 + r2;
    }

    let r3 = testPrecedence(&mut tokenBuf[..], &mut exprBuf[..]);
    if r3 != 0 {
    if r3 <> 0 {
        return 30 + r3;
    }

    let r4 = testParens(&mut tokenBuf[..], &mut exprBuf[..]);
    if r4 != 0 {
    if r4 <> 0 {
        return 40 + r4;
    }

    let r5 = testNeg(&mut tokenBuf[..], &mut exprBuf[..]);
    if r5 != 0 {
    if r5 <> 0 {
        return 50 + r5;
    }

    let r6 = testComplex(&mut tokenBuf[..], &mut exprBuf[..]);
    if r6 != 0 {
    if r6 <> 0 {
        return 60 + r6;
    }

    let r7 = testChained(&mut tokenBuf[..], &mut exprBuf[..]);
    if r7 != 0 {
    if r7 <> 0 {
        return 70 + r7;
    }

    let r8 = testTokenCount(&mut tokenBuf[..], &mut exprBuf[..]);
    if r8 != 0 {
    if r8 <> 0 {
        return 80 + r8;
    }

    let r9 = testDivision(&mut tokenBuf[..], &mut exprBuf[..]);
    if r9 != 0 {
    if r9 <> 0 {
        return 90 + r9;
    }

    let r10 = testDeepNesting(&mut tokenBuf[..], &mut exprBuf[..]);
    if r10 != 0 {
    if r10 <> 0 {
        return 100 + r10;
    }

    let r11 = testNodeCount(&mut tokenBuf[..], &mut exprBuf[..]);
    if r11 != 0 {
    if r11 <> 0 {
        return 110 + r11;
    }

    return 0;
}

test/tests/prog.vm.rad +13 -13

    let mut stackBuf: [i32; 64] = [0; 64];
    let mut localsBuf: [i32; 128] = [0; 128];
    let mut framesBuf: [Frame; 8] = [Frame { returnAddr: 0, localBase: 0 }; 8];

    let r1 = testArith(&mut stackBuf[..], &mut localsBuf[..], &mut framesBuf[..]);
    if r1 != 0 {
    if r1 <> 0 {
        return 10 + r1;
    }

    let r2 = testLocals(&mut stackBuf[..], &mut localsBuf[..], &mut framesBuf[..]);
    if r2 != 0 {
    if r2 <> 0 {
        return 20 + r2;
    }

    let r3 = testConditional(&mut stackBuf[..], &mut localsBuf[..], &mut framesBuf[..]);
    if r3 != 0 {
    if r3 <> 0 {
        return 30 + r3;
    }

    let r4 = testLoop(&mut stackBuf[..], &mut localsBuf[..], &mut framesBuf[..]);
    if r4 != 0 {
    if r4 <> 0 {
        return 40 + r4;
    }

    let r5 = testCall(&mut stackBuf[..], &mut localsBuf[..], &mut framesBuf[..]);
    if r5 != 0 {
    if r5 <> 0 {
        return 50 + r5;
    }

    let r6 = testDivByZero(&mut stackBuf[..], &mut localsBuf[..], &mut framesBuf[..]);
    if r6 != 0 {
    if r6 <> 0 {
        return 60 + r6;
    }

    let r7 = testNegAndEq(&mut stackBuf[..], &mut localsBuf[..], &mut framesBuf[..]);
    if r7 != 0 {
    if r7 <> 0 {
        return 70 + r7;
    }

    let r8 = testFactorial(&mut stackBuf[..], &mut localsBuf[..], &mut framesBuf[..]);
    if r8 != 0 {
    if r8 <> 0 {
        return 80 + r8;
    }

    let r9 = testDup(&mut stackBuf[..], &mut localsBuf[..], &mut framesBuf[..]);
    if r9 != 0 {
    if r9 <> 0 {
        return 90 + r9;
    }

    let r10 = testStackUnderflow(&mut stackBuf[..], &mut localsBuf[..], &mut framesBuf[..]);
    if r10 != 0 {
    if r10 <> 0 {
        return 100 + r10;
    }

    let r11 = testSuccessNoCatch(&mut stackBuf[..], &mut localsBuf[..], &mut framesBuf[..]);
    if r11 != 0 {
    if r11 <> 0 {
        return 110 + r11;
    }

    let r12 = testCallOverflow(&mut stackBuf[..], &mut localsBuf[..], &mut framesBuf[..]);
    if r12 != 0 {
    if r12 <> 0 {
        return 120 + r12;
    }

    let r13 = testCatchNoBinding(&mut stackBuf[..], &mut localsBuf[..], &mut framesBuf[..]);
    if r13 != 0 {
    if r13 <> 0 {
        return 130 + r13;
    }

    return 0;
}

test/tests/range.arithmetic.rad +10 -10

4	4		let arr: [i32; 6] = [10, 20, 30, 40, 50, 60];
5	5		let len: u32 = 6;
6	6
7	7		// Arithmetic in range start (no parens needed).
8	8		let s = &arr[len - 3..len];
9		-	if s.len != 3 { return 1; }
10		-	if s[0] != 40 { return 2; }
11		-	if s[2] != 60 { return 3; }
	9	+	if s.len <> 3 { return 1; }
	10	+	if s[0] <> 40 { return 2; }
	11	+	if s[2] <> 60 { return 3; }
12	12
13	13		// Arithmetic in range end.
14	14		let s2 = &arr[0..len - 2];
15		-	if s2.len != 4 { return 4; }
16		-	if s2[3] != 40 { return 5; }
	15	+	if s2.len <> 4 { return 4; }
	16	+	if s2[3] <> 40 { return 5; }
17	17
18	18		// Arithmetic in both.
19	19		let s3 = &arr[len - 4..len - 1];
20		-	if s3.len != 3 { return 6; }
21		-	if s3[0] != 30 { return 7; }
22		-	if s3[2] != 50 { return 8; }
	20	+	if s3.len <> 3 { return 6; }
	21	+	if s3[0] <> 30 { return 7; }
	22	+	if s3[2] <> 50 { return 8; }
23	23
24	24		// Arithmetic in subscript.
25		-	if arr[len - 1] != 60 { return 9; }
26		-	if arr[len - 6] != 10 { return 10; }
	25	+	if arr[len - 1] <> 60 { return 9; }
	26	+	if arr[len - 6] <> 10 { return 10; }
27	27
28	28		return 0;
29	29		}

test/tests/record.copy.rad +5 -5

94	94
95	95		@default fn main() -> i32 {
96	96		let s: S = S { x: 561, y: 938, z: 102 };
97	97
98	98		let r1: i32 = func1(s);
99		-	if r1 != 0 {
	99	+	if r1 <> 0 {
100	100		return 10 + r1;
101	101		}
102	102		assert s.x == 561;
103	103		assert s.y == 938;
104	104		assert s.z == 102;
105	105
106	106		let r2: i32 = func2(s);
107		-	if r2 != 0 {
	107	+	if r2 <> 0 {
108	108		return 30 + r2;
109	109		}
110	110
111	111		let r3: i32 = func3(s);
112		-	if r3 != 0 {
	112	+	if r3 <> 0 {
113	113		return 40 + r3;
114	114		}
115	115
116	116		let r4: i32 = func4(s);
117		-	if r4 != 0 {
	117	+	if r4 <> 0 {
118	118		return 50 + r4;
119	119		}
120	120
121	121		let r5: i32 = func5(s);
122		-	if r5 != 0 {
	122	+	if r5 <> 0 {
123	123		return 60 + r5;
124	124		}
125	125
126	126		return 0;
127	127		}

test/tests/record.empty.eq.rad +1 -1

fn emptyEq(a: Empty, b: Empty) -> bool {
    return a == b;
}

fn emptyNeq(a: Empty, b: Empty) -> bool {
    return a != b;
    return a <> b;
}

fn emptyAlwaysEqual() -> bool {
    let a = Empty {};
    let b = Empty {};

test/tests/record.unlabeled.deref.rad +10 -10


@default fn main() -> i32 {
    let w: Wrap = Wrap(42);

    // Basic deref.
    if *w != 42 {
    if *w <> 42 {
        return 1;
    }

    // Deref in function call.
    if getInner(w) != 42 {
    if getInner(w) <> 42 {
        return 2;
    }

    // Deref bool.
    let b: WrapBool = WrapBool(true);
    if *b != true {
    if *b <> true {
        return 3;
    }

    // Deref u8.
    let u: WrapU8 = WrapU8(7);
    if *u != 7 {
    if *u <> 7 {
        return 4;
    }

    // Deref in arithmetic.
    let a: Wrap = Wrap(10);
    let b2: Wrap = Wrap(20);
    if *a + *b2 != 30 {
    if *a + *b2 <> 30 {
        return 5;
    }

    // Deref and reconstruct.
    let w2: Wrap = passThrough(w);
    if *w2 != 42 {
    if *w2 <> 42 {
        return 6;
    }

    // Deref u64.
    let big: WrapU64 = WrapU64(1234567890);
    if *big != 1234567890 {
    if *big <> 1234567890 {
        return 7;
    }

    // Deref in comparison.
    let x: Wrap = Wrap(5);
    let y: Wrap = Wrap(5);
    if *x != *y {
    if *x <> *y {
        return 8;
    }

    // Deref in let binding.
    let val: i32 = *Wrap(99);
    if val != 99 {
    if val <> 99 {
        return 9;
    }

    // Assignment through deref on mutable binding.
    let mut m: Wrap = Wrap(0);
    *m = 77;
    if *m != 77 {
    if *m <> 77 {
        return 10;
    }

    return 0;
}

test/tests/record.unlabeled.rad +2 -2

17	17		let r1: R = R(true, 43);
18	18
19	19		let s2: S = passS(s1);
20	20		let r2: R = passR(r1);
21	21
22		-	if s2 != S(42) {
	22	+	if s2 <> S(42) {
23	23		return 0;
24	24		}
25		-	if r2 != R(true, 43) {
	25	+	if r2 <> R(true, 43) {
26	26		return 0;
27	27		}
28	28		return 1;
29	29		}

test/tests/regalloc.spill.reuse.rad +1 -1

    let saved: u32 = old + 1;

    let first: u32 = callPressure(1, 2, 3, 4, 5, 6, 7, 8);
    let second: u32 = callPressure(8, 7, 6, 5, 4, 3, 2, 1);

    assert first != 0 and second != 0;
    assert first <> 0 and second <> 0;

    return saved;
}

@default fn main() -> i32 {

test/tests/result.void.success.rad +2 -2

    try voidSuccess() catch {
        return (1) - 42;
    };

    // Guard should still be 42, not clobbered.
    if guard != 42 {
    if guard <> 42 {
        return (2) - 42;
    }

    // Try the error path too.
    try voidError() catch {
        guard = 99;
    };

    if guard != 99 {
    if guard <> 99 {
        return (3) - 42;
    }

    return (42) - 42;
}

test/tests/slice.append.rad +24 -24

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

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

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

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

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

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

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

    // Append from empty (cap == 0 triggers growth with cap = 1).
    let mut empty = @sliceOf(ptr as *mut i32, 0, 0);
    empty.append(99, a);

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

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

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

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

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

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

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

    assert vals.len == 3;
    assert vals.cap == 5;

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

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

test/tests/slice.cap.rad +10 -10

@default fn main() -> i32 {
    // Test that regular slices have cap == len.
    let mut arr: [i32; 4] = [10, 20, 30, 40];
    let s = &mut arr[..];

    if s.cap != 4 {
    if s.cap <> 4 {
        return 1;
    }
    if s.len != s.cap {
    if s.len <> s.cap {
        return 2;
    }

    // Test @sliceOf with explicit capacity.
    let ptr = &mut arr[0];
    let s2 = @sliceOf(ptr, 2, 4);

    if s2.len != 2 {
    if s2.len <> 2 {
        return 3;
    }
    if s2.cap != 4 {
    if s2.cap <> 4 {
        return 4;
    }
    if s2[0] != 10 {
    if s2[0] <> 10 {
        return 5;
    }
    if s2[1] != 20 {
    if s2[1] <> 20 {
        return 6;
    }

    // Test @sliceOf with zero length.
    let s3 = @sliceOf(ptr, 0, 4);

    if s3.len != 0 {
    if s3.len <> 0 {
        return 7;
    }
    if s3.cap != 4 {
    if s3.cap <> 4 {
        return 8;
    }

    // Test @sliceOf still works and has cap == len.
    let s4 = @sliceOf(ptr, 3);

    if s4.len != 3 {
    if s4.len <> 3 {
        return 9;
    }
    if s4.cap != 3 {
    if s4.cap <> 3 {
        return 10;
    }
    return 0;
}

test/tests/slice.delete.rad +13 -13

6	6		let mut s = &mut arr[..];
7	7
8	8		// Delete middle element (index 2: value 30).
9	9		s.delete(2);
10	10
11		-	if s.len != 4 {
	11	+	if s.len <> 4 {
12	12		return 1;
13	13		}
14		-	if s[0] != 10 {
	14	+	if s[0] <> 10 {
15	15		return 2;
16	16		}
17		-	if s[1] != 20 {
	17	+	if s[1] <> 20 {
18	18		return 3;
19	19		}
20		-	if s[2] != 40 {
	20	+	if s[2] <> 40 {
21	21		return 4;
22	22		}
23		-	if s[3] != 50 {
	23	+	if s[3] <> 50 {
24	24		return 5;
25	25		}
26	26
27	27		// Delete first element (index 0: value 10).
28	28		s.delete(0);
29	29
30		-	if s.len != 3 {
	30	+	if s.len <> 3 {
31	31		return 6;
32	32		}
33		-	if s[0] != 20 {
	33	+	if s[0] <> 20 {
34	34		return 7;
35	35		}
36		-	if s[1] != 40 {
	36	+	if s[1] <> 40 {
37	37		return 8;
38	38		}
39		-	if s[2] != 50 {
	39	+	if s[2] <> 50 {
40	40		return 9;
41	41		}
42	42
43	43		// Delete last element (index 2: value 50).
44	44		s.delete(2);
45	45
46		-	if s.len != 2 {
	46	+	if s.len <> 2 {
47	47		return 10;
48	48		}
49		-	if s[0] != 20 {
	49	+	if s[0] <> 20 {
50	50		return 11;
51	51		}
52		-	if s[1] != 40 {
	52	+	if s[1] <> 40 {
53	53		return 12;
54	54		}
55	55
56	56		// Cap should be unchanged.
57		-	if s.cap != 5 {
	57	+	if s.cap <> 5 {
58	58		return 13;
59	59		}
60	60		return 0;
61	61		}

test/tests/slice.subslice.rad +2 -2

    let arr: [i32; 3] = [7, 8, 9];
    let slice: *[i32] = &arr[..];

    // Test single element subslice
    let single: *[i32] = &slice[1..2];
    if (single[0] != 8 or single.len != 1) {
    if (single[0] <> 8 or single.len <> 1) {
        return false;
    }

    // Test empty subslice
    let empty: *[i32] = &slice[2..2];
    if (empty.len != 0) {
    if (empty.len <> 0) {
        return false;
    }
    return true;
}


test/tests/switch.blockargs.clobber.rad +2 -2

@default fn main() -> i32 {
    // Critical case: two payload values that differ.
    // With the bug, the switch clobber makes this return true.
    let a: Val = Val::data(42);
    let b: Val = Val::data(99);
    assert a != b;
    assert a <> b;

    // Same payload - should be equal.
    let c: Val = Val::data(42);
    let d: Val = Val::data(42);
    assert c == d;

    assert g == h;

    // Different variants - should not be equal.
    let i: Val = Val::none;
    let j: Val = Val::data(42);
    assert i != j;
    assert i <> j;
    return 0;
}

test/tests/union.payload.record.eq.rad +1 -1

fn maybePointEq(a: MaybePoint, b: MaybePoint) -> bool {
    return a == b;
}

fn maybePointNeq(a: MaybePoint, b: MaybePoint) -> bool {
    return a != b;
    return a <> b;
}

test/tests/unsigned.compare.rad +2 -2

        }
        if current < 0 {
            return false;
        }
        if current >= MAX_U32 {
            if current != MAX_U32 {
            if current <> MAX_U32 {
                return false;
            }
        } else {
            if current == MAX_U32 {
                return false;
            }
        }
        if current <= 0 {
            if current != 0 {
            if current <> 0 {
                return false;
            }
        } else {
            if current == 0 {
                return false;

316	316		match f3 {
317	317		case encode::F3_ADD => return Instr::Addiw { rd, rs1, imm },
318	318		case encode::F3_SLL => return Instr::Slliw { rd, rs1, shamt: imm & 0x1F },
319	319		case encode::F3_SRL => {
320	320		let shamt = imm & 0x1F;
321		-	if (imm & 0x400) != 0 {
	321	+	if (imm & 0x400) <> 0 {
322	322		return Instr::Sraiw { rd, rs1, shamt };
323	323		} else {
324	324		return Instr::Srliw { rd, rs1, shamt };
325	325		}
326	326		},

446	446		// Check if the value fits in 32 bits (sign-extended).
447	447		let lo32 = imm as i32;
448	448		if lo32 as i64 == imm {
449	449		let s = splitImm(lo32);
450	450		emit(e, encode::lui(rd, s.hi));
451		-	if s.lo != 0 {
	451	+	if s.lo <> 0 {
452	452		emit(e, encode::addiw(rd, rd, s.lo));
453	453		}
454	454		return;
455	455		}
456	456		// Full 64-bit immediate: use only rd, no scratch registers.

468	468		/// Branch if equal: `if (rs1 == rs2) pc += imm`.
469	469		export fn beq(rs1: gen::Reg, rs2: gen::Reg, imm: i32) -> u32 {
470	470		return encodeB(OP_BRANCH, rs1, rs2, F3_BEQ, imm);
471	471		}
472	472
473		-	/// Branch if not equal: `if (rs1 != rs2) pc += imm`.
	473	+	/// Branch if not equal: `if (rs1 <> rs2) pc += imm`.
474	474		export fn bne(rs1: gen::Reg, rs2: gen::Reg, imm: i32) -> u32 {
475	475		return encodeB(OP_BRANCH, rs1, rs2, F3_BNE, imm);
476	476		}
477	477
478	478		/// Branch if less than (signed): `if (rs1 < rs2) pc += imm`.

587	587		/// Implemented as `sltiu rd, rs, 1`.
588	588		export fn seqz(rd: gen::Reg, rs: gen::Reg) -> u32 {
589	589		return sltiu(rd, rs, 1);
590	590		}
591	591
592		-	/// Set if not equal to zero: `rd = (rs != 0) ? 1 : 0`.
	592	+	/// Set if not equal to zero: `rd = (rs <> 0) ? 1 : 0`.
593	593		/// Implemented as `sltu rd, zero, rs`.
594	594		export fn snez(rd: gen::Reg, rs: gen::Reg) -> u32 {
595	595		return sltu(rd, super::ZERO, rs);
596	596		}
597	597
598	598		/// Branch if equal to zero: `if (rs == 0) pc += imm`.
599	599		export fn beqz(rs: gen::Reg, imm: i32) -> u32 {
600	600		return beq(rs, super::ZERO, imm);
601	601		}
602	602
603		-	/// Branch if not equal to zero: `if (rs != 0) pc += imm`.
	603	+	/// Branch if not equal to zero: `if (rs <> 0) pc += imm`.
604	604		export fn bnez(rs: gen::Reg, imm: i32) -> u32 {
605	605		return bne(rs, super::ZERO, imm);
606	606		}
607	607
608	608		/// Call: `jal ra, imm`.

494	494
495	495		// For large blits where both pointers are in real registers,
496	496		// use an inline loop instead of unrolled LD/SD pairs.
497	497		let dwordBytes = remaining & ~(super::DWORD_SIZE - 1);
498	498		let canLoop = not bothSpilled
499		-	and rsrc != super::SCRATCH1 and rsrc != super::SCRATCH2
500		-	and rdst != super::SCRATCH1 and rdst != super::SCRATCH2;
	499	+	and rsrc <> super::SCRATCH1 and rsrc <> super::SCRATCH2
	500	+	and rdst <> super::SCRATCH1 and rdst <> super::SCRATCH2;
501	501
502	502		if canLoop and dwordBytes >= super::BLIT_LOOP_THRESHOLD {
503	503		emit::emitAddImm(s.e, super::SCRATCH1, rsrc, dwordBytes);
504	504
505	505		let loopStart = s.e.codeLen;
506	506
507	507		emit::emitLd(s.e, super::SCRATCH2, rsrc, 0);
508	508		emit::emitSd(s.e, super::SCRATCH2, rdst, 0);
509	509		emit::emit(s.e, encode::addi(rsrc, rsrc, super::DWORD_SIZE));
510	510
511		-	if rdst != rsrc {
	511	+	if rdst <> rsrc {
512	512		emit::emit(s.e, encode::addi(rdst, rdst, super::DWORD_SIZE));
513	513		}
514	514		let brOff = (loopStart as i32 - s.e.codeLen as i32) * super::INSTR_SIZE;
515	515
516	516		emit::emit(s.e, encode::bne(rsrc, super::SCRATCH1, brOff));

402	402		let options = lower::LowerOptions { debug: ctx.debug, buildTest: ctx.config.buildTest };
403	403		let mut low = lower::lowerer(res, &ctx.graph, entryPkg.name, &mut res.arena, options);
404	404
405	405		// Lower all packages except entry.
406	406		for i in 0..ctx.packageCount {
407		-	if i != entryIdx {
	407	+	if i <> entryIdx {
408	408		try lowerPackage(ctx, res, &mut low, &mut ctx.packages[i], false);
409	409		}
410	410		}
411	411		// Lower entry package.
412	412		let defaultFn = try lowerPackage(ctx, res, &mut low, &mut ctx.packages[entryIdx], true);

44	44		//////////////////////////
45	45
46	46		/// Extract I-type immediate (sign-extended).
47	47		export fn immI(instr: u32) -> i32 {
48	48		let imm = instr >> 20;
49		-	if (imm & 0x800) != 0 {
	49	+	if (imm & 0x800) <> 0 {
50	50		return (imm \| 0xFFFFF000) as i32;
51	51		}
52	52		return imm as i32;
53	53		}
54	54
55	55		/// Extract S-type immediate (sign-extended).
56	56		export fn immS(instr: u32) -> i32 {
57	57		let lo = (instr >> 7) & 0x1F;
58	58		let hi = (instr >> 25) & 0x7F;
59	59		let imm = (hi << 5) \| lo;
60		-	if (imm & 0x800) != 0 {
	60	+	if (imm & 0x800) <> 0 {
61	61		return (imm \| 0xFFFFF000) as i32;
62	62		}
63	63		return imm as i32;
64	64		}
65	65

68	68		let imm11 = (instr >> 7) & 0x1;
69	69		let imm4_1 = (instr >> 8) & 0xF;
70	70		let imm10_5 = (instr >> 25) & 0x3F;
71	71		let imm12 = (instr >> 31) & 0x1;
72	72		let imm = (imm12 << 12) \| (imm11 << 11) \| (imm10_5 << 5) \| (imm4_1 << 1);
73		-	if (imm & 0x1000) != 0 {
	73	+	if (imm & 0x1000) <> 0 {
74	74		return (imm \| 0xFFFFE000) as i32;
75	75		}
76	76		return imm as i32;
77	77		}
78	78

81	81		let imm19_12 = (instr >> 12) & 0xFF;
82	82		let imm11 = (instr >> 20) & 0x1;
83	83		let imm10_1 = (instr >> 21) & 0x3FF;
84	84		let imm20 = (instr >> 31) & 0x1;
85	85		let imm = (imm20 << 20) \| (imm19_12 << 12) \| (imm11 << 11) \| (imm10_1 << 1);
86		-	if (imm & 0x100000) != 0 {
	86	+	if (imm & 0x100000) <> 0 {
87	87		return (imm \| 0xFFE00000) as i32;
88	88		}
89	89		return imm as i32;
90	90		}
91	91
92	92		/// Extract U-type immediate (upper 20 bits, sign-extended).
93	93		export fn immU(instr: u32) -> i32 {
94	94		let imm = instr >> 12;
95		-	if (imm & 0x80000) != 0 {
	95	+	if (imm & 0x80000) <> 0 {
96	96		return (imm \| 0xFFF00000) as i32;
97	97		}
98	98		return imm as i32;
99	99		}
100	100

261	261		case encode::F3_OR => return Instr::Ori { rd, rs1, imm },
262	262		case encode::F3_AND => return Instr::Andi { rd, rs1, imm },
263	263		case encode::F3_SLL => return Instr::Slli { rd, rs1, shamt: imm & 0x3F },
264	264		case encode::F3_SRL => {
265	265		let shamt = imm & 0x3F;
266		-	if (imm & 0x400) != 0 {
	266	+	if (imm & 0x400) <> 0 {
267	267		return Instr::Srai { rd, rs1, shamt };
268	268		} else {
269	269		return Instr::Srli { rd, rs1, shamt };
270	270		}
271	271		},

157	157
158	158		// Build list of callee-saved registers with offsets.
159	159		let mut offset = totalSize - (super::DWORD_SIZE * 3);
160	160		for reg, i in super::CALLEE_SAVED {
161	161		// Check if this register is in use.
162		-	if (usedCalleeSaved & (1 << i)) != 0 {
	162	+	if (usedCalleeSaved & (1 << i)) <> 0 {
163	163		frame.savedRegs[frame.savedRegsLen] = SavedReg {
164	164		reg,
165	165		offset,
166	166		};
167	167		frame.savedRegsLen += 1;

405	405		export fn splitImm(imm: i32) -> SplitImm {
406	406		let lo = imm & 0xFFF;
407	407		let mut hi = (imm >> 12) & 0xFFFFF;
408	408		// If `lo`'s sign bit is set, it will be sign-extended to negative.
409	409		// Compensate by incrementing `hi`.
410		-	if (lo & 0x800) != 0 {
	410	+	if (lo & 0x800) <> 0 {
411	411		hi += 1;
412	412		return SplitImm { hi, lo: lo \| 0xFFFFF000 as i32 };
413	413		}
414	414		return SplitImm { hi, lo };
415	415		}

211	211		return rd;
212	212		}
213	213
214	214		/// Emit a move instruction if source and destination differ.
215	215		fn emitMv(s: *mut Selector, rd: gen::Reg, rs: gen::Reg) {
216		-	if rd != rs {
	216	+	if rd <> rs {
217	217		emit::emit(s.e, encode::mv(rd, rs));
218	218		}
219	219		}
220	220
221	221		/// Emit zero-extension from a sub-word type to the full register width.

255	255		/// Resolve a value, trap if zero (unless known non-zero), and return the register.
256	256		fn resolveAndTrapIfZero(s: *mut Selector, b: il::Val) -> gen::Reg {
257	257		let rs2 = resolveVal(s, super::SCRATCH2, b);
258	258		let mut knownNonZero = false;
259	259		if let case il::Val::Imm(imm) = b {
260		-	knownNonZero = imm != 0;
	260	+	knownNonZero = imm <> 0;
261	261		}
262	262		if not knownNonZero {
263	263		emit::emit(s.e, encode::bne(rs2, super::ZERO, super::INSTR_SIZE * 2));
264	264		emit::emit(s.e, encode::ebreak());
265	265		}

523	523		// it does, advance the base registers by the accumulated
524	524		// offset and reset to zero.
525	525		while remaining >= super::DWORD_SIZE {
526	526		if offset > super::MAX_IMM - super::DWORD_SIZE {
527	527		emit::emitAddImm(s.e, rsrc, rsrc, offset);
528		-	if rdst != rsrc {
	528	+	if rdst <> rsrc {
529	529		emit::emitAddImm(s.e, rdst, rdst, offset);
530	530		}
531	531		offset = 0;
532	532		}
533	533		if let off = srcReload {

559	559		remaining -= super::WORD_SIZE;
560	560		}
561	561		while remaining > 0 {
562	562		if offset > super::MAX_IMM - 1 {
563	563		emit::emitAddImm(s.e, rsrc, rsrc, offset);
564		-	if rdst != rsrc {
	564	+	if rdst <> rsrc {
565	565		emit::emitAddImm(s.e, rdst, rdst, offset);
566	566		}
567	567		offset = 0;
568	568		}
569	569		if let off = srcReload {

541	541		remaining -= super::DWORD_SIZE;
542	542		}
543	543		if remaining >= super::WORD_SIZE {
544	544		if offset > super::MAX_IMM - super::WORD_SIZE {
545	545		emit::emitAddImm(s.e, rsrc, rsrc, offset);
546		-	if rdst != rsrc {
	546	+	if rdst <> rsrc {
547	547		emit::emitAddImm(s.e, rdst, rdst, offset);
548	548		}
549	549		offset = 0;
550	550		}
551	551		if let off = srcReload {

578	578		}
579	579		// Restore base registers if they were advanced (never happens
580	580		// in the both-spilled case since size <= MAX_IMM).
581	581		if not bothSpilled {
582	582		let advanced = staticSize as i32 - offset;
583		-	if advanced != 0 {
	583	+	if advanced <> 0 {
584	584		emit::emitAddImm(s.e, rsrc, rsrc, 0 - advanced);
585		-	if rdst != rsrc {
	585	+	if rdst <> rsrc {
586	586		emit::emitAddImm(s.e, rdst, rdst, 0 - advanced);
587	587		}
588	588		}
589	589		}
590	590		},

603	603		let rs = resolveVal(s, super::SCRATCH1, v);
604	604		emitMv(s, super::A0, rs);
605	605		}
606	606		// Skip the jump to epilogue if this RET is in the last block,
607	607		// since the epilogue immediately follows.
608		-	if frame.totalSize != 0 and blockIdx + 1 == frame.epilogueBlock {
	608	+	if frame.totalSize <> 0 and blockIdx + 1 == frame.epilogueBlock {
609	609		// Epilogue is the next block; fallthrough is sufficient.
610	610		} else {
611	611		emit::emitReturn(s.e, frame);
612	612		}
613	613		},
614	614		case il::Instr::Jmp { target, args } => {
615	615		// Move arguments to target block's parameter registers.
616	616		emitBlockArgs(s, func, target, args);
617	617		// Skip branch if target is the next block (fallthrough).
618		-	if target != blockIdx + 1 {
	618	+	if target <> blockIdx + 1 {
619	619		emit::recordBranch(s.e, target, emit::BranchKind::Jump);
620	620		}
621	621		},
622	622		case il::Instr::Br { op, typ, a, b, thenTarget, thenArgs, elseTarget, elseArgs } => {
623	623		// Use zero register directly for immediate `0` operands.

672	672		panic "selectInstr: both `then` and `else` have block arguments";
673	673		} else if thenArgs.len > 0 {
674	674		emit::recordBranch(s.e, elseTarget, emit::BranchKind::InvertedCond { op, rs1, rs2 });
675	675		emitBlockArgs(s, func, thenTarget, thenArgs);
676	676		// Skip trailing jump if then is the next block (fallthrough).
677		-	if thenTarget != blockIdx + 1 {
	677	+	if thenTarget <> blockIdx + 1 {
678	678		emit::recordBranch(s.e, thenTarget, emit::BranchKind::Jump);
679	679		}
680	680		} else if thenTarget == blockIdx + 1 and elseArgs.len == 0 {
681	681		// Then is the next block and no else args: invert the
682	682		// condition to branch to else and fall through to then.
683	683		emit::recordBranch(s.e, elseTarget, emit::BranchKind::InvertedCond { op, rs1, rs2 });
684	684		} else {
685	685		emit::recordBranch(s.e, thenTarget, emit::BranchKind::Cond { op, rs1, rs2 });
686	686		emitBlockArgs(s, func, elseTarget, elseArgs);
687	687		// Skip trailing jump if else is the next block (fallthrough).
688		-	if elseTarget != blockIdx + 1 {
	688	+	if elseTarget <> blockIdx + 1 {
689	689		emit::recordBranch(s.e, elseTarget, emit::BranchKind::Jump);
690	690		}
691	691		}
692	692		},
693	693		case il::Instr::Switch { val, defaultTarget, defaultArgs, cases } => {

1057	1057		// Number of pending moves.
1058	1058		let mut numPending: u32 = 0;
1059	1059
1060	1060		for i in 0..n {
1061	1061		let dst = dsts[i];
1062		-	if dst != super::ZERO { // Skip entries with no destination.
	1062	+	if dst <> super::ZERO { // Skip entries with no destination.
1063	1063		match args[i] {
1064	1064		case il::Val::Reg(r) => {
1065	1065		if let _ = regalloc::spill::spillSlot(&s.ralloc.spill, r) {
1066	1066		// Spilled value needs load, not a register move.
1067	1067		pending[i] = true;
1068	1068		numPending += 1;
1069	1069		} else {
1070	1070		let src = getReg(s, r);
1071		-	if src != dst {
	1071	+	if src <> dst {
1072	1072		// Register-to-register move needed.
1073	1073		srcRegs[i] = src;
1074	1074		isRegMove[i] = true;
1075	1075		pending[i] = true;
1076	1076		numPending += 1;

1103	1103		let dst = dsts[i];
1104	1104		let mut isReady = true;
1105	1105
1106	1106		// Check if `dst` is used as source by any other pending register move.
1107	1107		for j in 0..n {
1108		-	if j != i and pending[j] and isRegMove[j] and srcRegs[j] == dst {
	1108	+	if j <> i and pending[j] and isRegMove[j] and srcRegs[j] == dst {
1109	1109		isReady = false;
1110	1110		break;
1111	1111		}
1112	1112		}
1113	1113		if isReady {

116	116
117	117		let p2 = a.func(a.ctx, 8, 8);
118	118		try testing::expect(super::used(&arena) == 24);
119	119
120	120		// Verify the pointers are distinct.
121		-	try testing::expect(p1 as u64 != p2 as u64);
	121	+	try testing::expect(p1 as u64 <> p2 as u64);
122	122		}

64	64		return false;
65	65		}
66	66
67	67		/// Check if an attribute set includes the given attribute.
68	68		export fn hasAttribute(attrs: u32, attr: Attribute) -> bool {
69		-	return (attrs & (attr as u32)) != 0;
	69	+	return (attrs & (attr as u32)) <> 0;
70	70		}
71	71
72	72		/// Signedness of an integer type.
73	73		export union Signedness {
74	74		/// Signed, eg. `i8`.

124	124		/// Right shift (`>>`).
125	125		Shr,
126	126
127	127		/// Equality comparison (`==`).
128	128		Eq,
129		-	/// Inequality comparison (`!=`).
	129	+	/// Inequality comparison (`<>`).
130	130		Ne,
131	131		/// Less-than comparison (`<`).
132	132		Lt,
133	133		/// Greater-than comparison (`>`).
134	134		Gt,

16	16		case super::BinaryOp::BitOr => return "\|",
17	17		case super::BinaryOp::BitXor => return "^",
18	18		case super::BinaryOp::Shl => return "<<",
19	19		case super::BinaryOp::Shr => return ">>",
20	20		case super::BinaryOp::Eq => return "==",
21		-	case super::BinaryOp::Ne => return "!=",
	21	+	case super::BinaryOp::Ne => return "<>",
22	22		case super::BinaryOp::Lt => return "<",
23	23		case super::BinaryOp::Gt => return ">",
24	24		case super::BinaryOp::Lte => return "<=",
25	25		case super::BinaryOp::Gte => return ">=",
26	26		case super::BinaryOp::And => return "and",

84	84		return false;
85	85		}
86	86		let word = n / 32;
87	87		let b = n % 32;
88	88
89		-	return (bs.bits[word] & (1 << b)) != 0;
	89	+	return (bs.bits[word] & (1 << b)) <> 0;
90	90		}
91	91
92	92		/// Count the number of set bits.
93	93		export fn count(bs: *Bitset) -> u32 {
94	94		let mut total: u32 = 0;
95	95		let numWords = bs.bits.len;
96	96		for i in 0..numWords {
97	97		let word = bs.bits[i];
98		-	if word != 0 {
	98	+	if word <> 0 {
99	99		total += popCount(word);
100	100		}
101	101		}
102	102		return total;
103	103		}

141	141		let maxWords = max(numWordsA, numWordsB);
142	142
143	143		for i in 0..maxWords {
144	144		let wordA = a.bits[i] if i < numWordsA else 0;
145	145		let wordB = b.bits[i] if i < numWordsB else 0;
146		-	if wordA != wordB {
	146	+	if wordA <> wordB {
147	147		return false;
148	148		}
149	149		}
150	150		return true;
151	151		}

9	9		//! REPEAT UNTIL changed == false
10	10		//! changed = false
11	11		//! FOR EACH BLOCK b IN POST-ORDER DO
12	12		//! newOut = UNION(liveIn[succ] FOR EACH SUCCESSOR OF b)
13	13		//! newIn = uses[b] \| (newOut - defs[b])
14		-	//! IF newIn != liveIn[b] OR newOut != liveOut[b] THEN
	14	+	//! IF newIn <> liveIn[b] OR newOut <> liveOut[b] THEN
15	15		//! changed = true
16	16		//! liveIn[b] = newIn
17	17		//! liveOut[b] = newOut
18	18		//!
19	19		//! Usage:

147	147		) -> bool {
148	148		let numWords = dst.bits.len;
149	149		let mut changed = false;
150	150		for i in 0..numWords {
151	151		let newWord = uses.bits[i] \| (liveOut.bits[i] & ~defs.bits[i]);
152		-	if dst.bits[i] != newWord {
	152	+	if dst.bits[i] <> newWord {
153	153		dst.bits[i] = newWord;
154	154		changed = true;
155	155		}
156	156		}
157	157		return changed;

350	350
351	351		/// Append a data value to the builder.
352	352		fn dataBuilderPush(b: *mut DataValueBuilder, value: il::DataValue) {
353	353		b.values.append(value, b.allocator);
354	354
355		-	if value.item != il::DataItem::Undef {
	355	+	if value.item <> il::DataItem::Undef {
356	356		b.allUndef = false;
357	357		}
358	358		}
359	359
360	360		/// Return the accumulated values.

1662	1662		}
1663	1663		}
1664	1664
1665	1665		/// Compare two data value slices for structural equality.
1666	1666		fn dataValuesEq(a: [il::DataValue], b: [il::DataValue]) -> bool {
1667		-	if a.len != b.len {
	1667	+	if a.len <> b.len {
1668	1668		return false;
1669	1669		}
1670	1670		for i in 0..a.len {
1671		-	if a[i].count != b[i].count {
	1671	+	if a[i].count <> b[i].count {
1672	1672		return false;
1673	1673		}
1674	1674		if not dataItemEq(a[i].item, b[i].item) {
1675	1675		return false;
1676	1676		}

1969	1969		switchToBlock(self, target);
1970	1970		}
1971	1971
1972	1972		/// Emit a conditional branch based on `cond`.
1973	1973		fn emitBr(self: *mut FnLowerer, cond: il::Reg, thenBlock: BlockId, elseBlock: BlockId) throws (LowerError) {
1974		-	assert thenBlock != elseBlock;
	1974	+	assert thenBlock <> elseBlock;
1975	1975		emit(self, il::Instr::Br {
1976	1976		op: il::CmpOp::Ne,
1977	1977		typ: il::Type::W32,
1978	1978		a: il::Val::Reg(cond),
1979	1979		b: il::Val::Imm(0),

1994	1994		a: il::Val,
1995	1995		b: il::Val,
1996	1996		thenBlock: BlockId,
1997	1997		elseBlock: BlockId
1998	1998		) throws (LowerError) {
1999		-	assert thenBlock != elseBlock;
	1999	+	assert thenBlock <> elseBlock;
2000	2000		emit(self, il::Instr::Br {
2001	2001		op, typ, a, b,
2002	2002		thenTarget: *thenBlock, thenArgs: &mut [],
2003	2003		elseTarget: *elseBlock, elseArgs: &mut [],
2004	2004		});

2370	2370
2371	2371		/// Add a predecessor edge from `pred` to `target`.
2372	2372		/// Must be called before the target block is sealed. Duplicates are ignored.
2373	2373		fn addPredecessor(self: *mut FnLowerer, target: BlockId, pred: BlockId) {
2374	2374		let blk = getBlockMut(self, target);
2375		-	assert blk.sealState != Sealed::Yes, "addPredecessor: adding predecessor to sealed block";
	2375	+	assert blk.sealState <> Sealed::Yes, "addPredecessor: adding predecessor to sealed block";
2376	2376		let preds = &mut blk.preds;
2377	2377		for i in 0..preds.len {
2378	2378		if preds[i] == *pred { // Avoid duplicate predecessor entries.
2379	2379		return;
2380	2380		}

2418	2418		self.loopDepth += 1;
2419	2419		}
2420	2420
2421	2421		/// Exit the current loop context.
2422	2422		fn exitLoop(self: *mut FnLowerer) {
2423		-	assert self.loopDepth != 0, "exitLoop: loopDepth is zero";
	2423	+	assert self.loopDepth <> 0, "exitLoop: loopDepth is zero";
2424	2424		self.loopDepth -= 1;
2425	2425		}
2426	2426
2427	2427		/// Get the current loop context.
2428	2428		fn currentLoop(self: mut FnLowerer) -> ?mut LoopCtx {