Make String formatting available without libstd

Fixes rust-lang#14342.

Author: kmcallister

src/libcollections/lib.rs

@@ -556,22 +556,22 @@ pub trait Deque<T> : MutableSeq<T> {
 #[doc(hidden)]
 pub fn fixme_14344_be_sure_to_link_to_collections() {}
 
+// NOTE: Remove after next snapshot
+#[cfg(stage0)]
 #[cfg(not(test))]
 mod std {
-    // NOTE: Remove after next snapshot
-    #[cfg(stage0)] pub use core::option;   // necessary for fail!()
-    #[cfg(stage0)] pub use core::clone;    // deriving(Clone)
-    #[cfg(stage0)] pub use core::cmp;      // deriving(Eq, Ord, etc.)
-    #[cfg(stage0)] pub use hash;           // deriving(Hash)
-
+    pub use core::option;   // necessary for fail!()
     pub use core::fmt;      // necessary for fail!()
+    pub use core::clone;    // deriving(Clone)
+    pub use core::cmp;      // deriving(Eq, Ord, etc.)
+    pub use hash;           // deriving(Hash)
 
-    #[cfg(stage0)]
     pub mod collections {
         pub use MutableSeq;
     }
 }
 
 mod collections {
-    pub use hash;  // deriving(Hsah)
+    pub use hash;     // deriving(Hsah)
+    pub use string;   // format!()
 }

src/libcollections/macros.rs

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

src/libcollections/string.rs

@@ -16,6 +16,7 @@ use core::prelude::*;
 
 use core::default::Default;
 use core::fmt;
+use core::fmt::FormatWriter;
 use core::mem;
 use core::ptr;
 // FIXME: ICE's abound if you import the `Slice` type while importing `Slice` trait
@@ -726,6 +727,28 @@ impl String {
     pub unsafe fn as_mut_vec<'a>(&'a mut self) -> &'a mut Vec<u8> {
         &mut self.vec
     }
+
+    /// 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.
+    ///            Because this structure can only be safely generated at
+    ///            compile-time, this function is safe.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// let s = format_args!(String::format, "Hello, {}!", "world");
+    /// assert_eq!(s, "Hello, world!".to_string());
+    /// ```
+    pub fn format(args: &fmt::Arguments) -> String {
+        let mut output = vec!();
+        let _ = write!(&mut output, "{}", args);
+        String::from_utf8(output)
+            .ok().expect("non-utf8 result from write!()")
+    }
 }
 
 impl Collection for String {
@@ -1142,6 +1165,12 @@ mod tests {
         assert_eq!(b.as_slice(), "1234522");
     }
 
+    #[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(|| {

src/libcollections/vec.rs

@@ -1611,6 +1611,13 @@ impl<T> MutableSeq<T> for Vec<T> {
 
 }
 
+impl fmt::FormatWriter for Vec<u8> {
+    fn write(&mut self, bytes: &[u8]) -> fmt::Result {
+        self.push_all(bytes);
+        Ok(())
+    }
+}
+
 /// An iterator that moves out of a vector.
 pub struct MoveItems<T> {
     allocation: *mut T, // the block of memory allocated for the vector
@@ -2041,6 +2048,14 @@ mod tests {
         assert_eq!(vec.len(), 0);
     }
 
+    #[test]
+    fn test_format_writer() {
+        use core::fmt::FormatWriter;
+        let mut vec: Vec<u8> = vec!(b'x', b'y');
+        vec.write("abc".as_bytes());
+        assert_eq!(vec.as_slice(), b"xyabc");
+    }
+
     #[bench]
     fn bench_new(b: &mut Bencher) {
         b.iter(|| {

src/libcore/lib.rs

@@ -133,14 +133,14 @@ pub mod tuple;
 pub mod unit;
 pub mod fmt;
 
+// NOTE: Remove after next snapshot
 #[doc(hidden)]
+#[cfg(stage0)]
 mod std {
-    // NOTE: Remove after next snapshot
-    #[cfg(stage0)] pub use clone;
-    #[cfg(stage0)] pub use cmp;
-    #[cfg(stage0)] pub use kinds;
-    #[cfg(stage0)] pub use option;
-
+    pub use clone;
+    pub use cmp;
+    pub use kinds;
+    pub use option;
     pub use fmt;
 }
 

src/libcore/macros.rs

@@ -38,7 +38,7 @@ macro_rules! fail(
         // insufficient, since the user may have
         // `#[forbid(dead_code)]` and which cannot be overridden.
         #[inline(always)]
-        fn _run_fmt(fmt: &::std::fmt::Arguments) -> ! {
+        fn _run_fmt(fmt: &::core::fmt::Arguments) -> ! {
             static _FILE_LINE: (&'static str, uint) = (file!(), line!());
             ::core::failure::begin_unwind(fmt, &_FILE_LINE)
         }

src/librustrt/lib.rs

@@ -164,10 +164,9 @@ pub mod shouldnt_be_public {
     pub use super::local_ptr::compiled::RT_TLS_PTR;
 }
 
+// NOTE: Remove after next snapshot
+#[cfg(stage0)]
 #[cfg(not(test))]
 mod std {
-    // NOTE: Remove after next snapshot
-    #[cfg(stage0)] pub use core::{option, cmp};
-
-    pub use core::fmt;
+    pub use core::{fmt, option, cmp};
 }

src/libstd/fmt.rs

@@ -459,10 +459,8 @@ pub use core::fmt::{secret_pointer};
 /// let s = format_args!(fmt::format, "Hello, {}!", "world");
 /// assert_eq!(s, "Hello, world!".to_string());
 /// ```
-pub fn format(args: &Arguments) -> string::String{
-    let mut output = io::MemWriter::new();
-    let _ = write!(&mut output, "{}", args);
-    string::String::from_utf8(output.unwrap()).unwrap()
+pub fn format(args: &Arguments) -> string::String {
+    string::String::format(args)
 }
 
 impl<'a> Writer for Formatter<'a> {

src/test/run-pass/format-no-std.rs

@@ -0,0 +1,37 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(phase)]
+#![deny(warnings)]
+#![no_std]
+
+#[phase(plugin, link)]
+extern crate core;
+
+#[phase(plugin, link)]
+extern crate collections;
+
+extern crate native;
+
+use core::str::Str;
+
+pub fn main() {
+    let s = format!("{}", 1i);
+    assert_eq!(s.as_slice(), "1");
+
+    let s = format!("test");
+    assert_eq!(s.as_slice(), "test");
+
+    let s = format!("{test}", test=3i);
+    assert_eq!(s.as_slice(), "3");
+
+    let s = format!("hello {}", "world");
+    assert_eq!(s.as_slice(), "hello world");
+}