make ToString completely use format! internally

Author: seanmonstar

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}", 10i, y = 30i);
+/// ```
+#[macro_export]
+#[stable]
+macro_rules! format {
+    ($($arg:tt)*) => ($crate::string::format(format_args!($($arg)*)))
+}

src/libcollections/string.rs

@@ -672,6 +672,32 @@ impl String {
     }
 }
 
+/// 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
+/// use std::string;
+///
+/// let s = string::format(format_args!("Hello, {}!", "world"));
+/// assert_eq!(s, "Hello, world!".to_string());
+/// ```
+#[unstable = "this is an implementation detail of format! and should not \
+                  be called directly"]
+pub fn format(args: fmt::Arguments) -> String {
+    use core::fmt::Writer;
+    let hint = fmt::Display::size_hint(&args);
+    let mut output = String::with_capacity(hint.min);
+    let _ = write!(&mut output, "{}", args);
+    output.shrink_to_fit();
+    output
+}
+
 impl FromUtf8Error {
     /// Consume this error, returning the bytes that were attempted to make a
     /// `String` with.
@@ -942,11 +968,7 @@ pub trait ToString {
 impl<T: fmt::Display + ?Sized> ToString for T {
     #[inline]
     fn to_string(&self) -> String {
-        use core::fmt::Writer;
-        let mut buf = String::new();
-        let _ = buf.write_fmt(format_args!("{}", self));
-        buf.shrink_to_fit();
-        buf
+        format!("{}", self)
     }
 }
 

src/libstd/fmt.rs

@@ -405,9 +405,7 @@
 
 #![unstable]
 
-use string;
-
-pub use core::fmt::{Formatter, Result, Writer, rt};
+pub use core::fmt::{Formatter, Result, Writer, rt, SizeHint};
 pub use core::fmt::{Show, String, Octal, Binary};
 pub use core::fmt::{Display, Debug};
 pub use core::fmt::{LowerHex, UpperHex, Pointer};
@@ -417,28 +415,3 @@ pub use core::fmt::{Argument, Arguments, write, radix, Radix, RadixFmt};
 
 #[doc(hidden)]
 pub use core::fmt::{argument, argumentuint};
-
-/// 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
-/// use std::fmt;
-///
-/// let s = fmt::format(format_args!("Hello, {}!", "world"));
-/// assert_eq!(s, "Hello, world!".to_string());
-/// ```
-#[unstable = "this is an implementation detail of format! and should not \
-                  be called directly"]
-pub fn format(args: Arguments) -> string::String {
-    let min = String::size_hint(args);
-    let mut output = string::String::with_capacity(min);
-    let _ = write!(&mut output, "{}", args);
-    output.shrink_to_fit();
-    output
-}

src/libstd/lib.rs

@@ -130,7 +130,7 @@ extern crate log;
 extern crate core;
 
 #[macro_use]
-#[macro_reexport(vec)]
+#[macro_reexport(format, vec)]
 extern crate "collections" as core_collections;
 
 extern crate "rand" as core_rand;

src/libstd/macros.rs

@@ -60,21 +60,6 @@ macro_rules! panic {
     });
 }
 
-/// 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}", 10i, y = 30i);
-/// ```
-#[macro_export]
-#[stable]
-macro_rules! format {
-    ($($arg:tt)*) => ($crate::fmt::format(format_args!($($arg)*)))
-}
 
 /// Equivalent to the `println!` macro except that a newline is not printed at
 /// the end of the message.

src/test/run-pass/deriving-show.rs

@@ -30,6 +30,7 @@ macro_rules! t {
     }
 }
 
+
 pub fn main() {
     t!(Unit, "Unit");
     t!(Tuple(1, 2), "Tuple(1, 2)");

src/test/run-pass/ifmt.rs

@@ -196,6 +196,7 @@ fn test_print() {
 // can do with them just yet (to test the output)
 fn test_format_args() {
     use std::fmt::Writer;
+    use std::string;
     let mut buf = String::new();
     {
         let w = &mut buf;
@@ -206,7 +207,7 @@ fn test_format_args() {
     let s = buf;
     t!(s, "1test3");
 
-    let s = fmt::format(format_args!("hello {}", "world"));
+    let s = string::format(format_args!("hello {}", "world"));
     t!(s, "hello world");
     let s = format!("{}: {}", "args were", format_args!("hello {}", "world"));
     t!(s, "args were: hello world");