---

yaml
---
r: 232790
b: refs/heads/try
c: 21f209a
h: refs/heads/master
v: v3

Author: apasel422

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: edeb4f1c86cbf6af8ef9874d4b3af50f721ea1b8
 refs/heads/snap-stage3: 1af31d4974e33027a68126fa5a5a3c2c6491824f
-refs/heads/try: 07d1a22ce5050cfa2edd7b257ac7fead534588a2
+refs/heads/try: 21f209a28b7294fb7afe73cc5a37aad93d426b75
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try/src/doc/trpl/testing.md

@@ -120,26 +120,13 @@ And that's reflected in the summary line:
 test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured
 ```
 
-We also get a non-zero status code. We can use `$?` on OS X and Linux:
+We also get a non-zero status code:
 
 ```bash
 $ echo $?
 101
 ```
 
-On Windows, if you’re using `cmd`:
-
-```bash
-> echo %ERRORLEVEL%
-```
-
-And if you’re using PowerShell:
-
-```bash
-> echo $LASTEXITCODE # the code itself
-> echo $? # a boolean, fail or succeed
-```
-
 This is useful if you want to integrate `cargo test` into other tooling.
 
 We can invert our test's failure with another attribute: `should_panic`:

branches/try/src/libcore/marker.rs

@@ -45,7 +45,7 @@ pub trait Sized {
 }
 
 /// Types that can be "unsized" to a dynamically sized type.
-#[unstable(feature = "unsize", issue = "27732")]
+#[unstable(feature = "unsize", issue = "27779")]
 #[lang="unsize"]
 pub trait Unsize<T: ?Sized> {
     // Empty.

branches/try/src/libcore/ops.rs

@@ -423,7 +423,7 @@ pub trait Rem<RHS=Self> {
     fn rem(self, rhs: RHS) -> Self::Output;
 }
 
-macro_rules! rem_impl_integer {
+macro_rules! rem_impl {
     ($($t:ty)*) => ($(
         /// This operation satisfies `n % d == n - (n / d) * d`.  The
         /// result has the same sign as the left operand.
@@ -439,28 +439,9 @@ macro_rules! rem_impl_integer {
     )*)
 }
 
-rem_impl_integer! { usize u8 u16 u32 u64 isize i8 i16 i32 i64 }
-
-#[cfg(not(stage0))]
-macro_rules! rem_impl_float {
-    ($($t:ty)*) => ($(
-        #[stable(feature = "rust1", since = "1.0.0")]
-        impl Rem for $t {
-            type Output = $t;
-
-            #[inline]
-            fn rem(self, other: $t) -> $t { self % other }
-        }
-
-        forward_ref_binop! { impl Rem, rem for $t, $t }
-    )*)
-}
-
-#[cfg(not(stage0))]
-rem_impl_float! { f32 f64 }
+rem_impl! { usize u8 u16 u32 u64 isize i8 i16 i32 i64 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-#[cfg(stage0)]
 impl Rem for f32 {
     type Output = f32;
 
@@ -482,7 +463,6 @@ impl Rem for f32 {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-#[cfg(stage0)]
 impl Rem for f64 {
     type Output = f64;
 
@@ -493,9 +473,7 @@ impl Rem for f64 {
     }
 }
 
-#[cfg(stage0)]
 forward_ref_binop! { impl Rem, rem for f64, f64 }
-#[cfg(stage0)]
 forward_ref_binop! { impl Rem, rem for f32, f32 }
 
 /// The `Neg` trait is used to specify the functionality of unary `-`.

branches/try/src/libcore/option.rs

@@ -779,26 +779,6 @@ impl<T> IntoIterator for Option<T> {
     }
 }
 
-#[stable(since = "1.4.0", feature = "option_iter")]
-impl<'a, T> IntoIterator for &'a Option<T> {
-    type Item = &'a T;
-    type IntoIter = Iter<'a, T>;
-
-    fn into_iter(self) -> Iter<'a, T> {
-        self.iter()
-    }
-}
-
-#[stable(since = "1.4.0", feature = "option_iter")]
-impl<'a, T> IntoIterator for &'a mut Option<T> {
-    type Item = &'a mut T;
-    type IntoIter = IterMut<'a, T>;
-
-    fn into_iter(mut self) -> IterMut<'a, T> {
-        self.iter_mut()
-    }
-}
-
 /////////////////////////////////////////////////////////////////////////////
 // The Option Iterators
 /////////////////////////////////////////////////////////////////////////////

branches/try/src/libcore/result.rs

@@ -815,26 +815,6 @@ impl<T, E> IntoIterator for Result<T, E> {
     }
 }
 
-#[stable(since = "1.4.0", feature = "result_iter")]
-impl<'a, T, E> IntoIterator for &'a Result<T, E> {
-    type Item = &'a T;
-    type IntoIter = Iter<'a, T>;
-
-    fn into_iter(self) -> Iter<'a, T> {
-        self.iter()
-    }
-}
-
-#[stable(since = "1.4.0", feature = "result_iter")]
-impl<'a, T, E> IntoIterator for &'a mut Result<T, E> {
-    type Item = &'a mut T;
-    type IntoIter = IterMut<'a, T>;
-
-    fn into_iter(mut self) -> IterMut<'a, T> {
-        self.iter_mut()
-    }
-}
-
 /////////////////////////////////////////////////////////////////////////////
 // The Result Iterators
 /////////////////////////////////////////////////////////////////////////////

branches/try/src/libcoretest/iter.rs

@@ -9,7 +9,6 @@
 // except according to those terms.
 
 use core::iter::*;
-use core::iter::order::*;
 use core::{i8, i16, isize};
 use core::usize;
 
@@ -21,51 +20,51 @@ fn test_lt() {
     let xs = [1,2,3];
     let ys = [1,2,0];
 
-    assert!(!lt(xs.iter(), ys.iter()));
-    assert!(!le(xs.iter(), ys.iter()));
-    assert!( gt(xs.iter(), ys.iter()));
-    assert!( ge(xs.iter(), ys.iter()));
+    assert!(!xs.iter().lt(ys.iter()));
+    assert!(!xs.iter().le(ys.iter()));
+    assert!( xs.iter().gt(ys.iter()));
+    assert!( xs.iter().ge(ys.iter()));
 
-    assert!( lt(ys.iter(), xs.iter()));
-    assert!( le(ys.iter(), xs.iter()));
-    assert!(!gt(ys.iter(), xs.iter()));
-    assert!(!ge(ys.iter(), xs.iter()));
+    assert!( ys.iter().lt(xs.iter()));
+    assert!( ys.iter().le(xs.iter()));
+    assert!(!ys.iter().gt(xs.iter()));
+    assert!(!ys.iter().ge(xs.iter()));
 
-    assert!( lt(empty.iter(), xs.iter()));
-    assert!( le(empty.iter(), xs.iter()));
-    assert!(!gt(empty.iter(), xs.iter()));
-    assert!(!ge(empty.iter(), xs.iter()));
+    assert!( empty.iter().lt(xs.iter()));
+    assert!( empty.iter().le(xs.iter()));
+    assert!(!empty.iter().gt(xs.iter()));
+    assert!(!empty.iter().ge(xs.iter()));
 
     // Sequence with NaN
     let u = [1.0f64, 2.0];
     let v = [0.0f64/0.0, 3.0];
 
-    assert!(!lt(u.iter(), v.iter()));
-    assert!(!le(u.iter(), v.iter()));
-    assert!(!gt(u.iter(), v.iter()));
-    assert!(!ge(u.iter(), v.iter()));
+    assert!(!u.iter().lt(v.iter()));
+    assert!(!u.iter().le(v.iter()));
+    assert!(!u.iter().gt(v.iter()));
+    assert!(!u.iter().ge(v.iter()));
 
     let a = [0.0f64/0.0];
     let b = [1.0f64];
     let c = [2.0f64];
 
-    assert!(lt(a.iter(), b.iter()) == (a[0] <  b[0]));
-    assert!(le(a.iter(), b.iter()) == (a[0] <= b[0]));
-    assert!(gt(a.iter(), b.iter()) == (a[0] >  b[0]));
-    assert!(ge(a.iter(), b.iter()) == (a[0] >= b[0]));
+    assert!(a.iter().lt(b.iter()) == (a[0] <  b[0]));
+    assert!(a.iter().le(b.iter()) == (a[0] <= b[0]));
+    assert!(a.iter().gt(b.iter()) == (a[0] >  b[0]));
+    assert!(a.iter().ge(b.iter()) == (a[0] >= b[0]));
 
-    assert!(lt(c.iter(), b.iter()) == (c[0] <  b[0]));
-    assert!(le(c.iter(), b.iter()) == (c[0] <= b[0]));
-    assert!(gt(c.iter(), b.iter()) == (c[0] >  b[0]));
-    assert!(ge(c.iter(), b.iter()) == (c[0] >= b[0]));
+    assert!(c.iter().lt(b.iter()) == (c[0] <  b[0]));
+    assert!(c.iter().le(b.iter()) == (c[0] <= b[0]));
+    assert!(c.iter().gt(b.iter()) == (c[0] >  b[0]));
+    assert!(c.iter().ge(b.iter()) == (c[0] >= b[0]));
 }
 
 #[test]
 fn test_multi_iter() {
     let xs = [1,2,3,4];
     let ys = [4,3,2,1];
-    assert!(eq(xs.iter(), ys.iter().rev()));
-    assert!(lt(xs.iter(), xs.iter().skip(2)));
+    assert!(xs.iter().eq(ys.iter().rev()));
+    assert!(xs.iter().lt(xs.iter().skip(2)));
 }
 
 #[test]

branches/try/src/libcoretest/option.rs

@@ -180,14 +180,11 @@ fn test_iter() {
     assert_eq!(it.next(), Some(&val));
     assert_eq!(it.size_hint(), (0, Some(0)));
     assert!(it.next().is_none());
-
-    let mut it = (&x).into_iter();
-    assert_eq!(it.next(), Some(&val));
 }
 
 #[test]
 fn test_mut_iter() {
-    let mut val = 5;
+    let val = 5;
     let new_val = 11;
 
     let mut x = Some(val);
@@ -208,10 +205,6 @@ fn test_mut_iter() {
         assert!(it.next().is_none());
     }
     assert_eq!(x, Some(new_val));
-
-    let mut y = Some(val);
-    let mut it = (&mut y).into_iter();
-    assert_eq!(it.next(), Some(&mut val));
 }
 
 #[test]

branches/try/src/libcoretest/result.rs

@@ -150,36 +150,3 @@ pub fn test_expect_err() {
     let err: Result<isize, &'static str> = Err("All good");
     err.expect("Got expected error");
 }
-
-#[test]
-pub fn test_iter() {
-    let ok: Result<isize, &'static str> = Ok(100);
-    let mut it = ok.iter();
-    assert_eq!(it.size_hint(), (1, Some(1)));
-    assert_eq!(it.next(), Some(&100));
-    assert_eq!(it.size_hint(), (0, Some(0)));
-    assert!(it.next().is_none());
-    assert_eq!((&ok).into_iter().next(), Some(&100));
-
-    let err: Result<isize, &'static str> = Err("error");
-    assert_eq!(err.iter().next(), None);
-}
-
-#[test]
-pub fn test_iter_mut() {
-    let mut ok: Result<isize, &'static str> = Ok(100);
-    for loc in ok.iter_mut() {
-        *loc = 200;
-    }
-    assert_eq!(ok, Ok(200));
-    for loc in &mut ok {
-        *loc = 300;
-    }
-    assert_eq!(ok, Ok(300));
-
-    let mut err: Result<isize, &'static str> = Err("error");
-    for loc in err.iter_mut() {
-        *loc = 200;
-    }
-    assert_eq!(err, Err("error"));
-}