---

yaml
---
r: 2309
b: refs/heads/master
c: d08b443
h: refs/heads/master
i:
  2307: 9d60e70
v: v3

Author: graydon

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 764de078e7c4baaf0a1f426e7ac4d834c2ea8797
+refs/heads/master: d08b443fffb1181d8d45ae5d061412f202dd4118

trunk/src/boot/fe/item.ml

@@ -199,14 +199,6 @@ and parse_stmts_including_none (ps:pstate) : Ast.stmt array =
           bump ps;
           expect ps SEMI;
           [| span ps apos (lexpos ps) Ast.STMT_cont |]
-      | ASSERT ->
-          bump ps;
-          let (stmts, expr) =
-             ctxt "stmts: check value" parse_expr ps
-          in
-              expect ps SEMI;
-              spans ps stmts apos (Ast.STMT_check_expr expr)
-(* leaving check as it is; adding assert as a synonym for the "old" check *)
       | CHECK ->
           bump ps;
           begin

trunk/src/boot/fe/lexer.mll

@@ -92,7 +92,6 @@
 
                 ("type", TYPE);
                 ("check", CHECK);
-                ("assert", ASSERT); 
                 ("claim", CLAIM);
                 ("prove", PROVE);
 

trunk/src/boot/fe/token.ml

@@ -77,7 +77,6 @@ type token =
   (* Type and type-state keywords *)
   | TYPE
   | CHECK
-  | ASSERT
   | CLAIM
   | PROVE
 
@@ -238,7 +237,6 @@ let rec string_of_tok t =
     (* Type and type-state keywords *)
     | TYPE       -> "type"
     | CHECK      -> "check"
-    | ASSERT     -> "assert"
     | CLAIM      -> "claim"
     | PROVE      -> "prove"
 

trunk/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);
 }

trunk/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;

trunk/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; }

trunk/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) {

trunk/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"; }