---

yaml
---
r: 149674
b: refs/heads/try2
c: 3245471
h: refs/heads/master
v: v3

Author: alexcrichton

[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: 567201e13be53d2d0e8dc4ea769ddf7b907c1ba3
+refs/heads/try2: 324547140e0b67b109b43dfa79cc39cdf06151e5
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/mk/clean.mk

@@ -58,7 +58,6 @@ clean-generic-$(2)-$(1):
          -name '*.[odasS]' -o \
          -name '*.so' -o      \
          -name '*.dylib' -o   \
-         -name '*.rlib' -o   \
          -name 'stamp.*' -o   \
          -name '*.lib' -o     \
          -name '*.dll' -o     \

branches/try2/src/doc/guide-container.md

@@ -384,7 +384,7 @@ the trailing underscore is a workaround for issue #5898 and will be removed.
 ~~~
 let mut ys = [1, 2, 3, 4, 5];
 ys.mut_iter().reverse_();
-assert!(ys == [5, 4, 3, 2, 1]);
+assert_eq!(ys, [5, 4, 3, 2, 1]);
 ~~~
 
 ## Random-access iterators

branches/try2/src/doc/tutorial.md

@@ -1688,7 +1688,7 @@ let x = Rc::new([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
 let y = x.clone(); // a new owner
 let z = x; // this moves `x` into `z`, rather than creating a new owner
 
-assert!(*z.borrow() == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+assert_eq!(*z.borrow(), [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
 
 // the variable is mutable, but not the contents of the box
 let mut a = Rc::new([10, 9, 8, 7, 6, 5, 4, 3, 2, 1]);
@@ -1707,7 +1707,7 @@ let x = Gc::new([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
 let y = x; // does not perform a move, unlike with `Rc`
 let z = x;
 
-assert!(*z.borrow() == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+assert_eq!(*z.borrow(), [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
 ~~~
 
 With shared ownership, mutability cannot be inherited so the boxes are always immutable. However,

branches/try2/src/libcollections/bitv.rs

@@ -1542,7 +1542,7 @@ mod tests {
 
         let mut b = a.clone();
 
-        assert!(a == b);
+        assert_eq!(&a, &b);
 
         assert!(b.remove(&1));
         assert!(a.contains(&1));
@@ -1561,7 +1561,7 @@ mod tests {
         let mut r = rng();
         let mut bitv = 0 as uint;
         b.iter(|| {
-            bitv |= 1 << ((r.next_u32() as uint) % uint::BITS);
+            bitv |= (1 << ((r.next_u32() as uint) % uint::BITS));
             &bitv
         })
     }

branches/try2/src/libcollections/dlist.rs

@@ -982,11 +982,11 @@ mod tests {
     fn test_eq() {
         let mut n: DList<u8> = list_from([]);
         let mut m = list_from([]);
-        assert!(n == m);
+        assert_eq!(&n, &m);
         n.push_front(1);
         assert!(n != m);
         m.push_back(1);
-        assert!(n == m);
+        assert_eq!(&n, &m);
 
         let n = list_from([2,3,4]);
         let m = list_from([1,2,3]);

branches/try2/src/libcollections/enum_set.rs

@@ -141,7 +141,7 @@ mod test {
 
     use enum_set::{EnumSet, CLike};
 
-    #[deriving(Eq, Show)]
+    #[deriving(Eq)]
     #[repr(uint)]
     enum Foo {
         A, B, C

branches/try2/src/libcollections/hashmap.rs

@@ -1065,7 +1065,7 @@ mod test_map {
         let mut observed = 0;
         for (k, v) in m.iter() {
             assert_eq!(*v, *k * 2);
-            observed |= 1 << *k;
+            observed |= (1 << *k);
         }
         assert_eq!(observed, 0xFFFF_FFFF);
     }
@@ -1293,7 +1293,7 @@ mod test_set {
         }
         let mut observed = 0;
         for k in a.iter() {
-            observed |= 1 << *k;
+            observed |= (1 << *k);
         }
         assert_eq!(observed, 0xFFFF_FFFF);
     }

branches/try2/src/libcollections/list.rs

@@ -153,7 +153,7 @@ mod tests {
     #[test]
     fn test_from_vec_empty() {
         let empty : list::List<int> = List::from_vec([]);
-        assert!(empty == Nil::<int>);
+        assert_eq!(empty, Nil::<int>);
     }
 
     #[test]
@@ -222,8 +222,8 @@ mod tests {
 
     #[test]
     fn test_append() {
-        assert!(List::from_vec([1, 2, 3, 4]) ==
-                List::from_vec([1, 2]).append(List::from_vec([3, 4])));
+        assert_eq!(List::from_vec([1, 2, 3, 4]),
+                   List::from_vec([1, 2]).append(List::from_vec([3, 4])));
     }
 
     #[test]
@@ -232,6 +232,6 @@ mod tests {
         let new_list = list.unshift(0);
         assert_eq!(list.len(), 1u);
         assert_eq!(new_list.len(), 2u);
-        assert!(new_list == List::from_vec([0, 1]));
+        assert_eq!(new_list, List::from_vec([0, 1]));
     }
 }

branches/try2/src/libcollections/lru_cache.rs

@@ -277,7 +277,7 @@ mod tests {
 
     fn assert_opt_eq<V: Eq>(opt: Option<&V>, v: V) {
         assert!(opt.is_some());
-        assert!(opt.unwrap() == &v);
+        assert_eq!(opt.unwrap(), &v);
     }
 
     #[test]

branches/try2/src/libcollections/ringbuf.rs

@@ -409,7 +409,6 @@ mod tests {
     use deque::Deque;
     use std::clone::Clone;
     use std::cmp::Eq;
-    use std::fmt::Show;
     use super::RingBuf;
 
     #[test]
@@ -494,7 +493,7 @@ mod tests {
     }
 
     #[cfg(test)]
-    fn test_parameterized<T:Clone + Eq + Show>(a: T, b: T, c: T, d: T) {
+    fn test_parameterized<T:Clone + Eq>(a: T, b: T, c: T, d: T) {
         let mut deq = RingBuf::new();
         assert_eq!(deq.len(), 0);
         deq.push_front(a.clone());
@@ -579,21 +578,21 @@ mod tests {
         })
     }
 
-    #[deriving(Clone, Eq, Show)]
+    #[deriving(Clone, Eq)]
     enum Taggy {
         One(int),
         Two(int, int),
         Three(int, int, int),
     }
 
-    #[deriving(Clone, Eq, Show)]
+    #[deriving(Clone, Eq)]
     enum Taggypar<T> {
         Onepar(int),
         Twopar(int, int),
         Threepar(int, int, int),
     }
 
-    #[deriving(Clone, Eq, Show)]
+    #[deriving(Clone, Eq)]
     struct RecCy {
         x: int,
         y: int,
@@ -813,7 +812,7 @@ mod tests {
     #[test]
     fn test_eq() {
         let mut d = RingBuf::new();
-        assert!(d == RingBuf::with_capacity(0));
+        assert_eq!(&d, &RingBuf::with_capacity(0));
         d.push_front(137);
         d.push_front(17);
         d.push_front(42);
@@ -823,11 +822,11 @@ mod tests {
         e.push_back(17);
         e.push_back(137);
         e.push_back(137);
-        assert!(&e == &d);
+        assert_eq!(&e, &d);
         e.pop_back();
         e.push_back(0);
         assert!(e != d);
         e.clear();
-        assert!(e == RingBuf::new());
+        assert_eq!(e, RingBuf::new());
     }
 }

branches/try2/src/libgetopts/lib.rs

@@ -1361,7 +1361,7 @@ mod tests {
                                 aliases: ~[] }];
         let verbose = reqopt("b", "banana", "some bananas", "VAL");
 
-        assert!(verbose.long_to_short() == short);
+        assert_eq!(verbose.long_to_short(), short);
     }
 
     #[test]

branches/try2/src/libnative/io/process.rs

@@ -470,7 +470,7 @@ fn spawn_process_os(config: p::ProcessConfig,
                 Err(e) => {
                     assert!(e.kind == io::BrokenPipe ||
                             e.kind == io::EndOfFile,
-                            "unexpected error: {}", e);
+                            "unexpected error: {:?}", e);
                     Ok(SpawnProcessResult {
                         pid: pid,
                         handle: ptr::null()
@@ -744,7 +744,7 @@ fn waitpid(pid: pid_t) -> p::ProcessExit {
 
         let mut status = 0 as c_int;
         match retry(|| unsafe { wait::waitpid(pid, &mut status, 0) }) {
-            -1 => fail!("unknown waitpid error: {}", super::last_error()),
+            -1 => fail!("unknown waitpid error: {:?}", super::last_error()),
             _ => {
                 if imp::WIFEXITED(status) {
                     p::ExitStatus(imp::WEXITSTATUS(status) as int)

branches/try2/src/libnum/bigint.rs

@@ -829,7 +829,7 @@ fn get_radix_base(radix: uint) -> (uint, uint) {
 }
 
 /// A Sign is a `BigInt`'s composing element.
-#[deriving(Eq, Clone, Show)]
+#[deriving(Eq, Clone)]
 pub enum Sign { Minus, Zero, Plus }
 
 impl Ord for Sign {

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

@@ -8,9 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 use back::archive::{Archive, METADATA_FILENAME};
 use back::rpath;
-use back::svh::Svh;
 use driver::driver::{CrateTranslation, OutputFilenames};
 use driver::session::Session;
 use driver::session;
@@ -499,31 +499,28 @@ pub mod write {
  *    system linkers understand.
  */
 
-pub fn find_crate_id(attrs: &[ast::Attribute],
-                     output: &OutputFilenames) -> CrateId {
-    match attr::find_crateid(attrs) {
+pub fn build_link_meta(attrs: &[ast::Attribute],
+                       output: &OutputFilenames,
+                       symbol_hasher: &mut Sha256)
+                       -> LinkMeta {
+    // This calculates CMH as defined above
+    fn crate_hash(symbol_hasher: &mut Sha256, crateid: &CrateId) -> ~str {
+        symbol_hasher.reset();
+        symbol_hasher.input_str(crateid.to_str());
+        truncated_hash_result(symbol_hasher)
+    }
+
+    let crateid = match attr::find_crateid(attrs) {
         None => from_str(output.out_filestem).unwrap(),
         Some(s) => s,
-    }
-}
+    };
 
-pub fn crate_id_hash(crate_id: &CrateId) -> ~str {
-    // This calculates CMH as defined above. Note that we don't use the path of
-    // the crate id in the hash because lookups are only done by (name/vers),
-    // not by path.
-    let mut s = Sha256::new();
-    s.input_str(crate_id.short_name_with_version());
-    truncated_hash_result(&mut s).slice_to(8).to_owned()
-}
+    let hash = crate_hash(symbol_hasher, &crateid);
 
-pub fn build_link_meta(krate: &ast::Crate,
-                       output: &OutputFilenames) -> LinkMeta {
-    let r = LinkMeta {
-        crateid: find_crate_id(krate.attrs, output),
-        crate_hash: Svh::calculate(krate),
-    };
-    info!("{}", r);
-    return r;
+    LinkMeta {
+        crateid: crateid,
+        crate_hash: hash,
+    }
 }
 
 fn truncated_hash_result(symbol_hasher: &mut Sha256) -> ~str {
@@ -542,7 +539,7 @@ fn symbol_hash(tcx: ty::ctxt, symbol_hasher: &mut Sha256,
     symbol_hasher.reset();
     symbol_hasher.input_str(link_meta.crateid.name);
     symbol_hasher.input_str("-");
-    symbol_hasher.input_str(link_meta.crate_hash.as_str());
+    symbol_hasher.input_str(link_meta.crate_hash);
     symbol_hasher.input_str("-");
     symbol_hasher.input_str(encoder::encoded_ty(tcx, t));
     let mut hash = truncated_hash_result(symbol_hasher);
@@ -715,8 +712,11 @@ pub fn mangle_internal_name_by_path_and_seq(path: PathElems, flav: &str) -> ~str
     mangle(path.chain(Some(gensym_name(flav)).move_iter()), None, None)
 }
 
-pub fn output_lib_filename(id: &CrateId) -> ~str {
-    format!("{}-{}-{}", id.name, crate_id_hash(id), id.version_or_default())
+pub fn output_lib_filename(lm: &LinkMeta) -> ~str {
+    format!("{}-{}-{}",
+            lm.crateid.name,
+            lm.crate_hash.slice_chars(0, 8),
+            lm.crateid.version_or_default())
 }
 
 pub fn get_cc_prog(sess: Session) -> ~str {
@@ -779,11 +779,11 @@ fn remove(sess: Session, path: &Path) {
 pub fn link_binary(sess: Session,
                    trans: &CrateTranslation,
                    outputs: &OutputFilenames,
-                   id: &CrateId) -> ~[Path] {
+                   lm: &LinkMeta) -> ~[Path] {
     let mut out_filenames = ~[];
     let crate_types = sess.crate_types.borrow();
     for &crate_type in crate_types.get().iter() {
-        let out_file = link_binary_output(sess, trans, crate_type, outputs, id);
+        let out_file = link_binary_output(sess, trans, crate_type, outputs, lm);
         out_filenames.push(out_file);
     }
 
@@ -807,8 +807,8 @@ fn is_writeable(p: &Path) -> bool {
 }
 
 pub fn filename_for_input(sess: &Session, crate_type: session::CrateType,
-                          id: &CrateId, out_filename: &Path) -> Path {
-    let libname = output_lib_filename(id);
+                          lm: &LinkMeta, out_filename: &Path) -> Path {
+    let libname = output_lib_filename(lm);
     match crate_type {
         session::CrateTypeRlib => {
             out_filename.with_filename(format!("lib{}.rlib", libname))
@@ -834,13 +834,13 @@ fn link_binary_output(sess: Session,
                       trans: &CrateTranslation,
                       crate_type: session::CrateType,
                       outputs: &OutputFilenames,
-                      id: &CrateId) -> Path {
+                      lm: &LinkMeta) -> Path {
     let obj_filename = outputs.temp_path(OutputTypeObject);
     let out_filename = match outputs.single_output_file {
         Some(ref file) => file.clone(),
         None => {
             let out_filename = outputs.path(OutputTypeExe);
-            filename_for_input(&sess, crate_type, id, &out_filename)
+            filename_for_input(&sess, crate_type, lm, &out_filename)
         }
     };
 

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

@@ -215,7 +215,7 @@ mod test {
     #[test]
     fn test_minimize1() {
         let res = minimize_rpaths([~"rpath1", ~"rpath2", ~"rpath1"]);
-        assert!(res.as_slice() == [~"rpath1", ~"rpath2"]);
+        assert_eq!(res.as_slice(), [~"rpath1", ~"rpath2"]);
     }
 
     #[test]
@@ -224,7 +224,7 @@ mod test {
                                    ~"1a", ~"4a", ~"1a",
                                    ~"2",  ~"3",  ~"4a",
                                    ~"3"]);
-        assert!(res.as_slice() == [~"1a", ~"2", ~"4a", ~"3"]);
+        assert_eq!(res.as_slice(), [~"1a", ~"2", ~"4a", ~"3"]);
     }
 
     #[test]