Extend and expose API for {:x?} and {:X?} formatting

compiler/rustc_parse_format/src/lib.rs

@@ -142,19 +142,36 @@ pub enum Alignment {
 #[derive(Copy, Clone, Debug, PartialEq)]
 pub enum Flag {
  /// A `+` will be used to denote positive numbers.
- FlagSignPlus,
+ FlagSignPlus = 0b0000_0001,
  /// A `-` will be used to denote negative numbers. This is the default.
- FlagSignMinus,
+ FlagSignMinus = 0b0000_0010,
  /// An alternate form will be used for the value. In the case of numbers,
  /// this means that the number will be prefixed with the supplied string.
- FlagAlternate,
+ FlagAlternate = 0b0000_0100,
  /// For numbers, this means that the number will be padded with zeroes,
  /// and the sign (`+` or `-`) will precede them.
- FlagSignAwareZeroPad,
- /// For Debug / `?`, format integers in lower-case hexadecimal.
- FlagDebugLowerHex,
- /// For Debug / `?`, format integers in upper-case hexadecimal.
- FlagDebugUpperHex,
+ FlagSignAwareZeroPad = 0b0000_1000,
+ /// For Debug / `?`, the variant used.
+ FlagDebugVariant = 0b1111_0000_0000,
+}
+
+/// Version of `DebugVariant` that can be used on stable.
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub enum DebugVariant {
+ /// [`LowerHex`]-like formatting. (`{:x?}`)
+ LowerHex = 0b0001_0000_0000,
+ /// [`UpperHex`]-like formatting. (`{:X?}`)
+ UpperHex = 0b0010_0000_0000,
+ /// [`Octal`]-like formatting. (`{:o?}`)
+ Octal = 0b0100_0000_0000,
+ /// [`Binary`]-like formatting. (`{:b?}`)
+ Binary = 0b1000_0000_0000,
+ /// [`LowerExp`]-like formatting. (`{:e?}`)
+ LowerExp = 0b0011_0000_0000,
+ /// [`UpperExp`]-like formatting. (`{:E?}`)
+ UpperExp = 0b0110_0000_0000,
+ /// [`Pointer`]-like formatting. (`{:p?}`)
+ Pointer = 0b1100_0000_0000,
 }
 
 /// A count is used for the precision and width parameters of an integer, and
@@ -580,13 +597,13 @@ impl<'a> Parser<'a> {
  }
  // Sign flags
  if self.consume('+') {
- spec.flags |= 1 << (FlagSignPlus as u32);
+ spec.flags |= FlagSignPlus as u32;
  } else if self.consume('-') {
- spec.flags |= 1 << (FlagSignMinus as u32);
+ spec.flags |= FlagSignMinus as u32;
  }
  // Alternate marker
  if self.consume('#') {
- spec.flags |= 1 << (FlagAlternate as u32);
+ spec.flags |= FlagAlternate as u32;
  }
  // Width and precision
  let mut havewidth = false;
@@ -601,7 +618,7 @@ impl<'a> Parser<'a> {
  spec.width_span = Some(self.span(end - 1, end + 1));
  havewidth = true;
  } else {
- spec.flags |= 1 << (FlagSignAwareZeroPad as u32);
+ spec.flags |= FlagSignAwareZeroPad as u32;
  }
  }
 
@@ -628,31 +645,43 @@ impl<'a> Parser<'a> {
  spec.precision_span = Some(self.span(start, end));
  }
 
- let ty_span_start = self.current_pos();
+ let mut ty_span_start = self.cur.peek().map(|(pos, _)| *pos);
  // Optional radix followed by the actual format specifier
- if self.consume('x') {
- if self.consume('?') {
- spec.flags |= 1 << (FlagDebugLowerHex as u32);
- spec.ty = "?";
- } else {
- spec.ty = "x";
- }
- } else if self.consume('X') {
- if self.consume('?') {
- spec.flags |= 1 << (FlagDebugUpperHex as u32);
- spec.ty = "?";
- } else {
- spec.ty = "X";
- }
- } else if self.consume('?') {
+ if self.consume('?') {
  spec.ty = "?";
  } else {
  spec.ty = self.word();
- if !spec.ty.is_empty() {
- let ty_span_end = self.current_pos();
- spec.ty_span = Some(self.span(ty_span_start, ty_span_end));
+
+ // FIXME: let chains
+ if let Some(&(pos, c)) = self.cur.peek() {
+ if c == '?' {
+ let variant = match spec.ty {
+ "x" => Some(DebugVariant::LowerHex),
+ "X" => Some(DebugVariant::UpperHex),
+ "o" => Some(DebugVariant::Octal),
+ "b" => Some(DebugVariant::Binary),
+ "e" => Some(DebugVariant::LowerExp),
+ "E" => Some(DebugVariant::UpperExp),
+ "p" => Some(DebugVariant::Pointer),
+ _ => None,
+ };
+ if let Some(variant) = variant {
+ spec.ty = "?";
+ spec.flags |= variant as u32;
+ ty_span_start = Some(pos);
+
+ // only advance if we have a valid variant
+ self.cur.next();
+ }
+ }
  }
  }
+ let ty_span_end = self.cur.peek().map(|(pos, _)| *pos);
+ if !spec.ty.is_empty() {
+ spec.ty_span = ty_span_start
+ .and_then(|s| ty_span_end.map(|e| (s, e)))
+ .map(|(start, end)| self.to_span_index(start).to(self.to_span_index(end)));
+ }
  spec
  }