From 4f892dd9d732f215192f94b28392f26e88f0861e Mon Sep 17 00:00:00 2001
From: Tim Chevalier <chevalier@alum.wellesley.edu>
Date: Mon, 2 May 2011 13:47:41 -0700
Subject: Check that the operand in a check is a call

In addition, fix bug in fold that was turning asserts into checks.

More typechecking still needs to be done.
---
 src/comp/middle/fold.rs   |  2 +-
 src/comp/middle/typeck.rs | 25 ++++++++++++++++++-------
 2 files changed, 19 insertions(+), 8 deletions(-)

(limited to 'src/comp')

diff --git a/src/comp/middle/fold.rs b/src/comp/middle/fold.rs
index e932fd9a..49b6290c 100644
--- a/src/comp/middle/fold.rs
+++ b/src/comp/middle/fold.rs
@@ -1396,7 +1396,7 @@ fn identity_fold_expr_check[ENV](&ENV e, &span sp, @expr x, ann a)
 
 fn identity_fold_expr_assert[ENV](&ENV e, &span sp, @expr x, ann a)
     -> @expr {
-    ret @respan(sp, ast.expr_check(x, a));
+    ret @respan(sp, ast.expr_assert(x, a));
 }
 
 fn identity_fold_expr_port[ENV](&ENV e, &span sp, ann a) -> @expr {
diff --git a/src/comp/middle/typeck.rs b/src/comp/middle/typeck.rs
index ec50fd84..fd915108 100644
--- a/src/comp/middle/typeck.rs
+++ b/src/comp/middle/typeck.rs
@@ -9,6 +9,8 @@ import util.common;
 import util.common.span;
 import util.common.plain_ann;
 
+import util.common.log_expr_err;
+
 import middle.ty;
 import middle.ty.ann_to_type;
 import middle.ty.arg;
@@ -1955,16 +1957,25 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr {
         }
 
         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_t,
-                                                plain_ann(fcx.ccx.tcx)));
+            /* e must be a call expr where all arguments are either
+             literals or slots */
+            alt (e.node) {
+                case (ast.expr_call(?operator, ?operands, _)) {
+                    /* operator must be a pure function */
+                    /* FIXME: need more checking */
+                    ret @fold.respan[ast.expr_]
+                        (expr.span, ast.expr_check(expr_t,
+                               plain_ann(fcx.ccx.tcx)));
+                    
+                }
+                case (_) {
+                    fcx.ccx.sess.span_err(expr.span,
+                        "Check on non-predicate");
+                }
+            }
         }
 
         case (ast.expr_assert(?e, _)) {
-- 
cgit v1.2.3