Revert "Use different syntax for checks that matter to typestate"

This reverts commit aa25f22f197682de3b18fc4c8ba068d1feda220f. It broke stage2, not sure why yet.

182 files changed, 1239 insertions, 1256 deletions

diff --git a/src/boot/fe/item.ml b/src/boot/fe/item.ml
index 70e59be3..6b232e7e 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 a65acba1..b375b874 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 27cb399b..0b157983 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 13b5739e..2fd13194 100644
--- a/src/comp/front/ast.rs
+++ b/src/comp/front/ast.rs
@@ -283,10 +283,7 @@ tag expr_ {
     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 c8b31159..f48d47c9 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 dabdee1c..3659af1c 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 3e8ca85a..fdd41cf0 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_bottom_expr(parser p) -> @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 594515f2..f367bcc6 100644
--- a/src/comp/front/token.rs
+++ b/src/comp/front/token.rs
@@ -89,7 +89,6 @@ tag token {
 
     /* 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 070174ba..41ec1836 100644
--- a/src/comp/lib/llvm.rs
+++ b/src/comp/lib/llvm.rs
@@ -861,19 +861,19 @@ obj builder(BuilderRef B, @mutable bool terminated) {
 
     /* Terminators */
     fn RetVoid()  -> ValueRef {
-        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 @@ obj builder(BuilderRef B, @mutable bool terminated) {
     }
 
     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 @@ obj builder(BuilderRef B, @mutable bool terminated) {
               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 @@ obj builder(BuilderRef B, @mutable bool terminated) {
     }
 
     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 @@ obj builder(BuilderRef B, @mutable bool terminated) {
     }
 
     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 @@ obj builder(BuilderRef B, @mutable bool terminated) {
     }
 
     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 @@ obj builder(BuilderRef B, @mutable bool terminated) {
     /* 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 @@ obj builder(BuilderRef B, @mutable bool terminated) {
     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 @@ obj builder(BuilderRef B, @mutable bool terminated) {
     }
 
     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 @@ obj builder(BuilderRef B, @mutable bool terminated) {
     }
 
     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 @@ obj builder(BuilderRef B, @mutable bool terminated) {
     }
 
     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 @@ state obj type_names(std.map.hashmap[TypeRef, str] type_names,
                     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 e932fd9a..a0f3bc93 100644
--- a/src/comp/middle/fold.rs
+++ b/src/comp/middle/fold.rs
@@ -196,10 +196,7 @@ type ast_fold[ENV] =
          @expr e, ann a) -> @expr)                fold_expr_log,
 
      (fn(&ENV e, &span sp,
-         @expr e, ann a) -> @expr)                fold_expr_check,
-
-     (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 bec62628..806f38b5 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 c045413c..d75a6db0 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 2c639c4c..d4ba3073 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 GEP_tup_like(@block_ctxt cx, ty.t t,
         // and the latter would only be meaningful if we supported non-0
         // values for the 0th index (we don't).
 
-        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 decl_native_fn_and_pair(@crate_ctxt ccx,
 
         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 220adcb1..83befefc 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 @@ mod Unify {
                         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 @@ mod Unify {
                 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 094b7e1f..3354fe46 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 ast_ty_to_ty(ty.ctxt tcx, ty_getter getter, &@ast.ty ast_ty) -> ty.t {
         }
 
         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 @@ mod Collect {
             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 @@ mod Collect {
     fn fold_item_const(&@env e, &span sp, ast.ident i,
                        @ast.ty t, @ast.expr ex,
                        ast.def_id id, ast.ann a) -> @ast.item {
-        // 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 @@ mod Collect {
     fn fold_item_fn(&@env e, &span sp, ast.ident i,
                     &ast._fn f, vec[ast.ty_param] ty_params,
                     ast.def_id id, ast.ann a) -> @ast.item {
-        // 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 @@ mod Collect {
     fn fold_native_item_fn(&@env e, &span sp, ast.ident i, option.t[str] ln,
                            &ast.fn_decl d, vec[ast.ty_param] ty_params,
                            ast.def_id id, ast.ann a) -> @ast.native_item {
-        // 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 @@ mod Collect {
     fn fold_item_obj(&@env e, &span sp, ast.ident i,
                     &ast._obj ob, vec[ast.ty_param] ty_params,
                     ast.obj_def_ids odid, ast.ann a) -> @ast.item {
-        // 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 @@ mod Collect {
     fn fold_item_ty(&@env e, &span sp, ast.ident i,
                     @ast.ty t, vec[ast.ty_param] ty_params,
                     ast.def_id id, ast.ann a) -> @ast.item {
-        // 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 @@ mod Pushdown {
                             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 @@ mod Pushdown {
             case (ast.expr_ret(_,_)) { e_1 = e.node; }
             case (ast.expr_put(_,_)) { e_1 = e.node; }
             case (ast.expr_be(_,_))  { e_1 = e.node; }
-            case (ast.expr_check(_,_)) { 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_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr {
 
         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_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr {
 
         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_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr {
                                          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 e15c720a..d08ae82d 100644
--- a/src/comp/middle/typestate_check.rs
+++ b/src/comp/middle/typestate_check.rs
@@ -55,8 +55,7 @@ import front.ast.expr_put;
 import front.ast.expr_port;
 import front.ast.expr_chan;
 import front.ast.expr_be;
-import front.ast.expr_check;
-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 util.typestate_ann.clone;
 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 @@ type fn_info      = std.map.hashmap[def_id, var_info];
 type fn_info_map = std.map.hashmap[def_id, fn_info];
  
 fn bit_num(def_id v, fn_info m) -> uint {
-  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 find_pre_post_obj(&fn_info_map fm, _obj o) -> () {
 
 fn find_pre_post_state_obj(fn_info_map fm, _obj o) -> bool {
     fn do_a_method(fn_info_map fm, &@method m) -> bool {
-        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 find_pre_post_state_obj(fn_info_map fm, _obj o) -> bool {
 fn find_pre_post_item(fn_info_map fm, fn_info enclosing, &item i) -> () {
   alt (i.node) {
     case (ast.item_const(?id, ?t, ?e, ?di, ?a)) {
-        find_pre_post_expr(fm, enclosing, e);
+        find_pre_post_expr(fm, enclosing, *e);
     }
     case (ast.item_fn(?id, ?f, ?ps, ?di, ?a)) {
-      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 find_pre_post_exprs(&fn_info_map fm, &fn_info enclosing,
 
 fn find_pre_post_loop(&fn_info_map fm, &fn_info enclosing, &@decl d,
      &@expr index, &block body, &ann a) -> () {
-    find_pre_post_expr(fm, enclosing, index);
+    find_pre_post_expr(fm, enclosing, *index);
     find_pre_post_block(fm, enclosing, body);
     auto loop_precond = declare_var(enclosing, decl_lhs(d),
-           seq_preconds(enclosing, vec(expr_pp(index),
-                                       block_pp(body))));
+           seq_preconds(enclosing, vec(expr_pp(*index),
+                                                   block_pp(body))));
     auto loop_postcond = intersect_postconds
-        (vec(expr_postcond(index), block_postcond(body)));
+        (vec(expr_postcond(*index), block_postcond(body)));
     set_pre_and_post(a, rec(precondition=loop_precond,
                             postcondition=loop_postcond));
 }
 
 /* Fills in annotations as a side effect. Does not rebuild the expr */
-fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, @expr e) -> () {
+fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, &expr e) -> () {
     auto num_local_vars = num_locals(enclosing);
 
     fn do_rand_(fn_info_map fm, fn_info enclosing, &@expr e) -> () {
-        find_pre_post_expr(fm, enclosing, e);
+        find_pre_post_expr(fm, enclosing, *e);
     }
     fn pp_one(&@expr e) -> pre_and_post {
-        ret expr_pp(e);
+        ret expr_pp(*e);
     }
     
         log("find_pre_post_expr (num_locals =" +
              uistr(num_local_vars) + "):");
-        log_expr(*e);
+        log_expr(e);
     
     alt (e.node) {
         case (expr_call(?operator, ?operands, ?a)) {
@@ -864,18 +974,18 @@ fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, @expr e) -> () {
             set_pre_and_post(a, empty_pre_post(num_local_vars));
         }
         case(expr_log(_, ?arg, ?a)) {
-            find_pre_post_expr(fm, enclosing, arg);
-            set_pre_and_post(a, expr_pp(arg));
+            find_pre_post_expr(fm, enclosing, *arg);
+            set_pre_and_post(a, expr_pp(*arg));
         }
         case (expr_chan(?arg, ?a)) {
-            find_pre_post_expr(fm, enclosing, arg);
-            set_pre_and_post(a, expr_pp(arg));
+            find_pre_post_expr(fm, enclosing, *arg);
+            set_pre_and_post(a, expr_pp(*arg));
         }
         case(expr_put(?opt, ?a)) {
             alt (opt) {
                 case (some[@expr](?arg)) {
-                    find_pre_post_expr(fm, enclosing, arg);
-                    set_pre_and_post(a, expr_pp(arg));
+                    find_pre_post_expr(fm, enclosing, *arg);
+                    set_pre_and_post(a, expr_pp(*arg));
                 }
                 case (none[@expr]) {
                     set_pre_and_post(a, empty_pre_post(num_local_vars));
@@ -894,10 +1004,10 @@ fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, @expr e) -> () {
         case (expr_assign(?lhs, ?rhs, ?a)) {
             alt (lhs.node) {
                 case (expr_path(?p, some[def](def_local(?d_id)), ?a_lhs)) {
-                    find_pre_post_expr(fm, enclosing, rhs);
-                    set_pre_and_post(a, expr_pp(rhs));
+                    find_pre_post_expr(fm, enclosing, *rhs);
+                    set_pre_and_post(a, expr_pp(*rhs));
                     log("gen:");
-                    log_expr(*e);
+                    log_expr(e);
                     gen(enclosing, a, d_id);
                 }
                 case (_) {
@@ -910,10 +1020,10 @@ fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, @expr e) -> () {
         case (expr_recv(?lhs, ?rhs, ?a)) {
             alt (lhs.node) {
                 case (expr_path(?p, some[def](def_local(?d_id)), ?a_lhs)) {
-                    find_pre_post_expr(fm, enclosing, rhs);
-                    set_pre_and_post(a, expr_pp(rhs));
+                    find_pre_post_expr(fm, enclosing, *rhs);
+                    set_pre_and_post(a, expr_pp(*rhs));
                     log("gen:");
-                    log_expr(*e);
+                    log_expr(e);
                     gen(enclosing, a, d_id);
                 }
                 case (_) {
@@ -939,45 +1049,45 @@ fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, @expr e) -> () {
                           postcondition=false_postcond(num_local_vars)));
                 }
                 case (some[@expr](?ret_val)) {
-                    find_pre_post_expr(fm, enclosing, ret_val);
+                    find_pre_post_expr(fm, enclosing, *ret_val);
                     let pre_and_post pp =
-                        rec(precondition=expr_precond(ret_val),
+                        rec(precondition=expr_precond(*ret_val),
                             postcondition=false_postcond(num_local_vars));
                     set_pre_and_post(a, pp);
                 }
             }
         }
         case (expr_be(?e, ?a)) {
-            find_pre_post_expr(fm, enclosing, e);
-            set_pre_and_post(a, rec(precondition=expr_prestate(e),
+            find_pre_post_expr(fm, enclosing, *e);
+            set_pre_and_post(a, rec(precondition=expr_prestate(*e),
                           postcondition=false_postcond(num_local_vars)));
         }
         case (expr_if(?antec, ?conseq, ?maybe_alt, ?a)) {
-            find_pre_post_expr(fm, enclosing, antec);
+            find_pre_post_expr(fm, enclosing, *antec);
             find_pre_post_block(fm, enclosing, conseq);
             alt (maybe_alt) {
                 case (none[@expr]) {
                     auto precond_res = seq_preconds(enclosing,
-                                                    vec(expr_pp(antec),
+                                                    vec(expr_pp(*antec),
                                                         block_pp(conseq)));
                     set_pre_and_post(a, rec(precondition=precond_res,
                                             postcondition=
-                                            expr_poststate(antec)));
+                                            expr_poststate(*antec)));
                 }
                 case (some[@expr](?altern)) {
-                    find_pre_post_expr(fm, enclosing, altern);
+                    find_pre_post_expr(fm, enclosing, *altern);
                     auto precond_true_case =
                         seq_preconds(enclosing,
-                                     vec(expr_pp(antec), block_pp(conseq)));
+                                     vec(expr_pp(*antec), block_pp(conseq)));
                     auto postcond_true_case = union_postconds
                         (num_local_vars,
-                         vec(expr_postcond(antec), block_postcond(conseq)));
+                         vec(expr_postcond(*antec), block_postcond(conseq)));
                     auto precond_false_case = seq_preconds
                         (enclosing,
-                         vec(expr_pp(antec), expr_pp(altern)));
+                         vec(expr_pp(*antec), expr_pp(*altern)));
                     auto postcond_false_case = union_postconds
                         (num_local_vars,
-                         vec(expr_postcond(antec), expr_postcond(altern)));
+                         vec(expr_postcond(*antec), expr_postcond(*altern)));
                     auto precond_res = union_postconds
                         (num_local_vars,
                          vec(precond_true_case, precond_false_case));
@@ -997,31 +1107,31 @@ fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, @expr e) -> () {
             find_pre_post_exprs(fm, enclosing, vec(l, r), a);
         }
         case (expr_unary(_,?operand,?a)) {
-            find_pre_post_expr(fm, enclosing, operand);
-            set_pre_and_post(a, expr_pp(operand));
+            find_pre_post_expr(fm, enclosing, *operand);
+            set_pre_and_post(a, expr_pp(*operand));
         }
         case (expr_cast(?operand, _, ?a)) {
-            find_pre_post_expr(fm, enclosing, operand);
-            set_pre_and_post(a, expr_pp(operand));
+            find_pre_post_expr(fm, enclosing, *operand);
+            set_pre_and_post(a, expr_pp(*operand));
         }
         case (expr_while(?test, ?body, ?a)) {
-            find_pre_post_expr(fm, enclosing, test);
+            find_pre_post_expr(fm, enclosing, *test);
             find_pre_post_block(fm, enclosing, body);
             set_pre_and_post(a,
               rec(precondition=
                   seq_preconds(enclosing,
-                                 vec(expr_pp(test), 
+                                 vec(expr_pp(*test), 
                                      block_pp(body))),
                   postcondition=
-                  intersect_postconds(vec(expr_postcond(test),
+                  intersect_postconds(vec(expr_postcond(*test),
                                           block_postcond(body)))));
         }
         case (expr_do_while(?body, ?test, ?a)) {
             find_pre_post_block(fm, enclosing, body);
-            find_pre_post_expr(fm, enclosing, test);
+            find_pre_post_expr(fm, enclosing, *test);
    
             auto loop_postcond = union_postconds(num_local_vars,
-                            vec(block_postcond(body), expr_postcond(test)));
+                            vec(block_postcond(body), expr_postcond(*test)));
             /* conservative approximination: if the body
                could break or cont, the test may never be executed */
             if (has_nonlocal_exits(body)) {
@@ -1031,7 +1141,7 @@ fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, @expr e) -> () {
             set_pre_and_post(a, 
                              rec(precondition=seq_preconds(enclosing,
                                              vec(block_pp(body),
-                                                 expr_pp(test))),
+                                                 expr_pp(*test))),
                    postcondition=loop_postcond));
         }
         case (expr_for(?d, ?index, ?body, ?a)) {
@@ -1044,7 +1154,7 @@ fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, @expr e) -> () {
             find_pre_post_exprs(fm, enclosing, vec(e, sub), a);
         }
         case (expr_alt(?e, ?alts, ?a)) {
-            find_pre_post_expr(fm, enclosing, e);
+            find_pre_post_expr(fm, enclosing, *e);
             fn do_an_alt(fn_info_map fm, fn_info enc, &arm an_alt)
                 -> pre_and_post {
                 find_pre_post_block(fm, enc, an_alt.block);
@@ -1060,7 +1170,7 @@ fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, @expr e) -> () {
                 intersect(pp.postcondition, next.postcondition);
                 ret pp;
             }
-            auto antec_pp = pp_clone(expr_pp(e)); 
+            auto antec_pp = pp_clone(expr_pp(*e)); 
             auto e_pp  = rec(precondition=empty_prestate(num_local_vars),
                              postcondition=false_postcond(num_local_vars));
             auto g = bind combine_pp(antec_pp, enclosing, _, _);
@@ -1071,8 +1181,8 @@ fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, @expr e) -> () {
             set_pre_and_post(a, alts_overall_pp);
         }
         case (expr_field(?operator, _, ?a)) {
-            find_pre_post_expr(fm, enclosing, operator);
-            set_pre_and_post(a, expr_pp(operator));
+            find_pre_post_expr(fm, enclosing, *operator);
+            set_pre_and_post(a, expr_pp(*operator));
         }
         case (expr_fail(?a)) {
             set_pre_and_post(a,
@@ -1081,14 +1191,10 @@ fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, @expr e) -> () {
                rec(precondition=empty_prestate(num_local_vars),
                    postcondition=false_postcond(num_local_vars)));
         }
-        case (expr_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 find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, @expr e) -> () {
             set_pre_and_post(a, empty_pre_post(num_local_vars));
         }
         case (expr_ext(_, _, _, ?expanded, ?a)) {
-            find_pre_post_expr(fm, enclosing, expanded);
-            set_pre_and_post(a, expr_pp(expanded));
+            find_pre_post_expr(fm, enclosing, *expanded);
+            set_pre_and_post(a, expr_pp(*expanded));
         }
     }
 }
 
 fn gen(&fn_info enclosing, &ann a, def_id id) -> bool {
-  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 find_pre_post_block(&fn_info_map fm, &fn_info enclosing, block b)
     
     _vec.map[@stmt, ()](do_one, b.node.stmts);
     fn do_inner_(fn_info_map fm, fn_info i, &@expr e) -> () {
-        find_pre_post_expr(fm, i, e);
+        find_pre_post_expr(fm, i, *e);
     }
     auto do_inner = bind do_inner_(fm, enclosing, _);
     option.map[@expr, ()](do_inner, b.node.expr);
@@ -1225,7 +1331,7 @@ fn find_pre_post_block(&fn_info_map fm, &fn_info enclosing, block b)
     auto f = get_pp_stmt;
     pps += _vec.map[@stmt, pre_and_post](f, b.node.stmts);
     fn get_pp_expr(&@expr e) -> pre_and_post {
-        ret expr_pp(e);
+        ret expr_pp(*e);
     }
     auto g = get_pp_expr;
     plus_option[pre_and_post](pps,
@@ -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 fixed_point_states(fn_info_map fm, fn_info f_info,
   }
 }
 
-fn check_states_expr(fn_info enclosing, @expr e) -> () {
+fn check_states_expr(fn_info enclosing, &expr e) -> () {
   let precond prec    = expr_precond(e);
   let prestate pres   = expr_prestate(e);
 
   if (!implies(pres, prec)) {
       log_err("check_states_expr: Unsatisfied precondition constraint for ");
-      log_expr_err(*e);
+      log_expr_err(e);
       log_err("Precondition: ");
       log_bitv_err(enclosing, prec);
       log_err("Prestate: ");
@@ -1988,7 +2093,7 @@ fn check_states_against_conditions(fn_info enclosing, &ast._fn f) -> () {
  
   _vec.map[@stmt, ()](do_one, f.body.node.stmts);
   fn do_inner_(fn_info i, &@expr e) -> () {
-    check_states_expr(i, e);
+    check_states_expr(i, *e);
   }
   auto do_inner = bind do_inner_(enclosing, _);
   option.map[@expr, ()](do_inner, f.body.node.expr);
@@ -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 8a5d40dc..dbc188b1 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 7ef91ce8..e49ed34e 100644
--- a/src/comp/pretty/pprust.rs
+++ b/src/comp/pretty/pprust.rs
@@ -661,18 +661,12 @@ fn print_expr(ps s, &@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 9e815b46..b7fbc3cc 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 368fe217..0d925d7d 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 1824d142..dfd2204d 100644
--- a/src/lib/_int.rs
+++ b/src/lib/_int.rs
@@ -27,7 +27,7 @@ iter range(int lo, int hi) -> int {
 
 fn to_str(int n, uint radix) -> str
 {
-    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 ed2027e1..44f14fb6 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 2d373cdd..97108c90 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 4761a867..126bf363 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 f52b016b..feb4296a 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 ee706ae7..776f82e9 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 9bad0f33..f73ad4fc 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 e185ca3e..774ce113 100644
--- a/src/lib/fs.rs
+++ b/src/lib/fs.rs
@@ -10,7 +10,7 @@ type path = str;
 
 fn dirname(path p) -> path {
     auto sep = path_sep();
-    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 7d59da30..4c1bf2df 100644
--- a/src/lib/io.rs
+++ b/src/lib/io.rs
@@ -72,7 +72,7 @@ state obj FILE_buf_reader(os.libc.FILE f, bool must_close) {
         ret os.libc.feof(f) != 0;
     }
     fn seek(int offset, seek_style whence) {
-        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 @@ state obj new_reader(buf_reader rdr) {
         if (c0 == -1) {ret -1 as char;} // FIXME will this stay valid?
         auto b0 = c0 as u8;
         auto w = _str.utf8_char_width(b0);
-        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 @@ state obj FILE_writer(os.libc.FILE f, bool must_close) {
     }
 
     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 d2a8ff97..d5230e9a 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 a52b02c5..b0980bc5 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 f4cf12d3..03115fc7 100644
--- a/src/lib/posix_fs.rs
+++ b/src/lib/posix_fs.rs
@@ -5,7 +5,7 @@ native "rust" mod rustrt {
 fn list_dir(str path) -> vec[str] {
   // TODO ensure this is always closed
   auto dir = os.libc.opendir(_str.buf(path));
-  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 690489db..3866be1e 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 mk_sha1() -> sha1 {
     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_sha1() -> sha1 {
      */
     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 mk_sha1() -> sha1 {
 
         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 1c6521e3..a2940d8d 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 c688a404..e8c9cf71 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 60e82200..7def7c11 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 68b1e263..4388cb3a 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 810feb39..961da730 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 f1998da5..a230d1be 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 b92ffd74..4ee2c12b 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 bad74a2a..91190260 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 bc0afcb5..68013dfe 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 857eaa8e..7587b005 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 55230e9e..bac6a055 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 70892682..33a740c8 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 0e2818a3..748ff6b7 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 5df5456b..956a7eb4 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 f6f36918..c3fc2e7c 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 ae994d1c..2d164e07 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 b5215f9a..8780b22a 100644
--- a/src/test/run-pass/bind-obj-ctor.rs
+++ b/src/test/run-pass/bind-obj-ctor.rs
@@ -11,7 +11,7 @@ fn main() {
   auto ctor1 = bind simple(_, 2);
   auto obj1 = ctor0(2);
   auto obj2 = ctor1(1);
-  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 7cafc501..be6e1b24 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 e73f2b7c..fbd6e78d 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 99324489..36b58a91 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 337efc6f..ba70bdb1 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 8f23035d..619790d7 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 b1d50533..d0ad615b 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 c105e801..ffcd9ec5 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 5a63d9ac..48c3b091 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 ecc7ac12..e04ad629 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 a3ddae6c..123f2eb2 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 99c319c2..e97c409d 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 ef93eee6..2bca6248 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 36487aa8..5630d2e2 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 32d4dae1..5131c42b 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 00835d41..cfa0fbe9 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 edb25e16..d9e5b869 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 e18611fa..2e7846f3 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 a1367e81..8ff67f0f 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 469b8e7c..7928ffed 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 0cd0177a..66681059 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 762303d5..31406969 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 52a01078..4c10a7d9 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 206c44af..e8ab6209 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 a37d1cb0..eb0357d9 100644
--- a/src/test/run-pass/expr-block-fn.rs
+++ b/src/test/run-pass/expr-block-fn.rs
@@ -6,7 +6,7 @@ fn test_fn() {
     ret 10;
   }
   let t res = { ten };
-  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 82d54c17..57487fd6 100644
--- a/src/test/run-pass/expr-block-generic-box1.rs
+++ b/src/test/run-pass/expr-block-generic-box1.rs
@@ -5,7 +5,7 @@ type compare[T] = fn(@T t1, @T t2) -> bool;
 
 fn test_generic[T](@T expected, &compare[T] eq) {
   let @T actual = { expected };
-  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 c1c8260c..3b1e4479 100644
--- a/src/test/run-pass/expr-block-generic-box2.rs
+++ b/src/test/run-pass/expr-block-generic-box2.rs
@@ -5,7 +5,7 @@ type compare[T] = fn(&T t1, &T t2) -> bool;
 
 fn test_generic[T](&T expected, &compare[T] eq) {
   let T actual = { expected };
-  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 d6061a6c..ded3b620 100644
--- a/src/test/run-pass/expr-block-generic.rs
+++ b/src/test/run-pass/expr-block-generic.rs
@@ -7,7 +7,7 @@ type compare[T] = fn(&T t1, &T t2) -> bool;
 
 fn test_generic[T](&T expected, &compare[T] eq) {
   let T actual = { expected };
-  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 1c03a6b0..ecc6f04a 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 d242d744..a629c9c9 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 d1d4c05d..32aea8bb 100644
--- a/src/test/run-pass/expr-if-generic-box1.rs
+++ b/src/test/run-pass/expr-if-generic-box1.rs
@@ -5,7 +5,7 @@ type compare[T] = fn(@T t1, @T t2) -> bool;
 
 fn test_generic[T](@T expected, @T not_expected, &compare[T] eq) {
   let @T actual = if (true) { expected } else { not_expected };
-  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 a126b1c4..d414d6d1 100644
--- a/src/test/run-pass/expr-if-generic-box2.rs
+++ b/src/test/run-pass/expr-if-generic-box2.rs
@@ -5,7 +5,7 @@ type compare[T] = fn(&T t1, &T t2) -> bool;
 
 fn test_generic[T](&T expected, &T not_expected, &compare[T] eq) {
   let T actual = if (true) { expected } else { not_expected };
-  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 b86a7553..0a0db2dd 100644
--- a/src/test/run-pass/expr-if-generic.rs
+++ b/src/test/run-pass/expr-if-generic.rs
@@ -7,7 +7,7 @@ type compare[T] = fn(&T t1, &T t2) -> bool;
 
 fn test_generic[T](&T expected, &T not_expected, &compare[T] eq) {
   let T actual = if (true) { expected } else { not_expected };
-  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 6d42c224..df20a3ba 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 67f56746..7c99f2ea 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 661effda..f09ee823 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 577ee6a2..91cf099c 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 e6136d2c..9cc3a8ca 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 37f21c8f..10b0fb77 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 33a376d5..d25405d8 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 9ba304c1..a655f591 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 02dbef5d..43d8b5c3 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 8f23d61d..efc6e8ca 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 5fa3837e..59446b4a 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 1d506dca..10c2cf40 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 ce3889fb..377e0fb2 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 f3a65edd..3975867a 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 c65e061a..ef1275e3 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 76d5e3ab..856f3aff 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 507d1c5f..54c3f956 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 07eae9c1..0ec7020c 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 9c795ec2..4398670f 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 4f93fef5..238ef2d1 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 cc549f6b..2a50ccd2 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 9879fa79..ced9140f 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 f29cfa00..9b19eec7 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 46421e0a..090a0504 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 2f697124..98401ecc 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 d2edfd2e..c387ef19 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 9b5b5297..6638cebf 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 eb5e76fb..3f00acb1 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 92ff04ea..fb387d31 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 ee80786c..fe7d147c 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 78bf94c3..ade7c51c 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 7034efba..fe0ffe6b 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 a91adaa1..6face271 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 8f2d9390..162e8b13 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 62807251..10f5e727 100644
--- a/src/test/run-pass/lib-box.rs
+++ b/src/test/run-pass/lib-box.rs
@@ -4,9 +4,9 @@ import std.Box;
 fn main() {
     auto x = @3;
     auto y = @3;
-    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 405ab72b..9fd177ea 100644
--- a/src/test/run-pass/lib-deque.rs
+++ b/src/test/run-pass/lib-deque.rs
@@ -5,125 +5,125 @@ import std.deque;
 
 fn test_simple() {
   let deque.t[int] d = deque.create[int]();
-  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 e4e68351..2e85abf6 100644
--- a/src/test/run-pass/lib-int.rs
+++ b/src/test/run-pass/lib-int.rs
@@ -4,22 +4,22 @@ import std._int;
 import std._str.eq;
 
 fn test_to_str() {
-  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 bcc2163c..7102c91e 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 abd2041e..4c8afa7d 100644
--- a/src/test/run-pass/lib-map.rs
+++ b/src/test/run-pass/lib-map.rs
@@ -28,19 +28,19 @@ fn test_simple() {
   let map.hashmap[uint, uint] hm_uu = map.mk_hashmap[uint, uint](hasher_uint,
                                                                  eqer_uint);
 
-  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 test_simple() {
 
   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 test_simple() {
   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 test_simple() {
   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 test_growth() {
 
   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 test_growth() {
   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 test_growth() {
   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 test_growth() {
 
   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 test_growth() {
       + "\") = \""
       + 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 test_growth() {
   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 test_removal() {
     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 test_removal() {
 
   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 test_removal() {
     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 test_removal() {
     i += 2u;
   }
 
-  assert (hm.size() == (num_to_insert / 2u));
+  check (hm.size() == (num_to_insert / 2u));
 
   log "-----";
 
@@ -281,7 +281,7 @@ fn test_removal() {
   while (i < num_to_insert) {
     log "get(" + _uint.to_str(i, 10u) + ") = "
       + _uint.to_str(hm.get(i), 10u);
-    assert (hm.get(i) == i * i);
+    check (hm.get(i) == i * i);
     i += 2u;
   }
 
@@ -296,7 +296,7 @@ fn test_removal() {
   while (i < num_to_insert) {
     log "get(" + _uint.to_str(i, 10u) + ") = "
       + _uint.to_str(hm.get(i), 10u);
-    assert (hm.get(i) == i * i);
+    check (hm.get(i) == i * i);
     i += 2u;
   }
 
@@ -304,13 +304,13 @@ fn test_removal() {
 
   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 test_removal() {
   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 test_removal() {
 
   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 7e8efb5e..57e3cdc8 100644
--- a/src/test/run-pass/lib-sha1.rs
+++ b/src/test/run-pass/lib-sha1.rs
@@ -69,13 +69,13 @@ fn main() {
     auto tests = fips_180_1_tests + wikipedia_tests;
 
     fn check_vec_eq(vec[u8] v0, vec[u8] v1) {
-        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 a342b24e..e2c3465c 100644
--- a/src/test/run-pass/lib-sort.rs
+++ b/src/test/run-pass/lib-sort.rs
@@ -10,7 +10,7 @@ fn check_sort(vec[int] v1, vec[int] v2) {
   auto i = 0u;
   while (i < len) {
     log v3.(i);
-    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 9b8c56bb..bd5cb036 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 76717711..835c08a2 100644
--- a/src/test/run-pass/lib-str.rs
+++ b/src/test/run-pass/lib-str.rs
@@ -2,22 +2,22 @@ use std;
 import std._str;
 
 fn test_bytes_len() {
-  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 test_split() {
       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 test_find() {
     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 test_find() {
 
 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 test_substr() {
 
 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 test_concat() {
 
 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 64d39619..356ca374 100644
--- a/src/test/run-pass/lib-uint.rs
+++ b/src/test/run-pass/lib-uint.rs
@@ -4,44 +4,44 @@ use std;
 import std._uint;
 
 fn main() {
-  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 3724d627..1d6b61a1 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 51341039..4d616648 100644
--- a/src/test/run-pass/lib-vec.rs
+++ b/src/test/run-pass/lib-vec.rs
@@ -2,10 +2,10 @@ use std;
 
 fn test_init_elt() {
   let vec[uint] v = std._vec.init_elt[uint](5u, 3u);
-  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 c816f817..2b517f78 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 5b67fdc6..f83ab4fb 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 71d4dfe9..887fb391 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 e9b7a972..19c2c074 100644
--- a/src/test/run-pass/native-opaque-type.rs
+++ b/src/test/run-pass/native-opaque-type.rs
@@ -3,5 +3,5 @@ native mod libc {
 }
 
 fn main() {
-  assert (true);
+  check (true);
 }
diff --git a/src/test/run-pass/obj-as.rs b/src/test/run-pass/obj-as.rs
index 28868548..6e0dac37 100644
--- a/src/test/run-pass/obj-as.rs
+++ b/src/test/run-pass/obj-as.rs
@@ -15,10 +15,10 @@ type small = obj {
 fn main() {
 
   let big b = big();
-  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 f512e6ee..167b15fb 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 62e0de87..3d633e72 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 208d0ded..f777b56c 100644
--- a/src/test/run-pass/obj-self-3.rs
+++ b/src/test/run-pass/obj-self-3.rs
@@ -19,11 +19,11 @@ fn main() {
   let int i = 0;
 
   i = a.m1(i);
-  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 b298f75f..85143c79 100644
--- a/src/test/run-pass/obj-with-vec.rs
+++ b/src/test/run-pass/obj-with-vec.rs
@@ -7,5 +7,5 @@ fn main() {
   }
   auto b = buf(vec(1 as u8, 2 as u8, 3 as u8));
   log b.get(1);
-  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 0c905ab9..d99ebb04 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 403d7c2e..2c028eba 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 57dcb3b2..15fa142a 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 ada02597..db81278b 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 30db0417..e25439a9 100644
--- a/src/test/run-pass/rec-tup.rs
+++ b/src/test/run-pass/rec-tup.rs
@@ -4,22 +4,22 @@ type point = rec(int x, int y);
 type rect = tup(point, point);
 
 fn f(rect r, int x1, int y1, int x2, int y2) {
-  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 7d295f6f..0f6b7d79 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 cd808ad7..e5c3da1b 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 942e9e90..e8bc4788 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 b0f0cf3b..c1d96cc3 100644
--- a/src/test/run-pass/stateful-obj.rs
+++ b/src/test/run-pass/stateful-obj.rs
@@ -14,10 +14,10 @@ obj counter(mutable int x) {
 
 fn main() {
   auto y = counter(0);
-  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 abfbe938..da4ca07f 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 a21fefbe..c906a23e 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 55548da5..06bc8b74 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 e2f5abb2..9793799a 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 15ddba84..3049faec 100644
--- a/src/test/run-pass/structured-compare-recursive.rs
+++ b/src/test/run-pass/structured-compare-recursive.rs
@@ -4,6 +4,6 @@ tag taggy {
 }
 
 fn main() {
-    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 e677c3cb..fed4b183 100644
--- a/src/test/run-pass/structured-compare.rs
+++ b/src/test/run-pass/structured-compare.rs
@@ -6,15 +6,15 @@ tag foo {
 fn main() {
   auto a = tup(1,2,3);
   auto b = tup(1,2,3);
-  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 5248e782..82b3e658 100644
--- a/src/test/run-pass/syntax-extension-fmt.rs
+++ b/src/test/run-pass/syntax-extension-fmt.rs
@@ -6,7 +6,7 @@ import std._str;
 fn test(str actual, str expected) {
   log actual;
   log expected;
-  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 695832b1..e3f89a7f 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 fec48a74..795a105a 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 ac29bcad..345a322e 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 54e37a34..e1473548 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 9438f50e..16c4b93b 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 59c46c4c..71255721 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 3c4f3ab6..121a9e6e 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 324ce0ed..d0f3994e 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 0f98ba5b..74b40a90 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 f9fbab88..b5b95db9 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 d115ac40..a3876bda 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 c1c8a3bd..a9ac1688 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 de7de81a..aae788a5 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 d256ced9..0a91b98a 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 b7670776..23406646 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 1903cb76..67b8b578 100644
--- a/src/test/run-pass/type-sizes.rs
+++ b/src/test/run-pass/type-sizes.rs
@@ -5,17 +5,17 @@ import size_of = std.sys.rustrt.size_of;
 use std;
 
 fn main() {
-  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 7e7b5026..1ff511aa 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 992c61d5..f89325fc 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 7cc94889..602d83c6 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 bf758a49..68f5fa9f 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 main() {
       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 07eaca19..08671093 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 69db4788..0f9f56dd 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 09a95402..b6c52c3e 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 b6976abd..fe207030 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 45f28f9b..78848936 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 c3042d0c..55174142 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 138d0ff2..67a41eab 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 2adaf24b..0e27f252 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 c0ac1803..8bf8140f 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);
 }