bump ps;
expect ps SEMI;
[| span ps apos (lexpos ps) Ast.STMT_cont |]
+ | ASSERT ->
+ bump ps;
+ let (stmts, expr) =
+ ctxt "stmts: check value" parse_expr ps
+ in
+ expect ps SEMI;
+ spans ps stmts apos (Ast.STMT_check_expr expr)
+(* leaving check as it is; adding assert as a synonym for the "old" check *)
| CHECK ->
bump ps;
begin
("type", TYPE);
("check", CHECK);
+ ("assert", ASSERT);
("claim", CLAIM);
("prove", PROVE);
(* Type and type-state keywords *)
| TYPE
| CHECK
+ | ASSERT
| CLAIM
| PROVE
(* Type and type-state keywords *)
| TYPE -> "type"
| CHECK -> "check"
+ | ASSERT -> "assert"
| CLAIM -> "claim"
| PROVE -> "prove"
expr_put(option.t[@expr], ann);
expr_be(@expr, ann);
expr_log(int, @expr, ann);
- expr_check_expr(@expr, ann);
+/* just an assert, no significance to typestate */
+ expr_assert(@expr, ann);
+/* preds that typestate is aware of */
+ expr_check(@expr, ann);
expr_port(ann);
expr_chan(@expr, ann);
}
case ('c') { ret ty.mk_char(st.tcx); }
case ('s') { ret ty.mk_str(st.tcx); }
case ('t') {
- check(next(st) as char == '[');
+ assert (next(st) as char == '[');
auto def = parse_def(st, sd);
let vec[ty.t] params = vec();
while (peek(st) as char != ']') {
case ('P') { ret ty.mk_port(st.tcx, parse_ty(st, sd)); }
case ('C') { ret ty.mk_chan(st.tcx, parse_ty(st, sd)); }
case ('T') {
- check(next(st) as char == '[');
+ assert (next(st) as char == '[');
let vec[ty.mt] params = vec();
while (peek(st) as char != ']') {
params += vec(parse_mt(st, sd));
ret ty.mk_tup(st.tcx, params);
}
case ('R') {
- check(next(st) as char == '[');
+ assert (next(st) as char == '[');
let vec[ty.field] fields = vec();
while (peek(st) as char != ']') {
auto name = "";
ret ty.mk_native_fn(st.tcx,abi,func._0,func._1);
}
case ('O') {
- check(next(st) as char == '[');
+ assert (next(st) as char == '[');
let vec[ty.method] methods = vec();
while (peek(st) as char != ']') {
auto proto;
case ('Y') { ret ty.mk_type(st.tcx); }
case ('#') {
auto pos = parse_hex(st);
- check (next(st) as char == ':');
+ assert (next(st) as char == ':');
auto len = parse_hex(st);
- check (next(st) as char == '#');
+ assert (next(st) as char == '#');
alt (st.tcx.rcache.find(tup(st.crate,pos,len))) {
case (some[ty.t](?tt)) { ret tt; }
case (none[ty.t]) {
}
fn parse_ty_fn(@pstate st, str_def sd) -> tup(vec[ty.arg], ty.t) {
- check(next(st) as char == '[');
+ assert (next(st) as char == '[');
let vec[ty.arg] inputs = vec();
while (peek(st) as char != ']') {
auto mode = ast.val;
keywords.insert("type", token.TYPE);
keywords.insert("check", token.CHECK);
+ keywords.insert("assert", token.ASSERT);
keywords.insert("claim", token.CLAIM);
keywords.insert("prove", token.PROVE);
auto n_hex_digits = 0;
- check (rdr.curr() == '\\');
+ assert (rdr.curr() == '\\');
alt (rdr.next()) {
case ('x') { n_hex_digits = 2; }
if (p.peek() == token.DOT) {
if (g == GREEDY) {
p.bump();
- check (is_ident(p.peek()));
+ assert (is_ident(p.peek()));
} else {
more = false;
}
ex = ast.expr_log(0, e, ast.ann_none);
}
- case (token.CHECK) {
+ case (token.ASSERT) {
p.bump();
- alt (p.peek()) {
- case (token.LPAREN) {
- auto e = parse_expr(p);
- auto hi = e.span.hi;
- ex = ast.expr_check_expr(e, ast.ann_none);
- }
- case (_) {
- p.get_session().unimpl("constraint-check stmt");
- }
- }
+ auto e = parse_expr(p);
+ auto hi = e.span.hi;
+ ex = ast.expr_assert(e, ast.ann_none);
}
+ case (token.CHECK) {
+ p.bump();
+ /* Should be a predicate (pure boolean function) applied to
+ arguments that are all either slot variables or literals.
+ but the typechecker enforces that. */
+ auto e = parse_expr(p);
+ auto hi = e.span.hi;
+ ex = ast.expr_check(e, ast.ann_none);
+ }
+
case (token.RET) {
p.bump();
alt (p.peek()) {
&ast.path path, vec[@ast.expr] args,
option.t[str] body) -> ast.expr_ {
- check (_vec.len[ast.ident](path.node.idents) > 0u);
+ assert (_vec.len[ast.ident](path.node.idents) > 0u);
auto extname = path.node.idents.(0);
if (_str.eq(extname, "fmt")) {
auto expanded = extfmt.expand_syntax_ext(args, body);
case (ast.expr_put(_,_)) { ret true; }
case (ast.expr_be(_,_)) { ret true; }
case (ast.expr_log(_,_,_)) { ret true; }
- case (ast.expr_check_expr(_,_)) { ret true; }
+ case (ast.expr_check(_,_)) { ret true; }
+ case (ast.expr_assert(_,_)) { ret true; }
}
}
// We should not be calling this on a cdir.
alt (p.peek()) {
case (token.CONST) {
- check (lyr == ast.layer_value);
+ assert (lyr == ast.layer_value);
ret parse_item_const(p);
}
case (token.FN) {
- check (lyr == ast.layer_value);
+ assert (lyr == ast.layer_value);
ret parse_item_fn_or_iter(p);
}
case (token.ITER) {
- check (lyr == ast.layer_value);
+ assert (lyr == ast.layer_value);
ret parse_item_fn_or_iter(p);
}
case (token.MOD) {
- check (lyr == ast.layer_value);
+ assert (lyr == ast.layer_value);
ret parse_item_mod(p);
}
case (token.NATIVE) {
- check (lyr == ast.layer_value);
+ assert (lyr == ast.layer_value);
ret parse_item_native_mod(p);
}
case (token.TYPE) {
/* Type and type-state keywords */
TYPE;
+ ASSERT;
CHECK;
CLAIM;
PROVE;
/* Type and type-state keywords */
case (TYPE) { ret "type"; }
+ case (ASSERT) { ret "assert"; }
case (CHECK) { ret "check"; }
case (CLAIM) { ret "claim"; }
case (PROVE) { ret "prove"; }
/* Terminators */
fn RetVoid() -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
*terminated = true;
ret llvm.LLVMBuildRetVoid(B);
}
fn Ret(ValueRef V) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
*terminated = true;
ret llvm.LLVMBuildRet(B, V);
}
fn AggregateRet(vec[ValueRef] RetVals) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
*terminated = true;
ret llvm.LLVMBuildAggregateRet(B,
_vec.buf[ValueRef](RetVals),
}
fn Br(BasicBlockRef Dest) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
*terminated = true;
ret llvm.LLVMBuildBr(B, Dest);
}
fn CondBr(ValueRef If, BasicBlockRef Then,
BasicBlockRef Else) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
*terminated = true;
ret llvm.LLVMBuildCondBr(B, If, Then, Else);
}
fn Switch(ValueRef V, BasicBlockRef Else, uint NumCases) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
*terminated = true;
ret llvm.LLVMBuildSwitch(B, V, Else, NumCases);
}
fn IndirectBr(ValueRef Addr, uint NumDests) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
*terminated = true;
ret llvm.LLVMBuildIndirectBr(B, Addr, NumDests);
}
vec[ValueRef] Args,
BasicBlockRef Then,
BasicBlockRef Catch) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
*terminated = true;
ret llvm.LLVMBuildInvoke(B, Fn,
_vec.buf[ValueRef](Args),
}
fn Unwind() -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
*terminated = true;
ret llvm.LLVMBuildUnwind(B);
}
fn Unreachable() -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
*terminated = true;
ret llvm.LLVMBuildUnreachable(B);
}
/* Arithmetic */
fn Add(ValueRef LHS, ValueRef RHS) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildAdd(B, LHS, RHS, _str.buf(""));
}
fn NSWAdd(ValueRef LHS, ValueRef RHS) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildNSWAdd(B, LHS, RHS, _str.buf(""));
}
fn NUWAdd(ValueRef LHS, ValueRef RHS) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildNUWAdd(B, LHS, RHS, _str.buf(""));
}
fn FAdd(ValueRef LHS, ValueRef RHS) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildFAdd(B, LHS, RHS, _str.buf(""));
}
fn Sub(ValueRef LHS, ValueRef RHS) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildSub(B, LHS, RHS, _str.buf(""));
}
fn NSWSub(ValueRef LHS, ValueRef RHS) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildNSWSub(B, LHS, RHS, _str.buf(""));
}
fn NUWSub(ValueRef LHS, ValueRef RHS) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildNUWSub(B, LHS, RHS, _str.buf(""));
}
fn FSub(ValueRef LHS, ValueRef RHS) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildFSub(B, LHS, RHS, _str.buf(""));
}
fn Mul(ValueRef LHS, ValueRef RHS) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildMul(B, LHS, RHS, _str.buf(""));
}
fn NSWMul(ValueRef LHS, ValueRef RHS) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildNSWMul(B, LHS, RHS, _str.buf(""));
}
fn NUWMul(ValueRef LHS, ValueRef RHS) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildNUWMul(B, LHS, RHS, _str.buf(""));
}
fn FMul(ValueRef LHS, ValueRef RHS) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildFMul(B, LHS, RHS, _str.buf(""));
}
fn UDiv(ValueRef LHS, ValueRef RHS) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildUDiv(B, LHS, RHS, _str.buf(""));
}
fn SDiv(ValueRef LHS, ValueRef RHS) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildSDiv(B, LHS, RHS, _str.buf(""));
}
fn ExactSDiv(ValueRef LHS, ValueRef RHS) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildExactSDiv(B, LHS, RHS, _str.buf(""));
}
fn FDiv(ValueRef LHS, ValueRef RHS) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildFDiv(B, LHS, RHS, _str.buf(""));
}
fn URem(ValueRef LHS, ValueRef RHS) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildURem(B, LHS, RHS, _str.buf(""));
}
fn SRem(ValueRef LHS, ValueRef RHS) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildSRem(B, LHS, RHS, _str.buf(""));
}
fn FRem(ValueRef LHS, ValueRef RHS) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildFRem(B, LHS, RHS, _str.buf(""));
}
fn Shl(ValueRef LHS, ValueRef RHS) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildShl(B, LHS, RHS, _str.buf(""));
}
fn LShr(ValueRef LHS, ValueRef RHS) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildLShr(B, LHS, RHS, _str.buf(""));
}
fn AShr(ValueRef LHS, ValueRef RHS) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildAShr(B, LHS, RHS, _str.buf(""));
}
fn And(ValueRef LHS, ValueRef RHS) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildAnd(B, LHS, RHS, _str.buf(""));
}
fn Or(ValueRef LHS, ValueRef RHS) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildOr(B, LHS, RHS, _str.buf(""));
}
fn Xor(ValueRef LHS, ValueRef RHS) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildXor(B, LHS, RHS, _str.buf(""));
}
fn BinOp(Opcode Op, ValueRef LHS, ValueRef RHS) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildBinOp(B, Op, LHS, RHS, _str.buf(""));
}
fn Neg(ValueRef V) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildNeg(B, V, _str.buf(""));
}
fn NSWNeg(ValueRef V) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildNSWNeg(B, V, _str.buf(""));
}
fn NUWNeg(ValueRef V) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildNUWNeg(B, V, _str.buf(""));
}
fn FNeg(ValueRef V) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildFNeg(B, V, _str.buf(""));
}
fn Not(ValueRef V) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildNot(B, V, _str.buf(""));
}
/* Memory */
fn Malloc(TypeRef Ty) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildMalloc(B, Ty, _str.buf(""));
}
fn ArrayMalloc(TypeRef Ty, ValueRef Val) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildArrayMalloc(B, Ty, Val, _str.buf(""));
}
fn Alloca(TypeRef Ty) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildAlloca(B, Ty, _str.buf(""));
}
fn ArrayAlloca(TypeRef Ty, ValueRef Val) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildArrayAlloca(B, Ty, Val, _str.buf(""));
}
fn Free(ValueRef PointerVal) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildFree(B, PointerVal);
}
fn Load(ValueRef PointerVal) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildLoad(B, PointerVal, _str.buf(""));
}
fn Store(ValueRef Val, ValueRef Ptr) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildStore(B, Val, Ptr);
}
fn GEP(ValueRef Pointer, vec[ValueRef] Indices) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildGEP(B, Pointer,
_vec.buf[ValueRef](Indices),
_vec.len[ValueRef](Indices),
}
fn InBoundsGEP(ValueRef Pointer, vec[ValueRef] Indices) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildInBoundsGEP(B, Pointer,
_vec.buf[ValueRef](Indices),
_vec.len[ValueRef](Indices),
}
fn StructGEP(ValueRef Pointer, uint Idx) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildStructGEP(B, Pointer, Idx, _str.buf(""));
}
fn GlobalString(sbuf Str) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildGlobalString(B, Str, _str.buf(""));
}
fn GlobalStringPtr(sbuf Str) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildGlobalStringPtr(B, Str, _str.buf(""));
}
/* Casts */
fn Trunc(ValueRef Val, TypeRef DestTy) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildTrunc(B, Val, DestTy, _str.buf(""));
}
fn ZExt(ValueRef Val, TypeRef DestTy) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildZExt(B, Val, DestTy, _str.buf(""));
}
fn SExt(ValueRef Val, TypeRef DestTy) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildSExt(B, Val, DestTy, _str.buf(""));
}
fn FPToUI(ValueRef Val, TypeRef DestTy) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildFPToUI(B, Val, DestTy, _str.buf(""));
}
fn FPToSI(ValueRef Val, TypeRef DestTy) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildFPToSI(B, Val, DestTy, _str.buf(""));
}
fn UIToFP(ValueRef Val, TypeRef DestTy) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildUIToFP(B, Val, DestTy, _str.buf(""));
}
fn SIToFP(ValueRef Val, TypeRef DestTy) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildSIToFP(B, Val, DestTy, _str.buf(""));
}
fn FPTrunc(ValueRef Val, TypeRef DestTy) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildFPTrunc(B, Val, DestTy, _str.buf(""));
}
fn FPExt(ValueRef Val, TypeRef DestTy) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildFPExt(B, Val, DestTy, _str.buf(""));
}
fn PtrToInt(ValueRef Val, TypeRef DestTy) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildPtrToInt(B, Val, DestTy, _str.buf(""));
}
fn IntToPtr(ValueRef Val, TypeRef DestTy) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildIntToPtr(B, Val, DestTy, _str.buf(""));
}
fn BitCast(ValueRef Val, TypeRef DestTy) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildBitCast(B, Val, DestTy, _str.buf(""));
}
fn ZExtOrBitCast(ValueRef Val, TypeRef DestTy) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildZExtOrBitCast(B, Val, DestTy, _str.buf(""));
}
fn SExtOrBitCast(ValueRef Val, TypeRef DestTy) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildSExtOrBitCast(B, Val, DestTy, _str.buf(""));
}
fn TruncOrBitCast(ValueRef Val, TypeRef DestTy) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildTruncOrBitCast(B, Val, DestTy, _str.buf(""));
}
fn Cast(Opcode Op, ValueRef Val, TypeRef DestTy, sbuf Name) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildCast(B, Op, Val, DestTy, _str.buf(""));
}
fn PointerCast(ValueRef Val, TypeRef DestTy) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildPointerCast(B, Val, DestTy, _str.buf(""));
}
fn IntCast(ValueRef Val, TypeRef DestTy) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildIntCast(B, Val, DestTy, _str.buf(""));
}
fn FPCast(ValueRef Val, TypeRef DestTy) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildFPCast(B, Val, DestTy, _str.buf(""));
}
/* Comparisons */
fn ICmp(uint Op, ValueRef LHS, ValueRef RHS) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildICmp(B, Op, LHS, RHS, _str.buf(""));
}
fn FCmp(uint Op, ValueRef LHS, ValueRef RHS) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildFCmp(B, Op, LHS, RHS, _str.buf(""));
}
/* Miscellaneous instructions */
fn Phi(TypeRef Ty, vec[ValueRef] vals,
vec[BasicBlockRef] bbs) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
auto phi = llvm.LLVMBuildPhi(B, Ty, _str.buf(""));
- check (_vec.len[ValueRef](vals) == _vec.len[BasicBlockRef](bbs));
+ assert (_vec.len[ValueRef](vals) == _vec.len[BasicBlockRef](bbs));
llvm.LLVMAddIncoming(phi,
_vec.buf[ValueRef](vals),
_vec.buf[BasicBlockRef](bbs),
fn AddIncomingToPhi(ValueRef phi,
vec[ValueRef] vals,
vec[BasicBlockRef] bbs) {
- check (_vec.len[ValueRef](vals) == _vec.len[BasicBlockRef](bbs));
+ assert (_vec.len[ValueRef](vals) == _vec.len[BasicBlockRef](bbs));
llvm.LLVMAddIncoming(phi,
_vec.buf[ValueRef](vals),
_vec.buf[BasicBlockRef](bbs),
}
fn Call(ValueRef Fn, vec[ValueRef] Args) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildCall(B, Fn,
_vec.buf[ValueRef](Args),
_vec.len[ValueRef](Args),
}
fn FastCall(ValueRef Fn, vec[ValueRef] Args) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
auto v = llvm.LLVMBuildCall(B, Fn,
_vec.buf[ValueRef](Args),
_vec.len[ValueRef](Args),
}
fn Select(ValueRef If, ValueRef Then, ValueRef Else) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildSelect(B, If, Then, Else, _str.buf(""));
}
fn VAArg(ValueRef List, TypeRef Ty) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildVAArg(B, List, Ty, _str.buf(""));
}
fn ExtractElement(ValueRef VecVal, ValueRef Index) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildExtractElement(B, VecVal, Index, _str.buf(""));
}
fn InsertElement(ValueRef VecVal, ValueRef EltVal,
ValueRef Index) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildInsertElement(B, VecVal, EltVal, Index,
_str.buf(""));
}
fn ShuffleVector(ValueRef V1, ValueRef V2, ValueRef Mask) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildShuffleVector(B, V1, V2, Mask, _str.buf(""));
}
fn ExtractValue(ValueRef AggVal, uint Index) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildExtractValue(B, AggVal, Index, _str.buf(""));
}
fn InsertValue(ValueRef AggVal, ValueRef EltVal,
uint Index) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildInsertValue(B, AggVal, EltVal, Index, _str.buf(""));
}
fn IsNull(ValueRef Val) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildIsNull(B, Val, _str.buf(""));
}
fn IsNotNull(ValueRef Val) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildIsNotNull(B, Val, _str.buf(""));
}
fn PtrDiff(ValueRef LHS, ValueRef RHS) -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
ret llvm.LLVMBuildPtrDiff(B, LHS, RHS, _str.buf(""));
}
fn Trap() -> ValueRef {
- check (!*terminated);
+ assert (!*terminated);
let BasicBlockRef BB = llvm.LLVMGetInsertBlock(B);
let ValueRef FN = llvm.LLVMGetBasicBlockParent(BB);
let ModuleRef M = llvm.LLVMGetGlobalParent(FN);
let ValueRef T = llvm.LLVMGetNamedFunction(M, _str.buf("llvm.trap"));
- check (T as int != 0);
+ assert (T as int != 0);
let vec[ValueRef] Args = vec();
ret llvm.LLVMBuildCall(B, T,
_vec.buf[ValueRef](Args),
std.map.hashmap[str, TypeRef] named_types) {
fn associate(str s, TypeRef t) {
- check (!named_types.contains_key(s));
- check (!type_names.contains_key(t));
+ assert (!named_types.contains_key(s));
+ assert (!type_names.contains_key(t));
type_names.insert(t, s);
named_types.insert(s, t);
}
@expr e, ann a) -> @expr) fold_expr_log,
(fn(&ENV e, &span sp,
- @expr e, ann a) -> @expr) fold_expr_check_expr,
+ @expr e, ann a) -> @expr) fold_expr_check,
+
+ (fn(&ENV e, &span sp,
+ @expr e, ann a) -> @expr) fold_expr_assert,
(fn(&ENV e, &span sp,
ann a) -> @expr) fold_expr_port,
ret fld.fold_expr_log(env_, e.span, l, ee, t2);
}
- case (ast.expr_check_expr(?x, ?t)) {
+ case (ast.expr_check(?x, ?t)) {
auto ee = fold_expr(env_, fld, x);
auto t2 = fld.fold_ann(env_, t);
- ret fld.fold_expr_check_expr(env_, e.span, ee, t2);
+ ret fld.fold_expr_check(env_, e.span, ee, t2);
+ }
+
+ case (ast.expr_assert(?x, ?t)) {
+ auto ee = fold_expr(env_, fld, x);
+ auto t2 = fld.fold_ann(env_, t);
+ ret fld.fold_expr_assert(env_, e.span, ee, t2);
}
case (ast.expr_port(?t)) {
ret @respan(sp, ast.expr_log(lvl, x, a));
}
-fn identity_fold_expr_check_expr[ENV](&ENV e, &span sp, @expr x, ann a)
+fn identity_fold_expr_check[ENV](&ENV e, &span sp, @expr x, ann a)
+ -> @expr {
+ ret @respan(sp, ast.expr_check(x, a));
+}
+
+fn identity_fold_expr_assert[ENV](&ENV e, &span sp, @expr x, ann a)
-> @expr {
- ret @respan(sp, ast.expr_check_expr(x, a));
+ ret @respan(sp, ast.expr_check(x, a));
}
fn identity_fold_expr_port[ENV](&ENV e, &span sp, ann a) -> @expr {
fold_expr_put = bind identity_fold_expr_put[ENV](_,_,_,_),
fold_expr_be = bind identity_fold_expr_be[ENV](_,_,_,_),
fold_expr_log = bind identity_fold_expr_log[ENV](_,_,_,_,_),
- fold_expr_check_expr
- = bind identity_fold_expr_check_expr[ENV](_,_,_,_),
+ fold_expr_check
+ = bind identity_fold_expr_check[ENV](_,_,_,_),
+ fold_expr_assert
+ = bind identity_fold_expr_assert[ENV](_,_,_,_),
+
fold_expr_port = bind identity_fold_expr_port[ENV](_,_,_),
fold_expr_chan = bind identity_fold_expr_chan[ENV](_,_,_,_),
);
fn ty_str(@ctxt cx, ty.t t) -> str {
- check (! cx.use_abbrevs);
+ assert (! cx.use_abbrevs);
auto sw = io.string_writer();
enc_ty(sw.get_writer(), cx, t);
ret sw.get_str();
fn fold_expr_path(&env e, &span sp, &ast.path p, &option.t[def] d,
ann a) -> @ast.expr {
auto n_idents = _vec.len[ast.ident](p.node.idents);
- check (n_idents != 0u);
+ assert (n_idents != 0u);
auto index = new_def_hash[def_wrap]();
auto d = find_final_def(e, index, sp, p.node.idents, ns_value,
let vec[TypeRef] atys = vec();
for (ty.arg arg in inputs) {
if (ty.type_has_dynamic_size(cx.tcx, arg.ty)) {
- check (arg.mode == ast.alias);
+ assert (arg.mode == ast.alias);
atys += vec(T_typaram_ptr(cx.tn));
} else {
let TypeRef t;
// Arg 2: Env (closure-bindings / self-obj)
alt (obj_self) {
case (some[TypeRef](?t)) {
- check (t as int != 0);
+ assert (t as int != 0);
atys += vec(t);
}
case (_) {
case (ty.ty_type) { llty = T_ptr(T_tydesc(cx.tn)); }
}
- check (llty as int != 0);
+ assert (llty as int != 0);
llvm.LLVMAddTypeName(cx.llmod,
_str.buf(ty.ty_to_short_str(cx.tcx,
cx.type_abbrevs, t)),
fn GEP_tup_like(@block_ctxt cx, ty.t t,
ValueRef base, vec[int] ixs) -> result {
- check (ty.type_is_tup_like(cx.fcx.lcx.ccx.tcx, t));
+ assert (ty.type_is_tup_like(cx.fcx.lcx.ccx.tcx, t));
// It might be a static-known type. Handle this.
// and the latter would only be meaningful if we supported non-0
// values for the 0th index (we don't).
- check (len > 1u);
+ assert (len > 1u);
if (n == 0u) {
// Since we're starting from a value that's a pointer to a
// *single* structure, the first index (in GEP-ese) should just be
// 0, to yield the pointee.
- check (ixs.(n) == 0);
+ assert (ixs.(n) == 0);
ret split_type(ccx, t, ixs, n+1u);
}
- check (n < len);
+ assert (n < len);
let int ix = ixs.(n);
let vec[ty.t] prefix = vec();
let uint n_params = ty.count_ty_params(cx.fcx.lcx.ccx.tcx, t);
auto tys = linearize_ty_params(cx, t);
- check (n_params == _vec.len[uint](tys._0));
- check (n_params == _vec.len[ValueRef](tys._1));
+ assert (n_params == _vec.len[uint](tys._0));
+ assert (n_params == _vec.len[ValueRef](tys._1));
auto root = get_static_tydesc(cx, t, tys._0).tydesc;
ret creader.get_tag_variants(cx.sess, cx.tcx, id);
}
- check (cx.items.contains_key(id));
+ assert (cx.items.contains_key(id));
alt (cx.items.get(id).node) {
case (ast.item_tag(_, ?variants, _, _, _)) {
let vec[variant_info] result = vec();
// No incoming edges are live, so we're in dead-code-land.
// Arbitrarily pick the first dead edge, since the caller
// is just going to propagate it outward.
- check (_vec.len[result](ins) >= 1u);
+ assert (_vec.len[result](ins) >= 1u);
ret ins.(0);
}
auto lv;
if (cx.fcx.lcx.ccx.sess.get_targ_crate_num() == fn_id._0) {
// Internal reference.
- check (cx.fcx.lcx.ccx.fn_pairs.contains_key(fn_id));
+ assert (cx.fcx.lcx.ccx.fn_pairs.contains_key(fn_id));
lv = lval_val(cx, cx.fcx.lcx.ccx.fn_pairs.get(fn_id));
} else {
// External reference.
alt (lcx.ccx.discrims.find(vid)) {
case (none[ValueRef]) {
// It's an external discriminant that we haven't seen yet.
- check (lcx.ccx.sess.get_targ_crate_num() != vid._0);
+ assert (lcx.ccx.sess.get_targ_crate_num() != vid._0);
auto sym = creader.get_symbol(lcx.ccx.sess, vid);
auto gvar = llvm.LLVMAddGlobal(lcx.ccx.llmod, T_int(),
_str.buf(sym));
case (ast.def_arg(?did)) {
alt (cx.fcx.llargs.find(did)) {
case (none[ValueRef]) {
- check (cx.fcx.llupvars.contains_key(did));
+ assert (cx.fcx.llupvars.contains_key(did));
ret lval_mem(cx, cx.fcx.llupvars.get(did));
}
case (some[ValueRef](?llval)) {
case (ast.def_local(?did)) {
alt (cx.fcx.lllocals.find(did)) {
case (none[ValueRef]) {
- check (cx.fcx.llupvars.contains_key(did));
+ assert (cx.fcx.llupvars.contains_key(did));
ret lval_mem(cx, cx.fcx.llupvars.get(did));
}
case (some[ValueRef](?llval)) {
}
}
case (ast.def_binding(?did)) {
- check (cx.fcx.lllocals.contains_key(did));
+ assert (cx.fcx.lllocals.contains_key(did));
ret lval_mem(cx, cx.fcx.lllocals.get(did));
}
case (ast.def_obj_field(?did)) {
- check (cx.fcx.llobjfields.contains_key(did));
+ assert (cx.fcx.llobjfields.contains_key(did));
ret lval_mem(cx, cx.fcx.llobjfields.get(did));
}
case (ast.def_fn(?did)) {
}
case (ast.def_const(?did)) {
// TODO: externals
- check (cx.fcx.lcx.ccx.consts.contains_key(did));
+ assert (cx.fcx.lcx.ccx.consts.contains_key(did));
ret lval_mem(cx, cx.fcx.lcx.ccx.consts.get(did));
}
case (ast.def_native_fn(?did)) {
ret trans_index(cx, e.span, base, idx, ann);
}
case (ast.expr_unary(?unop, ?base, ?ann)) {
- check (unop == ast.deref);
+ assert (unop == ast.deref);
auto sub = trans_expr(cx, base);
auto val = sub.bcx.build.GEP(sub.val,
}
} else if (ty.type_contains_params(cx.ccx.tcx,
out_arg.ty)) {
- check (out_arg.mode == ast.alias);
+ assert (out_arg.mode == ast.alias);
val = bcx.build.PointerCast(val, llout_arg_ty);
}
let ValueRef passed_arg = llvm.LLVMGetParam(llthunk, a);
if (ty.type_contains_params(cx.ccx.tcx, out_arg.ty)) {
- check (out_arg.mode == ast.alias);
+ assert (out_arg.mode == ast.alias);
passed_arg = bcx.build.PointerCast(passed_arg,
llout_arg_ty);
}
case (ast.expr_assign(?dst, ?src, ?ann)) {
auto lhs_res = trans_lval(cx, dst);
- check (lhs_res.is_mem);
+ assert (lhs_res.is_mem);
auto rhs_res = trans_expr(lhs_res.res.bcx, src);
auto t = node_ann_type(cx.fcx.lcx.ccx, ann);
// FIXME: calculate copy init-ness in typestate.
case (ast.expr_assign_op(?op, ?dst, ?src, ?ann)) {
auto t = node_ann_type(cx.fcx.lcx.ccx, ann);
auto lhs_res = trans_lval(cx, dst);
- check (lhs_res.is_mem);
+ assert (lhs_res.is_mem);
auto rhs_res = trans_expr(lhs_res.res.bcx, src);
if (ty.type_is_sequence(cx.fcx.lcx.ccx.tcx, t)) {
alt (op) {
ret trans_log(lvl, cx, a);
}
- case (ast.expr_check_expr(?a, _)) {
+ case (ast.expr_assert(?a, _)) {
+ ret trans_check_expr(cx, a);
+ }
+
+ case (ast.expr_check(?a, _)) {
ret trans_check_expr(cx, a);
}
fn trans_be(@block_ctxt cx, @ast.expr e) -> result {
// FIXME: This should be a typestate precondition
- check (ast.is_call_expr(e));
+ assert (ast.is_call_expr(e));
// FIXME: Turn this into a real tail call once
// calling convention issues are settled
ret trans_ret(cx, some(e));
auto bcx = cx;
auto data = trans_lval(bcx, lhs);
- check (data.is_mem);
+ assert (data.is_mem);
bcx = data.res.bcx;
auto unit_ty = node_ann_type(bcx.fcx.lcx.ccx, ann);
fn init_local(@block_ctxt cx, @ast.local local) -> result {
// Make a note to drop this slot on the way out.
- check (cx.fcx.lllocals.contains_key(local.id));
+ assert (cx.fcx.lllocals.contains_key(local.id));
auto llptr = cx.fcx.lllocals.get(local.id);
auto ty = node_ann_type(cx.fcx.lcx.ccx, local.ann);
auto bcx = cx;
auto bcx = cx;
if (cleanup_cx.kind == NON_SCOPE_BLOCK) {
- check (_vec.len[cleanup](cleanup_cx.cleanups) == 0u);
+ assert (_vec.len[cleanup](cleanup_cx.cleanups) == 0u);
}
auto i = _vec.len[cleanup](cleanup_cx.cleanups);
auto i = 0u;
for (ast.ty_param tp in ty_params) {
auto llarg = llvm.LLVMGetParam(cx.llfn, arg_n);
- check (llarg as int != 0);
+ assert (llarg as int != 0);
cx.lltydescs += vec(llarg);
arg_n += 1u;
i += 1u;
if (proto == ast.proto_iter) {
auto llarg = llvm.LLVMGetParam(cx.llfn, arg_n);
- check (llarg as int != 0);
+ assert (llarg as int != 0);
cx.lliterbody = some[ValueRef](llarg);
arg_n += 1u;
}
for (ast.arg arg in args) {
auto llarg = llvm.LLVMGetParam(cx.llfn, arg_n);
- check (llarg as int != 0);
+ assert (llarg as int != 0);
cx.llargs.insert(arg.id, llarg);
arg_n += 1u;
}
id=varg.id));
}
- check (cx.ccx.item_ids.contains_key(variant.node.id));
+ assert (cx.ccx.item_ids.contains_key(variant.node.id));
let ValueRef llfndecl = cx.ccx.item_ids.get(variant.node.id);
auto fcx = new_fn_ctxt(cx, llfndecl);
for each (uint i in _uint.range(0u, num_ty_param)) {
auto llarg = llvm.LLVMGetParam(fcx.llfn, arg_n);
fcx.lltydescs += vec(llarg);
- check (llarg as int != 0);
+ assert (llarg as int != 0);
call_args += vec(vp2i(bcx, llarg));
arg_n += 1u;
}
for (ty.arg arg in args) {
auto llarg = llvm.LLVMGetParam(fcx.llfn, arg_n);
- check (llarg as int != 0);
+ assert (llarg as int != 0);
push_arg(bcx, call_args, llarg, arg.ty, arg.mode);
if (arg.mode == ast.val) {
drop_args += vec(tup(llarg, arg.ty));
}
fn get_element_type(ctxt cx, t ty, uint i) -> t {
- check (type_is_tup_like(cx, ty));
+ assert (type_is_tup_like(cx, ty));
alt (struct(cx, ty)) {
case (ty_tup(?mts)) {
ret mts.(i).ty;
fail; // not reached
}
-fn expr_ann(@ast.expr expr) -> option.t[ast.ann] {
- alt (expr.node) {
- case (ast.expr_vec(_, _, ?ann)) { ret some[ast.ann](ann); }
- case (ast.expr_tup(_, ?ann)) { ret some[ast.ann](ann); }
- case (ast.expr_rec(_, _, ?ann)) { ret some[ast.ann](ann); }
- case (ast.expr_bind(_, _, ?ann)) { ret some[ast.ann](ann); }
- case (ast.expr_call(_, _, ?ann)) { ret some[ast.ann](ann); }
- case (ast.expr_self_method(_, ?ann)) { ret some[ast.ann](ann); }
- case (ast.expr_spawn(_, _, _, _, ?ann))
- { ret some[ast.ann](ann); }
- case (ast.expr_binary(_, _, _, ?ann)) { ret some[ast.ann](ann); }
- case (ast.expr_unary(_, _, ?ann)) { ret some[ast.ann](ann); }
- case (ast.expr_lit(_, ?ann)) { ret some[ast.ann](ann); }
- case (ast.expr_cast(_, _, ?ann)) { ret some[ast.ann](ann); }
- case (ast.expr_if(_, _, _, ?ann)) { ret some[ast.ann](ann); }
- case (ast.expr_for(_, _, _, ?ann)) { ret some[ast.ann](ann); }
- case (ast.expr_for_each(_, _, _, ?ann))
- { ret some[ast.ann](ann); }
- case (ast.expr_while(_, _, ?ann)) { ret some[ast.ann](ann); }
- case (ast.expr_do_while(_, _, ?ann)) { ret some[ast.ann](ann); }
- case (ast.expr_alt(_, _, ?ann)) { ret some[ast.ann](ann); }
- case (ast.expr_block(_, ?ann)) { ret some[ast.ann](ann); }
- case (ast.expr_assign(_, _, ?ann)) { ret some[ast.ann](ann); }
- case (ast.expr_assign_op(_, _, _, ?ann))
- { ret some[ast.ann](ann); }
- case (ast.expr_field(_, _, ?ann)) { ret some[ast.ann](ann); }
- case (ast.expr_index(_, _, ?ann)) { ret some[ast.ann](ann); }
- case (ast.expr_path(_, _, ?ann)) { ret some[ast.ann](ann); }
- case (ast.expr_ext(_, _, _, _, ?ann)) { ret some[ast.ann](ann); }
- case (ast.expr_port(?ann)) { ret some[ast.ann](ann); }
- case (ast.expr_chan(_, ?ann)) { ret some[ast.ann](ann); }
- case (ast.expr_send(_, _, ?ann)) { ret some[ast.ann](ann); }
- case (ast.expr_recv(_, _, ?ann)) { ret some[ast.ann](ann); }
-
- case (ast.expr_fail(_)) { ret none[ast.ann]; }
- case (ast.expr_break(_)) { ret none[ast.ann]; }
- case (ast.expr_cont(_)) { ret none[ast.ann]; }
- case (ast.expr_log(_,_,_)) { ret none[ast.ann]; }
- case (ast.expr_check_expr(_,_)) { ret none[ast.ann]; }
- case (ast.expr_ret(_,_)) { ret none[ast.ann]; }
- case (ast.expr_put(_,_)) { ret none[ast.ann]; }
- case (ast.expr_be(_,_)) { ret none[ast.ann]; }
+fn expr_ann(&@ast.expr e) -> ast.ann {
+ alt(e.node) {
+ case (ast.expr_vec(_,_,?a)) {
+ ret a;
+ }
+ case (ast.expr_tup(_,?a)) {
+ ret a;
+ }
+ case (ast.expr_rec(_,_,?a)) {
+ ret a;
+ }
+ case (ast.expr_call(_,_,?a)) {
+ ret a;
+ }
+ case (ast.expr_bind(_,_,?a)) {
+ ret a;
+ }
+ case (ast.expr_binary(_,_,_,?a)) {
+ ret a;
+ }
+ case (ast.expr_unary(_,_,?a)) {
+ ret a;
+ }
+ case (ast.expr_lit(_,?a)) {
+ ret a;
+ }
+ case (ast.expr_cast(_,_,?a)) {
+ ret a;
+ }
+ case (ast.expr_if(_,_,_,?a)) {
+ ret a;
+ }
+ case (ast.expr_while(_,_,?a)) {
+ ret a;
+ }
+ case (ast.expr_for(_,_,_,?a)) {
+ ret a;
+ }
+ case (ast.expr_for_each(_,_,_,?a)) {
+ ret a;
+ }
+ case (ast.expr_do_while(_,_,?a)) {
+ ret a;
+ }
+ case (ast.expr_alt(_,_,?a)) {
+ ret a;
+ }
+ case (ast.expr_block(_,?a)) {
+ ret a;
+ }
+ case (ast.expr_assign(_,_,?a)) {
+ ret a;
+ }
+ case (ast.expr_assign_op(_,_,_,?a)) {
+ ret a;
+ }
+ case (ast.expr_send(_,_,?a)) {
+ ret a;
+ }
+ case (ast.expr_recv(_,_,?a)) {
+ ret a;
+ }
+ case (ast.expr_field(_,_,?a)) {
+ ret a;
+ }
+ case (ast.expr_index(_,_,?a)) {
+ ret a;
+ }
+ case (ast.expr_path(_,_,?a)) {
+ ret a;
+ }
+ case (ast.expr_ext(_,_,_,_,?a)) {
+ ret a;
+ }
+ case (ast.expr_fail(?a)) {
+ ret a;
+ }
+ case (ast.expr_ret(_,?a)) {
+ ret a;
+ }
+ case (ast.expr_put(_,?a)) {
+ ret a;
+ }
+ case (ast.expr_be(_,?a)) {
+ ret a;
+ }
+ case (ast.expr_log(_,_,?a)) {
+ ret a;
+ }
+ case (ast.expr_assert(_,?a)) {
+ ret a;
+ }
+ case (ast.expr_check(_,?a)) {
+ ret a;
+ }
+ case (ast.expr_port(?a)) {
+ ret a;
+ }
+ case (ast.expr_chan(_,?a)) {
+ ret a;
+ }
+ case (ast.expr_break(?a)) {
+ ret a;
+ }
+ case (ast.expr_cont(?a)) {
+ ret a;
+ }
+ case (ast.expr_self_method(_, ?a)) {
+ ret a;
+ }
}
- fail;
}
// Returns the type of an expression as a monotype.
// instead of "fn(&T) -> T with T = int". If this isn't what you want, see
// expr_ty_params_and_ty() below.
fn expr_ty(ctxt cx, @ast.expr expr) -> t {
- alt (expr_ann(expr)) {
- case (none[ast.ann]) { ret mk_nil(cx); }
- case (some[ast.ann](?a)) { ret ann_to_monotype(cx, a); }
- }
+ { ret ann_to_monotype(cx, expr_ann(expr)); }
}
fn expr_ty_params_and_ty(ctxt cx, @ast.expr expr) -> tup(vec[t], t) {
- alt (expr_ann(expr)) {
- case (none[ast.ann]) {
- let vec[t] tps = vec();
- ret tup(tps, mk_nil(cx));
- }
- case (some[ast.ann](?a)) {
- ret tup(ann_to_type_params(a), ann_to_type(a));
- }
- }
+ auto a = expr_ann(expr);
+
+ ret tup(ann_to_type_params(a), ann_to_type(a));
}
fn expr_has_ty_params(@ast.expr expr) -> bool {
// FIXME: Rewrite using complex patterns when they're trustworthy.
alt (expr_ann(expr)) {
- case (none[ast.ann]) { fail; }
- case (some[ast.ann](?a)) {
- alt (a) {
- case (ast.ann_none) { fail; }
- case (ast.ann_type(_, ?tps_opt, _)) {
- ret !option.is_none[vec[t]](tps_opt);
- }
- }
+ case (ast.ann_none) { fail; }
+ case (ast.ann_type(_, ?tps_opt, _)) {
+ ret !option.is_none[vec[t]](tps_opt);
}
}
}
if (actual_n < vlen) {
cx.types.(actual_n) += vec(expected);
} else {
- check (actual_n == vlen);
+ assert (actual_n == vlen);
cx.types += vec(mutable vec(expected));
}
}
if (expected_n < vlen) {
cx.types.(expected_n) += vec(actual);
} else {
- check (expected_n == vlen);
+ assert (expected_n == vlen);
cx.types += vec(mutable vec(actual));
}
ret ures_ok(expected);
-> ty_param_count_and_ty {
alt (defn) {
case (ast.def_arg(?id)) {
- // check (fcx.locals.contains_key(id));
+ // assert (fcx.locals.contains_key(id));
ret tup(0u, fcx.locals.get(id));
}
case (ast.def_local(?id)) {
ret tup(0u, t);
}
case (ast.def_obj_field(?id)) {
- // check (fcx.locals.contains_key(id));
+ // assert (fcx.locals.contains_key(id));
ret tup(0u, fcx.locals.get(id));
}
case (ast.def_fn(?id)) {
fcx.ccx.type_cache, vid);
}
case (ast.def_binding(?id)) {
- // check (fcx.locals.contains_key(id));
+ // assert (fcx.locals.contains_key(id));
ret tup(0u, fcx.locals.get(id));
}
case (ast.def_obj(?id)) {
}
case (ast.ty_path(?path, ?def)) {
- check (def != none[ast.def]);
+ assert (def != none[ast.def]);
alt (option.get[ast.def](def)) {
case (ast.def_ty(?id)) {
typ = instantiate(tcx, getter, id, path.node.types);
ret creader.get_type(cx.sess, cx.tcx, id);
}
- // check (cx.id_to_ty_item.contains_key(id));
+ // assert (cx.id_to_ty_item.contains_key(id));
auto it = cx.id_to_ty_item.get(id);
auto tpt;
fn fold_item_const(&@env e, &span sp, ast.ident i,
@ast.ty t, @ast.expr ex,
ast.def_id id, ast.ann a) -> @ast.item {
- // check (e.cx.type_cache.contains_key(id));
+ // assert (e.cx.type_cache.contains_key(id));
auto typ = e.cx.type_cache.get(id)._1;
auto item = ast.item_const(i, t, ex, id, triv_ann(typ));
ret @fold.respan[ast.item_](sp, item);
fn fold_item_fn(&@env e, &span sp, ast.ident i,
&ast._fn f, vec[ast.ty_param] ty_params,
ast.def_id id, ast.ann a) -> @ast.item {
- // check (e.cx.type_cache.contains_key(id));
+ // assert (e.cx.type_cache.contains_key(id));
auto typ = e.cx.type_cache.get(id)._1;
auto item = ast.item_fn(i, f, ty_params, id, triv_ann(typ));
ret @fold.respan[ast.item_](sp, item);
fn fold_native_item_fn(&@env e, &span sp, ast.ident i, option.t[str] ln,
&ast.fn_decl d, vec[ast.ty_param] ty_params,
ast.def_id id, ast.ann a) -> @ast.native_item {
- // check (e.cx.type_cache.contains_key(id));
+ // assert (e.cx.type_cache.contains_key(id));
auto typ = e.cx.type_cache.get(id)._1;
auto item = ast.native_item_fn(i, ln, d, ty_params, id,
triv_ann(typ));
fn fold_item_obj(&@env e, &span sp, ast.ident i,
&ast._obj ob, vec[ast.ty_param] ty_params,
ast.obj_def_ids odid, ast.ann a) -> @ast.item {
- // check (e.cx.type_cache.contains_key(odid.ctor));
+ // assert (e.cx.type_cache.contains_key(odid.ctor));
auto t = e.cx.type_cache.get(odid.ctor)._1;
let vec[method] meth_tys = get_ctor_obj_methods(e, t);
let vec[@ast.method] methods = vec();
fn fold_item_ty(&@env e, &span sp, ast.ident i,
@ast.ty t, vec[ast.ty_param] ty_params,
ast.def_id id, ast.ann a) -> @ast.item {
- // check (e.cx.type_cache.contains_key(id));
+ // assert (e.cx.type_cache.contains_key(id));
auto typ = e.cx.type_cache.get(id)._1;
auto item = ast.item_ty(i, t, ty_params, id, triv_ann(typ));
ret @fold.respan[ast.item_](sp, item);
case (none[@ast.expr]) {
auto i = 0u;
for (ast.field field_0 in fields_0) {
- check (_str.eq(field_0.ident,
+ assert (_str.eq(field_0.ident,
field_mts.(i).ident));
auto e_1 =
pushdown_expr(fcx,
case (ast.expr_ret(_,_)) { e_1 = e.node; }
case (ast.expr_put(_,_)) { e_1 = e.node; }
case (ast.expr_be(_,_)) { e_1 = e.node; }
- case (ast.expr_check_expr(_,_)) { e_1 = e.node; }
+ case (ast.expr_check(_,_)) { e_1 = e.node; }
+ case (ast.expr_assert(_,_)) { e_1 = e.node; }
case (ast.expr_port(?ann)) {
auto t = Demand.simple(fcx, e.span, expected,
case (ast.expr_path(?pth, ?defopt, _)) {
auto t = ty.mk_nil(fcx.ccx.tcx);
- check (defopt != none[ast.def]);
+ assert (defopt != none[ast.def]);
auto defn = option.get[ast.def](defopt);
auto tpt = ty_param_count_and_ty_for_def(fcx, expr.span, defn);
case (ast.expr_be(?e, _)) {
/* FIXME: prove instead of check */
- check (ast.is_call_expr(e));
+ assert (ast.is_call_expr(e));
auto expr_0 = check_expr(fcx, e);
auto expr_1 = Pushdown.pushdown_expr(fcx, fcx.ret_ty, expr_0);
ret @fold.respan[ast.expr_](expr.span,
plain_ann(fcx.ccx.tcx)));
}
- case (ast.expr_check_expr(?e, _)) {
+ case (ast.expr_check(?e, _)) {
+ /* FIXME */
+ /* presumably, here is where we should check that e is
+ actually a call to a predicate, where all the arguments
+ are literals or slot variables? */
auto expr_t = check_expr(fcx, e);
Demand.simple(fcx, expr.span, ty.mk_bool(fcx.ccx.tcx),
expr_ty(fcx.ccx.tcx, expr_t));
ret @fold.respan[ast.expr_]
- (expr.span, ast.expr_check_expr(expr_t,
+ (expr.span, ast.expr_check(expr_t,
+ plain_ann(fcx.ccx.tcx)));
+ }
+
+ case (ast.expr_assert(?e, _)) {
+ auto expr_t = check_expr(fcx, e);
+ Demand.simple(fcx, expr.span, ty.mk_bool(fcx.ccx.tcx),
+ expr_ty(fcx.ccx.tcx, expr_t));
+ ret @fold.respan[ast.expr_]
+ (expr.span, ast.expr_assert(expr_t,
plain_ann(fcx.ccx.tcx)));
}
import front.ast.expr_port;
import front.ast.expr_chan;
import front.ast.expr_be;
-import front.ast.expr_check_expr;
+import front.ast.expr_check;
+import front.ast.expr_assert;
import front.ast.expr_cast;
import front.ast.expr_for;
import front.ast.expr_for_each;
import middle.ty;
import middle.ty.ann_to_type;
import middle.ty.arg;
-import middle.ty.block_ty;
-import middle.ty.expr_ty;
+import middle.ty.expr_ann;
import middle.ty.ty_to_str;
import pretty.pprust.print_block;
type fn_info_map = std.map.hashmap[def_id, fn_info];
fn bit_num(def_id v, fn_info m) -> uint {
- check (m.contains_key(v));
+ assert (m.contains_key(v));
ret m.get(v)._0;
}
fn get_fn_info(fn_info_map fm, def_id did) -> fn_info {
- check (fm.contains_key(did));
+ assert (fm.contains_key(did));
ret fm.get(did);
}
ret res;
}
/**** Helpers ****/
-fn expr_ann(&expr e) -> ann {
- alt(e.node) {
- case (ast.expr_vec(_,_,?a)) {
- ret a;
- }
- case (ast.expr_tup(_,?a)) {
- ret a;
- }
- case (ast.expr_rec(_,_,?a)) {
- ret a;
- }
- case (ast.expr_call(_,_,?a)) {
- ret a;
- }
- case (ast.expr_bind(_,_,?a)) {
- ret a;
- }
- case (ast.expr_binary(_,_,_,?a)) {
- ret a;
- }
- case (ast.expr_unary(_,_,?a)) {
- ret a;
- }
- case (ast.expr_lit(_,?a)) {
- ret a;
- }
- case (ast.expr_cast(_,_,?a)) {
- ret a;
- }
- case (ast.expr_if(_,_,_,?a)) {
- ret a;
- }
- case (ast.expr_while(_,_,?a)) {
- ret a;
- }
- case (ast.expr_for(_,_,_,?a)) {
- ret a;
- }
- case (ast.expr_for_each(_,_,_,?a)) {
- ret a;
- }
- case (ast.expr_do_while(_,_,?a)) {
- ret a;
- }
- case (ast.expr_alt(_,_,?a)) {
- ret a;
- }
- case (ast.expr_block(_,?a)) {
- ret a;
- }
- case (ast.expr_assign(_,_,?a)) {
- ret a;
- }
- case (ast.expr_assign_op(_,_,_,?a)) {
- ret a;
- }
- case (ast.expr_send(_,_,?a)) {
- ret a;
- }
- case (ast.expr_recv(_,_,?a)) {
- ret a;
- }
- case (ast.expr_field(_,_,?a)) {
- ret a;
- }
- case (ast.expr_index(_,_,?a)) {
- ret a;
- }
- case (ast.expr_path(_,_,?a)) {
- ret a;
- }
- case (ast.expr_ext(_,_,_,_,?a)) {
- ret a;
- }
- case (ast.expr_fail(?a)) {
- ret a;
- }
- case (ast.expr_ret(_,?a)) {
- ret a;
- }
- case (ast.expr_put(_,?a)) {
- ret a;
- }
- case (ast.expr_be(_,?a)) {
- ret a;
- }
- case (ast.expr_log(_,_,?a)) {
- ret a;
- }
- case (ast.expr_check_expr(_,?a)) {
- ret a;
- }
- case (ast.expr_port(?a)) {
- ret a;
- }
- case (ast.expr_chan(_,?a)) {
- ret a;
- }
- case (expr_break(?a)) {
- ret a;
- }
- case (expr_cont(?a)) {
- ret a;
- }
- case (expr_self_method(_, ?a)) {
- ret a;
- }
- }
-}
-
fn ann_to_ts_ann(ann a, uint nv) -> ts_ann {
alt (a) {
case (ann_none) { ret empty_ann(nv); }
fail;
}
case (ann_type(_,_,?t)) {
- check (! is_none[@ts_ann](t));
+ assert (! is_none[@ts_ann](t));
ret get[@ts_ann](t);
}
}
}
/* fails if e has no annotation */
-fn expr_states(&expr e) -> pre_and_post_state {
+fn expr_states(@expr e) -> pre_and_post_state {
alt (expr_ann(e)) {
case (ann_none) {
log_err "expr_pp: the impossible happened (no annotation)";
}
/* fails if e has no annotation */
-fn expr_pp(&expr e) -> pre_and_post {
+fn expr_pp(@expr e) -> pre_and_post {
alt (expr_ann(e)) {
case (ann_none) {
log_err "expr_pp: the impossible happened (no annotation)";
}
-fn expr_precond(&expr e) -> precond {
+fn expr_precond(@expr e) -> precond {
ret (expr_pp(e)).precondition;
}
-fn expr_postcond(&expr e) -> postcond {
+fn expr_postcond(@expr e) -> postcond {
ret (expr_pp(e)).postcondition;
}
-fn expr_prestate(&expr e) -> prestate {
+fn expr_prestate(@expr e) -> prestate {
ret (expr_states(e)).prestate;
}
-fn expr_poststate(&expr e) -> poststate {
+fn expr_poststate(@expr e) -> poststate {
ret (expr_states(e)).poststate;
}
if (sz >= 1u) {
auto first = pps.(0);
- check (pps_len(first) == num_vars);
+ assert (pps_len(first) == num_vars);
let precond rest = seq_preconds(enclosing,
slice[pre_and_post](pps, 1u, sz));
difference(rest, first.postcondition);
}
fn intersect_postconds(&vec[postcond] pcs) -> postcond {
- check (len[postcond](pcs) > 0u);
+ assert (len[postcond](pcs) > 0u);
ret intersect_postconds_go(bitv.clone(pcs.(0)), pcs);
}
fn find_pre_post_obj(&fn_info_map fm, _obj o) -> () {
fn do_a_method(fn_info_map fm, &@method m) -> () {
- check(fm.contains_key(m.node.id));
+ assert (fm.contains_key(m.node.id));
find_pre_post_fn(fm, fm.get(m.node.id), m.node.meth);
}
auto f = bind do_a_method(fm,_);
fn find_pre_post_state_obj(fn_info_map fm, _obj o) -> bool {
fn do_a_method(fn_info_map fm, &@method m) -> bool {
- check(fm.contains_key(m.node.id));
+ assert (fm.contains_key(m.node.id));
ret find_pre_post_state_fn(fm, fm.get(m.node.id), m.node.meth);
}
auto f = bind do_a_method(fm,_);
fn find_pre_post_item(fn_info_map fm, fn_info enclosing, &item i) -> () {
alt (i.node) {
case (ast.item_const(?id, ?t, ?e, ?di, ?a)) {
- find_pre_post_expr(fm, enclosing, *e);
+ find_pre_post_expr(fm, enclosing, e);
}
case (ast.item_fn(?id, ?f, ?ps, ?di, ?a)) {
- check (fm.contains_key(di));
+ assert (fm.contains_key(di));
find_pre_post_fn(fm, fm.get(di), f);
}
case (ast.item_mod(?id, ?m, ?di)) {
fn do_one(fn_info_map fm, fn_info enclosing,
&@expr e) -> () {
- find_pre_post_expr(fm, enclosing, *e);
+ find_pre_post_expr(fm, enclosing, e);
}
auto f = bind do_one(fm, enclosing, _);
_vec.map[@expr, ()](f, args);
fn get_pp(&@expr e) -> pre_and_post {
- ret expr_pp(*e);
+ ret expr_pp(e);
}
auto g = get_pp;
auto pps = _vec.map[@expr, pre_and_post](g, args);
fn find_pre_post_loop(&fn_info_map fm, &fn_info enclosing, &@decl d,
&@expr index, &block body, &ann a) -> () {
- find_pre_post_expr(fm, enclosing, *index);
+ find_pre_post_expr(fm, enclosing, index);
find_pre_post_block(fm, enclosing, body);
auto loop_precond = declare_var(enclosing, decl_lhs(d),
- seq_preconds(enclosing, vec(expr_pp(*index),
- block_pp(body))));
+ seq_preconds(enclosing, vec(expr_pp(index),
+ block_pp(body))));
auto loop_postcond = intersect_postconds
- (vec(expr_postcond(*index), block_postcond(body)));
+ (vec(expr_postcond(index), block_postcond(body)));
set_pre_and_post(a, rec(precondition=loop_precond,
postcondition=loop_postcond));
}
/* Fills in annotations as a side effect. Does not rebuild the expr */
-fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, &expr e) -> () {
+fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, @expr e) -> () {
auto num_local_vars = num_locals(enclosing);
fn do_rand_(fn_info_map fm, fn_info enclosing, &@expr e) -> () {
- find_pre_post_expr(fm, enclosing, *e);
+ find_pre_post_expr(fm, enclosing, e);
}
fn pp_one(&@expr e) -> pre_and_post {
- ret expr_pp(*e);
+ ret expr_pp(e);
}
log("find_pre_post_expr (num_locals =" +
uistr(num_local_vars) + "):");
- log_expr(e);
+ log_expr(*e);
alt (e.node) {
case (expr_call(?operator, ?operands, ?a)) {
set_pre_and_post(a, empty_pre_post(num_local_vars));
}
case(expr_log(_, ?arg, ?a)) {
- find_pre_post_expr(fm, enclosing, *arg);
- set_pre_and_post(a, expr_pp(*arg));
+ find_pre_post_expr(fm, enclosing, arg);
+ set_pre_and_post(a, expr_pp(arg));
}
case (expr_chan(?arg, ?a)) {
- find_pre_post_expr(fm, enclosing, *arg);
- set_pre_and_post(a, expr_pp(*arg));
+ find_pre_post_expr(fm, enclosing, arg);
+ set_pre_and_post(a, expr_pp(arg));
}
case(expr_put(?opt, ?a)) {
alt (opt) {
case (some[@expr](?arg)) {
- find_pre_post_expr(fm, enclosing, *arg);
- set_pre_and_post(a, expr_pp(*arg));
+ find_pre_post_expr(fm, enclosing, arg);
+ set_pre_and_post(a, expr_pp(arg));
}
case (none[@expr]) {
set_pre_and_post(a, empty_pre_post(num_local_vars));
case (expr_assign(?lhs, ?rhs, ?a)) {
alt (lhs.node) {
case (expr_path(?p, some[def](def_local(?d_id)), ?a_lhs)) {
- find_pre_post_expr(fm, enclosing, *rhs);
- set_pre_and_post(a, expr_pp(*rhs));
+ find_pre_post_expr(fm, enclosing, rhs);
+ set_pre_and_post(a, expr_pp(rhs));
log("gen:");
- log_expr(e);
+ log_expr(*e);
gen(enclosing, a, d_id);
}
case (_) {
case (expr_recv(?lhs, ?rhs, ?a)) {
alt (lhs.node) {
case (expr_path(?p, some[def](def_local(?d_id)), ?a_lhs)) {
- find_pre_post_expr(fm, enclosing, *rhs);
- set_pre_and_post(a, expr_pp(*rhs));
+ find_pre_post_expr(fm, enclosing, rhs);
+ set_pre_and_post(a, expr_pp(rhs));
log("gen:");
- log_expr(e);
+ log_expr(*e);
gen(enclosing, a, d_id);
}
case (_) {
postcondition=false_postcond(num_local_vars)));
}
case (some[@expr](?ret_val)) {
- find_pre_post_expr(fm, enclosing, *ret_val);
+ find_pre_post_expr(fm, enclosing, ret_val);
let pre_and_post pp =
- rec(precondition=expr_precond(*ret_val),
+ rec(precondition=expr_precond(ret_val),
postcondition=false_postcond(num_local_vars));
set_pre_and_post(a, pp);
}
}
}
case (expr_be(?e, ?a)) {
- find_pre_post_expr(fm, enclosing, *e);
- set_pre_and_post(a, rec(precondition=expr_prestate(*e),
+ find_pre_post_expr(fm, enclosing, e);
+ set_pre_and_post(a, rec(precondition=expr_prestate(e),
postcondition=false_postcond(num_local_vars)));
}
case (expr_if(?antec, ?conseq, ?maybe_alt, ?a)) {
- find_pre_post_expr(fm, enclosing, *antec);
+ find_pre_post_expr(fm, enclosing, antec);
find_pre_post_block(fm, enclosing, conseq);
alt (maybe_alt) {
case (none[@expr]) {
auto precond_res = seq_preconds(enclosing,
- vec(expr_pp(*antec),
+ vec(expr_pp(antec),
block_pp(conseq)));
set_pre_and_post(a, rec(precondition=precond_res,
postcondition=
- expr_poststate(*antec)));
+ expr_poststate(antec)));
}
case (some[@expr](?altern)) {
- find_pre_post_expr(fm, enclosing, *altern);
+ find_pre_post_expr(fm, enclosing, altern);
auto precond_true_case =
seq_preconds(enclosing,
- vec(expr_pp(*antec), block_pp(conseq)));
+ vec(expr_pp(antec), block_pp(conseq)));
auto postcond_true_case = union_postconds
(num_local_vars,
- vec(expr_postcond(*antec), block_postcond(conseq)));
+ vec(expr_postcond(antec), block_postcond(conseq)));
auto precond_false_case = seq_preconds
(enclosing,
- vec(expr_pp(*antec), expr_pp(*altern)));
+ vec(expr_pp(antec), expr_pp(altern)));
auto postcond_false_case = union_postconds
(num_local_vars,
- vec(expr_postcond(*antec), expr_postcond(*altern)));
+ vec(expr_postcond(antec), expr_postcond(altern)));
auto precond_res = union_postconds
(num_local_vars,
vec(precond_true_case, precond_false_case));
find_pre_post_exprs(fm, enclosing, vec(l, r), a);
}
case (expr_unary(_,?operand,?a)) {
- find_pre_post_expr(fm, enclosing, *operand);
- set_pre_and_post(a, expr_pp(*operand));
+ find_pre_post_expr(fm, enclosing, operand);
+ set_pre_and_post(a, expr_pp(operand));
}
case (expr_cast(?operand, _, ?a)) {
- find_pre_post_expr(fm, enclosing, *operand);
- set_pre_and_post(a, expr_pp(*operand));
+ find_pre_post_expr(fm, enclosing, operand);
+ set_pre_and_post(a, expr_pp(operand));
}
case (expr_while(?test, ?body, ?a)) {
- find_pre_post_expr(fm, enclosing, *test);
+ find_pre_post_expr(fm, enclosing, test);
find_pre_post_block(fm, enclosing, body);
set_pre_and_post(a,
rec(precondition=
seq_preconds(enclosing,
- vec(expr_pp(*test),
+ vec(expr_pp(test),
block_pp(body))),
postcondition=
- intersect_postconds(vec(expr_postcond(*test),
+ intersect_postconds(vec(expr_postcond(test),
block_postcond(body)))));
}
case (expr_do_while(?body, ?test, ?a)) {
find_pre_post_block(fm, enclosing, body);
- find_pre_post_expr(fm, enclosing, *test);
+ find_pre_post_expr(fm, enclosing, test);
auto loop_postcond = union_postconds(num_local_vars,
- vec(block_postcond(body), expr_postcond(*test)));
+ vec(block_postcond(body), expr_postcond(test)));
/* conservative approximination: if the body
could break or cont, the test may never be executed */
if (has_nonlocal_exits(body)) {
set_pre_and_post(a,
rec(precondition=seq_preconds(enclosing,
vec(block_pp(body),
- expr_pp(*test))),
+ expr_pp(test))),
postcondition=loop_postcond));
}
case (expr_for(?d, ?index, ?body, ?a)) {
find_pre_post_exprs(fm, enclosing, vec(e, sub), a);
}
case (expr_alt(?e, ?alts, ?a)) {
- find_pre_post_expr(fm, enclosing, *e);
+ find_pre_post_expr(fm, enclosing, e);
fn do_an_alt(fn_info_map fm, fn_info enc, &arm an_alt)
-> pre_and_post {
find_pre_post_block(fm, enc, an_alt.block);
intersect(pp.postcondition, next.postcondition);
ret pp;
}
- auto antec_pp = pp_clone(expr_pp(*e));
+ auto antec_pp = pp_clone(expr_pp(e));
auto e_pp = rec(precondition=empty_prestate(num_local_vars),
postcondition=false_postcond(num_local_vars));
auto g = bind combine_pp(antec_pp, enclosing, _, _);
set_pre_and_post(a, alts_overall_pp);
}
case (expr_field(?operator, _, ?a)) {
- find_pre_post_expr(fm, enclosing, *operator);
- set_pre_and_post(a, expr_pp(*operator));
+ find_pre_post_expr(fm, enclosing, operator);
+ set_pre_and_post(a, expr_pp(operator));
}
case (expr_fail(?a)) {
set_pre_and_post(a,
rec(precondition=empty_prestate(num_local_vars),
postcondition=false_postcond(num_local_vars)));
}
- case (expr_check_expr(?p, ?a)) {
+ case (expr_assert(?p, ?a)) {
+ find_pre_post_expr(fm, enclosing, p);
+ set_pre_and_post(a, expr_pp(p));
+ }
+ case (expr_check(?p, ?a)) {
/* will need to change when we support arbitrary predicates... */
- find_pre_post_expr(fm, enclosing, *p);
- set_pre_and_post(a, expr_pp(*p));
+ find_pre_post_expr(fm, enclosing, p);
+ set_pre_and_post(a, expr_pp(p));
}
case(expr_bind(?operator, ?maybe_args, ?a)) {
auto args = _vec.cat_options[@expr](maybe_args);
set_pre_and_post(a, empty_pre_post(num_local_vars));
}
case (expr_ext(_, _, _, ?expanded, ?a)) {
- find_pre_post_expr(fm, enclosing, *expanded);
- set_pre_and_post(a, expr_pp(*expanded));
+ find_pre_post_expr(fm, enclosing, expanded);
+ set_pre_and_post(a, expr_pp(expanded));
}
}
}
fn gen(&fn_info enclosing, &ann a, def_id id) -> bool {
- check(enclosing.contains_key(id));
+ assert (enclosing.contains_key(id));
let uint i = (enclosing.get(id))._0;
ret set_in_postcond(i, (ann_to_ts_ann_fail_more(a)).conditions);
}
fn declare_var(&fn_info enclosing, def_id id, prestate pre)
-> prestate {
- check(enclosing.contains_key(id));
+ assert (enclosing.contains_key(id));
let uint i = (enclosing.get(id))._0;
auto res = clone(pre);
relax_prestate(i, res);
}
fn gen_poststate(&fn_info enclosing, &ann a, def_id id) -> bool {
- check(enclosing.contains_key(id));
+ assert (enclosing.contains_key(id));
let uint i = (enclosing.get(id))._0;
ret set_in_poststate(i, (ann_to_ts_ann_fail_more(a)).states);
case(ast.decl_local(?alocal)) {
alt(alocal.init) {
case(some[ast.initializer](?an_init)) {
- find_pre_post_expr(fm, enclosing, *an_init.expr);
- auto rhs_pp = expr_pp(*an_init.expr);
+ find_pre_post_expr(fm, enclosing, an_init.expr);
+ auto rhs_pp = expr_pp(an_init.expr);
set_pre_and_post(alocal.ann, rhs_pp);
/* Inherit ann from initializer, and add var being
}
}
case(stmt_expr(?e,?a)) {
- find_pre_post_expr(fm, enclosing, *e);
- set_pre_and_post(a, expr_pp(*e));
+ find_pre_post_expr(fm, enclosing, e);
+ set_pre_and_post(a, expr_pp(e));
}
}
}
_vec.map[@stmt, ()](do_one, b.node.stmts);
fn do_inner_(fn_info_map fm, fn_info i, &@expr e) -> () {
- find_pre_post_expr(fm, i, *e);
+ find_pre_post_expr(fm, i, e);
}
auto do_inner = bind do_inner_(fm, enclosing, _);
option.map[@expr, ()](do_inner, b.node.expr);
auto f = get_pp_stmt;
pps += _vec.map[@stmt, pre_and_post](f, b.node.stmts);
fn get_pp_expr(&@expr e) -> pre_and_post {
- ret expr_pp(*e);
+ ret expr_pp(e);
}
auto g = get_pp_expr;
plus_option[pre_and_post](pps,
log("check_item_fn:");
log_fn(f, i, ty_params);
- check (fm.contains_key(id));
+ assert (fm.contains_key(id));
find_pre_post_fn(fm, fm.get(id), f);
ret @respan(sp, ast.item_fn(i, f, ty_params, id, a));
empty_prestate(num_locals(enclosing)), e);
}
case (ast.item_fn(?id, ?f, ?ps, ?di, ?a)) {
- check (fm.contains_key(di));
+ assert (fm.contains_key(di));
ret find_pre_post_state_fn(fm, fm.get(di), f);
}
case (ast.item_mod(?id, ?m, ?di)) {
fn set_prestate_ann(@ann a, prestate pre) -> bool {
alt (*a) {
case (ann_type(_,_,?ts_a)) {
- check (! is_none[@ts_ann](ts_a));
+ assert (! is_none[@ts_ann](ts_a));
ret set_prestate(get[@ts_ann](ts_a), pre);
}
case (ann_none) {
fn extend_prestate_ann(ann a, prestate pre) -> bool {
alt (a) {
case (ann_type(_,_,?ts_a)) {
- check (! is_none[@ts_ann](ts_a));
- ret extend_prestate((*get[@ts_ann](ts_a)).states.prestate, pre);
+ assert (! is_none[@ts_ann](ts_a));
+ ret extend_prestate((get[@ts_ann](ts_a)).states.prestate, pre);
}
case (ann_none) {
log("set_prestate_ann: expected an ann_type here");
fn set_poststate_ann(ann a, poststate post) -> bool {
alt (a) {
case (ann_type(_,_,?ts_a)) {
- check (! is_none[@ts_ann](ts_a));
- ret set_poststate(*get[@ts_ann](ts_a), post);
+ assert (! is_none[@ts_ann](ts_a));
+ ret set_poststate(get[@ts_ann](ts_a), post);
}
case (ann_none) {
log("set_poststate_ann: expected an ann_type here");
fn extend_poststate_ann(ann a, poststate post) -> bool {
alt (a) {
case (ann_type(_,_,?ts_a)) {
- check (! is_none[@ts_ann](ts_a));
+ assert (! is_none[@ts_ann](ts_a));
ret extend_poststate((*get[@ts_ann](ts_a)).states.poststate, post);
}
case (ann_none) {
fn set_pre_and_post(&ann a, pre_and_post pp) -> () {
alt (a) {
case (ann_type(_,_,?ts_a)) {
- check (! is_none[@ts_ann](ts_a));
+ assert (! is_none[@ts_ann](ts_a));
auto t = *get[@ts_ann](ts_a);
/* log("set_pre_and_post, old =");
log_pp(t.conditions);
for (@expr e in exprs) {
changed = find_pre_post_state_expr(fm, enclosing, post, e) || changed;
- post = expr_poststate(*e);
+ post = expr_poststate(e);
}
ret tup(changed, post);
/* in general, would need the intersection of
(poststate of index, poststate of body) */
changed = find_pre_post_state_block(fm, enclosing,
- expr_poststate(*index), body) || changed;
- auto res_p = intersect_postconds(vec(expr_poststate(*index),
+ expr_poststate(index), body) || changed;
+ auto res_p = intersect_postconds(vec(expr_poststate(index),
block_poststate(body)));
changed = extend_poststate_ann(a, res_p) || changed;
}
fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing,
- &prestate pres, &@expr e) -> bool {
+ &prestate pres, @expr e) -> bool {
auto changed = false;
auto num_local_vars = num_locals(enclosing);
|| changed;
/* rands go left-to-right */
ret(find_pre_post_state_exprs(fm, enclosing,
- expr_poststate(*operator), a, operands)
+ expr_poststate(operator), a, operands)
|| changed);
}
case (expr_spawn(_, _, ?operator, ?operands, ?a)) {
changed = find_pre_post_state_expr(fm, enclosing, pres, operator);
ret(find_pre_post_state_exprs(fm, enclosing,
- expr_poststate(*operator), a, operands)
+ expr_poststate(operator), a, operands)
|| changed);
}
case (expr_bind(?operator, ?maybe_args, ?a)) {
changed = find_pre_post_state_expr(fm, enclosing, pres, operator)
|| changed;
ret (find_pre_post_state_exprs(fm, enclosing,
- expr_poststate(*operator), a, cat_options[@expr](maybe_args))
+ expr_poststate(operator), a, cat_options[@expr](maybe_args))
|| changed);
}
case (expr_path(_,_,?a)) {
/* factor out the "one exp" pattern */
changed = find_pre_post_state_expr(fm, enclosing, pres, e);
changed = extend_prestate_ann(a, pres) || changed;
- changed = extend_poststate_ann(a, expr_poststate(*e)) || changed;
+ changed = extend_poststate_ann(a, expr_poststate(e)) || changed;
ret changed;
}
case (expr_chan(?e, ?a)) {
changed = find_pre_post_state_expr(fm, enclosing, pres, e);
changed = extend_prestate_ann(a, pres) || changed;
- changed = extend_poststate_ann(a, expr_poststate(*e)) || changed;
+ changed = extend_poststate_ann(a, expr_poststate(e)) || changed;
ret changed;
}
case (expr_ext(_, _, _, ?expanded, ?a)) {
changed = find_pre_post_state_expr(fm, enclosing, pres, expanded);
changed = extend_prestate_ann(a, pres) || changed;
- changed = extend_poststate_ann(a, expr_poststate(*expanded))
+ changed = extend_poststate_ann(a, expr_poststate(expanded))
|| changed;
ret changed;
}
case (some[@expr](?arg)) {
changed = find_pre_post_state_expr(fm, enclosing, pres, arg);
changed = extend_prestate_ann(a, pres) || changed;
- changed = extend_poststate_ann(a, expr_poststate(*arg))
+ changed = extend_poststate_ann(a, expr_poststate(arg))
|| changed;
ret changed;
}
case (some[@expr](?base)) {
changed = find_pre_post_state_expr(fm, enclosing, pres, base)
|| changed;
- changed = extend_poststate_ann(a, expr_poststate(*base))
+ changed = extend_poststate_ann(a, expr_poststate(base))
|| changed;
}
}
changed = pure_exp(a_lhs, pres) || changed;
changed = find_pre_post_state_expr(fm, enclosing, pres, rhs)
|| changed;
- changed = extend_poststate_ann(a, expr_poststate(*rhs))
+ changed = extend_poststate_ann(a, expr_poststate(rhs))
|| changed;
changed = gen_poststate(enclosing, a, d_id) || changed;
}
changed = find_pre_post_state_expr(fm, enclosing, pres, lhs)
|| changed;
changed = find_pre_post_state_expr(fm, enclosing,
- expr_poststate(*lhs), rhs) || changed;
- changed = extend_poststate_ann(a, expr_poststate(*rhs))
+ expr_poststate(lhs), rhs) || changed;
+ changed = extend_poststate_ann(a, expr_poststate(rhs))
|| changed;
}
}
changed = pure_exp(a_lhs, pres) || changed;
changed = find_pre_post_state_expr(fm, enclosing, pres, rhs)
|| changed;
- changed = extend_poststate_ann(a, expr_poststate(*rhs))
+ changed = extend_poststate_ann(a, expr_poststate(rhs))
|| changed;
changed = gen_poststate(enclosing, a, d_id) || changed;
}
changed = find_pre_post_state_expr(fm, enclosing, pres, lhs)
|| changed;
changed = find_pre_post_state_expr(fm, enclosing,
- expr_poststate(*lhs), rhs) || changed;
- changed = extend_poststate_ann(a, expr_poststate(*rhs))
+ expr_poststate(lhs), rhs) || changed;
+ changed = extend_poststate_ann(a, expr_poststate(rhs))
|| changed;
}
}
changed = find_pre_post_state_expr(fm, enclosing, pres, antec)
|| changed;
changed = find_pre_post_state_block(fm, enclosing,
- expr_poststate(*antec), conseq) || changed;
+ expr_poststate(antec), conseq) || changed;
alt (maybe_alt) {
case (none[@expr]) {
- changed = extend_poststate_ann(a, expr_poststate(*antec))
+ changed = extend_poststate_ann(a, expr_poststate(antec))
|| changed;
}
case (some[@expr](?altern)) {
changed = find_pre_post_state_expr(fm, enclosing,
- expr_poststate(*antec), altern) || changed;
+ expr_poststate(antec), altern) || changed;
auto poststate_res = intersect_postconds
- (vec(block_poststate(conseq), expr_poststate(*altern)));
+ (vec(block_poststate(conseq), expr_poststate(altern)));
changed = extend_poststate_ann(a, poststate_res) || changed;
}
}
log("new prestate:");
log_bitv(enclosing, pres);
log("new poststate:");
- log_bitv(enclosing, expr_poststate(*e));
+ log_bitv(enclosing, expr_poststate(e));
ret changed;
}
changed = find_pre_post_state_expr(fm, enclosing, pres, l)
|| changed;
changed = find_pre_post_state_expr(fm,
- enclosing, expr_poststate(*l), r) || changed;
- changed = extend_poststate_ann(a, expr_poststate(*r)) || changed;
+ enclosing, expr_poststate(l), r) || changed;
+ changed = extend_poststate_ann(a, expr_poststate(r)) || changed;
ret changed;
}
case (expr_send(?l, ?r, ?a)) {
changed = find_pre_post_state_expr(fm, enclosing, pres, l)
|| changed;
changed = find_pre_post_state_expr(fm,
- enclosing, expr_poststate(*l), r) || changed;
- changed = extend_poststate_ann(a, expr_poststate(*r)) || changed;
+ enclosing, expr_poststate(l), r) || changed;
+ changed = extend_poststate_ann(a, expr_poststate(r)) || changed;
ret changed;
}
case (expr_assign_op(?op, ?lhs, ?rhs, ?a)) {
changed = find_pre_post_state_expr(fm, enclosing, pres, lhs)
|| changed;
changed = find_pre_post_state_expr(fm,
- enclosing, expr_poststate(*lhs), rhs) || changed;
- changed = extend_poststate_ann(a, expr_poststate(*rhs)) || changed;
+ enclosing, expr_poststate(lhs), rhs) || changed;
+ changed = extend_poststate_ann(a, expr_poststate(rhs)) || changed;
ret changed;
}
case (expr_while(?test, ?body, ?a)) {
changed = find_pre_post_state_expr(fm, enclosing, pres, test)
|| changed;
changed = find_pre_post_state_block(fm,
- enclosing, expr_poststate(*test), body) || changed;
+ enclosing, expr_poststate(test), body) || changed;
changed = extend_poststate_ann(a,
- intersect_postconds(vec(expr_poststate(*test),
+ intersect_postconds(vec(expr_poststate(test),
block_poststate(body)))) || changed;
ret changed;
}
changed = set_poststate_ann(a, pres) || changed;
}
else {
- changed = extend_poststate_ann(a, expr_poststate(*test))
+ changed = extend_poststate_ann(a, expr_poststate(test))
|| changed;
}
changed = extend_prestate_ann(a, pres) || changed;
changed = find_pre_post_state_expr(fm, enclosing, pres, e) || changed;
changed = find_pre_post_state_expr(fm, enclosing,
- expr_poststate(*e), sub) || changed;
- changed = extend_poststate_ann(a, expr_poststate(*sub));
+ expr_poststate(e), sub) || changed;
+ changed = extend_poststate_ann(a, expr_poststate(sub));
ret changed;
}
case (expr_alt(?e, ?alts, ?a)) {
changed = extend_prestate_ann(a, pres) || changed;
changed = find_pre_post_state_expr(fm, enclosing, pres, e) || changed;
- auto e_post = expr_poststate(*e);
+ auto e_post = expr_poststate(e);
auto a_post;
if (_vec.len[arm](alts) > 0u) {
a_post = false_postcond(num_local_vars);
case (expr_field(?e,_,?a)) {
changed = find_pre_post_state_expr(fm, enclosing, pres, e);
changed = extend_prestate_ann(a, pres) || changed;
- changed = extend_poststate_ann(a, expr_poststate(*e)) || changed;
+ changed = extend_poststate_ann(a, expr_poststate(e)) || changed;
ret changed;
}
case (expr_unary(_,?operand,?a)) {
changed = find_pre_post_state_expr(fm, enclosing, pres, operand)
|| changed;
changed = extend_prestate_ann(a, pres) || changed;
- changed = extend_poststate_ann(a, expr_poststate(*operand))
+ changed = extend_poststate_ann(a, expr_poststate(operand))
|| changed;
ret changed;
}
changed = find_pre_post_state_expr(fm, enclosing, pres, operand)
|| changed;
changed = extend_prestate_ann(a, pres) || changed;
- changed = extend_poststate_ann(a, expr_poststate(*operand))
+ changed = extend_poststate_ann(a, expr_poststate(operand))
|| changed;
ret changed;
}
/* if execution continues after fail, then everything is true! woo! */
changed = set_poststate_ann(a, false_postcond(num_local_vars))
|| changed;
- /* log_err("fail: poststate = ");
- log_bitv(enclosing, expr_poststate(*e)); */
ret changed;
}
- case (expr_check_expr(?p, ?a)) {
+ case (expr_assert(?p, ?a)) {
+ ret pure_exp(a, pres);
+ }
+ case (expr_check(?p, ?a)) {
changed = extend_prestate_ann(a, pres) || changed;
changed = find_pre_post_state_expr(fm, enclosing, pres, p) || changed;
- /* p is pure, so the poststate must be the same as the prestate */
+ /* FIXME: update the postcondition to reflect that p holds */
changed = extend_poststate_ann(a, pres) || changed;
ret changed;
}
&prestate pres, @stmt s) -> bool {
auto changed = false;
auto stmt_ann_ = stmt_to_ann(*s);
- check (!is_none[@ts_ann](stmt_ann_));
+ assert (!is_none[@ts_ann](stmt_ann_));
auto stmt_ann = *(get[@ts_ann](stmt_ann_));
log("*At beginning: stmt = ");
log_stmt(*s);
changed = find_pre_post_state_expr
(fm, enclosing, pres, an_init.expr) || changed;
changed = extend_poststate(stmt_ann.states.poststate,
- expr_poststate(*an_init.expr))
+ expr_poststate(an_init.expr))
|| changed;
changed = gen_poststate(enclosing, a, alocal.id) || changed;
log("Summary: stmt = ");
}
case (stmt_expr(?e, _)) {
changed = find_pre_post_state_expr(fm, enclosing, pres, e) || changed;
- changed = extend_prestate(stmt_ann.states.prestate, expr_prestate(*e))
+ changed = extend_prestate(stmt_ann.states.prestate, expr_prestate(e))
|| changed;
changed = extend_poststate(stmt_ann.states.poststate,
- expr_poststate(*e)) || changed;
+ expr_poststate(e)) || changed;
/*
log("Summary: stmt = ");
log_stmt(*s);
case (none[@expr]) {}
case (some[@expr](?e)) {
changed = find_pre_post_state_expr(fm, enclosing, pres, e) || changed;
- post = expr_poststate(*e);
+ post = expr_poststate(e);
}
}
}
}
-fn check_states_expr(fn_info enclosing, &expr e) -> () {
+fn check_states_expr(fn_info enclosing, @expr e) -> () {
let precond prec = expr_precond(e);
let prestate pres = expr_prestate(e);
if (!implies(pres, prec)) {
log_err("check_states_expr: Unsatisfied precondition constraint for ");
- log_expr_err(e);
+ log_expr_err(*e);
log_err("Precondition: ");
log_bitv_err(enclosing, prec);
log_err("Prestate: ");
_vec.map[@stmt, ()](do_one, f.body.node.stmts);
fn do_inner_(fn_info i, &@expr e) -> () {
- check_states_expr(i, *e);
+ check_states_expr(i, e);
}
auto do_inner = bind do_inner_(enclosing, _);
option.map[@expr, ()](do_inner, f.body.node.expr);
ann a) -> @item {
/* Look up the var-to-bit-num map for this function */
- check(f_info_map.contains_key(id));
+ assert (f_info_map.contains_key(id));
auto f_info = f_info_map.get(id);
check_fn_states(f_info_map, f_info, f);
}
fn check_method_states(&fn_info_map f_info_map, @method m) -> () {
- check (f_info_map.contains_key(m.node.id));
+ assert (f_info_map.contains_key(m.node.id));
auto f_info = f_info_map.get(m.node.id);
check_fn_states(f_info_map, f_info, m.node.meth);
}
fn item_fn_anns(&fn_info_map fm, &span sp, ident i, &ast._fn f,
vec[ast.ty_param] ty_params, def_id id, ann a) -> @item {
- check(fm.contains_key(id));
+ assert (fm.contains_key(id));
auto f_info = fm.get(id);
log(i + " has " + uistr(num_locals(f_info)) + " local vars");
case (expr_log(?n, ?e, ?a)) {
e1 = expr_log(n, annotate_expr(fm, e), a);
}
- case (expr_check_expr(?e, ?a)) {
- e1 = expr_check_expr(annotate_expr(fm, e), a);
+ case (expr_assert(?e, ?a)) {
+ e1 = expr_assert(annotate_expr(fm, e), a);
+ }
+ case (expr_check(?e, ?a)) {
+ e1 = expr_check(annotate_expr(fm, e), a);
}
case (expr_port(_)) { /* no change */ }
case (expr_chan(?e, ?a)) {
case (ast.expr_log(_,?x, _)) {
walk_expr(v, x);
}
- case (ast.expr_check_expr(?x, _)) {
+ case (ast.expr_check(?x, _)) {
+ walk_expr(v, x);
+ }
+ case (ast.expr_assert(?x, _)) {
walk_expr(v, x);
}
case (ast.expr_port(_)) { }
}
print_expr(s, expr);
}
- case (ast.expr_check_expr(?expr,_)) {
+ case (ast.expr_check(?expr,_)) {
wrd1(s, "check");
popen_h(s);
print_expr(s, expr);
pclose(s);
}
+ case (ast.expr_assert(?expr,_)) {
+ wrd1(s, "assert");
+ popen_h(s);
+ print_expr(s, expr);
+ pclose(s);
+ }
case (ast.expr_ext(?path, ?args, ?body, _, _)) {
wrd(s.s, "#");
print_path(s, path);
fn pps_len(&pre_and_post p) -> uint {
// gratuitous check
- check (p.precondition.nbits == p.postcondition.nbits);
+ assert (p.precondition.nbits == p.postcondition.nbits);
ret p.precondition.nbits;
}
// Sets all the bits in a's postcondition to equal the
// corresponding bit in p's postcondition.
-fn set_poststate(&ts_ann a, &poststate p) -> bool {
+fn set_poststate(@ts_ann a, &poststate p) -> bool {
ret bitv.copy(a.states.poststate, p);
}
}
fn set_color(io.buf_writer writer, u8 first_char, u8 color) {
- check (color < 16u8);
+ assert (color < 16u8);
esc(writer);
if (color >= 8u8) {
fn to_str(int n, uint radix) -> str
{
- check (0u < radix && radix <= 16u);
+ assert (0u < radix && radix <= 16u);
if (n < 0) {
ret "-" + _uint.to_str((-n) as uint, radix);
} else {
fn char_range_at(str s, uint i) -> tup(char, uint) {
auto b0 = s.(i);
auto w = utf8_char_width(b0);
- check(w != 0u);
+ assert (w != 0u);
if (w == 1u) {ret tup(b0 as char, i + 1u);}
auto val = 0u;
auto end = i + w;
i += 1u;
while (i < end) {
auto byte = s.(i);
- check(byte & 0xc0_u8 == tag_cont_u8);
+ assert (byte & 0xc0_u8 == tag_cont_u8);
val <<= 6u;
val += (byte & 0x3f_u8) as uint;
i += 1u;
auto total = byte_len(s);
while (i < total) {
auto chsize = utf8_char_width(s.(i));
- check(chsize > 0u);
+ assert (chsize > 0u);
len += 1u;
i += chsize;
}
- check(i == total);
+ assert (i == total);
ret len;
}
fn pop_char(&mutable str s) -> char {
auto end = byte_len(s);
while (end > 0u && s.(end - 1u) & 0xc0_u8 == tag_cont_u8) {end -= 1u;}
- check(end > 0u);
+ assert (end > 0u);
auto ch = char_at(s, end - 1u);
s = substr(s, 0u, end - 1u);
ret ch;
fn shift_byte(&mutable str s) -> u8 {
auto len = byte_len(s);
- check(len > 0u);
+ assert (len > 0u);
auto b = s.(0);
s = substr(s, 1u, len - 1u);
ret b;
fn pop_byte(&mutable str s) -> u8 {
auto len = byte_len(s);
- check(len > 0u);
+ assert (len > 0u);
auto b = s.(len - 1u);
s = substr(s, 0u, len - 1u);
ret b;
{
auto n = num;
- check (0u < radix && radix <= 16u);
+ assert (0u < radix && radix <= 16u);
fn digit(uint n) -> char {
alt (n) {
case (0u) { ret '0'; }
}
fn buf_off[T](array[T] v, uint offset) -> vbuf {
- check (offset < len[T](v));
+ assert (offset < len[T](v));
ret rustrt.vec_buf[T](v, offset);
}
}
// Returns elements from [start..end) from v.
+
fn slice[T](array[T] v, uint start, uint end) -> vec[T] {
- check (start <= end);
- check (end <= len[T](v));
+ assert (start <= end);
+ assert (end <= len[T](v));
auto result = alloc[T](end - start);
let uint i = start;
while (i < end) {
fn shift[T](&mutable array[T] v) -> T {
auto ln = len[T](v);
- check(ln > 0u);
+ assert (ln > 0u);
auto e = v.(0);
v = slice[T](v, 1u, ln);
ret e;
fn pop[T](&mutable array[T] v) -> T {
auto ln = len[T](v);
- check(ln > 0u);
+ assert (ln > 0u);
ln -= 1u;
auto e = v.(ln);
v = slice[T](v, 0u, ln);
fn process(&fn(uint, uint) -> uint op, &t v0, &t v1) -> bool {
auto len = _vec.len[mutable uint](v1.storage);
- check (_vec.len[mutable uint](v0.storage) == len);
- check (v0.nbits == v1.nbits);
+ assert (_vec.len[mutable uint](v0.storage) == len);
+ assert (v0.nbits == v1.nbits);
auto changed = false;
}
fn get(&t v, uint i) -> bool {
- check (i < v.nbits);
+ assert (i < v.nbits);
auto bits = uint_bits();
}
fn set(&t v, uint i, bool x) {
- check (i < v.nbits);
+ assert (i < v.nbits);
auto bits = uint_bits();
// FIXME: can we just use structural equality on to_vec?
fn eq_vec(&t v0, &vec[uint] v1) -> bool {
- check (v0.nbits == _vec.len[uint](v1));
+ assert (v0.nbits == _vec.len[uint](v1));
auto len = v0.nbits;
auto i = 0u;
while (i < len) {
* elsewhere.
*/
fn grow[T](uint nelts, uint lo, vec[cell[T]] elts) -> vec[cell[T]] {
- check (nelts == _vec.len[cell[T]](elts));
+ assert (nelts == _vec.len[cell[T]](elts));
fn fill[T](uint i, uint nelts, uint lo,
vec[cell[T]] old) -> cell[T] {
fn be_uint_from_bytes(vec[u8] data, uint start, uint size) -> uint {
auto sz = size;
- check (sz <= 4u);
+ assert (sz <= 4u);
auto val = 0u;
auto pos = start;
while (sz > 0u) {
fn dirname(path p) -> path {
auto sep = path_sep();
- check (_str.byte_len(sep) == 1u);
+ assert (_str.byte_len(sep) == 1u);
let int i = _str.rindex(p, sep.(0));
if (i == -1) {
ret p;
ret os.libc.feof(f) != 0;
}
fn seek(int offset, seek_style whence) {
- check (os.libc.fseek(f, offset, convert_whence(whence)) == 0);
+ assert (os.libc.fseek(f, offset, convert_whence(whence)) == 0);
}
fn tell() -> uint {
ret os.libc.ftell(f) as uint;
if (c0 == -1) {ret -1 as char;} // FIXME will this stay valid?
auto b0 = c0 as u8;
auto w = _str.utf8_char_width(b0);
- check(w > 0u);
+ assert (w > 0u);
if (w == 1u) {ret b0 as char;}
auto val = 0u;
while (w > 1u) {
w -= 1u;
auto next = rdr.read_byte();
- check(next > -1);
- check(next & 0xc0 == 0x80);
+ assert (next > -1);
+ assert (next & 0xc0 == 0x80);
val <<= 6u;
val += (next & 0x3f) as uint;
}
}
fn seek(int offset, seek_style whence) {
- check(os.libc.fseek(f, offset, convert_whence(whence)) == 0);
+ assert (os.libc.fseek(f, offset, convert_whence(whence)) == 0);
}
fn tell() -> uint {
fn pipe() -> tup(int, int) {
let vec[mutable int] fds = vec(mutable 0, 0);
- check(os.libc.pipe(_vec.buf[mutable int](fds)) == 0);
+ assert (os.libc.pipe(_vec.buf[mutable int](fds)) == 0);
ret tup(fds.(0), fds.(1));
}
fn waitpid(int pid) -> int {
let vec[mutable int] status = vec(mutable 0);
- check(os.libc.waitpid(pid, _vec.buf[mutable int](status), 0) != -1);
+ assert (os.libc.waitpid(pid, _vec.buf[mutable int](status), 0) != -1);
ret status.(0);
}
fn pipe() -> tup(int, int) {
let vec[mutable int] fds = vec(mutable 0, 0);
- check(os.libc.pipe(_vec.buf[mutable int](fds)) == 0);
+ assert (os.libc.pipe(_vec.buf[mutable int](fds)) == 0);
ret tup(fds.(0), fds.(1));
}
fn waitpid(int pid) -> int {
let vec[mutable int] status = vec(mutable 0);
- check(os.libc.waitpid(pid, _vec.buf[mutable int](status), 0) != -1);
+ assert (os.libc.waitpid(pid, _vec.buf[mutable int](status), 0) != -1);
ret status.(0);
}
fn list_dir(str path) -> vec[str] {
// TODO ensure this is always closed
auto dir = os.libc.opendir(_str.buf(path));
- check (dir as uint != 0u);
+ assert (dir as uint != 0u);
let vec[str] result = vec();
while (true) {
auto ent = os.libc.readdir(dir);
fn add_input(&sha1state st, &vec[u8] msg) {
// FIXME: Should be typestate precondition
- check (!st.computed);
+ assert (!st.computed);
for (u8 element in msg) {
st.msg_block.(st.msg_block_idx) = element;
fn process_msg_block(&sha1state st) {
// FIXME: Make precondition
- check (_vec.len[mutable u32](st.h) == digest_buf_len);
+ assert (_vec.len[mutable u32](st.h) == digest_buf_len);
// Constants
auto k = vec(0x5A827999u32,
*/
fn pad_msg(&sha1state st) {
// FIXME: Should be a precondition
- check (_vec.len[mutable u8](st.msg_block) == msg_block_len);
+ assert (_vec.len[mutable u8](st.msg_block) == msg_block_len);
/*
* Check to see if the current message block is too small to hold
fn reset() {
// FIXME: Should be typestate precondition
- check (_vec.len[mutable u32](st.h) == digest_buf_len);
+ assert (_vec.len[mutable u32](st.h) == digest_buf_len);
st.len_low = 0u32;
st.len_high = 0u32;
fn pipe() -> tup(int, int) {
let vec[mutable int] fds = vec(mutable 0, 0);
- check(os.libc._pipe(_vec.buf[mutable int](fds), 1024u,
+ assert (os.libc._pipe(_vec.buf[mutable int](fds), 1024u,
libc_constants.O_BINARY()) == 0);
ret tup(fds.(0), fds.(1));
}
// error-pattern:1 == 2
fn main() {
- check (1 == 2);
+ assert (1 == 2);
}
// error-pattern:1 == 2
fn child() {
- check (1 == 2);
+ assert (1 == 2);
}
fn main() {
fn main() {
let str s = "hello";
let int x = 0;
- check (s.(x) == (0x68 as u8));
+ assert (s.(x) == (0x68 as u8));
// NB: at the moment a string always has a trailing NULL,
// so the largest index value on the string above is 5, not
// 4. Possibly change this.
// Bounds-check failure.
- check (s.(x + 6) == (0x0 as u8));
+ assert (s.(x + 6) == (0x0 as u8));
}
fn main() {
let vec[int] v = vec(10);
let int x = 0;
- check (v.(x) == 10);
+ assert (v.(x) == 10);
// Bounds-check failure.
- check (v.(x + 2) == 20);
+ assert (v.(x + 2) == 20);
}
fn main() {
let vec[int] v = vec(10, 20);
let int x = 0;
- check (v.(x) == 10);
+ assert (v.(x) == 10);
// Bounds-check failure.
- check (v.(x-1) == 20);
+ assert (v.(x-1) == 20);
}
}
log _str.refcount(s);
- check (_str.refcount(s) == const_refcount);
+ assert (_str.refcount(s) == const_refcount);
}
fn main() {
let str s = "hi"; // ref up
foo(s); // ref up then down
log _str.refcount(s);
- check (_str.refcount(s) == const_refcount);
+ assert (_str.refcount(s) == const_refcount);
}
}
fn main() {
- check (altlit(10) == 20);
- check (altlit(11) == 22);
+ assert (altlit(10) == 20);
+ assert (altlit(11) == 22);
}
let color gray = rgb(127, 127, 127);
let color clear = rgba(50, 150, 250, 0);
let color red = hsl(0, 255, 255);
- check (process(gray) == 127);
- check (process(clear) == 0);
- check (process(red) == 255);
+ assert (process(gray) == 127);
+ assert (process(clear) == 0);
+ assert (process(red) == 255);
}
fn main() -> () {
let int a = 10;
log a;
- check (a * (a - 1) == 90);
+ assert (a * (a - 1) == 90);
}
\ No newline at end of file
fn main() -> () {
let int i32_a = 10;
- check(i32_a == 10);
- check(i32_a - 10 == 0);
- check(i32_a / 10 == 1);
- check(i32_a - 20 == -10);
- check(i32_a << 10 == 10240);
- check(i32_a << 16 == 655360);
- check(i32_a * 16 == 160);
- check(i32_a * i32_a * i32_a == 1000);
- check(i32_a * i32_a * i32_a * i32_a == 10000);
- check(((i32_a * i32_a) / i32_a) * i32_a == 100);
- check(i32_a * (i32_a - 1) << 2 + i32_a == 368640);
+ assert (i32_a == 10);
+ assert (i32_a - 10 == 0);
+ assert (i32_a / 10 == 1);
+ assert (i32_a - 20 == -10);
+ assert (i32_a << 10 == 10240);
+ assert (i32_a << 16 == 655360);
+ assert (i32_a * 16 == 160);
+ assert (i32_a * i32_a * i32_a == 1000);
+ assert (i32_a * i32_a * i32_a * i32_a == 10000);
+ assert (((i32_a * i32_a) / i32_a) * i32_a == 100);
+ assert (i32_a * (i32_a - 1) << 2 + i32_a == 368640);
let int i32_b = 0x10101010;
- check(i32_b + 1 - 1 == i32_b);
- check(i32_b << 1 == i32_b << 1);
- check(i32_b >> 1 == i32_b >> 1);
- check((i32_b & (i32_b << 1)) == 0);
+ assert (i32_b + 1 - 1 == i32_b);
+ assert (i32_b << 1 == i32_b << 1);
+ assert (i32_b >> 1 == i32_b >> 1);
+ assert ((i32_b & (i32_b << 1)) == 0);
log ((i32_b | (i32_b << 1)));
- check((i32_b | (i32_b << 1)) == 0x30303030);
+ assert ((i32_b | (i32_b << 1)) == 0x30303030);
}
\ No newline at end of file
fn main() -> () {
let int i32_c = 0x10101010;
- check (i32_c + i32_c * 2 / 3 * 2 + (i32_c - 7 % 3) ==
+ assert (i32_c + i32_c * 2 / 3 * 2 + (i32_c - 7 % 3) ==
i32_c + (((i32_c * 2) / 3) * 2) + (i32_c - (7 % 3)));
}
\ No newline at end of file
// Unsigned integer operations
fn main() {
- check (0u8 < 255u8);
- check (0u8 <= 255u8);
- check (255u8 > 0u8);
- check (255u8 >= 0u8);
- check (250u8 / 10u8 == 25u8);
- check (255u8 % 10u8 == 5u8);
- check (0u16 < 60000u16);
- check (0u16 <= 60000u16);
- check (60000u16 > 0u16);
- check (60000u16 >= 0u16);
- check (60000u16 / 10u16 == 6000u16);
- check (60005u16 % 10u16 == 5u16);
- check (0u32 < 4000000000u32);
- check (0u32 <= 4000000000u32);
- check (4000000000u32 > 0u32);
- check (4000000000u32 >= 0u32);
- check (4000000000u32 / 10u32 == 400000000u32);
- check (4000000005u32 % 10u32 == 5u32);
+ assert (0u8 < 255u8);
+ assert (0u8 <= 255u8);
+ assert (255u8 > 0u8);
+ assert (255u8 >= 0u8);
+ assert (250u8 / 10u8 == 25u8);
+ assert (255u8 % 10u8 == 5u8);
+ assert (0u16 < 60000u16);
+ assert (0u16 <= 60000u16);
+ assert (60000u16 > 0u16);
+ assert (60000u16 >= 0u16);
+ assert (60000u16 / 10u16 == 6000u16);
+ assert (60005u16 % 10u16 == 5u16);
+ assert (0u32 < 4000000000u32);
+ assert (0u32 <= 4000000000u32);
+ assert (4000000000u32 > 0u32);
+ assert (4000000000u32 >= 0u32);
+ assert (4000000000u32 / 10u32 == 400000000u32);
+ assert (4000000005u32 % 10u32 == 5u32);
// 64-bit numbers have some flakiness yet. Not tested
}
let clam b = rec(x=@10, y=@20);
let int z = a.x + b.y;
log z;
- check (z == 21);
+ assert (z == 21);
let fish forty = tup(@40);
let fish two = tup(@2);
let int answer = forty._0 + two._0;
log answer;
- check (answer == 42);
+ assert (answer == 42);
}
fn main() {
auto f1 = bind foo(@10, @12);
- check(f1() == 22);
+ assert (f1() == 22);
}
fn main() {
let fn() -> int g = bind f(10);
let int i = g();
- check(i == 10);
+ assert (i == 10);
}
auto ctor1 = bind simple(_, 2);
auto obj1 = ctor0(2);
auto obj2 = ctor1(1);
- check (obj0.sum() == 3);
- check (obj1.sum() == 3);
- check (obj2.sum() == 3);
+ assert (obj0.sum() == 3);
+ assert (obj1.sum() == 3);
+ assert (obj2.sum() == 3);
}
fn main() {
let fn() -> int g = bind f();
let int i = g();
- check(i == 42);
+ assert (i == 42);
}
fn main() {
let fn(int) -> int g = bind f(_);
let int i = g(42);
- check(i == 42);
+ assert (i == 42);
}
a = a ^ b;
log a;
log b;
- check (b == 1);
- check (a == 2);
+ assert (b == 1);
+ assert (a == 2);
- check (~(0xf0) & 0xff == 0xf);
- check (0xf0 | 0xf == 0xff);
- check (0xf << 4 == 0xf0);
- check (0xf0 >> 4 == 0xf);
- check (-16 >>> 2 == -4);
- check (0b1010_1010 | 0b0101_0101 == 0xff);
+ assert (~(0xf0) & 0xff == 0xf);
+ assert (0xf0 | 0xf == 0xff);
+ assert (0xf << 4 == 0xf0);
+ assert (0xf0 >> 4 == 0xf);
+ assert (-16 >>> 2 == -4);
+ assert (0b1010_1010 | 0b0101_0101 == 0xff);
}
fn main() {
if (!false) {
- check (true);
+ assert (true);
} else {
- check (false);
+ assert (false);
}
if (!true) {
- check (false);
+ assert (false);
} else {
- check (true);
+ assert (true);
}
}
// xfail-boot
fn main() {
- check (@1 < @3);
- check (@@"hello " > @@"hello");
- check (@@@"hello" != @@@"there");
+ assert (@1 < @3);
+ assert (@@"hello " > @@"hello");
+ assert (@@@"hello" != @@@"there");
}
\ No newline at end of file
let int foo = 17;
let box[int] bfoo = tup(@foo);
log "see what's in our box";
- check (unbox[int](bfoo) == foo);
+ assert (unbox[int](bfoo) == foo);
}
fn main() {
let @int x = @10;
- check ((*x) == 10);
+ assert ((*x) == 10);
}
i += 1;
if (i == 10) { break; }
}
- check(i == 10);
+ assert (i == 10);
do {
i += 1;
if (i == 20) { break; }
} while (i < 30);
- check(i == 20);
+ assert (i == 20);
for (int x in vec(1, 2, 3, 4, 5, 6)) {
if (x == 3) { break; }
- check(x <= 3);
+ assert (x <= 3);
}
i = 0;
while (i < 10) {
i += 1;
if (i % 2 == 0) { cont; }
- check(i % 2 != 0);
+ assert (i % 2 != 0);
}
i = 0;
do {
i += 1;
if (i % 2 == 0) { cont; }
- check(i % 2 != 0);
+ assert (i % 2 != 0);
} while (i < 10);
for (int x in vec(1, 2, 3, 4, 5, 6)) {
if (x % 2 == 0) { cont; }
- check(x % 2 != 0);
+ assert (x % 2 != 0);
}
}
fn main() {
let int i = 'Q' as int;
- check (i == 0x51);
+ assert (i == 0x51);
let u32 u = i as u32;
- check (u == (0x51 as u32));
- check (u == ('Q' as u32));
- check ((i as u8) == ('Q' as u8));
- check (((i as u8) as i8) == (('Q' as u8) as i8));
- check ((0x51 as char) == 'Q');
+ assert (u == (0x51 as u32));
+ assert (u == ('Q' as u32));
+ assert ((i as u8) == ('Q' as u8));
+ assert (((i as u8) as i8) == (('Q' as u8) as i8));
+ assert ((0x51 as char) == 'Q');
- check (true == (1 as bool));
- check ((0 as u32) == (false as u32));
+ assert (true == (1 as bool));
+ assert ((0 as u32) == (false as u32));
}
fn main() {
let char c = 'x';
let char d = 'x';
- check(c == 'x');
- check('x' == c);
- check(c == c);
- check(c == d);
- check(d == c);
- check (d == 'x');
- check('x' == d);
+ assert (c == 'x');
+ assert ('x' == c);
+ assert (c == c);
+ assert (c == d);
+ assert (d == c);
+ assert (d == 'x');
+ assert ('x' == d);
}
// xfail-boot
// xfail-stage0
fn f(@rec(int a, int b) x) {
- check (x.a == 10);
- check (x.b == 12);
+ assert (x.a == 10);
+ assert (x.b == 12);
}
fn main() {
y <- p;
log "received";
log y;
- check (y == 10);
+ assert (y == 10);
}
fn child(chan[int] c) {
ch <| 10;
let int i <- po;
- check (i == 10);
+ assert (i == 10);
ch <| 11;
auto j <- po;
- check (j == 11);
+ assert (j == 11);
}
}
fn main() {
- check (f(5000) == 5000);
+ assert (f(5000) == 5000);
}
fn main() {
let int x = 15;
let int y = 5;
- check(x / 5 == 3);
- check(x / 4 == 3);
- check(x / 3 == 5);
- check(x / y == 3);
- check(15 / y == 3);
+ assert (x / 5 == 3);
+ assert (x / 4 == 3);
+ assert (x / 3 == 5);
+ assert (x / y == 3);
+ assert (15 / y == 3);
- check(x % 5 == 0);
- check(x % 4 == 3);
- check(x % 3 == 0);
- check(x % y == 0);
- check(15 % y == 0);
+ assert (x % 5 == 0);
+ assert (x % 4 == 3);
+ assert (x % 3 == 0);
+ assert (x % y == 0);
+ assert (15 % y == 0);
}
fn main() {
if (1 == 2) {
- check(false);
+ assert (false);
} else if (2 == 3) {
- check(false);
+ assert (false);
} else if (3 == 4) {
- check(false);
+ assert (false);
} else {
- check(true);
+ assert (true);
}
if (1 == 2) {
- check(false);
+ assert (false);
} else if (2 == 2) {
- check(true);
+ assert (true);
}
if (1 == 2) {
- check(false);
+ assert (false);
} else if (2 == 2) {
if (1 == 1) {
- check(true);
+ assert (true);
} else {
if (2 == 1) {
- check(false);
+ assert (false);
} else {
- check(false);
+ assert (false);
}
}
}
if (1 == 2) {
- check(false);
+ assert (false);
} else {
if (1 == 2) {
- check(false);
+ assert (false);
} else {
- check(true);
+ assert (true);
}
}
}
@100
}
};
- check (*res == 100);
+ assert (*res == 100);
}
fn test_str() {
"happy"
}
};
- check (res == "happy");
+ assert (res == "happy");
}
fn main() {
expected
}
};
- check (eq(expected, actual));
+ assert (eq(expected, actual));
}
fn test_box() {
expected
}
};
- check (eq(expected, actual));
+ assert (eq(expected, actual));
}
fn test_vec() {
expected
}
};
- check (eq(expected, actual));
+ assert (eq(expected, actual));
}
fn test_bool() {
rec(i = 100)
}
};
- check (res == rec(i = 100));
+ assert (res == rec(i = 100));
}
fn test_tag() {
sad
}
};
- check (res == happy);
+ assert (res == happy);
}
fn main() {
false
}
};
- check (res);
+ assert (res);
res = alt(false) {
case (true) {
true
}
};
- check (res);
+ assert (res);
}
fn test_inferrence() {
false
}
};
- check (res);
+ assert (res);
}
fn test_alt_as_alt_head() {
true
}
};
- check (res);
+ assert (res);
}
fn test_alt_as_block_result() {
}
}
};
- check (res);
+ assert (res);
}
fn main() {
@100
};
- check (*x == 100);
+ assert (*x == 100);
}
ret 10;
}
let t res = { ten };
- check (res() == 10);
+ assert (res() == 10);
}
fn main() {
fn test_generic[T](@T expected, &compare[T] eq) {
let @T actual = { expected };
- check (eq(expected, actual));
+ assert (eq(expected, actual));
}
fn test_box() {
fn test_generic[T](&T expected, &compare[T] eq) {
let T actual = { expected };
- check (eq(expected, actual));
+ assert (eq(expected, actual));
}
fn test_vec() {
fn test_generic[T](&T expected, &compare[T] eq) {
let T actual = { expected };
- check (eq(expected, actual));
+ assert (eq(expected, actual));
}
fn test_bool() {
fn test_basic() {
let bool res = { true };
- check (res);
+ assert (res);
}
fn test_rec() {
auto res = { rec(v1 = 10, v2 = 20) };
- check (res.v2 == 20);
+ assert (res.v2 == 20);
}
fn test_filled_with_stuff() {
}
a
};
- check (res == 10);
+ assert (res == 10);
}
fn main() {
fn test_box() {
auto res = if (true) { @100 } else { @101 };
- check (*res == 100);
+ assert (*res == 100);
}
fn test_str() {
auto res = if (true) { "happy" } else { "sad" };
- check (res == "happy");
+ assert (res == "happy");
}
fn main() {
fn test_generic[T](@T expected, @T not_expected, &compare[T] eq) {
let @T actual = if (true) { expected } else { not_expected };
- check (eq(expected, actual));
+ assert (eq(expected, actual));
}
fn test_box() {
fn test_generic[T](&T expected, &T not_expected, &compare[T] eq) {
let T actual = if (true) { expected } else { not_expected };
- check (eq(expected, actual));
+ assert (eq(expected, actual));
}
fn test_vec() {
fn test_generic[T](&T expected, &T not_expected, &compare[T] eq) {
let T actual = if (true) { expected } else { not_expected };
- check (eq(expected, actual));
+ assert (eq(expected, actual));
}
fn test_bool() {
fn test_rec() {
auto res = if (true) { rec(i = 100) } else { rec(i = 101) };
- check (res == rec(i = 100));
+ assert (res == rec(i = 100));
}
fn test_tag() {
}
auto res = if (true) { happy } else { sad };
- check (res == happy);
+ assert (res == happy);
}
fn main() {
fn test_if() {
let bool res = if (true) { true } else { false };
- check (res);
+ assert (res);
}
fn test_else() {
let bool res = if (false) { false } else { true };
- check (res);
+ assert (res);
}
fn test_elseif1() {
} else {
false
};
- check (res);
+ assert (res);
}
fn test_elseif2() {
} else {
false
};
- check (res);
+ assert (res);
}
fn test_elseif3() {
} else {
true
};
- check (res);
+ assert (res);
}
fn test_inferrence() {
auto res = if (true) { true } else { false };
- check (res);
+ assert (res);
}
fn test_if_as_if_condition() {
} else {
false
};
- check (res1);
+ assert (res1);
auto res2 = if (if (true) { false } else { true }) {
false
} else {
true
};
- check (res2);
+ assert (res2);
}
fn test_if_as_block_result() {
} else {
false
};
- check (res);
+ assert (res);
}
fn main() {
type point = rec(int x, int y, mutable int z);
fn f(@point p) {
- check (p.z == 12);
+ assert (p.z == 12);
p.z = 13;
- check (p.z == 13);
+ assert (p.z == 13);
}
fn main() {
let point a = rec(x=10, y=11, mutable z=12);
let @point b = @a;
- check (b.z == 12);
+ assert (b.z == 12);
f(b);
- check (a.z == 12);
- check (b.z == 13);
+ assert (a.z == 12);
+ assert (b.z == 13);
}
}
}
fn main () {
- check (f(5) == 120);
+ assert (f(5) == 120);
// log "all done";
}
auto j = 3.1e+9;
auto k = 3.2e-10;
- check(a == b);
- check(c < b);
- check(c == d);
- check(e < g);
- check(f < h);
- check(g == 1000000.0f32);
- check(h == i);
- check(j > k);
- check(k < a);
+ assert (a == b);
+ assert (c < b);
+ assert (c == d);
+ assert (e < g);
+ assert (f < h);
+ assert (g == 1000000.0f32);
+ assert (h == i);
+ assert (j > k);
+ assert (k < a);
}
\ No newline at end of file
// xfail-boot
fn main() {
auto f = 4.999999999999;
- check (f > 4.90);
- check (f < 5.0);
+ assert (f > 4.90);
+ assert (f < 5.0);
auto g = 4.90000000001e-10;
- check(g > 5e-11);
- check(g < 5e-9);
+ assert (g > 5e-11);
+ assert (g < 5e-9);
}
\ No newline at end of file
}
}
- check (a.(0) == 0);
- check (a.(1) == 1);
- check (a.(2) == 10);
- check (a.(3) == 11);
- check (a.(4) == 100);
- check (a.(5) == 101);
- check (a.(6) == 110);
- check (a.(7) == 111);
+ assert (a.(0) == 0);
+ assert (a.(1) == 1);
+ assert (a.(2) == 10);
+ assert (a.(3) == 11);
+ assert (a.(4) == 100);
+ assert (a.(5) == 101);
+ assert (a.(6) == 110);
+ assert (a.(7) == 111);
}
}
}
- check (a.(0) == 0);
- check (a.(1) == 1);
- check (a.(2) == 10);
- check (a.(3) == 11);
+ assert (a.(0) == 0);
+ assert (a.(1) == 1);
+ assert (a.(2) == 10);
+ assert (a.(3) == 11);
}
for each (tup(int,int) p in pairs()) {
log p._0;
log p._1;
- check (p._0 + 10 == i);
+ assert (p._0 + 10 == i);
i += 1;
j = p._1;
}
- check(j == 45);
+ assert (j == 45);
}
\ No newline at end of file
}
log "sum";
log sum;
- check (sum == 45);
+ assert (sum == 45);
}
iter first_ten() -> int {
let int a = direct(3); // direct
//let int b = ho(direct); // indirect unbound
let int c = ho(bind direct(_)); // indirect bound
- //check(a == b);
- //check(b == c);
+ //assert (a == b);
+ //assert (b == c);
}
fn main() {
let fn() -> int g = f;
let int i = g();
- check(i == 42);
+ assert (i == 42);
}
auto expected = @100;
auto actual = id[@int](expected);
log *actual;
- check (*expected == *actual);
+ assert (*expected == *actual);
}
\ No newline at end of file
fn main() {
auto t = tup(1,2,3,4,5,6,7);
- check (t._5 == 6);
+ assert (t._5 == 6);
auto f0 = bind id[tup(int,int,int,int,int,int,int)](t);
- check (f0()._5 == 6);
+ assert (f0()._5 == 6);
}
fn main() {
auto t = tup(1,2,3,4,5,6,7);
- check (t._5 == 6);
+ assert (t._5 == 6);
auto f1 = bind id[tup(int,int,int,int,int,int,int)](_);
- check (f1(t)._5 == 6);
+ assert (f1(t)._5 == 6);
}
fn main() {
let @tup(int,int,int) x = box[int](tup(1,2,3));
- check (x._1 == 2);
+ assert (x._1 == 2);
}
\ No newline at end of file
auto b = f[int](10);
log b._0;
log b._1;
- check (b._0 == 10);
- check (b._1 == 10);
+ assert (b._0 == 10);
+ assert (b._1 == 10);
}
let int foo = 17;
let tupbox[int] tbfoo = tuplift[int](foo);
let recbox[int] rbfoo = reclift[int](foo);
- check (tbfoo._0 == foo);
- check (rbfoo.x == foo);
+ assert (tbfoo._0 == foo);
+ assert (rbfoo.x == foo);
}
fn main() {
let int x = 42;
let int y = id(x);
- check (x == y);
+ assert (x == y);
}
y = id[int](x);
log y;
- check (x == y);
+ assert (x == y);
b = id[char](a);
log b;
- check (a == b);
+ assert (a == b);
q = id[triple](p);
x = p._2;
y = q._2;
log y;
- check (x == y);
+ assert (x == y);
}
log h.get()._0;
log h.get()._1;
log h.get()._2;
- check (h.get()._0 == (1 as u8));
- check (h.get()._1 == (2 as u8));
- check (h.get()._2 == (3 as u8));
+ assert (h.get()._0 == (1 as u8));
+ assert (h.get()._1 == (2 as u8));
+ assert (h.get()._2 == (3 as u8));
}
log b.get(0);
log b.get(1);
log b.get(2);
- check (b.get(0) == 1);
- check (b.get(1) == 2);
- check (b.get(2) == 3);
+ assert (b.get(0) == 1);
+ assert (b.get(1) == 2);
+ assert (b.get(2) == 3);
b.take2(0);
}
hit = true;
}
}
- check (hit);
+ assert (hit);
}
fn main() {
alt (nop) {
case (some[int](?n)) {
log n;
- check (n == 5);
+ assert (n == 5);
}
}
case (some[tup(int, int)](?t)) {
log t._0;
log t._1;
- check (t._0 == 17);
- check (t._1 == 42);
+ assert (t._0 == 17);
+ assert (t._1 == 42);
}
}
}
fn chk(&int a) {
log a;
- check (a == 1);
+ assert (a == 1);
}
fn apply[T](fn() -> T produce, fn(&T) consume) {
fn main() {
log get_third(tup(1,2,3));
- check (get_third(tup(1,2,3)) == 3);
- check (get_third(tup(5u8,6u8,7u8)) == 7u8);
+ assert (get_third(tup(1,2,3)) == 3);
+ assert (get_third(tup(5u8,6u8,7u8)) == 7u8);
}
\ No newline at end of file
type pair[T] = tup(T,T);
fn main() {
let pair[int] x = tup(10,12);
- check (x._0 == 10);
- check (x._1 == 12);
+ assert (x._0 == 10);
+ assert (x._1 == 12);
}
fn main() {
let i32 x = -400_i32;
x = 0_i32 - x;
- check(x == 400_i32);
+ assert (x == 400_i32);
}
let i8 y = -12i8;
x = x + 1i8;
x = x - 1i8;
- check(x == y);
+ assert (x == y);
}
let vec[int] v = vec(0, 1, 2, 3, 4, 5);
let str s = "abcdef";
- check (v.(3u) == 3);
- check (v.(3u8) == 3);
- check (v.(3i8) == 3);
- check (v.(3u32) == 3);
- check (v.(3i32) == 3);
+ assert (v.(3u) == 3);
+ assert (v.(3u8) == 3);
+ assert (v.(3i8) == 3);
+ assert (v.(3u32) == 3);
+ assert (v.(3i32) == 3);
log v.(3u8);
- check (s.(3u) == 'd' as u8);
- check (s.(3u8) == 'd' as u8);
- check (s.(3i8) == 'd' as u8);
- check (s.(3u32) == 'd' as u8);
- check (s.(3i32) == 'd' as u8);
+ assert (s.(3u) == 'd' as u8);
+ assert (s.(3u8) == 'd' as u8);
+ assert (s.(3i8) == 'd' as u8);
+ assert (s.(3u32) == 'd' as u8);
+ assert (s.(3i32) == 'd' as u8);
log s.(3u8);
}
\ No newline at end of file
iter range(int a, int b) -> int {
- check (a < b);
+ assert (a < b);
let int i = a;
while (i < b) {
fn incr(& mutable int x) -> bool {
x += 1;
- check (false);
+ assert (false);
ret false;
}
fn main() {
auto x = (1 == 2) || (3 == 3);
- check (x);
+ assert (x);
let int y = 10;
log x || incr(y);
- check (y == 10);
+ assert (y == 10);
if (true && x) {
- check (true);
+ assert (true);
} else {
- check (false);
+ assert (false);
}
}
\ No newline at end of file
y <- p;
log "received 1";
log y;
- check (y == 10);
+ assert (y == 10);
spawn child(c);
y <- p;
log "received 2";
log y;
- check (y == 10);
+ assert (y == 10);
}
fn child(chan[int] c) {
act = bitv.create(0u, false);
exp = _vec.init_elt[uint](0u, 0u);
// FIXME: why can't I write vec[uint]()?
- check (bitv.eq_vec(act, exp));
+ assert (bitv.eq_vec(act, exp));
}
fn test_1_element() {
auto act;
act = bitv.create(1u, false);
- check (bitv.eq_vec(act, vec(0u)));
+ assert (bitv.eq_vec(act, vec(0u)));
act = bitv.create(1u, true);
- check (bitv.eq_vec(act, vec(1u)));
+ assert (bitv.eq_vec(act, vec(1u)));
}
fn test_10_elements() {
// all 0
act = bitv.create(10u, false);
- check (bitv.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u)));
+ assert (bitv.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u)));
// all 1
act = bitv.create(10u, true);
- check (bitv.eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u)));
+ assert (bitv.eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u)));
// mixed
act = bitv.create(10u, false);
bitv.set(act, 2u, true);
bitv.set(act, 3u, true);
bitv.set(act, 4u, true);
- check (bitv.eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 0u, 0u, 0u, 0u, 0u)));
+ assert (bitv.eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 0u, 0u, 0u, 0u, 0u)));
// mixed
act = bitv.create(10u, false);
bitv.set(act, 7u, true);
bitv.set(act, 8u, true);
bitv.set(act, 9u, true);
- check (bitv.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 1u, 1u, 1u, 1u, 1u)));
+ assert (bitv.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 1u, 1u, 1u, 1u, 1u)));
// mixed
act = bitv.create(10u, false);
bitv.set(act, 3u, true);
bitv.set(act, 6u, true);
bitv.set(act, 9u, true);
- check (bitv.eq_vec(act, vec(1u, 0u, 0u, 1u, 0u, 0u, 1u, 0u, 0u, 1u)));
+ assert (bitv.eq_vec(act, vec(1u, 0u, 0u, 1u, 0u, 0u, 1u, 0u, 0u, 1u)));
}
fn test_31_elements() {
// all 0
act = bitv.create(31u, false);
- check (bitv.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+ assert (bitv.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u)));
// all 1
act = bitv.create(31u, true);
- check (bitv.eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
+ assert (bitv.eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
1u, 1u, 1u, 1u, 1u, 1u, 1u)));
bitv.set(act, 5u, true);
bitv.set(act, 6u, true);
bitv.set(act, 7u, true);
- check (bitv.eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
+ assert (bitv.eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u)));
bitv.set(act, 21u, true);
bitv.set(act, 22u, true);
bitv.set(act, 23u, true);
- check (bitv.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+ assert (bitv.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
0u, 0u, 0u, 0u, 0u, 0u, 0u)));
bitv.set(act, 28u, true);
bitv.set(act, 29u, true);
bitv.set(act, 30u, true);
- check (bitv.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+ assert (bitv.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
1u, 1u, 1u, 1u, 1u, 1u, 1u)));
bitv.set(act, 3u, true);
bitv.set(act, 17u, true);
bitv.set(act, 30u, true);
- check (bitv.eq_vec(act, vec(0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u,
+ assert (bitv.eq_vec(act, vec(0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 1u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 1u)));
// all 0
act = bitv.create(32u, false);
- check (bitv.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+ assert (bitv.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u)));
// all 1
act = bitv.create(32u, true);
- check (bitv.eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
+ assert (bitv.eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u)));
bitv.set(act, 5u, true);
bitv.set(act, 6u, true);
bitv.set(act, 7u, true);
- check (bitv.eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
+ assert (bitv.eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u)));
bitv.set(act, 21u, true);
bitv.set(act, 22u, true);
bitv.set(act, 23u, true);
- check (bitv.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+ assert (bitv.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u)));
bitv.set(act, 29u, true);
bitv.set(act, 30u, true);
bitv.set(act, 31u, true);
- check (bitv.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+ assert (bitv.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u)));
bitv.set(act, 17u, true);
bitv.set(act, 30u, true);
bitv.set(act, 31u, true);
- check (bitv.eq_vec(act, vec(0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u,
+ assert (bitv.eq_vec(act, vec(0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 1u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 1u, 1u)));
// all 0
act = bitv.create(33u, false);
- check (bitv.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+ assert (bitv.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
// all 1
act = bitv.create(33u, true);
- check (bitv.eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
+ assert (bitv.eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
bitv.set(act, 5u, true);
bitv.set(act, 6u, true);
bitv.set(act, 7u, true);
- check (bitv.eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
+ assert (bitv.eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
bitv.set(act, 21u, true);
bitv.set(act, 22u, true);
bitv.set(act, 23u, true);
- check (bitv.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+ assert (bitv.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
bitv.set(act, 29u, true);
bitv.set(act, 30u, true);
bitv.set(act, 31u, true);
- check (bitv.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
+ assert (bitv.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u,
bitv.set(act, 30u, true);
bitv.set(act, 31u, true);
bitv.set(act, 32u, true);
- check (bitv.eq_vec(act, vec(0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u,
+ assert (bitv.eq_vec(act, vec(0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 1u, 0u, 0u, 0u, 0u, 0u, 0u,
0u, 0u, 0u, 0u, 0u, 0u, 1u, 1u,
fn main() {
auto x = @3;
auto y = @3;
- check (Box.ptr_eq[int](x, x));
- check (Box.ptr_eq[int](y, y));
- check (!Box.ptr_eq[int](x, y));
- check (!Box.ptr_eq[int](y, x));
+ assert (Box.ptr_eq[int](x, x));
+ assert (Box.ptr_eq[int](y, y));
+ assert (!Box.ptr_eq[int](x, y));
+ assert (!Box.ptr_eq[int](y, x));
}
fn test_simple() {
let deque.t[int] d = deque.create[int]();
- check (d.size() == 0u);
+ assert (d.size() == 0u);
d.add_front(17);
d.add_front(42);
d.add_back(137);
- check (d.size() == 3u);
+ assert (d.size() == 3u);
d.add_back(137);
- check (d.size() == 4u);
+ assert (d.size() == 4u);
log d.peek_front();
- check (d.peek_front() == 42);
+ assert (d.peek_front() == 42);
log d.peek_back();
- check (d.peek_back() == 137);
+ assert (d.peek_back() == 137);
let int i = d.pop_front();
log i;
- check (i == 42);
+ assert (i == 42);
i = d.pop_back();
log i;
- check (i == 137);
+ assert (i == 137);
i = d.pop_back();
log i;
- check (i == 137);
+ assert (i == 137);
i = d.pop_back();
log i;
- check (i == 17);
+ assert (i == 17);
- check (d.size() == 0u);
+ assert (d.size() == 0u);
d.add_back(3);
- check (d.size() == 1u);
+ assert (d.size() == 1u);
d.add_front(2);
- check (d.size() == 2u);
+ assert (d.size() == 2u);
d.add_back(4);
- check (d.size() == 3u);
+ assert (d.size() == 3u);
d.add_front(1);
- check (d.size() == 4u);
+ assert (d.size() == 4u);
log d.get(0);
log d.get(1);
log d.get(2);
log d.get(3);
- check (d.get(0) == 1);
- check (d.get(1) == 2);
- check (d.get(2) == 3);
- check (d.get(3) == 4);
+ assert (d.get(0) == 1);
+ assert (d.get(1) == 2);
+ assert (d.get(2) == 3);
+ assert (d.get(3) == 4);
}
fn test_boxes(@int a, @int b, @int c, @int d) {
let deque.t[@int] deq = deque.create[@int]();
- check (deq.size() == 0u);
+ assert (deq.size() == 0u);
deq.add_front(a);
deq.add_front(b);
deq.add_back(c);
- check (deq.size() == 3u);
+ assert (deq.size() == 3u);
deq.add_back(d);
- check (deq.size() == 4u);
+ assert (deq.size() == 4u);
- check (deq.peek_front() == b);
- check (deq.peek_back() == d);
+ assert (deq.peek_front() == b);
+ assert (deq.peek_back() == d);
- check (deq.pop_front() == b);
- check (deq.pop_back() == d);
- check (deq.pop_back() == c);
- check (deq.pop_back() == a);
+ assert (deq.pop_front() == b);
+ assert (deq.pop_back() == d);
+ assert (deq.pop_back() == c);
+ assert (deq.pop_back() == a);
- check (deq.size() == 0u);
+ assert (deq.size() == 0u);
deq.add_back(c);
- check (deq.size() == 1u);
+ assert (deq.size() == 1u);
deq.add_front(b);
- check (deq.size() == 2u);
+ assert (deq.size() == 2u);
deq.add_back(d);
- check (deq.size() == 3u);
+ assert (deq.size() == 3u);
deq.add_front(a);
- check (deq.size() == 4u);
+ assert (deq.size() == 4u);
- check (deq.get(0) == a);
- check (deq.get(1) == b);
- check (deq.get(2) == c);
- check (deq.get(3) == d);
+ assert (deq.get(0) == a);
+ assert (deq.get(1) == b);
+ assert (deq.get(2) == c);
+ assert (deq.get(3) == d);
}
type eqfn[T] = fn(&T a, &T b) -> bool;
fn test_parameterized[T](eqfn[T] e, &T a, &T b, &T c, &T d) {
let deque.t[T] deq = deque.create[T]();
- check (deq.size() == 0u);
+ assert (deq.size() == 0u);
deq.add_front(a);
deq.add_front(b);
deq.add_back(c);
- check (deq.size() == 3u);
+ assert (deq.size() == 3u);
deq.add_back(d);
- check (deq.size() == 4u);
+ assert (deq.size() == 4u);
- check (e(deq.peek_front(), b));
- check (e(deq.peek_back(), d));
+ assert (e(deq.peek_front(), b));
+ assert (e(deq.peek_back(), d));
- check (e(deq.pop_front(), b));
- check (e(deq.pop_back(), d));
- check (e(deq.pop_back(), c));
- check (e(deq.pop_back(), a));
+ assert (e(deq.pop_front(), b));
+ assert (e(deq.pop_back(), d));
+ assert (e(deq.pop_back(), c));
+ assert (e(deq.pop_back(), a));
- check (deq.size() == 0u);
+ assert (deq.size() == 0u);
deq.add_back(c);
- check (deq.size() == 1u);
+ assert (deq.size() == 1u);
deq.add_front(b);
- check (deq.size() == 2u);
+ assert (deq.size() == 2u);
deq.add_back(d);
- check (deq.size() == 3u);
+ assert (deq.size() == 3u);
deq.add_front(a);
- check (deq.size() == 4u);
+ assert (deq.size() == 4u);
- check (e(deq.get(0), a));
- check (e(deq.get(1), b));
- check (e(deq.get(2), c));
- check (e(deq.get(3), d));
+ assert (e(deq.get(0), a));
+ assert (e(deq.get(1), b));
+ assert (e(deq.get(2), c));
+ assert (e(deq.get(3), d));
}
tag taggy {
import std._str.eq;
fn test_to_str() {
- check (eq(_int.to_str(0, 10u), "0"));
- check (eq(_int.to_str(1, 10u), "1"));
- check (eq(_int.to_str(-1, 10u), "-1"));
- check (eq(_int.to_str(255, 16u), "ff"));
- check (eq(_int.to_str(100, 10u), "100"));
+ assert (eq(_int.to_str(0, 10u), "0"));
+ assert (eq(_int.to_str(1, 10u), "1"));
+ assert (eq(_int.to_str(-1, 10u), "-1"));
+ assert (eq(_int.to_str(255, 16u), "ff"));
+ assert (eq(_int.to_str(100, 10u), "100"));
}
fn test_pow() {
- check (_int.pow(0, 0u) == 1);
- check (_int.pow(0, 1u) == 0);
- check (_int.pow(0, 2u) == 0);
- check (_int.pow(-1, 0u) == -1);
- check (_int.pow(1, 0u) == 1);
- check (_int.pow(-3, 2u) == 9);
- check (_int.pow(-3, 3u) == -27);
- check (_int.pow(4, 9u) == 262144);
+ assert (_int.pow(0, 0u) == 1);
+ assert (_int.pow(0, 1u) == 0);
+ assert (_int.pow(0, 2u) == 0);
+ assert (_int.pow(-1, 0u) == -1);
+ assert (_int.pow(1, 0u) == 1);
+ assert (_int.pow(-3, 2u) == 9);
+ assert (_int.pow(-3, 3u) == -27);
+ assert (_int.pow(4, 9u) == 262144);
}
fn main() {
let io.reader inp = io.file_reader(tmpfile);
let str frood2 = inp.read_c_str();
log frood2;
- check (_str.eq(frood, frood2));
+ assert (_str.eq(frood, frood2));
}
fn main(vec[str] argv) {
let map.hashmap[uint, uint] hm_uu = map.mk_hashmap[uint, uint](hasher_uint,
eqer_uint);
- check (hm_uu.insert(10u, 12u));
- check (hm_uu.insert(11u, 13u));
- check (hm_uu.insert(12u, 14u));
+ assert (hm_uu.insert(10u, 12u));
+ assert (hm_uu.insert(11u, 13u));
+ assert (hm_uu.insert(12u, 14u));
- check (hm_uu.get(11u) == 13u);
- check (hm_uu.get(12u) == 14u);
- check (hm_uu.get(10u) == 12u);
+ assert (hm_uu.get(11u) == 13u);
+ assert (hm_uu.get(12u) == 14u);
+ assert (hm_uu.get(10u) == 12u);
- check (!hm_uu.insert(12u, 14u));
- check (hm_uu.get(12u) == 14u);
+ assert (!hm_uu.insert(12u, 14u));
+ assert (hm_uu.get(12u) == 14u);
- check (!hm_uu.insert(12u, 12u));
- check (hm_uu.get(12u) == 12u);
+ assert (!hm_uu.insert(12u, 12u));
+ assert (hm_uu.get(12u) == 12u);
let str ten = "ten";
let map.hashmap[str, uint] hm_su = map.mk_hashmap[str, uint](hasher_str,
eqer_str);
- check (hm_su.insert("ten", 12u));
- check (hm_su.insert(eleven, 13u));
- check (hm_su.insert("twelve", 14u));
+ assert (hm_su.insert("ten", 12u));
+ assert (hm_su.insert(eleven, 13u));
+ assert (hm_su.insert("twelve", 14u));
- check (hm_su.get(eleven) == 13u);
+ assert (hm_su.get(eleven) == 13u);
- check (hm_su.get("eleven") == 13u);
- check (hm_su.get("twelve") == 14u);
- check (hm_su.get("ten") == 12u);
+ assert (hm_su.get("eleven") == 13u);
+ assert (hm_su.get("twelve") == 14u);
+ assert (hm_su.get("ten") == 12u);
- check (!hm_su.insert("twelve", 14u));
- check (hm_su.get("twelve") == 14u);
+ assert (!hm_su.insert("twelve", 14u));
+ assert (hm_su.get("twelve") == 14u);
- check (!hm_su.insert("twelve", 12u));
- check (hm_su.get("twelve") == 12u);
+ assert (!hm_su.insert("twelve", 12u));
+ assert (hm_su.get("twelve") == 12u);
log "uint -> str";
let map.hashmap[uint, str] hm_us = map.mk_hashmap[uint, str](hasher_uint,
eqer_uint);
- check (hm_us.insert(10u, "twelve"));
- check (hm_us.insert(11u, "thirteen"));
- check (hm_us.insert(12u, "fourteen"));
+ assert (hm_us.insert(10u, "twelve"));
+ assert (hm_us.insert(11u, "thirteen"));
+ assert (hm_us.insert(12u, "fourteen"));
- check (_str.eq(hm_us.get(11u), "thirteen"));
- check (_str.eq(hm_us.get(12u), "fourteen"));
- check (_str.eq(hm_us.get(10u), "twelve"));
+ assert (_str.eq(hm_us.get(11u), "thirteen"));
+ assert (_str.eq(hm_us.get(12u), "fourteen"));
+ assert (_str.eq(hm_us.get(10u), "twelve"));
- check (!hm_us.insert(12u, "fourteen"));
- check (_str.eq(hm_us.get(12u), "fourteen"));
+ assert (!hm_us.insert(12u, "fourteen"));
+ assert (_str.eq(hm_us.get(12u), "fourteen"));
- check (!hm_us.insert(12u, "twelve"));
- check (_str.eq(hm_us.get(12u), "twelve"));
+ assert (!hm_us.insert(12u, "twelve"));
+ assert (_str.eq(hm_us.get(12u), "twelve"));
log "str -> str";
let map.hashmap[str, str] hm_ss = map.mk_hashmap[str, str](hasher_str,
eqer_str);
- check (hm_ss.insert(ten, "twelve"));
- check (hm_ss.insert(eleven, "thirteen"));
- check (hm_ss.insert(twelve, "fourteen"));
+ assert (hm_ss.insert(ten, "twelve"));
+ assert (hm_ss.insert(eleven, "thirteen"));
+ assert (hm_ss.insert(twelve, "fourteen"));
- check (_str.eq(hm_ss.get("eleven"), "thirteen"));
- check (_str.eq(hm_ss.get("twelve"), "fourteen"));
- check (_str.eq(hm_ss.get("ten"), "twelve"));
+ assert (_str.eq(hm_ss.get("eleven"), "thirteen"));
+ assert (_str.eq(hm_ss.get("twelve"), "fourteen"));
+ assert (_str.eq(hm_ss.get("ten"), "twelve"));
- check (!hm_ss.insert("twelve", "fourteen"));
- check (_str.eq(hm_ss.get("twelve"), "fourteen"));
+ assert (!hm_ss.insert("twelve", "fourteen"));
+ assert (_str.eq(hm_ss.get("twelve"), "fourteen"));
- check (!hm_ss.insert("twelve", "twelve"));
- check (_str.eq(hm_ss.get("twelve"), "twelve"));
+ assert (!hm_ss.insert("twelve", "twelve"));
+ assert (_str.eq(hm_ss.get("twelve"), "twelve"));
log "*** finished test_simple";
}
let uint i = 0u;
while (i < num_to_insert) {
- check (hm_uu.insert(i, i * i));
+ assert (hm_uu.insert(i, i * i));
log "inserting " + _uint.to_str(i, 10u)
+ " -> " + _uint.to_str(i * i, 10u);
i += 1u;
while (i < num_to_insert) {
log "get(" + _uint.to_str(i, 10u) + ") = "
+ _uint.to_str(hm_uu.get(i), 10u);
- check (hm_uu.get(i) == i * i);
+ assert (hm_uu.get(i) == i * i);
i += 1u;
}
- check (hm_uu.insert(num_to_insert, 17u));
- check (hm_uu.get(num_to_insert) == 17u);
+ assert (hm_uu.insert(num_to_insert, 17u));
+ assert (hm_uu.get(num_to_insert) == 17u);
log "-----";
while (i < num_to_insert) {
log "get(" + _uint.to_str(i, 10u) + ") = "
+ _uint.to_str(hm_uu.get(i), 10u);
- check (hm_uu.get(i) == i * i);
+ assert (hm_uu.get(i) == i * i);
i += 1u;
}
i = 0u;
while (i < num_to_insert) {
- check (hm_ss.insert(_uint.to_str(i, 2u), _uint.to_str(i * i, 2u)));
+ assert (hm_ss.insert(_uint.to_str(i, 2u), _uint.to_str(i * i, 2u)));
log "inserting \"" + _uint.to_str(i, 2u)
+ "\" -> \"" + _uint.to_str(i * i, 2u) + "\"";
i += 1u;
+ "\") = \""
+ hm_ss.get(_uint.to_str(i, 2u)) + "\"";
- check (_str.eq(hm_ss.get(_uint.to_str(i, 2u)),
+ assert (_str.eq(hm_ss.get(_uint.to_str(i, 2u)),
_uint.to_str(i * i, 2u)));
i += 1u;
}
- check (hm_ss.insert(_uint.to_str(num_to_insert, 2u),
+ assert (hm_ss.insert(_uint.to_str(num_to_insert, 2u),
_uint.to_str(17u, 2u)));
- check (_str.eq(hm_ss.get(_uint.to_str(num_to_insert, 2u)),
+ assert (_str.eq(hm_ss.get(_uint.to_str(num_to_insert, 2u)),
_uint.to_str(17u, 2u)));
log "-----";
while (i < num_to_insert) {
log "get(\"" + _uint.to_str(i, 2u) + "\") = \""
+ hm_ss.get(_uint.to_str(i, 2u)) + "\"";
- check (_str.eq(hm_ss.get(_uint.to_str(i, 2u)),
+ assert (_str.eq(hm_ss.get(_uint.to_str(i, 2u)),
_uint.to_str(i * i, 2u)));
i += 1u;
}
ret (u / 2u) * 2u;
}
- check (hash(0u) == hash(1u));
- check (hash(2u) == hash(3u));
- check (hash(0u) != hash(2u));
+ assert (hash(0u) == hash(1u));
+ assert (hash(2u) == hash(3u));
+ assert (hash(0u) != hash(2u));
let map.hashfn[uint] hasher = hash;
let map.eqfn[uint] eqer = eq;
let uint i = 0u;
while (i < num_to_insert) {
- check (hm.insert(i, i * i));
+ assert (hm.insert(i, i * i));
log "inserting " + _uint.to_str(i, 10u)
+ " -> " + _uint.to_str(i * i, 10u);
i += 1u;
}
- check (hm.size() == num_to_insert);
+ assert (hm.size() == num_to_insert);
log "-----";
log "removing evens";
let util.option[uint] v = hm.remove(i);
alt (v) {
case (util.some[uint](u)) {
- check (u == (i * i));
+ assert (u == (i * i));
}
case (util.none[uint]()) { fail; }
}
i += 2u;
}
- check (hm.size() == (num_to_insert / 2u));
+ assert (hm.size() == (num_to_insert / 2u));
log "-----";
while (i < num_to_insert) {
log "get(" + _uint.to_str(i, 10u) + ") = "
+ _uint.to_str(hm.get(i), 10u);
- check (hm.get(i) == i * i);
+ assert (hm.get(i) == i * i);
i += 2u;
}
while (i < num_to_insert) {
log "get(" + _uint.to_str(i, 10u) + ") = "
+ _uint.to_str(hm.get(i), 10u);
- check (hm.get(i) == i * i);
+ assert (hm.get(i) == i * i);
i += 2u;
}
i = 0u;
while (i < num_to_insert) {
- check (hm.insert(i, i * i));
+ assert (hm.insert(i, i * i));
log "inserting " + _uint.to_str(i, 10u)
+ " -> " + _uint.to_str(i * i, 10u);
i += 2u;
}
- check (hm.size() == num_to_insert);
+ assert (hm.size() == num_to_insert);
log "-----";
while (i < num_to_insert) {
log "get(" + _uint.to_str(i, 10u) + ") = "
+ _uint.to_str(hm.get(i), 10u);
- check (hm.get(i) == i * i);
+ assert (hm.get(i) == i * i);
i += 1u;
}
log "-----";
- check (hm.size() == num_to_insert);
+ assert (hm.size() == num_to_insert);
i = 0u;
while (i < num_to_insert) {
log "get(" + _uint.to_str(i, 10u) + ") = "
+ _uint.to_str(hm.get(i), 10u);
- check (hm.get(i) == i * i);
+ assert (hm.get(i) == i * i);
i += 1u;
}
auto tests = fips_180_1_tests + wikipedia_tests;
fn check_vec_eq(vec[u8] v0, vec[u8] v1) {
- check (_vec.len[u8](v0) == _vec.len[u8](v1));
+ assert (_vec.len[u8](v0) == _vec.len[u8](v1));
auto len = _vec.len[u8](v0);
auto i = 0u;
while (i < len) {
auto a = v0.(i);
auto b = v1.(i);
- check (a == b);
+ assert (a == b);
i += 1u;
}
}
auto i = 0u;
while (i < len) {
log v3.(i);
- check (v3.(i) == v2.(i));
+ assert (v3.(i) == v2.(i));
i += 1u;
}
}
auto s = "hello";
auto sb = _str.rustrt.str_buf(s);
auto s_cstr = _str.rustrt.str_from_cstr(sb);
- check (_str.eq(s_cstr, s));
+ assert (_str.eq(s_cstr, s));
auto s_buf = _str.rustrt.str_from_buf(sb, 5u);
- check (_str.eq(s_buf, s));
+ assert (_str.eq(s_buf, s));
}
import std._str;
fn test_bytes_len() {
- check (_str.byte_len("") == 0u);
- check (_str.byte_len("hello world") == 11u);
- check (_str.byte_len("\x63") == 1u);
- check (_str.byte_len("\xa2") == 2u);
- check (_str.byte_len("\u03c0") == 2u);
- check (_str.byte_len("\u2620") == 3u);
- check (_str.byte_len("\U0001d11e") == 4u);
+ assert (_str.byte_len("") == 0u);
+ assert (_str.byte_len("hello world") == 11u);
+ assert (_str.byte_len("\x63") == 1u);
+ assert (_str.byte_len("\xa2") == 2u);
+ assert (_str.byte_len("\u03c0") == 2u);
+ assert (_str.byte_len("\u2620") == 3u);
+ assert (_str.byte_len("\U0001d11e") == 4u);
}
fn test_index_and_rindex() {
- check(_str.index("hello", 'e' as u8) == 1);
- check(_str.index("hello", 'o' as u8) == 4);
- check(_str.index("hello", 'z' as u8) == -1);
- check(_str.rindex("hello", 'l' as u8) == 3);
- check(_str.rindex("hello", 'h' as u8) == 0);
- check(_str.rindex("hello", 'z' as u8) == -1);
+ assert (_str.index("hello", 'e' as u8) == 1);
+ assert (_str.index("hello", 'o' as u8) == 4);
+ assert (_str.index("hello", 'z' as u8) == -1);
+ assert (_str.rindex("hello", 'l' as u8) == 3);
+ assert (_str.rindex("hello", 'h' as u8) == 0);
+ assert (_str.rindex("hello", 'z' as u8) == -1);
}
fn test_split() {
log z;
}
log "comparing: " + v.(i) + " vs. " + k;
- check(_str.eq(v.(i), k));
+ assert (_str.eq(v.(i), k));
}
t("abc.hello.there", '.', 0, "abc");
t("abc.hello.there", '.', 1, "hello");
let int j = _str.find(haystack,needle);
log "searched for " + needle;
log j;
- check (i == j);
+ assert (i == j);
}
t("this is a simple", "is a", 5);
t("this is a simple", "is z", -1);
fn test_substr() {
fn t(&str a, &str b, int start) {
- check(_str.eq(_str.substr(a, start as uint,
+ assert (_str.eq(_str.substr(a, start as uint,
_str.byte_len(b)), b));
}
fn test_concat() {
fn t(&vec[str] v, &str s) {
- check(_str.eq(_str.concat(v), s));
+ assert (_str.eq(_str.concat(v), s));
}
t(vec("you", "know", "I'm", "no", "good"), "youknowI'mnogood");
fn test_connect() {
fn t(&vec[str] v, &str sep, &str s) {
- check(_str.eq(_str.connect(v, sep), s));
+ assert (_str.eq(_str.connect(v, sep), s));
}
t(vec("you", "know", "I'm", "no", "good"), " ", "you know I'm no good");
auto input = "abcDEF" + unicode + "xyz:.;";
auto expected = "ABCDEF" + unicode + "XYZ:.;";
auto actual = _str.to_upper(input);
- check (_str.eq(expected, actual));
+ assert (_str.eq(expected, actual));
}
import std._uint;
fn main() {
- check (_uint.next_power_of_two(0u) == 0u);
- check (_uint.next_power_of_two(1u) == 1u);
- check (_uint.next_power_of_two(2u) == 2u);
- check (_uint.next_power_of_two(3u) == 4u);
- check (_uint.next_power_of_two(4u) == 4u);
- check (_uint.next_power_of_two(5u) == 8u);
- check (_uint.next_power_of_two(6u) == 8u);
- check (_uint.next_power_of_two(7u) == 8u);
- check (_uint.next_power_of_two(8u) == 8u);
- check (_uint.next_power_of_two(9u) == 16u);
- check (_uint.next_power_of_two(10u) == 16u);
- check (_uint.next_power_of_two(11u) == 16u);
- check (_uint.next_power_of_two(12u) == 16u);
- check (_uint.next_power_of_two(13u) == 16u);
- check (_uint.next_power_of_two(14u) == 16u);
- check (_uint.next_power_of_two(15u) == 16u);
- check (_uint.next_power_of_two(16u) == 16u);
- check (_uint.next_power_of_two(17u) == 32u);
- check (_uint.next_power_of_two(18u) == 32u);
- check (_uint.next_power_of_two(19u) == 32u);
- check (_uint.next_power_of_two(20u) == 32u);
- check (_uint.next_power_of_two(21u) == 32u);
- check (_uint.next_power_of_two(22u) == 32u);
- check (_uint.next_power_of_two(23u) == 32u);
- check (_uint.next_power_of_two(24u) == 32u);
- check (_uint.next_power_of_two(25u) == 32u);
- check (_uint.next_power_of_two(26u) == 32u);
- check (_uint.next_power_of_two(27u) == 32u);
- check (_uint.next_power_of_two(28u) == 32u);
- check (_uint.next_power_of_two(29u) == 32u);
- check (_uint.next_power_of_two(30u) == 32u);
- check (_uint.next_power_of_two(31u) == 32u);
- check (_uint.next_power_of_two(32u) == 32u);
- check (_uint.next_power_of_two(33u) == 64u);
- check (_uint.next_power_of_two(34u) == 64u);
- check (_uint.next_power_of_two(35u) == 64u);
- check (_uint.next_power_of_two(36u) == 64u);
- check (_uint.next_power_of_two(37u) == 64u);
- check (_uint.next_power_of_two(38u) == 64u);
- check (_uint.next_power_of_two(39u) == 64u);
+ assert (_uint.next_power_of_two(0u) == 0u);
+ assert (_uint.next_power_of_two(1u) == 1u);
+ assert (_uint.next_power_of_two(2u) == 2u);
+ assert (_uint.next_power_of_two(3u) == 4u);
+ assert (_uint.next_power_of_two(4u) == 4u);
+ assert (_uint.next_power_of_two(5u) == 8u);
+ assert (_uint.next_power_of_two(6u) == 8u);
+ assert (_uint.next_power_of_two(7u) == 8u);
+ assert (_uint.next_power_of_two(8u) == 8u);
+ assert (_uint.next_power_of_two(9u) == 16u);
+ assert (_uint.next_power_of_two(10u) == 16u);
+ assert (_uint.next_power_of_two(11u) == 16u);
+ assert (_uint.next_power_of_two(12u) == 16u);
+ assert (_uint.next_power_of_two(13u) == 16u);
+ assert (_uint.next_power_of_two(14u) == 16u);
+ assert (_uint.next_power_of_two(15u) == 16u);
+ assert (_uint.next_power_of_two(16u) == 16u);
+ assert (_uint.next_power_of_two(17u) == 32u);
+ assert (_uint.next_power_of_two(18u) == 32u);
+ assert (_uint.next_power_of_two(19u) == 32u);
+ assert (_uint.next_power_of_two(20u) == 32u);
+ assert (_uint.next_power_of_two(21u) == 32u);
+ assert (_uint.next_power_of_two(22u) == 32u);
+ assert (_uint.next_power_of_two(23u) == 32u);
+ assert (_uint.next_power_of_two(24u) == 32u);
+ assert (_uint.next_power_of_two(25u) == 32u);
+ assert (_uint.next_power_of_two(26u) == 32u);
+ assert (_uint.next_power_of_two(27u) == 32u);
+ assert (_uint.next_power_of_two(28u) == 32u);
+ assert (_uint.next_power_of_two(29u) == 32u);
+ assert (_uint.next_power_of_two(30u) == 32u);
+ assert (_uint.next_power_of_two(31u) == 32u);
+ assert (_uint.next_power_of_two(32u) == 32u);
+ assert (_uint.next_power_of_two(33u) == 64u);
+ assert (_uint.next_power_of_two(34u) == 64u);
+ assert (_uint.next_power_of_two(35u) == 64u);
+ assert (_uint.next_power_of_two(36u) == 64u);
+ assert (_uint.next_power_of_two(37u) == 64u);
+ assert (_uint.next_power_of_two(38u) == 64u);
+ assert (_uint.next_power_of_two(39u) == 64u);
}
let uint n1 = _str.byte_len(s1);
let uint n2 = _vec.len[u8](v);
- check (n1 == n2);
+ assert (n1 == n2);
while (i < n1) {
let u8 a = s1.(i);
let u8 b = s2.(i);
log a;
log b;
- check (a == b);
+ assert (a == b);
i += 1u;
}
fn test_init_elt() {
let vec[uint] v = std._vec.init_elt[uint](5u, 3u);
- check (std._vec.len[uint](v) == 3u);
- check (v.(0) == 5u);
- check (v.(1) == 5u);
- check (v.(2) == 5u);
+ assert (std._vec.len[uint](v) == 3u);
+ assert (v.(0) == 5u);
+ assert (v.(1) == 5u);
+ assert (v.(2) == 5u);
}
fn id(uint x) -> uint {
fn test_init_fn() {
let fn(uint)->uint op = id;
let vec[uint] v = std._vec.init_fn[uint](op, 5u);
- check (std._vec.len[uint](v) == 5u);
- check (v.(0) == 0u);
- check (v.(1) == 1u);
- check (v.(2) == 2u);
- check (v.(3) == 3u);
- check (v.(4) == 4u);
+ assert (std._vec.len[uint](v) == 5u);
+ assert (v.(0) == 0u);
+ assert (v.(1) == 1u);
+ assert (v.(2) == 2u);
+ assert (v.(3) == 3u);
+ assert (v.(4) == 4u);
}
fn test_slice() {
let vec[int] v = vec(1,2,3,4,5);
auto v2 = std._vec.slice[int](v, 2u, 4u);
- check (std._vec.len[int](v2) == 2u);
- check (v2.(0) == 3);
- check (v2.(1) == 4);
+ assert (std._vec.len[int](v2) == 2u);
+ assert (v2.(0) == 3);
+ assert (v2.(1) == 4);
}
fn test_map() {
let vec[int] s = std._vec.map[int, int](op, v);
let int i = 0;
while (i < 5) {
- check (v.(i) * v.(i) == s.(i));
+ assert (v.(i) * v.(i) == s.(i));
i += 1;
}
}
auto i = 0;
while (i < 5) {
- check (v0.(i) * v1.(i) == u.(i));
+ assert (v0.(i) * v1.(i) == u.(i));
i += 1;
}
}
y += i;
}
log y;
- check (y == 6);
+ assert (y == 6);
auto s = "hello there";
let int i = 0;
for (u8 c in s) {
if (i == 0) {
- check (c == ('h' as u8));
+ assert (c == ('h' as u8));
}
if (i == 1) {
- check (c == ('e' as u8));
+ assert (c == ('e' as u8));
}
if (i == 2) {
- check (c == ('l' as u8));
+ assert (c == ('l' as u8));
}
if (i == 3) {
- check (c == ('l' as u8));
+ assert (c == ('l' as u8));
}
if (i == 4) {
- check (c == ('o' as u8));
+ assert (c == ('o' as u8));
}
// ...
i += 1;
log i;
log c;
}
- check(i == 11);
+ assert (i == 11);
}
let int y <- p;
log "transmission complete";
log y;
- check (y == 500);
+ assert (y == 500);
}
grow(v);
auto len = std._vec.len[int](v);
log len;
- check (len == (3 as uint));
+ assert (len == (3 as uint));
}
}
fn main() {
- check (true);
+ assert (true);
}
fn main() {
let big b = big();
- check (b.one() == 1);
- check (b.two() == 2);
- check (b.three() == 3);
+ assert (b.one() == 1);
+ assert (b.two() == 2);
+ assert (b.three() == 3);
let small s = b as small;
- check (s.one() == 1);
+ assert (s.one() == 1);
}
\ No newline at end of file
{
auto x = foo(mbox);
}
- check ((*mbox) == 11);
+ assert ((*mbox) == 11);
}
\ No newline at end of file
log "parent waiting for shutdown";
i <- p;
log "received int";
- check (i == 10);
+ assert (i == 10);
log "int is OK, child-dtor ran as expected";
}
\ No newline at end of file
let int i = 0;
i = a.m1(i);
- check (i == 1);
+ assert (i == 1);
i = a.m2(i);
- check (i == 2);
+ assert (i == 2);
i = a.m3(i);
- check (i == 4);
+ assert (i == 4);
}
}
auto b = buf(vec(1 as u8, 2 as u8, 3 as u8));
log b.get(1);
- check (b.get(1) == (2 as u8));
+ assert (b.get(1) == (2 as u8));
}
x *= 2;
log x;
- check (x == 2);
+ assert (x == 2);
x += 3;
log x;
- check (x == 5);
+ assert (x == 5);
x *= x;
log x;
- check (x == 25);
+ assert (x == 25);
x /= 5;
log x;
- check (x == 5);
+ assert (x == 5);
}
// Testcase for issue #130, operator associativity.
fn main() -> () {
- check ((3 * 5 / 2) == 7);
+ assert ((3 * 5 / 2) == 7);
}
type point = rec(int x, int y, int z);
fn f(&point p) {
- check (p.z == 12);
+ assert (p.z == 12);
}
fn main() {
let point right = rec(x=origin.x + 10 with origin);
let point up = rec(y=origin.y + 10 with origin);
- check(origin.x == 0);
- check(origin.y == 0);
+ assert (origin.x == 0);
+ assert (origin.y == 0);
- check(right.x == 10);
- check(right.y == 0);
+ assert (right.x == 10);
+ assert (right.y == 0);
- check(up.x == 0);
- check(up.y == 10);
+ assert (up.x == 0);
+ assert (up.y == 10);
}
type rect = tup(point, point);
fn f(rect r, int x1, int y1, int x2, int y2) {
- check (r._0.x == x1);
- check (r._0.y == y1);
- check (r._1.x == x2);
- check (r._1.y == y2);
+ assert (r._0.x == x1);
+ assert (r._0.y == y1);
+ assert (r._1.x == x2);
+ assert (r._1.y == y2);
}
fn main() {
let rect r = tup( rec(x=10, y=20),
rec(x=11, y=22) );
- check (r._0.x == 10);
- check (r._0.y == 20);
- check (r._1.x == 11);
- check (r._1.y == 22);
+ assert (r._0.x == 10);
+ assert (r._0.y == 20);
+ assert (r._1.x == 11);
+ assert (r._1.y == 22);
let rect r2 = r;
let int x = r2._0.x;
- check (x == 10);
+ assert (x == 10);
f(r, 10, 20, 11, 22);
f(r2, 10, 20, 11, 22);
}
type rect = rec(int x, int y, int w, int h);
fn f(rect r, int x, int y, int w, int h) {
- check (r.x == x);
- check (r.y == y);
- check (r.w == w);
- check (r.h == h);
+ assert (r.x == x);
+ assert (r.y == y);
+ assert (r.w == w);
+ assert (r.h == h);
}
fn main() {
let rect r = rec(x=10, y=20, w=100, h=200);
- check (r.x == 10);
- check (r.y == 20);
- check (r.w == 100);
- check (r.h == 200);
+ assert (r.x == 10);
+ assert (r.y == 20);
+ assert (r.w == 100);
+ assert (r.h == 200);
let rect r2 = r;
let int x = r2.x;
- check (x == 10);
+ assert (x == 10);
f(r, 10, 20, 100, 200);
f(r2, 10, 20, 100, 200);
}
mychan <| val;
auto x <- myport;
- check (x.val1 == i as u32);
- check (x.val2 == i as u32);
- check (x.val3 == i as u32);
+ assert (x.val1 == i as u32);
+ assert (x.val2 == i as u32);
+ assert (x.val3 == i as u32);
}
}
for each (uint i in _uint.range(0u, 10u)) {
auto x <- myport;
- check (x.val1 == i as u32);
- check (x.val2 == i as u32);
- check (x.val3 == i as u32);
+ assert (x.val1 == i as u32);
+ assert (x.val2 == i as u32);
+ assert (x.val3 == i as u32);
}
}
}
// xfail-boot
fn main() {
- check ("hello" < "hellr");
- check ("hello " > "hello");
- check ("hello" != "there");
+ assert ("hello" < "hellr");
+ assert ("hello " > "hello");
+ assert ("hello" != "there");
- check (vec(1,2,3,4) > vec(1,2,3));
- check (vec(1,2,3) < vec(1,2,3,4));
- check (vec(1,2,4,4) > vec(1,2,3,4));
- check (vec(1,2,3,4) < vec(1,2,4,4));
- check (vec(1,2,3) <= vec(1,2,3));
- check (vec(1,2,3) <= vec(1,2,3,3));
- check (vec(1,2,3,4) > vec(1,2,3));
- check (vec(1,2,3) == vec(1,2,3));
- check (vec(1,2,3) != vec(1,1,3));
+ assert (vec(1,2,3,4) > vec(1,2,3));
+ assert (vec(1,2,3) < vec(1,2,3,4));
+ assert (vec(1,2,4,4) > vec(1,2,3,4));
+ assert (vec(1,2,3,4) < vec(1,2,4,4));
+ assert (vec(1,2,3) <= vec(1,2,3));
+ assert (vec(1,2,3) <= vec(1,2,3,3));
+ assert (vec(1,2,3,4) > vec(1,2,3));
+ assert (vec(1,2,3) == vec(1,2,3));
+ assert (vec(1,2,3) != vec(1,1,3));
}
fn main() {
auto y = counter(0);
- check (y.hello() == 12345);
+ assert (y.hello() == 12345);
log y.get();
y.incr();
y.incr();
log y.get();
- check (y.get() == 2);
+ assert (y.get() == 2);
}
let str s = "hello";
s += "world";
log s;
- check(s.(9) == ('d' as u8));
+ assert (s.(9) == ('d' as u8));
}
fn test2() {
log a;
log b;
- check (_str.eq(a, "abcABCabc"));
- check (_str.eq(b, "ABCabcABC"));
+ assert (_str.eq(a, "abcABCabc"));
+ assert (_str.eq(b, "ABCabcABC"));
}
fn main() {
let str b = "world";
let str s = a + b;
log s;
- check(s.(9) == ('d' as u8));
+ assert (s.(9) == ('d' as u8));
}
fn main() {
auto s = "a";
s += "b";
- check (s.(0) == ('a' as u8));
- check (s.(1) == ('b' as u8));
+ assert (s.(0) == ('a' as u8));
+ assert (s.(1) == ('b' as u8));
s += "c";
s += "d";
- check (s.(0) == ('a' as u8));
- check (s.(1) == ('b' as u8));
- check (s.(2) == ('c' as u8));
- check (s.(3) == ('d' as u8));
+ assert (s.(0) == ('a' as u8));
+ assert (s.(1) == ('b' as u8));
+ assert (s.(2) == ('c' as u8));
+ assert (s.(3) == ('d' as u8));
}
auto s = "hello";
let u8 c = s.(4);
log c;
- check (c == (0x6f as u8));
+ assert (c == (0x6f as u8));
}
}
fn main() {
- check (bar <= bar);
+ assert (bar <= bar);
}
fn main() {
auto a = tup(1,2,3);
auto b = tup(1,2,3);
- check (a == b);
- check (a != tup(1,2,4));
- check (a < tup(1,2,4));
- check (a <= tup(1,2,4));
- check (tup(1,2,4) > a);
- check (tup(1,2,4) >= a);
+ assert (a == b);
+ assert (a != tup(1,2,4));
+ assert (a < tup(1,2,4));
+ assert (a <= tup(1,2,4));
+ assert (tup(1,2,4) > a);
+ assert (tup(1,2,4) >= a);
auto x = large;
auto y = small;
- check (x != y);
- check (x == large);
- check (x != small);
+ assert (x != y);
+ assert (x == large);
+ assert (x != small);
}
\ No newline at end of file
fn test(str actual, str expected) {
log actual;
log expected;
- check (_str.eq(actual, expected));
+ assert (_str.eq(actual, expected));
}
fn main() {
auto x = red(1,2);
auto y = green;
// FIXME: needs structural equality test working.
- // check (x != y);
+ // assert (x != y);
}
fn main() {
// -*- rust -*-
fn checktrue(bool res) -> bool {
- check(res);
+ assert (res);
ret true;
}
// -*- rust -*-
fn main() {
- check(even(42));
- check(odd(45));
+ assert (even(42));
+ assert (odd(45));
}
fn even(int n) -> bool {
let int value <- po;
value <- po;
value <- po;
- check(value == 30);
+ assert (value == 30);
}
let r r1;
r1 <- po;
- check (r1.val0 == 0);
- check (r1.val1 == 1u8);
- check (r1.val2 == '2');
+ assert (r1.val0 == 0);
+ assert (r1.val1 == 1u8);
+ assert (r1.val2 == '2');
}
fn test_vec() {
let vec[int] v1;
v1 <- po;
- check (v1.(0) == 0);
- check (v1.(1) == 1);
- check (v1.(2) == 2);
+ assert (v1.(0) == 0);
+ assert (v1.(1) == 1);
+ assert (v1.(2) == 2);
}
fn test_str() {
let str s1;
s1 <- po;
- check (s1.(0) as u8 == 't' as u8);
- check (s1.(1) as u8 == 'e' as u8);
- check (s1.(2) as u8 == 's' as u8);
- check (s1.(3) as u8 == 't' as u8);
+ assert (s1.(0) as u8 == 't' as u8);
+ assert (s1.(1) as u8 == 'e' as u8);
+ assert (s1.(2) as u8 == 's' as u8);
+ assert (s1.(3) as u8 == 't' as u8);
}
fn test_tup() {
let t t1;
t1 <- po;
- check (t0._0 == 0);
- check (t0._1 == 1u8);
- check (t0._2 == '2');
+ assert (t0._0 == 0);
+ assert (t0._1 == 1u8);
+ assert (t0._2 == '2');
}
fn test_tag() {
let t t1;
t1 <- po;
- check (t1 == tag1);
+ assert (t1 == tag1);
t1 <- po;
- check (t1 == tag2(10));
+ assert (t1 == tag2(10));
t1 <- po;
- check (t1 == tag3(10, 11u8, 'A'));
+ assert (t1 == tag3(10, 11u8, 'A'));
}
fn test_chan() {
let int i;
i <- po0;
- check (i == 10);
+ assert (i == 10);
}
fn main() {
}
log "Completed: Final number is: ";
- // check (sum == (((number_of_tasks * (number_of_tasks - 1)) / 2) *
+ // assert (sum == (((number_of_tasks * (number_of_tasks - 1)) / 2) *
// number_of_messages));
- check (sum == 480);
+ assert (sum == 480);
}
r <- p; sum += r; log (r);
r <- p; sum += r; log (r);
- check (sum == 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8);
+ assert (sum == 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8);
}
\ No newline at end of file
i += 1;
}
- check (sum == ((number_of_messages * (number_of_messages - 1)) / 2));
+ assert (sum == ((number_of_messages * (number_of_messages - 1)) / 2));
}
\ No newline at end of file
i += 1;
}
- check (sum == 1998000);
- // check (sum == 4 * ((number_of_messages *
+ assert (sum == 1998000);
+ // assert (sum == 4 * ((number_of_messages *
// (number_of_messages - 1)) / 2));
}
\ No newline at end of file
join t2;
join t3;
- check (sum == (((number_of_messages * 4) *
+ assert (sum == (((number_of_messages * 4) *
((number_of_messages * 4) - 1)) / 2));
}
\ No newline at end of file
join t2;
join t3;
- check (sum == (((number_of_messages * 4) *
+ assert (sum == (((number_of_messages * 4) *
((number_of_messages * 4) - 1)) / 2));
}
\ No newline at end of file
join t0;
- check (sum == (number_of_messages * (number_of_messages - 1)) / 2);
+ assert (sum == (number_of_messages * (number_of_messages - 1)) / 2);
}
\ No newline at end of file
let () n;
n <- po;
- check (n == ());
+ assert (n == ());
}
}
log "Completed: Final number is: ";
- check (sum == number_of_messages *
+ assert (sum == number_of_messages *
(number_of_tasks * number_of_tasks + number_of_tasks) / 2);
}
type point = tup(int, int);
fn f(point p, int x, int y) {
- check (p._0 == x);
- check (p._1 == y);
+ assert (p._0 == x);
+ assert (p._1 == y);
}
fn main() {
let point p = tup(10, 20);
- check (p._0 == 10);
- check (p._1 == 20);
+ assert (p._0 == 10);
+ assert (p._1 == 20);
let point p2 = p;
let int x = p2._0;
- check (x == 10);
+ assert (x == 10);
f(p, 10, 20);
f(p2, 10, 20);
}
use std;
fn main() {
- check (size_of[u8]() == (1 as uint));
- check (size_of[u32]() == (4 as uint));
- check (size_of[char]() == (4 as uint));
- check (size_of[i8]() == (1 as uint));
- check (size_of[i32]() == (4 as uint));
- check (size_of[tup(u8,i8)]() == (2 as uint));
- check (size_of[tup(u8,i8,u8)]() == (3 as uint));
+ assert (size_of[u8]() == (1 as uint));
+ assert (size_of[u32]() == (4 as uint));
+ assert (size_of[char]() == (4 as uint));
+ assert (size_of[i8]() == (1 as uint));
+ assert (size_of[i32]() == (4 as uint));
+ assert (size_of[tup(u8,i8)]() == (2 as uint));
+ assert (size_of[tup(u8,i8,u8)]() == (3 as uint));
// Alignment causes padding before the char and the u32.
- check (size_of[tup(u8,i8,tup(char,u8),u32)]() == (16 as uint));
- check (size_of[int]() == size_of[uint]());
- check (size_of[tup(int,())]() == size_of[int]());
- check (size_of[tup(int,(),())]() == size_of[int]());
- check (size_of[int]() == size_of[rec(int x)]());
+ assert (size_of[tup(u8,i8,tup(char,u8),u32)]() == (16 as uint));
+ assert (size_of[int]() == size_of[uint]());
+ assert (size_of[tup(int,())]() == size_of[int]());
+ assert (size_of[tup(int,(),())]() == size_of[int]());
+ assert (size_of[int]() == size_of[rec(int x)]());
}
fn main() {
let u32 word = (200000u32);
word = word - (1u32);
- check(word == (199999u32));
+ assert (word == (199999u32));
}
let u8 y = 35u8; // 0x23
x = x + (7u8); // 0x7
y = y - (9u8); // 0x9
- check(x == y);
+ assert (x == y);
}
let u8 y = 12u8;
x = x + (1u8);
x = x - (1u8);
- check(x == y);
+ assert (x == y);
// x = 14u8;
// x = x + 1u8;
}
let char y_diaeresis = 'ÿ'; // 0xff
let char pi = 'Π'; // 0x3a0
- check ((yen as int) == 0xa5);
- check ((c_cedilla as int) == 0xe7);
- check ((thorn as int) == 0xfe);
- check ((y_diaeresis as int) == 0xff);
- check ((pi as int) == 0x3a0);
+ assert ((yen as int) == 0xa5);
+ assert ((c_cedilla as int) == 0xe7);
+ assert ((thorn as int) == 0xfe);
+ assert ((y_diaeresis as int) == 0xff);
+ assert ((pi as int) == 0x3a0);
- check ((pi as int) == ('\u03a0' as int));
- check (('\x0a' as int) == ('\n' as int));
+ assert ((pi as int) == ('\u03a0' as int));
+ assert (('\x0a' as int) == ('\n' as int));
let str bhutan = "འབྲུག་ཡུལ།";
let str japan = "日本";
let str austria_e = "\u00d6sterreich";
let char oo = 'Ö';
- check ((oo as int) == 0xd6);
+ assert ((oo as int) == 0xd6);
fn check_str_eq(str a, str b) {
let int i = 0;
log ab;
let u8 bb = b.(i);
log bb;
- check(ab == bb);
+ assert (ab == bb);
i += 1;
}
}
let vec[char] chs = vec('e', 'é', '€', 0x10000 as char);
let str s = _str.from_chars(chs);
- check(_str.byte_len(s) == 10u);
- check(_str.char_len(s) == 4u);
- check(_vec.len[char](_str.to_chars(s)) == 4u);
- check(_str.eq(_str.from_chars(_str.to_chars(s)), s));
- check(_str.char_at(s, 0u) == 'e');
- check(_str.char_at(s, 1u) == 'é');
+ assert (_str.byte_len(s) == 10u);
+ assert (_str.char_len(s) == 4u);
+ assert (_vec.len[char](_str.to_chars(s)) == 4u);
+ assert (_str.eq(_str.from_chars(_str.to_chars(s)), s));
+ assert (_str.char_at(s, 0u) == 'e');
+ assert (_str.char_at(s, 1u) == 'é');
- check(_str.is_utf8(_str.bytes(s)));
- check(!_str.is_utf8(vec(0x80_u8)));
- check(!_str.is_utf8(vec(0xc0_u8)));
- check(!_str.is_utf8(vec(0xc0_u8, 0x10_u8)));
+ assert (_str.is_utf8(_str.bytes(s)));
+ assert (!_str.is_utf8(vec(0x80_u8)));
+ assert (!_str.is_utf8(vec(0xc0_u8)));
+ assert (!_str.is_utf8(vec(0xc0_u8, 0x10_u8)));
auto stack = "a×c€";
- check(_str.pop_char(stack) == '€');
- check(_str.pop_char(stack) == 'c');
+ assert (_str.pop_char(stack) == '€');
+ assert (_str.pop_char(stack) == 'c');
_str.push_char(stack, 'u');
- check(_str.eq(stack, "a×u"));
- check(_str.shift_char(stack) == 'a');
- check(_str.shift_char(stack) == '×');
+ assert (_str.eq(stack, "a×u"));
+ assert (_str.shift_char(stack) == 'a');
+ assert (_str.shift_char(stack) == '×');
_str.unshift_char(stack, 'ß');
- check(_str.eq(stack, "ßu"));
+ assert (_str.eq(stack, "ßu"));
}
v += vec(6,7,8,9,0);
log v.(9);
- check(v.(0) == 1);
- check(v.(7) == 8);
- check(v.(9) == 0);
+ assert (v.(0) == 1);
+ assert (v.(7) == 8);
+ assert (v.(9) == 0);
}
fn slow_growth() {
v += vec(17);
log v.(0);
- check (v.(0) == 17);
+ assert (v.(0) == 17);
}
fn slow_growth2_helper(str s) { // ref up: s
let acc a = acc(v); // ref up: a, v
log _vec.refcount[str](v);
- check (_vec.refcount[str](v) == 2u);
+ assert (_vec.refcount[str](v) == 2u);
a.add(s); // ref up: mumble, s. ref down: v
log _str.refcount(s);
log _str.refcount(mumble);
- check (_vec.refcount[str](v) == 1u);
- check (_str.refcount(s) == const_refcount);
- check (_str.refcount(mumble) == const_refcount);
+ assert (_vec.refcount[str](v) == 1u);
+ assert (_str.refcount(s) == const_refcount);
+ assert (_str.refcount(mumble) == const_refcount);
log v.(0);
log _vec.len[str](v);
- check (_str.eq(v.(0), mumble));
- check (_vec.len[str](v) == 1u);
+ assert (_str.eq(v.(0), mumble));
+ assert (_vec.len[str](v) == 1u);
} // ref down: a, mumble, s, v
log _str.refcount(s);
log _str.refcount(mumble);
- check (_str.refcount(s) == const_refcount);
- check (_str.refcount(mumble) == const_refcount);
+ assert (_str.refcount(s) == const_refcount);
+ assert (_str.refcount(mumble) == const_refcount);
log mumble;
log ss;
let str s = "hi"; // ref up: s
slow_growth2_helper(s);
log _str.refcount(s);
- check (_str.refcount(s) == const_refcount);
+ assert (_str.refcount(s) == const_refcount);
}
fn main() {
let vec[int] b = vec(6,7,8,9,0);
let vec[int] v = a + b;
log v.(9);
- check(v.(0) == 1);
- check(v.(7) == 8);
- check(v.(9) == 0);
+ assert (v.(0) == 1);
+ assert (v.(7) == 8);
+ assert (v.(9) == 0);
}
v += vec(3);
v += vec(4);
v += vec(5);
- check (v.(0) == 1);
- check (v.(1) == 2);
- check (v.(2) == 3);
- check (v.(3) == 4);
- check (v.(4) == 5);
+ assert (v.(0) == 1);
+ assert (v.(1) == 2);
+ assert (v.(2) == 3);
+ assert (v.(3) == 4);
+ assert (v.(4) == 5);
}
log_err _vec.refcount[int](v);
log_err _vec.refcount[int](v);
log_err _vec.refcount[int](v);
- check (_vec.refcount[int](v) == 1u || _vec.refcount[int](v) == 2u);
- check (_vec.refcount[int](v) == 1u || _vec.refcount[int](v) == 2u);
+ assert (_vec.refcount[int](v) == 1u || _vec.refcount[int](v) == 2u);
+ assert (_vec.refcount[int](v) == 1u || _vec.refcount[int](v) == 2u);
}
fn main() {
let vec[int] v = vec(1,2,3,4,5);
auto v2 = v.(1,2);
- check (v2.(0) == 2);
- check (v2.(1) == 3);
+ assert (v2.(0) == 2);
+ assert (v2.(1) == 3);
}
\ No newline at end of file
fn main() {
let vec[int] v = vec(10, 20);
- check (v.(0) == 10);
- check (v.(1) == 20);
+ assert (v.(0) == 10);
+ assert (v.(1) == 20);
let int x = 0;
- check (v.(x) == 10);
- check (v.(x + 1) == 20);
+ assert (v.(x) == 10);
+ assert (v.(x + 1) == 20);
x = x + 1;
- check (v.(x) == 20);
- check (v.(x-1) == 10);
+ assert (v.(x) == 20);
+ assert (v.(x-1) == 10);
}
break;
}
}
- check(i == 95);
+ assert (i == 95);
}
fn main() {
let point x = rec(x=10, y=11, mutable z=12);
f(x);
- check (x.z == 13);
+ assert (x.z == 13);
}
projects / rust.git / commitdiff