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

20 files changed, 249 insertions, 76 deletions

diff --git a/src/test/bench/core-set.rs b/src/test/bench/core-set.rs
index 15d89bebf75..07300b73c85 100644
--- a/src/test/bench/core-set.rs
+++ b/src/test/bench/core-set.rs
@@ -148,7 +148,7 @@ fn write_header(header: &str) {
 }
 
 fn write_row(label: &str, value: Duration) {
-    println!("{:30s} {} s\n", label, value);
+    println!("{:30} {} s\n", label, value);
 }
 
 fn write_results(label: &str, results: &Results) {
diff --git a/src/test/bench/noise.rs b/src/test/bench/noise.rs
index 1c530e3851e..419e39b53cf 100644
--- a/src/test/bench/noise.rs
+++ b/src/test/bench/noise.rs
@@ -115,7 +115,7 @@ fn main() {
     for y in range(0u, 256) {
         for x in range(0u, 256) {
             let idx = (pixels[y*256+x] / 0.2) as uint;
-            print!("{:c}", symbols[idx]);
+            print!("{}", symbols[idx]);
         }
         print!("\n");
     }
diff --git a/src/test/bench/shootout-k-nucleotide-pipes.rs b/src/test/bench/shootout-k-nucleotide-pipes.rs
index e39cd743ad5..4005c11e6b6 100644
--- a/src/test/bench/shootout-k-nucleotide-pipes.rs
+++ b/src/test/bench/shootout-k-nucleotide-pipes.rs
@@ -63,7 +63,7 @@ fn sort_and_fmt(mm: &HashMap<Vec<u8> , uint>, total: uint) -> String {
 
    let mut buffer = String::new();
    for &(ref k, v) in pairs_sorted.iter() {
-       buffer.push_str(format!("{} {:0.3f}\n",
+       buffer.push_str(format!("{} {:0.3}\n",
                                k.as_slice()
                                .to_ascii()
                                .to_uppercase()
diff --git a/src/test/bench/shootout-k-nucleotide.rs b/src/test/bench/shootout-k-nucleotide.rs
index 6ada34a5a58..b030e7bb93e 100644
--- a/src/test/bench/shootout-k-nucleotide.rs
+++ b/src/test/bench/shootout-k-nucleotide.rs
@@ -266,7 +266,7 @@ fn print_frequencies(frequencies: &Table, frame: uint) {
     }
 
     for &(count, key) in vector.iter().rev() {
-        println!("{} {:.3f}",
+        println!("{} {:.3}",
                  key.unpack(frame).as_slice(),
                  (count as f32 * 100.0) / (total_count as f32));
     }
diff --git a/src/test/bench/shootout-nbody.rs b/src/test/bench/shootout-nbody.rs
index 3bcc0c25df8..b62504d7ba8 100644
--- a/src/test/bench/shootout-nbody.rs
+++ b/src/test/bench/shootout-nbody.rs
@@ -179,11 +179,11 @@ fn main() {
     let mut bodies = BODIES;
 
     offset_momentum(&mut bodies);
-    println!("{:.9f}", energy(&bodies));
+    println!("{:.9}", energy(&bodies));
 
     advance(&mut bodies, 0.01, n);
 
-    println!("{:.9f}", energy(&bodies));
+    println!("{:.9}", energy(&bodies));
 }
 
 /// Pop a mutable reference off the head of a slice, mutating the slice to no
diff --git a/src/test/bench/shootout-spectralnorm.rs b/src/test/bench/shootout-spectralnorm.rs
index acb289aa3ad..f76391b596b 100644
--- a/src/test/bench/shootout-spectralnorm.rs
+++ b/src/test/bench/shootout-spectralnorm.rs
@@ -59,7 +59,7 @@ fn main() {
     } else {
         from_str(args[1].as_slice()).unwrap()
     });
-    println!("{:.9f}", answer);
+    println!("{:.9}", answer);
 }
 
 fn spectralnorm(n: uint) -> f64 {
diff --git a/src/test/compile-fail/associated-types-in-ambiguous-context.rs b/src/test/compile-fail/associated-types-in-ambiguous-context.rs
index a2c01fe62f6..24de1fa2f78 100644
--- a/src/test/compile-fail/associated-types-in-ambiguous-context.rs
+++ b/src/test/compile-fail/associated-types-in-ambiguous-context.rs
@@ -20,12 +20,12 @@ fn get<T:Get,U:Get>(x: T, y: U) -> Get::Value {}
 
 trait Other {
     fn uhoh<U:Get>(&self, foo: U, bar: <Self as Get>::Value) {}
-    //~^ ERROR this associated type is not allowed in this context
+    //~^ ERROR no suitable bound on `Self`
 }
 
 impl<T:Get> Other for T {
     fn uhoh<U:Get>(&self, foo: U, bar: <(T, U) as Get>::Value) {}
-    //~^ ERROR this associated type is not allowed in this context
+    //~^ ERROR currently unsupported
 }
 
 trait Grab {
diff --git a/src/test/compile-fail/associated-types-in-wrong-context.rs b/src/test/compile-fail/associated-types-in-wrong-context.rs
index 8fbfc33896b..8cab2759ad5 100644
--- a/src/test/compile-fail/associated-types-in-wrong-context.rs
+++ b/src/test/compile-fail/associated-types-in-wrong-context.rs
@@ -16,7 +16,7 @@ trait Get {
 }
 
 fn get(x: int) -> <int as Get>::Value {}
-//~^ ERROR this associated type is not allowed in this context
+//~^ ERROR unsupported
 
 struct Struct {
     x: int,
@@ -24,7 +24,7 @@ struct Struct {
 
 impl Struct {
     fn uhoh<T>(foo: <T as Get>::Value) {}
-    //~^ ERROR this associated type is not allowed in this context
+    //~^ ERROR no suitable bound on `T`
 }
 
 fn main() {
diff --git a/src/test/compile-fail/bad-lit-suffixes.rs b/src/test/compile-fail/bad-lit-suffixes.rs
new file mode 100644
index 00000000000..d10337e768c
--- /dev/null
+++ b/src/test/compile-fail/bad-lit-suffixes.rs
@@ -0,0 +1,41 @@
+// 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.
+
+
+extern crate
+    "foo"suffix //~ ERROR extern crate name with a suffix is illegal
+     as foo;
+
+extern
+    "C"suffix //~ ERROR ABI spec with a suffix is illegal
+    fn foo() {}
+
+extern
+    "C"suffix //~ ERROR ABI spec with a suffix is illegal
+{}
+
+fn main() {
+    ""suffix; //~ ERROR str literal with a suffix is illegal
+    b""suffix; //~ ERROR binary str literal with a suffix is illegal
+    r#""#suffix; //~ ERROR str literal with a suffix is illegal
+    br#""#suffix; //~ ERROR binary str literal with a suffix is illegal
+    'a'suffix; //~ ERROR char literal with a suffix is illegal
+    b'a'suffix; //~ ERROR byte literal with a suffix is illegal
+
+    1234u1024; //~ ERROR illegal width `1024` for integer literal
+    1234i1024; //~ ERROR illegal width `1024` for integer literal
+    1234f1024; //~ ERROR illegal width `1024` for float literal
+    1234.5f1024; //~ ERROR illegal width `1024` for float literal
+
+    1234suffix; //~ ERROR illegal suffix `suffix` for numeric literal
+    0b101suffix; //~ ERROR illegal suffix `suffix` for numeric literal
+    1.0suffix; //~ ERROR illegal suffix `suffix` for float literal
+    1.0e10suffix; //~ ERROR illegal suffix `suffix` for float literal
+}
diff --git a/src/test/compile-fail/deriving-non-type.rs b/src/test/compile-fail/deriving-non-type.rs
new file mode 100644
index 00000000000..8226bba42b0
--- /dev/null
+++ b/src/test/compile-fail/deriving-non-type.rs
@@ -0,0 +1,40 @@
+// 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.
+
+#![allow(dead_code)]
+
+struct S;
+
+#[deriving(PartialEq)] //~ ERROR: `deriving` may only be applied to structs and enums
+trait T { }
+
+#[deriving(PartialEq)] //~ ERROR: `deriving` may only be applied to structs and enums
+impl S { }
+
+#[deriving(PartialEq)] //~ ERROR: `deriving` may only be applied to structs and enums
+impl T for S { }
+
+#[deriving(PartialEq)] //~ ERROR: `deriving` may only be applied to structs and enums
+static s: uint = 0u;
+
+#[deriving(PartialEq)] //~ ERROR: `deriving` may only be applied to structs and enums
+const c: uint = 0u;
+
+#[deriving(PartialEq)] //~ ERROR: `deriving` may only be applied to structs and enums
+mod m { }
+
+#[deriving(PartialEq)] //~ ERROR: `deriving` may only be applied to structs and enums
+extern "C" { }
+
+#[deriving(PartialEq)] //~ ERROR: `deriving` may only be applied to structs and enums
+type A = uint;
+
+#[deriving(PartialEq)] //~ ERROR: `deriving` may only be applied to structs and enums
+fn main() { }
diff --git a/src/test/compile-fail/ifmt-bad-arg.rs b/src/test/compile-fail/ifmt-bad-arg.rs
index 6829b1e2721..db7f49272aa 100644
--- a/src/test/compile-fail/ifmt-bad-arg.rs
+++ b/src/test/compile-fail/ifmt-bad-arg.rs
@@ -23,8 +23,8 @@ fn main() {
     format!("{foo}", 1, foo=2);        //~ ERROR: argument never used
     format!("", foo=2);                //~ ERROR: named argument never used
 
-    format!("{0:d} {0:s}", 1);         //~ ERROR: redeclared with type `s`
-    format!("{foo:d} {foo:s}", foo=1); //~ ERROR: redeclared with type `s`
+    format!("{0:x} {0:X}", 1);         //~ ERROR: redeclared with type `X`
+    format!("{foo:x} {foo:X}", foo=1); //~ ERROR: redeclared with type `X`
 
     format!("{foo}", foo=1, foo=2);    //~ ERROR: duplicate argument
     format!("", foo=1, 2);             //~ ERROR: positional arguments cannot follow
diff --git a/src/test/compile-fail/ifmt-unimpl.rs b/src/test/compile-fail/ifmt-unimpl.rs
index 194047ce848..948040496bd 100644
--- a/src/test/compile-fail/ifmt-unimpl.rs
+++ b/src/test/compile-fail/ifmt-unimpl.rs
@@ -9,6 +9,6 @@
 // except according to those terms.
 
 fn main() {
-    format!("{:d}", "3");
-    //~^ ERROR: the trait `core::fmt::Signed` is not implemented
+    format!("{:X}", "3");
+    //~^ ERROR: the trait `core::fmt::UpperHex` is not implemented
 }
diff --git a/src/test/compile-fail/issue-1448-2.rs b/src/test/compile-fail/issue-1448-2.rs
index 3daced7a5ac..234fa85c89a 100644
--- a/src/test/compile-fail/issue-1448-2.rs
+++ b/src/test/compile-fail/issue-1448-2.rs
@@ -13,5 +13,5 @@
 fn foo(a: uint) -> uint { a }
 
 fn main() {
-    println!("{:u}", foo(10i)); //~ ERROR mismatched types
+    println!("{}", foo(10i)); //~ ERROR mismatched types
 }
diff --git a/src/test/compile-fail/issue-14853.rs b/src/test/compile-fail/issue-14853.rs
index 4243b98e0dd..6515b34d964 100644
--- a/src/test/compile-fail/issue-14853.rs
+++ b/src/test/compile-fail/issue-14853.rs
@@ -10,17 +10,18 @@
 
 use std::fmt::Show;
 
+trait Str {}
+
 trait Something {
-    fn yay<T: Show>(_: Option<Self>, thing: &[T]) -> String {
-    }
+    fn yay<T: Show>(_: Option<Self>, thing: &[T]);
 }
 
 struct X { data: u32 }
 
 impl Something for X {
-    fn yay<T: Str>(_:Option<X>, thing: &[T]) -> String {
-//~^ ERROR in method `yay`, type parameter 0 requires bound `core::str::Str`, which is not required
-        format!("{:s}", thing[0])
+    fn yay<T: Str>(_:Option<X>, thing: &[T]) {
+//~^ ERROR in method `yay`, type parameter 0 requires bound `Str`, which is not required
+
     }
 }
 
diff --git a/src/test/compile-fail/issue-19086.rs b/src/test/compile-fail/issue-19086.rs
new file mode 100644
index 00000000000..69201859457
--- /dev/null
+++ b/src/test/compile-fail/issue-19086.rs
@@ -0,0 +1,23 @@
+// 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.
+
+use Foo::FooB;
+
+enum Foo {
+    FooB { x: i32, y: i32 }
+}
+
+fn main() {
+    let f = FooB { x: 3, y: 4 };
+    match f {
+        FooB(a, b) => println!("{} {}", a, b),
+//~^ ERROR `FooB` does not name a non-struct variant or a tuple struct
+    }
+}
diff --git a/src/test/compile-fail/regions-escape-method.rs b/src/test/compile-fail/regions-escape-method.rs
new file mode 100644
index 00000000000..f92c264784a
--- /dev/null
+++ b/src/test/compile-fail/regions-escape-method.rs
@@ -0,0 +1,26 @@
+// Copyright 2012 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.
+
+// Test a method call where the parameter `B` would (illegally) be
+// inferred to a region bound in the method argument. If this program
+// were accepted, then the closure passed to `s.f` could escape its
+// argument.
+
+struct S;
+
+impl S {
+    fn f<B>(&self, _: |&i32| -> B) {
+    }
+}
+
+fn main() {
+    let s = S;
+    s.f(|p| p) //~ ERROR cannot infer
+}
diff --git a/src/test/compile-fail/utf8_idents.rs b/src/test/compile-fail/utf8_idents.rs
new file mode 100644
index 00000000000..0c3c11ccd07
--- /dev/null
+++ b/src/test/compile-fail/utf8_idents.rs
@@ -0,0 +1,24 @@
+// 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.
+//
+// ignore-lexer-test FIXME #15679
+
+fn foo<
+    'β, //~ ERROR non-ascii idents are not fully supported.
+    γ  //~ ERROR non-ascii idents are not fully supported.
+>() {}
+
+struct X {
+    δ: uint //~ ERROR non-ascii idents are not fully supported.
+}
+
+pub fn main() {
+    let α = 0.00001f64; //~ ERROR non-ascii idents are not fully supported.
+}
diff --git a/src/test/run-pass/associated-types-qualified-path-with-trait-with-type-parameters.rs b/src/test/run-pass/associated-types-qualified-path-with-trait-with-type-parameters.rs
new file mode 100644
index 00000000000..1b4eb2604a8
--- /dev/null
+++ b/src/test/run-pass/associated-types-qualified-path-with-trait-with-type-parameters.rs
@@ -0,0 +1,18 @@
+// 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(associated_types)]
+
+trait Foo<T> {
+    type Bar;
+    fn get_bar() -> <Self as Foo<T>>::Bar;
+}
+
+fn main() { }
diff --git a/src/test/run-pass/ifmt.rs b/src/test/run-pass/ifmt.rs
index 59f7eda4161..b78371c51e4 100644
--- a/src/test/run-pass/ifmt.rs
+++ b/src/test/run-pass/ifmt.rs
@@ -22,12 +22,12 @@ struct A;
 struct B;
 struct C;
 
-impl fmt::Signed for A {
+impl fmt::LowerHex for A {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.write("aloha".as_bytes())
     }
 }
-impl fmt::Signed for B {
+impl fmt::UpperHex for B {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.write("adios".as_bytes())
     }
@@ -55,71 +55,71 @@ pub fn main() {
     t!(format!("{}", 'a'), "a");
 
     // At least exercise all the formats
-    t!(format!("{:b}", true), "true");
-    t!(format!("{:c}", '☃'), "☃");
-    t!(format!("{:d}", 10i), "10");
-    t!(format!("{:i}", 10i), "10");
-    t!(format!("{:u}", 10u), "10");
+    t!(format!("{}", true), "true");
+    t!(format!("{}", '☃'), "☃");
+    t!(format!("{}", 10i), "10");
+    t!(format!("{}", 10i), "10");
+    t!(format!("{}", 10u), "10");
     t!(format!("{:o}", 10u), "12");
     t!(format!("{:x}", 10u), "a");
     t!(format!("{:X}", 10u), "A");
-    t!(format!("{:s}", "foo"), "foo");
-    t!(format!("{:s}", "foo".to_string()), "foo");
+    t!(format!("{}", "foo"), "foo");
+    t!(format!("{}", "foo".to_string()), "foo");
     t!(format!("{:p}", 0x1234 as *const int), "0x1234");
     t!(format!("{:p}", 0x1234 as *mut int), "0x1234");
-    t!(format!("{:d}", A), "aloha");
-    t!(format!("{:d}", B), "adios");
-    t!(format!("foo {:s} ☃☃☃☃☃☃", "bar"), "foo bar ☃☃☃☃☃☃");
+    t!(format!("{:x}", A), "aloha");
+    t!(format!("{:X}", B), "adios");
+    t!(format!("foo {} ☃☃☃☃☃☃", "bar"), "foo bar ☃☃☃☃☃☃");
     t!(format!("{1} {0}", 0i, 1i), "1 0");
     t!(format!("{foo} {bar}", foo=0i, bar=1i), "0 1");
     t!(format!("{foo} {1} {bar} {0}", 0i, 1i, foo=2i, bar=3i), "2 1 3 0");
     t!(format!("{} {0}", "a"), "a a");
     t!(format!("{foo_bar}", foo_bar=1i), "1");
-    t!(format!("{:d}", 5i + 5i), "10");
+    t!(format!("{}", 5i + 5i), "10");
     t!(format!("{:#4}", C), "☃123");
 
     let a: &fmt::Show = &1i;
     t!(format!("{}", a), "1");
 
     // Formatting strings and their arguments
-    t!(format!("{:s}", "a"), "a");
-    t!(format!("{:4s}", "a"), "a   ");
-    t!(format!("{:4s}", "☃"), "☃   ");
-    t!(format!("{:>4s}", "a"), "   a");
-    t!(format!("{:<4s}", "a"), "a   ");
-    t!(format!("{:^5s}", "a"),  "  a  ");
-    t!(format!("{:^5s}", "aa"), " aa  ");
-    t!(format!("{:^4s}", "a"),  " a  ");
-    t!(format!("{:^4s}", "aa"), " aa ");
-    t!(format!("{:.4s}", "a"), "a");
-    t!(format!("{:4.4s}", "a"), "a   ");
-    t!(format!("{:4.4s}", "aaaaaaaaaaaaaaaaaa"), "aaaa");
-    t!(format!("{:<4.4s}", "aaaaaaaaaaaaaaaaaa"), "aaaa");
-    t!(format!("{:>4.4s}", "aaaaaaaaaaaaaaaaaa"), "aaaa");
-    t!(format!("{:^4.4s}", "aaaaaaaaaaaaaaaaaa"), "aaaa");
-    t!(format!("{:>10.4s}", "aaaaaaaaaaaaaaaaaa"), "aaaa");
-    t!(format!("{:2.4s}", "aaaaa"), "aaaa");
-    t!(format!("{:2.4s}", "aaaa"), "aaaa");
-    t!(format!("{:2.4s}", "aaa"), "aaa");
-    t!(format!("{:2.4s}", "aa"), "aa");
-    t!(format!("{:2.4s}", "a"), "a ");
-    t!(format!("{:0>2s}", "a"), "0a");
-    t!(format!("{:.*s}", 4, "aaaaaaaaaaaaaaaaaa"), "aaaa");
-    t!(format!("{:.1$s}", "aaaaaaaaaaaaaaaaaa", 4), "aaaa");
-    t!(format!("{:.a$s}", "aaaaaaaaaaaaaaaaaa", a=4), "aaaa");
-    t!(format!("{:1$s}", "a", 4), "a   ");
-    t!(format!("{1:0$s}", 4, "a"), "a   ");
-    t!(format!("{:a$s}", "a", a=4), "a   ");
-    t!(format!("{:-#s}", "a"), "a");
-    t!(format!("{:+#s}", "a"), "a");
+    t!(format!("{}", "a"), "a");
+    t!(format!("{:4}", "a"), "a   ");
+    t!(format!("{:4}", "☃"), "☃   ");
+    t!(format!("{:>4}", "a"), "   a");
+    t!(format!("{:<4}", "a"), "a   ");
+    t!(format!("{:^5}", "a"),  "  a  ");
+    t!(format!("{:^5}", "aa"), " aa  ");
+    t!(format!("{:^4}", "a"),  " a  ");
+    t!(format!("{:^4}", "aa"), " aa ");
+    t!(format!("{:.4}", "a"), "a");
+    t!(format!("{:4.4}", "a"), "a   ");
+    t!(format!("{:4.4}", "aaaaaaaaaaaaaaaaaa"), "aaaa");
+    t!(format!("{:<4.4}", "aaaaaaaaaaaaaaaaaa"), "aaaa");
+    t!(format!("{:>4.4}", "aaaaaaaaaaaaaaaaaa"), "aaaa");
+    t!(format!("{:^4.4}", "aaaaaaaaaaaaaaaaaa"), "aaaa");
+    t!(format!("{:>10.4}", "aaaaaaaaaaaaaaaaaa"), "aaaa");
+    t!(format!("{:2.4}", "aaaaa"), "aaaa");
+    t!(format!("{:2.4}", "aaaa"), "aaaa");
+    t!(format!("{:2.4}", "aaa"), "aaa");
+    t!(format!("{:2.4}", "aa"), "aa");
+    t!(format!("{:2.4}", "a"), "a ");
+    t!(format!("{:0>2}", "a"), "0a");
+    t!(format!("{:.*}", 4, "aaaaaaaaaaaaaaaaaa"), "aaaa");
+    t!(format!("{:.1$}", "aaaaaaaaaaaaaaaaaa", 4), "aaaa");
+    t!(format!("{:.a$}", "aaaaaaaaaaaaaaaaaa", a=4), "aaaa");
+    t!(format!("{:1$}", "a", 4), "a   ");
+    t!(format!("{1:0$}", 4, "a"), "a   ");
+    t!(format!("{:a$}", "a", a=4), "a   ");
+    t!(format!("{:-#}", "a"), "a");
+    t!(format!("{:+#}", "a"), "a");
 
     // Some float stuff
-    t!(format!("{:f}", 1.0f32), "1");
-    t!(format!("{:f}", 1.0f64), "1");
-    t!(format!("{:.3f}", 1.0f64), "1.000");
-    t!(format!("{:10.3f}", 1.0f64),   "     1.000");
-    t!(format!("{:+10.3f}", 1.0f64),  "    +1.000");
-    t!(format!("{:+10.3f}", -1.0f64), "    -1.000");
+    t!(format!("{:}", 1.0f32), "1");
+    t!(format!("{:}", 1.0f64), "1");
+    t!(format!("{:.3}", 1.0f64), "1.000");
+    t!(format!("{:10.3}", 1.0f64),   "     1.000");
+    t!(format!("{:+10.3}", 1.0f64),  "    +1.000");
+    t!(format!("{:+10.3}", -1.0f64), "    -1.000");
 
     t!(format!("{:e}", 1.2345e6f32), "1.2345e6");
     t!(format!("{:e}", 1.2345e6f64), "1.2345e6");
@@ -164,7 +164,7 @@ fn test_write() {
     {
         let w = &mut buf as &mut io::Writer;
         write!(w, "{foo}", foo=4i);
-        write!(w, "{:s}", "hello");
+        write!(w, "{}", "hello");
         writeln!(w, "{}", "line");
         writeln!(w, "{foo}", foo="bar");
     }
diff --git a/src/test/run-pass/realloc-16687.rs b/src/test/run-pass/realloc-16687.rs
index bd581dd657f..a29ed712d40 100644
--- a/src/test/run-pass/realloc-16687.rs
+++ b/src/test/run-pass/realloc-16687.rs
@@ -46,19 +46,19 @@ unsafe fn test_triangle() -> bool {
     static PRINT : bool = false;
 
     unsafe fn allocate(size: uint, align: uint) -> *mut u8 {
-        if PRINT { println!("allocate(size={:u} align={:u})", size, align); }
+        if PRINT { println!("allocate(size={} align={})", size, align); }
 
         let ret = heap::allocate(size, align);
         if ret.is_null() { alloc::oom() }
 
-        if PRINT { println!("allocate(size={:u} align={:u}) ret: 0x{:010x}",
+        if PRINT { println!("allocate(size={} align={}) ret: 0x{:010x}",
                             size, align, ret as uint);
         }
 
         ret
     }
     unsafe fn deallocate(ptr: *mut u8, size: uint, align: uint) {
-        if PRINT { println!("deallocate(ptr=0x{:010x} size={:u} align={:u})",
+        if PRINT { println!("deallocate(ptr=0x{:010x} size={} align={})",
                             ptr as uint, size, align);
         }
 
@@ -66,7 +66,7 @@ unsafe fn test_triangle() -> bool {
     }
     unsafe fn reallocate(ptr: *mut u8, old_size: uint, size: uint, align: uint) -> *mut u8 {
         if PRINT {
-            println!("reallocate(ptr=0x{:010x} old_size={:u} size={:u} align={:u})",
+            println!("reallocate(ptr=0x{:010x} old_size={} size={} align={})",
                      ptr as uint, old_size, size, align);
         }
 
@@ -74,7 +74,7 @@ unsafe fn test_triangle() -> bool {
         if ret.is_null() { alloc::oom() }
 
         if PRINT {
-            println!("reallocate(ptr=0x{:010x} old_size={:u} size={:u} align={:u}) \
+            println!("reallocate(ptr=0x{:010x} old_size={} size={} align={}) \
                       ret: 0x{:010x}",
                      ptr as uint, old_size, size, align, ret as uint);
         }