Refactor data structures representing constraints (again...)

I added a "resolved" version of the ast::constr type -- ty::constr_def
-- that has a def_id field instead of an ann_field. This is more
consistent with other types and eliminates some checking.

Incidentally, I removed the def_map argument to the top-level function
in middle::alias, since the ty::ctxt already has a def_map field.

Author: catamorphism

src/comp/driver/rustc.rs

@@ -81,18 +81,18 @@ fn compile_input(session::session sess, eval::env env, str input,
     auto crate =
         time(time_passes, "parsing", bind parse_input(sess, p, input));
     if (sess.get_opts().output_type == link::output_type_none) { ret; }
-    auto def_map =
+    auto d =
         time(time_passes, "resolution",
              bind resolve::resolve_crate(sess, crate));
-    auto ty_cx = ty::mk_ctxt(sess, def_map);
+    auto ty_cx = ty::mk_ctxt(sess, d._0, d._1);
     time[()](time_passes, "typechecking",
              bind typeck::check_crate(ty_cx, crate));
     if (sess.get_opts().run_typestate) {
         time(time_passes, "typestate checking",
              bind middle::tstate::ck::check_crate(ty_cx, crate));
     }
     time(time_passes, "alias checking",
-         bind middle::alias::check_crate(@ty_cx, def_map, crate));
+         bind middle::alias::check_crate(@ty_cx, crate));
     auto llmod =
         time[llvm::llvm::ModuleRef](time_passes, "translation",
                                     bind trans::trans_crate(sess, crate,
@@ -109,8 +109,8 @@ fn pretty_print_input(session::session sess, eval::env env, str input,
     auto mode;
     alt (ppm) {
         case (ppm_typed) {
-            auto def_map = resolve::resolve_crate(sess, crate);
-            auto ty_cx = ty::mk_ctxt(sess, def_map);
+            auto d = resolve::resolve_crate(sess, crate);
+            auto ty_cx = ty::mk_ctxt(sess, d._0, d._1);
             typeck::check_crate(ty_cx, crate);
             mode = ppaux::mo_typed(ty_cx);
         }

src/comp/front/ast.rs

@@ -359,19 +359,17 @@ tag constr_arg_general_[T] { carg_base; carg_ident(T); carg_lit(@lit); }
 
 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]];
 
+type constr_ = rec(path path,
+                   vec[@constr_arg_general[uint]] args,
+                   ann ann);
 
-// 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 = spanned[constr_];
 
-type constr_use = spanned[constr_general[ident]];
+/* The parser generates ast::constrs; resolve generates
+ a mapping from each function to a list of ty::constr_defs,
+ corresponding to these. */
 
 type arg = rec(mode mode, @ty ty, ident ident, def_id id);
 

src/comp/front/creader.rs

@@ -78,8 +78,8 @@ fn parse_ty_or_bang(@pstate st, str_def sd) -> ty_or_bang {
     }
 }
 
-fn parse_constrs(@pstate st, str_def sd) -> vec[@ast::constr] {
-    let vec[@ast::constr] res = [];
+fn parse_constrs(@pstate st, str_def sd) -> vec[@ty::constr_def] {
+    let vec[@ty::constr_def] res = [];
     alt (peek(st) as char) {
         case (':') {
             do  {
@@ -92,7 +92,7 @@ fn parse_constrs(@pstate st, str_def sd) -> vec[@ast::constr] {
     ret res;
 }
 
-fn parse_constr(@pstate st, str_def sd) -> @ast::constr {
+fn parse_constr(@pstate st, str_def sd) -> @ty::constr_def {
     st.tcx.sess.unimpl("Reading constraints " + " isn't implemented");
     /*
     let vec[@ast::constr_arg] args = [];
@@ -318,7 +318,7 @@ fn parse_hex(@pstate st) -> uint {
 }
 
 fn parse_ty_fn(@pstate st, str_def sd) ->
-   tup(vec[ty::arg], ty::t, ast::controlflow, vec[@ast::constr]) {
+   tup(vec[ty::arg], ty::t, ast::controlflow, vec[@ty::constr_def]) {
     assert (next(st) as char == '[');
     let vec[ty::arg] inputs = [];
     while (peek(st) as char != ']') {

src/comp/middle/alias.rs

@@ -35,14 +35,11 @@ tag local_info { arg(ast::mode); objfield(ast::mutability); }
 
 type ctx =
     rec(@ty::ctxt tcx,
-        resolve::def_map dm,
         std::map::hashmap[def_num, local_info] local_map);
 
-fn check_crate(@ty::ctxt tcx, resolve::def_map dm, &@ast::crate crate) {
+fn check_crate(@ty::ctxt tcx, &@ast::crate crate) {
     auto cx =
         @rec(tcx=tcx,
-             dm=dm,
-
              // Stores information about object fields and function
              // arguments that's otherwise not easily available.
              local_map=util::common::new_int_hash());
@@ -173,7 +170,7 @@ fn check_call(&ctx cx, &@ast::expr f, &vec[@ast::expr] args, &scope sc) ->
     if (vec::len(unsafe_ts) > 0u) {
         alt (f.node) {
             case (ast::expr_path(_, ?ann)) {
-                if (def_is_local(cx.dm.get(ann.id), true)) {
+                if (def_is_local(cx.tcx.def_map.get(ann.id), true)) {
                     cx.tcx.sess.span_err
                         (f.span, #fmt("function may alias with argument \
                          %u, which is not immutably rooted",
@@ -231,7 +228,7 @@ fn check_tail_call(&ctx cx, &@ast::expr call) {
             auto ok = true;
             alt (args.(i).node) {
                 case (ast::expr_path(_, ?ann)) {
-                    auto def = cx.dm.get(ann.id);
+                    auto def = cx.tcx.def_map.get(ann.id);
                     auto dnum = ast::def_id_of_def(def)._1;
                     alt (cx.local_map.find(dnum)) {
                         case (some(arg(ast::alias(?mut)))) {
@@ -353,7 +350,7 @@ fn check_for(&ctx cx, &@ast::local local, &@ast::expr seq, &ast::block block,
 
 fn check_var(&ctx cx, &@ast::expr ex, &ast::path p, ast::ann ann, bool assign,
              &scope sc) {
-    auto def = cx.dm.get(ann.id);
+    auto def = cx.tcx.def_map.get(ann.id);
     if (!def_is_local(def, true)) { ret; }
     auto my_defnum = ast::def_id_of_def(def)._1;
     auto var_t = ty::expr_ty(*cx.tcx, ex);
@@ -379,7 +376,7 @@ fn check_assign(&@ctx cx, &@ast::expr dest, &@ast::expr src, &scope sc,
     visit_expr(cx, src, sc, v);
     alt (dest.node) {
         case (ast::expr_path(?p, ?ann)) {
-            auto dnum = ast::def_id_of_def(cx.dm.get(ann.id))._1;
+            auto dnum = ast::def_id_of_def(cx.tcx.def_map.get(ann.id))._1;
             if (is_immutable_alias(cx, sc, dnum)) {
                 cx.tcx.sess.span_err(dest.span,
                                      "assigning to immutable alias");
@@ -566,7 +563,7 @@ fn inner_mut(&vec[deref] ds) -> option::t[ty::t] {
 fn path_def_id(&ctx cx, &@ast::expr ex) -> option::t[ast::def_id] {
     alt (ex.node) {
         case (ast::expr_path(_, ?ann)) {
-            ret some(ast::def_id_of_def(cx.dm.get(ann.id)));
+            ret some(ast::def_id_of_def(cx.tcx.def_map.get(ann.id)));
         }
         case (_) { ret none; }
     }

src/comp/middle/metadata.rs

@@ -221,8 +221,7 @@ mod Encode {
                     case (ast::native_abi_cdecl) { w.write_char('c'); }
                     case (ast::native_abi_llvm) { w.write_char('l'); }
                 }
-                let vec[@constr] res_constrs = [];
-                enc_ty_fn(w, cx, args, out, ast::return, res_constrs);
+                enc_ty_fn(w, cx, args, out, ast::return, []);
             }
             case (ty::ty_obj(?methods)) {
                 w.write_str("O[");
@@ -253,7 +252,7 @@ mod Encode {
         }
     }
     fn enc_ty_fn(&io::writer w, &@ctxt cx, &vec[ty::arg] args, &ty::t out,
-                 &ast::controlflow cf, &vec[@ast::constr] constrs) {
+                 &ast::controlflow cf, &vec[@ty::constr_def] constrs) {
         w.write_char('[');
         for (ty::arg arg in args) {
             alt (arg.mode) {
@@ -271,15 +270,15 @@ mod Encode {
             case (_) { enc_ty(w, cx, out); }
         }
         auto colon = true;
-        for (@ast::constr c in constrs) {
+        for (@ty::constr_def c in constrs) {
             if (colon) {
                 w.write_char(':');
                 colon = false;
             } else { w.write_char(','); }
             enc_constr(w, cx, c);
         }
     }
-    fn enc_constr(&io::writer w, &@ctxt cx, &@ast::constr c) {
+    fn enc_constr(&io::writer w, &@ctxt cx, &@ty::constr_def c) {
         w.write_str(path_to_str(c.node.path));
         w.write_char('(');
         // FIXME

src/comp/middle/resolve.rs

@@ -11,7 +11,8 @@ import util::common::new_int_hash;
 import util::common::new_uint_hash;
 import util::common::new_str_hash;
 import util::common::span;
-import middle::tstate::ann::ts_ann;
+import util::common::respan;
+import middle::ty::constr_table;
 import visit::vt;
 import std::map::hashmap;
 import std::list;
@@ -111,24 +112,26 @@ type def_map = hashmap[uint, def];
 type env =
     rec(crate_map crate_map,
         def_map def_map,
+        constr_table fn_constrs,
         hashmap[def_id, @ast::item] ast_map,
         hashmap[ast::def_num, import_state] imports,
         hashmap[ast::def_num, @indexed_mod] mod_map,
         hashmap[def_id, vec[ident]] ext_map,
         ext_hash ext_cache,
         session sess);
 
-
 // Used to distinguish between lookups from outside and from inside modules,
 // since export restrictions should only be applied for the former.
 tag dir { inside; outside; }
 
 tag namespace { ns_value; ns_type; ns_module; }
 
-fn resolve_crate(session sess, @ast::crate crate) -> def_map {
+fn resolve_crate(session sess, @ast::crate crate)
+    -> tup(def_map, constr_table) {
     auto e =
         @rec(crate_map=new_uint_hash[ast::crate_num](),
              def_map=new_uint_hash[def](),
+             fn_constrs = new_def_hash[vec[ty::constr_def]](),
              ast_map=new_def_hash[@ast::item](),
              imports=new_int_hash[import_state](),
              mod_map=new_int_hash[@indexed_mod](),
@@ -140,7 +143,7 @@ fn resolve_crate(session sess, @ast::crate crate) -> def_map {
     resolve_imports(*e);
     check_for_collisions(e, *crate);
     resolve_names(e, crate);
-    ret e.def_map;
+    ret tup(e.def_map, e.fn_constrs);
 }
 
 
@@ -266,8 +269,9 @@ 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_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(c), @nil), visit::vtor(v));
     fn walk_expr(@env e, &@ast::expr exp, &scopes sc, &vt[scopes] v) {
@@ -282,12 +286,7 @@ 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) {
@@ -300,6 +299,13 @@ 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_arm(@env e, &ast::arm a, &scopes sc, &vt[scopes] v) {
         walk_pat(*e, sc, a.pat);
         visit_arm_with_scope(a, sc, v);
@@ -338,11 +344,16 @@ fn visit_native_item_with_scope(&@ast::native_item ni, &scopes sc,
     visit::visit_native_item(ni, cons(scope_native_item(ni), @sc), v);
 }
 
-fn visit_fn_with_scope(&ast::_fn f, &vec[ast::ty_param] tp, &span sp,
+fn visit_fn_with_scope(&@env e, &ast::_fn f, &vec[ast::ty_param] tp, &span sp,
                        &ident name, &def_id d_id, &ann a, &scopes sc,
                        &vt[scopes] v) {
-    visit::visit_fn(f, tp, sp, name, d_id, a, cons(scope_fn(f.decl, tp), @sc),
-                    v);
+    // here's where we need to set up the mapping
+    // for f's constrs in the table.
+    for (@ast::constr c in f.decl.constraints) {
+        resolve_constr(e, d_id, c, sc, v); 
+    }
+    visit::visit_fn(f, tp, sp, name, d_id, a,
+                    cons(scope_fn(f.decl, tp), @sc), v);
 }
 
 fn visit_block_with_scope(&ast::block b, &scopes sc, &vt[scopes] v) {
@@ -389,6 +400,37 @@ fn follow_import(&env e, &scopes sc, vec[ident] path, &span sp) -> def {
     }
 }
 
+fn resolve_constr(@env e, &def_id d_id, &@ast::constr c, &scopes sc,
+                  &vt[scopes] v) {
+    let def new_def = lookup_path_strict(*e, sc, c.span,
+                                         c.node.path.node.idents,
+                                         ns_value);
+    alt (new_def) {
+        case (ast::def_fn(?pred_id)) {
+            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, d_id, new_constr);
+        }
+        case (_) {
+            e.sess.span_err(c.span, "Non-predicate in constraint: "
+                            + ty::path_to_str(c.node.path));
+        }
+    }
+}
+
+fn add_constr(&@env e, &def_id d_id, &ty::constr_def c) {
+    e.fn_constrs.insert(d_id,
+       alt (e.fn_constrs.find(d_id)) {
+          case (none) {
+              [c]
+          }
+          case (some(?cs)) {
+              cs + [c]
+          }
+       });
+}
 
 // Import resolution
 fn resolve_import(&env e, &@ast::view_item it, &scopes sc) {

src/comp/middle/tstate/auxiliary.rs

@@ -198,8 +198,9 @@ to represent predicate *arguments* however. This type
 Both types store an ident and span, for error-logging purposes.
 */
 type pred_desc_ = rec(vec[@constr_arg_use] args, uint bit_num);
-
 type pred_desc = spanned[pred_desc_];
+type constr_arg_use = constr_arg_general[ident];
+
 
 tag constraint {
     cinit(uint, span, ident);
@@ -456,7 +457,7 @@ fn controlflow_expr(&crate_ctxt ccx, @expr e) -> controlflow {
     }
 }
 
-fn constraints_expr(&ty::ctxt cx, @expr e) -> vec[@ast::constr] {
+fn constraints_expr(&ty::ctxt cx, @expr e) -> vec[@ty::constr_def] {
     alt (ty::struct(cx, ty::ann_to_type(cx, expr_ann(e)))) {
         case (ty::ty_fn(_, _, _, _, ?cs)) { ret cs; }
         case (_) { ret []; }
@@ -511,9 +512,11 @@ fn constraints(&fn_ctxt fcx) -> vec[norm_constraint] {
 // FIXME:
 // this probably doesn't handle name shadowing well (or at all)
 // variables should really always be id'd by def_id and not ident
+
 fn match_args(&fn_ctxt fcx, vec[pred_desc] occs, vec[@constr_arg_use] occ) ->
    uint {
-    log "match_args: looking at " + pretty::ppaux::constr_args_to_str_1(occ);
+    log ("match_args: looking at " +
+         pretty::ppaux::constr_args_to_str(std::util::id[str], occ));
     for (pred_desc pd in occs) {
         log "match_args: candidate " + pred_desc_to_str(pd);
         if (ty::args_eq(str::eq, pd.node.args, occ)) { ret pd.node.bit_num; }
@@ -586,11 +589,13 @@ fn expr_to_constr(ty::ctxt tcx, &@expr e) -> constr {
 
 fn pred_desc_to_str(&pred_desc p) -> str {
     ret "<" + uistr(p.node.bit_num) + ", " +
-            pretty::ppaux::constr_args_to_str_1(p.node.args) + ">";
+         pretty::ppaux::constr_args_to_str(std::util::id[str], p.node.args)
+         + ">";
 }
 
-fn substitute_constr_args(&ty::ctxt cx, &vec[@expr] actuals, &@ast::constr c)
-   -> constr__ {
+fn substitute_constr_args(&ty::ctxt cx,
+                          &vec[@expr] actuals, &@ty::constr_def c)
+    -> constr__ {
     let vec[@constr_arg_use] res = [];
     for (@constr_arg a in c.node.args) {
         res += [substitute_arg(cx, actuals, a)];