auto merge of #19118 : jakub-/rust/roll-up, r=jakub-

5 files changed, 35 insertions, 32 deletions

diff --git a/src/libstd/fmt.rs b/src/libstd/fmt.rs
index e140ddba723..2482fe63028 100644
--- a/src/libstd/fmt.rs
+++ b/src/libstd/fmt.rs
@@ -38,11 +38,11 @@ Some examples of the `format!` extension are:
 ```rust
 # fn main() {
 format!("Hello");                  // => "Hello"
-format!("Hello, {:s}!", "world");  // => "Hello, world!"
-format!("The number is {:d}", 1i); // => "The number is 1"
+format!("Hello, {}!", "world");    // => "Hello, world!"
+format!("The number is {}", 1i);   // => "The number is 1"
 format!("{}", (3i, 4i));           // => "(3, 4)"
 format!("{value}", value=4i);      // => "4"
-format!("{} {}", 1i, 2i);          // => "1 2"
+format!("{} {}", 1i, 2u);          // => "1 2"
 # }
 ```
 
@@ -94,9 +94,9 @@ For example, the following `format!` expressions all use named argument:
 
 ```rust
 # fn main() {
-format!("{argument}", argument = "test");        // => "test"
-format!("{name} {}", 1i, name = 2i);             // => "2 1"
-format!("{a:s} {c:d} {b}", a="a", b=(), c=3i); // => "a 3 ()"
+format!("{argument}", argument = "test");   // => "test"
+format!("{name} {}", 1i, name = 2i);        // => "2 1"
+format!("{a} {c} {b}", a="a", b=(), c=3i);  // => "a 3 ()"
 # }
 ```
 
@@ -138,23 +138,16 @@ multiple actual types to be formatted via `{:d}` (like `i8` as well as `int`).
 The current mapping of types to traits is:
 
 * *nothing* ⇒ `Show`
-* `d` ⇒ `Signed`
-* `i` ⇒ `Signed`
-* `u` ⇒ `Unsigned`
-* `b` ⇒ `Bool`
-* `c` ⇒ `Char`
 * `o` ⇒ `Octal`
 * `x` ⇒ `LowerHex`
 * `X` ⇒ `UpperHex`
-* `s` ⇒ `String`
 * `p` ⇒ `Pointer`
-* `t` ⇒ `Binary`
-* `f` ⇒ `Float`
+* `b` ⇒ `Binary`
 * `e` ⇒ `LowerExp`
 * `E` ⇒ `UpperExp`
 
 What this means is that any type of argument which implements the
-`std::fmt::Binary` trait can then be formatted with `{:t}`. Implementations are
+`std::fmt::Binary` trait can then be formatted with `{:b}`. Implementations are
 provided for these traits for a number of primitive types by the standard
 library as well. If no format is specified (as in `{}` or `{:6}`), then the
 format trait used is the `Show` trait. This is one of the more commonly
@@ -216,7 +209,7 @@ impl fmt::Binary for Vector2D {
         // Respect the formatting flags by using the helper method
         // `pad_integral` on the Formatter object. See the method documentation
         // for details, and the function `pad` can be used to pad strings.
-        let decimals = f.precision.unwrap_or(3);
+        let decimals = f.precision().unwrap_or(3);
         let string = f64::to_str_exact(magnitude, decimals);
         f.pad_integral(true, "", string.as_bytes())
     }
@@ -226,7 +219,7 @@ fn main() {
     let myvector = Vector2D { x: 3, y: 4 };
 
     println!("{}", myvector);       // => "(3, 4)"
-    println!("{:10.3t}", myvector); // => "     5.000"
+    println!("{:10.3b}", myvector); // => "     5.000"
 }
 ```
 
@@ -418,10 +411,10 @@ use string;
 use vec::Vec;
 
 pub use core::fmt::{Formatter, Result, FormatWriter, rt};
-pub use core::fmt::{Show, Bool, Char, Signed, Unsigned, Octal, Binary};
-pub use core::fmt::{LowerHex, UpperHex, String, Pointer};
-pub use core::fmt::{Float, LowerExp, UpperExp};
-pub use core::fmt::{FormatError, WriteError};
+pub use core::fmt::{Show, Octal, Binary};
+pub use core::fmt::{LowerHex, UpperHex, Pointer};
+pub use core::fmt::{LowerExp, UpperExp};
+pub use core::fmt::Error;
 pub use core::fmt::{Argument, Arguments, write, radix, Radix, RadixFmt};
 
 #[doc(hidden)]
@@ -444,6 +437,8 @@ pub use core::fmt::{argument, argumentstr, argumentuint};
 /// let s = format_args!(fmt::format, "Hello, {}!", "world");
 /// assert_eq!(s, "Hello, world!".to_string());
 /// ```
+#[experimental = "this is an implementation detail of format! and should not \
+                  be called directly"]
 pub fn format(args: &Arguments) -> string::String {
     let mut output = Vec::new();
     let _ = write!(&mut output as &mut Writer, "{}", args);
@@ -454,7 +449,7 @@ impl<'a> Writer for Formatter<'a> {
     fn write(&mut self, b: &[u8]) -> io::IoResult<()> {
         match (*self).write(b) {
             Ok(()) => Ok(()),
-            Err(WriteError) => Err(io::standard_error(io::OtherIoError))
+            Err(Error) => Err(io::standard_error(io::OtherIoError))
         }
     }
 }
diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs
index 82bfa3c4e80..681400e9db5 100644
--- a/src/libstd/io/mod.rs
+++ b/src/libstd/io/mod.rs
@@ -1034,7 +1034,7 @@ pub trait Writer {
                     Ok(()) => Ok(()),
                     Err(e) => {
                         self.error = Err(e);
-                        Err(fmt::WriteError)
+                        Err(fmt::Error)
                     }
                 }
             }
@@ -1081,13 +1081,13 @@ pub trait Writer {
     /// Write the result of passing n through `int::to_str_bytes`.
     #[inline]
     fn write_int(&mut self, n: int) -> IoResult<()> {
-        write!(self, "{:d}", n)
+        write!(self, "{}", n)
     }
 
     /// Write the result of passing n through `uint::to_str_bytes`.
     #[inline]
     fn write_uint(&mut self, n: uint) -> IoResult<()> {
-        write!(self, "{:u}", n)
+        write!(self, "{}", n)
     }
 
     /// Write a little-endian uint (number of bytes depends on system).
@@ -1896,10 +1896,8 @@ impl Default for FilePermission {
 }
 
 impl fmt::Show for FilePermission {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.fill = '0';
-        formatter.width = Some(4);
-        (&self.bits as &fmt::Octal).fmt(formatter)
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{:04o}", self.bits)
     }
 }
 
diff --git a/src/libstd/macros.rs b/src/libstd/macros.rs
index 26e9e70dff3..4e5dd5d8818 100644
--- a/src/libstd/macros.rs
+++ b/src/libstd/macros.rs
@@ -240,6 +240,7 @@ macro_rules! unimplemented(
 /// format!("x = {}, y = {y}", 10i, y = 30i);
 /// ```
 #[macro_export]
+#[stable]
 macro_rules! format(
     ($($arg:tt)*) => (
         format_args!(::std::fmt::format, $($arg)*)
@@ -259,15 +260,18 @@ macro_rules! format(
 /// write!(&mut w, "formatted {}", "arguments");
 /// ```
 #[macro_export]
+#[stable]
 macro_rules! write(
     ($dst:expr, $($arg:tt)*) => ({
-        format_args_method!($dst, write_fmt, $($arg)*)
+        let dst = &mut *$dst;
+        format_args!(|args| { dst.write_fmt(args) }, $($arg)*)
     })
 )
 
 /// Equivalent to the `write!` macro, except that a newline is appended after
 /// the message is written.
 #[macro_export]
+#[stable]
 macro_rules! writeln(
     ($dst:expr, $fmt:expr $($arg:tt)*) => (
         write!($dst, concat!($fmt, "\n") $($arg)*)
@@ -277,6 +281,7 @@ macro_rules! writeln(
 /// Equivalent to the `println!` macro except that a newline is not printed at
 /// the end of the message.
 #[macro_export]
+#[stable]
 macro_rules! print(
     ($($arg:tt)*) => (format_args!(::std::io::stdio::print_args, $($arg)*))
 )
@@ -294,6 +299,7 @@ macro_rules! print(
 /// println!("format {} arguments", "some");
 /// ```
 #[macro_export]
+#[stable]
 macro_rules! println(
     ($($arg:tt)*) => (format_args!(::std::io::stdio::println_args, $($arg)*))
 )
diff --git a/src/libstd/os.rs b/src/libstd/os.rs
index b898b9a2df4..68ddabfd48f 100644
--- a/src/libstd/os.rs
+++ b/src/libstd/os.rs
@@ -1108,6 +1108,10 @@ extern "system" {
 /// Returns the arguments which this program was started with (normally passed
 /// via the command line).
 ///
+/// The first element is traditionally the path to the executable, but it can be
+/// set to arbitrary text, and it may not even exist, so this property should not
+//  be relied upon for security purposes.
+///
 /// The arguments are interpreted as utf-8, with invalid bytes replaced with \uFFFD.
 /// See `String::from_utf8_lossy` for details.
 /// # Example
diff --git a/src/libstd/rand/os.rs b/src/libstd/rand/os.rs
index 43a79770fbb..2a4d8347c30 100644
--- a/src/libstd/rand/os.rs
+++ b/src/libstd/rand/os.rs
@@ -212,12 +212,12 @@ mod imp {
     impl Rng for OsRng {
         fn next_u32(&mut self) -> u32 {
             let mut v = [0u8, .. 4];
-            self.fill_bytes(v);
+            self.fill_bytes(&mut v);
             unsafe { mem::transmute(v) }
         }
         fn next_u64(&mut self) -> u64 {
             let mut v = [0u8, .. 8];
-            self.fill_bytes(v);
+            self.fill_bytes(&mut v);
             unsafe { mem::transmute(v) }
         }
         fn fill_bytes(&mut self, v: &mut [u8]) {