From ea98b634c93045c33d06cd6ff8105d5c5e7a9026 Mon Sep 17 00:00:00 2001 From: Tim Chevalier Date: Mon, 2 May 2011 11:23:07 -0700 Subject: [PATCH] Use different syntax for checks that matter to typestate This giant commit changes the syntax of Rust to use "assert" for "check" expressions that didn't mean anything to the typestate system, and continue using "check" for checks that are used as part of typestate checking. Most of the changes are just replacing "check" with "assert" in test cases and rustc. --- src/boot/fe/item.ml | 8 + src/boot/fe/lexer.mll | 1 + src/boot/fe/token.ml | 2 + src/comp/front/ast.rs | 5 +- src/comp/front/creader.rs | 14 +- src/comp/front/lexer.rs | 3 +- src/comp/front/parser.rs | 42 +- src/comp/front/token.rs | 2 + src/comp/lib/llvm.rs | 186 ++++---- src/comp/middle/fold.rs | 31 +- src/comp/middle/metadata.rs | 2 +- src/comp/middle/resolve.rs | 2 +- src/comp/middle/trans.rs | 72 ++-- src/comp/middle/ty.rs | 187 +++++--- src/comp/middle/typeck.rs | 46 +- src/comp/middle/typestate_check.rs | 406 +++++++----------- src/comp/middle/walk.rs | 5 +- src/comp/pretty/pprust.rs | 8 +- src/comp/util/typestate_ann.rs | 4 +- src/lib/Term.rs | 2 +- src/lib/_int.rs | 2 +- src/lib/_str.rs | 14 +- src/lib/_uint.rs | 2 +- src/lib/_vec.rs | 11 +- src/lib/bitv.rs | 10 +- src/lib/deque.rs | 2 +- src/lib/ebml.rs | 2 +- src/lib/fs.rs | 2 +- src/lib/io.rs | 10 +- src/lib/linux_os.rs | 4 +- src/lib/macos_os.rs | 4 +- src/lib/posix_fs.rs | 2 +- src/lib/sha1.rs | 8 +- src/lib/win32_os.rs | 2 +- src/test/run-fail/fail.rs | 2 +- src/test/run-fail/linked-failure.rs | 2 +- src/test/run-fail/str-overrun.rs | 4 +- src/test/run-fail/vec-overrun.rs | 4 +- src/test/run-fail/vec-underrun.rs | 4 +- src/test/run-pass/alt-pattern-drop.rs | 4 +- src/test/run-pass/alt-pattern-lit.rs | 4 +- src/test/run-pass/alt-tag.rs | 6 +- src/test/run-pass/arith-0.rs | 2 +- src/test/run-pass/arith-1.rs | 32 +- src/test/run-pass/arith-2.rs | 2 +- src/test/run-pass/arith-unsigned.rs | 36 +- src/test/run-pass/autoderef-full-lval.rs | 4 +- src/test/run-pass/bind-exterior.rs | 2 +- src/test/run-pass/bind-interior.rs | 2 +- src/test/run-pass/bind-obj-ctor.rs | 6 +- src/test/run-pass/bind-thunk.rs | 2 +- src/test/run-pass/bind-trivial.rs | 2 +- src/test/run-pass/bitwise.rs | 16 +- src/test/run-pass/bool-not.rs | 8 +- src/test/run-pass/box-compare.rs | 6 +- src/test/run-pass/box-unbox.rs | 2 +- src/test/run-pass/box.rs | 2 +- src/test/run-pass/break.rs | 12 +- src/test/run-pass/cast.rs | 16 +- src/test/run-pass/char.rs | 14 +- src/test/run-pass/clone-with-exterior.rs | 4 +- src/test/run-pass/comm.rs | 2 +- src/test/run-pass/decl-with-recv.rs | 4 +- src/test/run-pass/deep.rs | 2 +- src/test/run-pass/div-mod.rs | 20 +- src/test/run-pass/else-if.rs | 26 +- src/test/run-pass/expr-alt-box.rs | 4 +- src/test/run-pass/expr-alt-generic-box1.rs | 2 +- src/test/run-pass/expr-alt-generic-box2.rs | 2 +- src/test/run-pass/expr-alt-generic.rs | 2 +- src/test/run-pass/expr-alt-struct.rs | 4 +- src/test/run-pass/expr-alt.rs | 10 +- src/test/run-pass/expr-block-box.rs | 2 +- src/test/run-pass/expr-block-fn.rs | 2 +- src/test/run-pass/expr-block-generic-box1.rs | 2 +- src/test/run-pass/expr-block-generic-box2.rs | 2 +- src/test/run-pass/expr-block-generic.rs | 2 +- src/test/run-pass/expr-block.rs | 6 +- src/test/run-pass/expr-if-box.rs | 4 +- src/test/run-pass/expr-if-generic-box1.rs | 2 +- src/test/run-pass/expr-if-generic-box2.rs | 2 +- src/test/run-pass/expr-if-generic.rs | 2 +- src/test/run-pass/expr-if-struct.rs | 4 +- src/test/run-pass/expr-if.rs | 18 +- src/test/run-pass/exterior.rs | 10 +- src/test/run-pass/fact.rs | 2 +- src/test/run-pass/float2.rs | 18 +- src/test/run-pass/floatlits.rs | 8 +- src/test/run-pass/foreach-nested-2.rs | 16 +- src/test/run-pass/foreach-nested.rs | 8 +- src/test/run-pass/foreach-put-structured.rs | 4 +- .../run-pass/foreach-simple-outer-slot.rs | 2 +- src/test/run-pass/fun-call-variants.rs | 4 +- src/test/run-pass/fun-indirect-call.rs | 2 +- src/test/run-pass/generic-alias-box.rs | 2 +- src/test/run-pass/generic-bind-2.rs | 4 +- src/test/run-pass/generic-bind.rs | 4 +- src/test/run-pass/generic-box.rs | 2 +- src/test/run-pass/generic-derived-type.rs | 4 +- src/test/run-pass/generic-exterior-box.rs | 4 +- src/test/run-pass/generic-fn-infer.rs | 2 +- src/test/run-pass/generic-fn.rs | 6 +- .../run-pass/generic-obj-with-derived-type.rs | 6 +- src/test/run-pass/generic-obj.rs | 6 +- src/test/run-pass/generic-tag-alt.rs | 2 +- src/test/run-pass/generic-tag-values.rs | 6 +- src/test/run-pass/generic-temporary.rs | 2 +- src/test/run-pass/generic-tup.rs | 4 +- src/test/run-pass/generic-type.rs | 4 +- src/test/run-pass/i32-sub.rs | 2 +- src/test/run-pass/i8-incr.rs | 2 +- src/test/run-pass/integral-indexing.rs | 20 +- src/test/run-pass/iter-range.rs | 2 +- src/test/run-pass/lazy-and-or.rs | 10 +- src/test/run-pass/lazychan.rs | 4 +- src/test/run-pass/lib-bitv.rs | 52 +-- src/test/run-pass/lib-box.rs | 8 +- src/test/run-pass/lib-deque.rs | 108 ++--- src/test/run-pass/lib-int.rs | 26 +- src/test/run-pass/lib-io.rs | 2 +- src/test/run-pass/lib-map.rs | 130 +++--- src/test/run-pass/lib-sha1.rs | 4 +- src/test/run-pass/lib-sort.rs | 2 +- src/test/run-pass/lib-str-buf.rs | 4 +- src/test/run-pass/lib-str.rs | 38 +- src/test/run-pass/lib-uint.rs | 80 ++-- src/test/run-pass/lib-vec-str-conversions.rs | 4 +- src/test/run-pass/lib-vec.rs | 30 +- src/test/run-pass/linear-for-loop.rs | 14 +- src/test/run-pass/many.rs | 2 +- src/test/run-pass/mutable-alias-vec.rs | 2 +- src/test/run-pass/native-opaque-type.rs | 2 +- src/test/run-pass/obj-as.rs | 8 +- src/test/run-pass/obj-dtor-2.rs | 2 +- src/test/run-pass/obj-dtor.rs | 2 +- src/test/run-pass/obj-self-3.rs | 6 +- src/test/run-pass/obj-with-vec.rs | 2 +- src/test/run-pass/opeq.rs | 8 +- src/test/run-pass/operator-associativity.rs | 2 +- src/test/run-pass/readalias.rs | 2 +- src/test/run-pass/rec-extend.rs | 12 +- src/test/run-pass/rec-tup.rs | 18 +- src/test/run-pass/rec.rs | 18 +- src/test/run-pass/rt-circular-buffer.rs | 12 +- src/test/run-pass/seq-compare.rs | 24 +- src/test/run-pass/stateful-obj.rs | 4 +- src/test/run-pass/str-append.rs | 6 +- src/test/run-pass/str-concat.rs | 2 +- src/test/run-pass/str-growth.rs | 12 +- src/test/run-pass/str-idx.rs | 2 +- .../run-pass/structured-compare-recursive.rs | 2 +- src/test/run-pass/structured-compare.rs | 18 +- src/test/run-pass/syntax-extension-fmt.rs | 2 +- src/test/run-pass/tag.rs | 2 +- src/test/run-pass/tail-cps.rs | 2 +- src/test/run-pass/tail-direct.rs | 4 +- src/test/run-pass/task-comm-0.rs | 2 +- src/test/run-pass/task-comm-16.rs | 34 +- src/test/run-pass/task-comm-3.rs | 4 +- src/test/run-pass/task-comm-4.rs | 2 +- src/test/run-pass/task-comm-5.rs | 2 +- src/test/run-pass/task-comm-6.rs | 4 +- src/test/run-pass/task-comm-7.rs | 2 +- src/test/run-pass/task-comm-8.rs | 2 +- src/test/run-pass/task-comm-9.rs | 2 +- src/test/run-pass/task-comm-chan-nil.rs | 2 +- src/test/run-pass/task-comm.rs | 2 +- src/test/run-pass/tup.rs | 10 +- src/test/run-pass/type-sizes.rs | 24 +- src/test/run-pass/u32-decr.rs | 2 +- src/test/run-pass/u8-incr-decr.rs | 2 +- src/test/run-pass/u8-incr.rs | 2 +- src/test/run-pass/utf8.rs | 18 +- src/test/run-pass/utf8_chars.rs | 32 +- src/test/run-pass/vec-append.rs | 26 +- src/test/run-pass/vec-concat.rs | 6 +- src/test/run-pass/vec-growth.rs | 10 +- src/test/run-pass/vec-ref-count.rs | 4 +- src/test/run-pass/vec-slice.rs | 4 +- src/test/run-pass/vec.rs | 12 +- src/test/run-pass/while-with-break.rs | 2 +- src/test/run-pass/writealias.rs | 2 +- 182 files changed, 1256 insertions(+), 1239 deletions(-) diff --git a/src/boot/fe/item.ml b/src/boot/fe/item.ml index 6b232e7eba7ed..70e59be303912 100644 --- a/src/boot/fe/item.ml +++ b/src/boot/fe/item.ml @@ -199,6 +199,14 @@ and parse_stmts_including_none (ps:pstate) : Ast.stmt array = 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 diff --git a/src/boot/fe/lexer.mll b/src/boot/fe/lexer.mll index b375b874b89d2..a65acba1a6f76 100644 --- a/src/boot/fe/lexer.mll +++ b/src/boot/fe/lexer.mll @@ -92,6 +92,7 @@ ("type", TYPE); ("check", CHECK); + ("assert", ASSERT); ("claim", CLAIM); ("prove", PROVE); diff --git a/src/boot/fe/token.ml b/src/boot/fe/token.ml index 0b1579839847c..27cb399b5516d 100644 --- a/src/boot/fe/token.ml +++ b/src/boot/fe/token.ml @@ -77,6 +77,7 @@ type token = (* Type and type-state keywords *) | TYPE | CHECK + | ASSERT | CLAIM | PROVE @@ -237,6 +238,7 @@ let rec string_of_tok t = (* Type and type-state keywords *) | TYPE -> "type" | CHECK -> "check" + | ASSERT -> "assert" | CLAIM -> "claim" | PROVE -> "prove" diff --git a/src/comp/front/ast.rs b/src/comp/front/ast.rs index 2fd13194e5037..13b5739e8dfec 100644 --- a/src/comp/front/ast.rs +++ b/src/comp/front/ast.rs @@ -283,7 +283,10 @@ tag expr_ { 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); } diff --git a/src/comp/front/creader.rs b/src/comp/front/creader.rs index f48d47c90be60..c8b31159444f7 100644 --- a/src/comp/front/creader.rs +++ b/src/comp/front/creader.rs @@ -93,7 +93,7 @@ fn parse_ty(@pstate st, str_def sd) -> ty.t { 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 != ']') { @@ -108,7 +108,7 @@ fn parse_ty(@pstate st, str_def sd) -> ty.t { 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)); @@ -117,7 +117,7 @@ fn parse_ty(@pstate st, str_def sd) -> ty.t { 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 = ""; @@ -149,7 +149,7 @@ fn parse_ty(@pstate st, str_def sd) -> ty.t { 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; @@ -175,9 +175,9 @@ fn parse_ty(@pstate st, str_def sd) -> ty.t { 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]) { @@ -245,7 +245,7 @@ fn parse_hex(@pstate st) -> uint { } 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; diff --git a/src/comp/front/lexer.rs b/src/comp/front/lexer.rs index 3659af1c655e2..dabdee1c7389a 100644 --- a/src/comp/front/lexer.rs +++ b/src/comp/front/lexer.rs @@ -127,6 +127,7 @@ fn keyword_table() -> std.map.hashmap[str, token.token] { 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); @@ -528,7 +529,7 @@ fn scan_numeric_escape(reader rdr) -> char { auto n_hex_digits = 0; - check (rdr.curr() == '\\'); + assert (rdr.curr() == '\\'); alt (rdr.next()) { case ('x') { n_hex_digits = 2; } diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index fdd41cf0ff702..3e8ca85a83055 100644 --- a/src/comp/front/parser.rs +++ b/src/comp/front/parser.rs @@ -621,7 +621,7 @@ fn parse_path(parser p, greed g) -> ast.path { if (p.peek() == token.DOT) { if (g == GREEDY) { p.bump(); - check (is_ident(p.peek())); + assert (is_ident(p.peek())); } else { more = false; } @@ -816,20 +816,23 @@ fn parse_bottom_expr(parser p) -> @ast.expr { 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()) { @@ -937,7 +940,7 @@ fn expand_syntax_ext(parser p, ast.span sp, &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); @@ -1673,7 +1676,8 @@ fn stmt_ends_with_semi(@ast.stmt stmt) -> bool { 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. @@ -2157,24 +2161,24 @@ fn parse_item(parser p) -> @ast.item { 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) { diff --git a/src/comp/front/token.rs b/src/comp/front/token.rs index f367bcc6835a2..594515f22141e 100644 --- a/src/comp/front/token.rs +++ b/src/comp/front/token.rs @@ -89,6 +89,7 @@ tag token { /* Type and type-state keywords */ TYPE; + ASSERT; CHECK; CLAIM; PROVE; @@ -258,6 +259,7 @@ fn to_str(token t) -> str { /* 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"; } diff --git a/src/comp/lib/llvm.rs b/src/comp/lib/llvm.rs index 41ec1836d18d2..070174bad3c68 100644 --- a/src/comp/lib/llvm.rs +++ b/src/comp/lib/llvm.rs @@ -861,19 +861,19 @@ obj builder(BuilderRef B, @mutable bool terminated) { /* 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), @@ -881,26 +881,26 @@ obj builder(BuilderRef B, @mutable bool terminated) { } 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); } @@ -909,7 +909,7 @@ obj builder(BuilderRef B, @mutable bool terminated) { vec[ValueRef] Args, BasicBlockRef Then, BasicBlockRef Catch) -> ValueRef { - check (!*terminated); + assert (!*terminated); *terminated = true; ret llvm.LLVMBuildInvoke(B, Fn, _vec.buf[ValueRef](Args), @@ -919,209 +919,209 @@ obj builder(BuilderRef B, @mutable bool terminated) { } 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), @@ -1129,7 +1129,7 @@ obj builder(BuilderRef B, @mutable bool terminated) { } 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), @@ -1137,125 +1137,125 @@ obj builder(BuilderRef B, @mutable bool terminated) { } 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("")); } @@ -1263,9 +1263,9 @@ obj builder(BuilderRef B, @mutable bool terminated) { /* 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), @@ -1276,7 +1276,7 @@ obj builder(BuilderRef B, @mutable bool terminated) { 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), @@ -1284,7 +1284,7 @@ obj builder(BuilderRef B, @mutable bool terminated) { } 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), @@ -1292,7 +1292,7 @@ obj builder(BuilderRef B, @mutable bool terminated) { } 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), @@ -1302,65 +1302,65 @@ obj builder(BuilderRef B, @mutable bool terminated) { } 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), @@ -1391,8 +1391,8 @@ state obj type_names(std.map.hashmap[TypeRef, str] type_names, 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); } diff --git a/src/comp/middle/fold.rs b/src/comp/middle/fold.rs index a0f3bc93f955d..e932fd9af497c 100644 --- a/src/comp/middle/fold.rs +++ b/src/comp/middle/fold.rs @@ -196,7 +196,10 @@ type ast_fold[ENV] = @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, @@ -796,10 +799,16 @@ fn fold_expr[ENV](&ENV env, ast_fold[ENV] fld, &@expr e) -> @expr { 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)) { @@ -1380,9 +1389,14 @@ fn identity_fold_expr_log[ENV](&ENV e, &span sp, int lvl, @expr x, 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 { @@ -1676,8 +1690,11 @@ fn new_identity_fold[ENV]() -> ast_fold[ENV] { 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](_,_,_,_), diff --git a/src/comp/middle/metadata.rs b/src/comp/middle/metadata.rs index 806f38b525281..bec6262847e3c 100644 --- a/src/comp/middle/metadata.rs +++ b/src/comp/middle/metadata.rs @@ -63,7 +63,7 @@ mod Encode { ); 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(); diff --git a/src/comp/middle/resolve.rs b/src/comp/middle/resolve.rs index d75a6db09d9ab..c045413c2dba7 100644 --- a/src/comp/middle/resolve.rs +++ b/src/comp/middle/resolve.rs @@ -662,7 +662,7 @@ fn fold_pat_tag(&env e, &span sp, ast.path p, vec[@ast.pat] args, 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, diff --git a/src/comp/middle/trans.rs b/src/comp/middle/trans.rs index 93cc0b4903b45..3123681a57826 100644 --- a/src/comp/middle/trans.rs +++ b/src/comp/middle/trans.rs @@ -586,7 +586,7 @@ fn type_of_explicit_args(@crate_ctxt cx, vec[ty.arg] inputs) -> vec[TypeRef] { 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; @@ -632,7 +632,7 @@ fn type_of_fn_full(@crate_ctxt cx, // 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 (_) { @@ -800,7 +800,7 @@ fn type_of_inner(@crate_ctxt cx, ty.t t) -> TypeRef { 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)), @@ -1355,7 +1355,7 @@ fn dynamic_align_of(@block_ctxt cx, ty.t t) -> result { 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. @@ -1393,17 +1393,17 @@ fn GEP_tup_like(@block_ctxt cx, ty.t t, // 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(); @@ -1597,8 +1597,8 @@ fn get_tydesc(&@block_ctxt cx, ty.t t, bool escapes) -> result { 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; @@ -2321,7 +2321,7 @@ fn tag_variants(@crate_ctxt cx, ast.def_id id) -> vec[variant_info] { 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(); @@ -3340,7 +3340,7 @@ fn join_results(@block_ctxt parent_cx, // 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); } @@ -3968,7 +3968,7 @@ fn lval_generic_fn(@block_ctxt cx, 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. @@ -4011,7 +4011,7 @@ fn lookup_discriminant(@local_ctxt lcx, ast.def_id tid, ast.def_id vid) 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)); @@ -4033,7 +4033,7 @@ fn trans_path(@block_ctxt cx, &ast.path p, &option.t[ast.def] dopt, 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)) { @@ -4044,7 +4044,7 @@ fn trans_path(@block_ctxt cx, &ast.path p, &option.t[ast.def] dopt, 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)) { @@ -4053,11 +4053,11 @@ fn trans_path(@block_ctxt cx, &ast.path p, &option.t[ast.def] dopt, } } 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)) { @@ -4109,7 +4109,7 @@ fn trans_path(@block_ctxt cx, &ast.path p, &option.t[ast.def] dopt, } 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)) { @@ -4248,7 +4248,7 @@ fn trans_lval(@block_ctxt cx, @ast.expr e) -> lval_result { 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, @@ -4412,7 +4412,7 @@ fn trans_bind_thunk(@local_ctxt cx, } } 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); } @@ -4425,7 +4425,7 @@ fn trans_bind_thunk(@local_ctxt cx, 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); } @@ -5115,7 +5115,7 @@ fn trans_expr(@block_ctxt cx, @ast.expr e) -> result { 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. @@ -5126,7 +5126,7 @@ fn trans_expr(@block_ctxt cx, @ast.expr e) -> result { 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) { @@ -5183,7 +5183,11 @@ fn trans_expr(@block_ctxt cx, @ast.expr e) -> result { 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); } @@ -5504,7 +5508,7 @@ fn trans_ret(@block_ctxt cx, &option.t[@ast.expr] e) -> result { 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)); @@ -5600,7 +5604,7 @@ fn trans_recv(@block_ctxt cx, @ast.expr lhs, @ast.expr rhs, 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); @@ -5632,7 +5636,7 @@ fn recv_val(@block_ctxt cx, ValueRef lhs, @ast.expr rhs, 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; @@ -5748,7 +5752,7 @@ fn trans_block_cleanups(@block_ctxt 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); @@ -5969,7 +5973,7 @@ fn create_llargs_for_fn_args(&@fn_ctxt cx, 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; @@ -5979,14 +5983,14 @@ fn create_llargs_for_fn_args(&@fn_ctxt cx, 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; } @@ -6424,7 +6428,7 @@ fn trans_tag_variant(@local_ctxt cx, ast.def_id tag_id, 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); @@ -6691,7 +6695,7 @@ fn decl_native_fn_and_pair(@crate_ctxt ccx, 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; } @@ -6757,7 +6761,7 @@ fn decl_native_fn_and_pair(@crate_ctxt ccx, 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)); diff --git a/src/comp/middle/ty.rs b/src/comp/middle/ty.rs index 83befefc70122..220adcb1a23aa 100644 --- a/src/comp/middle/ty.rs +++ b/src/comp/middle/ty.rs @@ -895,7 +895,7 @@ fn type_is_tup_like(ctxt cx, t ty) -> bool { } 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; @@ -1785,50 +1785,117 @@ fn pat_ty(ctxt cx, @ast.pat pat) -> t { 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. @@ -1838,35 +1905,21 @@ fn expr_ann(@ast.expr expr) -> option.t[ast.ann] { // 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); } } } @@ -2233,7 +2286,7 @@ mod Unify { 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)); } } @@ -2601,7 +2654,7 @@ mod Unify { 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); diff --git a/src/comp/middle/typeck.rs b/src/comp/middle/typeck.rs index 3354fe46ad963..094b7e1f0ee99 100644 --- a/src/comp/middle/typeck.rs +++ b/src/comp/middle/typeck.rs @@ -110,7 +110,7 @@ fn ty_param_count_and_ty_for_def(@fn_ctxt fcx, &ast.span sp, &ast.def defn) -> 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)) { @@ -122,7 +122,7 @@ fn ty_param_count_and_ty_for_def(@fn_ctxt fcx, &ast.span sp, &ast.def defn) 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)) { @@ -142,7 +142,7 @@ fn ty_param_count_and_ty_for_def(@fn_ctxt fcx, &ast.span sp, &ast.def defn) 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)) { @@ -298,7 +298,7 @@ fn ast_ty_to_ty(ty.ctxt tcx, ty_getter getter, &@ast.ty ast_ty) -> ty.t { } 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); @@ -411,7 +411,7 @@ mod Collect { 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; @@ -672,7 +672,7 @@ mod Collect { 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); @@ -681,7 +681,7 @@ mod Collect { 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); @@ -690,7 +690,7 @@ mod Collect { 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)); @@ -721,7 +721,7 @@ mod Collect { 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(); @@ -777,7 +777,7 @@ mod Collect { 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); @@ -1214,7 +1214,7 @@ mod Pushdown { 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, @@ -1409,7 +1409,8 @@ mod Pushdown { 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, @@ -1839,7 +1840,7 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr { 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); @@ -1939,7 +1940,7 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr { 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, @@ -1953,12 +1954,25 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr { 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))); } diff --git a/src/comp/middle/typestate_check.rs b/src/comp/middle/typestate_check.rs index d08ae82d603d7..e15c720a3d957 100644 --- a/src/comp/middle/typestate_check.rs +++ b/src/comp/middle/typestate_check.rs @@ -55,7 +55,8 @@ import front.ast.expr_put; 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; @@ -147,8 +148,7 @@ import util.typestate_ann.clone; 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; @@ -293,11 +293,11 @@ type fn_info = std.map.hashmap[def_id, var_info]; 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); } @@ -389,116 +389,6 @@ fn mk_f_to_fn_info(@ast.crate c) -> fn_info_map { 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); } @@ -532,7 +422,7 @@ fn ann_to_ts_ann_fail_more(ann a) -> @ts_ann { fail; } case (ann_type(_,_,?t)) { - check (! is_none[@ts_ann](t)); + assert (! is_none[@ts_ann](t)); ret get[@ts_ann](t); } } @@ -557,7 +447,7 @@ fn stmt_to_ann(&stmt s) -> option.t[@ts_ann] { } /* 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)"; @@ -578,7 +468,7 @@ fn expr_states(&expr e) -> pre_and_post_state { } /* 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)"; @@ -664,19 +554,19 @@ fn stmt_states(&stmt s, uint nv) -> pre_and_post_state { } -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; } @@ -737,7 +627,7 @@ fn seq_preconds(fn_info enclosing, vec[pre_and_post] pps) -> precond { 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); @@ -797,7 +687,7 @@ fn intersect_postconds_go(&postcond first, &vec[postcond] rest) -> postcond { } 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); } @@ -826,7 +716,7 @@ fn find_pre_post_state_native_mod(&native_mod m) -> bool { 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,_); @@ -836,7 +726,7 @@ fn find_pre_post_obj(&fn_info_map fm, _obj o) -> () { 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,_); @@ -849,10 +739,10 @@ fn find_pre_post_state_obj(fn_info_map fm, _obj o) -> bool { 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)) { @@ -883,14 +773,14 @@ fn find_pre_post_exprs(&fn_info_map fm, &fn_info enclosing, 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); @@ -904,31 +794,31 @@ fn find_pre_post_exprs(&fn_info_map fm, &fn_info enclosing, 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)) { @@ -974,18 +864,18 @@ fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, &expr e) -> () { 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)); @@ -1004,10 +894,10 @@ fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, &expr e) -> () { 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 (_) { @@ -1020,10 +910,10 @@ fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, &expr e) -> () { 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 (_) { @@ -1049,45 +939,45 @@ fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, &expr e) -> () { 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)); @@ -1107,31 +997,31 @@ fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, &expr e) -> () { 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)) { @@ -1141,7 +1031,7 @@ fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, &expr e) -> () { 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)) { @@ -1154,7 +1044,7 @@ fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, &expr e) -> () { 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); @@ -1170,7 +1060,7 @@ fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, &expr e) -> () { 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, _, _); @@ -1181,8 +1071,8 @@ fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, &expr e) -> () { 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, @@ -1191,10 +1081,14 @@ fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, &expr e) -> () { 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); @@ -1211,21 +1105,21 @@ fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, &expr e) -> () { 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); @@ -1233,7 +1127,7 @@ fn declare_var(&fn_info enclosing, def_id id, prestate pre) } 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); @@ -1251,8 +1145,8 @@ fn find_pre_post_stmt(fn_info_map fm, &fn_info enclosing, &ast.stmt s) 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 @@ -1281,8 +1175,8 @@ fn find_pre_post_stmt(fn_info_map fm, &fn_info enclosing, &ast.stmt s) } } 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)); } } } @@ -1318,7 +1212,7 @@ fn find_pre_post_block(&fn_info_map fm, &fn_info enclosing, block b) _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); @@ -1331,7 +1225,7 @@ fn find_pre_post_block(&fn_info_map fm, &fn_info enclosing, block b) 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, @@ -1363,7 +1257,7 @@ fn check_item_fn(&fn_info_map fm, &span sp, ident i, &ast._fn f, 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)); @@ -1377,7 +1271,7 @@ fn find_pre_post_state_item(fn_info_map fm, fn_info enclosing, @item i) 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)) { @@ -1401,7 +1295,7 @@ fn find_pre_post_state_item(fn_info_map fm, fn_info enclosing, @item i) 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) { @@ -1415,8 +1309,8 @@ fn set_prestate_ann(@ann a, prestate pre) -> bool { 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"); @@ -1428,8 +1322,8 @@ fn extend_prestate_ann(ann a, prestate pre) -> bool { 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"); @@ -1441,7 +1335,7 @@ fn set_poststate_ann(ann a, poststate post) -> bool { 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) { @@ -1454,7 +1348,7 @@ fn extend_poststate_ann(ann a, poststate post) -> bool { 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); @@ -1478,7 +1372,7 @@ fn seq_states(&fn_info_map fm, &fn_info enclosing, 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); @@ -1513,8 +1407,8 @@ fn find_pre_post_state_loop(fn_info_map fm, fn_info enclosing, /* 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; @@ -1522,7 +1416,7 @@ fn find_pre_post_state_loop(fn_info_map fm, fn_info enclosing, } 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); @@ -1540,20 +1434,20 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info 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)) { @@ -1563,19 +1457,19 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing, /* 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; } @@ -1584,7 +1478,7 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing, 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; } @@ -1611,7 +1505,7 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing, 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; } } @@ -1626,7 +1520,7 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing, 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; } @@ -1635,8 +1529,8 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing, 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; } } @@ -1651,7 +1545,7 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing, 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; } @@ -1660,8 +1554,8 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing, 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; } } @@ -1691,17 +1585,17 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing, 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; } } @@ -1710,7 +1604,7 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing, log("new prestate:"); log_bitv(enclosing, pres); log("new poststate:"); - log_bitv(enclosing, expr_poststate(*e)); + log_bitv(enclosing, expr_poststate(e)); ret changed; } @@ -1720,8 +1614,8 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing, 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)) { @@ -1729,8 +1623,8 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing, 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)) { @@ -1739,8 +1633,8 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing, 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)) { @@ -1756,9 +1650,9 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing, 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; } @@ -1777,7 +1671,7 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing, 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; } @@ -1793,14 +1687,14 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing, 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); @@ -1821,14 +1715,14 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing, 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; } @@ -1836,7 +1730,7 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing, 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; } @@ -1845,14 +1739,15 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing, /* 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; } @@ -1875,7 +1770,7 @@ fn find_pre_post_state_stmt(&fn_info_map fm, &fn_info enclosing, &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); @@ -1897,7 +1792,7 @@ fn find_pre_post_state_stmt(&fn_info_map fm, &fn_info enclosing, 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 = "); @@ -1932,10 +1827,10 @@ fn find_pre_post_state_stmt(&fn_info_map fm, &fn_info enclosing, } 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); @@ -1980,7 +1875,7 @@ fn find_pre_post_state_block(&fn_info_map fm, &fn_info enclosing, 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); } } @@ -2038,13 +1933,13 @@ fn fixed_point_states(fn_info_map fm, fn_info f_info, } } -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: "); @@ -2093,7 +1988,7 @@ fn check_states_against_conditions(fn_info enclosing, &ast._fn f) -> () { _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); @@ -2116,7 +2011,7 @@ fn check_item_fn_state(&fn_info_map f_info_map, &span sp, ident i, 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); @@ -2126,7 +2021,7 @@ fn check_item_fn_state(&fn_info_map f_info_map, &span sp, ident i, } 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); } @@ -2193,7 +2088,7 @@ fn init_block(&fn_info fi, &span sp, &block_ b) -> block { 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"); @@ -2413,8 +2308,11 @@ fn annotate_expr(&fn_info_map fm, &@expr e) -> @expr { 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)) { diff --git a/src/comp/middle/walk.rs b/src/comp/middle/walk.rs index dbc188b1d4066..8a5d40dc563c4 100644 --- a/src/comp/middle/walk.rs +++ b/src/comp/middle/walk.rs @@ -392,7 +392,10 @@ fn walk_expr(&ast_visitor v, @ast.expr e) { 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(_)) { } diff --git a/src/comp/pretty/pprust.rs b/src/comp/pretty/pprust.rs index e49ed34e948b1..7ef91ce89e4f9 100644 --- a/src/comp/pretty/pprust.rs +++ b/src/comp/pretty/pprust.rs @@ -661,12 +661,18 @@ fn print_expr(ps s, &@ast.expr expr) { } 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); diff --git a/src/comp/util/typestate_ann.rs b/src/comp/util/typestate_ann.rs index b7fbc3cc25d58..9e815b4648497 100644 --- a/src/comp/util/typestate_ann.rs +++ b/src/comp/util/typestate_ann.rs @@ -85,7 +85,7 @@ fn intersect(&precond p1, &precond p2) -> bool { 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; } @@ -129,7 +129,7 @@ fn set_prestate(@ts_ann a, &prestate p) -> bool { // 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); } diff --git a/src/lib/Term.rs b/src/lib/Term.rs index 0d925d7d0249c..368fe21710ed7 100644 --- a/src/lib/Term.rs +++ b/src/lib/Term.rs @@ -35,7 +35,7 @@ fn color_supported() -> bool { } fn set_color(io.buf_writer writer, u8 first_char, u8 color) { - check (color < 16u8); + assert (color < 16u8); esc(writer); if (color >= 8u8) { diff --git a/src/lib/_int.rs b/src/lib/_int.rs index dfd2204d007a9..1824d142dab79 100644 --- a/src/lib/_int.rs +++ b/src/lib/_int.rs @@ -27,7 +27,7 @@ iter range(int lo, int hi) -> int { 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 { diff --git a/src/lib/_str.rs b/src/lib/_str.rs index 44f14fb6e1cc3..ed2027e1da29a 100644 --- a/src/lib/_str.rs +++ b/src/lib/_str.rs @@ -218,14 +218,14 @@ fn utf8_char_width(u8 b) -> uint { 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; @@ -247,11 +247,11 @@ fn char_len(str s) -> uint { 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; } @@ -274,7 +274,7 @@ fn push_char(&mutable str s, char ch) { 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; @@ -404,7 +404,7 @@ fn slice(str s, uint begin, uint end) -> str { 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; @@ -412,7 +412,7 @@ fn shift_byte(&mutable str s) -> u8 { 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; diff --git a/src/lib/_uint.rs b/src/lib/_uint.rs index 97108c9082b64..2d373cdd2babc 100644 --- a/src/lib/_uint.rs +++ b/src/lib/_uint.rs @@ -56,7 +56,7 @@ fn to_str(uint num, uint radix) -> str { auto n = num; - check (0u < radix && radix <= 16u); + assert (0u < radix && radix <= 16u); fn digit(uint n) -> char { alt (n) { case (0u) { ret '0'; } diff --git a/src/lib/_vec.rs b/src/lib/_vec.rs index 126bf363052c0..4761a867494df 100644 --- a/src/lib/_vec.rs +++ b/src/lib/_vec.rs @@ -131,7 +131,7 @@ fn len_set[T](array[T] v, uint n) { } 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); } @@ -149,9 +149,10 @@ fn last[T](array[T] v) -> option.t[T] { } // 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) { @@ -163,7 +164,7 @@ fn slice[T](array[T] v, uint start, uint end) -> vec[T] { 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; @@ -171,7 +172,7 @@ fn shift[T](&mutable array[T] v) -> T { 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); diff --git a/src/lib/bitv.rs b/src/lib/bitv.rs index feb4296aa6efd..f52b016b76883 100644 --- a/src/lib/bitv.rs +++ b/src/lib/bitv.rs @@ -28,8 +28,8 @@ fn create(uint nbits, bool init) -> t { 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; @@ -84,7 +84,7 @@ fn clone(t v) -> t { } fn get(&t v, uint i) -> bool { - check (i < v.nbits); + assert (i < v.nbits); auto bits = uint_bits(); @@ -129,7 +129,7 @@ fn difference(&t v0, &t v1) -> bool { } fn set(&t v, uint i, bool x) { - check (i < v.nbits); + assert (i < v.nbits); auto bits = uint_bits(); @@ -196,7 +196,7 @@ fn to_str(&t v) -> str { // 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) { diff --git a/src/lib/deque.rs b/src/lib/deque.rs index 776f82e99fe8f..ee706ae7e7d1b 100644 --- a/src/lib/deque.rs +++ b/src/lib/deque.rs @@ -28,7 +28,7 @@ fn create[T]() -> t[T] { * 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] { diff --git a/src/lib/ebml.rs b/src/lib/ebml.rs index f73ad4fc64743..9bad0f3311d8c 100644 --- a/src/lib/ebml.rs +++ b/src/lib/ebml.rs @@ -99,7 +99,7 @@ fn doc_data(doc d) -> vec[u8] { 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) { diff --git a/src/lib/fs.rs b/src/lib/fs.rs index 774ce11324cbc..e185ca3e8c25c 100644 --- a/src/lib/fs.rs +++ b/src/lib/fs.rs @@ -10,7 +10,7 @@ type path = str; 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; diff --git a/src/lib/io.rs b/src/lib/io.rs index 4c1bf2dfb2b12..7d59da3040086 100644 --- a/src/lib/io.rs +++ b/src/lib/io.rs @@ -72,7 +72,7 @@ state obj FILE_buf_reader(os.libc.FILE f, bool must_close) { 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; @@ -101,14 +101,14 @@ state obj new_reader(buf_reader rdr) { 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; } @@ -279,7 +279,7 @@ state obj FILE_writer(os.libc.FILE f, bool must_close) { } 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 { diff --git a/src/lib/linux_os.rs b/src/lib/linux_os.rs index d5230e9ae09c4..d2a8ff97aafad 100644 --- a/src/lib/linux_os.rs +++ b/src/lib/linux_os.rs @@ -66,7 +66,7 @@ fn dylib_filename(str base) -> str { 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)); } @@ -76,7 +76,7 @@ fn fd_FILE(int fd) -> libc.FILE { 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); } diff --git a/src/lib/macos_os.rs b/src/lib/macos_os.rs index b0980bc522581..a52b02c5658e5 100644 --- a/src/lib/macos_os.rs +++ b/src/lib/macos_os.rs @@ -63,7 +63,7 @@ fn dylib_filename(str base) -> str { 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)); } @@ -73,7 +73,7 @@ fn fd_FILE(int fd) -> libc.FILE { 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); } diff --git a/src/lib/posix_fs.rs b/src/lib/posix_fs.rs index 03115fc7d331b..f4cf12d35f299 100644 --- a/src/lib/posix_fs.rs +++ b/src/lib/posix_fs.rs @@ -5,7 +5,7 @@ native "rust" mod rustrt { 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); diff --git a/src/lib/sha1.rs b/src/lib/sha1.rs index 3866be1e04cfe..690489db345fa 100644 --- a/src/lib/sha1.rs +++ b/src/lib/sha1.rs @@ -43,7 +43,7 @@ fn mk_sha1() -> sha1 { 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; @@ -67,7 +67,7 @@ fn mk_sha1() -> sha1 { 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, @@ -192,7 +192,7 @@ fn mk_sha1() -> sha1 { */ 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 @@ -236,7 +236,7 @@ fn mk_sha1() -> sha1 { 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; diff --git a/src/lib/win32_os.rs b/src/lib/win32_os.rs index a2940d8de55ea..1c6521e31f699 100644 --- a/src/lib/win32_os.rs +++ b/src/lib/win32_os.rs @@ -53,7 +53,7 @@ fn dylib_filename(str base) -> str { 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)); } diff --git a/src/test/run-fail/fail.rs b/src/test/run-fail/fail.rs index e8c9cf71bcbee..c688a40426d56 100644 --- a/src/test/run-fail/fail.rs +++ b/src/test/run-fail/fail.rs @@ -2,5 +2,5 @@ // error-pattern:1 == 2 fn main() { - check (1 == 2); + assert (1 == 2); } diff --git a/src/test/run-fail/linked-failure.rs b/src/test/run-fail/linked-failure.rs index 7def7c11d0a22..60e82200848a0 100644 --- a/src/test/run-fail/linked-failure.rs +++ b/src/test/run-fail/linked-failure.rs @@ -4,7 +4,7 @@ // error-pattern:1 == 2 fn child() { - check (1 == 2); + assert (1 == 2); } fn main() { diff --git a/src/test/run-fail/str-overrun.rs b/src/test/run-fail/str-overrun.rs index 4388cb3ac802e..68b1e263d27fa 100644 --- a/src/test/run-fail/str-overrun.rs +++ b/src/test/run-fail/str-overrun.rs @@ -6,12 +6,12 @@ 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)); } diff --git a/src/test/run-fail/vec-overrun.rs b/src/test/run-fail/vec-overrun.rs index 961da730e3bda..810feb39bcd9e 100644 --- a/src/test/run-fail/vec-overrun.rs +++ b/src/test/run-fail/vec-overrun.rs @@ -6,7 +6,7 @@ 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); } diff --git a/src/test/run-fail/vec-underrun.rs b/src/test/run-fail/vec-underrun.rs index a230d1be7ff76..f1998da529321 100644 --- a/src/test/run-fail/vec-underrun.rs +++ b/src/test/run-fail/vec-underrun.rs @@ -6,7 +6,7 @@ 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); } diff --git a/src/test/run-pass/alt-pattern-drop.rs b/src/test/run-pass/alt-pattern-drop.rs index 4ee2c12bec25d..b92ffd7481bda 100644 --- a/src/test/run-pass/alt-pattern-drop.rs +++ b/src/test/run-pass/alt-pattern-drop.rs @@ -21,12 +21,12 @@ fn foo(str s) { } 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); } diff --git a/src/test/run-pass/alt-pattern-lit.rs b/src/test/run-pass/alt-pattern-lit.rs index 91190260bb10f..bad74a2a3cefd 100644 --- a/src/test/run-pass/alt-pattern-lit.rs +++ b/src/test/run-pass/alt-pattern-lit.rs @@ -12,6 +12,6 @@ fn altlit(int f) -> int { } fn main() { - check (altlit(10) == 20); - check (altlit(11) == 22); + assert (altlit(10) == 20); + assert (altlit(11) == 22); } diff --git a/src/test/run-pass/alt-tag.rs b/src/test/run-pass/alt-tag.rs index 68013dfe303a7..bc0afcb5fec48 100644 --- a/src/test/run-pass/alt-tag.rs +++ b/src/test/run-pass/alt-tag.rs @@ -32,8 +32,8 @@ fn main() { 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); } diff --git a/src/test/run-pass/arith-0.rs b/src/test/run-pass/arith-0.rs index 7587b0050ad37..857eaa8e42a7d 100644 --- a/src/test/run-pass/arith-0.rs +++ b/src/test/run-pass/arith-0.rs @@ -1,5 +1,5 @@ fn main() -> () { let int a = 10; log a; - check (a * (a - 1) == 90); + assert (a * (a - 1) == 90); } \ No newline at end of file diff --git a/src/test/run-pass/arith-1.rs b/src/test/run-pass/arith-1.rs index bac6a055e80e1..55230e9e5dac5 100644 --- a/src/test/run-pass/arith-1.rs +++ b/src/test/run-pass/arith-1.rs @@ -1,22 +1,22 @@ 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 diff --git a/src/test/run-pass/arith-2.rs b/src/test/run-pass/arith-2.rs index 33a740c84fce6..70892682b777d 100644 --- a/src/test/run-pass/arith-2.rs +++ b/src/test/run-pass/arith-2.rs @@ -1,5 +1,5 @@ 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 diff --git a/src/test/run-pass/arith-unsigned.rs b/src/test/run-pass/arith-unsigned.rs index 748ff6b7da32b..0e2818a3a45da 100644 --- a/src/test/run-pass/arith-unsigned.rs +++ b/src/test/run-pass/arith-unsigned.rs @@ -2,24 +2,24 @@ // 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 } diff --git a/src/test/run-pass/autoderef-full-lval.rs b/src/test/run-pass/autoderef-full-lval.rs index 956a7eb440b55..5df5456b773ee 100644 --- a/src/test/run-pass/autoderef-full-lval.rs +++ b/src/test/run-pass/autoderef-full-lval.rs @@ -8,11 +8,11 @@ fn main() { 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); } diff --git a/src/test/run-pass/bind-exterior.rs b/src/test/run-pass/bind-exterior.rs index c3fc2e7c36137..f6f369185fc7a 100644 --- a/src/test/run-pass/bind-exterior.rs +++ b/src/test/run-pass/bind-exterior.rs @@ -4,5 +4,5 @@ fn foo(@int a, @int b) -> int { fn main() { auto f1 = bind foo(@10, @12); - check(f1() == 22); + assert (f1() == 22); } diff --git a/src/test/run-pass/bind-interior.rs b/src/test/run-pass/bind-interior.rs index 2d164e07e058c..ae994d1c7ab81 100644 --- a/src/test/run-pass/bind-interior.rs +++ b/src/test/run-pass/bind-interior.rs @@ -7,5 +7,5 @@ fn f(int n) -> int { fn main() { let fn() -> int g = bind f(10); let int i = g(); - check(i == 10); + assert (i == 10); } diff --git a/src/test/run-pass/bind-obj-ctor.rs b/src/test/run-pass/bind-obj-ctor.rs index 8780b22a002d8..b5215f9ad6887 100644 --- a/src/test/run-pass/bind-obj-ctor.rs +++ b/src/test/run-pass/bind-obj-ctor.rs @@ -11,7 +11,7 @@ fn main() { 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); } diff --git a/src/test/run-pass/bind-thunk.rs b/src/test/run-pass/bind-thunk.rs index be6e1b24e133e..7cafc50108d65 100644 --- a/src/test/run-pass/bind-thunk.rs +++ b/src/test/run-pass/bind-thunk.rs @@ -7,5 +7,5 @@ fn f() -> int { fn main() { let fn() -> int g = bind f(); let int i = g(); - check(i == 42); + assert (i == 42); } diff --git a/src/test/run-pass/bind-trivial.rs b/src/test/run-pass/bind-trivial.rs index fbd6e78d797bd..e73f2b7ca3c8f 100644 --- a/src/test/run-pass/bind-trivial.rs +++ b/src/test/run-pass/bind-trivial.rs @@ -7,5 +7,5 @@ fn f(int n) -> int { fn main() { let fn(int) -> int g = bind f(_); let int i = g(42); - check(i == 42); + assert (i == 42); } diff --git a/src/test/run-pass/bitwise.rs b/src/test/run-pass/bitwise.rs index 36b58a9172632..9932448918656 100644 --- a/src/test/run-pass/bitwise.rs +++ b/src/test/run-pass/bitwise.rs @@ -8,14 +8,14 @@ fn main() { 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); } diff --git a/src/test/run-pass/bool-not.rs b/src/test/run-pass/bool-not.rs index ba70bdb1318dc..337efc6f85f97 100644 --- a/src/test/run-pass/bool-not.rs +++ b/src/test/run-pass/bool-not.rs @@ -2,14 +2,14 @@ fn main() { if (!false) { - check (true); + assert (true); } else { - check (false); + assert (false); } if (!true) { - check (false); + assert (false); } else { - check (true); + assert (true); } } diff --git a/src/test/run-pass/box-compare.rs b/src/test/run-pass/box-compare.rs index 619790d796512..8f23035dbd863 100644 --- a/src/test/run-pass/box-compare.rs +++ b/src/test/run-pass/box-compare.rs @@ -1,6 +1,6 @@ // 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 diff --git a/src/test/run-pass/box-unbox.rs b/src/test/run-pass/box-unbox.rs index d0ad615b2e61c..b1d5053360785 100644 --- a/src/test/run-pass/box-unbox.rs +++ b/src/test/run-pass/box-unbox.rs @@ -6,5 +6,5 @@ fn main() { 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); } diff --git a/src/test/run-pass/box.rs b/src/test/run-pass/box.rs index ffcd9ec594628..c105e80146cc9 100644 --- a/src/test/run-pass/box.rs +++ b/src/test/run-pass/box.rs @@ -1,4 +1,4 @@ fn main() { let @int x = @10; - check ((*x) == 10); + assert ((*x) == 10); } diff --git a/src/test/run-pass/break.rs b/src/test/run-pass/break.rs index 48c3b091f08b0..5a63d9acb48c2 100644 --- a/src/test/run-pass/break.rs +++ b/src/test/run-pass/break.rs @@ -6,35 +6,35 @@ fn main() { 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); } } diff --git a/src/test/run-pass/cast.rs b/src/test/run-pass/cast.rs index e04ad62939d21..ecc7ac12db1fc 100644 --- a/src/test/run-pass/cast.rs +++ b/src/test/run-pass/cast.rs @@ -3,14 +3,14 @@ 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)); } diff --git a/src/test/run-pass/char.rs b/src/test/run-pass/char.rs index 123f2eb26c42e..a3ddae6c7cb90 100644 --- a/src/test/run-pass/char.rs +++ b/src/test/run-pass/char.rs @@ -1,12 +1,12 @@ 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); } diff --git a/src/test/run-pass/clone-with-exterior.rs b/src/test/run-pass/clone-with-exterior.rs index e97c409d50f3b..99c319c26d0f3 100644 --- a/src/test/run-pass/clone-with-exterior.rs +++ b/src/test/run-pass/clone-with-exterior.rs @@ -1,8 +1,8 @@ // 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() { diff --git a/src/test/run-pass/comm.rs b/src/test/run-pass/comm.rs index 2bca62488dc93..ef93eee634964 100644 --- a/src/test/run-pass/comm.rs +++ b/src/test/run-pass/comm.rs @@ -8,7 +8,7 @@ fn main() { y <- p; log "received"; log y; - check (y == 10); + assert (y == 10); } fn child(chan[int] c) { diff --git a/src/test/run-pass/decl-with-recv.rs b/src/test/run-pass/decl-with-recv.rs index 5630d2e278dd9..36487aa83b53f 100644 --- a/src/test/run-pass/decl-with-recv.rs +++ b/src/test/run-pass/decl-with-recv.rs @@ -6,9 +6,9 @@ fn main() { ch <| 10; let int i <- po; - check (i == 10); + assert (i == 10); ch <| 11; auto j <- po; - check (j == 11); + assert (j == 11); } diff --git a/src/test/run-pass/deep.rs b/src/test/run-pass/deep.rs index 5131c42b0fe00..32d4dae1fece8 100644 --- a/src/test/run-pass/deep.rs +++ b/src/test/run-pass/deep.rs @@ -10,5 +10,5 @@ fn f(int x) -> int { } fn main() { - check (f(5000) == 5000); + assert (f(5000) == 5000); } diff --git a/src/test/run-pass/div-mod.rs b/src/test/run-pass/div-mod.rs index cfa0fbe9c1776..00835d41c7210 100644 --- a/src/test/run-pass/div-mod.rs +++ b/src/test/run-pass/div-mod.rs @@ -3,15 +3,15 @@ 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); } diff --git a/src/test/run-pass/else-if.rs b/src/test/run-pass/else-if.rs index d9e5b8690250f..edb25e16f73c4 100644 --- a/src/test/run-pass/else-if.rs +++ b/src/test/run-pass/else-if.rs @@ -1,42 +1,42 @@ 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); } } } diff --git a/src/test/run-pass/expr-alt-box.rs b/src/test/run-pass/expr-alt-box.rs index 2e7846f36c337..e18611fa96ff7 100644 --- a/src/test/run-pass/expr-alt-box.rs +++ b/src/test/run-pass/expr-alt-box.rs @@ -9,7 +9,7 @@ fn test_box() { @100 } }; - check (*res == 100); + assert (*res == 100); } fn test_str() { @@ -18,7 +18,7 @@ fn test_str() { "happy" } }; - check (res == "happy"); + assert (res == "happy"); } fn main() { diff --git a/src/test/run-pass/expr-alt-generic-box1.rs b/src/test/run-pass/expr-alt-generic-box1.rs index 8ff67f0ff3b70..a1367e81b8cf7 100644 --- a/src/test/run-pass/expr-alt-generic-box1.rs +++ b/src/test/run-pass/expr-alt-generic-box1.rs @@ -9,7 +9,7 @@ fn test_generic[T](@T expected, &compare[T] eq) { expected } }; - check (eq(expected, actual)); + assert (eq(expected, actual)); } fn test_box() { diff --git a/src/test/run-pass/expr-alt-generic-box2.rs b/src/test/run-pass/expr-alt-generic-box2.rs index 7928ffede5545..469b8e7c6d9f3 100644 --- a/src/test/run-pass/expr-alt-generic-box2.rs +++ b/src/test/run-pass/expr-alt-generic-box2.rs @@ -9,7 +9,7 @@ fn test_generic[T](&T expected, &compare[T] eq) { expected } }; - check (eq(expected, actual)); + assert (eq(expected, actual)); } fn test_vec() { diff --git a/src/test/run-pass/expr-alt-generic.rs b/src/test/run-pass/expr-alt-generic.rs index 6668105955d9d..0cd0177a21513 100644 --- a/src/test/run-pass/expr-alt-generic.rs +++ b/src/test/run-pass/expr-alt-generic.rs @@ -9,7 +9,7 @@ fn test_generic[T](&T expected, &compare[T] eq) { expected } }; - check (eq(expected, actual)); + assert (eq(expected, actual)); } fn test_bool() { diff --git a/src/test/run-pass/expr-alt-struct.rs b/src/test/run-pass/expr-alt-struct.rs index 31406969d87c4..762303d53c17e 100644 --- a/src/test/run-pass/expr-alt-struct.rs +++ b/src/test/run-pass/expr-alt-struct.rs @@ -9,7 +9,7 @@ fn test_rec() { rec(i = 100) } }; - check (res == rec(i = 100)); + assert (res == rec(i = 100)); } fn test_tag() { @@ -26,7 +26,7 @@ fn test_tag() { sad } }; - check (res == happy); + assert (res == happy); } fn main() { diff --git a/src/test/run-pass/expr-alt.rs b/src/test/run-pass/expr-alt.rs index 4c10a7d9e2926..52a01078762b1 100644 --- a/src/test/run-pass/expr-alt.rs +++ b/src/test/run-pass/expr-alt.rs @@ -12,7 +12,7 @@ fn test_basic() { false } }; - check (res); + assert (res); res = alt(false) { case (true) { @@ -22,7 +22,7 @@ fn test_basic() { true } }; - check (res); + assert (res); } fn test_inferrence() { @@ -34,7 +34,7 @@ fn test_inferrence() { false } }; - check (res); + assert (res); } fn test_alt_as_alt_head() { @@ -47,7 +47,7 @@ fn test_alt_as_alt_head() { true } }; - check (res); + assert (res); } fn test_alt_as_block_result() { @@ -66,7 +66,7 @@ fn test_alt_as_block_result() { } } }; - check (res); + assert (res); } fn main() { diff --git a/src/test/run-pass/expr-block-box.rs b/src/test/run-pass/expr-block-box.rs index e8ab62091a59d..206c44afd3ae3 100644 --- a/src/test/run-pass/expr-block-box.rs +++ b/src/test/run-pass/expr-block-box.rs @@ -6,5 +6,5 @@ fn main() { @100 }; - check (*x == 100); + assert (*x == 100); } diff --git a/src/test/run-pass/expr-block-fn.rs b/src/test/run-pass/expr-block-fn.rs index eb0357d9e89ba..a37d1cb0f8d6d 100644 --- a/src/test/run-pass/expr-block-fn.rs +++ b/src/test/run-pass/expr-block-fn.rs @@ -6,7 +6,7 @@ fn test_fn() { ret 10; } let t res = { ten }; - check (res() == 10); + assert (res() == 10); } fn main() { diff --git a/src/test/run-pass/expr-block-generic-box1.rs b/src/test/run-pass/expr-block-generic-box1.rs index 57487fd617d06..82d54c175d055 100644 --- a/src/test/run-pass/expr-block-generic-box1.rs +++ b/src/test/run-pass/expr-block-generic-box1.rs @@ -5,7 +5,7 @@ type compare[T] = fn(@T t1, @T t2) -> bool; fn test_generic[T](@T expected, &compare[T] eq) { let @T actual = { expected }; - check (eq(expected, actual)); + assert (eq(expected, actual)); } fn test_box() { diff --git a/src/test/run-pass/expr-block-generic-box2.rs b/src/test/run-pass/expr-block-generic-box2.rs index 3b1e44791a074..c1c8260c68151 100644 --- a/src/test/run-pass/expr-block-generic-box2.rs +++ b/src/test/run-pass/expr-block-generic-box2.rs @@ -5,7 +5,7 @@ type compare[T] = fn(&T t1, &T t2) -> bool; fn test_generic[T](&T expected, &compare[T] eq) { let T actual = { expected }; - check (eq(expected, actual)); + assert (eq(expected, actual)); } fn test_vec() { diff --git a/src/test/run-pass/expr-block-generic.rs b/src/test/run-pass/expr-block-generic.rs index ded3b6207045b..d6061a6c84c80 100644 --- a/src/test/run-pass/expr-block-generic.rs +++ b/src/test/run-pass/expr-block-generic.rs @@ -7,7 +7,7 @@ type compare[T] = fn(&T t1, &T t2) -> bool; fn test_generic[T](&T expected, &compare[T] eq) { let T actual = { expected }; - check (eq(expected, actual)); + assert (eq(expected, actual)); } fn test_bool() { diff --git a/src/test/run-pass/expr-block.rs b/src/test/run-pass/expr-block.rs index ecc6f04a34029..1c03a6b0694af 100644 --- a/src/test/run-pass/expr-block.rs +++ b/src/test/run-pass/expr-block.rs @@ -5,12 +5,12 @@ 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() { @@ -21,7 +21,7 @@ fn test_filled_with_stuff() { } a }; - check (res == 10); + assert (res == 10); } fn main() { diff --git a/src/test/run-pass/expr-if-box.rs b/src/test/run-pass/expr-if-box.rs index a629c9c9bc464..d242d7448b777 100644 --- a/src/test/run-pass/expr-if-box.rs +++ b/src/test/run-pass/expr-if-box.rs @@ -5,12 +5,12 @@ 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() { diff --git a/src/test/run-pass/expr-if-generic-box1.rs b/src/test/run-pass/expr-if-generic-box1.rs index 32aea8bb72f15..d1d4c05dee93c 100644 --- a/src/test/run-pass/expr-if-generic-box1.rs +++ b/src/test/run-pass/expr-if-generic-box1.rs @@ -5,7 +5,7 @@ type compare[T] = fn(@T t1, @T t2) -> bool; 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() { diff --git a/src/test/run-pass/expr-if-generic-box2.rs b/src/test/run-pass/expr-if-generic-box2.rs index d414d6d104de7..a126b1c45a9c0 100644 --- a/src/test/run-pass/expr-if-generic-box2.rs +++ b/src/test/run-pass/expr-if-generic-box2.rs @@ -5,7 +5,7 @@ type compare[T] = fn(&T t1, &T t2) -> bool; 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() { diff --git a/src/test/run-pass/expr-if-generic.rs b/src/test/run-pass/expr-if-generic.rs index 0a0db2ddfde31..b86a7553d9893 100644 --- a/src/test/run-pass/expr-if-generic.rs +++ b/src/test/run-pass/expr-if-generic.rs @@ -7,7 +7,7 @@ type compare[T] = fn(&T t1, &T t2) -> bool; 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() { diff --git a/src/test/run-pass/expr-if-struct.rs b/src/test/run-pass/expr-if-struct.rs index df20a3bae6030..6d42c2241d57d 100644 --- a/src/test/run-pass/expr-if-struct.rs +++ b/src/test/run-pass/expr-if-struct.rs @@ -5,7 +5,7 @@ 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() { @@ -15,7 +15,7 @@ fn test_tag() { } auto res = if (true) { happy } else { sad }; - check (res == happy); + assert (res == happy); } fn main() { diff --git a/src/test/run-pass/expr-if.rs b/src/test/run-pass/expr-if.rs index 7c99f2ea82e1c..67f56746de6bd 100644 --- a/src/test/run-pass/expr-if.rs +++ b/src/test/run-pass/expr-if.rs @@ -5,12 +5,12 @@ 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() { @@ -21,7 +21,7 @@ fn test_elseif1() { } else { false }; - check (res); + assert (res); } fn test_elseif2() { @@ -32,7 +32,7 @@ fn test_elseif2() { } else { false }; - check (res); + assert (res); } fn test_elseif3() { @@ -43,12 +43,12 @@ 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() { @@ -57,14 +57,14 @@ 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() { @@ -77,7 +77,7 @@ fn test_if_as_block_result() { } else { false }; - check (res); + assert (res); } fn main() { diff --git a/src/test/run-pass/exterior.rs b/src/test/run-pass/exterior.rs index f09ee8234e35d..661effda38ac1 100644 --- a/src/test/run-pass/exterior.rs +++ b/src/test/run-pass/exterior.rs @@ -3,16 +3,16 @@ 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); } diff --git a/src/test/run-pass/fact.rs b/src/test/run-pass/fact.rs index 91cf099c3acb0..577ee6a226eb7 100644 --- a/src/test/run-pass/fact.rs +++ b/src/test/run-pass/fact.rs @@ -15,7 +15,7 @@ fn f(int x) -> int { } } fn main () { - check (f(5) == 120); + assert (f(5) == 120); // log "all done"; } diff --git a/src/test/run-pass/float2.rs b/src/test/run-pass/float2.rs index 9cc3a8ca9cd31..e6136d2cf4421 100644 --- a/src/test/run-pass/float2.rs +++ b/src/test/run-pass/float2.rs @@ -12,13 +12,13 @@ fn main() { 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 diff --git a/src/test/run-pass/floatlits.rs b/src/test/run-pass/floatlits.rs index 10b0fb7766a60..37f21c8f43a4f 100644 --- a/src/test/run-pass/floatlits.rs +++ b/src/test/run-pass/floatlits.rs @@ -1,9 +1,9 @@ // 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 diff --git a/src/test/run-pass/foreach-nested-2.rs b/src/test/run-pass/foreach-nested-2.rs index d25405d8c6e57..33a376d529e61 100644 --- a/src/test/run-pass/foreach-nested-2.rs +++ b/src/test/run-pass/foreach-nested-2.rs @@ -28,12 +28,12 @@ fn main() { } } - 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); } diff --git a/src/test/run-pass/foreach-nested.rs b/src/test/run-pass/foreach-nested.rs index a655f59101988..9ba304c1463a4 100644 --- a/src/test/run-pass/foreach-nested.rs +++ b/src/test/run-pass/foreach-nested.rs @@ -16,8 +16,8 @@ fn main() { } } - 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); } diff --git a/src/test/run-pass/foreach-put-structured.rs b/src/test/run-pass/foreach-put-structured.rs index 43d8b5c33a897..02dbef5d514b8 100644 --- a/src/test/run-pass/foreach-put-structured.rs +++ b/src/test/run-pass/foreach-put-structured.rs @@ -14,9 +14,9 @@ fn main() { 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 diff --git a/src/test/run-pass/foreach-simple-outer-slot.rs b/src/test/run-pass/foreach-simple-outer-slot.rs index efc6e8ca7025c..8f23d61d03dca 100644 --- a/src/test/run-pass/foreach-simple-outer-slot.rs +++ b/src/test/run-pass/foreach-simple-outer-slot.rs @@ -9,7 +9,7 @@ fn main() { } log "sum"; log sum; - check (sum == 45); + assert (sum == 45); } iter first_ten() -> int { diff --git a/src/test/run-pass/fun-call-variants.rs b/src/test/run-pass/fun-call-variants.rs index 59446b4a771eb..5fa3837e6b3cb 100644 --- a/src/test/run-pass/fun-call-variants.rs +++ b/src/test/run-pass/fun-call-variants.rs @@ -13,7 +13,7 @@ fn main() { 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); } diff --git a/src/test/run-pass/fun-indirect-call.rs b/src/test/run-pass/fun-indirect-call.rs index 10c2cf4050550..1d506dca26e80 100644 --- a/src/test/run-pass/fun-indirect-call.rs +++ b/src/test/run-pass/fun-indirect-call.rs @@ -7,5 +7,5 @@ fn f() -> int { fn main() { let fn() -> int g = f; let int i = g(); - check(i == 42); + assert (i == 42); } diff --git a/src/test/run-pass/generic-alias-box.rs b/src/test/run-pass/generic-alias-box.rs index 377e0fb2b8d14..ce3889fbb4c76 100644 --- a/src/test/run-pass/generic-alias-box.rs +++ b/src/test/run-pass/generic-alias-box.rs @@ -8,5 +8,5 @@ fn main() { auto expected = @100; auto actual = id[@int](expected); log *actual; - check (*expected == *actual); + assert (*expected == *actual); } \ No newline at end of file diff --git a/src/test/run-pass/generic-bind-2.rs b/src/test/run-pass/generic-bind-2.rs index 3975867ac29a3..f3a65edd549ce 100644 --- a/src/test/run-pass/generic-bind-2.rs +++ b/src/test/run-pass/generic-bind-2.rs @@ -5,7 +5,7 @@ fn id[T](&T t) -> T { 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); } diff --git a/src/test/run-pass/generic-bind.rs b/src/test/run-pass/generic-bind.rs index ef1275e3cecd6..c65e061ad214e 100644 --- a/src/test/run-pass/generic-bind.rs +++ b/src/test/run-pass/generic-bind.rs @@ -4,7 +4,7 @@ fn id[T](&T t) -> T { 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); } diff --git a/src/test/run-pass/generic-box.rs b/src/test/run-pass/generic-box.rs index 856f3aff8e6e0..76d5e3ab01b3b 100644 --- a/src/test/run-pass/generic-box.rs +++ b/src/test/run-pass/generic-box.rs @@ -4,5 +4,5 @@ fn box[T](&tup(T,T,T) x) -> @tup(T,T,T) { 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 diff --git a/src/test/run-pass/generic-derived-type.rs b/src/test/run-pass/generic-derived-type.rs index 54c3f9564ecf0..507d1c5fd8799 100644 --- a/src/test/run-pass/generic-derived-type.rs +++ b/src/test/run-pass/generic-derived-type.rs @@ -12,6 +12,6 @@ fn main() { 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); } diff --git a/src/test/run-pass/generic-exterior-box.rs b/src/test/run-pass/generic-exterior-box.rs index 0ec7020cdadda..07eae9c1a4268 100644 --- a/src/test/run-pass/generic-exterior-box.rs +++ b/src/test/run-pass/generic-exterior-box.rs @@ -8,6 +8,6 @@ fn main() { 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); } diff --git a/src/test/run-pass/generic-fn-infer.rs b/src/test/run-pass/generic-fn-infer.rs index 4398670f15e9a..9c795ec250c39 100644 --- a/src/test/run-pass/generic-fn-infer.rs +++ b/src/test/run-pass/generic-fn-infer.rs @@ -9,5 +9,5 @@ fn id[T](&T x) -> T { fn main() { let int x = 42; let int y = id(x); - check (x == y); + assert (x == y); } diff --git a/src/test/run-pass/generic-fn.rs b/src/test/run-pass/generic-fn.rs index 238ef2d1aea2a..4f93fef52c9cb 100644 --- a/src/test/run-pass/generic-fn.rs +++ b/src/test/run-pass/generic-fn.rs @@ -17,16 +17,16 @@ fn main() { 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); } diff --git a/src/test/run-pass/generic-obj-with-derived-type.rs b/src/test/run-pass/generic-obj-with-derived-type.rs index 2a50ccd2bb175..cc549f6bd6efa 100644 --- a/src/test/run-pass/generic-obj-with-derived-type.rs +++ b/src/test/run-pass/generic-obj-with-derived-type.rs @@ -11,7 +11,7 @@ fn main() { 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)); } diff --git a/src/test/run-pass/generic-obj.rs b/src/test/run-pass/generic-obj.rs index ced9140fc60bb..9879fa790b557 100644 --- a/src/test/run-pass/generic-obj.rs +++ b/src/test/run-pass/generic-obj.rs @@ -21,8 +21,8 @@ fn main() { 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); } diff --git a/src/test/run-pass/generic-tag-alt.rs b/src/test/run-pass/generic-tag-alt.rs index 9b19eec7388e3..f29cfa00036fa 100644 --- a/src/test/run-pass/generic-tag-alt.rs +++ b/src/test/run-pass/generic-tag-alt.rs @@ -10,7 +10,7 @@ fn altfoo[T](&foo[T] f) { hit = true; } } - check (hit); + assert (hit); } fn main() { diff --git a/src/test/run-pass/generic-tag-values.rs b/src/test/run-pass/generic-tag-values.rs index 090a050404a92..46421e0a28c6b 100644 --- a/src/test/run-pass/generic-tag-values.rs +++ b/src/test/run-pass/generic-tag-values.rs @@ -9,7 +9,7 @@ fn main() { alt (nop) { case (some[int](?n)) { log n; - check (n == 5); + assert (n == 5); } } @@ -18,8 +18,8 @@ fn main() { 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); } } } diff --git a/src/test/run-pass/generic-temporary.rs b/src/test/run-pass/generic-temporary.rs index 98401ecc1c5ee..2f69712462514 100644 --- a/src/test/run-pass/generic-temporary.rs +++ b/src/test/run-pass/generic-temporary.rs @@ -5,7 +5,7 @@ fn mk() -> int { fn chk(&int a) { log a; - check (a == 1); + assert (a == 1); } fn apply[T](fn() -> T produce, fn(&T) consume) { diff --git a/src/test/run-pass/generic-tup.rs b/src/test/run-pass/generic-tup.rs index c387ef1928dc1..d2edfd2e379b1 100644 --- a/src/test/run-pass/generic-tup.rs +++ b/src/test/run-pass/generic-tup.rs @@ -6,6 +6,6 @@ fn get_third[T](&tup(T,T,T) t) -> T { 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 diff --git a/src/test/run-pass/generic-type.rs b/src/test/run-pass/generic-type.rs index 6638cebfeeaf7..9b5b5297f15cd 100644 --- a/src/test/run-pass/generic-type.rs +++ b/src/test/run-pass/generic-type.rs @@ -1,6 +1,6 @@ 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); } diff --git a/src/test/run-pass/i32-sub.rs b/src/test/run-pass/i32-sub.rs index 3f00acb1ff86b..eb5e76fb292a6 100644 --- a/src/test/run-pass/i32-sub.rs +++ b/src/test/run-pass/i32-sub.rs @@ -3,6 +3,6 @@ fn main() { let i32 x = -400_i32; x = 0_i32 - x; - check(x == 400_i32); + assert (x == 400_i32); } diff --git a/src/test/run-pass/i8-incr.rs b/src/test/run-pass/i8-incr.rs index fb387d316c52f..92ff04ea28453 100644 --- a/src/test/run-pass/i8-incr.rs +++ b/src/test/run-pass/i8-incr.rs @@ -5,5 +5,5 @@ fn main() { let i8 y = -12i8; x = x + 1i8; x = x - 1i8; - check(x == y); + assert (x == y); } diff --git a/src/test/run-pass/integral-indexing.rs b/src/test/run-pass/integral-indexing.rs index fe7d147c30c1d..ee80786c18a41 100644 --- a/src/test/run-pass/integral-indexing.rs +++ b/src/test/run-pass/integral-indexing.rs @@ -4,19 +4,19 @@ fn main() { 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 diff --git a/src/test/run-pass/iter-range.rs b/src/test/run-pass/iter-range.rs index ade7c51c6ab02..78bf94c33ab47 100644 --- a/src/test/run-pass/iter-range.rs +++ b/src/test/run-pass/iter-range.rs @@ -1,5 +1,5 @@ iter range(int a, int b) -> int { - check (a < b); + assert (a < b); let int i = a; while (i < b) { diff --git a/src/test/run-pass/lazy-and-or.rs b/src/test/run-pass/lazy-and-or.rs index fe0ffe6b21b99..7034efba2b655 100644 --- a/src/test/run-pass/lazy-and-or.rs +++ b/src/test/run-pass/lazy-and-or.rs @@ -1,22 +1,22 @@ 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 diff --git a/src/test/run-pass/lazychan.rs b/src/test/run-pass/lazychan.rs index 6face271eed22..a91adaa15653a 100644 --- a/src/test/run-pass/lazychan.rs +++ b/src/test/run-pass/lazychan.rs @@ -10,13 +10,13 @@ fn main() { 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) { diff --git a/src/test/run-pass/lib-bitv.rs b/src/test/run-pass/lib-bitv.rs index 162e8b13293f3..8f2d939005c78 100644 --- a/src/test/run-pass/lib-bitv.rs +++ b/src/test/run-pass/lib-bitv.rs @@ -9,17 +9,17 @@ fn test_0_elements() { 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() { @@ -27,11 +27,11 @@ 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); @@ -40,7 +40,7 @@ fn test_10_elements() { 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); @@ -49,7 +49,7 @@ fn test_10_elements() { 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); @@ -57,7 +57,7 @@ fn test_10_elements() { 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() { @@ -65,14 +65,14 @@ 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))); @@ -87,7 +87,7 @@ fn test_31_elements() { 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))); @@ -102,7 +102,7 @@ fn test_31_elements() { 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))); @@ -116,7 +116,7 @@ fn test_31_elements() { 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))); @@ -126,7 +126,7 @@ fn test_31_elements() { 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))); @@ -137,14 +137,14 @@ fn test_32_elements() { // 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))); @@ -159,7 +159,7 @@ fn test_32_elements() { 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))); @@ -174,7 +174,7 @@ fn test_32_elements() { 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))); @@ -189,7 +189,7 @@ fn test_32_elements() { 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))); @@ -200,7 +200,7 @@ fn test_32_elements() { 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))); @@ -211,7 +211,7 @@ fn test_33_elements() { // 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, @@ -219,7 +219,7 @@ fn test_33_elements() { // 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, @@ -235,7 +235,7 @@ fn test_33_elements() { 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, @@ -251,7 +251,7 @@ fn test_33_elements() { 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, @@ -267,7 +267,7 @@ fn test_33_elements() { 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, @@ -280,7 +280,7 @@ fn test_33_elements() { 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, diff --git a/src/test/run-pass/lib-box.rs b/src/test/run-pass/lib-box.rs index 10f5e727110cf..62807251bd160 100644 --- a/src/test/run-pass/lib-box.rs +++ b/src/test/run-pass/lib-box.rs @@ -4,9 +4,9 @@ import std.Box; 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)); } diff --git a/src/test/run-pass/lib-deque.rs b/src/test/run-pass/lib-deque.rs index 9fd177eaf9601..405ab72be2037 100644 --- a/src/test/run-pass/lib-deque.rs +++ b/src/test/run-pass/lib-deque.rs @@ -5,125 +5,125 @@ import std.deque; 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 { diff --git a/src/test/run-pass/lib-int.rs b/src/test/run-pass/lib-int.rs index 2e85abf6509f2..e4e68351aabfc 100644 --- a/src/test/run-pass/lib-int.rs +++ b/src/test/run-pass/lib-int.rs @@ -4,22 +4,22 @@ import std._int; 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() { diff --git a/src/test/run-pass/lib-io.rs b/src/test/run-pass/lib-io.rs index 7102c91e36e32..bcc2163cfd3fa 100644 --- a/src/test/run-pass/lib-io.rs +++ b/src/test/run-pass/lib-io.rs @@ -20,7 +20,7 @@ fn test_simple(str tmpfilebase) { 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) { diff --git a/src/test/run-pass/lib-map.rs b/src/test/run-pass/lib-map.rs index 4c8afa7d547a3..abd2041e15131 100644 --- a/src/test/run-pass/lib-map.rs +++ b/src/test/run-pass/lib-map.rs @@ -28,19 +28,19 @@ fn test_simple() { 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"; @@ -51,21 +51,21 @@ fn test_simple() { 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"; @@ -73,19 +73,19 @@ fn test_simple() { 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"; @@ -93,19 +93,19 @@ fn test_simple() { 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"; } @@ -135,7 +135,7 @@ fn test_growth() { 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; @@ -147,12 +147,12 @@ fn test_growth() { 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 "-----"; @@ -162,7 +162,7 @@ fn test_growth() { 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; } @@ -176,7 +176,7 @@ fn test_growth() { 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; @@ -191,15 +191,15 @@ fn test_growth() { + "\") = \"" + 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 "-----"; @@ -210,7 +210,7 @@ fn test_growth() { 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; } @@ -230,9 +230,9 @@ fn test_removal() { 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; @@ -240,13 +240,13 @@ fn test_removal() { 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"; @@ -260,7 +260,7 @@ fn test_removal() { 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; } } @@ -273,7 +273,7 @@ fn test_removal() { i += 2u; } - check (hm.size() == (num_to_insert / 2u)); + assert (hm.size() == (num_to_insert / 2u)); log "-----"; @@ -281,7 +281,7 @@ fn test_removal() { 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; } @@ -296,7 +296,7 @@ fn test_removal() { 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; } @@ -304,13 +304,13 @@ fn test_removal() { 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 "-----"; @@ -318,7 +318,7 @@ fn test_removal() { 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; } @@ -329,13 +329,13 @@ fn test_removal() { 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; } diff --git a/src/test/run-pass/lib-sha1.rs b/src/test/run-pass/lib-sha1.rs index 57e3cdc856b6d..7e8efb5eba745 100644 --- a/src/test/run-pass/lib-sha1.rs +++ b/src/test/run-pass/lib-sha1.rs @@ -69,13 +69,13 @@ fn main() { 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; } } diff --git a/src/test/run-pass/lib-sort.rs b/src/test/run-pass/lib-sort.rs index e2c3465cdfd47..a342b24eb5662 100644 --- a/src/test/run-pass/lib-sort.rs +++ b/src/test/run-pass/lib-sort.rs @@ -10,7 +10,7 @@ fn check_sort(vec[int] v1, vec[int] v2) { auto i = 0u; while (i < len) { log v3.(i); - check (v3.(i) == v2.(i)); + assert (v3.(i) == v2.(i)); i += 1u; } } diff --git a/src/test/run-pass/lib-str-buf.rs b/src/test/run-pass/lib-str-buf.rs index bd5cb036a699f..9b8c56bb75121 100644 --- a/src/test/run-pass/lib-str-buf.rs +++ b/src/test/run-pass/lib-str-buf.rs @@ -8,8 +8,8 @@ fn main() { 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)); } diff --git a/src/test/run-pass/lib-str.rs b/src/test/run-pass/lib-str.rs index 835c08a20f68e..767177111b2b8 100644 --- a/src/test/run-pass/lib-str.rs +++ b/src/test/run-pass/lib-str.rs @@ -2,22 +2,22 @@ use std; 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() { @@ -30,7 +30,7 @@ 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"); @@ -46,7 +46,7 @@ fn test_find() { 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); @@ -57,7 +57,7 @@ fn test_find() { 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)); } @@ -68,7 +68,7 @@ fn test_substr() { 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"); @@ -79,7 +79,7 @@ fn test_concat() { 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"); @@ -95,7 +95,7 @@ fn test_to_upper() { 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)); } diff --git a/src/test/run-pass/lib-uint.rs b/src/test/run-pass/lib-uint.rs index 356ca374092c2..64d39619f0b77 100644 --- a/src/test/run-pass/lib-uint.rs +++ b/src/test/run-pass/lib-uint.rs @@ -4,44 +4,44 @@ use std; 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); } diff --git a/src/test/run-pass/lib-vec-str-conversions.rs b/src/test/run-pass/lib-vec-str-conversions.rs index 1d6b61a1900e3..3724d627b4984 100644 --- a/src/test/run-pass/lib-vec-str-conversions.rs +++ b/src/test/run-pass/lib-vec-str-conversions.rs @@ -21,14 +21,14 @@ fn test_simple() { 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; } diff --git a/src/test/run-pass/lib-vec.rs b/src/test/run-pass/lib-vec.rs index 4d6166483bcf2..51341039c691c 100644 --- a/src/test/run-pass/lib-vec.rs +++ b/src/test/run-pass/lib-vec.rs @@ -2,10 +2,10 @@ use std; 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 { @@ -14,20 +14,20 @@ 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() { @@ -37,7 +37,7 @@ 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; } } @@ -51,7 +51,7 @@ fn test_map2() { auto i = 0; while (i < 5) { - check (v0.(i) * v1.(i) == u.(i)); + assert (v0.(i) * v1.(i) == u.(i)); i += 1; } } diff --git a/src/test/run-pass/linear-for-loop.rs b/src/test/run-pass/linear-for-loop.rs index 2b517f78fe3de..c816f817225dd 100644 --- a/src/test/run-pass/linear-for-loop.rs +++ b/src/test/run-pass/linear-for-loop.rs @@ -6,30 +6,30 @@ fn main() { 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); } diff --git a/src/test/run-pass/many.rs b/src/test/run-pass/many.rs index f83ab4fb6a328..5b67fdc64e072 100644 --- a/src/test/run-pass/many.rs +++ b/src/test/run-pass/many.rs @@ -19,5 +19,5 @@ fn main() { let int y <- p; log "transmission complete"; log y; - check (y == 500); + assert (y == 500); } diff --git a/src/test/run-pass/mutable-alias-vec.rs b/src/test/run-pass/mutable-alias-vec.rs index 887fb39125eef..71d4dfe927d0f 100644 --- a/src/test/run-pass/mutable-alias-vec.rs +++ b/src/test/run-pass/mutable-alias-vec.rs @@ -13,5 +13,5 @@ fn main() { grow(v); auto len = std._vec.len[int](v); log len; - check (len == (3 as uint)); + assert (len == (3 as uint)); } diff --git a/src/test/run-pass/native-opaque-type.rs b/src/test/run-pass/native-opaque-type.rs index 19c2c074f9d7c..e9b7a972dfe26 100644 --- a/src/test/run-pass/native-opaque-type.rs +++ b/src/test/run-pass/native-opaque-type.rs @@ -3,5 +3,5 @@ native mod libc { } fn main() { - check (true); + assert (true); } diff --git a/src/test/run-pass/obj-as.rs b/src/test/run-pass/obj-as.rs index 6e0dac37b8fe6..28868548bbc27 100644 --- a/src/test/run-pass/obj-as.rs +++ b/src/test/run-pass/obj-as.rs @@ -15,10 +15,10 @@ type small = obj { 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 diff --git a/src/test/run-pass/obj-dtor-2.rs b/src/test/run-pass/obj-dtor-2.rs index 167b15fbaeec4..f512e6ee86837 100644 --- a/src/test/run-pass/obj-dtor-2.rs +++ b/src/test/run-pass/obj-dtor-2.rs @@ -14,5 +14,5 @@ fn main() { { auto x = foo(mbox); } - check ((*mbox) == 11); + assert ((*mbox) == 11); } \ No newline at end of file diff --git a/src/test/run-pass/obj-dtor.rs b/src/test/run-pass/obj-dtor.rs index 3d633e725eb92..62e0de87ef42e 100644 --- a/src/test/run-pass/obj-dtor.rs +++ b/src/test/run-pass/obj-dtor.rs @@ -29,6 +29,6 @@ fn main() { 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 diff --git a/src/test/run-pass/obj-self-3.rs b/src/test/run-pass/obj-self-3.rs index f777b56c15a15..208d0ded41ac0 100644 --- a/src/test/run-pass/obj-self-3.rs +++ b/src/test/run-pass/obj-self-3.rs @@ -19,11 +19,11 @@ fn main() { 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); } diff --git a/src/test/run-pass/obj-with-vec.rs b/src/test/run-pass/obj-with-vec.rs index 85143c7924dd6..b298f75f969f2 100644 --- a/src/test/run-pass/obj-with-vec.rs +++ b/src/test/run-pass/obj-with-vec.rs @@ -7,5 +7,5 @@ fn main() { } 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)); } diff --git a/src/test/run-pass/opeq.rs b/src/test/run-pass/opeq.rs index d99ebb0449a31..0c905ab95e0aa 100644 --- a/src/test/run-pass/opeq.rs +++ b/src/test/run-pass/opeq.rs @@ -5,18 +5,18 @@ fn main() { 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); } diff --git a/src/test/run-pass/operator-associativity.rs b/src/test/run-pass/operator-associativity.rs index 2c028eba627c6..403d7c2ed2caf 100644 --- a/src/test/run-pass/operator-associativity.rs +++ b/src/test/run-pass/operator-associativity.rs @@ -1,4 +1,4 @@ // Testcase for issue #130, operator associativity. fn main() -> () { - check ((3 * 5 / 2) == 7); + assert ((3 * 5 / 2) == 7); } diff --git a/src/test/run-pass/readalias.rs b/src/test/run-pass/readalias.rs index 15fa142a77a5a..57dcb3b2d077e 100644 --- a/src/test/run-pass/readalias.rs +++ b/src/test/run-pass/readalias.rs @@ -3,7 +3,7 @@ type point = rec(int x, int y, int z); fn f(&point p) { - check (p.z == 12); + assert (p.z == 12); } fn main() { diff --git a/src/test/run-pass/rec-extend.rs b/src/test/run-pass/rec-extend.rs index db81278b35c7b..ada02597572ec 100644 --- a/src/test/run-pass/rec-extend.rs +++ b/src/test/run-pass/rec-extend.rs @@ -8,12 +8,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); } diff --git a/src/test/run-pass/rec-tup.rs b/src/test/run-pass/rec-tup.rs index e25439a974daa..30db041706281 100644 --- a/src/test/run-pass/rec-tup.rs +++ b/src/test/run-pass/rec-tup.rs @@ -4,22 +4,22 @@ type point = rec(int x, int y); 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); } diff --git a/src/test/run-pass/rec.rs b/src/test/run-pass/rec.rs index 0f6b7d79196ab..7d295f6fb610c 100644 --- a/src/test/run-pass/rec.rs +++ b/src/test/run-pass/rec.rs @@ -3,21 +3,21 @@ 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); } diff --git a/src/test/run-pass/rt-circular-buffer.rs b/src/test/run-pass/rt-circular-buffer.rs index e5c3da1b88f21..cd808ad733deb 100644 --- a/src/test/run-pass/rt-circular-buffer.rs +++ b/src/test/run-pass/rt-circular-buffer.rs @@ -74,9 +74,9 @@ fn test_rotate() { 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); } } @@ -96,9 +96,9 @@ fn test_rotate_grow() { 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); } } } diff --git a/src/test/run-pass/seq-compare.rs b/src/test/run-pass/seq-compare.rs index e8bc4788c9a59..942e9e90d94dd 100644 --- a/src/test/run-pass/seq-compare.rs +++ b/src/test/run-pass/seq-compare.rs @@ -1,16 +1,16 @@ // 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)); } diff --git a/src/test/run-pass/stateful-obj.rs b/src/test/run-pass/stateful-obj.rs index c1d96cc3debee..b0f0cf3b9693c 100644 --- a/src/test/run-pass/stateful-obj.rs +++ b/src/test/run-pass/stateful-obj.rs @@ -14,10 +14,10 @@ obj counter(mutable int x) { 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); } diff --git a/src/test/run-pass/str-append.rs b/src/test/run-pass/str-append.rs index da4ca07fc26a2..abfbe938e223f 100644 --- a/src/test/run-pass/str-append.rs +++ b/src/test/run-pass/str-append.rs @@ -7,7 +7,7 @@ fn test1() { let str s = "hello"; s += "world"; log s; - check(s.(9) == ('d' as u8)); + assert (s.(9) == ('d' as u8)); } fn test2() { @@ -20,8 +20,8 @@ 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() { diff --git a/src/test/run-pass/str-concat.rs b/src/test/run-pass/str-concat.rs index c906a23ef6b00..a21fefbe23fd9 100644 --- a/src/test/run-pass/str-concat.rs +++ b/src/test/run-pass/str-concat.rs @@ -5,5 +5,5 @@ 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)); } diff --git a/src/test/run-pass/str-growth.rs b/src/test/run-pass/str-growth.rs index 06bc8b74621c5..55548da519c9f 100644 --- a/src/test/run-pass/str-growth.rs +++ b/src/test/run-pass/str-growth.rs @@ -1,14 +1,14 @@ 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)); } diff --git a/src/test/run-pass/str-idx.rs b/src/test/run-pass/str-idx.rs index 9793799a97c7a..e2f5abb292754 100644 --- a/src/test/run-pass/str-idx.rs +++ b/src/test/run-pass/str-idx.rs @@ -3,5 +3,5 @@ fn main() { auto s = "hello"; let u8 c = s.(4); log c; - check (c == (0x6f as u8)); + assert (c == (0x6f as u8)); } diff --git a/src/test/run-pass/structured-compare-recursive.rs b/src/test/run-pass/structured-compare-recursive.rs index 3049faec6b6b8..15ddba8465f1b 100644 --- a/src/test/run-pass/structured-compare-recursive.rs +++ b/src/test/run-pass/structured-compare-recursive.rs @@ -4,6 +4,6 @@ tag taggy { } fn main() { - check (bar <= bar); + assert (bar <= bar); } diff --git a/src/test/run-pass/structured-compare.rs b/src/test/run-pass/structured-compare.rs index fed4b1837303a..e677c3cb0bf87 100644 --- a/src/test/run-pass/structured-compare.rs +++ b/src/test/run-pass/structured-compare.rs @@ -6,15 +6,15 @@ tag foo { 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 diff --git a/src/test/run-pass/syntax-extension-fmt.rs b/src/test/run-pass/syntax-extension-fmt.rs index 82b3e658a6378..5248e782bec5b 100644 --- a/src/test/run-pass/syntax-extension-fmt.rs +++ b/src/test/run-pass/syntax-extension-fmt.rs @@ -6,7 +6,7 @@ import std._str; fn test(str actual, str expected) { log actual; log expected; - check (_str.eq(actual, expected)); + assert (_str.eq(actual, expected)); } fn main() { diff --git a/src/test/run-pass/tag.rs b/src/test/run-pass/tag.rs index e3f89a7f262f4..695832b129dad 100644 --- a/src/test/run-pass/tag.rs +++ b/src/test/run-pass/tag.rs @@ -9,7 +9,7 @@ fn f() { auto x = red(1,2); auto y = green; // FIXME: needs structural equality test working. - // check (x != y); + // assert (x != y); } fn main() { diff --git a/src/test/run-pass/tail-cps.rs b/src/test/run-pass/tail-cps.rs index 795a105ad9272..fec48a748c6fd 100644 --- a/src/test/run-pass/tail-cps.rs +++ b/src/test/run-pass/tail-cps.rs @@ -1,7 +1,7 @@ // -*- rust -*- fn checktrue(bool res) -> bool { - check(res); + assert (res); ret true; } diff --git a/src/test/run-pass/tail-direct.rs b/src/test/run-pass/tail-direct.rs index 345a322eb171a..ac29bcad16792 100644 --- a/src/test/run-pass/tail-direct.rs +++ b/src/test/run-pass/tail-direct.rs @@ -1,8 +1,8 @@ // -*- rust -*- fn main() { - check(even(42)); - check(odd(45)); + assert (even(42)); + assert (odd(45)); } fn even(int n) -> bool { diff --git a/src/test/run-pass/task-comm-0.rs b/src/test/run-pass/task-comm-0.rs index e1473548122c9..54e37a3444107 100644 --- a/src/test/run-pass/task-comm-0.rs +++ b/src/test/run-pass/task-comm-0.rs @@ -16,5 +16,5 @@ fn test05() { let int value <- po; value <- po; value <- po; - check(value == 30); + assert (value == 30); } diff --git a/src/test/run-pass/task-comm-16.rs b/src/test/run-pass/task-comm-16.rs index 16c4b93b8db58..9438f50ef4d44 100644 --- a/src/test/run-pass/task-comm-16.rs +++ b/src/test/run-pass/task-comm-16.rs @@ -14,9 +14,9 @@ fn test_rec() { 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() { @@ -29,9 +29,9 @@ 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() { @@ -44,10 +44,10 @@ 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() { @@ -62,9 +62,9 @@ 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() { @@ -84,11 +84,11 @@ 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() { @@ -109,7 +109,7 @@ fn test_chan() { let int i; i <- po0; - check (i == 10); + assert (i == 10); } fn main() { diff --git a/src/test/run-pass/task-comm-3.rs b/src/test/run-pass/task-comm-3.rs index 712557212c1ff..59c46c4c9dbbb 100644 --- a/src/test/run-pass/task-comm-3.rs +++ b/src/test/run-pass/task-comm-3.rs @@ -58,7 +58,7 @@ fn test00(bool is_multithreaded) { } 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); } diff --git a/src/test/run-pass/task-comm-4.rs b/src/test/run-pass/task-comm-4.rs index 121a9e6e1345c..3c4f3ab6ae041 100644 --- a/src/test/run-pass/task-comm-4.rs +++ b/src/test/run-pass/task-comm-4.rs @@ -28,5 +28,5 @@ fn test00() { 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 diff --git a/src/test/run-pass/task-comm-5.rs b/src/test/run-pass/task-comm-5.rs index d0f3994effb2d..324ce0eddc73d 100644 --- a/src/test/run-pass/task-comm-5.rs +++ b/src/test/run-pass/task-comm-5.rs @@ -21,5 +21,5 @@ fn test00() { 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 diff --git a/src/test/run-pass/task-comm-6.rs b/src/test/run-pass/task-comm-6.rs index 74b40a9098af8..0f98ba5b00c78 100644 --- a/src/test/run-pass/task-comm-6.rs +++ b/src/test/run-pass/task-comm-6.rs @@ -32,7 +32,7 @@ fn test00() { 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 diff --git a/src/test/run-pass/task-comm-7.rs b/src/test/run-pass/task-comm-7.rs index b5b95db9605f2..f9fbab88be30f 100644 --- a/src/test/run-pass/task-comm-7.rs +++ b/src/test/run-pass/task-comm-7.rs @@ -40,6 +40,6 @@ fn test00() { 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 diff --git a/src/test/run-pass/task-comm-8.rs b/src/test/run-pass/task-comm-8.rs index a3876bdae5ab5..d115ac4004f59 100644 --- a/src/test/run-pass/task-comm-8.rs +++ b/src/test/run-pass/task-comm-8.rs @@ -41,6 +41,6 @@ fn test00() { 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 diff --git a/src/test/run-pass/task-comm-9.rs b/src/test/run-pass/task-comm-9.rs index a9ac1688cd25b..c1c8a3bd6f978 100644 --- a/src/test/run-pass/task-comm-9.rs +++ b/src/test/run-pass/task-comm-9.rs @@ -29,5 +29,5 @@ fn test00() { 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 diff --git a/src/test/run-pass/task-comm-chan-nil.rs b/src/test/run-pass/task-comm-chan-nil.rs index aae788a5128c4..de7de81af47ba 100644 --- a/src/test/run-pass/task-comm-chan-nil.rs +++ b/src/test/run-pass/task-comm-chan-nil.rs @@ -14,5 +14,5 @@ fn main() { let () n; n <- po; - check (n == ()); + assert (n == ()); } diff --git a/src/test/run-pass/task-comm.rs b/src/test/run-pass/task-comm.rs index 0a91b98abdf8e..d256ced90b180 100644 --- a/src/test/run-pass/task-comm.rs +++ b/src/test/run-pass/task-comm.rs @@ -58,7 +58,7 @@ fn test00(bool is_multithreaded) { } 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); } diff --git a/src/test/run-pass/tup.rs b/src/test/run-pass/tup.rs index 234066460eff3..b7670776bd162 100644 --- a/src/test/run-pass/tup.rs +++ b/src/test/run-pass/tup.rs @@ -3,17 +3,17 @@ 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); } diff --git a/src/test/run-pass/type-sizes.rs b/src/test/run-pass/type-sizes.rs index 67b8b57871ff6..1903cb76049b8 100644 --- a/src/test/run-pass/type-sizes.rs +++ b/src/test/run-pass/type-sizes.rs @@ -5,17 +5,17 @@ import size_of = std.sys.rustrt.size_of; 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)]()); } diff --git a/src/test/run-pass/u32-decr.rs b/src/test/run-pass/u32-decr.rs index 1ff511aa6bb0c..7e7b5026f27a8 100644 --- a/src/test/run-pass/u32-decr.rs +++ b/src/test/run-pass/u32-decr.rs @@ -3,6 +3,6 @@ fn main() { let u32 word = (200000u32); word = word - (1u32); - check(word == (199999u32)); + assert (word == (199999u32)); } diff --git a/src/test/run-pass/u8-incr-decr.rs b/src/test/run-pass/u8-incr-decr.rs index f89325fc45f3a..992c61d5865b5 100644 --- a/src/test/run-pass/u8-incr-decr.rs +++ b/src/test/run-pass/u8-incr-decr.rs @@ -8,5 +8,5 @@ fn main() { let u8 y = 35u8; // 0x23 x = x + (7u8); // 0x7 y = y - (9u8); // 0x9 - check(x == y); + assert (x == y); } diff --git a/src/test/run-pass/u8-incr.rs b/src/test/run-pass/u8-incr.rs index 602d83c66c5c8..7cc9488948e44 100644 --- a/src/test/run-pass/u8-incr.rs +++ b/src/test/run-pass/u8-incr.rs @@ -5,7 +5,7 @@ fn main() { let u8 y = 12u8; x = x + (1u8); x = x - (1u8); - check(x == y); + assert (x == y); // x = 14u8; // x = x + 1u8; } diff --git a/src/test/run-pass/utf8.rs b/src/test/run-pass/utf8.rs index 68f5fa9f68003..bf758a4931594 100644 --- a/src/test/run-pass/utf8.rs +++ b/src/test/run-pass/utf8.rs @@ -6,14 +6,14 @@ fn main() { 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 = "日本"; @@ -28,7 +28,7 @@ fn main() { 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; @@ -37,7 +37,7 @@ fn main() { log ab; let u8 bb = b.(i); log bb; - check(ab == bb); + assert (ab == bb); i += 1; } } diff --git a/src/test/run-pass/utf8_chars.rs b/src/test/run-pass/utf8_chars.rs index 08671093edfb7..07eaca1927a69 100644 --- a/src/test/run-pass/utf8_chars.rs +++ b/src/test/run-pass/utf8_chars.rs @@ -9,25 +9,25 @@ fn main() { 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")); } diff --git a/src/test/run-pass/vec-append.rs b/src/test/run-pass/vec-append.rs index 0f9f56dd9541b..69db478841d41 100644 --- a/src/test/run-pass/vec-append.rs +++ b/src/test/run-pass/vec-append.rs @@ -15,9 +15,9 @@ fn fast_growth() { 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() { @@ -26,7 +26,7 @@ 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 @@ -52,7 +52,7 @@ 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 @@ -60,21 +60,21 @@ fn slow_growth2_helper(str s) { // ref up: s 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; @@ -84,7 +84,7 @@ fn slow_growth2() { 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() { diff --git a/src/test/run-pass/vec-concat.rs b/src/test/run-pass/vec-concat.rs index b6c52c3e08d74..09a95402e65f4 100644 --- a/src/test/run-pass/vec-concat.rs +++ b/src/test/run-pass/vec-concat.rs @@ -5,7 +5,7 @@ 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); } diff --git a/src/test/run-pass/vec-growth.rs b/src/test/run-pass/vec-growth.rs index fe2070306d520..b6976abd3a92e 100644 --- a/src/test/run-pass/vec-growth.rs +++ b/src/test/run-pass/vec-growth.rs @@ -4,10 +4,10 @@ fn main() { 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); } diff --git a/src/test/run-pass/vec-ref-count.rs b/src/test/run-pass/vec-ref-count.rs index 788489362fdc7..45f28f9bff29e 100644 --- a/src/test/run-pass/vec-ref-count.rs +++ b/src/test/run-pass/vec-ref-count.rs @@ -6,7 +6,7 @@ fn main() { 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); } diff --git a/src/test/run-pass/vec-slice.rs b/src/test/run-pass/vec-slice.rs index 5517414230899..c3042d0c03f84 100644 --- a/src/test/run-pass/vec-slice.rs +++ b/src/test/run-pass/vec-slice.rs @@ -4,6 +4,6 @@ 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 diff --git a/src/test/run-pass/vec.rs b/src/test/run-pass/vec.rs index 67a41eabcf6e2..138d0ff2880a0 100644 --- a/src/test/run-pass/vec.rs +++ b/src/test/run-pass/vec.rs @@ -2,12 +2,12 @@ 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); } diff --git a/src/test/run-pass/while-with-break.rs b/src/test/run-pass/while-with-break.rs index 0e27f252ebb31..2adaf24bbc389 100644 --- a/src/test/run-pass/while-with-break.rs +++ b/src/test/run-pass/while-with-break.rs @@ -11,5 +11,5 @@ fn main() { break; } } - check(i == 95); + assert (i == 95); } diff --git a/src/test/run-pass/writealias.rs b/src/test/run-pass/writealias.rs index 8bf8140f31580..c0ac1803ac73f 100644 --- a/src/test/run-pass/writealias.rs +++ b/src/test/run-pass/writealias.rs @@ -9,5 +9,5 @@ fn f(& mutable point p) { fn main() { let point x = rec(x=10, y=11, mutable z=12); f(x); - check (x.z == 13); + assert (x.z == 13); }