auto merge of #20837 : huonw/rust/remove-unused-lifetime, r=nikomatsakis

src/libcore/fmt/mod.rs

@@ -180,6 +180,7 @@ impl<'a> Arguments<'a> {
     /// unsafety, but will ignore invalid .
     #[doc(hidden)] #[inline]
     #[unstable = "implementation detail of the `format_args!` macro"]
+    #[cfg(stage0)] // SNAP 9e4e524
     pub fn with_placeholders(pieces: &'a [&'a str],
                              fmt: &'a [rt::Argument<'a>],
                              args: &'a [Argument<'a>]) -> Arguments<'a> {
@@ -189,6 +190,24 @@ impl<'a> Arguments<'a> {
             args: args
         }
     }
+    /// This function is used to specify nonstandard formatting parameters.
+    /// The `pieces` array must be at least as long as `fmt` to construct
+    /// a valid Arguments structure. Also, any `Count` within `fmt` that is
+    /// `CountIsParam` or `CountIsNextParam` has to point to an argument
+    /// created with `argumentuint`. However, failing to do so doesn't cause
+    /// unsafety, but will ignore invalid .
+    #[doc(hidden)] #[inline]
+    #[unstable = "implementation detail of the `format_args!` macro"]
+    #[cfg(not(stage0))]
+    pub fn with_placeholders(pieces: &'a [&'a str],
+                             fmt: &'a [rt::Argument],
+                             args: &'a [Argument<'a>]) -> Arguments<'a> {
+        Arguments {
+            pieces: pieces,
+            fmt: Some(fmt),
+            args: args
+        }
+    }
 }
 
 /// This structure represents a safely precompiled version of a format string
@@ -207,7 +226,11 @@ pub struct Arguments<'a> {
     pieces: &'a [&'a str],
 
     // Placeholder specs, or `None` if all specs are default (as in "{}{}").
+    // SNAP 9e4e524
+    #[cfg(stage0)]
     fmt: Option<&'a [rt::Argument<'a>]>,
+    #[cfg(not(stage0))]
+    fmt: Option<&'a [rt::Argument]>,
 
     // Dynamic arguments for interpolation, to be interleaved with string
     // pieces. (Every argument is preceded by a string piece.)

src/libcore/fmt/rt.rs

@@ -21,8 +21,17 @@ pub use self::Count::*;
 pub use self::Position::*;
 pub use self::Flag::*;
 
+// SNAP 9e4e524
 #[doc(hidden)]
 #[derive(Copy)]
+#[cfg(not(stage0))]
+pub struct Argument {
+    pub position: Position,
+    pub format: FormatSpec,
+}
+#[doc(hidden)]
+#[derive(Copy)]
+#[cfg(stage0)]
 pub struct Argument<'a> {
     pub position: Position,
     pub format: FormatSpec,

src/libsyntax/ext/format.rs

@@ -579,13 +579,9 @@ impl<'a, 'b> Context<'a, 'b> {
         } else {
             // Build up the static array which will store our precompiled
             // nonstandard placeholders, if there are any.
-            let piece_ty = self.ecx.ty_path(self.ecx.path_all(
+            let piece_ty = self.ecx.ty_path(self.ecx.path_global(
                     self.fmtsp,
-                    true, Context::rtpath(self.ecx, "Argument"),
-                    vec![static_lifetime],
-                    vec![],
-                    vec![]
-                ));
+                    Context::rtpath(self.ecx, "Argument")));
             let fmt = Context::static_array(self.ecx,
                                             "__STATIC_FMTARGS",
                                             piece_ty,