rustc: Thread an item-to-type mapping throughout the typechecking and translation phases

Author: pcwalton

src/comp/driver/rustc.rs

@@ -6,6 +6,7 @@ import front.token;
 import front.eval;
 import middle.trans;
 import middle.resolve;
+import middle.ty;
 import middle.typeck;
 import util.common;
 
@@ -62,8 +63,12 @@ impure fn compile_input(session.session sess,
     auto crate = parse_input(sess, p, input);
     crate = creader.read_crates(sess, crate, library_search_paths);
     crate = resolve.resolve_crate(sess, crate);
-    crate = typeck.check_crate(sess, crate);
-    trans.trans_crate(sess, crate, output, shared);
+
+    auto typeck_result = typeck.check_crate(sess, crate);
+    crate = typeck_result._0;
+    auto type_cache = typeck_result._1;
+
+    trans.trans_crate(sess, crate, type_cache, output, shared);
 }
 
 impure fn pretty_print_input(session.session sess,

src/comp/front/ast.rs

@@ -395,6 +395,8 @@ tag view_item_ {
     view_item_export(ident);
 }
 
+type obj_def_ids = rec(def_id ty, def_id ctor);
+
 type item = spanned[item_];
 tag item_ {
     item_const(ident, @ty, @expr, def_id, ann);
@@ -403,7 +405,7 @@ tag item_ {
     item_native_mod(ident, native_mod, def_id);
     item_ty(ident, @ty, vec[ty_param], def_id, ann);
     item_tag(ident, vec[variant], vec[ty_param], def_id);
-    item_obj(ident, _obj, vec[ty_param], def_id, ann);
+    item_obj(ident, _obj, vec[ty_param], obj_def_ids, ann);
 }
 
 type native_item = spanned[native_item_];

src/comp/front/creader.rs

@@ -544,6 +544,23 @@ fn read_crates(session.session sess,
 }
 
 
+fn kind_has_type_params(u8 kind_ch) -> bool {
+    // FIXME: It'd be great if we had u8 char literals.
+    if (kind_ch == ('c' as u8))      { ret false; }
+    else if (kind_ch == ('f' as u8)) { ret true;  }
+    else if (kind_ch == ('o' as u8)) { ret true;  }
+    else if (kind_ch == ('t' as u8)) { ret true;  }
+    else if (kind_ch == ('m' as u8)) { ret false; }
+    else if (kind_ch == ('n' as u8)) { ret false; }
+    else if (kind_ch == ('v' as u8)) { ret true;  }
+    else {
+        log #fmt("kind_has_type_params(): unknown kind char: %d",
+                 kind_ch as int);
+        fail;
+    }
+}
+
+
 // Crate metadata queries
 
 fn lookup_def(session.session sess, int cnum, vec[ast.ident] path)
@@ -567,7 +584,6 @@ fn lookup_def(session.session sess, int cnum, vec[ast.ident] path)
     auto def;
     if (kind_ch == ('c' as u8))      { def = ast.def_const(did);        }
     else if (kind_ch == ('f' as u8)) { def = ast.def_fn(did);           }
-    else if (kind_ch == ('y' as u8)) { def = ast.def_ty(did);           }
     else if (kind_ch == ('o' as u8)) { def = ast.def_obj(did);          }
     else if (kind_ch == ('t' as u8)) { def = ast.def_ty(did);           }
     else if (kind_ch == ('m' as u8)) { def = ast.def_mod(did);          }
@@ -584,13 +600,23 @@ fn lookup_def(session.session sess, int cnum, vec[ast.ident] path)
     ret some[ast.def](def);
 }
 
-fn get_type(session.session sess, ast.def_id def) -> ty.ty_params_and_ty {
+fn get_type(session.session sess, ast.def_id def) -> ty.ty_params_opt_and_ty {
     auto external_crate_id = def._0;
     auto data = sess.get_external_crate(external_crate_id);
     auto ebml_r = lookup_item(def._1, data);
     auto t = get_item_type(ebml_r, external_crate_id);
-    auto tps = get_item_ty_params(ebml_r, external_crate_id);
-    ret tup(tps, t);
+
+    auto tps_opt;
+    auto kind_ch = get_item_kind(ebml_r);
+    auto has_ty_params = kind_has_type_params(kind_ch);
+    if (has_ty_params) {
+        auto tps = get_item_ty_params(ebml_r, external_crate_id);
+        tps_opt = some[vec[ast.def_id]](tps);
+    } else {
+        tps_opt = none[vec[ast.def_id]];
+    }
+
+    ret tup(tps_opt, t);
 }
 
 fn get_symbol(session.session sess, ast.def_id def) -> str {

src/comp/front/parser.rs

@@ -1876,8 +1876,8 @@ impure fn parse_item_obj(parser p, ast.layer lyr) -> @ast.item {
                           methods=meths,
                           dtor=dtor);
 
-    auto item = ast.item_obj(ident, ob, ty_params,
-                             p.next_def_id(), ast.ann_none);
+    auto odid = rec(ty=p.next_def_id(), ctor=p.next_def_id());
+    auto item = ast.item_obj(ident, ob, ty_params, odid, ast.ann_none);
 
     ret @spanned(lo, hi, item);
 }

src/comp/middle/fold.rs

@@ -269,7 +269,7 @@ type ast_fold[ENV] =
      (fn(&ENV e, &span sp, ident ident,
          &ast._obj ob,
          vec[ast.ty_param] ty_params,
-         def_id id, ann a) -> @item)              fold_item_obj,
+         ast.obj_def_ids odid, ann a) -> @item)   fold_item_obj,
 
      // View Item folds.
      (fn(&ENV e, &span sp, ident ident,
@@ -975,9 +975,9 @@ fn fold_item[ENV](&ENV env, ast_fold[ENV] fld, @item i) -> @item {
                                   ty_params, id);
         }
 
-        case (ast.item_obj(?ident, ?ob, ?tps, ?id, ?ann)) {
+        case (ast.item_obj(?ident, ?ob, ?tps, ?odid, ?ann)) {
             let ast._obj ob_ = fold_obj[ENV](env_, fld, ob);
-            ret fld.fold_item_obj(env_, i.span, ident, ob_, tps, id, ann);
+            ret fld.fold_item_obj(env_, i.span, ident, ob_, tps, odid, ann);
         }
 
     }
@@ -1429,8 +1429,8 @@ fn identity_fold_item_tag[ENV](&ENV e, &span sp, ident i,
 
 fn identity_fold_item_obj[ENV](&ENV e, &span sp, ident i,
                                &ast._obj ob, vec[ast.ty_param] ty_params,
-                               def_id id, ann a) -> @item {
-    ret @respan(sp, ast.item_obj(i, ob, ty_params, id, a));
+                               ast.obj_def_ids odid, ann a) -> @item {
+    ret @respan(sp, ast.item_obj(i, ob, ty_params, odid, a));
 }
 
 // View Item folds.

src/comp/middle/metadata.rs

@@ -30,6 +30,7 @@ const uint tag_items_type = 0x0au;
 const uint tag_items_symbol = 0x0bu;
 const uint tag_items_variant = 0x0cu;
 const uint tag_items_tag_id = 0x0du;
+const uint tag_items_obj_type_id = 0x0eu;
 
 // Type encoding
 
@@ -237,10 +238,11 @@ fn encode_module_item_paths(&ebml.writer ebml_w, &ast._mod module) {
                 encode_def_id(ebml_w, did);
                 ebml.end_tag(ebml_w);
             }
-            case (ast.item_obj(?id, _, ?tps, ?did, ?ann)) {
+            case (ast.item_obj(?id, _, ?tps, ?odid, ?ann)) {
                 ebml.start_tag(ebml_w, tag_paths_item);
                 encode_name(ebml_w, id);
-                encode_def_id(ebml_w, did);
+                encode_def_id(ebml_w, odid.ctor);
+                encode_obj_type_id(ebml_w, odid.ty);
                 ebml.end_tag(ebml_w);
             }
         }
@@ -301,6 +303,12 @@ fn encode_tag_id(&ebml.writer ebml_w, &ast.def_id id) {
     ebml.end_tag(ebml_w);
 }
 
+fn encode_obj_type_id(&ebml.writer ebml_w, &ast.def_id id) {
+    ebml.start_tag(ebml_w, tag_items_obj_type_id);
+    ebml_w.writer.write(_str.bytes(def_to_str(id)));
+    ebml.end_tag(ebml_w);
+}
+
 
 fn encode_tag_variant_info(@trans.crate_ctxt cx, &ebml.writer ebml_w,
                            ast.def_id did, vec[ast.variant] variants) {
@@ -367,13 +375,21 @@ fn encode_info_for_item(@trans.crate_ctxt cx, &ebml.writer ebml_w,
 
             encode_tag_variant_info(cx, ebml_w, did, variants);
         }
-        case (ast.item_obj(?id, _, ?tps, ?did, ?ann)) {
+        case (ast.item_obj(?id, _, ?tps, ?odid, ?ann)) {
             ebml.start_tag(ebml_w, tag_items_item);
-            encode_def_id(ebml_w, did);
+            encode_def_id(ebml_w, odid.ctor);
             encode_kind(ebml_w, 'o' as u8);
             encode_type_params(ebml_w, tps);
-            encode_type(ebml_w, trans.node_ann_type(cx, ann));
-            encode_symbol(cx, ebml_w, did);
+            auto fn_ty = trans.node_ann_type(cx, ann);
+            encode_type(ebml_w, fn_ty);
+            encode_symbol(cx, ebml_w, odid.ctor);
+            ebml.end_tag(ebml_w);
+
+            ebml.start_tag(ebml_w, tag_items_item);
+            encode_def_id(ebml_w, odid.ty);
+            encode_kind(ebml_w, 'y' as u8);
+            encode_type_params(ebml_w, tps);
+            encode_type(ebml_w, ty.ty_fn_ret(fn_ty));
             ebml.end_tag(ebml_w);
         }
     }