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

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

5 files changed, 28 insertions, 38 deletions

diff --git a/src/comp/front/ast.rs b/src/comp/front/ast.rs
index 13b5739e..2fd13194 100644
--- a/src/comp/front/ast.rs
+++ b/src/comp/front/ast.rs
@@ -283,10 +283,7 @@ tag expr_ {
     expr_put(option.t[@expr], ann);
     expr_be(@expr, ann);
     expr_log(int, @expr, ann);
-/* just an assert, no significance to typestate */
-    expr_assert(@expr, ann);
-/* preds that typestate is aware of */
-    expr_check(@expr, ann);
+    expr_check_expr(@expr, ann);
     expr_port(ann);
     expr_chan(@expr, ann);
 }
diff --git a/src/comp/front/creader.rs b/src/comp/front/creader.rs
index c8b31159..f48d47c9 100644
--- a/src/comp/front/creader.rs
+++ b/src/comp/front/creader.rs
@@ -93,7 +93,7 @@ fn parse_ty(@pstate st, str_def sd) -> ty.t {
         case ('c') { ret ty.mk_char(st.tcx); }
         case ('s') { ret ty.mk_str(st.tcx); }
         case ('t') {
-            assert (next(st) as char == '[');
+            check(next(st) as char == '[');
             auto def = parse_def(st, sd);
             let vec[ty.t] params = vec();
             while (peek(st) as char != ']') {
@@ -108,7 +108,7 @@ fn parse_ty(@pstate st, str_def sd) -> ty.t {
         case ('P') { ret ty.mk_port(st.tcx, parse_ty(st, sd)); }
         case ('C') { ret ty.mk_chan(st.tcx, parse_ty(st, sd)); }
         case ('T') {
-            assert (next(st) as char == '[');
+            check(next(st) as char == '[');
             let vec[ty.mt] params = vec();
             while (peek(st) as char != ']') {
                 params += vec(parse_mt(st, sd));
@@ -117,7 +117,7 @@ fn parse_ty(@pstate st, str_def sd) -> ty.t {
             ret ty.mk_tup(st.tcx, params);
         }
         case ('R') {
-            assert (next(st) as char == '[');
+            check(next(st) as char == '[');
             let vec[ty.field] fields = vec();
             while (peek(st) as char != ']') {
                 auto name = "";
@@ -149,7 +149,7 @@ fn parse_ty(@pstate st, str_def sd) -> ty.t {
             ret ty.mk_native_fn(st.tcx,abi,func._0,func._1);
         }
         case ('O') {
-            assert (next(st) as char == '[');
+            check(next(st) as char == '[');
             let vec[ty.method] methods = vec();
             while (peek(st) as char != ']') {
                 auto proto;
@@ -175,9 +175,9 @@ fn parse_ty(@pstate st, str_def sd) -> ty.t {
         case ('Y') { ret ty.mk_type(st.tcx); }
         case ('#') {
             auto pos = parse_hex(st);
-            assert (next(st) as char == ':');
+            check (next(st) as char == ':');
             auto len = parse_hex(st);
-            assert (next(st) as char == '#');
+            check (next(st) as char == '#');
             alt (st.tcx.rcache.find(tup(st.crate,pos,len))) {
                 case (some[ty.t](?tt)) { ret tt; }
                 case (none[ty.t]) {
@@ -245,7 +245,7 @@ fn parse_hex(@pstate st) -> uint {
 }
 
 fn parse_ty_fn(@pstate st, str_def sd) -> tup(vec[ty.arg], ty.t) {
-    assert (next(st) as char == '[');
+    check(next(st) as char == '[');
     let vec[ty.arg] inputs = vec();
     while (peek(st) as char != ']') {
         auto mode = ast.val;
diff --git a/src/comp/front/lexer.rs b/src/comp/front/lexer.rs
index dabdee1c..3659af1c 100644
--- a/src/comp/front/lexer.rs
+++ b/src/comp/front/lexer.rs
@@ -127,7 +127,6 @@ fn keyword_table() -> std.map.hashmap[str, token.token] {
 
     keywords.insert("type", token.TYPE);
     keywords.insert("check", token.CHECK);
-    keywords.insert("assert", token.ASSERT);
     keywords.insert("claim", token.CLAIM);
     keywords.insert("prove", token.PROVE);
 
@@ -529,7 +528,7 @@ fn scan_numeric_escape(reader rdr) -> char {
 
     auto n_hex_digits = 0;
 
-    assert (rdr.curr() == '\\');
+    check (rdr.curr() == '\\');
 
     alt (rdr.next()) {
         case ('x') { n_hex_digits = 2; }
diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs
index 3e8ca85a..fdd41cf0 100644
--- a/src/comp/front/parser.rs
+++ b/src/comp/front/parser.rs
@@ -621,7 +621,7 @@ fn parse_path(parser p, greed g) -> ast.path {
                 if (p.peek() == token.DOT) {
                     if (g == GREEDY) {
                         p.bump();
-                        assert (is_ident(p.peek()));
+                        check (is_ident(p.peek()));
                     } else {
                         more = false;
                     }
@@ -816,22 +816,19 @@ fn parse_bottom_expr(parser p) -> @ast.expr {
             ex = ast.expr_log(0, e, ast.ann_none);
         }
 
-        case (token.ASSERT) {
-            p.bump();
-            auto e = parse_expr(p);
-            auto hi = e.span.hi;
-            ex = ast.expr_assert(e, ast.ann_none);
-        }
-
         case (token.CHECK) {
             p.bump();
-            /* Should be a predicate (pure boolean function) applied to 
-             arguments that are all either slot variables or literals.
-            but the typechecker enforces that. */
-            auto e = parse_expr(p);
-            auto hi = e.span.hi;
-            ex = ast.expr_check(e, ast.ann_none);
-        } 
+            alt (p.peek()) {
+                case (token.LPAREN) {
+                    auto e = parse_expr(p);
+                    auto hi = e.span.hi;
+                    ex = ast.expr_check_expr(e, ast.ann_none);
+                }
+                case (_) {
+                    p.get_session().unimpl("constraint-check stmt");
+                }
+            }
+        }
 
         case (token.RET) {
             p.bump();
@@ -940,7 +937,7 @@ fn expand_syntax_ext(parser p, ast.span sp,
                      &ast.path path, vec[@ast.expr] args,
                      option.t[str] body) -> ast.expr_ {
 
-    assert (_vec.len[ast.ident](path.node.idents) > 0u);
+    check (_vec.len[ast.ident](path.node.idents) > 0u);
     auto extname = path.node.idents.(0);
     if (_str.eq(extname, "fmt")) {
         auto expanded = extfmt.expand_syntax_ext(args, body);
@@ -1676,8 +1673,7 @@ fn stmt_ends_with_semi(@ast.stmt stmt) -> bool {
                 case (ast.expr_put(_,_))        { ret true; }
                 case (ast.expr_be(_,_))         { ret true; }
                 case (ast.expr_log(_,_,_))        { ret true; }
-                case (ast.expr_check(_,_)) { ret true; }
-                case (ast.expr_assert(_,_)) { ret true; }
+                case (ast.expr_check_expr(_,_)) { ret true; }
             }
         }
         // We should not be calling this on a cdir.
@@ -2161,24 +2157,24 @@ fn parse_item(parser p) -> @ast.item {
 
     alt (p.peek()) {
         case (token.CONST) {
-            assert (lyr == ast.layer_value);
+            check (lyr == ast.layer_value);
             ret parse_item_const(p);
         }
 
         case (token.FN) {
-            assert (lyr == ast.layer_value);
+            check (lyr == ast.layer_value);
             ret parse_item_fn_or_iter(p);
         }
         case (token.ITER) {
-            assert (lyr == ast.layer_value);
+            check (lyr == ast.layer_value);
             ret parse_item_fn_or_iter(p);
         }
         case (token.MOD) {
-            assert (lyr == ast.layer_value);
+            check (lyr == ast.layer_value);
             ret parse_item_mod(p);
         }
         case (token.NATIVE) {
-            assert (lyr == ast.layer_value);
+            check (lyr == ast.layer_value);
             ret parse_item_native_mod(p);
         }
         case (token.TYPE) {
diff --git a/src/comp/front/token.rs b/src/comp/front/token.rs
index 594515f2..f367bcc6 100644
--- a/src/comp/front/token.rs
+++ b/src/comp/front/token.rs
@@ -89,7 +89,6 @@ tag token {
 
     /* Type and type-state keywords */
     TYPE;
-    ASSERT;
     CHECK;
     CLAIM;
     PROVE;
@@ -259,7 +258,6 @@ fn to_str(token t) -> str {
 
         /* Type and type-state keywords */
         case (TYPE) { ret "type"; }
-        case (ASSERT) { ret "assert"; }
         case (CHECK) { ret "check"; }
         case (CLAIM) { ret "claim"; }
         case (PROVE) { ret "prove"; }