---

yaml
---
r: 4823
b: refs/heads/master
c: 30b5f85
h: refs/heads/master
i:
  4821: b6889c6
  4819: 73569b3
  4815: 7c837af
v: v3

Author: msullivan

[refs]

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

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 d =
+    let {def_map, ext_map} =
         time(time_passes, "resolution",
              bind resolve::resolve_crate(sess, ast_map, crate));
     let freevars =
         time(time_passes, "freevar finding",
-             bind freevars::annotate_freevars(sess, d, crate));
-    let ty_cx = ty::mk_ctxt(sess, d, ast_map, freevars);
+             bind freevars::annotate_freevars(sess, def_map, crate));
+    let ty_cx = ty::mk_ctxt(sess, def_map, ext_map, 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 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);
+        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);
         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,6 +36,7 @@ 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,
@@ -113,6 +114,7 @@ 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,
@@ -133,7 +135,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: def_map, ext_map: ext_map} {
     let e =
         @{cstore: sess.get_cstore(),
           def_map: new_int_hash::<def>(),
@@ -148,7 +150,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 e.def_map;
+    ret {def_map: e.def_map, ext_map: e.ext_map};
 }
 
 

trunk/src/comp/middle/ty.rs

@@ -212,6 +212,9 @@ 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,
@@ -392,7 +395,8 @@ fn mk_rcache() -> creader_cache {
 }
 
 
-fn mk_ctxt(s: session::session, dm: resolve::def_map, amap: ast_map::map,
+fn mk_ctxt(s: session::session, dm: resolve::def_map,
+           em: hashmap<def_id, [ident]>, amap: ast_map::map,
            freevars: freevars::freevar_map) -> ctxt {
     let ntt: node_type_table =
         @smallintmap::mk::<ty::ty_param_substs_opt_and_ty>();
@@ -402,6 +406,7 @@ fn mk_ctxt(s: session::session, dm: resolve::def_map, amap: ast_map::map,
         @{ts: ts,
           sess: s,
           def_map: dm,
+          ext_map: em,
           node_types: ntt,
           items: amap,
           freevars: freevars,
@@ -1066,6 +1071,13 @@ 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,6 +18,8 @@ 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 {
@@ -35,6 +37,17 @@ 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 {
@@ -77,67 +90,61 @@ 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; } _ { } }
-    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"; }
+    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" }
       ty_rec(elems) {
         let strs: [str] = ~[];
         for fld: field in elems { strs += ~[field_to_str(cx, fld)]; }
-        s += "{" + str::connect(strs, ",") + "}";
+        "{" + str::connect(strs, ",") + "}"
       }
       ty_tup(elems) {
         let strs = ~[];
         for elem in elems { strs += ~[ty_to_str(cx, elem)]; }
-        s += "(" + str::connect(strs, ",") + ")";
+        "(" + str::connect(strs, ",") + ")"
       }
       ty_tag(id, tps) {
-        // The user should never see this if the cname is set properly!
-
-        s += "<tag#" + int::str(id.crate) + ":" + int::str(id.node) + ">";
+        let s = get_id_ident(cx, id);
         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) {
-        s += fn_to_str(cx, proto, none, inputs, output, cf, constrs);
+        fn_to_str(cx, proto, none, inputs, output, cf, constrs)
       }
       ty_native_fn(_, inputs, output) {
-        s +=
-            fn_to_str(cx, ast::proto_fn, none, inputs, output, ast::return,
-                      ~[]);
+        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)]; }
-        s += "obj {\n\t" + str::connect(strs, "\n\t") + "\n}";
+        "obj {\n\t" + str::connect(strs, "\n\t") + "\n}"
       }
       ty_res(id, _, _) {
-        s +=
-            "<resource#" + int::str(id.node) + ":" + int::str(id.crate) + ">";
+        get_id_ident(cx, id)
       }
-      ty_var(v) { s += "<T" + int::str(v) + ">"; }
+      ty_var(v) { "<T" + int::str(v) + ">" }
       ty_param(id,_) {
-        s += "'" + str::unsafe_from_bytes(~[('a' as u8) + (id as u8)]);
+        "'" + str::unsafe_from_bytes(~[('a' as u8) + (id as u8)])
       }
-      _ { s += ty_to_short_str(cx, typ); }
+      _ { ty_to_short_str(cx, typ) }
     }
-    ret s;
 }
 
 fn ty_to_short_str(cx: &ctxt, typ: t) -> str {