---

yaml
---
r: 149679
b: refs/heads/try2
c: 715e618
h: refs/heads/master
i:
  149677: 19aa36c
  149675: b955833
  149671: f560c95
  149663: 1b7d04f
v: v3

Author: luqmana

[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: d60e43d9e9470107b3c1ebbd5dbd69a6a080f143
+refs/heads/try2: 715e618577381ea820d24664dc65b3b2f9ca3285
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

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/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]

branches/try2/src/librustc/driver/driver.rs

@@ -930,7 +930,7 @@ pub fn build_session(sopts: @session::Options,
                      -> Session {
     let codemap = @codemap::CodeMap::new();
     let diagnostic_handler =
-        diagnostic::default_handler();
+        diagnostic::mk_handler();
     let span_diagnostic_handler =
         diagnostic::mk_span_handler(diagnostic_handler, codemap);
 
@@ -1148,8 +1148,7 @@ pub fn build_output_filenames(input: &Input,
 }
 
 pub fn early_error(msg: &str) -> ! {
-    let mut emitter = diagnostic::EmitterWriter::stderr();
-    emitter.emit(None, msg, diagnostic::Fatal);
+    diagnostic::DefaultEmitter.emit(None, msg, diagnostic::Fatal);
     fail!(diagnostic::FatalError);
 }
 

branches/try2/src/librustc/lib.rs

@@ -384,8 +384,7 @@ pub fn monitor(f: proc()) {
         Err(value) => {
             // Task failed without emitting a fatal diagnostic
             if !value.is::<diagnostic::FatalError>() {
-                let mut emitter = diagnostic::EmitterWriter::stderr();
-                emitter.emit(
+                diagnostic::DefaultEmitter.emit(
                     None,
                     diagnostic::ice_msg("unexpected failure"),
                     diagnostic::Error);
@@ -395,7 +394,9 @@ pub fn monitor(f: proc()) {
                      this is a bug",
                 ];
                 for note in xs.iter() {
-                    emitter.emit(None, *note, diagnostic::Note)
+                    diagnostic::DefaultEmitter.emit(None,
+                                                    *note,
+                                                    diagnostic::Note)
                 }
 
                 println!("{}", r.read_to_str());

branches/try2/src/librustc/middle/astencode.rs

@@ -1468,7 +1468,7 @@ fn roundtrip(in_item: Option<@ast::Item>) {
     let ebml_doc = reader::Doc(wr.get_ref());
     let out_item = decode_item_ast(ebml_doc);
 
-    assert!(in_item == out_item);
+    assert_eq!(in_item, out_item);
 }
 
 #[test]

branches/try2/src/librustc/middle/graph.rs

@@ -349,19 +349,19 @@ mod test {
                                       start_data: N,
                                       expected_incoming: &[(E,N)],
                                       expected_outgoing: &[(E,N)]) {
-        assert!(graph.node_data(start_index) == &start_data);
+        assert_eq!(graph.node_data(start_index), &start_data);
 
         let mut counter = 0;
         graph.each_incoming_edge(start_index, |edge_index, edge| {
-            assert!(graph.edge_data(edge_index) == &edge.data);
+            assert_eq!(graph.edge_data(edge_index), &edge.data);
             assert!(counter < expected_incoming.len());
             debug!("counter={:?} expected={:?} edge_index={:?} edge={:?}",
                    counter, expected_incoming[counter], edge_index, edge);
             match expected_incoming[counter] {
                 (ref e, ref n) => {
-                    assert!(e == &edge.data);
-                    assert!(n == graph.node_data(edge.source));
-                    assert!(start_index == edge.target);
+                    assert_eq!(e, &edge.data);
+                    assert_eq!(n, graph.node_data(edge.source));
+                    assert_eq!(start_index, edge.target);
                 }
             }
             counter += 1;
@@ -371,15 +371,15 @@ mod test {
 
         let mut counter = 0;
         graph.each_outgoing_edge(start_index, |edge_index, edge| {
-            assert!(graph.edge_data(edge_index) == &edge.data);
+            assert_eq!(graph.edge_data(edge_index), &edge.data);
             assert!(counter < expected_outgoing.len());
             debug!("counter={:?} expected={:?} edge_index={:?} edge={:?}",
                    counter, expected_outgoing[counter], edge_index, edge);
             match expected_outgoing[counter] {
                 (ref e, ref n) => {
-                    assert!(e == &edge.data);
-                    assert!(start_index == edge.source);
-                    assert!(n == graph.node_data(edge.target));
+                    assert_eq!(e, &edge.data);
+                    assert_eq!(start_index, edge.source);
+                    assert_eq!(n, graph.node_data(edge.target));
                 }
             }
             counter += 1;

branches/try2/src/librustc/middle/trans/_match.rs

@@ -1528,7 +1528,7 @@ fn compile_submatch_continue<'r,
         Some(ref rec_fields) => {
             let pat_ty = node_id_type(bcx, pat_id);
             let pat_repr = adt::represent_type(bcx.ccx(), pat_ty);
-            expr::with_field_tys(tcx, pat_ty, None, |discr, field_tys| {
+            expr::with_field_tys(tcx, pat_ty, Some(pat_id), |discr, field_tys| {
                 let rec_vals = rec_fields.map(|field_name| {
                         let ix = ty::field_idx_strict(tcx, field_name.name, field_tys);
                         adt::trans_field_ptr(bcx, pat_repr, val, discr, ix)
@@ -2208,7 +2208,7 @@ fn bind_irrefutable_pat<'a>(
             let tcx = bcx.tcx();
             let pat_ty = node_id_type(bcx, pat.id);
             let pat_repr = adt::represent_type(bcx.ccx(), pat_ty);
-            expr::with_field_tys(tcx, pat_ty, None, |discr, field_tys| {
+            expr::with_field_tys(tcx, pat_ty, Some(pat.id), |discr, field_tys| {
                 for f in fields.iter() {
                     let ix = ty::field_idx_strict(tcx, f.ident.name, field_tys);
                     let fldptr = adt::trans_field_ptr(bcx, pat_repr, val,

branches/try2/src/librustc/middle/trans/type_.rs

@@ -25,7 +25,7 @@ use std::cast;
 
 use std::libc::{c_uint};
 
-#[deriving(Clone, Eq, Show)]
+#[deriving(Clone, Eq)]
 pub struct Type {
     priv rf: TypeRef
 }

branches/try2/src/librustc/middle/typeck/check/mod.rs

@@ -1732,13 +1732,7 @@ pub fn check_expr_with_unifier(fcx: @FnCtxt,
                                 ty::ty_rptr(_, mt) => formal_ty = mt.ty,
                                 ty::ty_err => (),
                                 _ => {
-                                    // So we hit this case when one implements the
-                                    // operator traits but leaves an argument as
-                                    // just T instead of &T. We'll catch it in the
-                                    // mismatch impl/trait method phase no need to
-                                    // ICE here.
-                                    // See: #11450
-                                    formal_ty = ty::mk_err();
+                                    fcx.ccx.tcx.sess.span_bug(arg.span, "no ref");
                                 }
                             }
                         }

branches/try2/src/librustc/middle/typeck/infer/region_inference/mod.rs

@@ -761,7 +761,7 @@ impl RegionVarBindings {
 
 // ______________________________________________________________________
 
-#[deriving(Eq, Show)]
+#[deriving(Eq)]
 enum Classification { Expanding, Contracting }
 
 enum VarValue { NoValue, Value(Region), ErrorValue }