---

yaml
---
r: 186107
b: refs/heads/try
c: 597b4fa
h: refs/heads/master
i:
  186105: 51bba93
  186103: e8a3b8f
v: v3

Author: ftxqxd

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: b4c965ee803a4521d8b4575f634e036f93e408f3
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 3a96d6a9818fe2affc98a187fb1065120458cee9
-refs/heads/try: ccf8fedf1cffcb8f6f3581d53d220039e192fe77
+refs/heads/try: 597b4fa984d866154f5e23244a4a48c787af43fd
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

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

@@ -576,6 +576,10 @@ extern fn panic_fmt(args: &core::fmt::Arguments,
 #[lang = "eh_personality"] extern fn eh_personality() {}
 # #[start] fn start(argc: isize, argv: *const *const u8) -> isize { 0 }
 # fn main() {}
+# mod std {  // for-loops
+#     pub use core::iter;
+#     pub use core::option;
+# }
 ```
 
 Note that there is one extra lang item here which differs from the examples

branches/try/src/liballoc/arc.rs

@@ -39,7 +39,7 @@
 //!
 //! let five = Arc::new(5);
 //!
-//! for _ in 0..10 {
+//! for _ in 0u..10 {
 //!     let five = five.clone();
 //!
 //!     Thread::spawn(move || {
@@ -56,7 +56,7 @@
 //!
 //! let five = Arc::new(Mutex::new(5));
 //!
-//! for _ in 0..10 {
+//! for _ in 0u..10 {
 //!     let five = five.clone();
 //!
 //!     Thread::spawn(move || {
@@ -101,7 +101,7 @@ use heap::deallocate;
 ///     let numbers: Vec<_> = (0..100u32).map(|i| i as f32).collect();
 ///     let shared_numbers = Arc::new(numbers);
 ///
-///     for _ in 0..10 {
+///     for _ in 0u..10 {
 ///         let child_numbers = shared_numbers.clone();
 ///
 ///         Thread::spawn(move || {
@@ -661,7 +661,7 @@ mod tests {
 
     #[test]
     fn test_cowarc_clone_make_unique() {
-        let mut cow0 = Arc::new(75);
+        let mut cow0 = Arc::new(75u);
         let mut cow1 = cow0.clone();
         let mut cow2 = cow1.clone();
 
@@ -685,7 +685,7 @@ mod tests {
 
     #[test]
     fn test_cowarc_clone_unique2() {
-        let mut cow0 = Arc::new(75);
+        let mut cow0 = Arc::new(75u);
         let cow1 = cow0.clone();
         let cow2 = cow1.clone();
 
@@ -708,7 +708,7 @@ mod tests {
 
     #[test]
     fn test_cowarc_clone_weak() {
-        let mut cow0 = Arc::new(75);
+        let mut cow0 = Arc::new(75u);
         let cow1_weak = cow0.downgrade();
 
         assert!(75 == *cow0);

branches/try/src/liballoc/boxed_test.rs

@@ -31,19 +31,19 @@ struct Test;
 
 #[test]
 fn any_move() {
-    let a = Box::new(8us) as Box<Any>;
+    let a = Box::new(8u) as Box<Any>;
     let b = Box::new(Test) as Box<Any>;
 
     match a.downcast::<uint>() {
-        Ok(a) => { assert!(a == Box::new(8us)); }
+        Ok(a) => { assert!(a == Box::new(8u)); }
         Err(..) => panic!()
     }
     match b.downcast::<Test>() {
         Ok(a) => { assert!(a == Box::new(Test)); }
         Err(..) => panic!()
     }
 
-    let a = Box::new(8) as Box<Any>;
+    let a = Box::new(8u) as Box<Any>;
     let b = Box::new(Test) as Box<Any>;
 
     assert!(a.downcast::<Box<Test>>().is_err());
@@ -52,14 +52,14 @@ fn any_move() {
 
 #[test]
 fn test_show() {
-    let a = Box::new(8) as Box<Any>;
+    let a = Box::new(8u) as Box<Any>;
     let b = Box::new(Test) as Box<Any>;
     let a_str = format!("{:?}", a);
     let b_str = format!("{:?}", b);
     assert_eq!(a_str, "Box<Any>");
     assert_eq!(b_str, "Box<Any>");
 
-    static EIGHT: usize = 8;
+    static EIGHT: usize = 8us;
     static TEST: Test = Test;
     let a = &EIGHT as &Any;
     let b = &TEST as &Any;

branches/try/src/liballoc/lib.rs

@@ -124,8 +124,7 @@ pub fn oom() -> ! {
 #[doc(hidden)]
 pub fn fixme_14344_be_sure_to_link_to_collections() {}
 
-// NOTE: remove after next snapshot
-#[cfg(all(stage0, not(test)))]
+#[cfg(not(test))]
 #[doc(hidden)]
 mod std {
     pub use core::fmt;

branches/try/src/liballoc/rc.rs

@@ -266,12 +266,12 @@ pub fn is_unique<T>(rc: &Rc<T>) -> bool {
 /// ```
 /// use std::rc::{self, Rc};
 ///
-/// let x = Rc::new(3);
-/// assert_eq!(rc::try_unwrap(x), Ok(3));
+/// let x = Rc::new(3u);
+/// assert_eq!(rc::try_unwrap(x), Ok(3u));
 ///
-/// let x = Rc::new(4);
+/// let x = Rc::new(4u);
 /// let _y = x.clone();
-/// assert_eq!(rc::try_unwrap(x), Err(Rc::new(4)));
+/// assert_eq!(rc::try_unwrap(x), Err(Rc::new(4u)));
 /// ```
 #[inline]
 #[unstable(feature = "alloc")]
@@ -300,9 +300,9 @@ pub fn try_unwrap<T>(rc: Rc<T>) -> Result<T, Rc<T>> {
 /// ```
 /// use std::rc::{self, Rc};
 ///
-/// let mut x = Rc::new(3);
-/// *rc::get_mut(&mut x).unwrap() = 4;
-/// assert_eq!(*x, 4);
+/// let mut x = Rc::new(3u);
+/// *rc::get_mut(&mut x).unwrap() = 4u;
+/// assert_eq!(*x, 4u);
 ///
 /// let _y = x.clone();
 /// assert!(rc::get_mut(&mut x).is_none());
@@ -845,7 +845,7 @@ mod tests {
 
     #[test]
     fn is_unique() {
-        let x = Rc::new(3);
+        let x = Rc::new(3u);
         assert!(super::is_unique(&x));
         let y = x.clone();
         assert!(!super::is_unique(&x));
@@ -893,21 +893,21 @@ mod tests {
 
     #[test]
     fn try_unwrap() {
-        let x = Rc::new(3);
-        assert_eq!(super::try_unwrap(x), Ok(3));
-        let x = Rc::new(4);
+        let x = Rc::new(3u);
+        assert_eq!(super::try_unwrap(x), Ok(3u));
+        let x = Rc::new(4u);
         let _y = x.clone();
-        assert_eq!(super::try_unwrap(x), Err(Rc::new(4)));
-        let x = Rc::new(5);
+        assert_eq!(super::try_unwrap(x), Err(Rc::new(4u)));
+        let x = Rc::new(5u);
         let _w = x.downgrade();
-        assert_eq!(super::try_unwrap(x), Err(Rc::new(5)));
+        assert_eq!(super::try_unwrap(x), Err(Rc::new(5u)));
     }
 
     #[test]
     fn get_mut() {
-        let mut x = Rc::new(3);
-        *super::get_mut(&mut x).unwrap() = 4;
-        assert_eq!(*x, 4);
+        let mut x = Rc::new(3u);
+        *super::get_mut(&mut x).unwrap() = 4u;
+        assert_eq!(*x, 4u);
         let y = x.clone();
         assert!(super::get_mut(&mut x).is_none());
         drop(y);
@@ -918,7 +918,7 @@ mod tests {
 
     #[test]
     fn test_cowrc_clone_make_unique() {
-        let mut cow0 = Rc::new(75);
+        let mut cow0 = Rc::new(75u);
         let mut cow1 = cow0.clone();
         let mut cow2 = cow1.clone();
 
@@ -942,7 +942,7 @@ mod tests {
 
     #[test]
     fn test_cowrc_clone_unique2() {
-        let mut cow0 = Rc::new(75);
+        let mut cow0 = Rc::new(75u);
         let cow1 = cow0.clone();
         let cow2 = cow1.clone();
 
@@ -965,7 +965,7 @@ mod tests {
 
     #[test]
     fn test_cowrc_clone_weak() {
-        let mut cow0 = Rc::new(75);
+        let mut cow0 = Rc::new(75u);
         let cow1_weak = cow0.downgrade();
 
         assert!(75 == *cow0);
@@ -979,7 +979,7 @@ mod tests {
 
     #[test]
     fn test_show() {
-        let foo = Rc::new(75);
+        let foo = Rc::new(75u);
         assert_eq!(format!("{:?}", foo), "75");
     }
 

branches/try/src/libcollections/lib.rs

@@ -109,16 +109,15 @@ pub fn fixme_14344_be_sure_to_link_to_collections() {}
 
 #[cfg(not(test))]
 mod std {
-    // NOTE: remove after next snapshot
-    #[cfg(stage0)] pub use core::clone;    // derive(Clone)
-    #[cfg(stage0)] pub use core::cmp;      // derive(Eq, Ord, etc.)
-    #[cfg(stage0)] pub use core::marker;   // derive(Copy)
-    #[cfg(stage0)] pub use core::hash;     // derive(Hash)
-    #[cfg(stage0)] pub use core::iter;
-    #[cfg(stage0)] pub use core::fmt;      // necessary for panic!()
-    #[cfg(stage0)] pub use core::option;   // necessary for panic!()
-
+    pub use core::fmt;      // necessary for panic!()
+    pub use core::option;   // necessary for panic!()
+    pub use core::clone;    // derive(Clone)
+    pub use core::cmp;      // derive(Eq, Ord, etc.)
+    pub use core::marker;   // derive(Copy)
+    pub use core::hash;     // derive(Hash)
     pub use core::ops;      // RangeFull
+    // for-loops
+    pub use core::iter;
 }
 
 #[cfg(test)]

branches/try/src/libcollections/macros.rs

@@ -22,19 +22,3 @@ macro_rules! vec {
     );
     ($($x:expr,)*) => (vec![$($x),*])
 }
-
-/// Use the syntax described in `std::fmt` to create a value of type `String`.
-/// See `std::fmt` for more information.
-///
-/// # Example
-///
-/// ```
-/// format!("test");
-/// format!("hello {}", "world!");
-/// format!("x = {}, y = {y}", 10, y = 30);
-/// ```
-#[macro_export]
-#[stable(feature = "rust1", since = "1.0.0")]
-macro_rules! format {
-    ($($arg:tt)*) => ($crate::string::String::format(format_args!($($arg)*)))
-}

branches/try/src/libcollections/ring_buf.rs

@@ -27,8 +27,8 @@ use core::ops::{Index, IndexMut};
 use core::ptr;
 use core::raw::Slice as RawSlice;
 
-use core::hash::{Writer, Hash, Hasher};
-use core::cmp;
+use std::hash::{Writer, Hash, Hasher};
+use std::cmp;
 
 use alloc::heap;
 

branches/try/src/libcollections/string.rs

@@ -671,29 +671,6 @@ impl String {
     pub fn clear(&mut self) {
         self.vec.clear()
     }
-
-    /// The format function takes a precompiled format string and a list of
-    /// arguments, to return the resulting formatted string.
-    ///
-    /// # Arguments
-    ///
-    ///   * args - a structure of arguments generated via the `format_args!` macro.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// let s = String::format(format_args!("Hello, {}!", "world"));
-    /// assert_eq!(s, "Hello, world!".to_string());
-    /// ```
-    #[unstable(feature = "collections",
-               reason = "duplicates std::fmt::format, only needed when libstd is missing")]
-    pub fn format(args: fmt::Arguments) -> String {
-        // FIXME #21826
-        use core::fmt::Writer;
-        let mut output = String::new();
-        let _ = write!(&mut output, "{}", args);
-        output
-    }
 }
 
 impl FromUtf8Error {
@@ -1371,12 +1348,6 @@ mod tests {
         assert_eq!(s, d);
     }
 
-    #[test]
-    fn test_format() {
-        let s = format_args!(String::format, "Hello, {}!", "world");
-        assert_eq!(s.as_slice(), "Hello, world!");
-    }
-
     #[bench]
     fn bench_with_capacity(b: &mut Bencher) {
         b.iter(|| {

branches/try/src/libcore/iter.rs

@@ -67,7 +67,7 @@ use num::{ToPrimitive, Int};
 use ops::{Add, Deref, FnMut};
 use option::Option;
 use option::Option::{Some, None};
-use marker::Sized;
+use std::marker::Sized;
 use usize;
 
 /// An interface for dealing with "external iterators". These types of iterators

branches/try/src/libcore/lib.rs

@@ -149,25 +149,17 @@ mod array;
 mod core {
     pub use panicking;
     pub use fmt;
-    #[cfg(not(stage0))] pub use clone;
-    #[cfg(not(stage0))] pub use cmp;
-    #[cfg(not(stage0))] pub use hash;
-    #[cfg(not(stage0))] pub use marker;
-    #[cfg(not(stage0))] pub use option;
-    #[cfg(not(stage0))] pub use iter;
 }
 
 #[doc(hidden)]
 mod std {
-    // NOTE: remove after next snapshot
-    #[cfg(stage0)] pub use clone;
-    #[cfg(stage0)] pub use cmp;
-    #[cfg(stage0)] pub use hash;
-    #[cfg(stage0)] pub use marker;
-    #[cfg(stage0)] pub use option;
-    #[cfg(stage0)] pub use fmt;
-    #[cfg(stage0)] pub use iter;
-
-    // range syntax
+    pub use clone;
+    pub use cmp;
+    pub use fmt;
+    pub use hash;
+    pub use marker;
     pub use ops;
+    pub use option;
+    // for-loops
+    pub use iter;
 }

branches/try/src/liblibc/lib.rs

@@ -5101,9 +5101,8 @@ pub fn issue_14344_workaround() {} // FIXME #14344 force linkage to happen corre
 
 #[test] fn work_on_windows() { } // FIXME #10872 needed for a happy windows
 
-// NOTE: remove after next snapshot
 #[doc(hidden)]
-#[cfg(all(stage0, not(test)))]
+#[cfg(not(test))]
 mod std {
     pub use core::marker;
 }

branches/try/src/librand/lib.rs

@@ -493,8 +493,7 @@ pub struct Open01<F>(pub F);
 /// ```
 pub struct Closed01<F>(pub F);
 
-// NOTE: remove after next snapshot
-#[cfg(all(stage0, not(test)))]
+#[cfg(not(test))]
 mod std {
     pub use core::{option, fmt}; // panic!()
     pub use core::clone; // derive Clone