More test fixes!

Author: alexcrichton

src/libcollections/dlist.rs

@@ -1066,6 +1066,7 @@ mod tests {
     }
 
     #[allow(deprecated)]
+    #[test]
     fn test_append() {
         {
             let mut m = DList::new();

src/libcore/iter.rs

@@ -1171,134 +1171,6 @@ impl_multiplicative! { uint, 1 }
 impl_multiplicative! { f32,  1.0 }
 impl_multiplicative! { f64,  1.0 }
 
-<<<<<<< HEAD
-=======
-/// A trait for iterators over elements which can be compared to one another.
-#[unstable = "recently renamed for new extension trait conventions"]
-pub trait IteratorOrdExt<A> {
-    /// Consumes the entire iterator to return the maximum element.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// let a = [1i, 2, 3, 4, 5];
-    /// assert!(a.iter().max().unwrap() == &5);
-    /// ```
-    fn max(self) -> Option<A>;
-
-    /// Consumes the entire iterator to return the minimum element.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// let a = [1i, 2, 3, 4, 5];
-    /// assert!(a.iter().min().unwrap() == &1);
-    /// ```
-    fn min(self) -> Option<A>;
-
-    /// `min_max` finds the minimum and maximum elements in the iterator.
-    ///
-    /// The return type `MinMaxResult` is an enum of three variants:
-    ///
-    /// - `NoElements` if the iterator is empty.
-    /// - `OneElement(x)` if the iterator has exactly one element.
-    /// - `MinMax(x, y)` is returned otherwise, where `x <= y`. Two
-    ///    values are equal if and only if there is more than one
-    ///    element in the iterator and all elements are equal.
-    ///
-    /// On an iterator of length `n`, `min_max` does `1.5 * n` comparisons,
-    /// and so is faster than calling `min` and `max` separately which does `2 * n` comparisons.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use std::iter::MinMaxResult::{NoElements, OneElement, MinMax};
-    ///
-    /// let v: [int; 0] = [];
-    /// assert_eq!(v.iter().min_max(), NoElements);
-    ///
-    /// let v = [1i];
-    /// assert!(v.iter().min_max() == OneElement(&1));
-    ///
-    /// let v = [1i, 2, 3, 4, 5];
-    /// assert!(v.iter().min_max() == MinMax(&1, &5));
-    ///
-    /// let v = [1i, 2, 3, 4, 5, 6];
-    /// assert!(v.iter().min_max() == MinMax(&1, &6));
-    ///
-    /// let v = [1i, 1, 1, 1];
-    /// assert!(v.iter().min_max() == MinMax(&1, &1));
-    /// ```
-    fn min_max(self) -> MinMaxResult<A>;
-}
-
-#[unstable = "trait is unstable"]
-impl<T, I> IteratorOrdExt<T> for I where I: Iterator<Item=T>, T: Ord {
-    #[inline]
-    fn max(self) -> Option<T> {
-        self.fold(None, |max, x| {
-            match max {
-                None    => Some(x),
-                Some(y) => Some(cmp::max(x, y))
-            }
-        })
-    }
-
-    #[inline]
-    fn min(self) -> Option<T> {
-        self.fold(None, |min, x| {
-            match min {
-                None    => Some(x),
-                Some(y) => Some(cmp::min(x, y))
-            }
-        })
-    }
-
-    fn min_max(mut self) -> MinMaxResult<T> {
-        let (mut min, mut max) = match self.next() {
-            None => return NoElements,
-            Some(x) => {
-                match self.next() {
-                    None => return OneElement(x),
-                    Some(y) => if x < y {(x, y)} else {(y,x)}
-                }
-            }
-        };
-
-        loop {
-            // `first` and `second` are the two next elements we want to look at.
-            // We first compare `first` and `second` (#1). The smaller one is then compared to
-            // current minimum (#2). The larger one is compared to current maximum (#3). This
-            // way we do 3 comparisons for 2 elements.
-            let first = match self.next() {
-                None => break,
-                Some(x) => x
-            };
-            let second = match self.next() {
-                None => {
-                    if first < min {
-                        min = first;
-                    } else if first > max {
-                        max = first;
-                    }
-                    break;
-                }
-                Some(x) => x
-            };
-            if first < second {
-                if first < min {min = first;}
-                if max < second {max = second;}
-            } else {
-                if second < min {min = second;}
-                if max < first {max = first;}
-            }
-        }
-
-        MinMax(min, max)
-    }
-}
-
->>>>>>> parent of f031671... Remove i suffix in docs
 /// `MinMaxResult` is an enum returned by `min_max`. See `IteratorOrdExt::min_max` for more detail.
 #[derive(Clone, PartialEq, Show)]
 #[unstable = "unclear whether such a fine-grained result is widely useful"]
@@ -1386,35 +1258,6 @@ impl<T, D, I> ExactSizeIterator for Cloned<I> where
     I: ExactSizeIterator + Iterator<Item=D>,
 {}
 
-<<<<<<< HEAD
-=======
-#[unstable = "recently renamed for extension trait conventions"]
-/// An extension trait for cloneable iterators.
-pub trait CloneIteratorExt {
-    /// Repeats an iterator endlessly
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use std::iter::{CloneIteratorExt, count};
-    ///
-    /// let a = count(1i,1i).take(1);
-    /// let mut cy = a.cycle();
-    /// assert_eq!(cy.next(), Some(1));
-    /// assert_eq!(cy.next(), Some(1));
-    /// ```
-    #[stable]
-    fn cycle(self) -> Cycle<Self>;
-}
-
-impl<I> CloneIteratorExt for I where I: Iterator + Clone {
-    #[inline]
-    fn cycle(self) -> Cycle<I> {
-        Cycle{orig: self.clone(), iter: self}
-    }
-}
-
->>>>>>> parent of f031671... Remove i suffix in docs
 /// An iterator that repeats endlessly
 #[derive(Clone, Copy)]
 #[must_use = "iterator adaptors are lazy and do nothing unless consumed"]

src/libcoretest/iter.rs

@@ -769,7 +769,7 @@ fn test_range_step_inclusive() {
 #[test]
 fn test_reverse() {
     let mut ys = [1i, 2, 3, 4, 5];
-    ys.iter_mut().reverse_();
+    ys.iter_mut().reverse_in_place();
     assert!(ys == [5, 4, 3, 2, 1]);
 }
 

src/libgraphviz/lib.rs

@@ -587,7 +587,7 @@ pub fn render_opts<'a, N:Clone+'a, E:Clone+'a, G:Labeller<'a,N,E>+GraphWalk<'a,N
 mod tests {
     use self::NodeLabels::*;
     use super::{Id, Labeller, Nodes, Edges, GraphWalk, render};
-    use super::LabelText::{mod, LabelStr, EscStr};
+    use super::LabelText::{self, LabelStr, EscStr};
     use std::io::IoResult;
     use std::borrow::IntoCow;
     use std::iter::repeat;

src/librand/chacha.rs

@@ -27,7 +27,7 @@ const CHACHA_ROUNDS: uint = 20; // Cryptographically secure from 8 upwards as of
 ///
 /// [1]: D. J. Bernstein, [*ChaCha, a variant of
 /// Salsa20*](http://cr.yp.to/chacha.html)
-#[deriving(Copy, Clone)]
+#[derive(Copy, Clone)]
 pub struct ChaChaRng {
     buffer:  [u32; STATE_WORDS], // Internal buffer of output
     state:   [u32; STATE_WORDS], // Initial state
@@ -284,7 +284,7 @@ mod test {
 
     #[test]
     fn test_rng_clone() {
-        let seed : &[_] = &[0u32, ..8];
+        let seed : &[_] = &[0u32; 8];
         let mut rng: ChaChaRng = SeedableRng::from_seed(seed);
         let mut clone = rng.clone();
         for _ in range(0u, 16) {

src/librand/lib.rs

@@ -403,7 +403,7 @@ pub trait SeedableRng<Seed>: Rng {
 /// RNGs"](http://www.jstatsoft.org/v08/i14/paper). *Journal of
 /// Statistical Software*. Vol. 8 (Issue 14).
 #[allow(missing_copy_implementations)]
-#[deriving(Clone)]
+#[derive(Clone)]
 pub struct XorShiftRng {
     x: u32,
     y: u32,

src/librustc/middle/infer/region_inference/mod.rs

@@ -22,7 +22,7 @@ use super::cres;
 use super::{RegionVariableOrigin, SubregionOrigin, TypeTrace, MiscVariable};
 
 use middle::region;
-use middle::ty::{mod, Ty};
+use middle::ty::{self, Ty};
 use middle::ty::{BoundRegion, FreeRegion, Region, RegionVid};
 use middle::ty::{ReEmpty, ReStatic, ReInfer, ReFree, ReEarlyBound};
 use middle::ty::{ReLateBound, ReScope, ReVar, ReSkolemized, BrFresh};
@@ -69,7 +69,7 @@ pub enum Verify<'tcx> {
     VerifyGenericBound(GenericKind<'tcx>, SubregionOrigin<'tcx>, Region, Vec<Region>),
 }
 
-#[deriving(Clone, Show, PartialEq, Eq)]
+#[derive(Clone, Show, PartialEq, Eq)]
 pub enum GenericKind<'tcx> {
     Param(ty::ParamTy),
     Projection(ty::ProjectionTy<'tcx>),

src/librustc_trans/back/write.rs

@@ -22,7 +22,7 @@ use syntax::codemap;
 use syntax::diagnostic;
 use syntax::diagnostic::{Emitter, Handler, Level, mk_handler};
 
-use std::ffi::{mod, CString};
+use std::ffi::{self, CString};
 use std::io::Command;
 use std::io::fs;
 use std::iter::Unfold;
@@ -32,7 +32,7 @@ use std::mem;
 use std::sync::{Arc, Mutex};
 use std::sync::mpsc::channel;
 use std::thread;
-use libc::{mod, c_uint, c_int, c_void};
+use libc::{self, c_uint, c_int, c_void};
 
 #[derive(Clone, Copy, PartialEq, PartialOrd, Ord, Eq)]
 pub enum OutputType {

src/librustc_trans/trans/base.rs

@@ -88,7 +88,7 @@ use util::nodemap::NodeMap;
 
 use arena::TypedArena;
 use libc::{c_uint, uint64_t};
-use std::ffi::{mod, CString};
+use std::ffi::{self, CString};
 use std::cell::{Cell, RefCell};
 use std::collections::HashSet;
 use std::mem;

src/librustc_typeck/check/_match.rs

@@ -195,10 +195,10 @@ pub fn check_pat<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>,
         ast::PatRegion(ref inner, mutbl) => {
             let inner_ty = fcx.infcx().next_ty_var();
 
-            // SNAP c894171 remove this `if`-`else` entirely after next snapshot
+            // SNAP b2085d9 remove this `if`-`else` entirely after next snapshot
             let mutbl = if mutbl == ast::MutImmutable {
                 ty::deref(fcx.infcx().shallow_resolve(expected), true)
-                   .map(|mt| mt.mutbl).unwrap_or(ast::MutImmutable);
+                   .map(|mt| mt.mutbl).unwrap_or(ast::MutImmutable)
             } else {
                 mutbl
             };

src/librustc_typeck/check/regionck.rs

@@ -92,7 +92,7 @@ use middle::region::CodeExtent;
 use middle::traits;
 use middle::ty::{ReScope};
 use middle::ty::{self, Ty, MethodCall};
-use middle::infer::{mod, GenericKind};
+use middle::infer::{self, GenericKind};
 use middle::pat_util;
 use util::ppaux::{ty_to_string, Repr};
 

src/libserialize/json_stage0.rs

@@ -2298,7 +2298,7 @@ impl ::Decoder<DecoderError> for Decoder {
 }
 
 /// A trait for converting values to JSON
-pub trait ToJson for Sized? {
+pub trait ToJson {
     /// Converts the value of `self` to an instance of JSON
     fn to_json(&self) -> Json;
 }

src/libserialize/serialize_stage0.rs

@@ -172,7 +172,7 @@ pub trait Decoder<E> {
     fn error(&mut self, err: &str) -> E;
 }
 
-pub trait Encodable<S:Encoder<E>, E> for Sized? {
+pub trait Encodable<S:Encoder<E>, E> {
     fn encode(&self, s: &mut S) -> Result<(), E>;
 }
 

src/libstd/dynamic_lib.rs

@@ -128,8 +128,8 @@ impl DynamicLibrary {
         // This function should have a lifetime constraint of 'a on
         // T but that feature is still unimplemented
 
+        let raw_string = CString::from_slice(symbol.as_bytes());
         let maybe_symbol_value = dl::check_for_errors_in(|| {
-            let raw_string = CString::from_slice(symbol.as_bytes());
             dl::symbol(self.handle, raw_string.as_ptr())
         });
 

src/libstd/lib.rs

@@ -253,8 +253,6 @@ pub mod num;
 
 /* Runtime and platform support */
 
-pub mod thread_local; // first for macros
-
 #[cfg_attr(stage0, macro_escape)]
 #[cfg_attr(not(stage0), macro_use)]
 pub mod thread_local;

src/libstd/rand/mod.rs

@@ -245,7 +245,7 @@ pub mod reader;
 
 /// The standard RNG. This is designed to be efficient on the current
 /// platform.
-#[deriving(Copy, Clone)]
+#[derive(Copy, Clone)]
 pub struct StdRng {
     rng: IsaacWordRng,
 }
@@ -322,7 +322,7 @@ static THREAD_RNG_RESEED_THRESHOLD: uint = 32_768;
 type ThreadRngInner = reseeding::ReseedingRng<StdRng, ThreadRngReseeder>;
 
 /// The thread-local RNG.
-#[deriving(Clone)]
+#[derive(Clone)]
 pub struct ThreadRng {
     rng: Rc<RefCell<ThreadRngInner>>,
 }

src/libstd/sys/windows/process.rs

@@ -466,19 +466,17 @@ fn free_handle(handle: *mut ()) {
 
 #[cfg(test)]
 mod tests {
-    use c_str::ToCStr;
+    use prelude::v1::*;
+    use str;
+    use ffi::CString;
+    use super::make_command_line;
 
     #[test]
     fn test_make_command_line() {
-        use prelude::v1::*;
-        use str;
-        use c_str::CString;
-        use super::make_command_line;
-
         fn test_wrapper(prog: &str, args: &[&str]) -> String {
-            make_command_line(&prog.to_c_str(),
+            make_command_line(&CString::from_slice(prog.as_bytes()),
                               args.iter()
-                                  .map(|a| a.to_c_str())
+                                  .map(|a| CString::from_slice(a.as_bytes()))
                                   .collect::<Vec<CString>>()
                                   .as_slice())
         }

src/libsyntax/feature_gate.rs

@@ -267,7 +267,7 @@ impl<'a, 'v> Visitor<'v> for PostExpansionVisitor<'a> {
                 }
             }
 
-            ast::ItemImpl(_, polarity, _, _, _, ref items) => {
+            ast::ItemImpl(_, polarity, _, _, _, _) => {
                 match polarity {
                     ast::ImplPolarity::Negative => {
                         self.gate_feature("optin_builtin_traits",
@@ -294,18 +294,6 @@ impl<'a, 'v> Visitor<'v> for PostExpansionVisitor<'a> {
                         i.span,
                         "the new orphan check rules will eventually be strictly enforced");
                 }
-
-                for item in items.iter() {
-                    match *item {
-                        ast::MethodImplItem(_) => {}
-                        ast::TypeImplItem(ref typedef) => {
-                            self.gate_feature("associated_types",
-                                              typedef.span,
-                                              "associated types are \
-                                               experimental")
-                        }
-                    }
-                }
             }
 
             _ => {}