Rebasing changes

Author: nrc

src/libcollections/ringbuf.rs

@@ -243,7 +243,8 @@ impl<T> RingBuf<T> {
     /// buf.push(5i);
     /// buf.push(3);
     /// buf.push(4);
-    /// assert_eq!(buf.iter().collect::<Vec<&int>>().as_slice(), &[&5, &3, &4]);
+    /// let b: &[_] = &[&5, &3, &4];
+    /// assert_eq!(buf.iter().collect::<Vec<&int>>().as_slice(), b);
     /// ```
     pub fn iter<'a>(&'a self) -> Items<'a, T> {
         Items{index: 0, rindex: self.nelts, lo: self.lo, elts: self.elts.as_slice()}
@@ -263,7 +264,8 @@ impl<T> RingBuf<T> {
     /// for num in buf.mut_iter() {
     ///     *num = *num - 2;
     /// }
-    /// assert_eq!(buf.mut_iter().collect::<Vec<&mut int>>().as_slice(), &[&mut 3, &mut 1, &mut 2]);
+    /// let b: &[_] = &[&mut 3, &mut 1, &mut 2];
+    /// assert_eq!(buf.mut_iter().collect::<Vec<&mut int>>().as_slice(), b);
     /// ```
     pub fn mut_iter<'a>(&'a mut self) -> MutItems<'a, T> {
         let start_index = raw_index(self.lo, self.elts.len(), 0);

src/libcollections/str.rs

@@ -1971,7 +1971,7 @@ mod tests {
         use std::iter::order;
         // official Unicode test data
         // from http://www.unicode.org/Public/UCD/latest/ucd/auxiliary/GraphemeBreakTest.txt
-        let test_same = [
+        let test_same: [(_, &[_]), .. 325] = [
             ("\u0020\u0020", &["\u0020", "\u0020"]), ("\u0020\u0308\u0020", &["\u0020\u0308",
             "\u0020"]), ("\u0020\u000D", &["\u0020", "\u000D"]), ("\u0020\u0308\u000D",
             &["\u0020\u0308", "\u000D"]), ("\u0020\u000A", &["\u0020", "\u000A"]),
@@ -2180,7 +2180,7 @@ mod tests {
             ("\u0646\u200D\u0020", &["\u0646\u200D", "\u0020"]),
         ];
 
-        let test_diff = [
+        let test_diff: [(_, &[_], &[_]), .. 23] = [
             ("\u0020\u0903", &["\u0020\u0903"], &["\u0020", "\u0903"]), ("\u0020\u0308\u0903",
             &["\u0020\u0308\u0903"], &["\u0020\u0308", "\u0903"]), ("\u000D\u0308\u0903",
             &["\u000D", "\u0308\u0903"], &["\u000D", "\u0308", "\u0903"]), ("\u000A\u0308\u0903",
@@ -2229,9 +2229,11 @@ mod tests {
         // test the indices iterators
         let s = "a̐éö̲\r\n";
         let gr_inds = s.grapheme_indices(true).collect::<Vec<(uint, &str)>>();
-        assert_eq!(gr_inds.as_slice(), &[(0u, "a̐"), (3, "é"), (6, "ö̲"), (11, "\r\n")]);
+        let b: &[_] = &[(0u, "a̐"), (3, "é"), (6, "ö̲"), (11, "\r\n")];
+        assert_eq!(gr_inds.as_slice(), b);
         let gr_inds = s.grapheme_indices(true).rev().collect::<Vec<(uint, &str)>>();
-        assert_eq!(gr_inds.as_slice(), &[(11, "\r\n"), (6, "ö̲"), (3, "é"), (0u, "a̐")]);
+        let b: &[_] = &[(11, "\r\n"), (6, "ö̲"), (3, "é"), (0u, "a̐")];
+        assert_eq!(gr_inds.as_slice(), b);
         let mut gr_inds = s.grapheme_indices(true);
         let e1 = gr_inds.size_hint();
         assert_eq!(e1, (1, Some(13)));
@@ -2243,7 +2245,8 @@ mod tests {
         // make sure the reverse iterator does the right thing with "\n" at beginning of string
         let s = "\n\r\n\r";
         let gr = s.graphemes(true).rev().collect::<Vec<&str>>();
-        assert_eq!(gr.as_slice(), &["\r", "\r\n", "\n"]);
+        let b: &[_] = &["\r", "\r\n", "\n"];
+        assert_eq!(gr.as_slice(), b);
     }
 
     #[test]

src/libcollections/string.rs

@@ -531,7 +531,8 @@ impl String {
     ///
     /// ```
     /// let s = String::from_str("hello");
-    /// assert_eq!(s.as_bytes(), &[104, 101, 108, 108, 111]);
+    /// let b: &[_] = &[104, 101, 108, 108, 111];
+    /// assert_eq!(s.as_bytes(), b);
     /// ```
     #[inline]
     pub fn as_bytes<'a>(&'a self) -> &'a [u8] {
@@ -552,7 +553,8 @@ impl String {
     ///     bytes[1] = 51;
     ///     bytes[4] = 48;
     /// }
-    /// assert_eq!(s.as_bytes(), &[104, 51, 108, 108, 48]);
+    /// let b: &[_] = &[104, 51, 108, 108, 48];
+    /// assert_eq!(s.as_bytes(), b);
     /// assert_eq!(s.as_slice(), "h3ll0")
     /// ```
     #[inline]

src/libcore/cmp.rs

@@ -112,12 +112,13 @@ impl Ordering {
     /// assert_eq!(Greater.reverse(), Less);
     ///
     ///
-    /// let mut data = &mut [2u, 10, 5, 8];
+    /// let mut data: &mut [_] = &mut [2u, 10, 5, 8];
     ///
     /// // sort the array from largest to smallest.
     /// data.sort_by(|a, b| a.cmp(b).reverse());
     ///
-    /// assert_eq!(data, &mut [10u, 8, 5, 2]);
+    /// let b: &mut [_] = &mut [10u, 8, 5, 2];
+    /// assert!(data == b);
     /// ```
     #[inline]
     #[experimental]

src/libcore/option.rs

@@ -530,7 +530,10 @@ impl<T> Slice<T> for Option<T> {
     fn as_slice<'a>(&'a self) -> &'a [T] {
         match *self {
             Some(ref x) => slice::ref_slice(x),
-            None => &[]
+            None => {
+                let result: &[_] = &[];
+                result
+            }
         }
     }
 }

src/libcore/raw.rs

@@ -58,8 +58,8 @@ pub struct TraitObject {
 }
 #[cfg(not(stage0))]
 pub struct TraitObject {
-    pub data: *(),
-    pub vtable: *(),
+    pub data: *mut (),
+    pub vtable: *mut (),
 }
 
 /// This trait is meant to map equivalences between raw structs and their

src/libcore/slice.rs

@@ -1648,6 +1648,27 @@ impl<'a,T:PartialEq, V: Slice<T>> Equiv<V> for &'a [T] {
     fn equiv(&self, other: &V) -> bool { self.as_slice() == other.as_slice() }
 }
 
+#[unstable = "waiting for DST"]
+impl<'a,T:PartialEq> PartialEq for &'a mut [T] {
+    fn eq(&self, other: & &'a mut [T]) -> bool {
+        self.len() == other.len() &&
+        order::eq(self.iter(), other.iter())
+    }
+    fn ne(&self, other: & &'a mut [T]) -> bool {
+        self.len() != other.len() ||
+        order::ne(self.iter(), other.iter())
+    }
+}
+
+#[unstable = "waiting for DST"]
+impl<'a,T:Eq> Eq for &'a mut [T] {}
+
+#[unstable = "waiting for DST"]
+impl<'a,T:PartialEq, V: Slice<T>> Equiv<V> for &'a mut [T] {
+    #[inline]
+    fn equiv(&self, other: &V) -> bool { self.as_slice() == other.as_slice() }
+}
+
 #[unstable = "waiting for DST"]
 impl<'a,T:Ord> Ord for &'a [T] {
     fn cmp(&self, other: & &'a [T]) -> Ordering {

src/libcoretest/iter.rs

@@ -368,7 +368,7 @@ fn test_collect() {
 
 #[test]
 fn test_all() {
-    let v: Box<&[int]> = box &[1i, 2, 3, 4, 5];
+    let v: Box<[int]> = box [1i, 2, 3, 4, 5];
     assert!(v.iter().all(|&x| x < 10));
     assert!(!v.iter().all(|&x| x % 2 == 0));
     assert!(!v.iter().all(|&x| x > 100));
@@ -377,7 +377,7 @@ fn test_all() {
 
 #[test]
 fn test_any() {
-    let v: Box<&[int]> = box &[1i, 2, 3, 4, 5];
+    let v: Box<[int]> = box [1i, 2, 3, 4, 5];
     assert!(v.iter().any(|&x| x < 10));
     assert!(v.iter().any(|&x| x % 2 == 0));
     assert!(!v.iter().any(|&x| x > 100));

src/libdebug/reflect.rs

@@ -251,7 +251,7 @@ impl<V:TyVisitor + MovePtr> TyVisitor for MovePtrAdaptor<V> {
     }
     #[cfg(not(stage0))]
     fn visit_evec_fixed(&mut self, n: uint, sz: uint, align: uint,
-                        inner: *TyDesc) -> bool {
+                        inner: *const TyDesc) -> bool {
         self.align(align);
         if ! self.inner.visit_evec_fixed(n, sz, align, inner) {
             return false;

src/libdebug/repr.rs

@@ -342,7 +342,7 @@ impl<'a> TyVisitor for ReprVisitor<'a> {
 
     #[cfg(not(stage0))]
     fn visit_evec_fixed(&mut self, n: uint, sz: uint, _align: uint,
-                        inner: *TyDesc) -> bool {
+                        inner: *const TyDesc) -> bool {
         let assumed_size = if sz == 0 { n } else { sz };
         self.get::<()>(|this, b| {
             this.write_vec_range(b, assumed_size, inner)

src/liblibc/lib.rs

@@ -302,7 +302,7 @@ extern {}
 /// A wrapper for a nullable pointer. Don't use this except for interacting
 /// with libc. Basically Option, but without the dependence on libstd.
 // If/when libprim happens, this can be removed in favor of that
-pub enum Nullable<type T> {
+pub enum Nullable<T> {
     Null,
     NotNull(T)
 }

src/librbml/io.rs

@@ -96,7 +96,8 @@ impl Writer for SeekableMemWriter {
             let (left, right) = if cap <= buf.len() {
                 (buf.slice_to(cap), buf.slice_from(cap))
             } else {
-                (buf, &[])
+                let result: (_, &[_]) = (buf, &[]);
+                result
             };
 
             // Do the necessary writes
@@ -142,24 +143,29 @@ mod tests {
         writer.write([1, 2, 3]).unwrap();
         writer.write([4, 5, 6, 7]).unwrap();
         assert_eq!(writer.tell(), Ok(8));
-        assert_eq!(writer.get_ref(), &[0, 1, 2, 3, 4, 5, 6, 7]);
+        let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
+        assert_eq!(writer.get_ref(), b);
 
         writer.seek(0, io::SeekSet).unwrap();
         assert_eq!(writer.tell(), Ok(0));
         writer.write([3, 4]).unwrap();
-        assert_eq!(writer.get_ref(), &[3, 4, 2, 3, 4, 5, 6, 7]);
+        let b: &[_] = &[3, 4, 2, 3, 4, 5, 6, 7];
+        assert_eq!(writer.get_ref(), b);
 
         writer.seek(1, io::SeekCur).unwrap();
         writer.write([0, 1]).unwrap();
-        assert_eq!(writer.get_ref(), &[3, 4, 2, 0, 1, 5, 6, 7]);
+        let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 7];
+        assert_eq!(writer.get_ref(), b);
 
         writer.seek(-1, io::SeekEnd).unwrap();
         writer.write([1, 2]).unwrap();
-        assert_eq!(writer.get_ref(), &[3, 4, 2, 0, 1, 5, 6, 1, 2]);
+        let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 1, 2];
+        assert_eq!(writer.get_ref(), b);
 
         writer.seek(1, io::SeekEnd).unwrap();
         writer.write([1]).unwrap();
-        assert_eq!(writer.get_ref(), &[3, 4, 2, 0, 1, 5, 6, 1, 2, 0, 1]);
+        let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 1, 2, 0, 1];
+        assert_eq!(writer.get_ref(), b);
     }
 
     #[test]

src/librlibc/lib.rs

@@ -49,7 +49,7 @@
 // implementations below. If pointer arithmetic is done through integers the
 // optimizations start to break down.
 extern "rust-intrinsic" {
-    fn offset<type T>(dst: *const T, offset: int) -> *const T;
+    fn offset<T>(dst: *const T, offset: int) -> *const T;
 }
 
 #[no_mangle]

src/librustc/diagnostics.rs

@@ -34,7 +34,6 @@ register_diagnostics!(
     E0015,
     E0016,
     E0017,
-    E0018,
     E0019,
     E0020,
     E0021,
@@ -53,7 +52,6 @@ register_diagnostics!(
     E0034,
     E0035,
     E0036,
-    E0037,
     E0038,
     E0039,
     E0040,
@@ -80,8 +78,6 @@ register_diagnostics!(
     E0061,
     E0062,
     E0063,
-    E0064,
-    E0065,
     E0066,
     E0067,
     E0068,
@@ -127,8 +123,6 @@ register_diagnostics!(
     E0108,
     E0109,
     E0110,
-    E0111,
-    E0112,
     E0113,
     E0114,
     E0115,

src/librustc/front/test.rs

@@ -477,10 +477,10 @@ fn mk_test_descs(cx: &TestCtxt) -> Gc<ast::Expr> {
 
     box(GC) ast::Expr {
         id: ast::DUMMY_NODE_ID,
-        node: ast::ExprAddrOf(box(GC) ast::MutImmutable,
+        node: ast::ExprAddrOf(ast::MutImmutable,
             box(GC) ast::Expr {
                 id: ast::DUMMY_NODE_ID,
-                node: ast::ExprVec(cx.testfns.borrow().iter().map(|test| {
+                node: ast::ExprVec(cx.testfns.iter().map(|test| {
                     mk_test_desc_and_fn_rec(cx, test)
             }).collect()),
             span: DUMMY_SP,

src/librustc/lint/builtin.rs

@@ -1556,6 +1556,9 @@ declare_lint!(pub UNKNOWN_CRATE_TYPE, Deny,
 declare_lint!(pub VARIANT_SIZE_DIFFERENCE, Allow,
               "detects enums with widely varying variant sizes")
 
+declare_lint!(pub TRANSMUTE_FAT_PTR, Allow,
+              "detects transmutes of fat pointers")
+
 /// Does nothing as a lint pass, but registers some `Lint`s
 /// which are used by other parts of the compiler.
 pub struct HardwiredLints;

src/librustc/middle/astencode.rs

@@ -1029,6 +1029,8 @@ impl<'a> rbml_writer_helpers for Encoder<'a> {
     }
 
     fn emit_autoref(&mut self, ecx: &e::EncodeContext, autoref: &ty::AutoRef) {
+        use serialize::Encoder;
+
         self.emit_enum("AutoRef", |this| {
             match autoref {
                 &ty::AutoPtr(r, m, None) => {
@@ -1067,6 +1069,8 @@ impl<'a> rbml_writer_helpers for Encoder<'a> {
     }
 
     fn emit_auto_deref_ref(&mut self, ecx: &e::EncodeContext, auto_deref_ref: &ty::AutoDerefRef) {
+        use serialize::Encoder;
+
         self.emit_struct("AutoDerefRef", 2, |this| {
             this.emit_struct_field("autoderefs", 0, |this| auto_deref_ref.autoderefs.encode(this));
             this.emit_struct_field("autoref", 1, |this| {
@@ -1081,6 +1085,8 @@ impl<'a> rbml_writer_helpers for Encoder<'a> {
     }
 
     fn emit_unsize_kind(&mut self, ecx: &e::EncodeContext, uk: &ty::UnsizeKind) {
+        use serialize::Encoder;
+
         self.emit_enum("UnsizeKind", |this| {
             match *uk {
                 ty::UnsizeLength(len) => {
@@ -1286,7 +1292,7 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext,
             _ if ty::adjust_is_object(adjustment) => {
                 let method_call = MethodCall::autoobject(id);
                 for &method in tcx.method_map.borrow().find(&method_call).iter() {
-                    rbml_w.tag(c::tag_table_method_map, |ebml_w| {
+                    rbml_w.tag(c::tag_table_method_map, |rbml_w| {
                         rbml_w.id(id);
                         rbml_w.tag(c::tag_table_val, |rbml_w| {
                             encode_method_callee(ecx, rbml_w, method_call.adjustment, method)
@@ -1297,7 +1303,7 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext,
                 for &dr in tcx.vtable_map.borrow().find(&method_call).iter() {
                     rbml_w.tag(c::tag_table_vtable_map, |rbml_w| {
                         rbml_w.id(id);
-                        rbml_w.tag(c::tag_table_val, |ebml_w| {
+                        rbml_w.tag(c::tag_table_val, |rbml_w| {
                             encode_vtable_res_with_key(ecx, rbml_w, method_call.adjustment, dr);
                         })
                     })
@@ -1336,7 +1342,7 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext,
         rbml_w.tag(c::tag_table_adjustments, |rbml_w| {
             rbml_w.id(id);
             rbml_w.tag(c::tag_table_val, |rbml_w| {
-                rbml_w.emit_auto_adjustment(ecx, adj);
+                rbml_w.emit_auto_adjustment(ecx, adjustment);
             })
         })
     }

src/librustc/middle/check_const.rs

@@ -182,7 +182,7 @@ fn check_expr(v: &mut CheckCrateVisitor, e: &Expr, is_const: bool) {
                     // Mutable slices are allowed.
                     ExprVec(_) => {}
                     _ => span_err!(v.tcx.sess, e.span, E0017,
-                                   "references in constants may only refer to immutable values");
+                                   "references in constants may only refer to immutable values")
 
                 }
           },

src/librustc/middle/intrinsicck.rs

@@ -92,7 +92,7 @@ impl<'a> IntrinsicCheckingVisitor<'a> {
         }
     }
 
-    fn check_transmute(&self, span: Span, from: ty::t, to: ty::t) {
+    fn check_transmute(&self, span: Span, from: ty::t, to: ty::t, id: ast::NodeId) {
         if type_size_is_affected_by_type_parameters(self.tcx, from) {
             span_err!(self.tcx.sess, span, E0139,
                       "cannot transmute from a type that contains type parameters");
@@ -106,6 +106,7 @@ impl<'a> IntrinsicCheckingVisitor<'a> {
             span: span,
             from: from,
             to: to,
+            id: id,
         };
         self.tcx.transmute_restrictions.borrow_mut().push(restriction);
     }
@@ -123,7 +124,7 @@ impl<'a> Visitor<()> for IntrinsicCheckingVisitor<'a> {
                                     if bare_fn_ty.abi == RustIntrinsic => {
                                 let from = *bare_fn_ty.sig.inputs.get(0);
                                 let to = bare_fn_ty.sig.output;
-                                self.check_transmute(expr.span, from, to);
+                                self.check_transmute(expr.span, from, to, expr.id);
                             }
                             _ => {
                                 self.tcx