Test fixes and rebase conflicts

Author: alexcrichton

src/libcollections/lib.rs

@@ -21,6 +21,7 @@
        html_root_url = "http://doc.rust-lang.org/nightly/",
        html_playground_url = "http://play.rust-lang.org/")]
 
+#![allow(unknown_features)]
 #![feature(unsafe_destructor, slicing_syntax)]
 #![feature(old_impl_check)]
 #![no_std]

src/libcollections/str.rs

@@ -1339,6 +1339,12 @@ pub trait StrExt: Index<FullRange, Output = str> {
     fn trim_left(&self) -> &str {
         UnicodeStr::trim_left(self.index(&FullRange))
     }
+
+    /// Returns a string with trailing whitespace removed.
+    #[stable]
+    fn trim_right(&self) -> &str {
+        UnicodeStr::trim_right(self.index(&FullRange))
+    }
 }
 
 #[stable]

src/libcore/intrinsics.rs

@@ -42,6 +42,9 @@
 #![experimental]
 #![allow(missing_docs)]
 
+#[cfg(not(stage0))]
+use marker::Sized;
+
 pub type GlueFn = extern "Rust" fn(*const i8);
 
 #[lang="ty_desc"]
@@ -200,7 +203,10 @@ extern "rust-intrinsic" {
     /// Gets an identifier which is globally unique to the specified type. This
     /// function will return the same value for a type regardless of whichever
     /// crate it is invoked in.
+    #[cfg(not(stage0))]
     pub fn type_id<T: ?Sized + 'static>() -> TypeId;
+    #[cfg(stage0)]
+    pub fn type_id<T: 'static>() -> TypeId;
 
     /// Create a value initialized to zero.
     ///
@@ -550,7 +556,16 @@ pub struct TypeId {
 }
 
 impl TypeId {
-    /// Returns the `TypeId` of the type this generic function has been instantiated with
+    /// Returns the `TypeId` of the type this generic function has been
+    /// instantiated with
+    #[cfg(stage0)]
+    pub fn of<T: 'static>() -> TypeId {
+        unsafe { type_id::<T>() }
+    }
+
+    /// Returns the `TypeId` of the type this generic function has been
+    /// instantiated with
+    #[cfg(not(stage0))]
     pub fn of<T: ?Sized + 'static>() -> TypeId {
         unsafe { type_id::<T>() }
     }

src/libcore/slice.rs

@@ -733,7 +733,7 @@ macro_rules! iterator {
 }
 
 macro_rules! make_slice {
-    ($t: ty -> $result: ty: $start: expr, $end: expr) => {{
+    ($t: ty => $result: ty: $start: expr, $end: expr) => {{
         let diff = $end as uint - $start as uint;
         let len = if mem::size_of::<T>() == 0 {
             diff
@@ -797,7 +797,7 @@ impl<'a, T> Iter<'a, T> {
     /// iterator can continue to be used while this exists.
     #[experimental]
     pub fn as_slice(&self) -> &'a [T] {
-        make_slice!(T -> &'a [T]: self.ptr, self.end)
+        make_slice!(T => &'a [T]: self.ptr, self.end)
     }
 }
 
@@ -876,7 +876,7 @@ impl<'a, T> ops::Index<ops::FullRange> for IterMut<'a, T> {
     type Output = [T];
     #[inline]
     fn index(&self, _index: &ops::FullRange) -> &[T] {
-        make_slice!(T -> &[T]: self.ptr, self.end)
+        make_slice!(T => &[T]: self.ptr, self.end)
     }
 }
 
@@ -909,7 +909,7 @@ impl<'a, T> ops::IndexMut<ops::FullRange> for IterMut<'a, T> {
     type Output = [T];
     #[inline]
     fn index_mut(&mut self, _index: &ops::FullRange) -> &mut [T] {
-        make_slice!(T -> &mut [T]: self.ptr, self.end)
+        make_slice!(T => &mut [T]: self.ptr, self.end)
     }
 }
 
@@ -923,7 +923,7 @@ impl<'a, T> IterMut<'a, T> {
     /// restricted lifetimes that do not consume the iterator.
     #[experimental]
     pub fn into_slice(self) -> &'a mut [T] {
-        make_slice!(T -> &'a mut [T]: self.ptr, self.end)
+        make_slice!(T => &'a mut [T]: self.ptr, self.end)
     }
 }
 

src/librustc/lib.rs

@@ -22,6 +22,7 @@
       html_favicon_url = "http://www.rust-lang.org/favicon.ico",
       html_root_url = "http://doc.rust-lang.org/nightly/")]
 
+#![allow(unknown_features)]
 #![feature(quote)]
 #![feature(slicing_syntax, unsafe_destructor)]
 #![feature(rustc_diagnostic_macros)]

src/librustc/middle/mem_categorization.rs

@@ -486,9 +486,9 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
             let method_call = ty::MethodCall::expr(expr.id());
             match self.typer.node_method_ty(method_call) {
                 Some(method_ty) => {
-                    // If this is an index implemented by a method call, then it will
-                    // include an implicit deref of the result.
-                    let ret_ty = ty::ty_fn_ret(method_ty).unwrap();
+                    // If this is an index implemented by a method call, then it
+                    // will include an implicit deref of the result.
+                    let ret_ty = self.overloaded_method_return_ty(method_ty);
                     self.cat_deref(expr,
                                    self.cat_rvalue_node(expr.id(),
                                                         expr.span(),

src/librustc_typeck/check/mod.rs

@@ -2405,7 +2405,7 @@ fn try_index_step<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
 
     // First, try built-in indexing.
     match (ty::index(adjusted_ty), &index_ty.sty) {
-        (Some(ty), &ty::ty_uint(ast::TyU)) | (Some(ty), &ty::ty_infer(ty::IntVar(_))) => {
+        (Some(ty), &ty::ty_uint(ast::TyUs)) | (Some(ty), &ty::ty_infer(ty::IntVar(_))) => {
             debug!("try_index_step: success, using built-in indexing");
             fcx.write_adjustment(base_expr.id, base_expr.span, ty::AdjustDerefRef(adjustment));
             return Some((tcx.types.uint, ty));

src/librustc_typeck/collect.rs

@@ -171,7 +171,7 @@ impl<'a, 'tcx> AstConv<'tcx> for CollectCtxt<'a, 'tcx> {
             x => {
                 self.tcx.sess.bug(format!("unexpected sort of node \
                                            in get_item_type_scheme(): {:?}",
-                                          x)[]);
+                                          x).as_slice());
             }
         }
     }

src/libserialize/lib.rs

@@ -25,6 +25,7 @@ Core encoding and decoding interfaces.
 #![allow(unknown_features)]
 #![feature(slicing_syntax)]
 #![feature(old_impl_check)]
+#![cfg_attr(stage0, allow(unused_attributes))]
 
 // test harness access
 #[cfg(test)] extern crate test;

src/libserialize/serialize.rs

@@ -499,7 +499,7 @@ macro_rules! peel {
 /// Evaluates to the number of identifiers passed to it, for example: `count_idents!(a, b, c) == 3
 macro_rules! count_idents {
     () => { 0u };
-    ($_i:ident, $($rest:ident),*) => { 1 + count_idents!($($rest),*) }
+    ($_i:ident, $($rest:ident,)*) => { 1 + count_idents!($($rest,)*) }
 }
 
 macro_rules! tuple {
@@ -508,7 +508,7 @@ macro_rules! tuple {
         impl<$($name:Decodable),*> Decodable for ($($name,)*) {
             #[allow(non_snake_case)]
             fn decode<D: Decoder>(d: &mut D) -> Result<($($name,)*), D::Error> {
-                let len: uint = count_idents!($($name),*);
+                let len: uint = count_idents!($($name,)*);
                 d.read_tuple(len, |d| {
                     let mut i = 0;
                     let ret = ($(try!(d.read_tuple_arg({ i+=1; i-1 },