---

yaml
---
r: 147823
b: refs/heads/try2
c: c34ef5d
h: refs/heads/master
i:
  147821: 24e2b8e
  147819: 622c311
  147815: 3c209e5
  147807: 5f093a2
v: v3

Author: bors

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 9cdad685a39fd826174a6cbcd283ad2dee41e175
+refs/heads/try2: c34ef5d7e4f44f8e65600a2c3866f5861c401ea1
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/driver/driver.rs

@@ -19,7 +19,4 @@ extern mod this = "rustdoc";
 #[cfg(rustc)]
 extern mod this = "rustc";
 
-#[cfg(rustdoc_ng)]
-extern mod this = "rustdoc_ng";
-
 fn main() { this::main() }

branches/try2/src/etc/emacs/rust-mode.el

@@ -54,7 +54,9 @@
     ;; We don't want to indent out to the open bracket if the
     ;; open bracket ends the line
     (when (not (looking-at "[[:blank:]]*\\(?://.*\\)?$"))
-      (when (looking-at "[[:space:]]") (forward-to-word 1))
+      (when (looking-at "[[:space:]]")
+	(forward-word 1)
+	(backward-word 1))
       (current-column))))
 
 (defun rust-mode-indent-line ()

branches/try2/src/librustc/back/link.rs

@@ -34,6 +34,7 @@ use std::run;
 use std::str;
 use std::io;
 use std::io::fs;
+use extra::hex::ToHex;
 use extra::tempfile::TempDir;
 use syntax::abi;
 use syntax::ast;
@@ -490,8 +491,10 @@ pub fn build_link_meta(sess: Session,
     }
 }
 
-pub fn truncated_hash_result(symbol_hasher: &mut Sha256) -> ~str {
-    symbol_hasher.result_str()
+fn truncated_hash_result(symbol_hasher: &mut Sha256) -> ~str {
+    let output = symbol_hasher.result_bytes();
+    // 64 bits should be enough to avoid collisions.
+    output.slice_to(8).to_hex()
 }
 
 
@@ -879,8 +882,11 @@ fn link_rlib(sess: Session,
     match trans {
         Some(trans) => {
             // Instead of putting the metadata in an object file section, rlibs
-            // contain the metadata in a separate file.
-            let metadata = obj_filename.with_filename(METADATA_FILENAME);
+            // contain the metadata in a separate file. We use a temp directory
+            // here so concurrent builds in the same directory don't try to use
+            // the same filename for metadata (stomping over one another)
+            let tmpdir = TempDir::new("rustc").expect("needs a temp dir");
+            let metadata = tmpdir.path().join(METADATA_FILENAME);
             fs::File::create(&metadata).write(trans.metadata);
             a.add_file(&metadata, false);
             fs::unlink(&metadata);

branches/try2/src/librustc/metadata/encoder.rs

@@ -1140,7 +1140,7 @@ fn encode_info_for_item(ecx: &EncodeContext,
             let impl_vtables = ty::lookup_impl_vtables(tcx, def_id);
             encode_impl_vtables(ebml_w, ecx, &impl_vtables);
         }
-        let elt = ast_map::impl_pretty_name(opt_trait, ty, item.ident);
+        let elt = ast_map::impl_pretty_name(opt_trait, ty);
         encode_path(ecx, ebml_w, path, elt);
         ebml_w.end_tag();
 

branches/try2/src/librustdoc/lib.rs

@@ -242,7 +242,7 @@ fn rust_input(cratefile: &str, matches: &getopts::Matches) -> Output {
     }
 
     // Load all plugins/passes into a PluginManager
-    let path = matches.opt_str("plugin-path").unwrap_or(~"/tmp/rustdoc_ng/plugins");
+    let path = matches.opt_str("plugin-path").unwrap_or(~"/tmp/rustdoc/plugins");
     let mut pm = plugins::PluginManager::new(Path::new(path));
     for pass in passes.iter() {
         let plugin = match PASSES.iter().position(|&(p, _, _)| p == *pass) {

branches/try2/src/libsyntax/ast_map.rs

@@ -82,26 +82,71 @@ pub fn path_elt_to_str(pe: path_elt, itr: @ident_interner) -> ~str {
     }
 }
 
-pub fn impl_pretty_name(trait_ref: &Option<trait_ref>,
-                        ty: &Ty, default: Ident) -> path_elt {
-    let itr = get_ident_interner();
-    let ty_ident = match ty.node {
-        ty_path(ref path, _, _) => path.segments.last().identifier,
-        _ => default
+/// write a "pretty" version of `ty` to `out`. This is designed so
+/// that symbols of `impl`'d methods give some hint of where they came
+/// from, even if it's hard to read (previously they would all just be
+/// listed as `__extensions__::method_name::hash`, with no indication
+/// of the type).
+// XXX: these dollar signs and the names in general are actually a
+//      relic of $ being one of the very few valid symbol names on
+//      unix. These kinds of details shouldn't be exposed way up here
+//      in the ast.
+fn pretty_ty(ty: &Ty, itr: @ident_interner, out: &mut ~str) {
+    let (prefix, subty) = match ty.node {
+        ty_uniq(ty) => ("$UP$", &*ty),
+        ty_box(mt { ty, .. }) => ("$SP$", &*ty),
+        ty_ptr(mt { ty, mutbl }) => (if mutbl == MutMutable {"$RPmut$"} else {"$RP$"},
+                                     &*ty),
+        ty_rptr(_, mt { ty, mutbl }) => (if mutbl == MutMutable {"$BPmut$"} else {"$BP$"},
+                                      &*ty),
+
+        ty_vec(ty) => ("$VEC$", &*ty),
+        ty_fixed_length_vec(ty, _) => ("$FIXEDVEC$", &*ty),
+
+        // these can't be represented as <prefix><contained ty>, so
+        // need custom handling.
+        ty_nil => { out.push_str("$NIL$"); return }
+        ty_path(ref path, _, _) => {
+                        out.push_str(itr.get(path.segments.last().identifier.name));
+                        return
+                    }
+        ty_tup(ref tys) => {
+            out.push_str(format!("$TUP_{}$", tys.len()));
+            for subty in tys.iter() {
+                pretty_ty(*subty, itr, out);
+                out.push_char('$');
+            }
+            return
+        }
+
+        // meh, better than nothing.
+        ty_bot => { out.push_str("$BOT$"); return }
+        ty_closure(..) => { out.push_str("$CLOSURE$"); return }
+        ty_bare_fn(..) => { out.push_str("$FN$"); return }
+        ty_typeof(..) => { out.push_str("$TYPEOF$"); return }
+        ty_infer(..) => { out.push_str("$INFER$"); return }
+
     };
+
+    out.push_str(prefix);
+    pretty_ty(subty, itr, out);
+}
+
+pub fn impl_pretty_name(trait_ref: &Option<trait_ref>, ty: &Ty) -> path_elt {
+    let itr = get_ident_interner();
+
     let hash = (trait_ref, ty).hash();
+    let mut pretty;
     match *trait_ref {
-        None => path_pretty_name(ty_ident, hash),
+        None => pretty = ~"",
         Some(ref trait_ref) => {
-            // XXX: this dollar sign is actually a relic of being one of the
-            //      very few valid symbol names on unix. These kinds of
-            //      details shouldn't be exposed way up here in the ast.
-            let s = format!("{}${}",
-                         itr.get(trait_ref.path.segments.last().identifier.name),
-                         itr.get(ty_ident.name));
-            path_pretty_name(Ident::new(itr.gensym(s)), hash)
+            pretty = itr.get(trait_ref.path.segments.last().identifier.name).to_owned();
+            pretty.push_char('$');
         }
-    }
+    };
+    pretty_ty(ty, itr, &mut pretty);
+
+    path_pretty_name(Ident::new(itr.gensym(pretty)), hash)
 }
 
 #[deriving(Clone)]
@@ -265,7 +310,7 @@ impl Visitor<()> for Ctx {
                 // Right now the ident on impls is __extensions__ which isn't
                 // very pretty when debugging, so attempt to select a better
                 // name to use.
-                let elt = impl_pretty_name(maybe_trait, ty, i.ident);
+                let elt = impl_pretty_name(maybe_trait, ty);
 
                 let impl_did = ast_util::local_def(i.id);
                 for m in ms.iter() {

branches/try2/src/test/compile-fail/ambig_impl_unify.rs

@@ -13,11 +13,11 @@ trait foo {
 }
 
 impl foo for ~[uint] {
-    fn foo(&self) -> int {1} //~ NOTE candidate #1 is `foo$__extensions__::foo`
+    fn foo(&self) -> int {1} //~ NOTE candidate #1 is `foo$$UP$$VEC$uint::foo`
 }
 
 impl foo for ~[int] {
-    fn foo(&self) -> int {2} //~ NOTE candidate #2 is `foo$__extensions__::foo`
+    fn foo(&self) -> int {2} //~ NOTE candidate #2 is `foo$$UP$$VEC$int::foo`
 }
 
 fn main() {