Un-revert "Use different syntax for checks that matter to typestate", fixing the problem.

This reverts commit d08b443fffb1181d8d45ae5d061412f202dd4118.

16 files changed, 510 insertions, 505 deletions

diff --git a/src/comp/front/ast.rs b/src/comp/front/ast.rs
index 2fd13194e50..13b5739e8df 100644
--- a/src/comp/front/ast.rs
+++ b/src/comp/front/ast.rs
@@ -283,7 +283,10 @@ tag expr_ {
     expr_put(option.t[@expr], ann);
     expr_be(@expr, ann);
     expr_log(int, @expr, ann);
-    expr_check_expr(@expr, ann);
+/* just an assert, no significance to typestate */
+    expr_assert(@expr, ann);
+/* preds that typestate is aware of */
+    expr_check(@expr, ann);
     expr_port(ann);
     expr_chan(@expr, ann);
 }
diff --git a/src/comp/front/creader.rs b/src/comp/front/creader.rs
index f48d47c90be..c8b31159444 100644
--- a/src/comp/front/creader.rs
+++ b/src/comp/front/creader.rs
@@ -93,7 +93,7 @@ fn parse_ty(@pstate st, str_def sd) -> ty.t {
         case ('c') { ret ty.mk_char(st.tcx); }
         case ('s') { ret ty.mk_str(st.tcx); }
         case ('t') {
-            check(next(st) as char == '[');
+            assert (next(st) as char == '[');
             auto def = parse_def(st, sd);
             let vec[ty.t] params = vec();
             while (peek(st) as char != ']') {
@@ -108,7 +108,7 @@ fn parse_ty(@pstate st, str_def sd) -> ty.t {
         case ('P') { ret ty.mk_port(st.tcx, parse_ty(st, sd)); }
         case ('C') { ret ty.mk_chan(st.tcx, parse_ty(st, sd)); }
         case ('T') {
-            check(next(st) as char == '[');
+            assert (next(st) as char == '[');
             let vec[ty.mt] params = vec();
             while (peek(st) as char != ']') {
                 params += vec(parse_mt(st, sd));
@@ -117,7 +117,7 @@ fn parse_ty(@pstate st, str_def sd) -> ty.t {
             ret ty.mk_tup(st.tcx, params);
         }
         case ('R') {
-            check(next(st) as char == '[');
+            assert (next(st) as char == '[');
             let vec[ty.field] fields = vec();
             while (peek(st) as char != ']') {
                 auto name = "";
@@ -149,7 +149,7 @@ fn parse_ty(@pstate st, str_def sd) -> ty.t {
             ret ty.mk_native_fn(st.tcx,abi,func._0,func._1);
         }
         case ('O') {
-            check(next(st) as char == '[');
+            assert (next(st) as char == '[');
             let vec[ty.method] methods = vec();
             while (peek(st) as char != ']') {
                 auto proto;
@@ -175,9 +175,9 @@ fn parse_ty(@pstate st, str_def sd) -> ty.t {
         case ('Y') { ret ty.mk_type(st.tcx); }
         case ('#') {
             auto pos = parse_hex(st);
-            check (next(st) as char == ':');
+            assert (next(st) as char == ':');
             auto len = parse_hex(st);
-            check (next(st) as char == '#');
+            assert (next(st) as char == '#');
             alt (st.tcx.rcache.find(tup(st.crate,pos,len))) {
                 case (some[ty.t](?tt)) { ret tt; }
                 case (none[ty.t]) {
@@ -245,7 +245,7 @@ fn parse_hex(@pstate st) -> uint {
 }
 
 fn parse_ty_fn(@pstate st, str_def sd) -> tup(vec[ty.arg], ty.t) {
-    check(next(st) as char == '[');
+    assert (next(st) as char == '[');
     let vec[ty.arg] inputs = vec();
     while (peek(st) as char != ']') {
         auto mode = ast.val;
diff --git a/src/comp/front/lexer.rs b/src/comp/front/lexer.rs
index 3659af1c655..dabdee1c738 100644
--- a/src/comp/front/lexer.rs
+++ b/src/comp/front/lexer.rs
@@ -127,6 +127,7 @@ fn keyword_table() -> std.map.hashmap[str, token.token] {
 
     keywords.insert("type", token.TYPE);
     keywords.insert("check", token.CHECK);
+    keywords.insert("assert", token.ASSERT);
     keywords.insert("claim", token.CLAIM);
     keywords.insert("prove", token.PROVE);
 
@@ -528,7 +529,7 @@ fn scan_numeric_escape(reader rdr) -> char {
 
     auto n_hex_digits = 0;
 
-    check (rdr.curr() == '\\');
+    assert (rdr.curr() == '\\');
 
     alt (rdr.next()) {
         case ('x') { n_hex_digits = 2; }
diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs
index fdd41cf0ff7..3e8ca85a830 100644
--- a/src/comp/front/parser.rs
+++ b/src/comp/front/parser.rs
@@ -621,7 +621,7 @@ fn parse_path(parser p, greed g) -> ast.path {
                 if (p.peek() == token.DOT) {
                     if (g == GREEDY) {
                         p.bump();
-                        check (is_ident(p.peek()));
+                        assert (is_ident(p.peek()));
                     } else {
                         more = false;
                     }
@@ -816,20 +816,23 @@ fn parse_bottom_expr(parser p) -> @ast.expr {
             ex = ast.expr_log(0, e, ast.ann_none);
         }
 
-        case (token.CHECK) {
+        case (token.ASSERT) {
             p.bump();
-            alt (p.peek()) {
-                case (token.LPAREN) {
-                    auto e = parse_expr(p);
-                    auto hi = e.span.hi;
-                    ex = ast.expr_check_expr(e, ast.ann_none);
-                }
-                case (_) {
-                    p.get_session().unimpl("constraint-check stmt");
-                }
-            }
+            auto e = parse_expr(p);
+            auto hi = e.span.hi;
+            ex = ast.expr_assert(e, ast.ann_none);
         }
 
+        case (token.CHECK) {
+            p.bump();
+            /* Should be a predicate (pure boolean function) applied to 
+             arguments that are all either slot variables or literals.
+            but the typechecker enforces that. */
+            auto e = parse_expr(p);
+            auto hi = e.span.hi;
+            ex = ast.expr_check(e, ast.ann_none);
+        } 
+
         case (token.RET) {
             p.bump();
             alt (p.peek()) {
@@ -937,7 +940,7 @@ fn expand_syntax_ext(parser p, ast.span sp,
                      &ast.path path, vec[@ast.expr] args,
                      option.t[str] body) -> ast.expr_ {
 
-    check (_vec.len[ast.ident](path.node.idents) > 0u);
+    assert (_vec.len[ast.ident](path.node.idents) > 0u);
     auto extname = path.node.idents.(0);
     if (_str.eq(extname, "fmt")) {
         auto expanded = extfmt.expand_syntax_ext(args, body);
@@ -1673,7 +1676,8 @@ fn stmt_ends_with_semi(@ast.stmt stmt) -> bool {
                 case (ast.expr_put(_,_))        { ret true; }
                 case (ast.expr_be(_,_))         { ret true; }
                 case (ast.expr_log(_,_,_))        { ret true; }
-                case (ast.expr_check_expr(_,_)) { ret true; }
+                case (ast.expr_check(_,_)) { ret true; }
+                case (ast.expr_assert(_,_)) { ret true; }
             }
         }
         // We should not be calling this on a cdir.
@@ -2157,24 +2161,24 @@ fn parse_item(parser p) -> @ast.item {
 
     alt (p.peek()) {
         case (token.CONST) {
-            check (lyr == ast.layer_value);
+            assert (lyr == ast.layer_value);
             ret parse_item_const(p);
         }
 
         case (token.FN) {
-            check (lyr == ast.layer_value);
+            assert (lyr == ast.layer_value);
             ret parse_item_fn_or_iter(p);
         }
         case (token.ITER) {
-            check (lyr == ast.layer_value);
+            assert (lyr == ast.layer_value);
             ret parse_item_fn_or_iter(p);
         }
         case (token.MOD) {
-            check (lyr == ast.layer_value);
+            assert (lyr == ast.layer_value);
             ret parse_item_mod(p);
         }
         case (token.NATIVE) {
-            check (lyr == ast.layer_value);
+            assert (lyr == ast.layer_value);
             ret parse_item_native_mod(p);
         }
         case (token.TYPE) {
diff --git a/src/comp/front/token.rs b/src/comp/front/token.rs
index f367bcc6835..594515f2214 100644
--- a/src/comp/front/token.rs
+++ b/src/comp/front/token.rs
@@ -89,6 +89,7 @@ tag token {
 
     /* Type and type-state keywords */
     TYPE;
+    ASSERT;
     CHECK;
     CLAIM;
     PROVE;
@@ -258,6 +259,7 @@ fn to_str(token t) -> str {
 
         /* Type and type-state keywords */
         case (TYPE) { ret "type"; }
+        case (ASSERT) { ret "assert"; }
         case (CHECK) { ret "check"; }
         case (CLAIM) { ret "claim"; }
         case (PROVE) { ret "prove"; }
diff --git a/src/comp/lib/llvm.rs b/src/comp/lib/llvm.rs
index 41ec1836d18..070174bad3c 100644
--- a/src/comp/lib/llvm.rs
+++ b/src/comp/lib/llvm.rs
@@ -861,19 +861,19 @@ obj builder(BuilderRef B, @mutable bool terminated) {
 
     /* Terminators */
     fn RetVoid()  -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         *terminated = true;
         ret llvm.LLVMBuildRetVoid(B);
     }
 
     fn Ret(ValueRef V) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         *terminated = true;
         ret llvm.LLVMBuildRet(B, V);
     }
 
     fn AggregateRet(vec[ValueRef] RetVals) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         *terminated = true;
         ret llvm.LLVMBuildAggregateRet(B,
                                        _vec.buf[ValueRef](RetVals),
@@ -881,26 +881,26 @@ obj builder(BuilderRef B, @mutable bool terminated) {
     }
 
     fn Br(BasicBlockRef Dest) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         *terminated = true;
         ret llvm.LLVMBuildBr(B, Dest);
     }
 
     fn CondBr(ValueRef If, BasicBlockRef Then,
               BasicBlockRef Else) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         *terminated = true;
         ret llvm.LLVMBuildCondBr(B, If, Then, Else);
     }
 
     fn Switch(ValueRef V, BasicBlockRef Else, uint NumCases) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         *terminated = true;
         ret llvm.LLVMBuildSwitch(B, V, Else, NumCases);
     }
 
     fn IndirectBr(ValueRef Addr, uint NumDests) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         *terminated = true;
         ret llvm.LLVMBuildIndirectBr(B, Addr, NumDests);
     }
@@ -909,7 +909,7 @@ obj builder(BuilderRef B, @mutable bool terminated) {
               vec[ValueRef] Args,
               BasicBlockRef Then,
               BasicBlockRef Catch) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         *terminated = true;
         ret llvm.LLVMBuildInvoke(B, Fn,
                                  _vec.buf[ValueRef](Args),
@@ -919,209 +919,209 @@ obj builder(BuilderRef B, @mutable bool terminated) {
     }
 
     fn Unwind() -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         *terminated = true;
         ret llvm.LLVMBuildUnwind(B);
     }
 
     fn Unreachable() -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         *terminated = true;
         ret llvm.LLVMBuildUnreachable(B);
     }
 
     /* Arithmetic */
     fn Add(ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildAdd(B, LHS, RHS, _str.buf(""));
     }
 
     fn NSWAdd(ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildNSWAdd(B, LHS, RHS, _str.buf(""));
     }
 
     fn NUWAdd(ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildNUWAdd(B, LHS, RHS, _str.buf(""));
     }
 
     fn FAdd(ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildFAdd(B, LHS, RHS, _str.buf(""));
     }
 
     fn Sub(ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildSub(B, LHS, RHS, _str.buf(""));
     }
 
     fn NSWSub(ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildNSWSub(B, LHS, RHS, _str.buf(""));
     }
 
     fn NUWSub(ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildNUWSub(B, LHS, RHS, _str.buf(""));
     }
 
     fn FSub(ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildFSub(B, LHS, RHS, _str.buf(""));
     }
 
     fn Mul(ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildMul(B, LHS, RHS, _str.buf(""));
     }
 
     fn NSWMul(ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildNSWMul(B, LHS, RHS, _str.buf(""));
     }
 
     fn NUWMul(ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildNUWMul(B, LHS, RHS, _str.buf(""));
     }
 
     fn FMul(ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildFMul(B, LHS, RHS, _str.buf(""));
     }
 
     fn UDiv(ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildUDiv(B, LHS, RHS, _str.buf(""));
     }
 
     fn SDiv(ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildSDiv(B, LHS, RHS, _str.buf(""));
     }
 
     fn ExactSDiv(ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildExactSDiv(B, LHS, RHS, _str.buf(""));
     }
 
     fn FDiv(ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildFDiv(B, LHS, RHS, _str.buf(""));
     }
 
     fn URem(ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildURem(B, LHS, RHS, _str.buf(""));
     }
 
     fn SRem(ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildSRem(B, LHS, RHS, _str.buf(""));
     }
 
     fn FRem(ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildFRem(B, LHS, RHS, _str.buf(""));
     }
 
     fn Shl(ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildShl(B, LHS, RHS, _str.buf(""));
     }
 
     fn LShr(ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildLShr(B, LHS, RHS, _str.buf(""));
     }
 
     fn AShr(ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildAShr(B, LHS, RHS, _str.buf(""));
     }
 
     fn And(ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildAnd(B, LHS, RHS, _str.buf(""));
     }
 
     fn Or(ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildOr(B, LHS, RHS, _str.buf(""));
     }
 
     fn Xor(ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildXor(B, LHS, RHS, _str.buf(""));
     }
 
     fn BinOp(Opcode Op, ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildBinOp(B, Op, LHS, RHS, _str.buf(""));
     }
 
     fn Neg(ValueRef V) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildNeg(B, V, _str.buf(""));
     }
 
     fn NSWNeg(ValueRef V) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildNSWNeg(B, V, _str.buf(""));
     }
 
     fn NUWNeg(ValueRef V) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildNUWNeg(B, V, _str.buf(""));
     }
     fn FNeg(ValueRef V) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildFNeg(B, V, _str.buf(""));
     }
     fn Not(ValueRef V) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildNot(B, V, _str.buf(""));
     }
 
     /* Memory */
     fn Malloc(TypeRef Ty) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildMalloc(B, Ty, _str.buf(""));
     }
 
     fn ArrayMalloc(TypeRef Ty, ValueRef Val) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildArrayMalloc(B, Ty, Val, _str.buf(""));
     }
 
     fn Alloca(TypeRef Ty) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildAlloca(B, Ty, _str.buf(""));
     }
 
     fn ArrayAlloca(TypeRef Ty, ValueRef Val) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildArrayAlloca(B, Ty, Val, _str.buf(""));
     }
 
     fn Free(ValueRef PointerVal) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildFree(B, PointerVal);
     }
 
     fn Load(ValueRef PointerVal) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildLoad(B, PointerVal, _str.buf(""));
     }
 
     fn Store(ValueRef Val, ValueRef Ptr) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildStore(B, Val, Ptr);
     }
 
     fn GEP(ValueRef Pointer, vec[ValueRef] Indices) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildGEP(B, Pointer,
                               _vec.buf[ValueRef](Indices),
                               _vec.len[ValueRef](Indices),
@@ -1129,7 +1129,7 @@ obj builder(BuilderRef B, @mutable bool terminated) {
     }
 
     fn InBoundsGEP(ValueRef Pointer, vec[ValueRef] Indices) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildInBoundsGEP(B, Pointer,
                                       _vec.buf[ValueRef](Indices),
                                       _vec.len[ValueRef](Indices),
@@ -1137,125 +1137,125 @@ obj builder(BuilderRef B, @mutable bool terminated) {
     }
 
     fn StructGEP(ValueRef Pointer, uint Idx) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildStructGEP(B, Pointer, Idx, _str.buf(""));
     }
 
     fn GlobalString(sbuf Str) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildGlobalString(B, Str, _str.buf(""));
     }
 
     fn GlobalStringPtr(sbuf Str) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildGlobalStringPtr(B, Str, _str.buf(""));
     }
 
     /* Casts */
     fn Trunc(ValueRef Val, TypeRef DestTy) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildTrunc(B, Val, DestTy, _str.buf(""));
     }
 
     fn ZExt(ValueRef Val, TypeRef DestTy) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildZExt(B, Val, DestTy, _str.buf(""));
     }
 
     fn SExt(ValueRef Val, TypeRef DestTy) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildSExt(B, Val, DestTy, _str.buf(""));
     }
 
     fn FPToUI(ValueRef Val, TypeRef DestTy) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildFPToUI(B, Val, DestTy, _str.buf(""));
     }
 
     fn FPToSI(ValueRef Val, TypeRef DestTy) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildFPToSI(B, Val, DestTy, _str.buf(""));
     }
 
     fn UIToFP(ValueRef Val, TypeRef DestTy) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildUIToFP(B, Val, DestTy, _str.buf(""));
     }
 
     fn SIToFP(ValueRef Val, TypeRef DestTy) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildSIToFP(B, Val, DestTy, _str.buf(""));
     }
 
     fn FPTrunc(ValueRef Val, TypeRef DestTy) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildFPTrunc(B, Val, DestTy, _str.buf(""));
     }
 
     fn FPExt(ValueRef Val, TypeRef DestTy) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildFPExt(B, Val, DestTy, _str.buf(""));
     }
 
     fn PtrToInt(ValueRef Val, TypeRef DestTy) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildPtrToInt(B, Val, DestTy, _str.buf(""));
     }
 
     fn IntToPtr(ValueRef Val, TypeRef DestTy) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildIntToPtr(B, Val, DestTy, _str.buf(""));
     }
 
     fn BitCast(ValueRef Val, TypeRef DestTy) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildBitCast(B, Val, DestTy, _str.buf(""));
     }
 
     fn ZExtOrBitCast(ValueRef Val, TypeRef DestTy) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildZExtOrBitCast(B, Val, DestTy, _str.buf(""));
     }
 
     fn SExtOrBitCast(ValueRef Val, TypeRef DestTy) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildSExtOrBitCast(B, Val, DestTy, _str.buf(""));
     }
 
     fn TruncOrBitCast(ValueRef Val, TypeRef DestTy) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildTruncOrBitCast(B, Val, DestTy, _str.buf(""));
     }
 
     fn Cast(Opcode Op, ValueRef Val, TypeRef DestTy, sbuf Name) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildCast(B, Op, Val, DestTy, _str.buf(""));
     }
 
     fn PointerCast(ValueRef Val, TypeRef DestTy) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildPointerCast(B, Val, DestTy, _str.buf(""));
     }
 
     fn IntCast(ValueRef Val, TypeRef DestTy) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildIntCast(B, Val, DestTy, _str.buf(""));
     }
 
     fn FPCast(ValueRef Val, TypeRef DestTy) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildFPCast(B, Val, DestTy, _str.buf(""));
     }
 
 
     /* Comparisons */
     fn ICmp(uint Op, ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildICmp(B, Op, LHS, RHS, _str.buf(""));
     }
 
     fn FCmp(uint Op, ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildFCmp(B, Op, LHS, RHS, _str.buf(""));
     }
 
@@ -1263,9 +1263,9 @@ obj builder(BuilderRef B, @mutable bool terminated) {
     /* Miscellaneous instructions */
     fn Phi(TypeRef Ty, vec[ValueRef] vals,
            vec[BasicBlockRef] bbs) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         auto phi = llvm.LLVMBuildPhi(B, Ty, _str.buf(""));
-        check (_vec.len[ValueRef](vals) == _vec.len[BasicBlockRef](bbs));
+        assert (_vec.len[ValueRef](vals) == _vec.len[BasicBlockRef](bbs));
         llvm.LLVMAddIncoming(phi,
                              _vec.buf[ValueRef](vals),
                              _vec.buf[BasicBlockRef](bbs),
@@ -1276,7 +1276,7 @@ obj builder(BuilderRef B, @mutable bool terminated) {
     fn AddIncomingToPhi(ValueRef phi,
                         vec[ValueRef] vals,
                         vec[BasicBlockRef] bbs) {
-        check (_vec.len[ValueRef](vals) == _vec.len[BasicBlockRef](bbs));
+        assert (_vec.len[ValueRef](vals) == _vec.len[BasicBlockRef](bbs));
         llvm.LLVMAddIncoming(phi,
                              _vec.buf[ValueRef](vals),
                              _vec.buf[BasicBlockRef](bbs),
@@ -1284,7 +1284,7 @@ obj builder(BuilderRef B, @mutable bool terminated) {
     }
 
     fn Call(ValueRef Fn, vec[ValueRef] Args) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildCall(B, Fn,
                                _vec.buf[ValueRef](Args),
                                _vec.len[ValueRef](Args),
@@ -1292,7 +1292,7 @@ obj builder(BuilderRef B, @mutable bool terminated) {
     }
 
     fn FastCall(ValueRef Fn, vec[ValueRef] Args) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         auto v = llvm.LLVMBuildCall(B, Fn,
                                     _vec.buf[ValueRef](Args),
                                     _vec.len[ValueRef](Args),
@@ -1302,65 +1302,65 @@ obj builder(BuilderRef B, @mutable bool terminated) {
     }
 
     fn Select(ValueRef If, ValueRef Then, ValueRef Else) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildSelect(B, If, Then, Else, _str.buf(""));
     }
 
     fn VAArg(ValueRef List, TypeRef Ty) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildVAArg(B, List, Ty, _str.buf(""));
     }
 
     fn ExtractElement(ValueRef VecVal, ValueRef Index) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildExtractElement(B, VecVal, Index, _str.buf(""));
     }
 
     fn InsertElement(ValueRef VecVal, ValueRef EltVal,
                      ValueRef Index) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildInsertElement(B, VecVal, EltVal, Index,
                                         _str.buf(""));
     }
 
     fn ShuffleVector(ValueRef V1, ValueRef V2, ValueRef Mask) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildShuffleVector(B, V1, V2, Mask, _str.buf(""));
     }
 
     fn ExtractValue(ValueRef AggVal, uint Index) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildExtractValue(B, AggVal, Index, _str.buf(""));
     }
 
     fn InsertValue(ValueRef AggVal, ValueRef EltVal,
                    uint Index) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildInsertValue(B, AggVal, EltVal, Index, _str.buf(""));
     }
 
     fn IsNull(ValueRef Val) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildIsNull(B, Val, _str.buf(""));
     }
 
     fn IsNotNull(ValueRef Val) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildIsNotNull(B, Val, _str.buf(""));
     }
 
     fn PtrDiff(ValueRef LHS, ValueRef RHS) -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         ret llvm.LLVMBuildPtrDiff(B, LHS, RHS, _str.buf(""));
     }
 
     fn Trap() -> ValueRef {
-        check (!*terminated);
+        assert (!*terminated);
         let BasicBlockRef BB = llvm.LLVMGetInsertBlock(B);
         let ValueRef FN = llvm.LLVMGetBasicBlockParent(BB);
         let ModuleRef M = llvm.LLVMGetGlobalParent(FN);
         let ValueRef T = llvm.LLVMGetNamedFunction(M, _str.buf("llvm.trap"));
-        check (T as int != 0);
+        assert (T as int != 0);
         let vec[ValueRef] Args = vec();
         ret llvm.LLVMBuildCall(B, T,
                                _vec.buf[ValueRef](Args),
@@ -1391,8 +1391,8 @@ state obj type_names(std.map.hashmap[TypeRef, str] type_names,
                     std.map.hashmap[str, TypeRef] named_types) {
 
     fn associate(str s, TypeRef t) {
-        check (!named_types.contains_key(s));
-        check (!type_names.contains_key(t));
+        assert (!named_types.contains_key(s));
+        assert (!type_names.contains_key(t));
         type_names.insert(t, s);
         named_types.insert(s, t);
     }
diff --git a/src/comp/middle/fold.rs b/src/comp/middle/fold.rs
index a0f3bc93f95..e932fd9af49 100644
--- a/src/comp/middle/fold.rs
+++ b/src/comp/middle/fold.rs
@@ -196,7 +196,10 @@ type ast_fold[ENV] =
          @expr e, ann a) -> @expr)                fold_expr_log,
 
      (fn(&ENV e, &span sp,
-         @expr e, ann a) -> @expr)                fold_expr_check_expr,
+         @expr e, ann a) -> @expr)                fold_expr_check,
+
+     (fn(&ENV e, &span sp,
+         @expr e, ann a) -> @expr)                fold_expr_assert,
 
      (fn(&ENV e, &span sp,
          ann a) -> @expr)                         fold_expr_port,
@@ -796,10 +799,16 @@ fn fold_expr[ENV](&ENV env, ast_fold[ENV] fld, &@expr e) -> @expr {
             ret fld.fold_expr_log(env_, e.span, l, ee, t2);
         }
 
-        case (ast.expr_check_expr(?x, ?t)) {
+        case (ast.expr_check(?x, ?t)) {
             auto ee = fold_expr(env_, fld, x);
             auto t2 = fld.fold_ann(env_, t);
-            ret fld.fold_expr_check_expr(env_, e.span, ee, t2);
+            ret fld.fold_expr_check(env_, e.span, ee, t2);
+        }
+
+        case (ast.expr_assert(?x, ?t)) {
+            auto ee = fold_expr(env_, fld, x);
+            auto t2 = fld.fold_ann(env_, t);
+            ret fld.fold_expr_assert(env_, e.span, ee, t2);
         }
 
         case (ast.expr_port(?t)) {
@@ -1380,9 +1389,14 @@ fn identity_fold_expr_log[ENV](&ENV e, &span sp, int lvl, @expr x,
     ret @respan(sp, ast.expr_log(lvl, x, a));
 }
 
-fn identity_fold_expr_check_expr[ENV](&ENV e, &span sp, @expr x, ann a)
+fn identity_fold_expr_check[ENV](&ENV e, &span sp, @expr x, ann a)
+    -> @expr {
+    ret @respan(sp, ast.expr_check(x, a));
+}
+
+fn identity_fold_expr_assert[ENV](&ENV e, &span sp, @expr x, ann a)
     -> @expr {
-    ret @respan(sp, ast.expr_check_expr(x, a));
+    ret @respan(sp, ast.expr_check(x, a));
 }
 
 fn identity_fold_expr_port[ENV](&ENV e, &span sp, ann a) -> @expr {
@@ -1676,8 +1690,11 @@ fn new_identity_fold[ENV]() -> ast_fold[ENV] {
          fold_expr_put    = bind identity_fold_expr_put[ENV](_,_,_,_),
          fold_expr_be     = bind identity_fold_expr_be[ENV](_,_,_,_),
          fold_expr_log    = bind identity_fold_expr_log[ENV](_,_,_,_,_),
-         fold_expr_check_expr
-         = bind identity_fold_expr_check_expr[ENV](_,_,_,_),
+         fold_expr_check
+         = bind identity_fold_expr_check[ENV](_,_,_,_),
+         fold_expr_assert
+         = bind identity_fold_expr_assert[ENV](_,_,_,_),
+              
          fold_expr_port   = bind identity_fold_expr_port[ENV](_,_,_),
          fold_expr_chan   = bind identity_fold_expr_chan[ENV](_,_,_,_),
 
diff --git a/src/comp/middle/metadata.rs b/src/comp/middle/metadata.rs
index 806f38b5252..bec6262847e 100644
--- a/src/comp/middle/metadata.rs
+++ b/src/comp/middle/metadata.rs
@@ -63,7 +63,7 @@ mod Encode {
     );
 
     fn ty_str(@ctxt cx, ty.t t) -> str {
-        check (! cx.use_abbrevs);
+        assert (! cx.use_abbrevs);
         auto sw = io.string_writer();
         enc_ty(sw.get_writer(), cx, t);
         ret sw.get_str();
diff --git a/src/comp/middle/resolve.rs b/src/comp/middle/resolve.rs
index d75a6db09d9..c045413c2db 100644
--- a/src/comp/middle/resolve.rs
+++ b/src/comp/middle/resolve.rs
@@ -662,7 +662,7 @@ fn fold_pat_tag(&env e, &span sp, ast.path p, vec[@ast.pat] args,
 fn fold_expr_path(&env e, &span sp, &ast.path p, &option.t[def] d,
                   ann a) -> @ast.expr {
     auto n_idents = _vec.len[ast.ident](p.node.idents);
-    check (n_idents != 0u);
+    assert (n_idents != 0u);
 
     auto index = new_def_hash[def_wrap]();
     auto d = find_final_def(e, index, sp, p.node.idents, ns_value,
diff --git a/src/comp/middle/trans.rs b/src/comp/middle/trans.rs
index d4ba3073bbb..2c639c4cd6e 100644
--- a/src/comp/middle/trans.rs
+++ b/src/comp/middle/trans.rs
@@ -586,7 +586,7 @@ fn type_of_explicit_args(@crate_ctxt cx, vec[ty.arg] inputs) -> vec[TypeRef] {
     let vec[TypeRef] atys = vec();
     for (ty.arg arg in inputs) {
         if (ty.type_has_dynamic_size(cx.tcx, arg.ty)) {
-            check (arg.mode == ast.alias);
+            assert (arg.mode == ast.alias);
             atys += vec(T_typaram_ptr(cx.tn));
         } else {
             let TypeRef t;
@@ -632,7 +632,7 @@ fn type_of_fn_full(@crate_ctxt cx,
     // Arg 2: Env (closure-bindings / self-obj)
     alt (obj_self) {
         case (some[TypeRef](?t)) {
-            check (t as int != 0);
+            assert (t as int != 0);
             atys += vec(t);
         }
         case (_) {
@@ -800,7 +800,7 @@ fn type_of_inner(@crate_ctxt cx, ty.t t) -> TypeRef {
         case (ty.ty_type) { llty = T_ptr(T_tydesc(cx.tn)); }
     }
 
-    check (llty as int != 0);
+    assert (llty as int != 0);
     llvm.LLVMAddTypeName(cx.llmod,
                          _str.buf(ty.ty_to_short_str(cx.tcx,
                                                      cx.type_abbrevs, t)),
@@ -1355,7 +1355,7 @@ fn dynamic_align_of(@block_ctxt cx, ty.t t) -> result {
 fn GEP_tup_like(@block_ctxt cx, ty.t t,
                 ValueRef base, vec[int] ixs) -> result {
 
-    check (ty.type_is_tup_like(cx.fcx.lcx.ccx.tcx, t));
+    assert (ty.type_is_tup_like(cx.fcx.lcx.ccx.tcx, t));
 
     // It might be a static-known type. Handle this.
 
@@ -1393,17 +1393,17 @@ fn GEP_tup_like(@block_ctxt cx, ty.t t,
         // and the latter would only be meaningful if we supported non-0
         // values for the 0th index (we don't).
 
-        check (len > 1u);
+        assert (len > 1u);
 
         if (n == 0u) {
             // Since we're starting from a value that's a pointer to a
             // *single* structure, the first index (in GEP-ese) should just be
             // 0, to yield the pointee.
-            check (ixs.(n) == 0);
+            assert (ixs.(n) == 0);
             ret split_type(ccx, t, ixs, n+1u);
         }
 
-        check (n < len);
+        assert (n < len);
 
         let int ix = ixs.(n);
         let vec[ty.t] prefix = vec();
@@ -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);
 
-        check (n_params == _vec.len[uint](tys._0));
-        check (n_params == _vec.len[ValueRef](tys._1));
+        assert (n_params == _vec.len[uint](tys._0));
+        assert (n_params == _vec.len[ValueRef](tys._1));
 
         auto root = get_static_tydesc(cx, t, tys._0).tydesc;
 
@@ -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);
     }
 
-    check (cx.items.contains_key(id));
+    assert (cx.items.contains_key(id));
     alt (cx.items.get(id).node) {
         case (ast.item_tag(_, ?variants, _, _, _)) {
             let vec[variant_info] result = vec();
@@ -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.
-            check (_vec.len[result](ins) >= 1u);
+            assert (_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.
-        check (cx.fcx.lcx.ccx.fn_pairs.contains_key(fn_id));
+        assert (cx.fcx.lcx.ccx.fn_pairs.contains_key(fn_id));
         lv = lval_val(cx, cx.fcx.lcx.ccx.fn_pairs.get(fn_id));
     } else {
         // External reference.
@@ -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.
-            check (lcx.ccx.sess.get_targ_crate_num() != vid._0);
+            assert (lcx.ccx.sess.get_targ_crate_num() != vid._0);
             auto sym = creader.get_symbol(lcx.ccx.sess, vid);
             auto gvar = llvm.LLVMAddGlobal(lcx.ccx.llmod, T_int(),
                                            _str.buf(sym));
@@ -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]) {
-                            check (cx.fcx.llupvars.contains_key(did));
+                            assert (cx.fcx.llupvars.contains_key(did));
                             ret lval_mem(cx, cx.fcx.llupvars.get(did));
                         }
                         case (some[ValueRef](?llval)) {
@@ -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]) {
-                            check (cx.fcx.llupvars.contains_key(did));
+                            assert (cx.fcx.llupvars.contains_key(did));
                             ret lval_mem(cx, cx.fcx.llupvars.get(did));
                         }
                         case (some[ValueRef](?llval)) {
@@ -4080,11 +4080,11 @@ fn trans_path(@block_ctxt cx, &ast.path p, &option.t[ast.def] dopt,
                     }
                 }
                 case (ast.def_binding(?did)) {
-                    check (cx.fcx.lllocals.contains_key(did));
+                    assert (cx.fcx.lllocals.contains_key(did));
                     ret lval_mem(cx, cx.fcx.lllocals.get(did));
                 }
                 case (ast.def_obj_field(?did)) {
-                    check (cx.fcx.llobjfields.contains_key(did));
+                    assert (cx.fcx.llobjfields.contains_key(did));
                     ret lval_mem(cx, cx.fcx.llobjfields.get(did));
                 }
                 case (ast.def_fn(?did)) {
@@ -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
-                    check (cx.fcx.lcx.ccx.consts.contains_key(did));
+                    assert (cx.fcx.lcx.ccx.consts.contains_key(did));
                     ret lval_mem(cx, cx.fcx.lcx.ccx.consts.get(did));
                 }
                 case (ast.def_native_fn(?did)) {
@@ -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)) {
-            check (unop == ast.deref);
+            assert (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)) {
-                    check (out_arg.mode == ast.alias);
+                    assert (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)) {
-                    check (out_arg.mode == ast.alias);
+                    assert (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);
-            check (lhs_res.is_mem);
+            assert (lhs_res.is_mem);
             auto rhs_res = trans_expr(lhs_res.res.bcx, src);
             auto t = node_ann_type(cx.fcx.lcx.ccx, ann);
             // FIXME: calculate copy init-ness in typestate.
@@ -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);
-            check (lhs_res.is_mem);
+            assert (lhs_res.is_mem);
             auto rhs_res = trans_expr(lhs_res.res.bcx, src);
             if (ty.type_is_sequence(cx.fcx.lcx.ccx.tcx, t)) {
                 alt (op) {
@@ -5210,7 +5210,11 @@ fn trans_expr(@block_ctxt cx, @ast.expr e) -> result {
             ret trans_log(lvl, cx, a);
         }
 
-        case (ast.expr_check_expr(?a, _)) {
+        case (ast.expr_assert(?a, _)) {
+            ret trans_check_expr(cx, a);
+        }
+
+        case (ast.expr_check(?a, _)) {
             ret trans_check_expr(cx, a);
         }
 
@@ -5531,7 +5535,7 @@ fn trans_ret(@block_ctxt cx, &option.t[@ast.expr] e) -> result {
 
 fn trans_be(@block_ctxt cx, @ast.expr e) -> result {
     // FIXME: This should be a typestate precondition
-    check (ast.is_call_expr(e));
+    assert (ast.is_call_expr(e));
     // FIXME: Turn this into a real tail call once
     // calling convention issues are settled
     ret trans_ret(cx, some(e));
@@ -5627,7 +5631,7 @@ fn trans_recv(@block_ctxt cx, @ast.expr lhs, @ast.expr rhs,
 
     auto bcx = cx;
     auto data = trans_lval(bcx, lhs);
-    check (data.is_mem);
+    assert (data.is_mem);
     bcx = data.res.bcx;
     auto unit_ty = node_ann_type(bcx.fcx.lcx.ccx, ann);
 
@@ -5659,7 +5663,7 @@ fn recv_val(@block_ctxt cx, ValueRef lhs, @ast.expr rhs,
 fn init_local(@block_ctxt cx, @ast.local local) -> result {
 
     // Make a note to drop this slot on the way out.
-    check (cx.fcx.lllocals.contains_key(local.id));
+    assert (cx.fcx.lllocals.contains_key(local.id));
     auto llptr = cx.fcx.lllocals.get(local.id);
     auto ty = node_ann_type(cx.fcx.lcx.ccx, local.ann);
     auto bcx = cx;
@@ -5775,7 +5779,7 @@ fn trans_block_cleanups(@block_ctxt cx,
     auto bcx = cx;
 
     if (cleanup_cx.kind == NON_SCOPE_BLOCK) {
-        check (_vec.len[cleanup](cleanup_cx.cleanups) == 0u);
+        assert (_vec.len[cleanup](cleanup_cx.cleanups) == 0u);
     }
 
     auto i = _vec.len[cleanup](cleanup_cx.cleanups);
@@ -5996,7 +6000,7 @@ fn create_llargs_for_fn_args(&@fn_ctxt cx,
             auto i = 0u;
             for (ast.ty_param tp in ty_params) {
                 auto llarg = llvm.LLVMGetParam(cx.llfn, arg_n);
-                check (llarg as int != 0);
+                assert (llarg as int != 0);
                 cx.lltydescs += vec(llarg);
                 arg_n += 1u;
                 i += 1u;
@@ -6006,14 +6010,14 @@ fn create_llargs_for_fn_args(&@fn_ctxt cx,
 
     if (proto == ast.proto_iter) {
         auto llarg = llvm.LLVMGetParam(cx.llfn, arg_n);
-        check (llarg as int != 0);
+        assert (llarg as int != 0);
         cx.lliterbody = some[ValueRef](llarg);
         arg_n += 1u;
     }
 
     for (ast.arg arg in args) {
         auto llarg = llvm.LLVMGetParam(cx.llfn, arg_n);
-        check (llarg as int != 0);
+        assert (llarg as int != 0);
         cx.llargs.insert(arg.id, llarg);
         arg_n += 1u;
     }
@@ -6451,7 +6455,7 @@ fn trans_tag_variant(@local_ctxt cx, ast.def_id tag_id,
                            id=varg.id));
     }
 
-    check (cx.ccx.item_ids.contains_key(variant.node.id));
+    assert (cx.ccx.item_ids.contains_key(variant.node.id));
     let ValueRef llfndecl = cx.ccx.item_ids.get(variant.node.id);
 
     auto fcx = new_fn_ctxt(cx, llfndecl);
@@ -6718,7 +6722,7 @@ fn decl_native_fn_and_pair(@crate_ctxt ccx,
             for each (uint i in _uint.range(0u, num_ty_param)) {
                 auto llarg = llvm.LLVMGetParam(fcx.llfn, arg_n);
                 fcx.lltydescs += vec(llarg);
-                check (llarg as int != 0);
+                assert (llarg as int != 0);
                 call_args += vec(vp2i(bcx, llarg));
                 arg_n += 1u;
             }
@@ -6784,7 +6788,7 @@ fn decl_native_fn_and_pair(@crate_ctxt ccx,
 
         for (ty.arg arg in args) {
             auto llarg = llvm.LLVMGetParam(fcx.llfn, arg_n);
-            check (llarg as int != 0);
+            assert (llarg as int != 0);
             push_arg(bcx, call_args, llarg, arg.ty, arg.mode);
             if (arg.mode == ast.val) {
                 drop_args += vec(tup(llarg, arg.ty));
diff --git a/src/comp/middle/ty.rs b/src/comp/middle/ty.rs
index 83befefc701..220adcb1a23 100644
--- a/src/comp/middle/ty.rs
+++ b/src/comp/middle/ty.rs
@@ -895,7 +895,7 @@ fn type_is_tup_like(ctxt cx, t ty) -> bool {
 }
 
 fn get_element_type(ctxt cx, t ty, uint i) -> t {
-    check (type_is_tup_like(cx, ty));
+    assert (type_is_tup_like(cx, ty));
     alt (struct(cx, ty)) {
         case (ty_tup(?mts)) {
             ret mts.(i).ty;
@@ -1785,50 +1785,117 @@ fn pat_ty(ctxt cx, @ast.pat pat) -> t {
     fail;   // not reached
 }
 
-fn expr_ann(@ast.expr expr) -> option.t[ast.ann] {
-    alt (expr.node) {
-        case (ast.expr_vec(_, _, ?ann))       { ret some[ast.ann](ann); }
-        case (ast.expr_tup(_, ?ann))          { ret some[ast.ann](ann); }
-        case (ast.expr_rec(_, _, ?ann))       { ret some[ast.ann](ann); }
-        case (ast.expr_bind(_, _, ?ann))      { ret some[ast.ann](ann); }
-        case (ast.expr_call(_, _, ?ann))      { ret some[ast.ann](ann); }
-        case (ast.expr_self_method(_, ?ann))  { ret some[ast.ann](ann); }
-        case (ast.expr_spawn(_, _, _, _, ?ann))
-                                              { ret some[ast.ann](ann); }
-        case (ast.expr_binary(_, _, _, ?ann)) { ret some[ast.ann](ann); }
-        case (ast.expr_unary(_, _, ?ann))     { ret some[ast.ann](ann); }
-        case (ast.expr_lit(_, ?ann))          { ret some[ast.ann](ann); }
-        case (ast.expr_cast(_, _, ?ann))      { ret some[ast.ann](ann); }
-        case (ast.expr_if(_, _, _, ?ann))     { ret some[ast.ann](ann); }
-        case (ast.expr_for(_, _, _, ?ann))    { ret some[ast.ann](ann); }
-        case (ast.expr_for_each(_, _, _, ?ann))
-                                              { ret some[ast.ann](ann); }
-        case (ast.expr_while(_, _, ?ann))     { ret some[ast.ann](ann); }
-        case (ast.expr_do_while(_, _, ?ann))  { ret some[ast.ann](ann); }
-        case (ast.expr_alt(_, _, ?ann))       { ret some[ast.ann](ann); }
-        case (ast.expr_block(_, ?ann))        { ret some[ast.ann](ann); }
-        case (ast.expr_assign(_, _, ?ann))    { ret some[ast.ann](ann); }
-        case (ast.expr_assign_op(_, _, _, ?ann))
-                                              { ret some[ast.ann](ann); }
-        case (ast.expr_field(_, _, ?ann))     { ret some[ast.ann](ann); }
-        case (ast.expr_index(_, _, ?ann))     { ret some[ast.ann](ann); }
-        case (ast.expr_path(_, _, ?ann))      { ret some[ast.ann](ann); }
-        case (ast.expr_ext(_, _, _, _, ?ann)) { ret some[ast.ann](ann); }
-        case (ast.expr_port(?ann))            { ret some[ast.ann](ann); }
-        case (ast.expr_chan(_, ?ann))         { ret some[ast.ann](ann); }
-        case (ast.expr_send(_, _, ?ann))      { ret some[ast.ann](ann); }
-        case (ast.expr_recv(_, _, ?ann))      { ret some[ast.ann](ann); }
-
-        case (ast.expr_fail(_))               { ret none[ast.ann]; }
-        case (ast.expr_break(_))              { ret none[ast.ann]; }
-        case (ast.expr_cont(_))               { ret none[ast.ann]; }
-        case (ast.expr_log(_,_,_))            { ret none[ast.ann]; }
-        case (ast.expr_check_expr(_,_))       { ret none[ast.ann]; }
-        case (ast.expr_ret(_,_))              { ret none[ast.ann]; }
-        case (ast.expr_put(_,_))              { ret none[ast.ann]; }
-        case (ast.expr_be(_,_))               { ret none[ast.ann]; }
+fn expr_ann(&@ast.expr e) -> ast.ann {
+    alt(e.node) {
+        case (ast.expr_vec(_,_,?a)) {
+            ret a;
+        }
+        case (ast.expr_tup(_,?a)) {
+            ret a;
+        }
+        case (ast.expr_rec(_,_,?a)) {
+            ret a;
+        }
+        case (ast.expr_call(_,_,?a)) {
+            ret a;
+        }
+        case (ast.expr_bind(_,_,?a)) {
+            ret a;
+        }
+        case (ast.expr_binary(_,_,_,?a)) {
+            ret a;
+        }
+        case (ast.expr_unary(_,_,?a)) {
+            ret a;
+        }
+        case (ast.expr_lit(_,?a)) {
+            ret a;
+        }
+        case (ast.expr_cast(_,_,?a)) {
+            ret a;
+        }
+        case (ast.expr_if(_,_,_,?a)) {
+            ret a;
+        }
+        case (ast.expr_while(_,_,?a)) {
+            ret a;
+        }
+        case (ast.expr_for(_,_,_,?a)) {
+            ret a;
+        }
+        case (ast.expr_for_each(_,_,_,?a)) {
+            ret a;
+        }
+        case (ast.expr_do_while(_,_,?a)) {
+            ret a;
+        }
+        case (ast.expr_alt(_,_,?a)) {
+            ret a;
+        }
+        case (ast.expr_block(_,?a)) {
+            ret a;
+        }
+        case (ast.expr_assign(_,_,?a)) {
+            ret a;
+        }
+        case (ast.expr_assign_op(_,_,_,?a)) {
+            ret a;
+        }
+        case (ast.expr_send(_,_,?a)) {
+            ret a;
+        }
+        case (ast.expr_recv(_,_,?a)) {
+            ret a;
+        }
+        case (ast.expr_field(_,_,?a)) {
+            ret a;
+        }
+        case (ast.expr_index(_,_,?a)) {
+            ret a;
+        }
+        case (ast.expr_path(_,_,?a)) {
+            ret a;
+        }
+        case (ast.expr_ext(_,_,_,_,?a)) {
+            ret a;
+        }
+        case (ast.expr_fail(?a)) {
+            ret a;
+        }
+        case (ast.expr_ret(_,?a)) {
+            ret a; 
+        }
+        case (ast.expr_put(_,?a)) {
+            ret a;
+        }
+        case (ast.expr_be(_,?a)) {
+            ret a;
+        }
+        case (ast.expr_log(_,_,?a)) {
+            ret a;
+        }
+        case (ast.expr_assert(_,?a)) {
+            ret a;
+        }
+        case (ast.expr_check(_,?a)) {
+            ret a;
+        }
+        case (ast.expr_port(?a)) {
+            ret a;
+        }
+        case (ast.expr_chan(_,?a)) {
+            ret a;
+        }
+        case (ast.expr_break(?a)) {
+            ret a;
+        }
+        case (ast.expr_cont(?a)) {
+            ret a;
+        }
+        case (ast.expr_self_method(_, ?a)) {
+            ret a;
+        }
     }
-    fail;
 }
 
 // Returns the type of an expression as a monotype.
@@ -1838,35 +1905,21 @@ fn expr_ann(@ast.expr expr) -> option.t[ast.ann] {
 // instead of "fn(&T) -> T with T = int". If this isn't what you want, see
 // expr_ty_params_and_ty() below.
 fn expr_ty(ctxt cx, @ast.expr expr) -> t {
-    alt (expr_ann(expr)) {
-        case (none[ast.ann])     { ret mk_nil(cx); }
-        case (some[ast.ann](?a)) { ret ann_to_monotype(cx, a); }
-    }
+    { ret ann_to_monotype(cx, expr_ann(expr)); }
 }
 
 fn expr_ty_params_and_ty(ctxt cx, @ast.expr expr) -> tup(vec[t], t) {
-    alt (expr_ann(expr)) {
-        case (none[ast.ann]) {
-            let vec[t] tps = vec();
-            ret tup(tps, mk_nil(cx));
-        }
-        case (some[ast.ann](?a)) {
-            ret tup(ann_to_type_params(a), ann_to_type(a));
-        }
-    }
+    auto a = expr_ann(expr);
+
+    ret tup(ann_to_type_params(a), ann_to_type(a));
 }
 
 fn expr_has_ty_params(@ast.expr expr) -> bool {
     // FIXME: Rewrite using complex patterns when they're trustworthy.
     alt (expr_ann(expr)) {
-        case (none[ast.ann]) { fail; }
-        case (some[ast.ann](?a)) {
-            alt (a) {
-                case (ast.ann_none) { fail; }
-                case (ast.ann_type(_, ?tps_opt, _)) {
-                    ret !option.is_none[vec[t]](tps_opt);
-                }
-            }
+        case (ast.ann_none) { fail; }
+        case (ast.ann_type(_, ?tps_opt, _)) {
+            ret !option.is_none[vec[t]](tps_opt);
         }
     }
 }
@@ -2233,7 +2286,7 @@ mod Unify {
                         if (actual_n < vlen) {
                             cx.types.(actual_n) += vec(expected);
                         } else {
-                            check (actual_n == vlen);
+                            assert (actual_n == vlen);
                             cx.types += vec(mutable vec(expected));
                         }
                     }
@@ -2601,7 +2654,7 @@ mod Unify {
                 if (expected_n < vlen) {
                     cx.types.(expected_n) += vec(actual);
                 } else {
-                    check (expected_n == vlen);
+                    assert (expected_n == vlen);
                     cx.types += vec(mutable vec(actual));
                 }
                 ret ures_ok(expected);
diff --git a/src/comp/middle/typeck.rs b/src/comp/middle/typeck.rs
index 3354fe46ad9..094b7e1f0ee 100644
--- a/src/comp/middle/typeck.rs
+++ b/src/comp/middle/typeck.rs
@@ -110,7 +110,7 @@ fn ty_param_count_and_ty_for_def(@fn_ctxt fcx, &ast.span sp, &ast.def defn)
         -> ty_param_count_and_ty {
     alt (defn) {
         case (ast.def_arg(?id)) {
-            // check (fcx.locals.contains_key(id));
+            // assert (fcx.locals.contains_key(id));
             ret tup(0u, fcx.locals.get(id));
         }
         case (ast.def_local(?id)) {
@@ -122,7 +122,7 @@ fn ty_param_count_and_ty_for_def(@fn_ctxt fcx, &ast.span sp, &ast.def defn)
             ret tup(0u, t);
         }
         case (ast.def_obj_field(?id)) {
-            // check (fcx.locals.contains_key(id));
+            // assert (fcx.locals.contains_key(id));
             ret tup(0u, fcx.locals.get(id));
         }
         case (ast.def_fn(?id)) {
@@ -142,7 +142,7 @@ fn ty_param_count_and_ty_for_def(@fn_ctxt fcx, &ast.span sp, &ast.def defn)
                                     fcx.ccx.type_cache, vid);
         }
         case (ast.def_binding(?id)) {
-            // check (fcx.locals.contains_key(id));
+            // assert (fcx.locals.contains_key(id));
             ret tup(0u, fcx.locals.get(id));
         }
         case (ast.def_obj(?id)) {
@@ -298,7 +298,7 @@ fn ast_ty_to_ty(ty.ctxt tcx, ty_getter getter, &@ast.ty ast_ty) -> ty.t {
         }
 
         case (ast.ty_path(?path, ?def)) {
-            check (def != none[ast.def]);
+            assert (def != none[ast.def]);
             alt (option.get[ast.def](def)) {
                 case (ast.def_ty(?id)) {
                     typ = instantiate(tcx, getter, id, path.node.types);
@@ -411,7 +411,7 @@ mod Collect {
             ret creader.get_type(cx.sess, cx.tcx, id);
         }
 
-        // check (cx.id_to_ty_item.contains_key(id));
+        // assert (cx.id_to_ty_item.contains_key(id));
 
         auto it = cx.id_to_ty_item.get(id);
         auto tpt;
@@ -672,7 +672,7 @@ mod Collect {
     fn fold_item_const(&@env e, &span sp, ast.ident i,
                        @ast.ty t, @ast.expr ex,
                        ast.def_id id, ast.ann a) -> @ast.item {
-        // check (e.cx.type_cache.contains_key(id));
+        // assert (e.cx.type_cache.contains_key(id));
         auto typ = e.cx.type_cache.get(id)._1;
         auto item = ast.item_const(i, t, ex, id, triv_ann(typ));
         ret @fold.respan[ast.item_](sp, item);
@@ -681,7 +681,7 @@ mod Collect {
     fn fold_item_fn(&@env e, &span sp, ast.ident i,
                     &ast._fn f, vec[ast.ty_param] ty_params,
                     ast.def_id id, ast.ann a) -> @ast.item {
-        // check (e.cx.type_cache.contains_key(id));
+        // assert (e.cx.type_cache.contains_key(id));
         auto typ = e.cx.type_cache.get(id)._1;
         auto item = ast.item_fn(i, f, ty_params, id, triv_ann(typ));
         ret @fold.respan[ast.item_](sp, item);
@@ -690,7 +690,7 @@ mod Collect {
     fn fold_native_item_fn(&@env e, &span sp, ast.ident i, option.t[str] ln,
                            &ast.fn_decl d, vec[ast.ty_param] ty_params,
                            ast.def_id id, ast.ann a) -> @ast.native_item {
-        // check (e.cx.type_cache.contains_key(id));
+        // assert (e.cx.type_cache.contains_key(id));
         auto typ = e.cx.type_cache.get(id)._1;
         auto item = ast.native_item_fn(i, ln, d, ty_params, id,
                                        triv_ann(typ));
@@ -721,7 +721,7 @@ mod Collect {
     fn fold_item_obj(&@env e, &span sp, ast.ident i,
                     &ast._obj ob, vec[ast.ty_param] ty_params,
                     ast.obj_def_ids odid, ast.ann a) -> @ast.item {
-        // check (e.cx.type_cache.contains_key(odid.ctor));
+        // assert (e.cx.type_cache.contains_key(odid.ctor));
         auto t = e.cx.type_cache.get(odid.ctor)._1;
         let vec[method] meth_tys = get_ctor_obj_methods(e, t);
         let vec[@ast.method] methods = vec();
@@ -777,7 +777,7 @@ mod Collect {
     fn fold_item_ty(&@env e, &span sp, ast.ident i,
                     @ast.ty t, vec[ast.ty_param] ty_params,
                     ast.def_id id, ast.ann a) -> @ast.item {
-        // check (e.cx.type_cache.contains_key(id));
+        // assert (e.cx.type_cache.contains_key(id));
         auto typ = e.cx.type_cache.get(id)._1;
         auto item = ast.item_ty(i, t, ty_params, id, triv_ann(typ));
         ret @fold.respan[ast.item_](sp, item);
@@ -1214,7 +1214,7 @@ mod Pushdown {
                             case (none[@ast.expr]) {
                                 auto i = 0u;
                                 for (ast.field field_0 in fields_0) {
-                                    check (_str.eq(field_0.ident,
+                                    assert (_str.eq(field_0.ident,
                                                    field_mts.(i).ident));
                                     auto e_1 =
                                         pushdown_expr(fcx,
@@ -1409,7 +1409,8 @@ mod Pushdown {
             case (ast.expr_ret(_,_)) { e_1 = e.node; }
             case (ast.expr_put(_,_)) { e_1 = e.node; }
             case (ast.expr_be(_,_))  { e_1 = e.node; }
-            case (ast.expr_check_expr(_,_)) { e_1 = e.node; }
+            case (ast.expr_check(_,_)) { e_1 = e.node; }
+            case (ast.expr_assert(_,_)) { e_1 = e.node; }
 
             case (ast.expr_port(?ann)) {
                 auto t = Demand.simple(fcx, e.span, expected,
@@ -1839,7 +1840,7 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr {
 
         case (ast.expr_path(?pth, ?defopt, _)) {
             auto t = ty.mk_nil(fcx.ccx.tcx);
-            check (defopt != none[ast.def]);
+            assert (defopt != none[ast.def]);
             auto defn = option.get[ast.def](defopt);
 
             auto tpt = ty_param_count_and_ty_for_def(fcx, expr.span, defn);
@@ -1939,7 +1940,7 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr {
 
         case (ast.expr_be(?e, _)) {
             /* FIXME: prove instead of check */
-            check (ast.is_call_expr(e));
+            assert (ast.is_call_expr(e));
             auto expr_0 = check_expr(fcx, e);
             auto expr_1 = Pushdown.pushdown_expr(fcx, fcx.ret_ty, expr_0);
             ret @fold.respan[ast.expr_](expr.span,
@@ -1953,12 +1954,25 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr {
                                          plain_ann(fcx.ccx.tcx)));
         }
 
-        case (ast.expr_check_expr(?e, _)) {
+        case (ast.expr_check(?e, _)) {
+            /* FIXME */
+        /* presumably, here is where we should check that e is
+         actually a call to a predicate, where all the arguments
+        are literals or slot variables? */
             auto expr_t = check_expr(fcx, e);
             Demand.simple(fcx, expr.span, ty.mk_bool(fcx.ccx.tcx),
                           expr_ty(fcx.ccx.tcx, expr_t));
             ret @fold.respan[ast.expr_]
-                (expr.span, ast.expr_check_expr(expr_t,
+                (expr.span, ast.expr_check(expr_t,
+                                                plain_ann(fcx.ccx.tcx)));
+        }
+
+        case (ast.expr_assert(?e, _)) {
+            auto expr_t = check_expr(fcx, e);
+            Demand.simple(fcx, expr.span, ty.mk_bool(fcx.ccx.tcx),
+                          expr_ty(fcx.ccx.tcx, expr_t));
+            ret @fold.respan[ast.expr_]
+                (expr.span, ast.expr_assert(expr_t,
                                                 plain_ann(fcx.ccx.tcx)));
         }
 
diff --git a/src/comp/middle/typestate_check.rs b/src/comp/middle/typestate_check.rs
index d08ae82d603..e15c720a3d9 100644
--- a/src/comp/middle/typestate_check.rs
+++ b/src/comp/middle/typestate_check.rs
@@ -55,7 +55,8 @@ import front.ast.expr_put;
 import front.ast.expr_port;
 import front.ast.expr_chan;
 import front.ast.expr_be;
-import front.ast.expr_check_expr;
+import front.ast.expr_check;
+import front.ast.expr_assert;
 import front.ast.expr_cast;
 import front.ast.expr_for;
 import front.ast.expr_for_each;
@@ -147,8 +148,7 @@ import util.typestate_ann.clone;
 import middle.ty;
 import middle.ty.ann_to_type;
 import middle.ty.arg;
-import middle.ty.block_ty;
-import middle.ty.expr_ty;
+import middle.ty.expr_ann;
 import middle.ty.ty_to_str;
 
 import pretty.pprust.print_block;
@@ -293,11 +293,11 @@ type fn_info      = std.map.hashmap[def_id, var_info];
 type fn_info_map = std.map.hashmap[def_id, fn_info];
  
 fn bit_num(def_id v, fn_info m) -> uint {
-  check (m.contains_key(v));
+  assert (m.contains_key(v));
   ret m.get(v)._0;
 }
 fn get_fn_info(fn_info_map fm, def_id did) -> fn_info {
-    check (fm.contains_key(did));
+    assert (fm.contains_key(did));
     ret fm.get(did);
 }
 
@@ -389,116 +389,6 @@ fn mk_f_to_fn_info(@ast.crate c) -> fn_info_map {
   ret res;
 }
 /**** Helpers ****/
-fn expr_ann(&expr e) -> ann {
-  alt(e.node) {
-    case (ast.expr_vec(_,_,?a)) {
-      ret a;
-    }
-    case (ast.expr_tup(_,?a)) {
-      ret a;
-    }
-    case (ast.expr_rec(_,_,?a)) {
-      ret a;
-    }
-    case (ast.expr_call(_,_,?a)) {
-      ret a;
-    }
-    case (ast.expr_bind(_,_,?a)) {
-      ret a;
-    }
-    case (ast.expr_binary(_,_,_,?a)) {
-      ret a;
-    }
-    case (ast.expr_unary(_,_,?a)) {
-      ret a;
-    }
-    case (ast.expr_lit(_,?a)) {
-      ret a;
-    }
-    case (ast.expr_cast(_,_,?a)) {
-      ret a;
-    }
-    case (ast.expr_if(_,_,_,?a)) {
-      ret a;
-    }
-    case (ast.expr_while(_,_,?a)) {
-      ret a;
-    }
-    case (ast.expr_for(_,_,_,?a)) {
-      ret a;
-    }
-    case (ast.expr_for_each(_,_,_,?a)) {
-      ret a;
-    }
-    case (ast.expr_do_while(_,_,?a)) {
-      ret a;
-    }
-    case (ast.expr_alt(_,_,?a)) {
-      ret a;
-    }
-    case (ast.expr_block(_,?a)) {
-      ret a;
-    }
-    case (ast.expr_assign(_,_,?a)) {
-      ret a;
-    }
-    case (ast.expr_assign_op(_,_,_,?a)) {
-      ret a;
-    }
-    case (ast.expr_send(_,_,?a)) {
-      ret a;
-    }
-    case (ast.expr_recv(_,_,?a)) {
-      ret a;
-    }
-    case (ast.expr_field(_,_,?a)) {
-      ret a;
-    }
-    case (ast.expr_index(_,_,?a)) {
-      ret a;
-    }
-    case (ast.expr_path(_,_,?a)) {
-      ret a;
-    }
-    case (ast.expr_ext(_,_,_,_,?a)) {
-      ret a;
-    }
-    case (ast.expr_fail(?a)) {
-      ret a;
-    }
-    case (ast.expr_ret(_,?a)) {
-      ret a; 
-    }
-    case (ast.expr_put(_,?a)) {
-      ret a;
-    }
-    case (ast.expr_be(_,?a)) {
-      ret a;
-    }
-    case (ast.expr_log(_,_,?a)) {
-      ret a;
-    }
-    case (ast.expr_check_expr(_,?a)) {
-      ret a;
-    }
-    case (ast.expr_port(?a)) {
-      ret a;
-    }
-    case (ast.expr_chan(_,?a)) {
-      ret a;
-    }
-    case (expr_break(?a)) {
-        ret a;
-    }
-    case (expr_cont(?a)) {
-        ret a;
-    }
-    case (expr_self_method(_, ?a)) {
-        ret a;
-    }
-  }
-}
-
 fn ann_to_ts_ann(ann a, uint nv) -> ts_ann {
   alt (a) {
     case (ann_none)         { ret empty_ann(nv); }
@@ -532,7 +422,7 @@ fn ann_to_ts_ann_fail_more(ann a) -> @ts_ann {
           fail;
       }
       case (ann_type(_,_,?t)) {
-          check (! is_none[@ts_ann](t));
+          assert (! is_none[@ts_ann](t));
           ret get[@ts_ann](t);
       }
   }
@@ -557,7 +447,7 @@ fn stmt_to_ann(&stmt s) -> option.t[@ts_ann] {
 }
 
 /* fails if e has no annotation */
-fn expr_states(&expr e) -> pre_and_post_state {
+fn expr_states(@expr e) -> pre_and_post_state {
   alt (expr_ann(e)) {
     case (ann_none) {
       log_err "expr_pp: the impossible happened (no annotation)";
@@ -578,7 +468,7 @@ fn expr_states(&expr e) -> pre_and_post_state {
 }
 
 /* fails if e has no annotation */
-fn expr_pp(&expr e) -> pre_and_post {
+fn expr_pp(@expr e) -> pre_and_post {
   alt (expr_ann(e)) {
     case (ann_none) {
       log_err "expr_pp: the impossible happened (no annotation)";
@@ -664,19 +554,19 @@ fn stmt_states(&stmt s, uint nv) -> pre_and_post_state {
 }
 
 
-fn expr_precond(&expr e) -> precond {
+fn expr_precond(@expr e) -> precond {
   ret (expr_pp(e)).precondition;
 }
 
-fn expr_postcond(&expr e) -> postcond {
+fn expr_postcond(@expr e) -> postcond {
   ret (expr_pp(e)).postcondition;
 }
 
-fn expr_prestate(&expr e) -> prestate {
+fn expr_prestate(@expr e) -> prestate {
   ret (expr_states(e)).prestate;
 }
 
-fn expr_poststate(&expr e) -> poststate {
+fn expr_poststate(@expr e) -> poststate {
   ret (expr_states(e)).poststate;
 }
 
@@ -737,7 +627,7 @@ fn seq_preconds(fn_info enclosing, vec[pre_and_post] pps) -> precond {
 
   if (sz >= 1u) {
     auto first   = pps.(0);
-    check (pps_len(first) == num_vars);
+    assert (pps_len(first) == num_vars);
     let precond rest = seq_preconds(enclosing,
                          slice[pre_and_post](pps, 1u, sz));
     difference(rest, first.postcondition);
@@ -797,7 +687,7 @@ fn intersect_postconds_go(&postcond first, &vec[postcond] rest) -> postcond {
 }
 
 fn intersect_postconds(&vec[postcond] pcs) -> postcond {
-  check (len[postcond](pcs) > 0u);
+  assert (len[postcond](pcs) > 0u);
 
   ret intersect_postconds_go(bitv.clone(pcs.(0)), pcs);
 }
@@ -826,7 +716,7 @@ fn find_pre_post_state_native_mod(&native_mod m) -> bool {
  
 fn find_pre_post_obj(&fn_info_map fm, _obj o) -> () {
     fn do_a_method(fn_info_map fm, &@method m) -> () {
-        check(fm.contains_key(m.node.id));
+        assert (fm.contains_key(m.node.id));
         find_pre_post_fn(fm, fm.get(m.node.id), m.node.meth);
     }
     auto f = bind do_a_method(fm,_);
@@ -836,7 +726,7 @@ fn find_pre_post_obj(&fn_info_map fm, _obj o) -> () {
 
 fn find_pre_post_state_obj(fn_info_map fm, _obj o) -> bool {
     fn do_a_method(fn_info_map fm, &@method m) -> bool {
-        check(fm.contains_key(m.node.id));
+        assert (fm.contains_key(m.node.id));
         ret find_pre_post_state_fn(fm, fm.get(m.node.id), m.node.meth);
     }
     auto f = bind do_a_method(fm,_);
@@ -849,10 +739,10 @@ fn find_pre_post_state_obj(fn_info_map fm, _obj o) -> bool {
 fn find_pre_post_item(fn_info_map fm, fn_info enclosing, &item i) -> () {
   alt (i.node) {
     case (ast.item_const(?id, ?t, ?e, ?di, ?a)) {
-        find_pre_post_expr(fm, enclosing, *e);
+        find_pre_post_expr(fm, enclosing, e);
     }
     case (ast.item_fn(?id, ?f, ?ps, ?di, ?a)) {
-      check (fm.contains_key(di));
+      assert (fm.contains_key(di));
       find_pre_post_fn(fm, fm.get(di), f);
     }
     case (ast.item_mod(?id, ?m, ?di)) {
@@ -883,14 +773,14 @@ fn find_pre_post_exprs(&fn_info_map fm, &fn_info enclosing,
 
     fn do_one(fn_info_map fm, fn_info enclosing,
               &@expr e) -> () {
-        find_pre_post_expr(fm, enclosing, *e);
+        find_pre_post_expr(fm, enclosing, e);
     }
     auto f = bind do_one(fm, enclosing, _);
 
     _vec.map[@expr, ()](f, args);
 
     fn get_pp(&@expr e) -> pre_and_post {
-        ret expr_pp(*e);
+        ret expr_pp(e);
     }
     auto g = get_pp;
     auto pps = _vec.map[@expr, pre_and_post](g, args);
@@ -904,31 +794,31 @@ fn find_pre_post_exprs(&fn_info_map fm, &fn_info enclosing,
 
 fn find_pre_post_loop(&fn_info_map fm, &fn_info enclosing, &@decl d,
      &@expr index, &block body, &ann a) -> () {
-    find_pre_post_expr(fm, enclosing, *index);
+    find_pre_post_expr(fm, enclosing, index);
     find_pre_post_block(fm, enclosing, body);
     auto loop_precond = declare_var(enclosing, decl_lhs(d),
-           seq_preconds(enclosing, vec(expr_pp(*index),
-                                                   block_pp(body))));
+           seq_preconds(enclosing, vec(expr_pp(index),
+                                       block_pp(body))));
     auto loop_postcond = intersect_postconds
-        (vec(expr_postcond(*index), block_postcond(body)));
+        (vec(expr_postcond(index), block_postcond(body)));
     set_pre_and_post(a, rec(precondition=loop_precond,
                             postcondition=loop_postcond));
 }
 
 /* Fills in annotations as a side effect. Does not rebuild the expr */
-fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, &expr e) -> () {
+fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, @expr e) -> () {
     auto num_local_vars = num_locals(enclosing);
 
     fn do_rand_(fn_info_map fm, fn_info enclosing, &@expr e) -> () {
-        find_pre_post_expr(fm, enclosing, *e);
+        find_pre_post_expr(fm, enclosing, e);
     }
     fn pp_one(&@expr e) -> pre_and_post {
-        ret expr_pp(*e);
+        ret expr_pp(e);
     }
     
         log("find_pre_post_expr (num_locals =" +
              uistr(num_local_vars) + "):");
-        log_expr(e);
+        log_expr(*e);
     
     alt (e.node) {
         case (expr_call(?operator, ?operands, ?a)) {
@@ -974,18 +864,18 @@ fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, &expr e) -> () {
             set_pre_and_post(a, empty_pre_post(num_local_vars));
         }
         case(expr_log(_, ?arg, ?a)) {
-            find_pre_post_expr(fm, enclosing, *arg);
-            set_pre_and_post(a, expr_pp(*arg));
+            find_pre_post_expr(fm, enclosing, arg);
+            set_pre_and_post(a, expr_pp(arg));
         }
         case (expr_chan(?arg, ?a)) {
-            find_pre_post_expr(fm, enclosing, *arg);
-            set_pre_and_post(a, expr_pp(*arg));
+            find_pre_post_expr(fm, enclosing, arg);
+            set_pre_and_post(a, expr_pp(arg));
         }
         case(expr_put(?opt, ?a)) {
             alt (opt) {
                 case (some[@expr](?arg)) {
-                    find_pre_post_expr(fm, enclosing, *arg);
-                    set_pre_and_post(a, expr_pp(*arg));
+                    find_pre_post_expr(fm, enclosing, arg);
+                    set_pre_and_post(a, expr_pp(arg));
                 }
                 case (none[@expr]) {
                     set_pre_and_post(a, empty_pre_post(num_local_vars));
@@ -1004,10 +894,10 @@ fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, &expr e) -> () {
         case (expr_assign(?lhs, ?rhs, ?a)) {
             alt (lhs.node) {
                 case (expr_path(?p, some[def](def_local(?d_id)), ?a_lhs)) {
-                    find_pre_post_expr(fm, enclosing, *rhs);
-                    set_pre_and_post(a, expr_pp(*rhs));
+                    find_pre_post_expr(fm, enclosing, rhs);
+                    set_pre_and_post(a, expr_pp(rhs));
                     log("gen:");
-                    log_expr(e);
+                    log_expr(*e);
                     gen(enclosing, a, d_id);
                 }
                 case (_) {
@@ -1020,10 +910,10 @@ fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, &expr e) -> () {
         case (expr_recv(?lhs, ?rhs, ?a)) {
             alt (lhs.node) {
                 case (expr_path(?p, some[def](def_local(?d_id)), ?a_lhs)) {
-                    find_pre_post_expr(fm, enclosing, *rhs);
-                    set_pre_and_post(a, expr_pp(*rhs));
+                    find_pre_post_expr(fm, enclosing, rhs);
+                    set_pre_and_post(a, expr_pp(rhs));
                     log("gen:");
-                    log_expr(e);
+                    log_expr(*e);
                     gen(enclosing, a, d_id);
                 }
                 case (_) {
@@ -1049,45 +939,45 @@ fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, &expr e) -> () {
                           postcondition=false_postcond(num_local_vars)));
                 }
                 case (some[@expr](?ret_val)) {
-                    find_pre_post_expr(fm, enclosing, *ret_val);
+                    find_pre_post_expr(fm, enclosing, ret_val);
                     let pre_and_post pp =
-                        rec(precondition=expr_precond(*ret_val),
+                        rec(precondition=expr_precond(ret_val),
                             postcondition=false_postcond(num_local_vars));
                     set_pre_and_post(a, pp);
                 }
             }
         }
         case (expr_be(?e, ?a)) {
-            find_pre_post_expr(fm, enclosing, *e);
-            set_pre_and_post(a, rec(precondition=expr_prestate(*e),
+            find_pre_post_expr(fm, enclosing, e);
+            set_pre_and_post(a, rec(precondition=expr_prestate(e),
                           postcondition=false_postcond(num_local_vars)));
         }
         case (expr_if(?antec, ?conseq, ?maybe_alt, ?a)) {
-            find_pre_post_expr(fm, enclosing, *antec);
+            find_pre_post_expr(fm, enclosing, antec);
             find_pre_post_block(fm, enclosing, conseq);
             alt (maybe_alt) {
                 case (none[@expr]) {
                     auto precond_res = seq_preconds(enclosing,
-                                                    vec(expr_pp(*antec),
+                                                    vec(expr_pp(antec),
                                                         block_pp(conseq)));
                     set_pre_and_post(a, rec(precondition=precond_res,
                                             postcondition=
-                                            expr_poststate(*antec)));
+                                            expr_poststate(antec)));
                 }
                 case (some[@expr](?altern)) {
-                    find_pre_post_expr(fm, enclosing, *altern);
+                    find_pre_post_expr(fm, enclosing, altern);
                     auto precond_true_case =
                         seq_preconds(enclosing,
-                                     vec(expr_pp(*antec), block_pp(conseq)));
+                                     vec(expr_pp(antec), block_pp(conseq)));
                     auto postcond_true_case = union_postconds
                         (num_local_vars,
-                         vec(expr_postcond(*antec), block_postcond(conseq)));
+                         vec(expr_postcond(antec), block_postcond(conseq)));
                     auto precond_false_case = seq_preconds
                         (enclosing,
-                         vec(expr_pp(*antec), expr_pp(*altern)));
+                         vec(expr_pp(antec), expr_pp(altern)));
                     auto postcond_false_case = union_postconds
                         (num_local_vars,
-                         vec(expr_postcond(*antec), expr_postcond(*altern)));
+                         vec(expr_postcond(antec), expr_postcond(altern)));
                     auto precond_res = union_postconds
                         (num_local_vars,
                          vec(precond_true_case, precond_false_case));
@@ -1107,31 +997,31 @@ fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, &expr e) -> () {
             find_pre_post_exprs(fm, enclosing, vec(l, r), a);
         }
         case (expr_unary(_,?operand,?a)) {
-            find_pre_post_expr(fm, enclosing, *operand);
-            set_pre_and_post(a, expr_pp(*operand));
+            find_pre_post_expr(fm, enclosing, operand);
+            set_pre_and_post(a, expr_pp(operand));
         }
         case (expr_cast(?operand, _, ?a)) {
-            find_pre_post_expr(fm, enclosing, *operand);
-            set_pre_and_post(a, expr_pp(*operand));
+            find_pre_post_expr(fm, enclosing, operand);
+            set_pre_and_post(a, expr_pp(operand));
         }
         case (expr_while(?test, ?body, ?a)) {
-            find_pre_post_expr(fm, enclosing, *test);
+            find_pre_post_expr(fm, enclosing, test);
             find_pre_post_block(fm, enclosing, body);
             set_pre_and_post(a,
               rec(precondition=
                   seq_preconds(enclosing,
-                                 vec(expr_pp(*test), 
+                                 vec(expr_pp(test), 
                                      block_pp(body))),
                   postcondition=
-                  intersect_postconds(vec(expr_postcond(*test),
+                  intersect_postconds(vec(expr_postcond(test),
                                           block_postcond(body)))));
         }
         case (expr_do_while(?body, ?test, ?a)) {
             find_pre_post_block(fm, enclosing, body);
-            find_pre_post_expr(fm, enclosing, *test);
+            find_pre_post_expr(fm, enclosing, test);
    
             auto loop_postcond = union_postconds(num_local_vars,
-                            vec(block_postcond(body), expr_postcond(*test)));
+                            vec(block_postcond(body), expr_postcond(test)));
             /* conservative approximination: if the body
                could break or cont, the test may never be executed */
             if (has_nonlocal_exits(body)) {
@@ -1141,7 +1031,7 @@ fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, &expr e) -> () {
             set_pre_and_post(a, 
                              rec(precondition=seq_preconds(enclosing,
                                              vec(block_pp(body),
-                                                 expr_pp(*test))),
+                                                 expr_pp(test))),
                    postcondition=loop_postcond));
         }
         case (expr_for(?d, ?index, ?body, ?a)) {
@@ -1154,7 +1044,7 @@ fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, &expr e) -> () {
             find_pre_post_exprs(fm, enclosing, vec(e, sub), a);
         }
         case (expr_alt(?e, ?alts, ?a)) {
-            find_pre_post_expr(fm, enclosing, *e);
+            find_pre_post_expr(fm, enclosing, e);
             fn do_an_alt(fn_info_map fm, fn_info enc, &arm an_alt)
                 -> pre_and_post {
                 find_pre_post_block(fm, enc, an_alt.block);
@@ -1170,7 +1060,7 @@ fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, &expr e) -> () {
                 intersect(pp.postcondition, next.postcondition);
                 ret pp;
             }
-            auto antec_pp = pp_clone(expr_pp(*e)); 
+            auto antec_pp = pp_clone(expr_pp(e)); 
             auto e_pp  = rec(precondition=empty_prestate(num_local_vars),
                              postcondition=false_postcond(num_local_vars));
             auto g = bind combine_pp(antec_pp, enclosing, _, _);
@@ -1181,8 +1071,8 @@ fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, &expr e) -> () {
             set_pre_and_post(a, alts_overall_pp);
         }
         case (expr_field(?operator, _, ?a)) {
-            find_pre_post_expr(fm, enclosing, *operator);
-            set_pre_and_post(a, expr_pp(*operator));
+            find_pre_post_expr(fm, enclosing, operator);
+            set_pre_and_post(a, expr_pp(operator));
         }
         case (expr_fail(?a)) {
             set_pre_and_post(a,
@@ -1191,10 +1081,14 @@ fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, &expr e) -> () {
                rec(precondition=empty_prestate(num_local_vars),
                    postcondition=false_postcond(num_local_vars)));
         }
-        case (expr_check_expr(?p, ?a)) {
+        case (expr_assert(?p, ?a)) {
+            find_pre_post_expr(fm, enclosing, p);
+            set_pre_and_post(a, expr_pp(p));
+        }
+        case (expr_check(?p, ?a)) {
             /* will need to change when we support arbitrary predicates... */
-            find_pre_post_expr(fm, enclosing, *p);
-            set_pre_and_post(a, expr_pp(*p));
+            find_pre_post_expr(fm, enclosing, p);
+            set_pre_and_post(a, expr_pp(p));
         }
         case(expr_bind(?operator, ?maybe_args, ?a)) {
             auto args = _vec.cat_options[@expr](maybe_args);
@@ -1211,21 +1105,21 @@ fn find_pre_post_expr(&fn_info_map fm, &fn_info enclosing, &expr e) -> () {
             set_pre_and_post(a, empty_pre_post(num_local_vars));
         }
         case (expr_ext(_, _, _, ?expanded, ?a)) {
-            find_pre_post_expr(fm, enclosing, *expanded);
-            set_pre_and_post(a, expr_pp(*expanded));
+            find_pre_post_expr(fm, enclosing, expanded);
+            set_pre_and_post(a, expr_pp(expanded));
         }
     }
 }
 
 fn gen(&fn_info enclosing, &ann a, def_id id) -> bool {
-  check(enclosing.contains_key(id));
+  assert (enclosing.contains_key(id));
   let uint i = (enclosing.get(id))._0;
   ret set_in_postcond(i, (ann_to_ts_ann_fail_more(a)).conditions);
 }
 
 fn declare_var(&fn_info enclosing, def_id id, prestate pre)
    -> prestate {
-    check(enclosing.contains_key(id));
+    assert (enclosing.contains_key(id));
     let uint i = (enclosing.get(id))._0;
     auto res = clone(pre);
     relax_prestate(i, res);
@@ -1233,7 +1127,7 @@ fn declare_var(&fn_info enclosing, def_id id, prestate pre)
 }
 
 fn gen_poststate(&fn_info enclosing, &ann a, def_id id) -> bool {
-  check(enclosing.contains_key(id));
+  assert (enclosing.contains_key(id));
   let uint i = (enclosing.get(id))._0;
 
   ret set_in_poststate(i, (ann_to_ts_ann_fail_more(a)).states);
@@ -1251,8 +1145,8 @@ fn find_pre_post_stmt(fn_info_map fm, &fn_info enclosing, &ast.stmt s)
             case(ast.decl_local(?alocal)) {
                 alt(alocal.init) {
                     case(some[ast.initializer](?an_init)) {
-                        find_pre_post_expr(fm, enclosing, *an_init.expr);
-                        auto rhs_pp = expr_pp(*an_init.expr);
+                        find_pre_post_expr(fm, enclosing, an_init.expr);
+                        auto rhs_pp = expr_pp(an_init.expr);
                         set_pre_and_post(alocal.ann, rhs_pp);
 
                         /* Inherit ann from initializer, and add var being
@@ -1281,8 +1175,8 @@ fn find_pre_post_stmt(fn_info_map fm, &fn_info enclosing, &ast.stmt s)
         }
     }
     case(stmt_expr(?e,?a)) {
-        find_pre_post_expr(fm, enclosing, *e);
-        set_pre_and_post(a, expr_pp(*e));
+        find_pre_post_expr(fm, enclosing, e);
+        set_pre_and_post(a, expr_pp(e));
     }    
   }
 }
@@ -1318,7 +1212,7 @@ fn find_pre_post_block(&fn_info_map fm, &fn_info enclosing, block b)
     
     _vec.map[@stmt, ()](do_one, b.node.stmts);
     fn do_inner_(fn_info_map fm, fn_info i, &@expr e) -> () {
-        find_pre_post_expr(fm, i, *e);
+        find_pre_post_expr(fm, i, e);
     }
     auto do_inner = bind do_inner_(fm, enclosing, _);
     option.map[@expr, ()](do_inner, b.node.expr);
@@ -1331,7 +1225,7 @@ fn find_pre_post_block(&fn_info_map fm, &fn_info enclosing, block b)
     auto f = get_pp_stmt;
     pps += _vec.map[@stmt, pre_and_post](f, b.node.stmts);
     fn get_pp_expr(&@expr e) -> pre_and_post {
-        ret expr_pp(*e);
+        ret expr_pp(e);
     }
     auto g = get_pp_expr;
     plus_option[pre_and_post](pps,
@@ -1363,7 +1257,7 @@ fn check_item_fn(&fn_info_map fm, &span sp, ident i, &ast._fn f,
     log("check_item_fn:");
     log_fn(f, i, ty_params);
 
-  check (fm.contains_key(id));
+  assert (fm.contains_key(id));
   find_pre_post_fn(fm, fm.get(id), f);  
 
   ret @respan(sp, ast.item_fn(i, f, ty_params, id, a));
@@ -1377,7 +1271,7 @@ fn find_pre_post_state_item(fn_info_map fm, fn_info enclosing, @item i)
               empty_prestate(num_locals(enclosing)), e);
     }
     case (ast.item_fn(?id, ?f, ?ps, ?di, ?a)) {
-      check (fm.contains_key(di));
+      assert (fm.contains_key(di));
       ret find_pre_post_state_fn(fm, fm.get(di), f);
     }
     case (ast.item_mod(?id, ?m, ?di)) {
@@ -1401,7 +1295,7 @@ fn find_pre_post_state_item(fn_info_map fm, fn_info enclosing, @item i)
 fn set_prestate_ann(@ann a, prestate pre) -> bool {
   alt (*a) {
     case (ann_type(_,_,?ts_a)) {
-      check (! is_none[@ts_ann](ts_a));
+      assert (! is_none[@ts_ann](ts_a));
       ret set_prestate(get[@ts_ann](ts_a), pre);
     }
     case (ann_none) {
@@ -1415,8 +1309,8 @@ fn set_prestate_ann(@ann a, prestate pre) -> bool {
 fn extend_prestate_ann(ann a, prestate pre) -> bool {
   alt (a) {
     case (ann_type(_,_,?ts_a)) {
-      check (! is_none[@ts_ann](ts_a));
-      ret extend_prestate((*get[@ts_ann](ts_a)).states.prestate, pre);
+      assert (! is_none[@ts_ann](ts_a));
+      ret extend_prestate((get[@ts_ann](ts_a)).states.prestate, pre);
     }
     case (ann_none) {
       log("set_prestate_ann: expected an ann_type here");
@@ -1428,8 +1322,8 @@ fn extend_prestate_ann(ann a, prestate pre) -> bool {
 fn set_poststate_ann(ann a, poststate post) -> bool {
   alt (a) {
     case (ann_type(_,_,?ts_a)) {
-      check (! is_none[@ts_ann](ts_a));
-      ret set_poststate(*get[@ts_ann](ts_a), post);
+      assert (! is_none[@ts_ann](ts_a));
+      ret set_poststate(get[@ts_ann](ts_a), post);
     }
     case (ann_none) {
       log("set_poststate_ann: expected an ann_type here");
@@ -1441,7 +1335,7 @@ fn set_poststate_ann(ann a, poststate post) -> bool {
 fn extend_poststate_ann(ann a, poststate post) -> bool {
   alt (a) {
     case (ann_type(_,_,?ts_a)) {
-      check (! is_none[@ts_ann](ts_a));
+      assert (! is_none[@ts_ann](ts_a));
       ret extend_poststate((*get[@ts_ann](ts_a)).states.poststate, post);
     }
     case (ann_none) {
@@ -1454,7 +1348,7 @@ fn extend_poststate_ann(ann a, poststate post) -> bool {
 fn set_pre_and_post(&ann a, pre_and_post pp) -> () {
     alt (a) {
         case (ann_type(_,_,?ts_a)) {
-            check (! is_none[@ts_ann](ts_a));
+            assert (! is_none[@ts_ann](ts_a));
             auto t = *get[@ts_ann](ts_a);
             /*  log("set_pre_and_post, old =");
             log_pp(t.conditions);
@@ -1478,7 +1372,7 @@ fn seq_states(&fn_info_map fm, &fn_info enclosing,
 
   for (@expr e in exprs) {
     changed = find_pre_post_state_expr(fm, enclosing, post, e) || changed;
-    post = expr_poststate(*e);
+    post = expr_poststate(e);
   }
 
   ret tup(changed, post);
@@ -1513,8 +1407,8 @@ fn find_pre_post_state_loop(fn_info_map fm, fn_info enclosing,
     /* in general, would need the intersection of
        (poststate of index, poststate of body) */
     changed = find_pre_post_state_block(fm, enclosing,
-                expr_poststate(*index), body) || changed;
-    auto res_p = intersect_postconds(vec(expr_poststate(*index),
+                expr_poststate(index), body) || changed;
+    auto res_p = intersect_postconds(vec(expr_poststate(index),
                                          block_poststate(body)));
   
     changed = extend_poststate_ann(a, res_p) || changed;
@@ -1522,7 +1416,7 @@ fn find_pre_post_state_loop(fn_info_map fm, fn_info enclosing,
 }
 
 fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing,
-                            &prestate pres, &@expr e) -> bool {
+                            &prestate pres, @expr e) -> bool {
   auto changed = false;
   auto num_local_vars = num_locals(enclosing);
 
@@ -1540,20 +1434,20 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing,
         || changed;
       /* rands go left-to-right */
       ret(find_pre_post_state_exprs(fm, enclosing,
-                                    expr_poststate(*operator), a, operands)
+                                    expr_poststate(operator), a, operands)
           || changed);
     }
     case (expr_spawn(_, _, ?operator, ?operands, ?a)) {
         changed = find_pre_post_state_expr(fm, enclosing, pres, operator);
         ret(find_pre_post_state_exprs(fm, enclosing,
-                 expr_poststate(*operator), a, operands)
+                 expr_poststate(operator), a, operands)
           || changed);
     }
     case (expr_bind(?operator, ?maybe_args, ?a)) {
         changed = find_pre_post_state_expr(fm, enclosing, pres, operator)
             || changed;
         ret (find_pre_post_state_exprs(fm, enclosing,
-          expr_poststate(*operator), a, cat_options[@expr](maybe_args))
+          expr_poststate(operator), a, cat_options[@expr](maybe_args))
             || changed);
     }
     case (expr_path(_,_,?a)) {
@@ -1563,19 +1457,19 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing,
         /* factor out the "one exp" pattern */
         changed = find_pre_post_state_expr(fm, enclosing, pres, e);
         changed = extend_prestate_ann(a, pres) || changed;
-        changed = extend_poststate_ann(a, expr_poststate(*e)) || changed;
+        changed = extend_poststate_ann(a, expr_poststate(e)) || changed;
         ret changed;
     }
     case (expr_chan(?e, ?a)) {
         changed = find_pre_post_state_expr(fm, enclosing, pres, e);
         changed = extend_prestate_ann(a, pres) || changed;
-        changed = extend_poststate_ann(a, expr_poststate(*e)) || changed;
+        changed = extend_poststate_ann(a, expr_poststate(e)) || changed;
         ret changed;
     }
     case (expr_ext(_, _, _, ?expanded, ?a)) {
         changed = find_pre_post_state_expr(fm, enclosing, pres, expanded);
         changed = extend_prestate_ann(a, pres) || changed;
-        changed = extend_poststate_ann(a, expr_poststate(*expanded))
+        changed = extend_poststate_ann(a, expr_poststate(expanded))
            || changed;
         ret changed;
     }
@@ -1584,7 +1478,7 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing,
             case (some[@expr](?arg)) {
                 changed = find_pre_post_state_expr(fm, enclosing, pres, arg);
                 changed = extend_prestate_ann(a, pres) || changed;
-                changed = extend_poststate_ann(a, expr_poststate(*arg))
+                changed = extend_poststate_ann(a, expr_poststate(arg))
                     || changed;
                 ret changed;
             }
@@ -1611,7 +1505,7 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing,
             case (some[@expr](?base)) {
                 changed = find_pre_post_state_expr(fm, enclosing, pres, base)
                     || changed;
-                changed = extend_poststate_ann(a, expr_poststate(*base))
+                changed = extend_poststate_ann(a, expr_poststate(base))
                     || changed;
             }
         }
@@ -1626,7 +1520,7 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing,
                 changed = pure_exp(a_lhs, pres) || changed;
                 changed = find_pre_post_state_expr(fm, enclosing, pres, rhs)
                     || changed;
-                changed = extend_poststate_ann(a, expr_poststate(*rhs))
+                changed = extend_poststate_ann(a, expr_poststate(rhs))
                     || changed;
                 changed = gen_poststate(enclosing, a, d_id) || changed;
             }
@@ -1635,8 +1529,8 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing,
                 changed = find_pre_post_state_expr(fm, enclosing, pres, lhs)
                     || changed;
                 changed = find_pre_post_state_expr(fm, enclosing,
-                     expr_poststate(*lhs), rhs) || changed;
-                changed = extend_poststate_ann(a, expr_poststate(*rhs))
+                     expr_poststate(lhs), rhs) || changed;
+                changed = extend_poststate_ann(a, expr_poststate(rhs))
                     || changed;
             }
         }
@@ -1651,7 +1545,7 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing,
                 changed = pure_exp(a_lhs, pres) || changed;
                 changed = find_pre_post_state_expr(fm, enclosing, pres, rhs)
                     || changed;
-                changed = extend_poststate_ann(a, expr_poststate(*rhs))
+                changed = extend_poststate_ann(a, expr_poststate(rhs))
                     || changed;
                 changed = gen_poststate(enclosing, a, d_id) || changed;
             }
@@ -1660,8 +1554,8 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing,
                 changed = find_pre_post_state_expr(fm, enclosing, pres, lhs)
                     || changed;
                 changed = find_pre_post_state_expr(fm, enclosing,
-                     expr_poststate(*lhs), rhs) || changed;
-                changed = extend_poststate_ann(a, expr_poststate(*rhs))
+                     expr_poststate(lhs), rhs) || changed;
+                changed = extend_poststate_ann(a, expr_poststate(rhs))
                     || changed;
             }
         }
@@ -1691,17 +1585,17 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing,
         changed = find_pre_post_state_expr(fm, enclosing, pres, antec)
             || changed;
         changed = find_pre_post_state_block(fm, enclosing,
-          expr_poststate(*antec), conseq) || changed;
+          expr_poststate(antec), conseq) || changed;
         alt (maybe_alt) {
             case (none[@expr]) {
-                changed = extend_poststate_ann(a, expr_poststate(*antec))
+                changed = extend_poststate_ann(a, expr_poststate(antec))
                     || changed;
             }
             case (some[@expr](?altern)) {
                 changed = find_pre_post_state_expr(fm, enclosing,
-                   expr_poststate(*antec), altern) || changed;
+                   expr_poststate(antec), altern) || changed;
                 auto poststate_res = intersect_postconds
-                    (vec(block_poststate(conseq), expr_poststate(*altern)));
+                    (vec(block_poststate(conseq), expr_poststate(altern)));
                 changed = extend_poststate_ann(a, poststate_res) || changed;
             }
         }
@@ -1710,7 +1604,7 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing,
         log("new prestate:");
         log_bitv(enclosing, pres);
         log("new poststate:");
-        log_bitv(enclosing, expr_poststate(*e));
+        log_bitv(enclosing, expr_poststate(e));
 
         ret changed;
     }
@@ -1720,8 +1614,8 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing,
         changed = find_pre_post_state_expr(fm, enclosing, pres, l)
                     || changed;
         changed = find_pre_post_state_expr(fm,
-                    enclosing, expr_poststate(*l), r) || changed;
-        changed = extend_poststate_ann(a, expr_poststate(*r)) || changed;
+                    enclosing, expr_poststate(l), r) || changed;
+        changed = extend_poststate_ann(a, expr_poststate(r)) || changed;
         ret changed;
     }
     case (expr_send(?l, ?r, ?a)) {
@@ -1729,8 +1623,8 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing,
         changed = find_pre_post_state_expr(fm, enclosing, pres, l)
                     || changed;
         changed = find_pre_post_state_expr(fm,
-                    enclosing, expr_poststate(*l), r) || changed;
-        changed = extend_poststate_ann(a, expr_poststate(*r)) || changed;
+                    enclosing, expr_poststate(l), r) || changed;
+        changed = extend_poststate_ann(a, expr_poststate(r)) || changed;
         ret changed;
     }
     case (expr_assign_op(?op, ?lhs, ?rhs, ?a)) {
@@ -1739,8 +1633,8 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing,
         changed = find_pre_post_state_expr(fm, enclosing, pres, lhs)
                     || changed;
         changed = find_pre_post_state_expr(fm,
-                    enclosing, expr_poststate(*lhs), rhs) || changed;
-        changed = extend_poststate_ann(a, expr_poststate(*rhs)) || changed;
+                    enclosing, expr_poststate(lhs), rhs) || changed;
+        changed = extend_poststate_ann(a, expr_poststate(rhs)) || changed;
         ret changed;
     }
     case (expr_while(?test, ?body, ?a)) {
@@ -1756,9 +1650,9 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing,
         changed = find_pre_post_state_expr(fm, enclosing, pres, test)
             || changed;
         changed = find_pre_post_state_block(fm, 
-                   enclosing, expr_poststate(*test), body) || changed; 
+                   enclosing, expr_poststate(test), body) || changed; 
         changed = extend_poststate_ann(a,
-                    intersect_postconds(vec(expr_poststate(*test),
+                    intersect_postconds(vec(expr_poststate(test),
                                         block_poststate(body)))) || changed;
         ret changed;
     }
@@ -1777,7 +1671,7 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing,
             changed = set_poststate_ann(a, pres) || changed;
         }
         else {
-            changed = extend_poststate_ann(a, expr_poststate(*test))
+            changed = extend_poststate_ann(a, expr_poststate(test))
               || changed;
         }
 
@@ -1793,14 +1687,14 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing,
         changed = extend_prestate_ann(a, pres) || changed; 
         changed = find_pre_post_state_expr(fm, enclosing, pres, e) || changed;
         changed = find_pre_post_state_expr(fm, enclosing,
-                     expr_poststate(*e), sub) || changed;
-        changed = extend_poststate_ann(a, expr_poststate(*sub));
+                     expr_poststate(e), sub) || changed;
+        changed = extend_poststate_ann(a, expr_poststate(sub));
         ret changed;
     }
     case (expr_alt(?e, ?alts, ?a)) {
         changed = extend_prestate_ann(a, pres) || changed; 
         changed = find_pre_post_state_expr(fm, enclosing, pres, e) || changed;
-        auto e_post = expr_poststate(*e);
+        auto e_post = expr_poststate(e);
         auto a_post;
         if (_vec.len[arm](alts) > 0u) {
             a_post = false_postcond(num_local_vars);
@@ -1821,14 +1715,14 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing,
     case (expr_field(?e,_,?a)) {
         changed = find_pre_post_state_expr(fm, enclosing, pres, e);
         changed = extend_prestate_ann(a, pres) || changed;
-        changed = extend_poststate_ann(a, expr_poststate(*e)) || changed;
+        changed = extend_poststate_ann(a, expr_poststate(e)) || changed;
         ret changed;
     }
     case (expr_unary(_,?operand,?a)) {
         changed = find_pre_post_state_expr(fm, enclosing, pres, operand)
           || changed;
         changed = extend_prestate_ann(a, pres) || changed;
-        changed = extend_poststate_ann(a, expr_poststate(*operand))
+        changed = extend_poststate_ann(a, expr_poststate(operand))
           || changed;
         ret changed;
     }
@@ -1836,7 +1730,7 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing,
            changed = find_pre_post_state_expr(fm, enclosing, pres, operand)
           || changed;
         changed = extend_prestate_ann(a, pres) || changed;
-        changed = extend_poststate_ann(a, expr_poststate(*operand))
+        changed = extend_poststate_ann(a, expr_poststate(operand))
           || changed;
         ret changed;
     }
@@ -1845,14 +1739,15 @@ fn find_pre_post_state_expr(&fn_info_map fm, &fn_info enclosing,
         /* if execution continues after fail, then everything is true! woo! */
         changed = set_poststate_ann(a, false_postcond(num_local_vars))
           || changed;
-        /*        log_err("fail: poststate = ");
-                  log_bitv(enclosing, expr_poststate(*e)); */
         ret changed;
     }
-    case (expr_check_expr(?p, ?a)) {
+    case (expr_assert(?p, ?a)) {
+        ret pure_exp(a, pres);
+    }
+    case (expr_check(?p, ?a)) {
         changed = extend_prestate_ann(a, pres) || changed;
         changed = find_pre_post_state_expr(fm, enclosing, pres, p) || changed;
-        /* p is pure, so the poststate must be the same as the prestate */
+        /* FIXME: update the postcondition to reflect that p holds */
         changed = extend_poststate_ann(a, pres) || changed;
         ret changed;
     }
@@ -1875,7 +1770,7 @@ fn find_pre_post_state_stmt(&fn_info_map fm, &fn_info enclosing,
                             &prestate pres, @stmt s) -> bool {
   auto changed = false;
   auto stmt_ann_ = stmt_to_ann(*s);
-  check (!is_none[@ts_ann](stmt_ann_));
+  assert (!is_none[@ts_ann](stmt_ann_));
   auto stmt_ann = *(get[@ts_ann](stmt_ann_));
               log("*At beginning: stmt = ");
               log_stmt(*s);
@@ -1897,7 +1792,7 @@ fn find_pre_post_state_stmt(&fn_info_map fm, &fn_info enclosing,
                 changed = find_pre_post_state_expr
                     (fm, enclosing, pres, an_init.expr) || changed;
                 changed = extend_poststate(stmt_ann.states.poststate,
-                                           expr_poststate(*an_init.expr))
+                                           expr_poststate(an_init.expr))
                     || changed;
                 changed = gen_poststate(enclosing, a, alocal.id) || changed;
               log("Summary: stmt = ");
@@ -1932,10 +1827,10 @@ fn find_pre_post_state_stmt(&fn_info_map fm, &fn_info enclosing,
     }
     case (stmt_expr(?e, _)) {
       changed = find_pre_post_state_expr(fm, enclosing, pres, e) || changed;
-      changed = extend_prestate(stmt_ann.states.prestate, expr_prestate(*e))
+      changed = extend_prestate(stmt_ann.states.prestate, expr_prestate(e))
           || changed;
       changed = extend_poststate(stmt_ann.states.poststate,
-                                 expr_poststate(*e)) || changed;
+                                 expr_poststate(e)) || changed;
       /*
                     log("Summary: stmt = ");
               log_stmt(*s);
@@ -1980,7 +1875,7 @@ fn find_pre_post_state_block(&fn_info_map fm, &fn_info enclosing,
     case (none[@expr]) {}
     case (some[@expr](?e)) {
       changed = find_pre_post_state_expr(fm, enclosing, pres, e) || changed;
-      post = expr_poststate(*e);
+      post = expr_poststate(e);
     }
   }
 
@@ -2038,13 +1933,13 @@ fn fixed_point_states(fn_info_map fm, fn_info f_info,
   }
 }
 
-fn check_states_expr(fn_info enclosing, &expr e) -> () {
+fn check_states_expr(fn_info enclosing, @expr e) -> () {
   let precond prec    = expr_precond(e);
   let prestate pres   = expr_prestate(e);
 
   if (!implies(pres, prec)) {
       log_err("check_states_expr: Unsatisfied precondition constraint for ");
-      log_expr_err(e);
+      log_expr_err(*e);
       log_err("Precondition: ");
       log_bitv_err(enclosing, prec);
       log_err("Prestate: ");
@@ -2093,7 +1988,7 @@ fn check_states_against_conditions(fn_info enclosing, &ast._fn f) -> () {
  
   _vec.map[@stmt, ()](do_one, f.body.node.stmts);
   fn do_inner_(fn_info i, &@expr e) -> () {
-    check_states_expr(i, *e);
+    check_states_expr(i, e);
   }
   auto do_inner = bind do_inner_(enclosing, _);
   option.map[@expr, ()](do_inner, f.body.node.expr);
@@ -2116,7 +2011,7 @@ fn check_item_fn_state(&fn_info_map f_info_map, &span sp, ident i,
                        ann a) -> @item {
 
   /* Look up the var-to-bit-num map for this function */
-  check(f_info_map.contains_key(id));
+  assert (f_info_map.contains_key(id));
   auto f_info = f_info_map.get(id);
 
   check_fn_states(f_info_map, f_info, f);
@@ -2126,7 +2021,7 @@ fn check_item_fn_state(&fn_info_map f_info_map, &span sp, ident i,
 }
 
 fn check_method_states(&fn_info_map f_info_map, @method m) -> () {
-    check (f_info_map.contains_key(m.node.id));
+    assert (f_info_map.contains_key(m.node.id));
     auto f_info = f_info_map.get(m.node.id);
     check_fn_states(f_info_map, f_info, m.node.meth);
 }
@@ -2193,7 +2088,7 @@ fn init_block(&fn_info fi, &span sp, &block_ b) -> block {
 fn item_fn_anns(&fn_info_map fm, &span sp, ident i, &ast._fn f,
                 vec[ast.ty_param] ty_params, def_id id, ann a) -> @item {
 
-    check(fm.contains_key(id));
+    assert (fm.contains_key(id));
     auto f_info = fm.get(id);
 
     log(i + " has " + uistr(num_locals(f_info)) + " local vars");
@@ -2413,8 +2308,11 @@ fn annotate_expr(&fn_info_map fm, &@expr e) -> @expr {
         case (expr_log(?n, ?e, ?a)) {
             e1 = expr_log(n, annotate_expr(fm, e), a);
         }
-        case (expr_check_expr(?e, ?a)) {
-            e1 = expr_check_expr(annotate_expr(fm, e), a);
+        case (expr_assert(?e, ?a)) {
+            e1 = expr_assert(annotate_expr(fm, e), a);
+        }
+        case (expr_check(?e, ?a)) {
+            e1 = expr_check(annotate_expr(fm, e), a);
         }
         case (expr_port(_)) { /* no change */ }
         case (expr_chan(?e, ?a)) {
diff --git a/src/comp/middle/walk.rs b/src/comp/middle/walk.rs
index dbc188b1d40..8a5d40dc563 100644
--- a/src/comp/middle/walk.rs
+++ b/src/comp/middle/walk.rs
@@ -392,7 +392,10 @@ fn walk_expr(&ast_visitor v, @ast.expr e) {
         case (ast.expr_log(_,?x, _)) {
             walk_expr(v, x);
         }
-        case (ast.expr_check_expr(?x, _)) {
+        case (ast.expr_check(?x, _)) {
+            walk_expr(v, x);
+        }
+        case (ast.expr_assert(?x, _)) {
             walk_expr(v, x);
         }
         case (ast.expr_port(_)) { }
diff --git a/src/comp/pretty/pprust.rs b/src/comp/pretty/pprust.rs
index e49ed34e948..7ef91ce89e4 100644
--- a/src/comp/pretty/pprust.rs
+++ b/src/comp/pretty/pprust.rs
@@ -661,12 +661,18 @@ fn print_expr(ps s, &@ast.expr expr) {
             }
             print_expr(s, expr);
         }
-        case (ast.expr_check_expr(?expr,_)) {
+        case (ast.expr_check(?expr,_)) {
             wrd1(s, "check");
             popen_h(s);
             print_expr(s, expr);
             pclose(s);
         }
+        case (ast.expr_assert(?expr,_)) {
+            wrd1(s, "assert");
+            popen_h(s);
+            print_expr(s, expr);
+            pclose(s);
+        }
         case (ast.expr_ext(?path, ?args, ?body, _, _)) {
             wrd(s.s, "#");
             print_path(s, path);
diff --git a/src/comp/util/typestate_ann.rs b/src/comp/util/typestate_ann.rs
index b7fbc3cc25d..9e815b46484 100644
--- a/src/comp/util/typestate_ann.rs
+++ b/src/comp/util/typestate_ann.rs
@@ -85,7 +85,7 @@ fn intersect(&precond p1, &precond p2) -> bool {
 
 fn pps_len(&pre_and_post p) -> uint {
   // gratuitous check
-  check (p.precondition.nbits == p.postcondition.nbits);
+  assert (p.precondition.nbits == p.postcondition.nbits);
   ret p.precondition.nbits;
 }
 
@@ -129,7 +129,7 @@ fn set_prestate(@ts_ann a, &prestate p) -> bool {
 
 // Sets all the bits in a's postcondition to equal the
 // corresponding bit in p's postcondition.
-fn set_poststate(&ts_ann a, &poststate p) -> bool {
+fn set_poststate(@ts_ann a, &poststate p) -> bool {
   ret bitv.copy(a.states.poststate, p);
 }