Delete unused "next" variants from formatting infrastructure

The formatting infrastructure stopped emitting these a while back, and in
removing them we can simplify related code.

src/libcore/fmt/mod.rs

@@ -10,7 +10,6 @@ use crate::mem;
 use crate::num::flt2dec;
 use crate::ops::Deref;
 use crate::result;
-use crate::slice;
 use crate::str;
 
 mod builders;
@@ -234,7 +233,6 @@ pub struct Formatter<'a> {
     precision: Option<usize>,
 
     buf: &'a mut (dyn Write + 'a),
-    curarg: slice::Iter<'a, ArgumentV1<'a>>,
     args: &'a [ArgumentV1<'a>],
 }
 
@@ -1044,7 +1042,6 @@ pub fn write(output: &mut dyn Write, args: Arguments<'_>) -> Result {
         align: rt::v1::Alignment::Unknown,
         fill: ' ',
         args: args.args,
-        curarg: args.args.iter(),
     };
 
     let mut idx = 0;
@@ -1117,7 +1114,6 @@ impl<'a> Formatter<'a> {
 
             // These only exist in the struct for the `run` method,
             // which won’t be used together with this method.
-            curarg: self.curarg.clone(),
             args: self.args,
         }
     }
@@ -1134,9 +1130,17 @@ impl<'a> Formatter<'a> {
         self.precision = self.getcount(&arg.format.precision);
 
         // Extract the correct argument
-        let value = match arg.position {
-            rt::v1::Position::Next => *self.curarg.next().unwrap(),
-            rt::v1::Position::At(i) => self.args[i],
+        let value = {
+            #[cfg(bootstrap)]
+            {
+                match arg.position {
+                    rt::v1::Position::At(i) => self.args[i],
+                }
+            }
+            #[cfg(not(bootstrap))]
+            {
+                self.args[arg.position]
+            }
         };
 
         // Then actually do some printing
@@ -1148,7 +1152,6 @@ impl<'a> Formatter<'a> {
             rt::v1::Count::Is(n) => Some(n),
             rt::v1::Count::Implied => None,
             rt::v1::Count::Param(i) => self.args[i].as_usize(),
-            rt::v1::Count::NextParam => self.curarg.next()?.as_usize(),
         }
     }
 

src/libcore/fmt/rt/v1.rs

@@ -7,7 +7,10 @@
 
 #[derive(Copy, Clone)]
 pub struct Argument {
+    #[cfg(bootstrap)]
     pub position: Position,
+    #[cfg(not(bootstrap))]
+    pub position: usize,
     pub format: FormatSpec,
 }
 
@@ -37,12 +40,11 @@ pub enum Alignment {
 pub enum Count {
     Is(usize),
     Param(usize),
-    NextParam,
     Implied,
 }
 
+#[cfg(bootstrap)]
 #[derive(Copy, Clone)]
 pub enum Position {
-    Next,
     At(usize),
 }

src/librustc_builtin_macros/format.rs

@@ -590,17 +590,6 @@ impl<'a, 'b> Context<'a, 'b> {
             parse::NextArgument(ref arg) => {
                 // Build the position
                 let pos = {
-                    let pos = |c, arg| {
-                        let mut path = Context::rtpath(self.ecx, "Position");
-                        path.push(self.ecx.ident_of(c, sp));
-                        match arg {
-                            Some(i) => {
-                                let arg = self.ecx.expr_usize(sp, i);
-                                self.ecx.expr_call_global(sp, path, vec![arg])
-                            }
-                            None => self.ecx.expr_path(self.ecx.path_global(sp, path)),
-                        }
-                    };
                     match arg.position {
                         parse::ArgumentIs(i) | parse::ArgumentImplicitlyIs(i) => {
                             // Map to index in final generated argument array
@@ -615,7 +604,7 @@ impl<'a, 'b> Context<'a, 'b> {
                                     arg_idx
                                 }
                             };
-                            pos("At", Some(arg_idx))
+                            self.ecx.expr_usize(sp, arg_idx)
                         }
 
                         // should never be the case, because names are already