Reject programs with unsatisfied predicate constraints

Generate appropriate constraints for calls to functions with
preconditions, and reject calls where those constraints don't
hold true in the prestate.

...by which I mean that it works for one test case :-)

Author: catamorphism

src/comp/front/ast.rs

@@ -355,14 +355,31 @@ tag ty_ {
     ty_constr(@ty, vec[@constr]);
 }
 
-tag constr_arg_ {
+/*
+A constraint arg that's a function argument is referred to by its position
+rather than name.  This is so we could have higher-order functions that have
+constraints (potentially -- right now there's no way to write that), and also
+so that the typestate pass doesn't have to map a function name onto its decl.
+So, the constr_arg type is parameterized: it's instantiated with uint for
+declarations, and ident for uses.
+*/
+tag constr_arg_general_[T] {
     carg_base;
-    carg_ident(ident);
+    carg_ident(T); 
     carg_lit(@lit);
 }
-type constr_arg = spanned[constr_arg_];
-type constr_ = rec(path path, vec[@constr_arg] args);
-type constr = spanned[constr_];
+type constr_arg = constr_arg_general[uint];
+type constr_arg_use = constr_arg_general[ident];
+type constr_arg_general[T] = spanned[constr_arg_general_[T]];
+
+// The ann field is there so that using the def_map in the type
+// context, we can get the def_id for the path.
+type constr_general[T] = rec(path path,
+                             vec[@constr_arg_general[T]] args,
+                             ann ann);
+
+type constr = spanned[constr_general[uint]];
+type constr_use = spanned[constr_general[ident]];
 
 type arg = rec(mode mode, @ty ty, ident ident, def_id id);
 type fn_decl = rec(vec[arg] inputs,

src/comp/front/creader.rs

@@ -94,6 +94,9 @@ fn parse_constrs(@pstate st, str_def sd) -> vec[@ast::constr] {
 }
 
 fn parse_constr(@pstate st, str_def sd) -> @ast::constr {
+    st.tcx.sess.unimpl("Reading constraints "
+                   + " isn't implemented");
+    /*
     let vec[@ast::constr_arg] args = [];
     auto sp = rec(lo=0u,hi=0u); // FIXME
     let vec[ast::ident] ids = [];
@@ -105,6 +108,7 @@ fn parse_constr(@pstate st, str_def sd) -> @ast::constr {
     log_err(p1);
     let char ignore = next(st) as char;
     assert(ignore as char == '(');
+    auto def = parse_def(st, sd);
     do {
         alt (peek(st) as char) {
             case ('*') {
@@ -132,7 +136,7 @@ fn parse_constr(@pstate st, str_def sd) -> @ast::constr {
         }
     } while (next(st) as char == ',');
     ignore = next(st) as char;
-    ret @respan(sp, rec(path=pth, args=args));
+    */
 }
 
 fn parse_ty(@pstate st, str_def sd) -> ty::t {

src/comp/front/parser.rs

@@ -339,7 +339,7 @@ fn parse_ty_fn(ast::proto proto, &parser p, uint lo)
     auto inputs = parse_seq(token::LPAREN, token::RPAREN,
                             some(token::COMMA), parse_fn_input_ty, p);
 
-    auto constrs = parse_constrs(p);
+    auto constrs = parse_constrs([], p);
 
     let @ast::ty output;
     auto cf = ast::return;
@@ -409,35 +409,57 @@ fn parse_ty_field(&parser p) -> ast::ty_field {
     ret spanned(lo, mt.ty.span.hi, rec(ident=id, mt=mt));
 }
 
-fn parse_constr_arg(&parser p) -> @ast::constr_arg {
+// if i is the jth ident in args, return j
+// otherwise, fail
+fn ident_index(&parser p, &vec[ast::arg] args, &ast::ident i) -> uint {
+    auto j = 0u;
+    for (ast::arg a in args) {
+        if (a.ident == i) {
+            ret j;
+        }
+        j += 1u;
+    }
+    p.get_session().span_err(p.get_span(),
+      "Unbound variable " + i + " in constraint arg");
+}
+
+fn parse_constr_arg(vec[ast::arg] args, &parser p) -> @ast::constr_arg {
     auto sp = p.get_span();
     auto carg = ast::carg_base;
     if (p.peek() == token::BINOP(token::STAR)) {
         p.bump();
     } else {
-        carg = ast::carg_ident(parse_value_ident(p));
+        let ast::ident i = parse_value_ident(p);
+        carg = ast::carg_ident(ident_index(p, args, i));
     }
     ret @rec(node=carg, span=sp);
 }
 
-fn parse_ty_constr(&parser p) -> @ast::constr {
+fn parse_ty_constr(&vec[ast::arg] fn_args, &parser p) -> @ast::constr {
     auto lo = p.get_lo_pos();
     auto path = parse_path(p);
-    auto pf = parse_constr_arg;
-    auto args = parse_seq[@ast::constr_arg](token::LPAREN,
+    auto pf = bind parse_constr_arg(fn_args, _);
+    let rec(vec[@ast::constr_arg] node, span span) args =
+         parse_seq[@ast::constr_arg](token::LPAREN,
                                          token::RPAREN,
                                          some(token::COMMA), pf, p);
-    ret @spanned(lo, args.span.hi, rec(path=path, args=args.node));
+    // FIXME fix the def_id
+    ret @spanned(lo, args.span.hi,
+                 rec(path=path, args=args.node, ann=p.get_ann()));
 }
 
-fn parse_constrs(&parser p) -> common::spanned[vec[@ast::constr]] {
+// Use the args list to translate each bound variable 
+// mentioned in a constraint to an arg index.
+// Seems weird to do this in the parser, but I'm not sure how else to.
+fn parse_constrs(&vec[ast::arg] args, 
+                 &parser p) -> common::spanned[vec[@ast::constr]] {
     auto lo = p.get_lo_pos();
     auto hi = p.get_hi_pos();
     let vec[@ast::constr] constrs = [];
     if (p.peek() == token::COLON) {
         p.bump();
         while (true) {
-            auto constr = parse_ty_constr(p);
+            auto constr = parse_ty_constr(args, p);
             hi = constr.span.hi;
             vec::push[@ast::constr](constrs, constr);
             if (p.peek() == token::COMMA) {
@@ -452,7 +474,7 @@ fn parse_constrs(&parser p) -> common::spanned[vec[@ast::constr]] {
 
 fn parse_ty_constrs(@ast::ty t, &parser p) -> @ast::ty {
    if (p.peek() == token::COLON) {
-       auto constrs = parse_constrs(p);
+       auto constrs = parse_constrs([], p);
        ret @spanned(t.span.lo, constrs.span.hi,
                     ast::ty_constr(t, constrs.node));
    }
@@ -1768,7 +1790,7 @@ fn parse_fn_decl(&parser p, ast::purity purity) -> ast::fn_decl {
 
     let ty_or_bang res;
 
-    auto constrs = parse_constrs(p).node;
+    auto constrs = parse_constrs(inputs.node, p).node;
 
     if (p.peek() == token::RARROW) {
         p.bump();

src/comp/middle/metadata.rs

@@ -286,6 +286,8 @@ mod Encode {
     fn enc_constr(&io::writer w, &@ctxt cx, &@ast::constr c) {
         w.write_str(path_to_str(c.node.path));
         w.write_char('(');
+        // FIXME
+        //   w.write_str(cx.ds(c.node.id));
         auto comma = false;
         for (@constr_arg a in c.node.args) {
             if (comma) {
@@ -299,7 +301,7 @@ mod Encode {
                     w.write_char('*');
                 }
                 case (carg_ident(?i)) {
-                    w.write_str(i);
+                    w.write_uint(i);
                 }
                 case (carg_lit(?l)) {
                     w.write_str(lit_to_str(l));

src/comp/middle/resolve.rs

@@ -254,7 +254,8 @@ fn resolve_names(&@env e, &@ast::crate c) {
                   visit_arm = bind walk_arm(e, _, _, _),
                   visit_expr = bind walk_expr(e, _, _, _),
                   visit_ty = bind walk_ty(e, _, _, _),
-                  visit_fn = visit_fn_with_scope
+                  visit_fn = visit_fn_with_scope,
+                  visit_constr = bind walk_constr(e, _, _, _)
                   with *visit::default_visitor());
     visit::visit_crate(*c, cons(scope_crate(c), @nil),
                        visit::vtor(v));
@@ -270,6 +271,14 @@ fn resolve_names(&@env e, &@ast::crate c) {
             case (_) {}
         }
     }
+
+    fn walk_constr(@env e, &@ast::constr c, &scopes sc, &vt[scopes] v) {
+        auto new_def = lookup_path_strict(*e, sc, c.span,
+                                          c.node.path.node.idents,
+                                          ns_value);
+        e.def_map.insert(c.node.ann.id, new_def);
+    }
+
     fn walk_ty(@env e, &@ast::ty t, &scopes sc, &vt[scopes] v) {
         visit::visit_ty(t, sc, v);
         alt (t.node) {