From d08b443fffb1181d8d45ae5d061412f202dd4118 Mon Sep 17 00:00:00 2001 From: Graydon Hoare Date: Mon, 2 May 2011 16:24:09 -0700 Subject: [PATCH] Revert "Use different syntax for checks that matter to typestate" This reverts commit aa25f22f197682de3b18fc4c8ba068d1feda220f. It broke stage2, not sure why yet. --- 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, 1239 insertions(+), 1256 deletions(-) diff --git a/src/boot/fe/item.ml b/src/boot/fe/item.ml index 70e59be3039..6b232e7eba7 100644 --- a/src/boot/fe/item.ml +++ b/src/boot/fe/item.ml @@ -199,14 +199,6 @@ 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 a65acba1a6f..b375b874b89 100644 --- a/src/boot/fe/lexer.mll +++ b/src/boot/fe/lexer.mll @@ -92,7 +92,6 @@ ("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 27cb399b551..0b157983984 100644 --- a/src/boot/fe/token.ml +++ b/src/boot/fe/token.ml @@ -77,7 +77,6 @@ type token = (* Type and type-state keywords *) | TYPE | CHECK - | ASSERT | CLAIM | PROVE @@ -238,7 +237,6 @@ 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 13b5739e8df..2fd13194e50 100644 --- a/src/comp/front/ast.rs +++ b/src/comp/front/ast.rs @@ -283,10 +283,7 @@ fn unop_to_str(unop op) -> str { expr_put(option.t[@expr], ann); expr_be(@expr, ann); expr_log(int, @expr, ann); -/* just an assert, no significance to typestate */ - expr_assert(@expr, ann); -/* preds that typestate is aware of */ - expr_check(@expr, ann); + expr_check_expr(@expr, ann); expr_port(ann); expr_chan(@expr, ann); } diff --git a/src/comp/front/creader.rs b/src/comp/front/creader.rs index c8b31159444..f48d47c90be 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') { - assert (next(st) as char == '['); + check(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') { - assert (next(st) as char == '['); + check(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') { - assert (next(st) as char == '['); + check(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') { - assert (next(st) as char == '['); + check(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); - assert (next(st) as char == ':'); + check (next(st) as char == ':'); auto len = parse_hex(st); - assert (next(st) as char == '#'); + check (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) { - assert (next(st) as char == '['); + check(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 dabdee1c738..3659af1c655 100644 --- a/src/comp/front/lexer.rs +++ b/src/comp/front/lexer.rs @@ -127,7 +127,6 @@ 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); @@ -529,7 +528,7 @@ fn scan_numeric_escape(reader rdr) -> char { auto n_hex_digits = 0; - assert (rdr.curr() == '\\'); + check (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 3e8ca85a830..fdd41cf0ff7 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(); - assert (is_ident(p.peek())); + check (is_ident(p.peek())); } else { more = false; } @@ -816,22 +816,19 @@ fn parse_expr_opt(parser p) -> option.t[@ast.expr] { ex = ast.expr_log(0, e, ast.ann_none); } - case (token.ASSERT) { - p.bump(); - 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); - } + 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"); + } + } + } case (token.RET) { p.bump(); @@ -940,7 +937,7 @@ fn expand_syntax_ext(parser p, ast.span sp, &ast.path path, vec[@ast.expr] args, option.t[str] body) -> ast.expr_ { - assert (_vec.len[ast.ident](path.node.idents) > 0u); + check (_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); @@ -1676,8 +1673,7 @@ 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(_,_)) { ret true; } - case (ast.expr_assert(_,_)) { ret true; } + case (ast.expr_check_expr(_,_)) { ret true; } } } // We should not be calling this on a cdir. @@ -2161,24 +2157,24 @@ fn parse_item(parser p) -> @ast.item { alt (p.peek()) { case (token.CONST) { - assert (lyr == ast.layer_value); + check (lyr == ast.layer_value); ret parse_item_const(p); } case (token.FN) { - assert (lyr == ast.layer_value); + check (lyr == ast.layer_value); ret parse_item_fn_or_iter(p); } case (token.ITER) { - assert (lyr == ast.layer_value); + check (lyr == ast.layer_value); ret parse_item_fn_or_iter(p); } case (token.MOD) { - assert (lyr == ast.layer_value); + check (lyr == ast.layer_value); ret parse_item_mod(p); } case (token.NATIVE) { - assert (lyr == ast.layer_value); + check (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 594515f2214..f367bcc6835 100644 --- a/src/comp/front/token.rs +++ b/src/comp/front/token.rs @@ -89,7 +89,6 @@ /* Type and type-state keywords */ TYPE; - ASSERT; CHECK; CLAIM; PROVE; @@ -259,7 +258,6 @@ 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 070174bad3c..41ec1836d18 100644 --- a/src/comp/lib/llvm.rs +++ b/src/comp/lib/llvm.rs @@ -861,19 +861,19 @@ fn LLVMRustWriteOutputFile(PassManagerRef PM, ModuleRef M, /* Terminators */ fn RetVoid() -> ValueRef { - assert (!*terminated); + check (!*terminated); *terminated = true; ret llvm.LLVMBuildRetVoid(B); } fn Ret(ValueRef V) -> ValueRef { - assert (!*terminated); + check (!*terminated); *terminated = true; ret llvm.LLVMBuildRet(B, V); } fn AggregateRet(vec[ValueRef] RetVals) -> ValueRef { - assert (!*terminated); + check (!*terminated); *terminated = true; ret llvm.LLVMBuildAggregateRet(B, _vec.buf[ValueRef](RetVals), @@ -881,26 +881,26 @@ fn AggregateRet(vec[ValueRef] RetVals) -> ValueRef { } fn Br(BasicBlockRef Dest) -> ValueRef { - assert (!*terminated); + check (!*terminated); *terminated = true; ret llvm.LLVMBuildBr(B, Dest); } fn CondBr(ValueRef If, BasicBlockRef Then, BasicBlockRef Else) -> ValueRef { - assert (!*terminated); + check (!*terminated); *terminated = true; ret llvm.LLVMBuildCondBr(B, If, Then, Else); } fn Switch(ValueRef V, BasicBlockRef Else, uint NumCases) -> ValueRef { - assert (!*terminated); + check (!*terminated); *terminated = true; ret llvm.LLVMBuildSwitch(B, V, Else, NumCases); } fn IndirectBr(ValueRef Addr, uint NumDests) -> ValueRef { - assert (!*terminated); + check (!*terminated); *terminated = true; ret llvm.LLVMBuildIndirectBr(B, Addr, NumDests); } @@ -909,7 +909,7 @@ fn Invoke(ValueRef Fn, vec[ValueRef] Args, BasicBlockRef Then, BasicBlockRef Catch) -> ValueRef { - assert (!*terminated); + check (!*terminated); *terminated = true; ret llvm.LLVMBuildInvoke(B, Fn, _vec.buf[ValueRef](Args), @@ -919,209 +919,209 @@ fn Invoke(ValueRef Fn, } fn Unwind() -> ValueRef { - assert (!*terminated); + check (!*terminated); *terminated = true; ret llvm.LLVMBuildUnwind(B); } fn Unreachable() -> ValueRef { - assert (!*terminated); + check (!*terminated); *terminated = true; ret llvm.LLVMBuildUnreachable(B); } /* Arithmetic */ fn Add(ValueRef LHS, ValueRef RHS) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildAdd(B, LHS, RHS, _str.buf("")); } fn NSWAdd(ValueRef LHS, ValueRef RHS) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildNSWAdd(B, LHS, RHS, _str.buf("")); } fn NUWAdd(ValueRef LHS, ValueRef RHS) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildNUWAdd(B, LHS, RHS, _str.buf("")); } fn FAdd(ValueRef LHS, ValueRef RHS) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildFAdd(B, LHS, RHS, _str.buf("")); } fn Sub(ValueRef LHS, ValueRef RHS) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildSub(B, LHS, RHS, _str.buf("")); } fn NSWSub(ValueRef LHS, ValueRef RHS) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildNSWSub(B, LHS, RHS, _str.buf("")); } fn NUWSub(ValueRef LHS, ValueRef RHS) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildNUWSub(B, LHS, RHS, _str.buf("")); } fn FSub(ValueRef LHS, ValueRef RHS) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildFSub(B, LHS, RHS, _str.buf("")); } fn Mul(ValueRef LHS, ValueRef RHS) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildMul(B, LHS, RHS, _str.buf("")); } fn NSWMul(ValueRef LHS, ValueRef RHS) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildNSWMul(B, LHS, RHS, _str.buf("")); } fn NUWMul(ValueRef LHS, ValueRef RHS) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildNUWMul(B, LHS, RHS, _str.buf("")); } fn FMul(ValueRef LHS, ValueRef RHS) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildFMul(B, LHS, RHS, _str.buf("")); } fn UDiv(ValueRef LHS, ValueRef RHS) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildUDiv(B, LHS, RHS, _str.buf("")); } fn SDiv(ValueRef LHS, ValueRef RHS) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildSDiv(B, LHS, RHS, _str.buf("")); } fn ExactSDiv(ValueRef LHS, ValueRef RHS) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildExactSDiv(B, LHS, RHS, _str.buf("")); } fn FDiv(ValueRef LHS, ValueRef RHS) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildFDiv(B, LHS, RHS, _str.buf("")); } fn URem(ValueRef LHS, ValueRef RHS) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildURem(B, LHS, RHS, _str.buf("")); } fn SRem(ValueRef LHS, ValueRef RHS) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildSRem(B, LHS, RHS, _str.buf("")); } fn FRem(ValueRef LHS, ValueRef RHS) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildFRem(B, LHS, RHS, _str.buf("")); } fn Shl(ValueRef LHS, ValueRef RHS) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildShl(B, LHS, RHS, _str.buf("")); } fn LShr(ValueRef LHS, ValueRef RHS) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildLShr(B, LHS, RHS, _str.buf("")); } fn AShr(ValueRef LHS, ValueRef RHS) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildAShr(B, LHS, RHS, _str.buf("")); } fn And(ValueRef LHS, ValueRef RHS) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildAnd(B, LHS, RHS, _str.buf("")); } fn Or(ValueRef LHS, ValueRef RHS) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildOr(B, LHS, RHS, _str.buf("")); } fn Xor(ValueRef LHS, ValueRef RHS) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildXor(B, LHS, RHS, _str.buf("")); } fn BinOp(Opcode Op, ValueRef LHS, ValueRef RHS) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildBinOp(B, Op, LHS, RHS, _str.buf("")); } fn Neg(ValueRef V) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildNeg(B, V, _str.buf("")); } fn NSWNeg(ValueRef V) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildNSWNeg(B, V, _str.buf("")); } fn NUWNeg(ValueRef V) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildNUWNeg(B, V, _str.buf("")); } fn FNeg(ValueRef V) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildFNeg(B, V, _str.buf("")); } fn Not(ValueRef V) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildNot(B, V, _str.buf("")); } /* Memory */ fn Malloc(TypeRef Ty) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildMalloc(B, Ty, _str.buf("")); } fn ArrayMalloc(TypeRef Ty, ValueRef Val) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildArrayMalloc(B, Ty, Val, _str.buf("")); } fn Alloca(TypeRef Ty) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildAlloca(B, Ty, _str.buf("")); } fn ArrayAlloca(TypeRef Ty, ValueRef Val) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildArrayAlloca(B, Ty, Val, _str.buf("")); } fn Free(ValueRef PointerVal) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildFree(B, PointerVal); } fn Load(ValueRef PointerVal) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildLoad(B, PointerVal, _str.buf("")); } fn Store(ValueRef Val, ValueRef Ptr) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildStore(B, Val, Ptr); } fn GEP(ValueRef Pointer, vec[ValueRef] Indices) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildGEP(B, Pointer, _vec.buf[ValueRef](Indices), _vec.len[ValueRef](Indices), @@ -1129,7 +1129,7 @@ fn GEP(ValueRef Pointer, vec[ValueRef] Indices) -> ValueRef { } fn InBoundsGEP(ValueRef Pointer, vec[ValueRef] Indices) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildInBoundsGEP(B, Pointer, _vec.buf[ValueRef](Indices), _vec.len[ValueRef](Indices), @@ -1137,125 +1137,125 @@ fn InBoundsGEP(ValueRef Pointer, vec[ValueRef] Indices) -> ValueRef { } fn StructGEP(ValueRef Pointer, uint Idx) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildStructGEP(B, Pointer, Idx, _str.buf("")); } fn GlobalString(sbuf Str) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildGlobalString(B, Str, _str.buf("")); } fn GlobalStringPtr(sbuf Str) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildGlobalStringPtr(B, Str, _str.buf("")); } /* Casts */ fn Trunc(ValueRef Val, TypeRef DestTy) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildTrunc(B, Val, DestTy, _str.buf("")); } fn ZExt(ValueRef Val, TypeRef DestTy) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildZExt(B, Val, DestTy, _str.buf("")); } fn SExt(ValueRef Val, TypeRef DestTy) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildSExt(B, Val, DestTy, _str.buf("")); } fn FPToUI(ValueRef Val, TypeRef DestTy) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildFPToUI(B, Val, DestTy, _str.buf("")); } fn FPToSI(ValueRef Val, TypeRef DestTy) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildFPToSI(B, Val, DestTy, _str.buf("")); } fn UIToFP(ValueRef Val, TypeRef DestTy) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildUIToFP(B, Val, DestTy, _str.buf("")); } fn SIToFP(ValueRef Val, TypeRef DestTy) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildSIToFP(B, Val, DestTy, _str.buf("")); } fn FPTrunc(ValueRef Val, TypeRef DestTy) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildFPTrunc(B, Val, DestTy, _str.buf("")); } fn FPExt(ValueRef Val, TypeRef DestTy) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildFPExt(B, Val, DestTy, _str.buf("")); } fn PtrToInt(ValueRef Val, TypeRef DestTy) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildPtrToInt(B, Val, DestTy, _str.buf("")); } fn IntToPtr(ValueRef Val, TypeRef DestTy) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildIntToPtr(B, Val, DestTy, _str.buf("")); } fn BitCast(ValueRef Val, TypeRef DestTy) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildBitCast(B, Val, DestTy, _str.buf("")); } fn ZExtOrBitCast(ValueRef Val, TypeRef DestTy) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildZExtOrBitCast(B, Val, DestTy, _str.buf("")); } fn SExtOrBitCast(ValueRef Val, TypeRef DestTy) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildSExtOrBitCast(B, Val, DestTy, _str.buf("")); } fn TruncOrBitCast(ValueRef Val, TypeRef DestTy) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildTruncOrBitCast(B, Val, DestTy, _str.buf("")); } fn Cast(Opcode Op, ValueRef Val, TypeRef DestTy, sbuf Name) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildCast(B, Op, Val, DestTy, _str.buf("")); } fn PointerCast(ValueRef Val, TypeRef DestTy) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildPointerCast(B, Val, DestTy, _str.buf("")); } fn IntCast(ValueRef Val, TypeRef DestTy) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildIntCast(B, Val, DestTy, _str.buf("")); } fn FPCast(ValueRef Val, TypeRef DestTy) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildFPCast(B, Val, DestTy, _str.buf("")); } /* Comparisons */ fn ICmp(uint Op, ValueRef LHS, ValueRef RHS) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildICmp(B, Op, LHS, RHS, _str.buf("")); } fn FCmp(uint Op, ValueRef LHS, ValueRef RHS) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildFCmp(B, Op, LHS, RHS, _str.buf("")); } @@ -1263,9 +1263,9 @@ fn FCmp(uint Op, ValueRef LHS, ValueRef RHS) -> ValueRef { /* Miscellaneous instructions */ fn Phi(TypeRef Ty, vec[ValueRef] vals, vec[BasicBlockRef] bbs) -> ValueRef { - assert (!*terminated); + check (!*terminated); auto phi = llvm.LLVMBuildPhi(B, Ty, _str.buf("")); - assert (_vec.len[ValueRef](vals) == _vec.len[BasicBlockRef](bbs)); + check (_vec.len[ValueRef](vals) == _vec.len[BasicBlockRef](bbs)); llvm.LLVMAddIncoming(phi, _vec.buf[ValueRef](vals), _vec.buf[BasicBlockRef](bbs), @@ -1276,7 +1276,7 @@ fn Phi(TypeRef Ty, vec[ValueRef] vals, fn AddIncomingToPhi(ValueRef phi, vec[ValueRef] vals, vec[BasicBlockRef] bbs) { - assert (_vec.len[ValueRef](vals) == _vec.len[BasicBlockRef](bbs)); + check (_vec.len[ValueRef](vals) == _vec.len[BasicBlockRef](bbs)); llvm.LLVMAddIncoming(phi, _vec.buf[ValueRef](vals), _vec.buf[BasicBlockRef](bbs), @@ -1284,7 +1284,7 @@ fn AddIncomingToPhi(ValueRef phi, } fn Call(ValueRef Fn, vec[ValueRef] Args) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildCall(B, Fn, _vec.buf[ValueRef](Args), _vec.len[ValueRef](Args), @@ -1292,7 +1292,7 @@ fn Call(ValueRef Fn, vec[ValueRef] Args) -> ValueRef { } fn FastCall(ValueRef Fn, vec[ValueRef] Args) -> ValueRef { - assert (!*terminated); + check (!*terminated); auto v = llvm.LLVMBuildCall(B, Fn, _vec.buf[ValueRef](Args), _vec.len[ValueRef](Args), @@ -1302,65 +1302,65 @@ fn FastCall(ValueRef Fn, vec[ValueRef] Args) -> ValueRef { } fn Select(ValueRef If, ValueRef Then, ValueRef Else) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildSelect(B, If, Then, Else, _str.buf("")); } fn VAArg(ValueRef List, TypeRef Ty) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildVAArg(B, List, Ty, _str.buf("")); } fn ExtractElement(ValueRef VecVal, ValueRef Index) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildExtractElement(B, VecVal, Index, _str.buf("")); } fn InsertElement(ValueRef VecVal, ValueRef EltVal, ValueRef Index) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildInsertElement(B, VecVal, EltVal, Index, _str.buf("")); } fn ShuffleVector(ValueRef V1, ValueRef V2, ValueRef Mask) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildShuffleVector(B, V1, V2, Mask, _str.buf("")); } fn ExtractValue(ValueRef AggVal, uint Index) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildExtractValue(B, AggVal, Index, _str.buf("")); } fn InsertValue(ValueRef AggVal, ValueRef EltVal, uint Index) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildInsertValue(B, AggVal, EltVal, Index, _str.buf("")); } fn IsNull(ValueRef Val) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildIsNull(B, Val, _str.buf("")); } fn IsNotNull(ValueRef Val) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildIsNotNull(B, Val, _str.buf("")); } fn PtrDiff(ValueRef LHS, ValueRef RHS) -> ValueRef { - assert (!*terminated); + check (!*terminated); ret llvm.LLVMBuildPtrDiff(B, LHS, RHS, _str.buf("")); } fn Trap() -> ValueRef { - assert (!*terminated); + check (!*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")); - assert (T as int != 0); + check (T as int != 0); let vec[ValueRef] Args = vec(); ret llvm.LLVMBuildCall(B, T, _vec.buf[ValueRef](Args), @@ -1391,8 +1391,8 @@ fn mk_type_handle() -> type_handle { std.map.hashmap[str, TypeRef] named_types) { fn associate(str s, TypeRef t) { - assert (!named_types.contains_key(s)); - assert (!type_names.contains_key(t)); + check (!named_types.contains_key(s)); + check (!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 e932fd9af49..a0f3bc93f95 100644 --- a/src/comp/middle/fold.rs +++ b/src/comp/middle/fold.rs @@ -196,10 +196,7 @@ @expr e, ann a) -> @expr) fold_expr_log, (fn(&ENV e, &span sp, - @expr e, ann a) -> @expr) fold_expr_check, - - (fn(&ENV e, &span sp, - @expr e, ann a) -> @expr) fold_expr_assert, + @expr e, ann a) -> @expr) fold_expr_check_expr, (fn(&ENV e, &span sp, ann a) -> @expr) fold_expr_port, @@ -799,16 +796,10 @@ 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(?x, ?t)) { + case (ast.expr_check_expr(?x, ?t)) { auto ee = fold_expr(env_, fld, x); auto t2 = fld.fold_ann(env_, t); - 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); + ret fld.fold_expr_check_expr(env_, e.span, ee, t2); } case (ast.expr_port(?t)) { @@ -1389,14 +1380,9 @@ 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[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) +fn identity_fold_expr_check_expr[ENV](&ENV e, &span sp, @expr x, ann a) -> @expr { - ret @respan(sp, ast.expr_check(x, a)); + ret @respan(sp, ast.expr_check_expr(x, a)); } fn identity_fold_expr_port[ENV](&ENV e, &span sp, ann a) -> @expr { @@ -1690,11 +1676,8 @@ 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 - = bind identity_fold_expr_check[ENV](_,_,_,_), - fold_expr_assert - = bind identity_fold_expr_assert[ENV](_,_,_,_), - + fold_expr_check_expr + = bind identity_fold_expr_check_expr[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 bec6262847e..806f38b5252 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 { - assert (! cx.use_abbrevs); + check (! 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 c045413c2db..d75a6db09d9 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); - assert (n_idents != 0u); + check (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 2c639c4cd6e..d4ba3073bbb 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)) { - assert (arg.mode == ast.alias); + check (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)) { - assert (t as int != 0); + check (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)); } } - assert (llty as int != 0); + check (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 { - assert (ty.type_is_tup_like(cx.fcx.lcx.ccx.tcx, t)); + check (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 split_type(@crate_ctxt ccx, ty.t t, vec[int] ixs, uint n) // and the latter would only be meaningful if we supported non-0 // values for the 0th index (we don't). - assert (len > 1u); + check (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. - assert (ixs.(n) == 0); + check (ixs.(n) == 0); ret split_type(ccx, t, ixs, n+1u); } - assert (n < len); + check (n < len); let int ix = ixs.(n); let vec[ty.t] prefix = vec(); @@ -1618,8 +1618,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); - assert (n_params == _vec.len[uint](tys._0)); - assert (n_params == _vec.len[ValueRef](tys._1)); + check (n_params == _vec.len[uint](tys._0)); + check (n_params == _vec.len[ValueRef](tys._1)); auto root = get_static_tydesc(cx, t, tys._0).tydesc; @@ -2348,7 +2348,7 @@ fn tag_variants(@crate_ctxt cx, ast.def_id id) -> vec[variant_info] { ret creader.get_tag_variants(cx.sess, cx.tcx, id); } - assert (cx.items.contains_key(id)); + check (cx.items.contains_key(id)); alt (cx.items.get(id).node) { case (ast.item_tag(_, ?variants, _, _, _)) { let vec[variant_info] result = vec(); @@ -3367,7 +3367,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. - assert (_vec.len[result](ins) >= 1u); + check (_vec.len[result](ins) >= 1u); ret ins.(0); } @@ -3995,7 +3995,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. - assert (cx.fcx.lcx.ccx.fn_pairs.contains_key(fn_id)); + check (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. @@ -4038,7 +4038,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. - assert (lcx.ccx.sess.get_targ_crate_num() != vid._0); + check (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)); @@ -4060,7 +4060,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]) { - assert (cx.fcx.llupvars.contains_key(did)); + check (cx.fcx.llupvars.contains_key(did)); ret lval_mem(cx, cx.fcx.llupvars.get(did)); } case (some[ValueRef](?llval)) { @@ -4071,7 +4071,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]) { - assert (cx.fcx.llupvars.contains_key(did)); + check (cx.fcx.llupvars.contains_key(did)); ret lval_mem(cx, cx.fcx.llupvars.get(did)); } case (some[ValueRef](?llval)) { @@ -4080,11 +4080,11 @@ fn trans_path(@block_ctxt cx, &ast.path p, &option.t[ast.def] dopt, } } case (ast.def_binding(?did)) { - assert (cx.fcx.lllocals.contains_key(did)); + check (cx.fcx.lllocals.contains_key(did)); ret lval_mem(cx, cx.fcx.lllocals.get(did)); } case (ast.def_obj_field(?did)) { - assert (cx.fcx.llobjfields.contains_key(did)); + check (cx.fcx.llobjfields.contains_key(did)); ret lval_mem(cx, cx.fcx.llobjfields.get(did)); } case (ast.def_fn(?did)) { @@ -4136,7 +4136,7 @@ fn trans_path(@block_ctxt cx, &ast.path p, &option.t[ast.def] dopt, } case (ast.def_const(?did)) { // TODO: externals - assert (cx.fcx.lcx.ccx.consts.contains_key(did)); + check (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)) { @@ -4275,7 +4275,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)) { - assert (unop == ast.deref); + check (unop == ast.deref); auto sub = trans_expr(cx, base); auto val = sub.bcx.build.GEP(sub.val, @@ -4439,7 +4439,7 @@ fn trans_bind_thunk(@local_ctxt cx, } } else if (ty.type_contains_params(cx.ccx.tcx, out_arg.ty)) { - assert (out_arg.mode == ast.alias); + check (out_arg.mode == ast.alias); val = bcx.build.PointerCast(val, llout_arg_ty); } @@ -4452,7 +4452,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)) { - assert (out_arg.mode == ast.alias); + check (out_arg.mode == ast.alias); passed_arg = bcx.build.PointerCast(passed_arg, llout_arg_ty); } @@ -5142,7 +5142,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); - assert (lhs_res.is_mem); + check (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. @@ -5153,7 +5153,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); - assert (lhs_res.is_mem); + check (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) { @@ -5210,11 +5210,7 @@ fn trans_expr(@block_ctxt cx, @ast.expr e) -> result { ret trans_log(lvl, cx, a); } - case (ast.expr_assert(?a, _)) { - ret trans_check_expr(cx, a); - } - - case (ast.expr_check(?a, _)) { + case (ast.expr_check_expr(?a, _)) { ret trans_check_expr(cx, a); } @@ -5535,7 +5531,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 - assert (ast.is_call_expr(e)); + check (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)); @@ -5631,7 +5627,7 @@ fn trans_recv(@block_ctxt cx, @ast.expr lhs, @ast.expr rhs, auto bcx = cx; auto data = trans_lval(bcx, lhs); - assert (data.is_mem); + check (data.is_mem); bcx = data.res.bcx; auto unit_ty = node_ann_type(bcx.fcx.lcx.ccx, ann); @@ -5663,7 +5659,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. - assert (cx.fcx.lllocals.contains_key(local.id)); + check (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; @@ -5779,7 +5775,7 @@ fn trans_block_cleanups(@block_ctxt cx, auto bcx = cx; if (cleanup_cx.kind == NON_SCOPE_BLOCK) { - assert (_vec.len[cleanup](cleanup_cx.cleanups) == 0u); + check (_vec.len[cleanup](cleanup_cx.cleanups) == 0u); } auto i = _vec.len[cleanup](cleanup_cx.cleanups); @@ -6000,7 +5996,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); - assert (llarg as int != 0); + check (llarg as int != 0); cx.lltydescs += vec(llarg); arg_n += 1u; i += 1u; @@ -6010,14 +6006,14 @@ fn create_llargs_for_fn_args(&@fn_ctxt cx, if (proto == ast.proto_iter) { auto llarg = llvm.LLVMGetParam(cx.llfn, arg_n); - assert (llarg as int != 0); + check (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); - assert (llarg as int != 0); + check (llarg as int != 0); cx.llargs.insert(arg.id, llarg); arg_n += 1u; } @@ -6455,7 +6451,7 @@ fn trans_tag_variant(@local_ctxt cx, ast.def_id tag_id, id=varg.id)); } - assert (cx.ccx.item_ids.contains_key(variant.node.id)); + check (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); @@ -6722,7 +6718,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); - assert (llarg as int != 0); + check (llarg as int != 0); call_args += vec(vp2i(bcx, llarg)); arg_n += 1u; } @@ -6788,7 +6784,7 @@ fn push_arg(@block_ctxt cx, for (ty.arg arg in args) { auto llarg = llvm.LLVMGetParam(fcx.llfn, arg_n); - assert (llarg as int != 0); + check (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 220adcb1a23..83befefc701 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 { - assert (type_is_tup_like(cx, ty)); + check (type_is_tup_like(cx, ty)); alt (struct(cx, ty)) { case (ty_tup(?mts)) { ret mts.(i).ty; @@ -1785,117 +1785,50 @@ fn pat_ty(ctxt cx, @ast.pat pat) -> t { fail; // not reached } -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; - } +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]; } } + fail; } // Returns the type of an expression as a monotype. @@ -1905,21 +1838,35 @@ fn expr_ann(&@ast.expr e) -> 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 { - { ret ann_to_monotype(cx, expr_ann(expr)); } + alt (expr_ann(expr)) { + case (none[ast.ann]) { ret mk_nil(cx); } + case (some[ast.ann](?a)) { ret ann_to_monotype(cx, a); } + } } fn expr_ty_params_and_ty(ctxt cx, @ast.expr expr) -> tup(vec[t], t) { - auto a = expr_ann(expr); - - ret tup(ann_to_type_params(a), ann_to_type(a)); + 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)); + } + } } fn expr_has_ty_params(@ast.expr expr) -> bool { // FIXME: Rewrite using complex patterns when they're trustworthy. alt (expr_ann(expr)) { - case (ast.ann_none) { fail; } - case (ast.ann_type(_, ?tps_opt, _)) { - ret !option.is_none[vec[t]](tps_opt); + 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); + } + } } } } @@ -2286,7 +2233,7 @@ fn unify_step(@ctxt cx, t expected, t actual) -> result { if (actual_n < vlen) { cx.types.(actual_n) += vec(expected); } else { - assert (actual_n == vlen); + check (actual_n == vlen); cx.types += vec(mutable vec(expected)); } } @@ -2654,7 +2601,7 @@ fn unify_step(@ctxt cx, t expected, t actual) -> result { if (expected_n < vlen) { cx.types.(expected_n) += vec(actual); } else { - assert (expected_n == vlen); + check (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 094b7e1f0ee..3354fe46ad9 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)) { - // assert (fcx.locals.contains_key(id)); + // check (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)) { - // assert (fcx.locals.contains_key(id)); + // check (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)) { - // assert (fcx.locals.contains_key(id)); + // check (fcx.locals.contains_key(id)); ret tup(0u, fcx.locals.get(id)); } case (ast.def_obj(?id)) { @@ -298,7 +298,7 @@ fn instantiate(ty.ctxt tcx, } case (ast.ty_path(?path, ?def)) { - assert (def != none[ast.def]); + check (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 @@ fn getter(@ctxt cx, ast.def_id id) -> ty.ty_param_count_and_ty { ret creader.get_type(cx.sess, cx.tcx, id); } - // assert (cx.id_to_ty_item.contains_key(id)); + // check (cx.id_to_ty_item.contains_key(id)); auto it = cx.id_to_ty_item.get(id); auto tpt; @@ -672,7 +672,7 @@ fn convert_native(&@env e, @ast.native_item i) -> @env { 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 { - // assert (e.cx.type_cache.contains_key(id)); + // check (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 @@ fn fold_item_const(&@env e, &span sp, ast.ident i, 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 { - // assert (e.cx.type_cache.contains_key(id)); + // check (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 @@ fn fold_item_fn(&@env e, &span sp, ast.ident i, 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 { - // assert (e.cx.type_cache.contains_key(id)); + // check (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 @@ fn get_ctor_obj_methods(&@env e, ty.t t) -> vec[method] { 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 { - // assert (e.cx.type_cache.contains_key(odid.ctor)); + // check (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 @@ fn fold_item_obj(&@env e, &span sp, ast.ident i, 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 { - // assert (e.cx.type_cache.contains_key(id)); + // check (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 @@ fn pushdown_expr_full(&@fn_ctxt fcx, ty.t expected, @ast.expr e, case (none[@ast.expr]) { auto i = 0u; for (ast.field field_0 in fields_0) { - assert (_str.eq(field_0.ident, + check (_str.eq(field_0.ident, field_mts.(i).ident)); auto e_1 = pushdown_expr(fcx, @@ -1409,8 +1409,7 @@ fn pushdown_expr_full(&@fn_ctxt fcx, ty.t expected, @ast.expr e, 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(_,_)) { e_1 = e.node; } - case (ast.expr_assert(_,_)) { e_1 = e.node; } + case (ast.expr_check_expr(_,_)) { e_1 = e.node; } case (ast.expr_port(?ann)) { auto t = Demand.simple(fcx, e.span, expected, @@ -1840,7 +1839,7 @@ fn check_call(&@fn_ctxt fcx, @ast.expr f, vec[@ast.expr] args) case (ast.expr_path(?pth, ?defopt, _)) { auto t = ty.mk_nil(fcx.ccx.tcx); - assert (defopt != none[ast.def]); + check (defopt != none[ast.def]); auto defn = option.get[ast.def](defopt); auto tpt = ty_param_count_and_ty_for_def(fcx, expr.span, defn); @@ -1940,7 +1939,7 @@ fn check_call(&@fn_ctxt fcx, @ast.expr f, vec[@ast.expr] args) case (ast.expr_be(?e, _)) { /* FIXME: prove instead of check */ - assert (ast.is_call_expr(e)); + check (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, @@ -1954,25 +1953,12 @@ fn check_call(&@fn_ctxt fcx, @ast.expr f, vec[@ast.expr] args) plain_ann(fcx.ccx.tcx))); } - 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? */ + case (ast.expr_check_expr(?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_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, + (expr.span, ast.expr_check_expr(expr_t, plain_ann(fcx.ccx.tcx))); } diff --git a/src/comp/middle/typestate_check.rs b/src/comp/middle/typestate_check.rs index e15c720a3d9..d08ae82d603 100644 --- a/src/comp/middle/typestate_check.rs +++ b/src/comp/middle/typestate_check.rs @@ -55,8 +55,7 @@ import front.ast.expr_port; import front.ast.expr_chan; import front.ast.expr_be; -import front.ast.expr_check; -import front.ast.expr_assert; +import front.ast.expr_check_expr; import front.ast.expr_cast; import front.ast.expr_for; import front.ast.expr_for_each; @@ -148,7 +147,8 @@ import middle.ty; import middle.ty.ann_to_type; import middle.ty.arg; -import middle.ty.expr_ann; +import middle.ty.block_ty; +import middle.ty.expr_ty; import middle.ty.ty_to_str; import pretty.pprust.print_block; @@ -293,11 +293,11 @@ fn print_idents(vec[ident] idents) -> () { type fn_info_map = std.map.hashmap[def_id, fn_info]; fn bit_num(def_id v, fn_info m) -> uint { - assert (m.contains_key(v)); + check (m.contains_key(v)); ret m.get(v)._0; } fn get_fn_info(fn_info_map fm, def_id did) -> fn_info { - assert (fm.contains_key(did)); + check (fm.contains_key(did)); ret fm.get(did); } @@ -389,6 +389,116 @@ 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); } @@ -422,7 +532,7 @@ fn ann_to_ts_ann_fail_more(ann a) -> @ts_ann { fail; } case (ann_type(_,_,?t)) { - assert (! is_none[@ts_ann](t)); + check (! is_none[@ts_ann](t)); ret get[@ts_ann](t); } } @@ -447,7 +557,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)"; @@ -468,7 +578,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)"; @@ -554,19 +664,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; } @@ -627,7 +737,7 @@ fn seq_preconds(fn_info enclosing, vec[pre_and_post] pps) -> precond { if (sz >= 1u) { auto first = pps.(0); - assert (pps_len(first) == num_vars); + check (pps_len(first) == num_vars); let precond rest = seq_preconds(enclosing, slice[pre_and_post](pps, 1u, sz)); difference(rest, first.postcondition); @@ -687,7 +797,7 @@ fn intersect_postconds_go(&postcond first, &vec[postcond] rest) -> postcond { } fn intersect_postconds(&vec[postcond] pcs) -> postcond { - assert (len[postcond](pcs) > 0u); + check (len[postcond](pcs) > 0u); ret intersect_postconds_go(bitv.clone(pcs.(0)), pcs); } @@ -716,7 +826,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) -> () { - assert (fm.contains_key(m.node.id)); + check(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,_); @@ -726,7 +836,7 @@ fn do_a_method(fn_info_map fm, &@method m) -> () { fn find_pre_post_state_obj(fn_info_map fm, _obj o) -> bool { fn do_a_method(fn_info_map fm, &@method m) -> bool { - assert (fm.contains_key(m.node.id)); + check(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,_); @@ -739,10 +849,10 @@ fn do_a_method(fn_info_map fm, &@method m) -> 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)) { - assert (fm.contains_key(di)); + check (fm.contains_key(di)); find_pre_post_fn(fm, fm.get(di), f); } case (ast.item_mod(?id, ?m, ?di)) { @@ -773,14 +883,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); @@ -794,31 +904,31 @@ fn get_pp(&@expr e) -> pre_and_post { 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)) { @@ -864,18 +974,18 @@ fn pp_one(&@expr e) -> pre_and_post { 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)); @@ -894,10 +1004,10 @@ fn pp_one(&@expr e) -> pre_and_post { 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 (_) { @@ -910,10 +1020,10 @@ fn pp_one(&@expr e) -> pre_and_post { 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 (_) { @@ -939,45 +1049,45 @@ fn pp_one(&@expr e) -> pre_and_post { 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)); @@ -997,31 +1107,31 @@ fn pp_one(&@expr e) -> pre_and_post { 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)) { @@ -1031,7 +1141,7 @@ fn pp_one(&@expr e) -> pre_and_post { 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)) { @@ -1044,7 +1154,7 @@ fn pp_one(&@expr e) -> pre_and_post { 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); @@ -1060,7 +1170,7 @@ fn combine_pp(pre_and_post antec, 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, _, _); @@ -1071,8 +1181,8 @@ fn combine_pp(pre_and_post antec, 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, @@ -1081,14 +1191,10 @@ fn combine_pp(pre_and_post antec, rec(precondition=empty_prestate(num_local_vars), postcondition=false_postcond(num_local_vars))); } - 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)) { + case (expr_check_expr(?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); @@ -1105,21 +1211,21 @@ fn combine_pp(pre_and_post antec, 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 { - assert (enclosing.contains_key(id)); + check(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 { - assert (enclosing.contains_key(id)); + check(enclosing.contains_key(id)); let uint i = (enclosing.get(id))._0; auto res = clone(pre); relax_prestate(i, res); @@ -1127,7 +1233,7 @@ fn declare_var(&fn_info enclosing, def_id id, prestate pre) } fn gen_poststate(&fn_info enclosing, &ann a, def_id id) -> bool { - assert (enclosing.contains_key(id)); + check(enclosing.contains_key(id)); let uint i = (enclosing.get(id))._0; ret set_in_poststate(i, (ann_to_ts_ann_fail_more(a)).states); @@ -1145,8 +1251,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 @@ -1175,8 +1281,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)); } } } @@ -1212,7 +1318,7 @@ fn do_one_(fn_info_map fm, fn_info i, &@stmt s) -> () { _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); @@ -1225,7 +1331,7 @@ fn get_pp_stmt(&@stmt s) -> pre_and_post { 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, @@ -1257,7 +1363,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); - assert (fm.contains_key(id)); + check (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)); @@ -1271,7 +1377,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)) { - assert (fm.contains_key(di)); + check (fm.contains_key(di)); ret find_pre_post_state_fn(fm, fm.get(di), f); } case (ast.item_mod(?id, ?m, ?di)) { @@ -1295,7 +1401,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)) { - assert (! is_none[@ts_ann](ts_a)); + check (! is_none[@ts_ann](ts_a)); ret set_prestate(get[@ts_ann](ts_a), pre); } case (ann_none) { @@ -1309,8 +1415,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)) { - assert (! is_none[@ts_ann](ts_a)); - ret extend_prestate((get[@ts_ann](ts_a)).states.prestate, pre); + check (! 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"); @@ -1322,8 +1428,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)) { - assert (! is_none[@ts_ann](ts_a)); - ret set_poststate(get[@ts_ann](ts_a), post); + check (! 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"); @@ -1335,7 +1441,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)) { - assert (! is_none[@ts_ann](ts_a)); + check (! is_none[@ts_ann](ts_a)); ret extend_poststate((*get[@ts_ann](ts_a)).states.poststate, post); } case (ann_none) { @@ -1348,7 +1454,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)) { - assert (! is_none[@ts_ann](ts_a)); + check (! is_none[@ts_ann](ts_a)); auto t = *get[@ts_ann](ts_a); /* log("set_pre_and_post, old ="); log_pp(t.conditions); @@ -1372,7 +1478,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); @@ -1407,8 +1513,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; @@ -1416,7 +1522,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); @@ -1434,20 +1540,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)) { @@ -1457,19 +1563,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; } @@ -1478,7 +1584,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; } @@ -1505,7 +1611,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; } } @@ -1520,7 +1626,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; } @@ -1529,8 +1635,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; } } @@ -1545,7 +1651,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; } @@ -1554,8 +1660,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; } } @@ -1585,17 +1691,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; } } @@ -1604,7 +1710,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; } @@ -1614,8 +1720,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)) { @@ -1623,8 +1729,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)) { @@ -1633,8 +1739,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)) { @@ -1650,9 +1756,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; } @@ -1671,7 +1777,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; } @@ -1687,14 +1793,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); @@ -1715,14 +1821,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; } @@ -1730,7 +1836,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; } @@ -1739,15 +1845,14 @@ 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_assert(?p, ?a)) { - ret pure_exp(a, pres); - } - case (expr_check(?p, ?a)) { + case (expr_check_expr(?p, ?a)) { changed = extend_prestate_ann(a, pres) || changed; changed = find_pre_post_state_expr(fm, enclosing, pres, p) || changed; - /* FIXME: update the postcondition to reflect that p holds */ + /* p is pure, so the poststate must be the same as the prestate */ changed = extend_poststate_ann(a, pres) || changed; ret changed; } @@ -1770,7 +1875,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); - assert (!is_none[@ts_ann](stmt_ann_)); + check (!is_none[@ts_ann](stmt_ann_)); auto stmt_ann = *(get[@ts_ann](stmt_ann_)); log("*At beginning: stmt = "); log_stmt(*s); @@ -1792,7 +1897,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 = "); @@ -1827,10 +1932,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); @@ -1875,7 +1980,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); } } @@ -1933,13 +2038,13 @@ fn (&fn_info_map, &fn_info, &ast._fn) -> bool f, } } -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: "); @@ -1988,7 +2093,7 @@ fn do_one_(fn_info i, &@stmt s) -> () { _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); @@ -2011,7 +2116,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 */ - assert (f_info_map.contains_key(id)); + check(f_info_map.contains_key(id)); auto f_info = f_info_map.get(id); check_fn_states(f_info_map, f_info, f); @@ -2021,7 +2126,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) -> () { - assert (f_info_map.contains_key(m.node.id)); + check (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); } @@ -2088,7 +2193,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 { - assert (fm.contains_key(id)); + check(fm.contains_key(id)); auto f_info = fm.get(id); log(i + " has " + uistr(num_locals(f_info)) + " local vars"); @@ -2308,11 +2413,8 @@ 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_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_check_expr(?e, ?a)) { + e1 = expr_check_expr(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 8a5d40dc563..dbc188b1d40 100644 --- a/src/comp/middle/walk.rs +++ b/src/comp/middle/walk.rs @@ -392,10 +392,7 @@ fn walk_expr(&ast_visitor v, @ast.expr e) { case (ast.expr_log(_,?x, _)) { walk_expr(v, x); } - case (ast.expr_check(?x, _)) { - walk_expr(v, x); - } - case (ast.expr_assert(?x, _)) { + case (ast.expr_check_expr(?x, _)) { walk_expr(v, x); } case (ast.expr_port(_)) { } diff --git a/src/comp/pretty/pprust.rs b/src/comp/pretty/pprust.rs index 7ef91ce89e4..e49ed34e948 100644 --- a/src/comp/pretty/pprust.rs +++ b/src/comp/pretty/pprust.rs @@ -661,18 +661,12 @@ fn print_opt(ps s, &option.t[@ast.expr] expr) { } print_expr(s, expr); } - case (ast.expr_check(?expr,_)) { + case (ast.expr_check_expr(?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 9e815b46484..b7fbc3cc25d 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 - assert (p.precondition.nbits == p.postcondition.nbits); + check (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 368fe21710e..0d925d7d024 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) { - assert (color < 16u8); + check (color < 16u8); esc(writer); if (color >= 8u8) { diff --git a/src/lib/_int.rs b/src/lib/_int.rs index 1824d142dab..dfd2204d007 100644 --- a/src/lib/_int.rs +++ b/src/lib/_int.rs @@ -27,7 +27,7 @@ fn to_str(int n, uint radix) -> str { - assert (0u < radix && radix <= 16u); + check (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 ed2027e1da2..44f14fb6e1c 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); - assert (w != 0u); + check(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); - assert (byte & 0xc0_u8 == tag_cont_u8); + check(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)); - assert (chsize > 0u); + check(chsize > 0u); len += 1u; i += chsize; } - assert (i == total); + check(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;} - assert (end > 0u); + check(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); - assert (len > 0u); + check(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); - assert (len > 0u); + check(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 2d373cdd2ba..97108c9082b 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; - assert (0u < radix && radix <= 16u); + check (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 4761a867494..126bf363052 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 { - assert (offset < len[T](v)); + check (offset < len[T](v)); ret rustrt.vec_buf[T](v, offset); } @@ -149,10 +149,9 @@ 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] { - assert (start <= end); - assert (end <= len[T](v)); + check (start <= end); + check (end <= len[T](v)); auto result = alloc[T](end - start); let uint i = start; while (i < end) { @@ -164,7 +163,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); - assert (ln > 0u); + check(ln > 0u); auto e = v.(0); v = slice[T](v, 1u, ln); ret e; @@ -172,7 +171,7 @@ fn shift[T](&mutable array[T] v) -> T { fn pop[T](&mutable array[T] v) -> T { auto ln = len[T](v); - assert (ln > 0u); + check(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 f52b016b768..feb4296aa6e 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); - assert (_vec.len[mutable uint](v0.storage) == len); - assert (v0.nbits == v1.nbits); + check (_vec.len[mutable uint](v0.storage) == len); + check (v0.nbits == v1.nbits); auto changed = false; @@ -84,7 +84,7 @@ fn clone(t v) -> t { } fn get(&t v, uint i) -> bool { - assert (i < v.nbits); + check (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) { - assert (i < v.nbits); + check (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 { - assert (v0.nbits == _vec.len[uint](v1)); + check (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 ee706ae7e7d..776f82e99fe 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]] { - assert (nelts == _vec.len[cell[T]](elts)); + check (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 9bad0f3311d..f73ad4fc647 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; - assert (sz <= 4u); + check (sz <= 4u); auto val = 0u; auto pos = start; while (sz > 0u) { diff --git a/src/lib/fs.rs b/src/lib/fs.rs index e185ca3e8c2..774ce11324c 100644 --- a/src/lib/fs.rs +++ b/src/lib/fs.rs @@ -10,7 +10,7 @@ fn path_sep() -> str { fn dirname(path p) -> path { auto sep = path_sep(); - assert (_str.byte_len(sep) == 1u); + check (_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 7d59da30400..4c1bf2dfb2b 100644 --- a/src/lib/io.rs +++ b/src/lib/io.rs @@ -72,7 +72,7 @@ fn eof() -> bool { ret os.libc.feof(f) != 0; } fn seek(int offset, seek_style whence) { - assert (os.libc.fseek(f, offset, convert_whence(whence)) == 0); + check (os.libc.fseek(f, offset, convert_whence(whence)) == 0); } fn tell() -> uint { ret os.libc.ftell(f) as uint; @@ -101,14 +101,14 @@ fn read_char() -> char { if (c0 == -1) {ret -1 as char;} // FIXME will this stay valid? auto b0 = c0 as u8; auto w = _str.utf8_char_width(b0); - assert (w > 0u); + check(w > 0u); if (w == 1u) {ret b0 as char;} auto val = 0u; while (w > 1u) { w -= 1u; auto next = rdr.read_byte(); - assert (next > -1); - assert (next & 0xc0 == 0x80); + check(next > -1); + check(next & 0xc0 == 0x80); val <<= 6u; val += (next & 0x3f) as uint; } @@ -279,7 +279,7 @@ fn write(vec[u8] v) { } fn seek(int offset, seek_style whence) { - assert (os.libc.fseek(f, offset, convert_whence(whence)) == 0); + check(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 d2a8ff97aaf..d5230e9ae09 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); - assert (os.libc.pipe(_vec.buf[mutable int](fds)) == 0); + check(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); - assert (os.libc.waitpid(pid, _vec.buf[mutable int](status), 0) != -1); + check(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 a52b02c5658..b0980bc5225 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); - assert (os.libc.pipe(_vec.buf[mutable int](fds)) == 0); + check(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); - assert (os.libc.waitpid(pid, _vec.buf[mutable int](status), 0) != -1); + check(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 f4cf12d35f2..03115fc7d33 100644 --- a/src/lib/posix_fs.rs +++ b/src/lib/posix_fs.rs @@ -5,7 +5,7 @@ fn list_dir(str path) -> vec[str] { // TODO ensure this is always closed auto dir = os.libc.opendir(_str.buf(path)); - assert (dir as uint != 0u); + check (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 690489db345..3866be1e04c 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 - assert (!st.computed); + check (!st.computed); for (u8 element in msg) { st.msg_block.(st.msg_block_idx) = element; @@ -67,7 +67,7 @@ fn add_input(&sha1state st, &vec[u8] msg) { fn process_msg_block(&sha1state st) { // FIXME: Make precondition - assert (_vec.len[mutable u32](st.h) == digest_buf_len); + check (_vec.len[mutable u32](st.h) == digest_buf_len); // Constants auto k = vec(0x5A827999u32, @@ -192,7 +192,7 @@ fn mk_result(&sha1state st) -> vec[u8] { */ fn pad_msg(&sha1state st) { // FIXME: Should be a precondition - assert (_vec.len[mutable u8](st.msg_block) == msg_block_len); + check (_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 pad_msg(&sha1state st) { fn reset() { // FIXME: Should be typestate precondition - assert (_vec.len[mutable u32](st.h) == digest_buf_len); + check (_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 1c6521e31f6..a2940d8de55 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); - assert (os.libc._pipe(_vec.buf[mutable int](fds), 1024u, + check(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 c688a40426d..e8c9cf71bcb 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() { - assert (1 == 2); + check (1 == 2); } diff --git a/src/test/run-fail/linked-failure.rs b/src/test/run-fail/linked-failure.rs index 60e82200848..7def7c11d0a 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() { - assert (1 == 2); + check (1 == 2); } fn main() { diff --git a/src/test/run-fail/str-overrun.rs b/src/test/run-fail/str-overrun.rs index 68b1e263d27..4388cb3ac80 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; - assert (s.(x) == (0x68 as u8)); + check (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. - assert (s.(x + 6) == (0x0 as u8)); + check (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 810feb39bcd..961da730e3b 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; - assert (v.(x) == 10); + check (v.(x) == 10); // Bounds-check failure. - assert (v.(x + 2) == 20); + check (v.(x + 2) == 20); } diff --git a/src/test/run-fail/vec-underrun.rs b/src/test/run-fail/vec-underrun.rs index f1998da5293..a230d1be7ff 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; - assert (v.(x) == 10); + check (v.(x) == 10); // Bounds-check failure. - assert (v.(x-1) == 20); + check (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 b92ffd7481b..4ee2c12bec2 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); - assert (_str.refcount(s) == const_refcount); + check (_str.refcount(s) == const_refcount); } fn main() { let str s = "hi"; // ref up foo(s); // ref up then down log _str.refcount(s); - assert (_str.refcount(s) == const_refcount); + check (_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 bad74a2a3ce..91190260bb1 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() { - assert (altlit(10) == 20); - assert (altlit(11) == 22); + check (altlit(10) == 20); + check (altlit(11) == 22); } diff --git a/src/test/run-pass/alt-tag.rs b/src/test/run-pass/alt-tag.rs index bc0afcb5fec..68013dfe303 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); - assert (process(gray) == 127); - assert (process(clear) == 0); - assert (process(red) == 255); + check (process(gray) == 127); + check (process(clear) == 0); + check (process(red) == 255); } diff --git a/src/test/run-pass/arith-0.rs b/src/test/run-pass/arith-0.rs index 857eaa8e42a..7587b0050ad 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; - assert (a * (a - 1) == 90); + check (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 55230e9e5da..bac6a055e80 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; - 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); + 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); let int i32_b = 0x10101010; - 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); + 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); log ((i32_b | (i32_b << 1))); - assert ((i32_b | (i32_b << 1)) == 0x30303030); + check((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 70892682b77..33a740c84fc 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; - assert (i32_c + i32_c * 2 / 3 * 2 + (i32_c - 7 % 3) == + check (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 0e2818a3a45..748ff6b7da3 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() { - 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); + 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); // 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 5df5456b773..956a7eb440b 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; - assert (z == 21); + check (z == 21); let fish forty = tup(@40); let fish two = tup(@2); let int answer = forty._0 + two._0; log answer; - assert (answer == 42); + check (answer == 42); } diff --git a/src/test/run-pass/bind-exterior.rs b/src/test/run-pass/bind-exterior.rs index f6f369185fc..c3fc2e7c361 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); - assert (f1() == 22); + check(f1() == 22); } diff --git a/src/test/run-pass/bind-interior.rs b/src/test/run-pass/bind-interior.rs index ae994d1c7ab..2d164e07e05 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(); - assert (i == 10); + check(i == 10); } diff --git a/src/test/run-pass/bind-obj-ctor.rs b/src/test/run-pass/bind-obj-ctor.rs index b5215f9ad68..8780b22a002 100644 --- a/src/test/run-pass/bind-obj-ctor.rs +++ b/src/test/run-pass/bind-obj-ctor.rs @@ -11,7 +11,7 @@ fn sum() -> int { auto ctor1 = bind simple(_, 2); auto obj1 = ctor0(2); auto obj2 = ctor1(1); - assert (obj0.sum() == 3); - assert (obj1.sum() == 3); - assert (obj2.sum() == 3); + check (obj0.sum() == 3); + check (obj1.sum() == 3); + check (obj2.sum() == 3); } diff --git a/src/test/run-pass/bind-thunk.rs b/src/test/run-pass/bind-thunk.rs index 7cafc50108d..be6e1b24e13 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(); - assert (i == 42); + check(i == 42); } diff --git a/src/test/run-pass/bind-trivial.rs b/src/test/run-pass/bind-trivial.rs index e73f2b7ca3c..fbd6e78d797 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); - assert (i == 42); + check(i == 42); } diff --git a/src/test/run-pass/bitwise.rs b/src/test/run-pass/bitwise.rs index 99324489186..36b58a91726 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; - assert (b == 1); - assert (a == 2); + check (b == 1); + check (a == 2); - 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); + 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); } diff --git a/src/test/run-pass/bool-not.rs b/src/test/run-pass/bool-not.rs index 337efc6f85f..ba70bdb1318 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) { - assert (true); + check (true); } else { - assert (false); + check (false); } if (!true) { - assert (false); + check (false); } else { - assert (true); + check (true); } } diff --git a/src/test/run-pass/box-compare.rs b/src/test/run-pass/box-compare.rs index 8f23035dbd8..619790d7965 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() { - assert (@1 < @3); - assert (@@"hello " > @@"hello"); - assert (@@@"hello" != @@@"there"); + check (@1 < @3); + check (@@"hello " > @@"hello"); + check (@@@"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 b1d50533607..d0ad615b2e6 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"; - assert (unbox[int](bfoo) == foo); + check (unbox[int](bfoo) == foo); } diff --git a/src/test/run-pass/box.rs b/src/test/run-pass/box.rs index c105e80146c..ffcd9ec5946 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; - assert ((*x) == 10); + check ((*x) == 10); } diff --git a/src/test/run-pass/break.rs b/src/test/run-pass/break.rs index 5a63d9acb48..48c3b091f08 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; } } - assert (i == 10); + check(i == 10); do { i += 1; if (i == 20) { break; } } while (i < 30); - assert (i == 20); + check(i == 20); for (int x in vec(1, 2, 3, 4, 5, 6)) { if (x == 3) { break; } - assert (x <= 3); + check(x <= 3); } i = 0; while (i < 10) { i += 1; if (i % 2 == 0) { cont; } - assert (i % 2 != 0); + check(i % 2 != 0); } i = 0; do { i += 1; if (i % 2 == 0) { cont; } - assert (i % 2 != 0); + check(i % 2 != 0); } while (i < 10); for (int x in vec(1, 2, 3, 4, 5, 6)) { if (x % 2 == 0) { cont; } - assert (x % 2 != 0); + check(x % 2 != 0); } } diff --git a/src/test/run-pass/cast.rs b/src/test/run-pass/cast.rs index ecc7ac12db1..e04ad62939d 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; - assert (i == 0x51); + check (i == 0x51); let u32 u = i as u32; - 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 (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 (true == (1 as bool)); - assert ((0 as u32) == (false as u32)); + check (true == (1 as bool)); + check ((0 as u32) == (false as u32)); } diff --git a/src/test/run-pass/char.rs b/src/test/run-pass/char.rs index a3ddae6c7cb..123f2eb26c4 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'; - assert (c == 'x'); - assert ('x' == c); - assert (c == c); - assert (c == d); - assert (d == c); - assert (d == 'x'); - assert ('x' == d); + check(c == 'x'); + check('x' == c); + check(c == c); + check(c == d); + check(d == c); + check (d == 'x'); + check('x' == d); } diff --git a/src/test/run-pass/clone-with-exterior.rs b/src/test/run-pass/clone-with-exterior.rs index 99c319c26d0..e97c409d50f 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) { - assert (x.a == 10); - assert (x.b == 12); + check (x.a == 10); + check (x.b == 12); } fn main() { diff --git a/src/test/run-pass/comm.rs b/src/test/run-pass/comm.rs index ef93eee6349..2bca62488dc 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; - assert (y == 10); + check (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 36487aa83b5..5630d2e278d 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; - assert (i == 10); + check (i == 10); ch <| 11; auto j <- po; - assert (j == 11); + check (j == 11); } diff --git a/src/test/run-pass/deep.rs b/src/test/run-pass/deep.rs index 32d4dae1fec..5131c42b0fe 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() { - assert (f(5000) == 5000); + check (f(5000) == 5000); } diff --git a/src/test/run-pass/div-mod.rs b/src/test/run-pass/div-mod.rs index 00835d41c72..cfa0fbe9c17 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; - assert (x / 5 == 3); - assert (x / 4 == 3); - assert (x / 3 == 5); - assert (x / y == 3); - assert (15 / y == 3); + check(x / 5 == 3); + check(x / 4 == 3); + check(x / 3 == 5); + check(x / y == 3); + check(15 / y == 3); - assert (x % 5 == 0); - assert (x % 4 == 3); - assert (x % 3 == 0); - assert (x % y == 0); - assert (15 % y == 0); + check(x % 5 == 0); + check(x % 4 == 3); + check(x % 3 == 0); + check(x % y == 0); + check(15 % y == 0); } diff --git a/src/test/run-pass/else-if.rs b/src/test/run-pass/else-if.rs index edb25e16f73..d9e5b869025 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) { - assert (false); + check(false); } else if (2 == 3) { - assert (false); + check(false); } else if (3 == 4) { - assert (false); + check(false); } else { - assert (true); + check(true); } if (1 == 2) { - assert (false); + check(false); } else if (2 == 2) { - assert (true); + check(true); } if (1 == 2) { - assert (false); + check(false); } else if (2 == 2) { if (1 == 1) { - assert (true); + check(true); } else { if (2 == 1) { - assert (false); + check(false); } else { - assert (false); + check(false); } } } if (1 == 2) { - assert (false); + check(false); } else { if (1 == 2) { - assert (false); + check(false); } else { - assert (true); + check(true); } } } diff --git a/src/test/run-pass/expr-alt-box.rs b/src/test/run-pass/expr-alt-box.rs index e18611fa96f..2e7846f36c3 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 } }; - assert (*res == 100); + check (*res == 100); } fn test_str() { @@ -18,7 +18,7 @@ fn test_str() { "happy" } }; - assert (res == "happy"); + check (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 a1367e81b8c..8ff67f0ff3b 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 } }; - assert (eq(expected, actual)); + check (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 469b8e7c6d9..7928ffede55 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 } }; - assert (eq(expected, actual)); + check (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 0cd0177a215..6668105955d 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 } }; - assert (eq(expected, actual)); + check (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 762303d53c1..31406969d87 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) } }; - assert (res == rec(i = 100)); + check (res == rec(i = 100)); } fn test_tag() { @@ -26,7 +26,7 @@ fn test_tag() { sad } }; - assert (res == happy); + check (res == happy); } fn main() { diff --git a/src/test/run-pass/expr-alt.rs b/src/test/run-pass/expr-alt.rs index 52a01078762..4c10a7d9e29 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 } }; - assert (res); + check (res); res = alt(false) { case (true) { @@ -22,7 +22,7 @@ fn test_basic() { true } }; - assert (res); + check (res); } fn test_inferrence() { @@ -34,7 +34,7 @@ fn test_inferrence() { false } }; - assert (res); + check (res); } fn test_alt_as_alt_head() { @@ -47,7 +47,7 @@ fn test_alt_as_alt_head() { true } }; - assert (res); + check (res); } fn test_alt_as_block_result() { @@ -66,7 +66,7 @@ fn test_alt_as_block_result() { } } }; - assert (res); + check (res); } fn main() { diff --git a/src/test/run-pass/expr-block-box.rs b/src/test/run-pass/expr-block-box.rs index 206c44afd3a..e8ab62091a5 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 }; - assert (*x == 100); + check (*x == 100); } diff --git a/src/test/run-pass/expr-block-fn.rs b/src/test/run-pass/expr-block-fn.rs index a37d1cb0f8d..eb0357d9e89 100644 --- a/src/test/run-pass/expr-block-fn.rs +++ b/src/test/run-pass/expr-block-fn.rs @@ -6,7 +6,7 @@ fn ten() -> int { ret 10; } let t res = { ten }; - assert (res() == 10); + check (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 82d54c175d0..57487fd617d 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 @@ fn test_generic[T](@T expected, &compare[T] eq) { let @T actual = { expected }; - assert (eq(expected, actual)); + check (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 c1c8260c681..3b1e44791a0 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 @@ fn test_generic[T](&T expected, &compare[T] eq) { let T actual = { expected }; - assert (eq(expected, actual)); + check (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 d6061a6c84c..ded3b620704 100644 --- a/src/test/run-pass/expr-block-generic.rs +++ b/src/test/run-pass/expr-block-generic.rs @@ -7,7 +7,7 @@ fn test_generic[T](&T expected, &compare[T] eq) { let T actual = { expected }; - assert (eq(expected, actual)); + check (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 1c03a6b0694..ecc6f04a340 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 }; - assert (res); + check (res); } fn test_rec() { auto res = { rec(v1 = 10, v2 = 20) }; - assert (res.v2 == 20); + check (res.v2 == 20); } fn test_filled_with_stuff() { @@ -21,7 +21,7 @@ fn test_filled_with_stuff() { } a }; - assert (res == 10); + check (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 d242d7448b7..a629c9c9bc4 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 }; - assert (*res == 100); + check (*res == 100); } fn test_str() { auto res = if (true) { "happy" } else { "sad" }; - assert (res == "happy"); + check (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 d1d4c05dee9..32aea8bb72f 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 @@ fn test_generic[T](@T expected, @T not_expected, &compare[T] eq) { let @T actual = if (true) { expected } else { not_expected }; - assert (eq(expected, actual)); + check (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 a126b1c45a9..d414d6d104d 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 @@ fn test_generic[T](&T expected, &T not_expected, &compare[T] eq) { let T actual = if (true) { expected } else { not_expected }; - assert (eq(expected, actual)); + check (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 b86a7553d98..0a0db2ddfde 100644 --- a/src/test/run-pass/expr-if-generic.rs +++ b/src/test/run-pass/expr-if-generic.rs @@ -7,7 +7,7 @@ fn test_generic[T](&T expected, &T not_expected, &compare[T] eq) { let T actual = if (true) { expected } else { not_expected }; - assert (eq(expected, actual)); + check (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 6d42c2241d5..df20a3bae60 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) }; - assert (res == rec(i = 100)); + check (res == rec(i = 100)); } fn test_tag() { @@ -15,7 +15,7 @@ fn test_tag() { } auto res = if (true) { happy } else { sad }; - assert (res == happy); + check (res == happy); } fn main() { diff --git a/src/test/run-pass/expr-if.rs b/src/test/run-pass/expr-if.rs index 67f56746de6..7c99f2ea82e 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 }; - assert (res); + check (res); } fn test_else() { let bool res = if (false) { false } else { true }; - assert (res); + check (res); } fn test_elseif1() { @@ -21,7 +21,7 @@ fn test_elseif1() { } else { false }; - assert (res); + check (res); } fn test_elseif2() { @@ -32,7 +32,7 @@ fn test_elseif2() { } else { false }; - assert (res); + check (res); } fn test_elseif3() { @@ -43,12 +43,12 @@ fn test_elseif3() { } else { true }; - assert (res); + check (res); } fn test_inferrence() { auto res = if (true) { true } else { false }; - assert (res); + check (res); } fn test_if_as_if_condition() { @@ -57,14 +57,14 @@ fn test_if_as_if_condition() { } else { false }; - assert (res1); + check (res1); auto res2 = if (if (true) { false } else { true }) { false } else { true }; - assert (res2); + check (res2); } fn test_if_as_block_result() { @@ -77,7 +77,7 @@ fn test_if_as_block_result() { } else { false }; - assert (res); + check (res); } fn main() { diff --git a/src/test/run-pass/exterior.rs b/src/test/run-pass/exterior.rs index 661effda38a..f09ee8234e3 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) { - assert (p.z == 12); + check (p.z == 12); p.z = 13; - assert (p.z == 13); + check (p.z == 13); } fn main() { let point a = rec(x=10, y=11, mutable z=12); let @point b = @a; - assert (b.z == 12); + check (b.z == 12); f(b); - assert (a.z == 12); - assert (b.z == 13); + check (a.z == 12); + check (b.z == 13); } diff --git a/src/test/run-pass/fact.rs b/src/test/run-pass/fact.rs index 577ee6a226e..91cf099c3ac 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 () { - assert (f(5) == 120); + check (f(5) == 120); // log "all done"; } diff --git a/src/test/run-pass/float2.rs b/src/test/run-pass/float2.rs index e6136d2cf44..9cc3a8ca9cd 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; - 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); + 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); } \ No newline at end of file diff --git a/src/test/run-pass/floatlits.rs b/src/test/run-pass/floatlits.rs index 37f21c8f43a..10b0fb7766a 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; - assert (f > 4.90); - assert (f < 5.0); + check (f > 4.90); + check (f < 5.0); auto g = 4.90000000001e-10; - assert (g > 5e-11); - assert (g < 5e-9); + check(g > 5e-11); + check(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 33a376d529e..d25405d8c6e 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() { } } - assert (a.(0) == 0); - assert (a.(1) == 1); - assert (a.(2) == 10); - assert (a.(3) == 11); - assert (a.(4) == 100); - assert (a.(5) == 101); - assert (a.(6) == 110); - assert (a.(7) == 111); + check (a.(0) == 0); + check (a.(1) == 1); + check (a.(2) == 10); + check (a.(3) == 11); + check (a.(4) == 100); + check (a.(5) == 101); + check (a.(6) == 110); + check (a.(7) == 111); } diff --git a/src/test/run-pass/foreach-nested.rs b/src/test/run-pass/foreach-nested.rs index 9ba304c1463..a655f591019 100644 --- a/src/test/run-pass/foreach-nested.rs +++ b/src/test/run-pass/foreach-nested.rs @@ -16,8 +16,8 @@ fn main() { } } - assert (a.(0) == 0); - assert (a.(1) == 1); - assert (a.(2) == 10); - assert (a.(3) == 11); + check (a.(0) == 0); + check (a.(1) == 1); + check (a.(2) == 10); + check (a.(3) == 11); } diff --git a/src/test/run-pass/foreach-put-structured.rs b/src/test/run-pass/foreach-put-structured.rs index 02dbef5d514..43d8b5c33a8 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; - assert (p._0 + 10 == i); + check (p._0 + 10 == i); i += 1; j = p._1; } - assert (j == 45); + check(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 8f23d61d03d..efc6e8ca702 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; - assert (sum == 45); + check (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 5fa3837e6b3..59446b4a771 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 - //assert (a == b); - //assert (b == c); + //check(a == b); + //check(b == c); } diff --git a/src/test/run-pass/fun-indirect-call.rs b/src/test/run-pass/fun-indirect-call.rs index 1d506dca26e..10c2cf40505 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(); - assert (i == 42); + check(i == 42); } diff --git a/src/test/run-pass/generic-alias-box.rs b/src/test/run-pass/generic-alias-box.rs index ce3889fbb4c..377e0fb2b8d 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; - assert (*expected == *actual); + check (*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 f3a65edd549..3975867ac29 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); - assert (t._5 == 6); + check (t._5 == 6); auto f0 = bind id[tup(int,int,int,int,int,int,int)](t); - assert (f0()._5 == 6); + check (f0()._5 == 6); } diff --git a/src/test/run-pass/generic-bind.rs b/src/test/run-pass/generic-bind.rs index c65e061ad21..ef1275e3cec 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); - assert (t._5 == 6); + check (t._5 == 6); auto f1 = bind id[tup(int,int,int,int,int,int,int)](_); - assert (f1(t)._5 == 6); + check (f1(t)._5 == 6); } diff --git a/src/test/run-pass/generic-box.rs b/src/test/run-pass/generic-box.rs index 76d5e3ab01b..856f3aff8e6 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)); - assert (x._1 == 2); + check (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 507d1c5fd87..54c3f9564ec 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; - assert (b._0 == 10); - assert (b._1 == 10); + check (b._0 == 10); + check (b._1 == 10); } diff --git a/src/test/run-pass/generic-exterior-box.rs b/src/test/run-pass/generic-exterior-box.rs index 07eae9c1a42..0ec7020cdad 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); - assert (tbfoo._0 == foo); - assert (rbfoo.x == foo); + check (tbfoo._0 == foo); + check (rbfoo.x == foo); } diff --git a/src/test/run-pass/generic-fn-infer.rs b/src/test/run-pass/generic-fn-infer.rs index 9c795ec250c..4398670f15e 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); - assert (x == y); + check (x == y); } diff --git a/src/test/run-pass/generic-fn.rs b/src/test/run-pass/generic-fn.rs index 4f93fef52c9..238ef2d1aea 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; - assert (x == y); + check (x == y); b = id[char](a); log b; - assert (a == b); + check (a == b); q = id[triple](p); x = p._2; y = q._2; log y; - assert (x == y); + check (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 cc549f6bd6e..2a50ccd2bb1 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; - assert (h.get()._0 == (1 as u8)); - assert (h.get()._1 == (2 as u8)); - assert (h.get()._2 == (3 as u8)); + check (h.get()._0 == (1 as u8)); + check (h.get()._1 == (2 as u8)); + check (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 9879fa790b5..ced9140fc60 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); - assert (b.get(0) == 1); - assert (b.get(1) == 2); - assert (b.get(2) == 3); + check (b.get(0) == 1); + check (b.get(1) == 2); + check (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 f29cfa00036..9b19eec7388 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; } } - assert (hit); + check (hit); } fn main() { diff --git a/src/test/run-pass/generic-tag-values.rs b/src/test/run-pass/generic-tag-values.rs index 46421e0a28c..090a050404a 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; - assert (n == 5); + check (n == 5); } } @@ -18,8 +18,8 @@ fn main() { case (some[tup(int, int)](?t)) { log t._0; log t._1; - assert (t._0 == 17); - assert (t._1 == 42); + check (t._0 == 17); + check (t._1 == 42); } } } diff --git a/src/test/run-pass/generic-temporary.rs b/src/test/run-pass/generic-temporary.rs index 2f697124625..98401ecc1c5 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; - assert (a == 1); + check (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 d2edfd2e379..c387ef1928d 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)); - assert (get_third(tup(1,2,3)) == 3); - assert (get_third(tup(5u8,6u8,7u8)) == 7u8); + check (get_third(tup(1,2,3)) == 3); + check (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 9b5b5297f15..6638cebfeea 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); - assert (x._0 == 10); - assert (x._1 == 12); + check (x._0 == 10); + check (x._1 == 12); } diff --git a/src/test/run-pass/i32-sub.rs b/src/test/run-pass/i32-sub.rs index eb5e76fb292..3f00acb1ff8 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; - assert (x == 400_i32); + check(x == 400_i32); } diff --git a/src/test/run-pass/i8-incr.rs b/src/test/run-pass/i8-incr.rs index 92ff04ea284..fb387d316c5 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; - assert (x == y); + check(x == y); } diff --git a/src/test/run-pass/integral-indexing.rs b/src/test/run-pass/integral-indexing.rs index ee80786c18a..fe7d147c30c 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"; - assert (v.(3u) == 3); - assert (v.(3u8) == 3); - assert (v.(3i8) == 3); - assert (v.(3u32) == 3); - assert (v.(3i32) == 3); + check (v.(3u) == 3); + check (v.(3u8) == 3); + check (v.(3i8) == 3); + check (v.(3u32) == 3); + check (v.(3i32) == 3); log v.(3u8); - 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); + 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); 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 78bf94c33ab..ade7c51c6ab 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 { - assert (a < b); + check (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 7034efba2b6..fe0ffe6b21b 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; - assert (false); + check (false); ret false; } fn main() { auto x = (1 == 2) || (3 == 3); - assert (x); + check (x); let int y = 10; log x || incr(y); - assert (y == 10); + check (y == 10); if (true && x) { - assert (true); + check (true); } else { - assert (false); + check (false); } } \ No newline at end of file diff --git a/src/test/run-pass/lazychan.rs b/src/test/run-pass/lazychan.rs index a91adaa1565..6face271eed 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; - assert (y == 10); + check (y == 10); spawn child(c); y <- p; log "received 2"; log y; - assert (y == 10); + check (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 8f2d939005c..162e8b13293 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]()? - assert (bitv.eq_vec(act, exp)); + check (bitv.eq_vec(act, exp)); } fn test_1_element() { auto act; act = bitv.create(1u, false); - assert (bitv.eq_vec(act, vec(0u))); + check (bitv.eq_vec(act, vec(0u))); act = bitv.create(1u, true); - assert (bitv.eq_vec(act, vec(1u))); + check (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); - assert (bitv.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u))); + check (bitv.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u))); // all 1 act = bitv.create(10u, true); - assert (bitv.eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u))); + check (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); - assert (bitv.eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 0u, 0u, 0u, 0u, 0u))); + check (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); - assert (bitv.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 1u, 1u, 1u, 1u, 1u))); + check (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); - assert (bitv.eq_vec(act, vec(1u, 0u, 0u, 1u, 0u, 0u, 1u, 0u, 0u, 1u))); + check (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); - assert (bitv.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + check (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); - assert (bitv.eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, + check (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); - assert (bitv.eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, + check (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); - assert (bitv.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + check (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); - assert (bitv.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + check (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); - assert (bitv.eq_vec(act, vec(0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u, + check (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); - assert (bitv.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + check (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); - assert (bitv.eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, + check (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); - assert (bitv.eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, + check (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); - assert (bitv.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + check (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); - assert (bitv.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + check (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); - assert (bitv.eq_vec(act, vec(0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u, + check (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); - assert (bitv.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + check (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); - assert (bitv.eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, + check (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); - assert (bitv.eq_vec(act, vec(1u, 1u, 1u, 1u, 1u, 1u, 1u, 1u, + check (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); - assert (bitv.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + check (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); - assert (bitv.eq_vec(act, vec(0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, + check (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); - assert (bitv.eq_vec(act, vec(0u, 0u, 0u, 1u, 0u, 0u, 0u, 0u, + check (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 62807251bd1..10f5e727110 100644 --- a/src/test/run-pass/lib-box.rs +++ b/src/test/run-pass/lib-box.rs @@ -4,9 +4,9 @@ fn main() { auto x = @3; auto y = @3; - 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)); + 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)); } diff --git a/src/test/run-pass/lib-deque.rs b/src/test/run-pass/lib-deque.rs index 405ab72be20..9fd177eaf96 100644 --- a/src/test/run-pass/lib-deque.rs +++ b/src/test/run-pass/lib-deque.rs @@ -5,125 +5,125 @@ fn test_simple() { let deque.t[int] d = deque.create[int](); - assert (d.size() == 0u); + check (d.size() == 0u); d.add_front(17); d.add_front(42); d.add_back(137); - assert (d.size() == 3u); + check (d.size() == 3u); d.add_back(137); - assert (d.size() == 4u); + check (d.size() == 4u); log d.peek_front(); - assert (d.peek_front() == 42); + check (d.peek_front() == 42); log d.peek_back(); - assert (d.peek_back() == 137); + check (d.peek_back() == 137); let int i = d.pop_front(); log i; - assert (i == 42); + check (i == 42); i = d.pop_back(); log i; - assert (i == 137); + check (i == 137); i = d.pop_back(); log i; - assert (i == 137); + check (i == 137); i = d.pop_back(); log i; - assert (i == 17); + check (i == 17); - assert (d.size() == 0u); + check (d.size() == 0u); d.add_back(3); - assert (d.size() == 1u); + check (d.size() == 1u); d.add_front(2); - assert (d.size() == 2u); + check (d.size() == 2u); d.add_back(4); - assert (d.size() == 3u); + check (d.size() == 3u); d.add_front(1); - assert (d.size() == 4u); + check (d.size() == 4u); log d.get(0); log d.get(1); log d.get(2); log d.get(3); - assert (d.get(0) == 1); - assert (d.get(1) == 2); - assert (d.get(2) == 3); - assert (d.get(3) == 4); + check (d.get(0) == 1); + check (d.get(1) == 2); + check (d.get(2) == 3); + check (d.get(3) == 4); } fn test_boxes(@int a, @int b, @int c, @int d) { let deque.t[@int] deq = deque.create[@int](); - assert (deq.size() == 0u); + check (deq.size() == 0u); deq.add_front(a); deq.add_front(b); deq.add_back(c); - assert (deq.size() == 3u); + check (deq.size() == 3u); deq.add_back(d); - assert (deq.size() == 4u); + check (deq.size() == 4u); - assert (deq.peek_front() == b); - assert (deq.peek_back() == d); + check (deq.peek_front() == b); + check (deq.peek_back() == d); - assert (deq.pop_front() == b); - assert (deq.pop_back() == d); - assert (deq.pop_back() == c); - assert (deq.pop_back() == a); + check (deq.pop_front() == b); + check (deq.pop_back() == d); + check (deq.pop_back() == c); + check (deq.pop_back() == a); - assert (deq.size() == 0u); + check (deq.size() == 0u); deq.add_back(c); - assert (deq.size() == 1u); + check (deq.size() == 1u); deq.add_front(b); - assert (deq.size() == 2u); + check (deq.size() == 2u); deq.add_back(d); - assert (deq.size() == 3u); + check (deq.size() == 3u); deq.add_front(a); - assert (deq.size() == 4u); + check (deq.size() == 4u); - assert (deq.get(0) == a); - assert (deq.get(1) == b); - assert (deq.get(2) == c); - assert (deq.get(3) == d); + check (deq.get(0) == a); + check (deq.get(1) == b); + check (deq.get(2) == c); + check (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](); - assert (deq.size() == 0u); + check (deq.size() == 0u); deq.add_front(a); deq.add_front(b); deq.add_back(c); - assert (deq.size() == 3u); + check (deq.size() == 3u); deq.add_back(d); - assert (deq.size() == 4u); + check (deq.size() == 4u); - assert (e(deq.peek_front(), b)); - assert (e(deq.peek_back(), d)); + check (e(deq.peek_front(), b)); + check (e(deq.peek_back(), d)); - 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 (e(deq.pop_front(), b)); + check (e(deq.pop_back(), d)); + check (e(deq.pop_back(), c)); + check (e(deq.pop_back(), a)); - assert (deq.size() == 0u); + check (deq.size() == 0u); deq.add_back(c); - assert (deq.size() == 1u); + check (deq.size() == 1u); deq.add_front(b); - assert (deq.size() == 2u); + check (deq.size() == 2u); deq.add_back(d); - assert (deq.size() == 3u); + check (deq.size() == 3u); deq.add_front(a); - assert (deq.size() == 4u); + check (deq.size() == 4u); - assert (e(deq.get(0), a)); - assert (e(deq.get(1), b)); - assert (e(deq.get(2), c)); - assert (e(deq.get(3), d)); + check (e(deq.get(0), a)); + check (e(deq.get(1), b)); + check (e(deq.get(2), c)); + check (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 e4e68351aab..2e85abf6509 100644 --- a/src/test/run-pass/lib-int.rs +++ b/src/test/run-pass/lib-int.rs @@ -4,22 +4,22 @@ import std._str.eq; fn test_to_str() { - 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")); + 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")); } fn test_pow() { - 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); + 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); } fn main() { diff --git a/src/test/run-pass/lib-io.rs b/src/test/run-pass/lib-io.rs index bcc2163cfd3..7102c91e36e 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; - assert (_str.eq(frood, frood2)); + check (_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 abd2041e151..4c8afa7d547 100644 --- a/src/test/run-pass/lib-map.rs +++ b/src/test/run-pass/lib-map.rs @@ -28,19 +28,19 @@ fn hash_uint(&uint u) -> uint { let map.hashmap[uint, uint] hm_uu = map.mk_hashmap[uint, uint](hasher_uint, eqer_uint); - assert (hm_uu.insert(10u, 12u)); - assert (hm_uu.insert(11u, 13u)); - assert (hm_uu.insert(12u, 14u)); + check (hm_uu.insert(10u, 12u)); + check (hm_uu.insert(11u, 13u)); + check (hm_uu.insert(12u, 14u)); - assert (hm_uu.get(11u) == 13u); - assert (hm_uu.get(12u) == 14u); - assert (hm_uu.get(10u) == 12u); + check (hm_uu.get(11u) == 13u); + check (hm_uu.get(12u) == 14u); + check (hm_uu.get(10u) == 12u); - assert (!hm_uu.insert(12u, 14u)); - assert (hm_uu.get(12u) == 14u); + check (!hm_uu.insert(12u, 14u)); + check (hm_uu.get(12u) == 14u); - assert (!hm_uu.insert(12u, 12u)); - assert (hm_uu.get(12u) == 12u); + check (!hm_uu.insert(12u, 12u)); + check (hm_uu.get(12u) == 12u); let str ten = "ten"; @@ -51,21 +51,21 @@ fn hash_uint(&uint u) -> uint { let map.hashmap[str, uint] hm_su = map.mk_hashmap[str, uint](hasher_str, eqer_str); - assert (hm_su.insert("ten", 12u)); - assert (hm_su.insert(eleven, 13u)); - assert (hm_su.insert("twelve", 14u)); + check (hm_su.insert("ten", 12u)); + check (hm_su.insert(eleven, 13u)); + check (hm_su.insert("twelve", 14u)); - assert (hm_su.get(eleven) == 13u); + check (hm_su.get(eleven) == 13u); - assert (hm_su.get("eleven") == 13u); - assert (hm_su.get("twelve") == 14u); - assert (hm_su.get("ten") == 12u); + check (hm_su.get("eleven") == 13u); + check (hm_su.get("twelve") == 14u); + check (hm_su.get("ten") == 12u); - assert (!hm_su.insert("twelve", 14u)); - assert (hm_su.get("twelve") == 14u); + check (!hm_su.insert("twelve", 14u)); + check (hm_su.get("twelve") == 14u); - assert (!hm_su.insert("twelve", 12u)); - assert (hm_su.get("twelve") == 12u); + check (!hm_su.insert("twelve", 12u)); + check (hm_su.get("twelve") == 12u); log "uint -> str"; @@ -73,19 +73,19 @@ fn hash_uint(&uint u) -> uint { let map.hashmap[uint, str] hm_us = map.mk_hashmap[uint, str](hasher_uint, eqer_uint); - assert (hm_us.insert(10u, "twelve")); - assert (hm_us.insert(11u, "thirteen")); - assert (hm_us.insert(12u, "fourteen")); + check (hm_us.insert(10u, "twelve")); + check (hm_us.insert(11u, "thirteen")); + check (hm_us.insert(12u, "fourteen")); - 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 (_str.eq(hm_us.get(11u), "thirteen")); + check (_str.eq(hm_us.get(12u), "fourteen")); + check (_str.eq(hm_us.get(10u), "twelve")); - assert (!hm_us.insert(12u, "fourteen")); - assert (_str.eq(hm_us.get(12u), "fourteen")); + check (!hm_us.insert(12u, "fourteen")); + check (_str.eq(hm_us.get(12u), "fourteen")); - assert (!hm_us.insert(12u, "twelve")); - assert (_str.eq(hm_us.get(12u), "twelve")); + check (!hm_us.insert(12u, "twelve")); + check (_str.eq(hm_us.get(12u), "twelve")); log "str -> str"; @@ -93,19 +93,19 @@ fn hash_uint(&uint u) -> uint { let map.hashmap[str, str] hm_ss = map.mk_hashmap[str, str](hasher_str, eqer_str); - assert (hm_ss.insert(ten, "twelve")); - assert (hm_ss.insert(eleven, "thirteen")); - assert (hm_ss.insert(twelve, "fourteen")); + check (hm_ss.insert(ten, "twelve")); + check (hm_ss.insert(eleven, "thirteen")); + check (hm_ss.insert(twelve, "fourteen")); - 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 (_str.eq(hm_ss.get("eleven"), "thirteen")); + check (_str.eq(hm_ss.get("twelve"), "fourteen")); + check (_str.eq(hm_ss.get("ten"), "twelve")); - assert (!hm_ss.insert("twelve", "fourteen")); - assert (_str.eq(hm_ss.get("twelve"), "fourteen")); + check (!hm_ss.insert("twelve", "fourteen")); + check (_str.eq(hm_ss.get("twelve"), "fourteen")); - assert (!hm_ss.insert("twelve", "twelve")); - assert (_str.eq(hm_ss.get("twelve"), "twelve")); + check (!hm_ss.insert("twelve", "twelve")); + check (_str.eq(hm_ss.get("twelve"), "twelve")); log "*** finished test_simple"; } @@ -135,7 +135,7 @@ fn hash_uint(&uint u) -> uint { let uint i = 0u; while (i < num_to_insert) { - assert (hm_uu.insert(i, i * i)); + check (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 hash_uint(&uint u) -> uint { while (i < num_to_insert) { log "get(" + _uint.to_str(i, 10u) + ") = " + _uint.to_str(hm_uu.get(i), 10u); - assert (hm_uu.get(i) == i * i); + check (hm_uu.get(i) == i * i); i += 1u; } - assert (hm_uu.insert(num_to_insert, 17u)); - assert (hm_uu.get(num_to_insert) == 17u); + check (hm_uu.insert(num_to_insert, 17u)); + check (hm_uu.get(num_to_insert) == 17u); log "-----"; @@ -162,7 +162,7 @@ fn hash_uint(&uint u) -> uint { while (i < num_to_insert) { log "get(" + _uint.to_str(i, 10u) + ") = " + _uint.to_str(hm_uu.get(i), 10u); - assert (hm_uu.get(i) == i * i); + check (hm_uu.get(i) == i * i); i += 1u; } @@ -176,7 +176,7 @@ fn hash_uint(&uint u) -> uint { i = 0u; while (i < num_to_insert) { - assert (hm_ss.insert(_uint.to_str(i, 2u), _uint.to_str(i * i, 2u))); + check (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 hash_uint(&uint u) -> uint { + "\") = \"" + hm_ss.get(_uint.to_str(i, 2u)) + "\""; - assert (_str.eq(hm_ss.get(_uint.to_str(i, 2u)), + check (_str.eq(hm_ss.get(_uint.to_str(i, 2u)), _uint.to_str(i * i, 2u))); i += 1u; } - assert (hm_ss.insert(_uint.to_str(num_to_insert, 2u), + check (hm_ss.insert(_uint.to_str(num_to_insert, 2u), _uint.to_str(17u, 2u))); - assert (_str.eq(hm_ss.get(_uint.to_str(num_to_insert, 2u)), + check (_str.eq(hm_ss.get(_uint.to_str(num_to_insert, 2u)), _uint.to_str(17u, 2u))); log "-----"; @@ -210,7 +210,7 @@ fn hash_uint(&uint u) -> uint { while (i < num_to_insert) { log "get(\"" + _uint.to_str(i, 2u) + "\") = \"" + hm_ss.get(_uint.to_str(i, 2u)) + "\""; - assert (_str.eq(hm_ss.get(_uint.to_str(i, 2u)), + check (_str.eq(hm_ss.get(_uint.to_str(i, 2u)), _uint.to_str(i * i, 2u))); i += 1u; } @@ -230,9 +230,9 @@ fn hash(&uint u) -> uint { ret (u / 2u) * 2u; } - assert (hash(0u) == hash(1u)); - assert (hash(2u) == hash(3u)); - assert (hash(0u) != hash(2u)); + check (hash(0u) == hash(1u)); + check (hash(2u) == hash(3u)); + check (hash(0u) != hash(2u)); let map.hashfn[uint] hasher = hash; let map.eqfn[uint] eqer = eq; @@ -240,13 +240,13 @@ fn hash(&uint u) -> uint { let uint i = 0u; while (i < num_to_insert) { - assert (hm.insert(i, i * i)); + check (hm.insert(i, i * i)); log "inserting " + _uint.to_str(i, 10u) + " -> " + _uint.to_str(i * i, 10u); i += 1u; } - assert (hm.size() == num_to_insert); + check (hm.size() == num_to_insert); log "-----"; log "removing evens"; @@ -260,7 +260,7 @@ fn hash(&uint u) -> uint { let util.option[uint] v = hm.remove(i); alt (v) { case (util.some[uint](u)) { - assert (u == (i * i)); + check (u == (i * i)); } case (util.none[uint]()) { fail; } } @@ -273,7 +273,7 @@ fn hash(&uint u) -> uint { i += 2u; } - assert (hm.size() == (num_to_insert / 2u)); + check (hm.size() == (num_to_insert / 2u)); log "-----"; @@ -281,7 +281,7 @@ fn hash(&uint u) -> uint { while (i < num_to_insert) { log "get(" + _uint.to_str(i, 10u) + ") = " + _uint.to_str(hm.get(i), 10u); - assert (hm.get(i) == i * i); + check (hm.get(i) == i * i); i += 2u; } @@ -296,7 +296,7 @@ fn hash(&uint u) -> uint { while (i < num_to_insert) { log "get(" + _uint.to_str(i, 10u) + ") = " + _uint.to_str(hm.get(i), 10u); - assert (hm.get(i) == i * i); + check (hm.get(i) == i * i); i += 2u; } @@ -304,13 +304,13 @@ fn hash(&uint u) -> uint { i = 0u; while (i < num_to_insert) { - assert (hm.insert(i, i * i)); + check (hm.insert(i, i * i)); log "inserting " + _uint.to_str(i, 10u) + " -> " + _uint.to_str(i * i, 10u); i += 2u; } - assert (hm.size() == num_to_insert); + check (hm.size() == num_to_insert); log "-----"; @@ -318,7 +318,7 @@ fn hash(&uint u) -> uint { while (i < num_to_insert) { log "get(" + _uint.to_str(i, 10u) + ") = " + _uint.to_str(hm.get(i), 10u); - assert (hm.get(i) == i * i); + check (hm.get(i) == i * i); i += 1u; } @@ -329,13 +329,13 @@ fn hash(&uint u) -> uint { log "-----"; - assert (hm.size() == num_to_insert); + check (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); - assert (hm.get(i) == i * i); + check (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 7e8efb5eba7..57e3cdc856b 100644 --- a/src/test/run-pass/lib-sha1.rs +++ b/src/test/run-pass/lib-sha1.rs @@ -69,13 +69,13 @@ fn a_million_letter_a() -> str { auto tests = fips_180_1_tests + wikipedia_tests; fn check_vec_eq(vec[u8] v0, vec[u8] v1) { - assert (_vec.len[u8](v0) == _vec.len[u8](v1)); + check (_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); - assert (a == b); + check (a == b); i += 1u; } } diff --git a/src/test/run-pass/lib-sort.rs b/src/test/run-pass/lib-sort.rs index a342b24eb56..e2c3465cdfd 100644 --- a/src/test/run-pass/lib-sort.rs +++ b/src/test/run-pass/lib-sort.rs @@ -10,7 +10,7 @@ fn lteq(&int a, &int b) -> bool { auto i = 0u; while (i < len) { log v3.(i); - assert (v3.(i) == v2.(i)); + check (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 9b8c56bb751..bd5cb036a69 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); - assert (_str.eq(s_cstr, s)); + check (_str.eq(s_cstr, s)); auto s_buf = _str.rustrt.str_from_buf(sb, 5u); - assert (_str.eq(s_buf, s)); + check (_str.eq(s_buf, s)); } diff --git a/src/test/run-pass/lib-str.rs b/src/test/run-pass/lib-str.rs index 767177111b2..835c08a20f6 100644 --- a/src/test/run-pass/lib-str.rs +++ b/src/test/run-pass/lib-str.rs @@ -2,22 +2,22 @@ import std._str; fn test_bytes_len() { - 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); + 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); } fn test_index_and_rindex() { - 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); + 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); } fn test_split() { @@ -30,7 +30,7 @@ fn t(&str s, char c, int i, &str k) { log z; } log "comparing: " + v.(i) + " vs. " + k; - assert (_str.eq(v.(i), k)); + check(_str.eq(v.(i), k)); } t("abc.hello.there", '.', 0, "abc"); t("abc.hello.there", '.', 1, "hello"); @@ -46,7 +46,7 @@ fn t(&str haystack, &str needle, int i) { let int j = _str.find(haystack,needle); log "searched for " + needle; log j; - assert (i == j); + check (i == j); } t("this is a simple", "is a", 5); t("this is a simple", "is z", -1); @@ -57,7 +57,7 @@ fn t(&str haystack, &str needle, int i) { fn test_substr() { fn t(&str a, &str b, int start) { - assert (_str.eq(_str.substr(a, start as uint, + check(_str.eq(_str.substr(a, start as uint, _str.byte_len(b)), b)); } @@ -68,7 +68,7 @@ fn t(&str a, &str b, int start) { fn test_concat() { fn t(&vec[str] v, &str s) { - assert (_str.eq(_str.concat(v), s)); + check(_str.eq(_str.concat(v), s)); } t(vec("you", "know", "I'm", "no", "good"), "youknowI'mnogood"); @@ -79,7 +79,7 @@ fn t(&vec[str] v, &str s) { fn test_connect() { fn t(&vec[str] v, &str sep, &str s) { - assert (_str.eq(_str.connect(v, sep), s)); + check(_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); - assert (_str.eq(expected, actual)); + check (_str.eq(expected, actual)); } diff --git a/src/test/run-pass/lib-uint.rs b/src/test/run-pass/lib-uint.rs index 64d39619f0b..356ca374092 100644 --- a/src/test/run-pass/lib-uint.rs +++ b/src/test/run-pass/lib-uint.rs @@ -4,44 +4,44 @@ import std._uint; fn main() { - 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); + 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); } diff --git a/src/test/run-pass/lib-vec-str-conversions.rs b/src/test/run-pass/lib-vec-str-conversions.rs index 3724d627b49..1d6b61a1900 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); - assert (n1 == n2); + check (n1 == n2); while (i < n1) { let u8 a = s1.(i); let u8 b = s2.(i); log a; log b; - assert (a == b); + check (a == b); i += 1u; } diff --git a/src/test/run-pass/lib-vec.rs b/src/test/run-pass/lib-vec.rs index 51341039c69..4d6166483bc 100644 --- a/src/test/run-pass/lib-vec.rs +++ b/src/test/run-pass/lib-vec.rs @@ -2,10 +2,10 @@ fn test_init_elt() { let vec[uint] v = std._vec.init_elt[uint](5u, 3u); - assert (std._vec.len[uint](v) == 3u); - assert (v.(0) == 5u); - assert (v.(1) == 5u); - assert (v.(2) == 5u); + check (std._vec.len[uint](v) == 3u); + check (v.(0) == 5u); + check (v.(1) == 5u); + check (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); - 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); + 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); } fn test_slice() { let vec[int] v = vec(1,2,3,4,5); auto v2 = std._vec.slice[int](v, 2u, 4u); - assert (std._vec.len[int](v2) == 2u); - assert (v2.(0) == 3); - assert (v2.(1) == 4); + check (std._vec.len[int](v2) == 2u); + check (v2.(0) == 3); + check (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) { - assert (v.(i) * v.(i) == s.(i)); + check (v.(i) * v.(i) == s.(i)); i += 1; } } @@ -51,7 +51,7 @@ fn test_map2() { auto i = 0; while (i < 5) { - assert (v0.(i) * v1.(i) == u.(i)); + check (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 c816f817225..2b517f78fe3 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; - assert (y == 6); + check (y == 6); auto s = "hello there"; let int i = 0; for (u8 c in s) { if (i == 0) { - assert (c == ('h' as u8)); + check (c == ('h' as u8)); } if (i == 1) { - assert (c == ('e' as u8)); + check (c == ('e' as u8)); } if (i == 2) { - assert (c == ('l' as u8)); + check (c == ('l' as u8)); } if (i == 3) { - assert (c == ('l' as u8)); + check (c == ('l' as u8)); } if (i == 4) { - assert (c == ('o' as u8)); + check (c == ('o' as u8)); } // ... i += 1; log i; log c; } - assert (i == 11); + check(i == 11); } diff --git a/src/test/run-pass/many.rs b/src/test/run-pass/many.rs index 5b67fdc64e0..f83ab4fb6a3 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; - assert (y == 500); + check (y == 500); } diff --git a/src/test/run-pass/mutable-alias-vec.rs b/src/test/run-pass/mutable-alias-vec.rs index 71d4dfe927d..887fb39125e 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; - assert (len == (3 as uint)); + check (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 e9b7a972dfe..19c2c074f9d 100644 --- a/src/test/run-pass/native-opaque-type.rs +++ b/src/test/run-pass/native-opaque-type.rs @@ -3,5 +3,5 @@ } fn main() { - assert (true); + check (true); } diff --git a/src/test/run-pass/obj-as.rs b/src/test/run-pass/obj-as.rs index 28868548bbc..6e0dac37b8f 100644 --- a/src/test/run-pass/obj-as.rs +++ b/src/test/run-pass/obj-as.rs @@ -15,10 +15,10 @@ fn main() { let big b = big(); - assert (b.one() == 1); - assert (b.two() == 2); - assert (b.three() == 3); + check (b.one() == 1); + check (b.two() == 2); + check (b.three() == 3); let small s = b as small; - assert (s.one() == 1); + check (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 f512e6ee868..167b15fbaee 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); } - assert ((*mbox) == 11); + check ((*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 62e0de87ef4..3d633e725eb 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"; - assert (i == 10); + check (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 208d0ded41a..f777b56c15a 100644 --- a/src/test/run-pass/obj-self-3.rs +++ b/src/test/run-pass/obj-self-3.rs @@ -19,11 +19,11 @@ fn m3(mutable int i) -> int { let int i = 0; i = a.m1(i); - assert (i == 1); + check (i == 1); i = a.m2(i); - assert (i == 2); + check (i == 2); i = a.m3(i); - assert (i == 4); + check (i == 4); } diff --git a/src/test/run-pass/obj-with-vec.rs b/src/test/run-pass/obj-with-vec.rs index b298f75f969..85143c7924d 100644 --- a/src/test/run-pass/obj-with-vec.rs +++ b/src/test/run-pass/obj-with-vec.rs @@ -7,5 +7,5 @@ fn get(int i) -> u8 { } auto b = buf(vec(1 as u8, 2 as u8, 3 as u8)); log b.get(1); - assert (b.get(1) == (2 as u8)); + check (b.get(1) == (2 as u8)); } diff --git a/src/test/run-pass/opeq.rs b/src/test/run-pass/opeq.rs index 0c905ab95e0..d99ebb0449a 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; - assert (x == 2); + check (x == 2); x += 3; log x; - assert (x == 5); + check (x == 5); x *= x; log x; - assert (x == 25); + check (x == 25); x /= 5; log x; - assert (x == 5); + check (x == 5); } diff --git a/src/test/run-pass/operator-associativity.rs b/src/test/run-pass/operator-associativity.rs index 403d7c2ed2c..2c028eba627 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() -> () { - assert ((3 * 5 / 2) == 7); + check ((3 * 5 / 2) == 7); } diff --git a/src/test/run-pass/readalias.rs b/src/test/run-pass/readalias.rs index 57dcb3b2d07..15fa142a77a 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) { - assert (p.z == 12); + check (p.z == 12); } fn main() { diff --git a/src/test/run-pass/rec-extend.rs b/src/test/run-pass/rec-extend.rs index ada02597572..db81278b35c 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); - assert (origin.x == 0); - assert (origin.y == 0); + check(origin.x == 0); + check(origin.y == 0); - assert (right.x == 10); - assert (right.y == 0); + check(right.x == 10); + check(right.y == 0); - assert (up.x == 0); - assert (up.y == 10); + check(up.x == 0); + check(up.y == 10); } diff --git a/src/test/run-pass/rec-tup.rs b/src/test/run-pass/rec-tup.rs index 30db0417062..e25439a974d 100644 --- a/src/test/run-pass/rec-tup.rs +++ b/src/test/run-pass/rec-tup.rs @@ -4,22 +4,22 @@ type rect = tup(point, point); fn f(rect r, int x1, int y1, int x2, int y2) { - assert (r._0.x == x1); - assert (r._0.y == y1); - assert (r._1.x == x2); - assert (r._1.y == y2); + check (r._0.x == x1); + check (r._0.y == y1); + check (r._1.x == x2); + check (r._1.y == y2); } fn main() { let rect r = tup( rec(x=10, y=20), rec(x=11, y=22) ); - assert (r._0.x == 10); - assert (r._0.y == 20); - assert (r._1.x == 11); - assert (r._1.y == 22); + check (r._0.x == 10); + check (r._0.y == 20); + check (r._1.x == 11); + check (r._1.y == 22); let rect r2 = r; let int x = r2._0.x; - assert (x == 10); + check (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 7d295f6fb61..0f6b7d79196 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) { - assert (r.x == x); - assert (r.y == y); - assert (r.w == w); - assert (r.h == h); + check (r.x == x); + check (r.y == y); + check (r.w == w); + check (r.h == h); } fn main() { let rect r = rec(x=10, y=20, w=100, h=200); - assert (r.x == 10); - assert (r.y == 20); - assert (r.w == 100); - assert (r.h == 200); + check (r.x == 10); + check (r.y == 20); + check (r.w == 100); + check (r.h == 200); let rect r2 = r; let int x = r2.x; - assert (x == 10); + check (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 cd808ad733d..e5c3da1b88f 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; - assert (x.val1 == i as u32); - assert (x.val2 == i as u32); - assert (x.val3 == i as u32); + check (x.val1 == i as u32); + check (x.val2 == i as u32); + check (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; - assert (x.val1 == i as u32); - assert (x.val2 == i as u32); - assert (x.val3 == i as u32); + check (x.val1 == i as u32); + check (x.val2 == i as u32); + check (x.val3 == i as u32); } } } diff --git a/src/test/run-pass/seq-compare.rs b/src/test/run-pass/seq-compare.rs index 942e9e90d94..e8bc4788c9a 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() { - assert ("hello" < "hellr"); - assert ("hello " > "hello"); - assert ("hello" != "there"); + check ("hello" < "hellr"); + check ("hello " > "hello"); + check ("hello" != "there"); - 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)); + 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)); } diff --git a/src/test/run-pass/stateful-obj.rs b/src/test/run-pass/stateful-obj.rs index b0f0cf3b969..c1d96cc3deb 100644 --- a/src/test/run-pass/stateful-obj.rs +++ b/src/test/run-pass/stateful-obj.rs @@ -14,10 +14,10 @@ fn get() -> int { fn main() { auto y = counter(0); - assert (y.hello() == 12345); + check (y.hello() == 12345); log y.get(); y.incr(); y.incr(); log y.get(); - assert (y.get() == 2); + check (y.get() == 2); } diff --git a/src/test/run-pass/str-append.rs b/src/test/run-pass/str-append.rs index abfbe938e22..da4ca07fc26 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; - assert (s.(9) == ('d' as u8)); + check(s.(9) == ('d' as u8)); } fn test2() { @@ -20,8 +20,8 @@ fn test2() { log a; log b; - assert (_str.eq(a, "abcABCabc")); - assert (_str.eq(b, "ABCabcABC")); + check (_str.eq(a, "abcABCabc")); + check (_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 a21fefbe23f..c906a23ef6b 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; - assert (s.(9) == ('d' as u8)); + check(s.(9) == ('d' as u8)); } diff --git a/src/test/run-pass/str-growth.rs b/src/test/run-pass/str-growth.rs index 55548da519c..06bc8b74621 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"; - assert (s.(0) == ('a' as u8)); - assert (s.(1) == ('b' as u8)); + check (s.(0) == ('a' as u8)); + check (s.(1) == ('b' as u8)); s += "c"; s += "d"; - assert (s.(0) == ('a' as u8)); - assert (s.(1) == ('b' as u8)); - assert (s.(2) == ('c' as u8)); - assert (s.(3) == ('d' as u8)); + check (s.(0) == ('a' as u8)); + check (s.(1) == ('b' as u8)); + check (s.(2) == ('c' as u8)); + check (s.(3) == ('d' as u8)); } diff --git a/src/test/run-pass/str-idx.rs b/src/test/run-pass/str-idx.rs index e2f5abb2927..9793799a97c 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; - assert (c == (0x6f as u8)); + check (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 15ddba8465f..3049faec6b6 100644 --- a/src/test/run-pass/structured-compare-recursive.rs +++ b/src/test/run-pass/structured-compare-recursive.rs @@ -4,6 +4,6 @@ } fn main() { - assert (bar <= bar); + check (bar <= bar); } diff --git a/src/test/run-pass/structured-compare.rs b/src/test/run-pass/structured-compare.rs index e677c3cb0bf..fed4b183730 100644 --- a/src/test/run-pass/structured-compare.rs +++ b/src/test/run-pass/structured-compare.rs @@ -6,15 +6,15 @@ fn main() { auto a = tup(1,2,3); auto b = tup(1,2,3); - 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); + 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); auto x = large; auto y = small; - assert (x != y); - assert (x == large); - assert (x != small); + check (x != y); + check (x == large); + check (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 5248e782bec..82b3e658a63 100644 --- a/src/test/run-pass/syntax-extension-fmt.rs +++ b/src/test/run-pass/syntax-extension-fmt.rs @@ -6,7 +6,7 @@ fn test(str actual, str expected) { log actual; log expected; - assert (_str.eq(actual, expected)); + check (_str.eq(actual, expected)); } fn main() { diff --git a/src/test/run-pass/tag.rs b/src/test/run-pass/tag.rs index 695832b129d..e3f89a7f262 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. - // assert (x != y); + // check (x != y); } fn main() { diff --git a/src/test/run-pass/tail-cps.rs b/src/test/run-pass/tail-cps.rs index fec48a748c6..795a105ad92 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 { - assert (res); + check(res); ret true; } diff --git a/src/test/run-pass/tail-direct.rs b/src/test/run-pass/tail-direct.rs index ac29bcad167..345a322eb17 100644 --- a/src/test/run-pass/tail-direct.rs +++ b/src/test/run-pass/tail-direct.rs @@ -1,8 +1,8 @@ // -*- rust -*- fn main() { - assert (even(42)); - assert (odd(45)); + check(even(42)); + check(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 54e37a34441..e1473548122 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; - assert (value == 30); + check(value == 30); } diff --git a/src/test/run-pass/task-comm-16.rs b/src/test/run-pass/task-comm-16.rs index 9438f50ef4d..16c4b93b8db 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; - assert (r1.val0 == 0); - assert (r1.val1 == 1u8); - assert (r1.val2 == '2'); + check (r1.val0 == 0); + check (r1.val1 == 1u8); + check (r1.val2 == '2'); } fn test_vec() { @@ -29,9 +29,9 @@ fn test_vec() { let vec[int] v1; v1 <- po; - assert (v1.(0) == 0); - assert (v1.(1) == 1); - assert (v1.(2) == 2); + check (v1.(0) == 0); + check (v1.(1) == 1); + check (v1.(2) == 2); } fn test_str() { @@ -44,10 +44,10 @@ fn test_str() { let str s1; s1 <- po; - 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); + 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); } fn test_tup() { @@ -62,9 +62,9 @@ fn test_tup() { let t t1; t1 <- po; - assert (t0._0 == 0); - assert (t0._1 == 1u8); - assert (t0._2 == '2'); + check (t0._0 == 0); + check (t0._1 == 1u8); + check (t0._2 == '2'); } fn test_tag() { @@ -84,11 +84,11 @@ fn test_tag() { let t t1; t1 <- po; - assert (t1 == tag1); + check (t1 == tag1); t1 <- po; - assert (t1 == tag2(10)); + check (t1 == tag2(10)); t1 <- po; - assert (t1 == tag3(10, 11u8, 'A')); + check (t1 == tag3(10, 11u8, 'A')); } fn test_chan() { @@ -109,7 +109,7 @@ fn test_chan() { let int i; i <- po0; - assert (i == 10); + check (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 59c46c4c9db..712557212c1 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: "; - // assert (sum == (((number_of_tasks * (number_of_tasks - 1)) / 2) * + // check (sum == (((number_of_tasks * (number_of_tasks - 1)) / 2) * // number_of_messages)); - assert (sum == 480); + check (sum == 480); } diff --git a/src/test/run-pass/task-comm-4.rs b/src/test/run-pass/task-comm-4.rs index 3c4f3ab6ae0..121a9e6e134 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); - assert (sum == 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8); + check (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 324ce0eddc7..d0f3994effb 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; } - assert (sum == ((number_of_messages * (number_of_messages - 1)) / 2)); + check (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 0f98ba5b00c..74b40a9098a 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; } - assert (sum == 1998000); - // assert (sum == 4 * ((number_of_messages * + check (sum == 1998000); + // check (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 f9fbab88be3..b5b95db9605 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; - assert (sum == (((number_of_messages * 4) * + check (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 d115ac4004f..a3876bdae5a 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; - assert (sum == (((number_of_messages * 4) * + check (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 c1c8a3bd6f9..a9ac1688cd2 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; - assert (sum == (number_of_messages * (number_of_messages - 1)) / 2); + check (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 de7de81af47..aae788a5128 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; - assert (n == ()); + check (n == ()); } diff --git a/src/test/run-pass/task-comm.rs b/src/test/run-pass/task-comm.rs index d256ced90b1..0a91b98abdf 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: "; - assert (sum == number_of_messages * + check (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 b7670776bd1..234066460ef 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) { - assert (p._0 == x); - assert (p._1 == y); + check (p._0 == x); + check (p._1 == y); } fn main() { let point p = tup(10, 20); - assert (p._0 == 10); - assert (p._1 == 20); + check (p._0 == 10); + check (p._1 == 20); let point p2 = p; let int x = p2._0; - assert (x == 10); + check (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 1903cb76049..67b8b57871f 100644 --- a/src/test/run-pass/type-sizes.rs +++ b/src/test/run-pass/type-sizes.rs @@ -5,17 +5,17 @@ use std; fn main() { - 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)); + 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)); // Alignment causes padding before the char and the u32. - 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)]()); + 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)]()); } diff --git a/src/test/run-pass/u32-decr.rs b/src/test/run-pass/u32-decr.rs index 7e7b5026f27..1ff511aa6bb 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); - assert (word == (199999u32)); + check(word == (199999u32)); } diff --git a/src/test/run-pass/u8-incr-decr.rs b/src/test/run-pass/u8-incr-decr.rs index 992c61d5865..f89325fc45f 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 - assert (x == y); + check(x == y); } diff --git a/src/test/run-pass/u8-incr.rs b/src/test/run-pass/u8-incr.rs index 7cc9488948e..602d83c66c5 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); - assert (x == y); + check(x == y); // x = 14u8; // x = x + 1u8; } diff --git a/src/test/run-pass/utf8.rs b/src/test/run-pass/utf8.rs index bf758a49315..68f5fa9f680 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 - 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 ((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 ((pi as int) == ('\u03a0' as int)); - assert (('\x0a' as int) == ('\n' as int)); + check ((pi as int) == ('\u03a0' as int)); + check (('\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 = 'Ö'; - assert ((oo as int) == 0xd6); + check ((oo as int) == 0xd6); fn check_str_eq(str a, str b) { let int i = 0; @@ -37,7 +37,7 @@ fn check_str_eq(str a, str b) { log ab; let u8 bb = b.(i); log bb; - assert (ab == bb); + check(ab == bb); i += 1; } } diff --git a/src/test/run-pass/utf8_chars.rs b/src/test/run-pass/utf8_chars.rs index 07eaca1927a..08671093edf 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); - 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.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.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))); + 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))); auto stack = "a×c€"; - assert (_str.pop_char(stack) == '€'); - assert (_str.pop_char(stack) == 'c'); + check(_str.pop_char(stack) == '€'); + check(_str.pop_char(stack) == 'c'); _str.push_char(stack, 'u'); - assert (_str.eq(stack, "a×u")); - assert (_str.shift_char(stack) == 'a'); - assert (_str.shift_char(stack) == '×'); + check(_str.eq(stack, "a×u")); + check(_str.shift_char(stack) == 'a'); + check(_str.shift_char(stack) == '×'); _str.unshift_char(stack, 'ß'); - assert (_str.eq(stack, "ßu")); + check(_str.eq(stack, "ßu")); } diff --git a/src/test/run-pass/vec-append.rs b/src/test/run-pass/vec-append.rs index 69db478841d..0f9f56dd954 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); - assert (v.(0) == 1); - assert (v.(7) == 8); - assert (v.(9) == 0); + check(v.(0) == 1); + check(v.(7) == 8); + check(v.(9) == 0); } fn slow_growth() { @@ -26,7 +26,7 @@ fn slow_growth() { v += vec(17); log v.(0); - assert (v.(0) == 17); + check (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); - assert (_vec.refcount[str](v) == 2u); + check (_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); - assert (_vec.refcount[str](v) == 1u); - assert (_str.refcount(s) == const_refcount); - assert (_str.refcount(mumble) == const_refcount); + check (_vec.refcount[str](v) == 1u); + check (_str.refcount(s) == const_refcount); + check (_str.refcount(mumble) == const_refcount); log v.(0); log _vec.len[str](v); - assert (_str.eq(v.(0), mumble)); - assert (_vec.len[str](v) == 1u); + check (_str.eq(v.(0), mumble)); + check (_vec.len[str](v) == 1u); } // ref down: a, mumble, s, v log _str.refcount(s); log _str.refcount(mumble); - assert (_str.refcount(s) == const_refcount); - assert (_str.refcount(mumble) == const_refcount); + check (_str.refcount(s) == const_refcount); + check (_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); - assert (_str.refcount(s) == const_refcount); + check (_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 09a95402e65..b6c52c3e08d 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); - assert (v.(0) == 1); - assert (v.(7) == 8); - assert (v.(9) == 0); + check(v.(0) == 1); + check(v.(7) == 8); + check(v.(9) == 0); } diff --git a/src/test/run-pass/vec-growth.rs b/src/test/run-pass/vec-growth.rs index b6976abd3a9..fe2070306d5 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); - assert (v.(0) == 1); - assert (v.(1) == 2); - assert (v.(2) == 3); - assert (v.(3) == 4); - assert (v.(4) == 5); + check (v.(0) == 1); + check (v.(1) == 2); + check (v.(2) == 3); + check (v.(3) == 4); + check (v.(4) == 5); } diff --git a/src/test/run-pass/vec-ref-count.rs b/src/test/run-pass/vec-ref-count.rs index 45f28f9bff2..788489362fd 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); - assert (_vec.refcount[int](v) == 1u || _vec.refcount[int](v) == 2u); - assert (_vec.refcount[int](v) == 1u || _vec.refcount[int](v) == 2u); + check (_vec.refcount[int](v) == 1u || _vec.refcount[int](v) == 2u); + check (_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 c3042d0c03f..55174142308 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); - assert (v2.(0) == 2); - assert (v2.(1) == 3); + check (v2.(0) == 2); + check (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 138d0ff2880..67a41eabcf6 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); - assert (v.(0) == 10); - assert (v.(1) == 20); + check (v.(0) == 10); + check (v.(1) == 20); let int x = 0; - assert (v.(x) == 10); - assert (v.(x + 1) == 20); + check (v.(x) == 10); + check (v.(x + 1) == 20); x = x + 1; - assert (v.(x) == 20); - assert (v.(x-1) == 10); + check (v.(x) == 20); + check (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 2adaf24bbc3..0e27f252ebb 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; } } - assert (i == 95); + check(i == 95); } diff --git a/src/test/run-pass/writealias.rs b/src/test/run-pass/writealias.rs index c0ac1803ac7..8bf8140f315 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); - assert (x.z == 13); + check (x.z == 13); } -- GitLab