---

yaml
---
r: 178589
b: refs/heads/try
c: ccf8fed
h: refs/heads/master
i:
  178587: 385d159
v: v3

Author: Keegan McAllister

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 336c8d2e9c6b276b162bdb3edd43706372e6eddd
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 474b324eda10440d6568ef872a7307d38e7de95b
-refs/heads/try: 6cebe475d1bcebd632992350f8a4a46981b12213
+refs/heads/try: ccf8fedf1cffcb8f6f3581d53d220039e192fe77
 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,10 +576,6 @@ 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/lib.rs

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

branches/try/src/libcollections/lib.rs

@@ -109,15 +109,16 @@ pub fn fixme_14344_be_sure_to_link_to_collections() {}
 
 #[cfg(not(test))]
 mod std {
-    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)
+    // 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::ops;      // RangeFull
-    // for-loops
-    pub use core::iter;
 }
 
 #[cfg(test)]

branches/try/src/libcollections/macros.rs

@@ -22,3 +22,19 @@ 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 std::hash::{Writer, Hash, Hasher};
-use std::cmp;
+use core::hash::{Writer, Hash, Hasher};
+use core::cmp;
 
 use alloc::heap;
 

branches/try/src/libcollections/string.rs

@@ -671,6 +671,29 @@ 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 {
@@ -1348,6 +1371,12 @@ 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 std::marker::Sized;
+use marker::Sized;
 use usize;
 
 /// An interface for dealing with "external iterators". These types of iterators

branches/try/src/libcore/lib.rs

@@ -149,17 +149,25 @@ 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 {
-    pub use clone;
-    pub use cmp;
-    pub use fmt;
-    pub use hash;
-    pub use marker;
+    // 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 ops;
-    pub use option;
-    // for-loops
-    pub use iter;
 }

branches/try/src/liblibc/lib.rs

@@ -5101,8 +5101,9 @@ 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(not(test))]
+#[cfg(all(stage0, not(test)))]
 mod std {
     pub use core::marker;
 }

branches/try/src/librand/lib.rs

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

branches/try/src/libstd/fmt.rs

@@ -434,7 +434,5 @@ pub use core::fmt::{argument, argumentuint};
 /// ```
 #[stable(feature = "rust1", since = "1.0.0")]
 pub fn format(args: Arguments) -> string::String {
-    let mut output = string::String::new();
-    let _ = write!(&mut output, "{}", args);
-    output
+    string::String::format(args)
 }

branches/try/src/libstd/lib.rs

@@ -139,7 +139,7 @@ extern crate log;
 extern crate core;
 
 #[macro_use]
-#[macro_reexport(vec)]
+#[macro_reexport(vec, format)]
 extern crate "collections" as core_collections;
 
 extern crate "rand" as core_rand;
@@ -284,11 +284,12 @@ mod tuple;
 // can be resolved within libstd.
 #[doc(hidden)]
 mod std {
+    // NOTE: remove after next snapshot
     // mods used for deriving
-    pub use clone;
-    pub use cmp;
-    pub use hash;
-    pub use default;
+    #[cfg(stage0)] pub use clone;
+    #[cfg(stage0)] pub use cmp;
+    #[cfg(stage0)] pub use hash;
+    #[cfg(stage0)] pub use default;
 
     pub use sync; // used for select!()
     pub use error; // used for try!()
@@ -311,5 +312,6 @@ mod std {
 
     pub use boxed; // used for vec![]
     // for-loops
-    pub use iter;
+    // NOTE: remove after next snapshot
+    #[cfg(stage0)] pub use iter;
 }

branches/try/src/libstd/macros.rs

@@ -70,6 +70,7 @@ macro_rules! panic {
 /// format!("hello {}", "world!");
 /// format!("x = {}, y = {y}", 10, y = 30);
 /// ```
+#[cfg(stage0)] // NOTE: remove after snapshot
 #[macro_export]
 #[stable(feature = "rust1", since = "1.0.0")]
 macro_rules! format {

branches/try/src/libsyntax/ext/base.rs

@@ -544,6 +544,7 @@ pub struct ExtCtxt<'a> {
     pub cfg: ast::CrateConfig,
     pub backtrace: ExpnId,
     pub ecfg: expand::ExpansionConfig,
+    pub use_std: bool,
 
     pub mod_path: Vec<ast::Ident> ,
     pub trace_mac: bool,
@@ -563,6 +564,7 @@ impl<'a> ExtCtxt<'a> {
             backtrace: NO_EXPANSION,
             mod_path: Vec::new(),
             ecfg: ecfg,
+            use_std: true,
             trace_mac: false,
             exported_macros: Vec::new(),
             syntax_env: env,
@@ -737,6 +739,9 @@ impl<'a> ExtCtxt<'a> {
     pub fn ident_of(&self, st: &str) -> ast::Ident {
         str_to_ident(st)
     }
+    pub fn ident_of_std(&self, st: &str) -> ast::Ident {
+        self.ident_of(if self.use_std { "std" } else { st })
+    }
     pub fn name_of(&self, st: &str) -> ast::Name {
         token::intern(st)
     }