---

yaml
---
r: 4822
b: refs/heads/master
c: 031529e
h: refs/heads/master
v: v3

Author: pcwalton

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: e7c8019dd9889e1736b075d1b205f8b118b286b3
+refs/heads/master: 031529e3fe34267168a43cf74dbdd9e41f12ac43

trunk/src/comp/driver/rustc.rs

@@ -143,13 +143,13 @@ fn compile_input(sess: session::session, cfg: ast::crate_cfg, input: str,
              bind middle::ast_map::map_crate(*crate));
     time(time_passes, "external crate/lib resolution",
          bind creader::read_crates(sess, *crate));
-    let {def_map, ext_map} =
+    let d =
         time(time_passes, "resolution",
              bind resolve::resolve_crate(sess, ast_map, crate));
     let freevars =
         time(time_passes, "freevar finding",
-             bind freevars::annotate_freevars(sess, def_map, crate));
-    let ty_cx = ty::mk_ctxt(sess, def_map, ext_map, ast_map, freevars);
+             bind freevars::annotate_freevars(sess, d, crate));
+    let ty_cx = ty::mk_ctxt(sess, d, ast_map, freevars);
     time::<()>(time_passes, "typechecking",
              bind typeck::check_crate(ty_cx, crate));
     time::<()>(time_passes, "alt checking",
@@ -222,9 +222,9 @@ fn pretty_print_input(sess: session::session, cfg: ast::crate_cfg, input: str,
     alt ppm {
       ppm_typed. {
         let amap = middle::ast_map::map_crate(*crate);
-        let {def_map, ext_map} = resolve::resolve_crate(sess, amap, crate);
-        let freevars = freevars::annotate_freevars(sess, def_map, crate);
-        let ty_cx = ty::mk_ctxt(sess, def_map, ext_map, amap, freevars);
+        let d = resolve::resolve_crate(sess, amap, crate);
+        let freevars = freevars::annotate_freevars(sess, d, crate);
+        let ty_cx = ty::mk_ctxt(sess, d, amap, freevars);
         typeck::check_crate(ty_cx, crate);
         ann = {pre: ann_paren_for_expr, post: bind ann_typed_post(ty_cx, _)};
       }

trunk/src/comp/middle/resolve.rs

@@ -36,7 +36,6 @@ import syntax::print::pprust::*;
 
 export resolve_crate;
 export def_map;
-export ext_map;
 
 // Resolving happens in two passes. The first pass collects defids of all
 // (internal) imports and modules, so that they can be looked up when needed,
@@ -114,7 +113,6 @@ type indexed_mod =
    only need to look at them to determine exports, which they can't control.*/
 
 type def_map = hashmap<node_id, def>;
-type ext_map = hashmap<def_id, [ident]>;
 
 type env =
     {cstore: cstore::cstore,
@@ -135,7 +133,7 @@ tag dir { inside; outside; }
 tag namespace { ns_value; ns_type; ns_module; }
 
 fn resolve_crate(sess: session, amap: &ast_map::map, crate: @ast::crate) ->
-    {def_map: def_map, ext_map: ext_map} {
+   def_map {
     let e =
         @{cstore: sess.get_cstore(),
           def_map: new_int_hash::<def>(),
@@ -150,7 +148,7 @@ fn resolve_crate(sess: session, amap: &ast_map::map, crate: @ast::crate) ->
     resolve_imports(*e);
     check_for_collisions(e, *crate);
     resolve_names(e, crate);
-    ret {def_map: e.def_map, ext_map: e.ext_map};
+    ret e.def_map;
 }
 
 

trunk/src/comp/middle/trans.rs

@@ -5626,7 +5626,9 @@ fn alloc_ty(cx: &@block_ctxt, t: &ty::t) -> result {
     // past caller conventions and may well make sense again,
     // so we leave it as-is.
 
-    bcx = gc::add_gc_root(bcx, val, t);
+    if (bcx_tcx(cx).sess.get_opts().do_gc) {
+        bcx = gc::add_gc_root(bcx, val, t);
+    }
 
     ret rslt(cx, val);
 }

trunk/src/comp/middle/ty.rs

@@ -212,9 +212,6 @@ type ctxt =
     @{ts: @type_store,
       sess: session::session,
       def_map: resolve::def_map,
-      // We need the ext_map just for printing the types of tags defined in
-      // other crates. Once we get cnames back it should go.
-      ext_map: resolve::ext_map,
       node_types: node_type_table,
       items: ast_map::map,
       freevars: freevars::freevar_map,
@@ -395,8 +392,7 @@ fn mk_rcache() -> creader_cache {
 }
 
 
-fn mk_ctxt(s: session::session, dm: resolve::def_map,
-           em: hashmap<def_id, [ident]>, amap: ast_map::map,
+fn mk_ctxt(s: session::session, dm: resolve::def_map, amap: ast_map::map,
            freevars: freevars::freevar_map) -> ctxt {
     let ntt: node_type_table =
         @smallintmap::mk::<ty::ty_param_substs_opt_and_ty>();
@@ -406,7 +402,6 @@ fn mk_ctxt(s: session::session, dm: resolve::def_map,
         @{ts: ts,
           sess: s,
           def_map: dm,
-          ext_map: em,
           node_types: ntt,
           items: amap,
           freevars: freevars,
@@ -1071,13 +1066,6 @@ fn type_kind(cx: &ctxt, ty: &t) -> ast::kind {
             if result == ast::kind_pinned { break; }
         }
       }
-      // Tuples lower to the lowest of their members.
-      ty_tup(tys) {
-        for ty: t in tys {
-            result = kind::lower_kind(result, type_kind(cx, ty));
-            if result == ast::kind_pinned { break; }
-        }
-      }
 
       // Tags lower to the lowest of their variants.
       ty_tag(did, tps) {

trunk/src/comp/util/ppaux.rs

@@ -18,8 +18,6 @@ import pp::zerobreak;
 import pp::hardbreak;
 import ast::ty_mach_to_str;
 import syntax::ast;
-import middle::ast_map;
-import metadata::csearch;
 
 fn mode_str(m: &ty::mode) -> str {
     alt m {
@@ -37,17 +35,6 @@ fn fn_ident_to_string(id: ast::node_id, i: &ast::fn_ident) -> str {
     ret alt i { none. { "anon" + int::str(id) } some(s) { s } };
 }
 
-fn get_id_ident(cx: &ctxt, id: ast::def_id) -> str {
-    if (id.crate != ast::local_crate) {
-        str::connect(cx.ext_map.get(id), "::")
-    } else {
-        alt cx.items.find(id.node) {
-          some(ast_map::node_item(it)) { it.ident }
-          _ { fail "get_id_ident: can't find item in ast_map" }
-        }
-    }
-}
-
 fn ty_to_str(cx: &ctxt, typ: &t) -> str {
     fn fn_input_to_str(cx: &ctxt, input: &{mode: middle::ty::mode, ty: t}) ->
        str {
@@ -90,61 +77,67 @@ fn ty_to_str(cx: &ctxt, typ: &t) -> str {
         ret mstr + ty_to_str(cx, m.ty);
     }
     alt cname(cx, typ) { some(cs) { ret cs; } _ { } }
-    ret alt struct(cx, typ) {
-      ty_native(_) { "native" }
-      ty_nil. { "()" }
-      ty_bot. { "_|_" }
-      ty_bool. { "bool" }
-      ty_int. { "int" }
-      ty_float. { "float" }
-      ty_uint. { "uint" }
-      ty_machine(tm) { ty_mach_to_str(tm) }
-      ty_char. { "char" }
-      ty_str. { "str" }
-      ty_istr. { "istr" }
-      ty_box(tm) { "@" + mt_to_str(cx, tm) }
-      ty_uniq(t) { "~" + ty_to_str(cx, t) }
-      ty_vec(tm) { "[" + mt_to_str(cx, tm) + "]" }
-      ty_type. { "type" }
+    let s = "";
+    alt struct(cx, typ) {
+      ty_native(_) { s += "native"; }
+      ty_nil. { s += "()"; }
+      ty_bot. { s += "_|_"; }
+      ty_bool. { s += "bool"; }
+      ty_int. { s += "int"; }
+      ty_float. { s += "float"; }
+      ty_uint. { s += "uint"; }
+      ty_machine(tm) { s += ty_mach_to_str(tm); }
+      ty_char. { s += "char"; }
+      ty_str. { s += "str"; }
+      ty_istr. { s += "istr"; }
+      ty_box(tm) { s += "@" + mt_to_str(cx, tm); }
+      ty_uniq(t) { s += "~" + ty_to_str(cx, t); }
+      ty_vec(tm) { s += "[" + mt_to_str(cx, tm) + "]"; }
+      ty_type. { s += "type"; }
       ty_rec(elems) {
         let strs: [str] = ~[];
         for fld: field in elems { strs += ~[field_to_str(cx, fld)]; }
-        "{" + str::connect(strs, ",") + "}"
+        s += "{" + str::connect(strs, ",") + "}";
       }
       ty_tup(elems) {
         let strs = ~[];
         for elem in elems { strs += ~[ty_to_str(cx, elem)]; }
-        "(" + str::connect(strs, ",") + ")"
+        s += "(" + str::connect(strs, ",") + ")";
       }
       ty_tag(id, tps) {
-        let s = get_id_ident(cx, id);
+        // The user should never see this if the cname is set properly!
+
+        s += "<tag#" + int::str(id.crate) + ":" + int::str(id.node) + ">";
         if vec::len::<t>(tps) > 0u {
             let strs: [str] = ~[];
             for typ: t in tps { strs += ~[ty_to_str(cx, typ)]; }
             s += "[" + str::connect(strs, ",") + "]";
         }
-        s
       }
       ty_fn(proto, inputs, output, cf, constrs) {
-        fn_to_str(cx, proto, none, inputs, output, cf, constrs)
+        s += fn_to_str(cx, proto, none, inputs, output, cf, constrs);
       }
       ty_native_fn(_, inputs, output) {
-        fn_to_str(cx, ast::proto_fn, none, inputs, output, ast::return, ~[])
+        s +=
+            fn_to_str(cx, ast::proto_fn, none, inputs, output, ast::return,
+                      ~[]);
       }
       ty_obj(meths) {
         let strs = ~[];
         for m: method in meths { strs += ~[method_to_str(cx, m)]; }
-        "obj {\n\t" + str::connect(strs, "\n\t") + "\n}"
+        s += "obj {\n\t" + str::connect(strs, "\n\t") + "\n}";
       }
       ty_res(id, _, _) {
-        get_id_ident(cx, id)
+        s +=
+            "<resource#" + int::str(id.node) + ":" + int::str(id.crate) + ">";
       }
-      ty_var(v) { "<T" + int::str(v) + ">" }
+      ty_var(v) { s += "<T" + int::str(v) + ">"; }
       ty_param(id,_) {
-        "'" + str::unsafe_from_bytes(~[('a' as u8) + (id as u8)])
+        s += "'" + str::unsafe_from_bytes(~[('a' as u8) + (id as u8)]);
       }
-      _ { ty_to_short_str(cx, typ) }
+      _ { s += ty_to_short_str(cx, typ); }
     }
+    ret s;
 }
 
 fn ty_to_short_str(cx: &ctxt, typ: t) -> str {