Beginnings of support for constrained types

Programs with constrained types now parse and typecheck, but
typestate doesn't check them specially, so the one relevant test
case so far is XFAILed.

Also rewrote all of the constraint-related data structures in the
process (again), for some reason. I got rid of a superfluous
data structure in the context that was mapping front-end constraints
to resolved constraints, instead handling constraints in the same
way in which everything else gets resolved.

Author: catamorphism

src/comp/driver/rustc.rs

@@ -134,8 +134,8 @@ fn compile_input(session::session sess, ast::crate_cfg cfg, str input,
              bind resolve::resolve_crate(sess, ast_map, crate));
     auto freevars =
         time(time_passes, "freevar finding",
-             bind freevars::annotate_freevars(sess, d._0, crate));
-    auto ty_cx = ty::mk_ctxt(sess, d._0, d._1, ast_map, freevars);
+             bind freevars::annotate_freevars(sess, d, crate));
+    auto ty_cx = ty::mk_ctxt(sess, d, ast_map, freevars);
     time[()](time_passes, "typechecking",
              bind typeck::check_crate(ty_cx, crate));
     if (sess.get_opts().run_typestate) {
@@ -200,8 +200,8 @@ fn pretty_print_input(session::session sess, ast::crate_cfg cfg,
         case (ppm_typed) {
             auto amap = middle::ast_map::map_crate(*crate);
             auto d = resolve::resolve_crate(sess, amap, crate);
-            auto freevars = freevars::annotate_freevars(sess, d._0, crate);
-            auto ty_cx = ty::mk_ctxt(sess, d._0, d._1, amap, freevars);
+            auto freevars = freevars::annotate_freevars(sess, d, crate);
+            auto ty_cx = ty::mk_ctxt(sess, d, amap, freevars);
             typeck::check_crate(ty_cx, crate);
             ann = rec(pre=ann_paren_for_expr,
                       post=bind ann_typed_post(ty_cx, _));

src/comp/metadata/tydecode.rs

@@ -7,6 +7,7 @@ import std::option;
 import std::option::none;
 import std::option::some;
 import syntax::ast;
+import syntax::ast::*;
 import ast::respan;
 import middle::ty;
 
@@ -65,13 +66,15 @@ fn parse_ty_or_bang(@pstate st, str_def sd) -> ty_or_bang {
     }
 }
 
-fn parse_constrs(@pstate st, str_def sd) -> (@ty::constr_def)[] {
-    let (@ty::constr_def)[] rslt = ~[];
+fn parse_constrs(@pstate st, str_def sd) -> (@ty::constr)[] {
+    let (@ty::constr)[] rslt = ~[];
     alt (peek(st) as char) {
         case (':') {
-            do  {
+            do {
                 next(st);
-                rslt += ~[parse_constr(st, sd)];
+                let @ty::constr one = parse_constr[uint](st, sd,
+                                                         parse_constr_arg);
+                rslt += ~[one];
             } while (peek(st) as char == ';')
         }
         case (_) { }
@@ -102,40 +105,50 @@ fn parse_path(@pstate st, str_def sd) -> ast::path {
     fail "parse_path: ill-formed path";
 }
 
-fn parse_constr(@pstate st, str_def sd) -> @ty::constr_def {
-    let (@ast::constr_arg)[] args = ~[];
+type arg_parser[T] = fn (@pstate st, str_def sd)
+                       -> ast::constr_arg_general_[T];
+
+fn parse_constr_arg(@pstate st, str_def sd) -> ast::fn_constr_arg {
+     alt (peek(st) as char) {
+      case ('*') {
+        st.pos += 1u;
+        ret ast::carg_base;
+      }
+      case (?c) {
+        /* how will we disambiguate between
+           an arg index and a lit argument? */
+        if (c >= '0' && c <= '9') {
+            next(st);
+          // FIXME
+          ret ast::carg_ident((c as uint) - 48u);
+        }
+        else {
+          log_err("Lit args are unimplemented");
+          fail; // FIXME
+        }
+        /*
+          else {
+          auto lit = parse_lit(st, sd, ',');
+          args += [respan(st.span, ast::carg_lit(lit))];
+          }
+        */
+      }
+    }
+}
+
+fn parse_constr[T](@pstate st, str_def sd, arg_parser[T] pser)
+    -> @ty::constr_general[T] {
     auto sp = rec(lo=0u,hi=0u); // FIXME: use a real span
-    let ast::path pth = parse_path(st, sd);
+    let (@sp_constr_arg[T])[] args = ~[];
+    let path pth = parse_path(st, sd);
     let char ignore = next(st) as char;
     assert(ignore as char == '(');
     auto def = parse_def(st, sd);
+    let constr_arg_general_[T] an_arg;
     do {
-        alt (peek(st) as char) {
-            case ('*') {
-                st.pos += 1u;
-                args += ~[@respan(sp, ast::carg_base)];
-            }
-            case (?c) {
-                /* how will we disambiguate between
-                 an arg index and a lit argument? */
-                if (c >= '0' && c <= '9') {
-                    // FIXME
-                    args += ~[@respan(sp,
-                                      ast::carg_ident((c as uint) - 48u))];
-                    ignore = next(st) as char;
-                }
-                else {
-                    log_err("Lit args are unimplemented");
-                    fail; // FIXME
-                }
-                /*
-                else {
-                    auto lit = parse_lit(st, sd, ',');
-                    args += [respan(st.span, ast::carg_lit(lit))];
-                }
-                */
-            }
-        }
+        an_arg = pser(st, sd);
+        // FIXME use a real span
+        args += ~[@respan(sp, an_arg)];
         ignore = next(st) as char;
     } while (ignore == ';');
     assert(ignore == ')');
@@ -335,7 +348,7 @@ fn parse_hex(@pstate st) -> uint {
 }
 
 fn parse_ty_fn(@pstate st, str_def sd) ->
-   tup(ty::arg[], ty::t, ast::controlflow, (@ty::constr_def)[]) {
+   tup(ty::arg[], ty::t, ast::controlflow, (@ty::constr)[]) {
     assert (next(st) as char == '[');
     let ty::arg[] inputs = ~[];
     while (peek(st) as char != ']') {
@@ -384,3 +397,14 @@ fn parse_def_id(&u8[] buf) -> ast::def_id {
     auto def_id = uint::parse_buf(def_part_vec, 10u) as int;
     ret tup(crate_num, def_id);
 }
+
+//
+// Local Variables:
+// mode: rust
+// fill-column: 78;
+// indent-tabs-mode: nil
+// c-basic-offset: 4
+// buffer-file-coding-system: utf-8-unix
+// compile-command: "make -k -C $RBUILD 2>&1 | sed -e 's/\\/x\\//x:\\//g'";
+// End:
+//

src/comp/metadata/tyencode.rs

@@ -8,7 +8,7 @@ import std::int;
 import std::uint;
 import syntax::ast::*;
 import middle::ty;
-import syntax::print::pprust::lit_to_str;
+import syntax::print::pprust::*;
 import util::common;
 
 export ctxt;
@@ -199,8 +199,9 @@ fn enc_proto(&ioivec::writer w, proto proto) {
         case (proto_fn) { w.write_char('F'); }
     }
 }
+
 fn enc_ty_fn(&ioivec::writer w, &@ctxt cx, &ty::arg[] args, &ty::t out,
-             &controlflow cf, &(@ty::constr_def)[] constrs) {
+             &controlflow cf, &(@ty::constr)[] constrs) {
     w.write_char('[');
     for (ty::arg arg in args) {
         alt (arg.mode) {
@@ -214,7 +215,7 @@ fn enc_ty_fn(&ioivec::writer w, &@ctxt cx, &ty::arg[] args, &ty::t out,
     }
     w.write_char(']');
     auto colon = true;
-    for (@ty::constr_def c in constrs) {
+    for (@ty::constr c in constrs) {
         if (colon) {
             w.write_char(':');
             colon = false;
@@ -227,7 +228,8 @@ fn enc_ty_fn(&ioivec::writer w, &@ctxt cx, &ty::arg[] args, &ty::t out,
     }
 
 }
-fn enc_constr(&ioivec::writer w, &@ctxt cx, &@ty::constr_def c) {
+
+fn enc_constr(&ioivec::writer w, &@ctxt cx, &@ty::constr c) {
     w.write_str(path_to_str(c.node.path));
     w.write_char('(');
     w.write_str(cx.ds(c.node.id));

src/comp/middle/resolve.rs

@@ -1,5 +1,6 @@
 
 import syntax::ast;
+import syntax::ast::*;
 import ast::ident;
 import ast::fn_ident;
 import ast::def;
@@ -19,6 +20,7 @@ import middle::ty::constr_table;
 import syntax::visit;
 import visit::vt;
 import std::ivec;
+import std::int;
 import std::map::hashmap;
 import std::list;
 import std::list::list;
@@ -28,6 +30,7 @@ import std::option;
 import std::option::some;
 import std::option::none;
 import std::str;
+import syntax::print::pprust::*;
 
 export resolve_crate;
 export def_map;
@@ -109,7 +112,6 @@ type def_map = hashmap[node_id, def];
 type env =
     rec(cstore::cstore cstore,
         def_map def_map,
-        constr_table fn_constrs,
         ast_map::map ast_map,
         hashmap[ast::node_id, import_state] imports,
         hashmap[ast::node_id, @indexed_mod] mod_map,
@@ -124,12 +126,11 @@ tag dir { inside; outside; }
 
 tag namespace { ns_value; ns_type; ns_module; }
 
-fn resolve_crate(session sess, &ast_map::map amap, @ast::crate crate) ->
-   tup(def_map, constr_table) {
+fn resolve_crate(session sess, &ast_map::map amap, @ast::crate crate)
+  -> def_map {
     auto e =
         @rec(cstore=sess.get_cstore(),
              def_map=new_int_hash[def](),
-             fn_constrs = new_int_hash[ty::constr_def[]](),
              ast_map=amap,
              imports=new_int_hash[import_state](),
              mod_map=new_int_hash[@indexed_mod](),
@@ -140,7 +141,7 @@ fn resolve_crate(session sess, &ast_map::map amap, @ast::crate crate) ->
     resolve_imports(*e);
     check_for_collisions(e, *crate);
     resolve_names(e, crate);
-    ret tup(e.def_map, e.fn_constrs);
+    ret e.def_map;
 }
 
 
@@ -249,7 +250,7 @@ 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_constr=bind walk_constr(e, _, _, _),
+             visit_constr=bind walk_constr(e, _, _, _, _, _),
              visit_fn=bind visit_fn_with_scope(e, _, _, _, _, _, _, _)
              with *visit::default_visitor());
     visit::visit_crate(*c, cons(scope_crate, @nil), visit::mk_vt(v));
@@ -277,10 +278,9 @@ fn resolve_names(&@env e, &@ast::crate c) {
             case (_) { }
         }
     }
-    fn walk_constr(@env e, &@ast::constr c, &scopes sc, &vt[scopes] v) {
-        maybe_insert(e, c.node.id,
-                     lookup_path_strict(*e, sc, c.span, c.node.path.node,
-                                        ns_value));
+    fn walk_constr(@env e, &ast::path p, &span sp, node_id id,
+                   &scopes sc, &vt[scopes] v) {
+        maybe_insert(e, id, lookup_path_strict(*e, sc, sp, p.node, ns_value));
     }
     fn walk_arm(@env e, &ast::arm a, &scopes sc, &vt[scopes] v) {
         for (@ast::pat p in a.pats) { walk_pat(*e, sc, p); }
@@ -411,29 +411,18 @@ fn resolve_constr(@env e, node_id id, &@ast::constr c, &scopes sc,
     if (option::is_some(new_def)) {
         alt (option::get(new_def)) {
             case (ast::def_fn(?pred_id, ast::pure_fn)) {
-                let ty::constr_general[uint] c_ =
-                    rec(path=c.node.path, args=c.node.args, id=pred_id);
-                let ty::constr_def new_constr = respan(c.span, c_);
-                add_constr(e, id, new_constr);
+                e.def_map.insert(c.node.id, ast::def_fn(pred_id,
+                                                        ast::pure_fn));
             }
             case (_) {
                 e.sess.span_err(c.span,
                                 "Non-predicate in constraint: " +
-                                ast::path_to_str(c.node.path));
+                                path_to_str(c.node.path));
             }
         }
     }
 }
 
-fn add_constr(&@env e, node_id id, &ty::constr_def c) {
-    e.fn_constrs.insert(id,
-                        alt (e.fn_constrs.find(id)) {
-                            case (none) { ~[c] }
-                            case (some(?cs)) { cs + ~[c] }
-                        });
-}
-
-
 // Import resolution
 fn resolve_import(&env e, &@ast::view_item it, scopes sc) {
     auto defid;