From 984eb97abf6bca61041d7e769e7a667c2c940987 Mon Sep 17 00:00:00 2001 From: ilslv Date: Wed, 19 Jan 2022 10:35:32 +0300 Subject: [PATCH 01/14] Replace `peg` crate with manually implemented parser --- Cargo.lock | 25 +- Cargo.toml | 5 +- build.rs | 23 - src/display.rs | 121 +-- src/lib.rs | 2 - src/parsing.rs | 1882 ++++++++++++++++++++++++------------------- src/parsing.rustpeg | 37 - 7 files changed, 1068 insertions(+), 1027 deletions(-) delete mode 100644 src/parsing.rustpeg diff --git a/Cargo.lock b/Cargo.lock index 4bdc3f32..e1698074 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -13,20 +13,11 @@ name = "derive_more" version = "0.99.17" dependencies = [ "convert_case", - "peg", "proc-macro2", - "quote 1.0.10", + "quote", "rustc_version", "syn", -] - -[[package]] -name = "peg" -version = "0.5.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "40df12dde1d836ed2a4c3bfc2799797e3abaf807d97520d28d6e3f3bf41a5f85" -dependencies = [ - "quote 0.3.15", + "unicode-xid", ] [[package]] @@ -38,12 +29,6 @@ dependencies = [ "unicode-xid", ] -[[package]] -name = "quote" -version = "0.3.15" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7a6e920b65c65f10b2ae65c831a81a073a89edd28c7cce89475bff467ab4167a" - [[package]] name = "quote" version = "1.0.10" @@ -75,12 +60,12 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f2afee18b8beb5a596ecb4a2dce128c719b4ba399d34126b9e4396e3f9860966" dependencies = [ "proc-macro2", - "quote 1.0.10", + "quote", "unicode-xid", ] [[package]] name = "unicode-xid" -version = "0.2.1" +version = "0.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f7fe0bb3479651439c9112f72b6c505038574c9fbb575ed1bf3b797fa39dd564" +checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3" diff --git a/Cargo.toml b/Cargo.toml index 458267db..138d0991 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -31,9 +31,9 @@ proc-macro2 = "1.0" quote = "1.0" syn = "1.0.3" convert_case = { version = "0.4", optional = true} +unicode-xid = { version = "0.2.2", optional = true } [build-dependencies] -peg = { version = "0.5", optional = true } rustc_version = { version = "0.4", optional = true } [badges] @@ -48,7 +48,7 @@ as_ref = [] constructor = [] deref = [] deref_mut = [] -display = ["syn/extra-traits"] +display = ["syn/extra-traits", "unicode-xid"] error = ["syn/extra-traits"] from = ["syn/extra-traits"] from_str = [] @@ -62,7 +62,6 @@ mul = ["syn/extra-traits"] not = ["syn/extra-traits"] sum = [] try_into = ["syn/extra-traits"] -generate-parsing-rs = ["peg"] testing-helpers = ["rustc_version"] is_variant = ["convert_case"] unwrap = ["convert_case", "rustc_version"] diff --git a/build.rs b/build.rs index 8b306c30..233bee2c 100644 --- a/build.rs +++ b/build.rs @@ -1,28 +1,6 @@ #[cfg(feature = "testing-helpers")] extern crate rustc_version; -#[cfg(feature = "generate-parsing-rs")] -extern crate peg; - -#[cfg(not(feature = "generate-parsing-rs"))] -fn generate_peg() {} -#[cfg(feature = "generate-parsing-rs")] -fn generate_peg() { - let contents = match ::std::fs::read_to_string("src/parsing.rustpeg") { - Ok(contents) => contents, - Err(e) => panic!("{}", e), - }; - - let compiled = match ::peg::compile(&contents) { - Ok(compiled) => compiled, - Err(e) => panic!("{}", e), - }; - - if let Err(e) = ::std::fs::write("src/parsing.rs", compiled) { - panic!("{}", e); - } -} - #[cfg(not(feature = "testing-helpers"))] fn detect_nightly() {} @@ -49,5 +27,4 @@ fn detect_track_caller() { fn main() { detect_nightly(); detect_track_caller(); - generate_peg(); } diff --git a/src/display.rs b/src/display.rs index 127531d0..c3eb76aa 100644 --- a/src/display.rs +++ b/src/display.rs @@ -6,8 +6,10 @@ use syn::{ parse::Parser as _, punctuated::Punctuated, spanned::Spanned as _, Error, Result, }; -use crate::utils; -use utils::{HashMap, HashSet}; +use crate::{ + parsing, + utils::{self, HashMap, HashSet}, +}; /// Provides the hook to expand `#[derive(Display)]` into an implementation of `From` pub fn expand(input: &syn::DeriveInput, trait_name: &str) -> Result { @@ -744,110 +746,35 @@ impl Placeholder { /// Parses [`Placeholder`]s from a given formatting string. fn parse_fmt_string(s: &str) -> Vec { let mut n = 0; - crate::parsing::all_placeholders(s) + parsing::format_string(s) .into_iter() - .flatten() - .map(|m| { - let (maybe_arg, maybe_typ) = crate::parsing::format(m).unwrap(); - let position = maybe_arg.unwrap_or_else(|| { - // Assign "the next argument". - // https://doc.rust-lang.org/stable/std/fmt/index.html#positional-parameters - n += 1; - n - 1 - }); - let typ = maybe_typ.unwrap_or_default(); - let trait_name = match typ { - "" => "Display", - "?" | "x?" | "X?" => "Debug", - "o" => "Octal", - "x" => "LowerHex", - "X" => "UpperHex", - "p" => "Pointer", - "b" => "Binary", - "e" => "LowerExp", - "E" => "UpperExp", - _ => unreachable!(), - }; + .flat_map(|f| f.formats) + .map(|format| { + let (maybe_arg, ty) = ( + format.arg, + format.spec.map(|s| s.ty).unwrap_or(parsing::Type::Display), + ); + let position = maybe_arg + .and_then(|arg| match arg { + parsing::Argument::Integer(i) => Some(i), + parsing::Argument::Identifier(_) => None, + }) + .unwrap_or_else(|| { + // Assign "the next argument". + // https://doc.rust-lang.org/stable/std/fmt/index.html#positional-parameters + n += 1; + n - 1 + }); + Placeholder { position, - trait_name, + trait_name: ty.trait_name(), } }) .collect() } } -#[cfg(test)] -mod regex_maybe_placeholder_spec { - - #[test] - fn parses_placeholders_and_omits_escaped() { - let fmt_string = "{}, {:?}, {{}}, {{{1:0$}}}"; - let placeholders: Vec<_> = crate::parsing::all_placeholders(&fmt_string) - .into_iter() - .flatten() - .collect(); - assert_eq!(placeholders, vec!["{}", "{:?}", "{1:0$}"]); - } -} - -#[cfg(test)] -mod regex_placeholder_format_spec { - - #[test] - fn detects_type() { - for (p, expected) in vec![ - ("{}", ""), - ("{:?}", "?"), - ("{:x?}", "x?"), - ("{:X?}", "X?"), - ("{:o}", "o"), - ("{:x}", "x"), - ("{:X}", "X"), - ("{:p}", "p"), - ("{:b}", "b"), - ("{:e}", "e"), - ("{:E}", "E"), - ("{:.*}", ""), - ("{8}", ""), - ("{:04}", ""), - ("{1:0$}", ""), - ("{:width$}", ""), - ("{9:>8.*}", ""), - ("{2:.1$x}", "x"), - ] { - let typ = crate::parsing::format(p).unwrap().1.unwrap_or_default(); - assert_eq!(typ, expected); - } - } - - #[test] - fn detects_arg() { - for (p, expected) in vec![ - ("{}", ""), - ("{0:?}", "0"), - ("{12:x?}", "12"), - ("{3:X?}", "3"), - ("{5:o}", "5"), - ("{6:x}", "6"), - ("{:X}", ""), - ("{8}", "8"), - ("{:04}", ""), - ("{1:0$}", "1"), - ("{:width$}", ""), - ("{9:>8.*}", "9"), - ("{2:.1$x}", "2"), - ] { - let arg = crate::parsing::format(p) - .unwrap() - .0 - .map(|s| s.to_string()) - .unwrap_or_default(); - assert_eq!(arg, String::from(expected)); - } - } -} - #[cfg(test)] mod placeholder_parse_fmt_string_spec { use super::*; diff --git a/src/lib.rs b/src/lib.rs index 339e7504..dad6ef0c 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -240,8 +240,6 @@ mod mul_like; #[cfg(feature = "not")] mod not_like; #[cfg(feature = "display")] -#[allow(ellipsis_inclusive_range_patterns)] -#[allow(clippy::all)] mod parsing; #[cfg(feature = "sum")] mod sum_like; diff --git a/src/parsing.rs b/src/parsing.rs index 528d4382..6744915a 100644 --- a/src/parsing.rs +++ b/src/parsing.rs @@ -1,883 +1,1075 @@ -use self::RuleResult::{Failed, Matched}; -fn escape_default(s: &str) -> String { - s.chars().flat_map(|c| c.escape_default()).collect() -} -fn char_range_at(s: &str, pos: usize) -> (char, usize) { - let c = &s[pos..].chars().next().unwrap(); - let next_pos = pos + c.len_utf8(); - (*c, next_pos) -} -#[derive(Clone)] -enum RuleResult { - Matched(usize, T), - Failed, -} -#[derive(PartialEq, Eq, Debug, Clone)] -pub struct ParseError { - pub line: usize, - pub column: usize, - pub offset: usize, - pub expected: ::std::collections::HashSet<&'static str>, -} -pub type ParseResult = Result; -impl ::std::fmt::Display for ParseError { - fn fmt( - &self, - fmt: &mut ::std::fmt::Formatter, - ) -> ::std::result::Result<(), ::std::fmt::Error> { - write!(fmt, "error at {}:{}: expected ", self.line, self.column)?; - if self.expected.len() == 0 { - write!(fmt, "EOF")?; - } else if self.expected.len() == 1 { - write!( - fmt, - "`{}`", - escape_default(self.expected.iter().next().unwrap()) - )?; - } else { - let mut iter = self.expected.iter(); - write!(fmt, "one of `{}`", escape_default(iter.next().unwrap()))?; - for elem in iter { - write!(fmt, ", `{}`", escape_default(elem))?; - } - } - Ok(()) - } +use std::{convert::identity, iter}; + +use unicode_xid::UnicodeXID as XID; + +/// Output of the [`format_string`] parser. +#[derive(Debug, Clone, Eq, PartialEq)] +pub(crate) struct FormatString<'a> { + pub(crate) formats: Vec>, } -impl ::std::error::Error for ParseError { - fn description(&self) -> &str { - "parse error" - } + +/// Output of the [`format`] parser. +#[derive(Debug, Clone, Copy, Eq, PartialEq)] +pub(crate) struct Format<'a> { + pub(crate) arg: Option>, + pub(crate) spec: Option>, } -fn slice_eq( - input: &str, - state: &mut ParseState, - pos: usize, - m: &'static str, -) -> RuleResult<()> { - #![inline] - #![allow(dead_code)] - let l = m.len(); - if input.len() >= pos + l && &input.as_bytes()[pos..pos + l] == m.as_bytes() { - Matched(pos + l, ()) - } else { - state.mark_failure(pos, m) - } + +/// Output of the [`format_spec`] parser. +#[derive(Debug, Clone, Copy, Eq, PartialEq)] +pub(crate) struct FormatSpec<'a> { + pub(crate) width: Option>, + pub(crate) precision: Option>, + pub(crate) ty: Type, } -fn slice_eq_case_insensitive( - input: &str, - state: &mut ParseState, - pos: usize, - m: &'static str, -) -> RuleResult<()> { - #![inline] - #![allow(dead_code)] - let mut used = 0usize; - let mut input_iter = input[pos..].chars().flat_map(|x| x.to_uppercase()); - for m_char_upper in m.chars().flat_map(|x| x.to_uppercase()) { - used += m_char_upper.len_utf8(); - let input_char_result = input_iter.next(); - if input_char_result.is_none() || input_char_result.unwrap() != m_char_upper { - return state.mark_failure(pos, m); - } - } - Matched(pos + used, ()) -} -fn any_char(input: &str, state: &mut ParseState, pos: usize) -> RuleResult<()> { - #![inline] - #![allow(dead_code)] - if input.len() > pos { - let (_, next) = char_range_at(input, pos); - Matched(next, ()) - } else { - state.mark_failure(pos, "") - } + +/// Output of the [`argument`] parser. +#[derive(Debug, Clone, Copy, Eq, PartialEq)] +pub(crate) enum Argument<'a> { + Integer(usize), + Identifier(&'a str), } -fn pos_to_line(input: &str, pos: usize) -> (usize, usize) { - let before = &input[..pos]; - let line = before.as_bytes().iter().filter(|&&c| c == b'\n').count() + 1; - let col = before.chars().rev().take_while(|&c| c != '\n').count() + 1; - (line, col) -} -impl<'input> ParseState<'input> { - fn mark_failure(&mut self, pos: usize, expected: &'static str) -> RuleResult<()> { - if self.suppress_fail == 0 { - if pos > self.max_err_pos { - self.max_err_pos = pos; - self.expected.clear(); - } - if pos == self.max_err_pos { - self.expected.insert(expected); - } - } - Failed - } + +/// Output of the [`precision`] parser. +#[derive(Debug, Clone, Copy, Eq, PartialEq)] +pub(crate) enum Precision<'a> { + Count(Count<'a>), + Star, } -struct ParseState<'input> { - max_err_pos: usize, - suppress_fail: usize, - expected: ::std::collections::HashSet<&'static str>, - _phantom: ::std::marker::PhantomData<&'input ()>, -} -impl<'input> ParseState<'input> { - fn new() -> ParseState<'input> { - ParseState { - max_err_pos: 0, - suppress_fail: 0, - expected: ::std::collections::HashSet::new(), - _phantom: ::std::marker::PhantomData, - } - } + +/// Output of the [`count`] parser. +#[derive(Debug, Clone, Copy, Eq, PartialEq)] +pub(crate) enum Count<'a> { + Integer(usize), + Parameter(Parameter<'a>), } -fn __parse_discard_doubles<'input>( - __input: &'input str, - __state: &mut ParseState<'input>, - __pos: usize, -) -> RuleResult> { - #![allow(non_snake_case, unused)] - { - let __seq_res = { - let __choice_res = { - let __seq_res = slice_eq(__input, __state, __pos, "{"); - match __seq_res { - Matched(__pos, _) => slice_eq(__input, __state, __pos, "{"), - Failed => Failed, - } - }; - match __choice_res { - Matched(__pos, __value) => Matched(__pos, __value), - Failed => { - let __seq_res = slice_eq(__input, __state, __pos, "}"); - match __seq_res { - Matched(__pos, _) => slice_eq(__input, __state, __pos, "}"), - Failed => Failed, - } - } - } - }; - match __seq_res { - Matched(__pos, _) => Matched(__pos, { None }), - Failed => Failed, - } - } +/// Output of the [`type_`] parser. See [formatting traits][1] for more info. +/// +/// [1]: https://doc.rust-lang.org/stable/std/fmt/index.html#formatting-traits +#[derive(Debug, Clone, Copy, Eq, PartialEq)] +pub(crate) enum Type { + Display, + Debug, + LowerDebug, + UpperDebug, + Octal, + LowerHex, + UpperHex, + Pointer, + Binary, + LowerExp, + UpperExp, } -fn __parse_placeholder_inner<'input>( - __input: &'input str, - __state: &mut ParseState<'input>, - __pos: usize, -) -> RuleResult> { - #![allow(non_snake_case, unused)] - { - let __seq_res = { - let str_start = __pos; - match { - let __seq_res = if __input.len() > __pos { - let (__ch, __next) = char_range_at(__input, __pos); - match __ch { - '{' => Matched(__next, ()), - _ => __state.mark_failure(__pos, "[{]"), - } - } else { - __state.mark_failure(__pos, "[{]") - }; - match __seq_res { - Matched(__pos, _) => { - let __seq_res = { - let mut __repeat_pos = __pos; - loop { - let __pos = __repeat_pos; - let __step_res = { - let __seq_res = { - __state.suppress_fail += 1; - let __assert_res = if __input.len() > __pos { - let (__ch, __next) = - char_range_at(__input, __pos); - match __ch { - '{' | '}' => Matched(__next, ()), - _ => { - __state.mark_failure(__pos, "[{}]") - } - } - } else { - __state.mark_failure(__pos, "[{}]") - }; - __state.suppress_fail -= 1; - match __assert_res { - Failed => Matched(__pos, ()), - Matched(..) => Failed, - } - }; - match __seq_res { - Matched(__pos, _) => { - any_char(__input, __state, __pos) - } - Failed => Failed, - } - }; - match __step_res { - Matched(__newpos, __value) => { - __repeat_pos = __newpos; - } - Failed => { - break; - } - } - } - Matched(__repeat_pos, ()) - }; - match __seq_res { - Matched(__pos, _) => { - if __input.len() > __pos { - let (__ch, __next) = char_range_at(__input, __pos); - match __ch { - '}' => Matched(__next, ()), - _ => __state.mark_failure(__pos, "[}]"), - } - } else { - __state.mark_failure(__pos, "[}]") - } - } - Failed => Failed, - } - } - Failed => Failed, - } - } { - Matched(__newpos, _) => { - Matched(__newpos, &__input[str_start..__newpos]) - } - Failed => Failed, - } - }; - match __seq_res { - Matched(__pos, n) => Matched(__pos, { Some(n) }), - Failed => Failed, +impl Type { + /// Returns trait name of this [`Type`]. + pub(crate) fn trait_name(&self) -> &'static str { + match self { + Self::Display => "Display", + Self::Debug | Self::LowerDebug | Self::UpperDebug => "Debug", + Self::Octal => "Octal", + Self::LowerHex => "LowerHex", + Self::UpperHex => "UpperHex", + Self::Pointer => "Pointer", + Self::Binary => "Binary", + Self::LowerExp => "LowerExp", + Self::UpperExp => "UpperExp", } } } -fn __parse_discard_any<'input>( - __input: &'input str, - __state: &mut ParseState<'input>, - __pos: usize, -) -> RuleResult> { - #![allow(non_snake_case, unused)] - { - let __seq_res = any_char(__input, __state, __pos); - match __seq_res { - Matched(__pos, _) => Matched(__pos, { None }), - Failed => Failed, - } - } +/// Type alias for [`FormatSpec::width`]. +type Width<'a> = Count<'a>; + +/// Output of the [`maybe_format`] parser. +type MaybeFormat<'a> = Option>; + +/// Output of the [`identifier`] parser. +type Identifier<'a> = &'a str; + +/// Output of the [`parameter`] parser. +type Parameter<'a> = Argument<'a>; + +/// [`str`](prim@str) left to parse. +type LeftToParse<'a> = &'a str; + +/// Parses an `format_string` as defined in the [grammar spec][1]. +/// +/// # Grammar +/// +/// [`format_string`]` := `[`text`]` [`[`maybe_format text`]`] *` +/// +/// # Example +/// +/// ```text +/// Hello +/// Hello, {}! +/// {:?} +/// Hello {people}! +/// {} {} +/// {:04} +/// {par:-^#.0$?} +/// ``` +/// +/// # Return value +/// +/// - [`Some`] in case of successful parse. +/// - [`None`] otherwise (not all characters are consumed by underlying +/// parsers). +/// +/// [1]: https://doc.rust-lang.org/stable/std/fmt/index.html#syntax +pub(crate) fn format_string(input: &str) -> Option> { + let (mut input, _) = optional_result(text)(input); + + let formats = iter::repeat(()) + .scan(&mut input, |input, _| { + let (curr, format) = + alt([&mut maybe_format, &mut map(text, |(i, _)| (i, None))])(input)?; + **input = curr; + Some(format) + }) + .flatten() + .collect(); + + // Should consume all tokens for a successful parse. + input.is_empty().then(|| FormatString { formats }) } -fn __parse_arg<'input>( - __input: &'input str, - __state: &mut ParseState<'input>, - __pos: usize, -) -> RuleResult { - #![allow(non_snake_case, unused)] - { - let __seq_res = { - let str_start = __pos; - match { - let mut __repeat_pos = __pos; - let mut __repeat_value = vec![]; - loop { - let __pos = __repeat_pos; - let __step_res = if __input.len() > __pos { - let (__ch, __next) = char_range_at(__input, __pos); - match __ch { - '0'...'9' => Matched(__next, ()), - _ => __state.mark_failure(__pos, "[0-9]"), - } - } else { - __state.mark_failure(__pos, "[0-9]") - }; - match __step_res { - Matched(__newpos, __value) => { - __repeat_pos = __newpos; - __repeat_value.push(__value); - } - Failed => { - break; - } - } - } - if __repeat_value.len() >= 1 { - Matched(__repeat_pos, ()) - } else { - Failed - } - } { - Matched(__newpos, _) => { - Matched(__newpos, &__input[str_start..__newpos]) - } - Failed => Failed, - } - }; - match __seq_res { - Matched(__pos, n) => Matched(__pos, { n.parse().unwrap() }), - Failed => Failed, - } +/// Parses an `maybe_format` as defined in the [grammar spec][1]. +/// +/// # Grammar +/// +/// [`maybe_format`]` := '{' '{' | '}' '}' | `[`format`] +/// +/// # Example +/// +/// ```text +/// {{ +/// }} +/// {:04} +/// {:#?} +/// {par:-^#.0$?} +/// ``` +/// +/// [1]: https://doc.rust-lang.org/stable/std/fmt/index.html#syntax +fn maybe_format(input: &str) -> Option<(LeftToParse<'_>, MaybeFormat<'_>)> { + alt([ + &mut map(str("{{"), |i| (i, None)), + &mut map(str("}}"), |i| (i, None)), + &mut map(format, |(i, format)| (i, Some(format))), + ])(input) +} + +/// Parses an `format` as defined in the [grammar spec][1]. +/// +/// # Grammar +/// +/// [`format`]` := '{' [`[`argument`]`] [':' `[`format_spec`]`] '}'` +/// +/// # Example +/// +/// ```text +/// {par} +/// {:#?} +/// {par:-^#.0$?} +/// ``` +/// +/// [1]: https://doc.rust-lang.org/stable/std/fmt/index.html#syntax +fn format(input: &str) -> Option<(LeftToParse<'_>, Format<'_>)> { + let input = char('{')(input)?; + + let (input, arg) = optional_result(argument)(input); + + let (input, spec) = map_or_else( + char(':'), + |i| Some((i, None)), + map(format_spec, |(i, s)| (i, Some(s))), + )(input)?; + + let input = char('}')(input)?; + + Some((input, Format { arg, spec })) +} + +/// Parses an `argument` as defined in the [grammar spec][1]. +/// +/// # Grammar +/// +/// [`argument`]` := `[`integer`]` | `[`identifier`] +/// +/// # Example +/// +/// ```text +/// 0 +/// ident +/// Минск +/// ``` +/// +/// [1]: https://doc.rust-lang.org/stable/std/fmt/index.html#syntax +fn argument(input: &str) -> Option<(LeftToParse<'_>, Argument)> { + alt([ + &mut map(identifier, |(i, ident)| (i, Argument::Identifier(ident))), + &mut map(integer, |(i, int)| (i, Argument::Integer(int))), + ])(input) +} + +/// Parses an `format_spec` as defined in the [grammar spec][1]. +/// +/// # Grammar +/// +/// [`format_spec`]` := [[fill]align][sign]['#']['0'][`[`width`]`]` +/// `['.' `[`precision`]`]`[`type`] +/// +/// # Example +/// +/// ```text +/// ^ +/// <^ +/// ->+#0width$.precision$x? +/// ``` +/// +/// [`type`]: type_ +/// [1]: https://doc.rust-lang.org/stable/std/fmt/index.html#syntax +fn format_spec(input: &str) -> Option<(LeftToParse<'_>, FormatSpec<'_>)> { + let input = unwrap_or_else( + alt([ + &mut try_seq([&mut any_char, &mut one_of("<^>")]), + &mut one_of("<^>"), + ]), + identity, + )(input); + + let input = seq([ + &mut optional(one_of("+-")), + &mut optional(char('#')), + &mut optional(try_seq([ + &mut char('0'), + &mut lookahead(check_char(|c| !matches!(c, '0'..='9' | '$'))), + ])), + ])(input); + + let (input, width) = optional_result(count)(input); + + let (input, precision) = map_or_else( + char('.'), + |i| Some((i, None)), + map(precision, |(i, p)| (i, Some(p))), + )(input)?; + + let (input, ty) = type_(input)?; + + Some(( + input, + FormatSpec { + width, + precision, + ty, + }, + )) +} + +/// Parses an `precision` as defined in the [grammar spec][1]. +/// +/// # Grammar +/// +/// [`precision`]` := `[`count`]` | '*'` +/// +/// # Example +/// +/// ```text +/// 0 +/// 42$ +/// par$ +/// * +/// ``` +/// +/// [1]: https://doc.rust-lang.org/stable/std/fmt/index.html#syntax +fn precision(input: &str) -> Option<(LeftToParse<'_>, Precision<'_>)> { + alt([ + &mut map(count, |(i, c)| (i, Precision::Count(c))), + &mut map(char('*'), |i| (i, Precision::Star)), + ])(input) +} + +/// Parses an `type` as defined in the [grammar spec][1]. +/// +/// # Grammar +/// +/// [`type`]` := '' | '?' | 'x?' | 'X?' | identifier` +/// +/// # Example +/// +/// All possible [`Type`]s. +/// +/// ```text +/// ? +/// x? +/// X? +/// o +/// x +/// X +/// p +/// b +/// e +/// E +/// ``` +/// +/// [`type`]: type_ +/// [1]: https://doc.rust-lang.org/stable/std/fmt/index.html#syntax +fn type_(input: &str) -> Option<(&str, Type)> { + alt([ + &mut map(str("x?"), |i| (i, Type::LowerDebug)), + &mut map(str("X?"), |i| (i, Type::UpperDebug)), + &mut map(char('?'), |i| (i, Type::Debug)), + &mut map(char('o'), |i| (i, Type::Octal)), + &mut map(char('x'), |i| (i, Type::LowerHex)), + &mut map(char('X'), |i| (i, Type::UpperHex)), + &mut map(char('p'), |i| (i, Type::Pointer)), + &mut map(char('b'), |i| (i, Type::Binary)), + &mut map(char('e'), |i| (i, Type::LowerExp)), + &mut map(char('E'), |i| (i, Type::UpperExp)), + &mut map(lookahead(char('}')), |i| (i, Type::Display)), + ])(input) +} + +/// Parses an `count` as defined in the [grammar spec][1]. +/// +/// # Grammar +/// +/// [`count`]` := `[`parameter`]` | `[`integer`] +/// +/// # Example +/// +/// ```text +/// 0 +/// 42$ +/// par$ +/// ``` +/// +/// [1]: https://doc.rust-lang.org/stable/std/fmt/index.html#syntax +fn count(input: &str) -> Option<(LeftToParse<'_>, Count<'_>)> { + alt([ + &mut map(parameter, |(i, p)| (i, Count::Parameter(p))), + &mut map(integer, |(i, int)| (i, Count::Integer(int))), + ])(input) +} + +/// Parses an `parameter` as defined in the [grammar spec][1]. +/// +/// # Grammar +/// +/// [`parameter`]` := `[`argument`]` '$'` +/// +/// # Example +/// +/// ```text +/// 42$ +/// par$ +/// ``` +/// +/// [1]: https://doc.rust-lang.org/stable/std/fmt/index.html#syntax +fn parameter(input: &str) -> Option<(LeftToParse<'_>, Parameter<'_>)> { + and_then(argument, |(i, arg)| map(char('$'), |i| (i, arg))(i))(input) +} + +/// Parses an `identifier` as defined in the [grammar spec][1]. +/// +/// # Grammar +/// +/// `IDENTIFIER_OR_KEYWORD : XID_Start XID_Continue* | _ XID_Continue+` +/// +/// See [rust reference][2] for more info. +/// +/// # Example +/// +/// ```text +/// identifier +/// Минск +/// ``` +/// +/// [1]: https://doc.rust-lang.org/stable/std/fmt/index.html#syntax +/// [2]: https://doc.rust-lang.org/reference/identifiers.html +fn identifier(input: &str) -> Option<(LeftToParse<'_>, Identifier<'_>)> { + map( + alt([ + &mut map( + check_char(XID::is_xid_start), + take_while0(check_char(XID::is_xid_continue)), + ), + &mut and_then(char('_'), take_while1(check_char(XID::is_xid_continue))), + ]), + |(i, _)| (i, &input[..(input.as_bytes().len() - i.as_bytes().len())]), + )(input) +} + +/// Parses an `integer` as defined in the [grammar spec][1]. +/// +/// [1]: https://doc.rust-lang.org/stable/std/fmt/index.html#syntax +fn integer(input: &str) -> Option<(LeftToParse<'_>, usize)> { + and_then( + take_while1(check_char(|c| matches!(c, '0'..='9'))), + |(i, int)| int.parse().ok().map(|int| (i, int)), + )(input) +} + +/// Parses an `text` as defined in the [grammar spec][1]. +/// +/// [1]: https://doc.rust-lang.org/stable/std/fmt/index.html#syntax +fn text(input: &str) -> Option<(LeftToParse<'_>, &str)> { + take_until1(any_char, one_of("{}"))(input) +} + +/// Applies non-failing parsers in sequence. +fn seq( + mut parsers: [&mut dyn FnMut(&str) -> &str; N], +) -> impl FnMut(&str) -> LeftToParse<'_> + '_ { + move |input| parsers.iter_mut().fold(input, |i, p| (**p)(i)) +} + +/// Tries to apply parsers in sequence. Returns [`None`] in case one of them +/// returned [`None`]. +fn try_seq( + mut parsers: [&mut dyn FnMut(&str) -> Option<&str>; N], +) -> impl FnMut(&str) -> Option> + '_ { + move |input| parsers.iter_mut().try_fold(input, |i, p| (**p)(i)) +} + +/// Returns first successful parser or [`None`] in case all of them returned +/// [`None`]. +fn alt<'p, 'i, T: 'i, const N: usize>( + mut parsers: [&'p mut dyn FnMut(&'i str) -> Option; N], +) -> impl FnMut(&'i str) -> Option + 'p { + move |input| parsers.iter_mut().find_map(|p| (**p)(input)) +} + +/// Maps output of the parser in case it returned [`Some`]. +fn map<'i, I: 'i, O: 'i>( + mut parser: impl FnMut(&'i str) -> Option, + mut f: impl FnMut(I) -> O, +) -> impl FnMut(&'i str) -> Option { + move |input| parser(input).map(&mut f) +} + +/// Maps output of the parser in case it returned [`Some`] or uses `default`. +fn map_or_else<'i, I: 'i, O: 'i>( + mut parser: impl FnMut(&'i str) -> Option, + mut default: impl FnMut(&'i str) -> O, + mut f: impl FnMut(I) -> O, +) -> impl FnMut(&'i str) -> O { + move |input| parser(input).map_or_else(|| default(input), &mut f) +} + +/// Returns the contained [`Some`] value or computes it from a closure. +fn unwrap_or_else<'i, O: 'i>( + mut parser: impl FnMut(&'i str) -> Option, + mut f: impl FnMut(&'i str) -> O, +) -> impl FnMut(&'i str) -> O { + move |input| parser(input).unwrap_or_else(|| f(input)) +} + +/// Returns [`None`] if the parser returned is [`None`], otherwise calls `f` +/// with the wrapped value and returns the result. +fn and_then<'i, I: 'i, O: 'i>( + mut parser: impl FnMut(&'i str) -> Option, + mut f: impl FnMut(I) -> Option, +) -> impl FnMut(&'i str) -> Option { + move |input| parser(input).and_then(&mut f) +} + +/// Checks whether `parser` is successful while not advancing the original +/// `input`. +fn lookahead( + mut parser: impl FnMut(&str) -> Option<&str>, +) -> impl FnMut(&str) -> Option> { + move |input| map(&mut parser, |_| input)(input) +} + +/// Makes underlying `parser` optional by returning the original `input` in case +/// it returned [`None`]. +fn optional( + mut parser: impl FnMut(&str) -> Option<&str>, +) -> impl FnMut(&str) -> LeftToParse<'_> { + move |input: &str| parser(input).unwrap_or(input) +} + +/// Makes underlying `parser` optional by returning the original `input` and +/// [`None`] in case it returned [`None`]. +fn optional_result<'i, T: 'i>( + mut parser: impl FnMut(&'i str) -> Option<(&'i str, T)>, +) -> impl FnMut(&'i str) -> (LeftToParse<'i>, Option) { + move |input: &str| { + map_or_else(&mut parser, |i| (i, None), |(i, c)| (i, Some(c)))(input) } } -fn __parse_ty<'input>( - __input: &'input str, - __state: &mut ParseState<'input>, - __pos: usize, -) -> RuleResult<&'input str> { - #![allow(non_snake_case, unused)] - { - let __seq_res = { - let str_start = __pos; - match { - let __choice_res = { - let __choice_res = slice_eq(__input, __state, __pos, "x?"); - match __choice_res { - Matched(__pos, __value) => Matched(__pos, __value), - Failed => slice_eq(__input, __state, __pos, "X?"), - } - }; - match __choice_res { - Matched(__pos, __value) => Matched(__pos, __value), - Failed => { - let __choice_res = slice_eq(__input, __state, __pos, "o"); - match __choice_res { - Matched(__pos, __value) => Matched(__pos, __value), - Failed => { - let __choice_res = - slice_eq(__input, __state, __pos, "x"); - match __choice_res { - Matched(__pos, __value) => Matched(__pos, __value), - Failed => { - let __choice_res = - slice_eq(__input, __state, __pos, "X"); - match __choice_res { - Matched(__pos, __value) => { - Matched(__pos, __value) - } - Failed => { - let __choice_res = slice_eq( - __input, __state, __pos, "p", - ); - match __choice_res { - Matched(__pos, __value) => { - Matched(__pos, __value) - } - Failed => { - let __choice_res = slice_eq( - __input, __state, __pos, - "b", - ); - match __choice_res { - Matched(__pos, __value) => { - Matched(__pos, __value) - } - Failed => { - let __choice_res = - slice_eq( - __input, - __state, __pos, - "e", - ); - match __choice_res { - Matched( - __pos, - __value, - ) => Matched( - __pos, __value, - ), - Failed => { - let __choice_res = - slice_eq( - __input, - __state, - __pos, - "E", - ); - match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => slice_eq ( __input , __state , __pos , "?" ) } - } - } - } - } - } - } - } - } - } - } - } - } - } - } - } { - Matched(__newpos, _) => { - Matched(__newpos, &__input[str_start..__newpos]) - } - Failed => Failed, - } - }; - match __seq_res { - Matched(__pos, n) => Matched(__pos, { n }), - Failed => Failed, +/// Parses while `parser` is successful. Never fails. +fn take_while0( + mut parser: impl FnMut(&str) -> Option<&str>, +) -> impl FnMut(&str) -> (LeftToParse<'_>, &str) { + move |input| { + let mut cur = input; + while let Some(step) = parser(cur) { + cur = step; } + ( + cur, + &input[..(input.as_bytes().len() - cur.as_bytes().len())], + ) } } -fn __parse_format_spec<'input>( - __input: &'input str, - __state: &mut ParseState<'input>, - __pos: usize, -) -> RuleResult> { - #![allow(non_snake_case, unused)] - { - let __seq_res = slice_eq(__input, __state, __pos, ":"); - match __seq_res { - Matched(__pos, _) => { - let __seq_res = match { - let __seq_res = match { - let __seq_res = { - __state.suppress_fail += 1; - let __assert_res = if __input.len() > __pos { - let (__ch, __next) = char_range_at(__input, __pos); - match __ch { - '<' | '^' | '>' => Matched(__next, ()), - _ => __state.mark_failure(__pos, "[<^>]"), - } - } else { - __state.mark_failure(__pos, "[<^>]") - }; - __state.suppress_fail -= 1; - match __assert_res { - Failed => Matched(__pos, ()), - Matched(..) => Failed, - } - }; - match __seq_res { - Matched(__pos, _) => any_char(__input, __state, __pos), - Failed => Failed, - } - } { - Matched(__newpos, _) => Matched(__newpos, ()), - Failed => Matched(__pos, ()), - }; - match __seq_res { - Matched(__pos, _) => { - if __input.len() > __pos { - let (__ch, __next) = char_range_at(__input, __pos); - match __ch { - '<' | '^' | '>' => Matched(__next, ()), - _ => __state.mark_failure(__pos, "[<^>]"), - } - } else { - __state.mark_failure(__pos, "[<^>]") - } - } - Failed => Failed, - } - } { - Matched(__newpos, _) => Matched(__newpos, ()), - Failed => Matched(__pos, ()), - }; - match __seq_res { - Matched(__pos, _) => { - let __seq_res = match { - let __choice_res = slice_eq(__input, __state, __pos, "+"); - match __choice_res { - Matched(__pos, __value) => Matched(__pos, __value), - Failed => slice_eq(__input, __state, __pos, "-"), - } - } { - Matched(__newpos, _) => Matched(__newpos, ()), - Failed => Matched(__pos, ()), - }; - match __seq_res { - Matched(__pos, _) => { - let __seq_res = - match slice_eq(__input, __state, __pos, "#") { - Matched(__newpos, _) => Matched(__newpos, ()), - Failed => Matched(__pos, ()), - }; - match __seq_res { - Matched(__pos, _) => { - let __seq_res = match { - let __choice_res = { - let __seq_res = { - let mut __repeat_pos = __pos; - let mut __repeat_value = vec![]; - loop { - let __pos = __repeat_pos; - let __step_res = - if __input.len() > __pos { - let (__ch, __next) = - char_range_at( - __input, __pos, - ); - match __ch { - 'A'...'Z' - | 'a'...'z' - | '0'...'9' - | '_' => Matched( - __next, - (), - ), - _ => __state - .mark_failure( - __pos, - "[A-Za-z0-9_]", - ), - } - } else { - __state.mark_failure( - __pos, - "[A-Za-z0-9_]", - ) - }; - match __step_res { - Matched( - __newpos, - __value, - ) => { - __repeat_pos = __newpos; - __repeat_value - .push(__value); - } - Failed => { - break; - } - } - } - if __repeat_value.len() >= 1 { - Matched(__repeat_pos, ()) - } else { - Failed - } - }; - match __seq_res { - Matched(__pos, _) => slice_eq( - __input, __state, __pos, "$", - ), - Failed => Failed, - } - }; - match __choice_res { - Matched(__pos, __value) => { - Matched(__pos, __value) - } - Failed => { - let mut __repeat_pos = __pos; - let mut __repeat_value = vec![]; - loop { - let __pos = __repeat_pos; - let __step_res = if __input - .len() - > __pos - { - let (__ch, __next) = - char_range_at( - __input, __pos, - ); - match __ch { - '0'...'9' => { - Matched(__next, ()) - } - _ => __state - .mark_failure( - __pos, "[0-9]", - ), - } - } else { - __state.mark_failure( - __pos, "[0-9]", - ) - }; - match __step_res { - Matched( - __newpos, - __value, - ) => { - __repeat_pos = __newpos; - __repeat_value - .push(__value); - } - Failed => { - break; - } - } - } - if __repeat_value.len() >= 1 { - Matched(__repeat_pos, ()) - } else { - Failed - } - } - } - } { - Matched(__newpos, _) => { - Matched(__newpos, ()) - } - Failed => Matched(__pos, ()), - }; - match __seq_res { - Matched(__pos, _) => { - let __seq_res = match slice_eq( - __input, __state, __pos, "0", - ) { - Matched(__newpos, _) => { - Matched(__newpos, ()) - } - Failed => Matched(__pos, ()), - }; - match __seq_res { - Matched(__pos, _) => { - let __seq_res = match { - let __seq_res = slice_eq( - __input, __state, - __pos, ".", - ); - match __seq_res { - Matched(__pos, _) => { - let __choice_res = { - let __seq_res = { - let mut - __repeat_pos = - __pos; - let mut - __repeat_value = - vec![]; - loop { - let __pos = __repeat_pos ; - let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { 'A' ... 'Z' | 'a' ... 'z' | '0' ... '9' | '_' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[A-Za-z0-9_]" ) , } } else { __state . mark_failure ( __pos , "[A-Za-z0-9_]" ) } ; - match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } - } - if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } - }; - match __seq_res { Matched ( __pos , _ ) => { slice_eq ( __input , __state , __pos , "$" ) } Failed => Failed , } - }; - match __choice_res { - Matched( - __pos, - __value, - ) => Matched( - __pos, - __value, - ), - Failed => { - let __choice_res = { - let mut __repeat_pos = __pos ; - let mut - __repeat_value = vec![]; - loop { - let __pos = __repeat_pos ; - let __step_res = if __input . len ( ) > __pos { let ( __ch , __next ) = char_range_at ( __input , __pos ) ; match __ch { '0' ... '9' => Matched ( __next , ( ) ) , _ => __state . mark_failure ( __pos , "[0-9]" ) , } } else { __state . mark_failure ( __pos , "[0-9]" ) } ; - match __step_res { Matched ( __newpos , __value ) => { __repeat_pos = __newpos ; __repeat_value . push ( __value ) ; } , Failed => { break ; } } - } - if __repeat_value . len ( ) >= 1 { Matched ( __repeat_pos , ( ) ) } else { Failed } - }; - match __choice_res { Matched ( __pos , __value ) => Matched ( __pos , __value ) , Failed => slice_eq ( __input , __state , __pos , "*" ) } - } - } - } - Failed => Failed, - } - } { - Matched(__newpos, _) => { - Matched(__newpos, ()) - } - Failed => { - Matched(__pos, ()) - } - }; - match __seq_res { - Matched(__pos, _) => { - let __seq_res = - match __parse_ty( - __input, - __state, __pos, - ) { - Matched( - __newpos, - __value, - ) => Matched( - __newpos, - Some( - __value, - ), - ), - Failed => { - Matched( - __pos, - None, - ) - } - }; - match __seq_res { - Matched( - __pos, - n, - ) => Matched( - __pos, - { n }, - ), - Failed => Failed, - } - } - Failed => Failed, - } - } - Failed => Failed, - } - } - Failed => Failed, - } - } - Failed => Failed, - } - } - Failed => Failed, - } - } - Failed => Failed, - } - } - Failed => Failed, +/// Parses while `parser` is successful. Returns [`None`] in case `parser` never +/// succeeded. +fn take_while1( + mut parser: impl FnMut(&str) -> Option<&str>, +) -> impl FnMut(&str) -> Option<(LeftToParse<'_>, &str)> { + move |input| { + let mut cur = parser(input)?; + while let Some(step) = parser(cur) { + cur = step; } + Some(( + cur, + &input[..(input.as_bytes().len() - cur.as_bytes().len())], + )) } } -fn __parse_all_placeholders<'input>( - __input: &'input str, - __state: &mut ParseState<'input>, - __pos: usize, -) -> RuleResult> { - #![allow(non_snake_case, unused)] - { - let __seq_res = { - let mut __repeat_pos = __pos; - let mut __repeat_value = vec![]; - loop { - let __pos = __repeat_pos; - let __step_res = { - let __choice_res = __parse_discard_doubles(__input, __state, __pos); - match __choice_res { - Matched(__pos, __value) => Matched(__pos, __value), - Failed => { - let __choice_res = - __parse_placeholder_inner(__input, __state, __pos); - match __choice_res { - Matched(__pos, __value) => Matched(__pos, __value), - Failed => __parse_discard_any(__input, __state, __pos), - } - } - } - }; - match __step_res { - Matched(__newpos, __value) => { - __repeat_pos = __newpos; - __repeat_value.push(__value); - } - Failed => { - break; - } - } +/// Parses with `basic` while `until` returns [`None`]. Returns [`None`] in case +/// `until` succeeded initially or `basic` never succeeded. Doesn't consume +/// [`char`]s parsed by `until`. +fn take_until1( + mut basic: impl FnMut(&str) -> Option<&str>, + mut until: impl FnMut(&str) -> Option<&str>, +) -> impl FnMut(&str) -> Option<(LeftToParse<'_>, &str)> { + move |input: &str| { + if until(input).is_some() { + return None; + } + let mut cur = basic(input)?; + loop { + if until(cur).is_some() { + break; } - Matched(__repeat_pos, __repeat_value) - }; - match __seq_res { - Matched(__pos, x) => { - Matched(__pos, { x.into_iter().flat_map(|x| x).collect() }) + if let Some(b) = basic(cur) { + cur = b; + } else { + break; } - Failed => Failed, } + + Some(( + cur, + &input[..(input.as_bytes().len() - cur.as_bytes().len())], + )) } } -fn __parse_format<'input>( - __input: &'input str, - __state: &mut ParseState<'input>, - __pos: usize, -) -> RuleResult<(Option, Option<&'input str>)> { - #![allow(non_snake_case, unused)] - { - let __seq_res = slice_eq(__input, __state, __pos, "{"); - match __seq_res { - Matched(__pos, _) => { - let __seq_res = match __parse_arg(__input, __state, __pos) { - Matched(__newpos, __value) => Matched(__newpos, Some(__value)), - Failed => Matched(__pos, None), - }; - match __seq_res { - Matched(__pos, n) => { - let __seq_res = - match __parse_format_spec(__input, __state, __pos) { - Matched(__newpos, __value) => { - Matched(__newpos, Some(__value)) - } - Failed => Matched(__pos, None), - }; - match __seq_res { - Matched(__pos, o) => { - let __seq_res = slice_eq(__input, __state, __pos, "}"); - match __seq_res { - Matched(__pos, _) => { - Matched(__pos, { (n, o.and_then(|x| x)) }) - } - Failed => Failed, - } - } - Failed => Failed, - } - } - Failed => Failed, - } - } - Failed => Failed, - } +/// Checks whether `input` starts with `s`. +fn str(s: &str) -> impl FnMut(&str) -> Option> + '_ { + move |input| input.starts_with(s).then(|| &input[s.as_bytes().len()..]) +} + +/// Checks whether `input` starts with `c`. +fn char(c: char) -> impl FnMut(&str) -> Option> { + move |input| input.starts_with(c).then(|| &input[c.len_utf8()..]) +} + +/// Checks whether first [`char`] suits `check`. +fn check_char( + mut check: impl FnMut(char) -> bool, +) -> impl FnMut(&str) -> Option> { + move |input| { + input + .chars() + .next() + .and_then(|c| check(c).then(|| &input[c.len_utf8()..])) } } -pub fn all_placeholders<'input>(__input: &'input str) -> ParseResult> { - #![allow(non_snake_case, unused)] - let mut __state = ParseState::new(); - match __parse_all_placeholders(__input, &mut __state, 0) { - Matched(__pos, __value) => { - if __pos == __input.len() { - return Ok(__value); - } - } - _ => {} +/// Checks whether first [`char`] of input is present in `chars`. +fn one_of(chars: &str) -> impl FnMut(&str) -> Option> + '_ { + move |input: &str| chars.chars().find_map(|c| char(c)(input)) +} + +/// Parses any [`char`]. +fn any_char(input: &str) -> Option> { + input.chars().next().map(|c| &input[c.len_utf8()..]) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn text() { + assert_eq!(format_string(""), Some(FormatString { formats: vec![] })); + assert_eq!( + format_string("test"), + Some(FormatString { formats: vec![] }), + ); + assert_eq!( + format_string("Минск"), + Some(FormatString { formats: vec![] }), + ); + assert_eq!(format_string("🦀"), Some(FormatString { formats: vec![] })); } - let (__line, __col) = pos_to_line(__input, __state.max_err_pos); - Err(ParseError { - line: __line, - column: __col, - offset: __state.max_err_pos, - expected: __state.expected, - }) -} - -pub fn format<'input>( - __input: &'input str, -) -> ParseResult<(Option, Option<&'input str>)> { - #![allow(non_snake_case, unused)] - let mut __state = ParseState::new(); - match __parse_format(__input, &mut __state, 0) { - Matched(__pos, __value) => { - if __pos == __input.len() { - return Ok(__value); - } - } - _ => {} + + #[test] + fn argument() { + assert_eq!( + format_string("{}"), + Some(FormatString { + formats: vec![Format { + arg: None, + spec: None, + }], + }), + ); + assert_eq!( + format_string("{0}"), + Some(FormatString { + formats: vec![Format { + arg: Some(Argument::Integer(0)), + spec: None + }] + }) + ); + assert_eq!( + format_string("{par}"), + Some(FormatString { + formats: vec![Format { + arg: Some(Argument::Identifier("par")), + spec: None + }] + }) + ); + assert_eq!( + format_string("{Минск}"), + Some(FormatString { + formats: vec![Format { + arg: Some(Argument::Identifier("Минск")), + spec: None + }] + }) + ); + } + + #[test] + fn spec() { + assert_eq!( + format_string("{:}"), + Some(FormatString { + formats: vec![Format { + arg: None, + spec: Some(FormatSpec { + width: None, + precision: None, + ty: Type::Display + }) + }] + }) + ); + assert_eq!( + format_string("{:^}"), + Some(FormatString { + formats: vec![Format { + arg: None, + spec: Some(FormatSpec { + width: None, + precision: None, + ty: Type::Display + }) + }] + }) + ); + assert_eq!( + format_string("{:-<}"), + Some(FormatString { + formats: vec![Format { + arg: None, + spec: Some(FormatSpec { + width: None, + precision: None, + ty: Type::Display + }) + }] + }) + ); + assert_eq!( + format_string("{: <}"), + Some(FormatString { + formats: vec![Format { + arg: None, + spec: Some(FormatSpec { + width: None, + precision: None, + ty: Type::Display + }) + }] + }) + ); + assert_eq!( + format_string("{:^<}"), + Some(FormatString { + formats: vec![Format { + arg: None, + spec: Some(FormatSpec { + width: None, + precision: None, + ty: Type::Display + }) + }] + }) + ); + assert_eq!( + format_string("{:+}"), + Some(FormatString { + formats: vec![Format { + arg: None, + spec: Some(FormatSpec { + width: None, + precision: None, + ty: Type::Display + }) + }] + }) + ); + assert_eq!( + format_string("{:^<-}"), + Some(FormatString { + formats: vec![Format { + arg: None, + spec: Some(FormatSpec { + width: None, + precision: None, + ty: Type::Display + }) + }] + }) + ); + assert_eq!( + format_string("{:#}"), + Some(FormatString { + formats: vec![Format { + arg: None, + spec: Some(FormatSpec { + width: None, + precision: None, + ty: Type::Display + }) + }] + }) + ); + assert_eq!( + format_string("{:+#}"), + Some(FormatString { + formats: vec![Format { + arg: None, + spec: Some(FormatSpec { + width: None, + precision: None, + ty: Type::Display + }) + }] + }) + ); + assert_eq!( + format_string("{:-<#}"), + Some(FormatString { + formats: vec![Format { + arg: None, + spec: Some(FormatSpec { + width: None, + precision: None, + ty: Type::Display + }) + }] + }) + ); + assert_eq!( + format_string("{:^<-#}"), + Some(FormatString { + formats: vec![Format { + arg: None, + spec: Some(FormatSpec { + width: None, + precision: None, + ty: Type::Display + }) + }] + }) + ); + assert_eq!( + format_string("{:0}"), + Some(FormatString { + formats: vec![Format { + arg: None, + spec: Some(FormatSpec { + width: None, + precision: None, + ty: Type::Display + }) + }] + }) + ); + assert_eq!( + format_string("{:#0}"), + Some(FormatString { + formats: vec![Format { + arg: None, + spec: Some(FormatSpec { + width: None, + precision: None, + ty: Type::Display + }) + }] + }) + ); + assert_eq!( + format_string("{:-0}"), + Some(FormatString { + formats: vec![Format { + arg: None, + spec: Some(FormatSpec { + width: None, + precision: None, + ty: Type::Display + }) + }] + }) + ); + assert_eq!( + format_string("{:^<0}"), + Some(FormatString { + formats: vec![Format { + arg: None, + spec: Some(FormatSpec { + width: None, + precision: None, + ty: Type::Display + }) + }] + }) + ); + assert_eq!( + format_string("{:^<+#0}"), + Some(FormatString { + formats: vec![Format { + arg: None, + spec: Some(FormatSpec { + width: None, + precision: None, + ty: Type::Display + }) + }] + }) + ); + assert_eq!( + format_string("{:1}"), + Some(FormatString { + formats: vec![Format { + arg: None, + spec: Some(FormatSpec { + width: Some(Width::Integer(1)), + precision: None, + ty: Type::Display + }) + }] + }) + ); + assert_eq!( + format_string("{:1$}"), + Some(FormatString { + formats: vec![Format { + arg: None, + spec: Some(FormatSpec { + width: Some(Width::Parameter(Argument::Integer(1))), + precision: None, + ty: Type::Display + }) + }] + }) + ); + assert_eq!( + format_string("{:par$}"), + Some(FormatString { + formats: vec![Format { + arg: None, + spec: Some(FormatSpec { + width: Some(Width::Parameter(Argument::Identifier("par"))), + precision: None, + ty: Type::Display + }) + }] + }) + ); + assert_eq!( + format_string("{:-^-#0Минск$}"), + Some(FormatString { + formats: vec![Format { + arg: None, + spec: Some(FormatSpec { + width: Some(Width::Parameter(Argument::Identifier("Минск"))), + precision: None, + ty: Type::Display + }) + }] + }) + ); + assert_eq!( + format_string("{:.*}"), + Some(FormatString { + formats: vec![Format { + arg: None, + spec: Some(FormatSpec { + width: None, + precision: Some(Precision::Star), + ty: Type::Display + }) + }] + }) + ); + assert_eq!( + format_string("{:.0}"), + Some(FormatString { + formats: vec![Format { + arg: None, + spec: Some(FormatSpec { + width: None, + precision: Some(Precision::Count(Count::Integer(0))), + ty: Type::Display + }) + }] + }) + ); + assert_eq!( + format_string("{:.0$}"), + Some(FormatString { + formats: vec![Format { + arg: None, + spec: Some(FormatSpec { + width: None, + precision: Some(Precision::Count(Count::Parameter( + Argument::Integer(0) + ))), + ty: Type::Display + }) + }] + }) + ); + assert_eq!( + format_string("{:.par$}"), + Some(FormatString { + formats: vec![Format { + arg: None, + spec: Some(FormatSpec { + width: None, + precision: Some(Precision::Count(Count::Parameter( + Argument::Identifier("par") + ))), + ty: Type::Display + }) + }] + }) + ); + assert_eq!( + format_string("{: >+#2$.par$}"), + Some(FormatString { + formats: vec![Format { + arg: None, + spec: Some(FormatSpec { + width: Some(Width::Parameter(Argument::Integer(2))), + precision: Some(Precision::Count(Count::Parameter( + Argument::Identifier("par") + ))), + ty: Type::Display + }) + }] + }) + ); + assert_eq!( + format_string("{:x?}"), + Some(FormatString { + formats: vec![Format { + arg: None, + spec: Some(FormatSpec { + width: None, + precision: None, + ty: Type::LowerDebug + }) + }] + }) + ); + assert_eq!( + format_string("{:E}"), + Some(FormatString { + formats: vec![Format { + arg: None, + spec: Some(FormatSpec { + width: None, + precision: None, + ty: Type::UpperExp + }) + }] + }) + ); + assert_eq!( + format_string("{: >+#par$.par$X?}"), + Some(FormatString { + formats: vec![Format { + arg: None, + spec: Some(FormatSpec { + width: Some(Width::Parameter(Argument::Identifier("par"))), + precision: Some(Precision::Count(Count::Parameter( + Argument::Identifier("par") + ))), + ty: Type::UpperDebug + }) + }] + }) + ); + } + + #[test] + fn full() { + assert_eq!( + format_string("prefix{{{0:#?}postfix{par:-^par$.a$}}}"), + Some(FormatString { + formats: vec![ + Format { + arg: Some(Argument::Integer(0)), + spec: Some(FormatSpec { + width: None, + precision: None, + ty: Type::Debug, + }) + }, + Format { + arg: Some(Argument::Identifier("par")), + spec: Some(FormatSpec { + width: Some(Width::Parameter(Argument::Identifier("par"))), + precision: Some(Precision::Count(Count::Parameter( + Argument::Identifier("a") + ))), + ty: Type::Display + }) + } + ] + }) + ) + } + + #[test] + fn error() { + assert_eq!(format_string("{"), None); + assert_eq!(format_string("}"), None); + assert_eq!(format_string("{{}"), None); + assert_eq!(format_string("{:x?"), None); + assert_eq!(format_string("{:.}"), None); + assert_eq!(format_string("{:q}"), None); + assert_eq!(format_string("{:par}"), None); + assert_eq!(format_string("{⚙️}"), None); } - let (__line, __col) = pos_to_line(__input, __state.max_err_pos); - Err(ParseError { - line: __line, - column: __col, - offset: __state.max_err_pos, - expected: __state.expected, - }) } diff --git a/src/parsing.rustpeg b/src/parsing.rustpeg deleted file mode 100644 index 6ba5b6ed..00000000 --- a/src/parsing.rustpeg +++ /dev/null @@ -1,37 +0,0 @@ -discard_doubles -> Option<&'input str> - = ("{" "{" / "}" "}") { None } - -placeholder_inner -> Option<&'input str> - = n:($([{] (![{}].)* [}])) { Some(n) } - -discard_any -> Option<&'input str> - = . { None } - -arg -> usize - = n:$([0-9]+) { n.parse().unwrap() } - -ty -> &'input str - = n:$(("x?" / "X?") / ("o" / "x" / "X" / "p" / "b" / "e" / "E" / "?")) { n } - -format_spec -> Option<&'input str> - = ":" ((![<^>] .)? [<^>])? ("+" / "-")? "#"? (( [A-Za-z0-9_]+ "$") / [0-9]+)? "0"? ("." (([A-Za-z0-9_]+ "$") / [0-9]+ / "*"))? n:ty? { n } - -/// PEG for parsing formatting placeholders from a string. -/// -/// Reproduces `maybe-format` expression of [formatting syntax][1]. -/// -/// [1]: https://doc.rust-lang.org/stable/std/fmt/index.html#syntax -pub all_placeholders -> Vec<&'input str> - = x:(discard_doubles / placeholder_inner / discard_any)* { x.into_iter().flat_map(|x| x).collect() } - -/// PEG for parsing inner type of formatting placeholder. -/// -/// Reproduces `format` expression of [formatting syntax][1], but is simplified -/// in the following way (as we need to parse `type` only): -/// - `argument` is replaced just with `\d+` (instead of [`identifier`][2]); -/// - `character` is allowed to be any symbol. -/// -/// [1]: https://doc.rust-lang.org/stable/std/fmt/index.html#syntax -/// [2]: https://doc.rust-lang.org/reference/identifiers.html#identifiers -pub format -> (Option, Option<&'input str>) - = "{" n:arg? o:format_spec? "}" { (n, o.and_then(|x| x)) } \ No newline at end of file From c0ac03b2a1368b905f9bee502d8f9cd000ad631c Mon Sep 17 00:00:00 2001 From: ilslv Date: Wed, 19 Jan 2022 11:05:37 +0300 Subject: [PATCH 02/14] Fix for 1.36 --- Cargo.lock | 71 ---------------------------- src/parsing.rs | 122 +++++++++++++++++++++++++++++++------------------ 2 files changed, 77 insertions(+), 116 deletions(-) delete mode 100644 Cargo.lock diff --git a/Cargo.lock b/Cargo.lock deleted file mode 100644 index e1698074..00000000 --- a/Cargo.lock +++ /dev/null @@ -1,71 +0,0 @@ -# This file is automatically @generated by Cargo. -# It is not intended for manual editing. -version = 3 - -[[package]] -name = "convert_case" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6245d59a3e82a7fc217c5828a6692dbc6dfb63a0c8c90495621f7b9d79704a0e" - -[[package]] -name = "derive_more" -version = "0.99.17" -dependencies = [ - "convert_case", - "proc-macro2", - "quote", - "rustc_version", - "syn", - "unicode-xid", -] - -[[package]] -name = "proc-macro2" -version = "1.0.32" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ba508cc11742c0dc5c1659771673afbab7a0efab23aa17e854cbab0837ed0b43" -dependencies = [ - "unicode-xid", -] - -[[package]] -name = "quote" -version = "1.0.10" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "38bc8cc6a5f2e3655e0899c1b848643b2562f853f114bfec7be120678e3ace05" -dependencies = [ - "proc-macro2", -] - -[[package]] -name = "rustc_version" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366" -dependencies = [ - "semver", -] - -[[package]] -name = "semver" -version = "1.0.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "568a8e6258aa33c13358f81fd834adb854c6f7c9468520910a9b1e8fac068012" - -[[package]] -name = "syn" -version = "1.0.81" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f2afee18b8beb5a596ecb4a2dce128c719b4ba399d34126b9e4396e3f9860966" -dependencies = [ - "proc-macro2", - "quote", - "unicode-xid", -] - -[[package]] -name = "unicode-xid" -version = "0.2.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3" diff --git a/src/parsing.rs b/src/parsing.rs index 6744915a..37cf1f86 100644 --- a/src/parsing.rs +++ b/src/parsing.rs @@ -66,15 +66,15 @@ impl Type { /// Returns trait name of this [`Type`]. pub(crate) fn trait_name(&self) -> &'static str { match self { - Self::Display => "Display", - Self::Debug | Self::LowerDebug | Self::UpperDebug => "Debug", - Self::Octal => "Octal", - Self::LowerHex => "LowerHex", - Self::UpperHex => "UpperHex", - Self::Pointer => "Pointer", - Self::Binary => "Binary", - Self::LowerExp => "LowerExp", - Self::UpperExp => "UpperExp", + Type::Display => "Display", + Type::Debug | Type::LowerDebug | Type::UpperDebug => "Debug", + Type::Octal => "Octal", + Type::LowerHex => "LowerHex", + Type::UpperHex => "UpperHex", + Type::Pointer => "Pointer", + Type::Binary => "Binary", + Type::LowerExp => "LowerExp", + Type::UpperExp => "UpperExp", } } } @@ -125,7 +125,9 @@ pub(crate) fn format_string(input: &str) -> Option> { let formats = iter::repeat(()) .scan(&mut input, |input, _| { let (curr, format) = - alt([&mut maybe_format, &mut map(text, |(i, _)| (i, None))])(input)?; + alt(&mut [&mut maybe_format, &mut map(text, |(i, _)| (i, None))])( + input, + )?; **input = curr; Some(format) }) @@ -133,7 +135,11 @@ pub(crate) fn format_string(input: &str) -> Option> { .collect(); // Should consume all tokens for a successful parse. - input.is_empty().then(|| FormatString { formats }) + if input.is_empty() { + Some(FormatString { formats }) + } else { + None + } } /// Parses an `maybe_format` as defined in the [grammar spec][1]. @@ -154,7 +160,7 @@ pub(crate) fn format_string(input: &str) -> Option> { /// /// [1]: https://doc.rust-lang.org/stable/std/fmt/index.html#syntax fn maybe_format(input: &str) -> Option<(LeftToParse<'_>, MaybeFormat<'_>)> { - alt([ + alt(&mut [ &mut map(str("{{"), |i| (i, None)), &mut map(str("}}"), |i| (i, None)), &mut map(format, |(i, format)| (i, Some(format))), @@ -208,7 +214,7 @@ fn format(input: &str) -> Option<(LeftToParse<'_>, Format<'_>)> { /// /// [1]: https://doc.rust-lang.org/stable/std/fmt/index.html#syntax fn argument(input: &str) -> Option<(LeftToParse<'_>, Argument)> { - alt([ + alt(&mut [ &mut map(identifier, |(i, ident)| (i, Argument::Identifier(ident))), &mut map(integer, |(i, int)| (i, Argument::Integer(int))), ])(input) @@ -233,19 +239,22 @@ fn argument(input: &str) -> Option<(LeftToParse<'_>, Argument)> { /// [1]: https://doc.rust-lang.org/stable/std/fmt/index.html#syntax fn format_spec(input: &str) -> Option<(LeftToParse<'_>, FormatSpec<'_>)> { let input = unwrap_or_else( - alt([ - &mut try_seq([&mut any_char, &mut one_of("<^>")]), + alt(&mut [ + &mut try_seq(&mut [&mut any_char, &mut one_of("<^>")]), &mut one_of("<^>"), ]), identity, )(input); - let input = seq([ + let input = seq(&mut [ &mut optional(one_of("+-")), &mut optional(char('#')), - &mut optional(try_seq([ + &mut optional(try_seq(&mut [ &mut char('0'), - &mut lookahead(check_char(|c| !matches!(c, '0'..='9' | '$'))), + &mut lookahead(check_char(|c| match c { + '0'..='9' | '$' => false, + _ => true, + })), ])), ])(input); @@ -286,7 +295,7 @@ fn format_spec(input: &str) -> Option<(LeftToParse<'_>, FormatSpec<'_>)> { /// /// [1]: https://doc.rust-lang.org/stable/std/fmt/index.html#syntax fn precision(input: &str) -> Option<(LeftToParse<'_>, Precision<'_>)> { - alt([ + alt(&mut [ &mut map(count, |(i, c)| (i, Precision::Count(c))), &mut map(char('*'), |i| (i, Precision::Star)), ])(input) @@ -318,7 +327,7 @@ fn precision(input: &str) -> Option<(LeftToParse<'_>, Precision<'_>)> { /// [`type`]: type_ /// [1]: https://doc.rust-lang.org/stable/std/fmt/index.html#syntax fn type_(input: &str) -> Option<(&str, Type)> { - alt([ + alt(&mut [ &mut map(str("x?"), |i| (i, Type::LowerDebug)), &mut map(str("X?"), |i| (i, Type::UpperDebug)), &mut map(char('?'), |i| (i, Type::Debug)), @@ -349,7 +358,7 @@ fn type_(input: &str) -> Option<(&str, Type)> { /// /// [1]: https://doc.rust-lang.org/stable/std/fmt/index.html#syntax fn count(input: &str) -> Option<(LeftToParse<'_>, Count<'_>)> { - alt([ + alt(&mut [ &mut map(parameter, |(i, p)| (i, Count::Parameter(p))), &mut map(integer, |(i, int)| (i, Count::Integer(int))), ])(input) @@ -392,7 +401,7 @@ fn parameter(input: &str) -> Option<(LeftToParse<'_>, Parameter<'_>)> { /// [2]: https://doc.rust-lang.org/reference/identifiers.html fn identifier(input: &str) -> Option<(LeftToParse<'_>, Identifier<'_>)> { map( - alt([ + alt(&mut [ &mut map( check_char(XID::is_xid_start), take_while0(check_char(XID::is_xid_continue)), @@ -408,7 +417,10 @@ fn identifier(input: &str) -> Option<(LeftToParse<'_>, Identifier<'_>)> { /// [1]: https://doc.rust-lang.org/stable/std/fmt/index.html#syntax fn integer(input: &str) -> Option<(LeftToParse<'_>, usize)> { and_then( - take_while1(check_char(|c| matches!(c, '0'..='9'))), + take_while1(check_char(|c| match c { + '0'..='9' => true, + _ => false, + })), |(i, int)| int.parse().ok().map(|int| (i, int)), )(input) } @@ -421,24 +433,24 @@ fn text(input: &str) -> Option<(LeftToParse<'_>, &str)> { } /// Applies non-failing parsers in sequence. -fn seq( - mut parsers: [&mut dyn FnMut(&str) -> &str; N], -) -> impl FnMut(&str) -> LeftToParse<'_> + '_ { +fn seq<'p>( + parsers: &'p mut [&'p mut dyn FnMut(&str) -> &str], +) -> impl FnMut(&str) -> LeftToParse<'_> + 'p { move |input| parsers.iter_mut().fold(input, |i, p| (**p)(i)) } /// Tries to apply parsers in sequence. Returns [`None`] in case one of them /// returned [`None`]. -fn try_seq( - mut parsers: [&mut dyn FnMut(&str) -> Option<&str>; N], -) -> impl FnMut(&str) -> Option> + '_ { +fn try_seq<'p>( + parsers: &'p mut [&'p mut dyn FnMut(&str) -> Option<&str>], +) -> impl FnMut(&str) -> Option> + 'p { move |input| parsers.iter_mut().try_fold(input, |i, p| (**p)(i)) } /// Returns first successful parser or [`None`] in case all of them returned /// [`None`]. -fn alt<'p, 'i, T: 'i, const N: usize>( - mut parsers: [&'p mut dyn FnMut(&'i str) -> Option; N], +fn alt<'p, 'i, T: 'i>( + parsers: &'p mut [&'p mut dyn FnMut(&'i str) -> Option], ) -> impl FnMut(&'i str) -> Option + 'p { move |input| parsers.iter_mut().find_map(|p| (**p)(input)) } @@ -568,12 +580,24 @@ fn take_until1( /// Checks whether `input` starts with `s`. fn str(s: &str) -> impl FnMut(&str) -> Option> + '_ { - move |input| input.starts_with(s).then(|| &input[s.as_bytes().len()..]) + move |input| { + if input.starts_with(s) { + Some(&input[s.as_bytes().len()..]) + } else { + None + } + } } /// Checks whether `input` starts with `c`. fn char(c: char) -> impl FnMut(&str) -> Option> { - move |input| input.starts_with(c).then(|| &input[c.len_utf8()..]) + move |input| { + if input.starts_with(c) { + Some(&input[c.len_utf8()..]) + } else { + None + } + } } /// Checks whether first [`char`] suits `check`. @@ -581,10 +605,13 @@ fn check_char( mut check: impl FnMut(char) -> bool, ) -> impl FnMut(&str) -> Option> { move |input| { - input - .chars() - .next() - .and_then(|c| check(c).then(|| &input[c.len_utf8()..])) + input.chars().next().and_then(|c| { + if check(c) { + Some(&input[c.len_utf8()..]) + } else { + None + } + }) } } @@ -613,7 +640,10 @@ mod tests { format_string("Минск"), Some(FormatString { formats: vec![] }), ); - assert_eq!(format_string("🦀"), Some(FormatString { formats: vec![] })); + assert_eq!( + format_string("🦀"), + Some(FormatString { formats: vec![] }) + ); } #[test] @@ -872,7 +902,7 @@ mod tests { formats: vec![Format { arg: None, spec: Some(FormatSpec { - width: Some(Width::Integer(1)), + width: Some(Count::Integer(1)), precision: None, ty: Type::Display }) @@ -885,7 +915,7 @@ mod tests { formats: vec![Format { arg: None, spec: Some(FormatSpec { - width: Some(Width::Parameter(Argument::Integer(1))), + width: Some(Count::Parameter(Argument::Integer(1))), precision: None, ty: Type::Display }) @@ -898,7 +928,7 @@ mod tests { formats: vec![Format { arg: None, spec: Some(FormatSpec { - width: Some(Width::Parameter(Argument::Identifier("par"))), + width: Some(Count::Parameter(Argument::Identifier("par"))), precision: None, ty: Type::Display }) @@ -911,7 +941,9 @@ mod tests { formats: vec![Format { arg: None, spec: Some(FormatSpec { - width: Some(Width::Parameter(Argument::Identifier("Минск"))), + width: Some(Count::Parameter(Argument::Identifier( + "Минск" + ))), precision: None, ty: Type::Display }) @@ -980,7 +1012,7 @@ mod tests { formats: vec![Format { arg: None, spec: Some(FormatSpec { - width: Some(Width::Parameter(Argument::Integer(2))), + width: Some(Count::Parameter(Argument::Integer(2))), precision: Some(Precision::Count(Count::Parameter( Argument::Identifier("par") ))), @@ -1021,7 +1053,7 @@ mod tests { formats: vec![Format { arg: None, spec: Some(FormatSpec { - width: Some(Width::Parameter(Argument::Identifier("par"))), + width: Some(Count::Parameter(Argument::Identifier("par"))), precision: Some(Precision::Count(Count::Parameter( Argument::Identifier("par") ))), @@ -1049,7 +1081,7 @@ mod tests { Format { arg: Some(Argument::Identifier("par")), spec: Some(FormatSpec { - width: Some(Width::Parameter(Argument::Identifier("par"))), + width: Some(Count::Parameter(Argument::Identifier("par"))), precision: Some(Precision::Count(Count::Parameter( Argument::Identifier("a") ))), From 9cdb6d86b3afe2e77f1b82a2d185ddf8f9b41b35 Mon Sep 17 00:00:00 2001 From: ilslv Date: Wed, 19 Jan 2022 11:08:27 +0300 Subject: [PATCH 03/14] Return Cargo.lock and fmt --- .idea/derive_more_fork.iml | 13 +++++++ .idea/modules.xml | 8 +++++ .idea/vcs.xml | 6 ++++ Cargo.lock | 71 ++++++++++++++++++++++++++++++++++++++ src/parsing.rs | 9 ++--- 5 files changed, 100 insertions(+), 7 deletions(-) create mode 100644 .idea/derive_more_fork.iml create mode 100644 .idea/modules.xml create mode 100644 .idea/vcs.xml create mode 100644 Cargo.lock diff --git a/.idea/derive_more_fork.iml b/.idea/derive_more_fork.iml new file mode 100644 index 00000000..a6b108e4 --- /dev/null +++ b/.idea/derive_more_fork.iml @@ -0,0 +1,13 @@ + + + + + + + + + + + + + \ No newline at end of file diff --git a/.idea/modules.xml b/.idea/modules.xml new file mode 100644 index 00000000..6c23e66e --- /dev/null +++ b/.idea/modules.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/.idea/vcs.xml b/.idea/vcs.xml new file mode 100644 index 00000000..94a25f7f --- /dev/null +++ b/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/Cargo.lock b/Cargo.lock new file mode 100644 index 00000000..0ad225fa --- /dev/null +++ b/Cargo.lock @@ -0,0 +1,71 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "convert_case" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6245d59a3e82a7fc217c5828a6692dbc6dfb63a0c8c90495621f7b9d79704a0e" + +[[package]] +name = "derive_more" +version = "0.99.17" +dependencies = [ + "convert_case", + "proc-macro2", + "quote", + "rustc_version", + "syn", + "unicode-xid", +] + +[[package]] +name = "proc-macro2" +version = "1.0.36" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c7342d5883fbccae1cc37a2353b09c87c9b0f3afd73f5fb9bba687a1f733b029" +dependencies = [ + "unicode-xid", +] + +[[package]] +name = "quote" +version = "1.0.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "47aa80447ce4daf1717500037052af176af5d38cc3e571d9ec1c7353fc10c87d" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "rustc_version" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366" +dependencies = [ + "semver", +] + +[[package]] +name = "semver" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "568a8e6258aa33c13358f81fd834adb854c6f7c9468520910a9b1e8fac068012" + +[[package]] +name = "syn" +version = "1.0.85" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a684ac3dcd8913827e18cd09a68384ee66c1de24157e3c556c9ab16d85695fb7" +dependencies = [ + "proc-macro2", + "quote", + "unicode-xid", +] + +[[package]] +name = "unicode-xid" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3" diff --git a/src/parsing.rs b/src/parsing.rs index 37cf1f86..8184f6c2 100644 --- a/src/parsing.rs +++ b/src/parsing.rs @@ -640,10 +640,7 @@ mod tests { format_string("Минск"), Some(FormatString { formats: vec![] }), ); - assert_eq!( - format_string("🦀"), - Some(FormatString { formats: vec![] }) - ); + assert_eq!(format_string("🦀"), Some(FormatString { formats: vec![] })); } #[test] @@ -941,9 +938,7 @@ mod tests { formats: vec![Format { arg: None, spec: Some(FormatSpec { - width: Some(Count::Parameter(Argument::Identifier( - "Минск" - ))), + width: Some(Count::Parameter(Argument::Identifier("Минск"))), precision: None, ty: Type::Display }) From e0bd159a5330bd81aa7fbb0451e38e66c17eb4b8 Mon Sep 17 00:00:00 2001 From: ilslv Date: Wed, 19 Jan 2022 11:11:03 +0300 Subject: [PATCH 04/14] Revert "Return Cargo.lock and fmt" This reverts commit 9cdb6d86b3afe2e77f1b82a2d185ddf8f9b41b35. --- .idea/derive_more_fork.iml | 13 ------- .idea/modules.xml | 8 ----- .idea/vcs.xml | 6 ---- Cargo.lock | 71 -------------------------------------- src/parsing.rs | 9 +++-- 5 files changed, 7 insertions(+), 100 deletions(-) delete mode 100644 .idea/derive_more_fork.iml delete mode 100644 .idea/modules.xml delete mode 100644 .idea/vcs.xml delete mode 100644 Cargo.lock diff --git a/.idea/derive_more_fork.iml b/.idea/derive_more_fork.iml deleted file mode 100644 index a6b108e4..00000000 --- a/.idea/derive_more_fork.iml +++ /dev/null @@ -1,13 +0,0 @@ - - - - - - - - - - - - - \ No newline at end of file diff --git a/.idea/modules.xml b/.idea/modules.xml deleted file mode 100644 index 6c23e66e..00000000 --- a/.idea/modules.xml +++ /dev/null @@ -1,8 +0,0 @@ - - - - - - - - \ No newline at end of file diff --git a/.idea/vcs.xml b/.idea/vcs.xml deleted file mode 100644 index 94a25f7f..00000000 --- a/.idea/vcs.xml +++ /dev/null @@ -1,6 +0,0 @@ - - - - - - \ No newline at end of file diff --git a/Cargo.lock b/Cargo.lock deleted file mode 100644 index 0ad225fa..00000000 --- a/Cargo.lock +++ /dev/null @@ -1,71 +0,0 @@ -# This file is automatically @generated by Cargo. -# It is not intended for manual editing. -version = 3 - -[[package]] -name = "convert_case" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6245d59a3e82a7fc217c5828a6692dbc6dfb63a0c8c90495621f7b9d79704a0e" - -[[package]] -name = "derive_more" -version = "0.99.17" -dependencies = [ - "convert_case", - "proc-macro2", - "quote", - "rustc_version", - "syn", - "unicode-xid", -] - -[[package]] -name = "proc-macro2" -version = "1.0.36" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c7342d5883fbccae1cc37a2353b09c87c9b0f3afd73f5fb9bba687a1f733b029" -dependencies = [ - "unicode-xid", -] - -[[package]] -name = "quote" -version = "1.0.14" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "47aa80447ce4daf1717500037052af176af5d38cc3e571d9ec1c7353fc10c87d" -dependencies = [ - "proc-macro2", -] - -[[package]] -name = "rustc_version" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366" -dependencies = [ - "semver", -] - -[[package]] -name = "semver" -version = "1.0.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "568a8e6258aa33c13358f81fd834adb854c6f7c9468520910a9b1e8fac068012" - -[[package]] -name = "syn" -version = "1.0.85" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a684ac3dcd8913827e18cd09a68384ee66c1de24157e3c556c9ab16d85695fb7" -dependencies = [ - "proc-macro2", - "quote", - "unicode-xid", -] - -[[package]] -name = "unicode-xid" -version = "0.2.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3" diff --git a/src/parsing.rs b/src/parsing.rs index 8184f6c2..37cf1f86 100644 --- a/src/parsing.rs +++ b/src/parsing.rs @@ -640,7 +640,10 @@ mod tests { format_string("Минск"), Some(FormatString { formats: vec![] }), ); - assert_eq!(format_string("🦀"), Some(FormatString { formats: vec![] })); + assert_eq!( + format_string("🦀"), + Some(FormatString { formats: vec![] }) + ); } #[test] @@ -938,7 +941,9 @@ mod tests { formats: vec![Format { arg: None, spec: Some(FormatSpec { - width: Some(Count::Parameter(Argument::Identifier("Минск"))), + width: Some(Count::Parameter(Argument::Identifier( + "Минск" + ))), precision: None, ty: Type::Display }) From 9bdbe1120cdd21e3d0e416fdc6be707961421524 Mon Sep 17 00:00:00 2001 From: ilslv Date: Wed, 19 Jan 2022 11:13:19 +0300 Subject: [PATCH 05/14] Fix --- Cargo.lock | 71 ++++++++++++++++++++++++++++++++++++++++++++++++++ src/parsing.rs | 9 ++----- 2 files changed, 73 insertions(+), 7 deletions(-) create mode 100644 Cargo.lock diff --git a/Cargo.lock b/Cargo.lock new file mode 100644 index 00000000..0ad225fa --- /dev/null +++ b/Cargo.lock @@ -0,0 +1,71 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "convert_case" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6245d59a3e82a7fc217c5828a6692dbc6dfb63a0c8c90495621f7b9d79704a0e" + +[[package]] +name = "derive_more" +version = "0.99.17" +dependencies = [ + "convert_case", + "proc-macro2", + "quote", + "rustc_version", + "syn", + "unicode-xid", +] + +[[package]] +name = "proc-macro2" +version = "1.0.36" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c7342d5883fbccae1cc37a2353b09c87c9b0f3afd73f5fb9bba687a1f733b029" +dependencies = [ + "unicode-xid", +] + +[[package]] +name = "quote" +version = "1.0.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "47aa80447ce4daf1717500037052af176af5d38cc3e571d9ec1c7353fc10c87d" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "rustc_version" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366" +dependencies = [ + "semver", +] + +[[package]] +name = "semver" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "568a8e6258aa33c13358f81fd834adb854c6f7c9468520910a9b1e8fac068012" + +[[package]] +name = "syn" +version = "1.0.85" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a684ac3dcd8913827e18cd09a68384ee66c1de24157e3c556c9ab16d85695fb7" +dependencies = [ + "proc-macro2", + "quote", + "unicode-xid", +] + +[[package]] +name = "unicode-xid" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3" diff --git a/src/parsing.rs b/src/parsing.rs index 37cf1f86..8184f6c2 100644 --- a/src/parsing.rs +++ b/src/parsing.rs @@ -640,10 +640,7 @@ mod tests { format_string("Минск"), Some(FormatString { formats: vec![] }), ); - assert_eq!( - format_string("🦀"), - Some(FormatString { formats: vec![] }) - ); + assert_eq!(format_string("🦀"), Some(FormatString { formats: vec![] })); } #[test] @@ -941,9 +938,7 @@ mod tests { formats: vec![Format { arg: None, spec: Some(FormatSpec { - width: Some(Count::Parameter(Argument::Identifier( - "Минск" - ))), + width: Some(Count::Parameter(Argument::Identifier("Минск"))), precision: None, ty: Type::Display }) From 1ae08e583516001c8e4b42ce7774fc84d15b2439 Mon Sep 17 00:00:00 2001 From: ilslv Date: Wed, 19 Jan 2022 15:05:35 +0300 Subject: [PATCH 06/14] Remove redundant check --- src/parsing.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/parsing.rs b/src/parsing.rs index 8184f6c2..41628469 100644 --- a/src/parsing.rs +++ b/src/parsing.rs @@ -252,7 +252,7 @@ fn format_spec(input: &str) -> Option<(LeftToParse<'_>, FormatSpec<'_>)> { &mut optional(try_seq(&mut [ &mut char('0'), &mut lookahead(check_char(|c| match c { - '0'..='9' | '$' => false, + '$' => false, _ => true, })), ])), From bc86fcab2e7e169b3b8c2d551d934a6ebc455670 Mon Sep 17 00:00:00 2001 From: ilslv Date: Wed, 19 Jan 2022 15:07:52 +0300 Subject: [PATCH 07/14] Remove redundant check --- src/parsing.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/parsing.rs b/src/parsing.rs index 8184f6c2..41628469 100644 --- a/src/parsing.rs +++ b/src/parsing.rs @@ -252,7 +252,7 @@ fn format_spec(input: &str) -> Option<(LeftToParse<'_>, FormatSpec<'_>)> { &mut optional(try_seq(&mut [ &mut char('0'), &mut lookahead(check_char(|c| match c { - '0'..='9' | '$' => false, + '$' => false, _ => true, })), ])), From 74149c4b291c2f76824cc83408c878028d7cb93e Mon Sep 17 00:00:00 2001 From: ilslv Date: Thu, 20 Jan 2022 11:12:09 +0300 Subject: [PATCH 08/14] Implement interpolated strings --- Cargo.lock | 51 ++++++++++-------- Cargo.toml | 3 ++ src/display.rs | 136 ++++++++++++++++++++++++++++++----------------- tests/display.rs | 126 ++++++++++++++++++++++++++++++++++++++++++- 4 files changed, 244 insertions(+), 72 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 0ad225fa..80cddc7e 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1,71 +1,78 @@ # This file is automatically @generated by Cargo. # It is not intended for manual editing. -version = 3 - [[package]] name = "convert_case" version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6245d59a3e82a7fc217c5828a6692dbc6dfb63a0c8c90495621f7b9d79704a0e" [[package]] name = "derive_more" version = "0.99.17" dependencies = [ - "convert_case", - "proc-macro2", - "quote", - "rustc_version", - "syn", - "unicode-xid", + "convert_case 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)", + "proc-macro2 1.0.36 (registry+https://github.com/rust-lang/crates.io-index)", + "quote 1.0.14 (registry+https://github.com/rust-lang/crates.io-index)", + "rustc_version 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)", + "rustversion 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)", + "syn 1.0.86 (registry+https://github.com/rust-lang/crates.io-index)", + "unicode-xid 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "proc-macro2" version = "1.0.36" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c7342d5883fbccae1cc37a2353b09c87c9b0f3afd73f5fb9bba687a1f733b029" dependencies = [ - "unicode-xid", + "unicode-xid 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "quote" version = "1.0.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "47aa80447ce4daf1717500037052af176af5d38cc3e571d9ec1c7353fc10c87d" dependencies = [ - "proc-macro2", + "proc-macro2 1.0.36 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "rustc_version" version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366" dependencies = [ - "semver", + "semver 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)", ] +[[package]] +name = "rustversion" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" + [[package]] name = "semver" version = "1.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "568a8e6258aa33c13358f81fd834adb854c6f7c9468520910a9b1e8fac068012" [[package]] name = "syn" -version = "1.0.85" +version = "1.0.86" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a684ac3dcd8913827e18cd09a68384ee66c1de24157e3c556c9ab16d85695fb7" dependencies = [ - "proc-macro2", - "quote", - "unicode-xid", + "proc-macro2 1.0.36 (registry+https://github.com/rust-lang/crates.io-index)", + "quote 1.0.14 (registry+https://github.com/rust-lang/crates.io-index)", + "unicode-xid 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)", ] [[package]] name = "unicode-xid" version = "0.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3" + +[metadata] +"checksum convert_case 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "6245d59a3e82a7fc217c5828a6692dbc6dfb63a0c8c90495621f7b9d79704a0e" +"checksum proc-macro2 1.0.36 (registry+https://github.com/rust-lang/crates.io-index)" = "c7342d5883fbccae1cc37a2353b09c87c9b0f3afd73f5fb9bba687a1f733b029" +"checksum quote 1.0.14 (registry+https://github.com/rust-lang/crates.io-index)" = "47aa80447ce4daf1717500037052af176af5d38cc3e571d9ec1c7353fc10c87d" +"checksum rustc_version 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366" +"checksum rustversion 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)" = "f2cc38e8fa666e2de3c4aba7edeb5ffc5246c1c2ed0e3d17e560aeeba736b23f" +"checksum semver 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "568a8e6258aa33c13358f81fd834adb854c6f7c9468520910a9b1e8fac068012" +"checksum syn 1.0.86 (registry+https://github.com/rust-lang/crates.io-index)" = "8a65b3f4ffa0092e9887669db0eae07941f023991ab58ea44da8fe8e2d511c6b" +"checksum unicode-xid 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3" diff --git a/Cargo.toml b/Cargo.toml index 138d0991..e991b2b2 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -33,6 +33,9 @@ syn = "1.0.3" convert_case = { version = "0.4", optional = true} unicode-xid = { version = "0.2.2", optional = true } +[dev-dependencies] +rustversion = "1.0.6" + [build-dependencies] rustc_version = { version = "0.4", optional = true } diff --git a/src/display.rs b/src/display.rs index c3eb76aa..10906d0d 100644 --- a/src/display.rs +++ b/src/display.rs @@ -359,6 +359,7 @@ impl<'a, 'b> State<'a, 'b> { == "fmt" => { let expected_affix_usage = "outer `enum` `fmt` is an affix spec that expects no args and at most 1 placeholder for inner variant display"; + let placeholders = Placeholder::parse_fmt_string(&fmt.value()); if outer_enum { if list.nested.iter().skip(1).count() != 0 { return Err(Error::new( @@ -367,35 +368,18 @@ impl<'a, 'b> State<'a, 'b> { )); } // TODO: Check for a single `Display` group? - let fmt_string = match &list.nested[0] { - syn::NestedMeta::Meta(syn::Meta::NameValue( - syn::MetaNameValue { - path, - lit: syn::Lit::Str(s), - .. - }, - )) if path - .segments + if placeholders.len() > 1 + || placeholders .first() - .expect("path shouldn't be empty") - .ident - == "fmt" => - { - s.value() - } - // This one has been checked already in get_meta_fmt() method. - _ => unreachable!(), - }; - - let num_placeholders = - Placeholder::parse_fmt_string(&fmt_string).len(); - if num_placeholders > 1 { + .map(|p| p.arg != Argument::Integer(0)) + .unwrap_or_default() + { return Err(Error::new( list.nested[1].span(), expected_affix_usage, )); } - if num_placeholders == 1 { + if placeholders.len() == 1 { return Ok((quote_spanned!(fmt.span()=> #fmt), true)); } } @@ -421,8 +405,26 @@ impl<'a, 'b> State<'a, 'b> { Ok(quote_spanned!(list.span()=> #args #arg,)) })?; + let interpolated_args = placeholders + .into_iter() + .flat_map(|p| { + let map_argument = |arg| match arg { + Argument::Ident(i) => { + let ident = syn::Ident::new(&i, Span::call_site()); + Some(quote! { #ident = #ident, }) + } + Argument::Integer(_) => None, + }; + + map_argument(p.arg) + .into_iter() + .chain(p.width.and_then(map_argument)) + .chain(p.precision.and_then(map_argument)) + }) + .collect::(); + Ok(( - quote_spanned!(meta.span()=> write!(_derive_more_display_formatter, #fmt, #args)), + quote_spanned!(meta.span()=> write!(_derive_more_display_formatter, #fmt, #args #interpolated_args)), false, )) } @@ -665,9 +667,6 @@ impl<'a, 'b> State<'a, 'b> { _ => unreachable!(), }) .collect(); - if fmt_args.is_empty() { - return HashMap::default(); - } let fmt_string = match &list.nested[0] { syn::NestedMeta::Meta(syn::Meta::NameValue(syn::MetaNameValue { path, @@ -689,7 +688,14 @@ impl<'a, 'b> State<'a, 'b> { Placeholder::parse_fmt_string(&fmt_string).into_iter().fold( HashMap::default(), |mut bounds, pl| { - if let Some(arg) = fmt_args.get(&pl.position) { + let arg = match pl.arg { + Argument::Integer(i) => fmt_args.get(&i).cloned(), + Argument::Ident(i) => { + Some(syn::Ident::new(&i, Span::call_site()).into()) + } + }; + + if let Some(arg) = &arg { if fields_type_params.contains_key(arg) { bounds .entry(fields_type_params[arg].clone()) @@ -733,11 +739,28 @@ impl<'a, 'b> State<'a, 'b> { } } +#[derive(Debug, PartialEq)] +enum Argument { + Integer(usize), + Ident(String), +} + +impl<'a> From> for Argument { + fn from(arg: parsing::Argument<'a>) -> Self { + match arg { + parsing::Argument::Integer(i) => Argument::Integer(i), + parsing::Argument::Identifier(i) => Argument::Ident(i.to_owned()), + } + } +} + /// Representation of formatting placeholder. #[derive(Debug, PartialEq)] struct Placeholder { /// Position of formatting argument to be used for this placeholder. - position: usize, + arg: Argument, + width: Option, + precision: Option, /// Name of [`std::fmt`] trait to be used for rendering this placeholder. trait_name: &'static str, } @@ -754,20 +777,25 @@ impl Placeholder { format.arg, format.spec.map(|s| s.ty).unwrap_or(parsing::Type::Display), ); - let position = maybe_arg - .and_then(|arg| match arg { - parsing::Argument::Integer(i) => Some(i), - parsing::Argument::Identifier(_) => None, - }) - .unwrap_or_else(|| { - // Assign "the next argument". - // https://doc.rust-lang.org/stable/std/fmt/index.html#positional-parameters - n += 1; - n - 1 - }); + let position = maybe_arg.map(Into::into).unwrap_or_else(|| { + // Assign "the next argument". + // https://doc.rust-lang.org/stable/std/fmt/index.html#positional-parameters + n += 1; + Argument::Integer(n - 1) + }); Placeholder { - position, + arg: position, + width: format.spec.and_then(|s| match s.width { + Some(parsing::Count::Parameter(arg)) => Some(arg.into()), + _ => None, + }), + precision: format.spec.and_then(|s| match s.precision { + Some(parsing::Precision::Count(parsing::Count::Parameter( + arg, + ))) => Some(arg.into()), + _ => None, + }), trait_name: ty.trait_name(), } }) @@ -781,32 +809,44 @@ mod placeholder_parse_fmt_string_spec { #[test] fn indicates_position_and_trait_name_for_each_fmt_placeholder() { - let fmt_string = "{},{:?},{{}},{{{1:0$}}}-{2:.1$x}{0:#?}{:width$}"; + let fmt_string = "{},{:?},{{}},{{{1:0$}}}-{2:.1$x}{par:#?}{:width$}"; assert_eq!( Placeholder::parse_fmt_string(&fmt_string), vec![ Placeholder { - position: 0, + arg: Argument::Integer(0), + width: None, + precision: None, trait_name: "Display", }, Placeholder { - position: 1, + arg: Argument::Integer(1), + width: None, + precision: None, trait_name: "Debug", }, Placeholder { - position: 1, + arg: Argument::Integer(1), + width: Some(Argument::Integer(0)), + precision: None, trait_name: "Display", }, Placeholder { - position: 2, + arg: Argument::Integer(2), + width: None, + precision: Some(Argument::Integer(1)), trait_name: "LowerHex", }, Placeholder { - position: 0, + arg: Argument::Ident("par".to_owned()), + width: None, + precision: None, trait_name: "Debug", }, Placeholder { - position: 2, + arg: Argument::Integer(2), + width: Some(Argument::Ident("width".to_owned())), + precision: None, trait_name: "Display", }, ], diff --git a/tests/display.rs b/tests/display.rs index fae596b8..b906e531 100644 --- a/tests/display.rs +++ b/tests/display.rs @@ -41,7 +41,7 @@ impl PositiveOrNegative { } #[derive(Display)] -#[display(fmt = "{}", message)] +#[display(fmt = "{message}")] struct Error { message: &'static str, backtrace: (), @@ -109,7 +109,7 @@ struct Generic(T); #[display(fmt = "Here's a prefix for {} and a suffix")] enum Affix { A(u32), - #[display(fmt = "{} -- {}", wat, stuff)] + #[display(fmt = "{wat} -- {}", stuff)] B { wat: String, stuff: bool, @@ -171,6 +171,19 @@ mod generic { assert_eq!(NamedGenericStruct { field: 1 }.to_string(), "Generic 1"); } + #[derive(Display)] + #[display(fmt = "Generic {field}")] + struct InterpolatedNamedGenericStruct { + field: T, + } + #[test] + fn interpolated_named_generic_struct() { + assert_eq!( + InterpolatedNamedGenericStruct { field: 1 }.to_string(), + "Generic 1", + ); + } + #[derive(Display)] struct AutoNamedGenericStruct { field: T, @@ -188,6 +201,16 @@ mod generic { assert_eq!(UnnamedGenericStruct(2).to_string(), "Generic 2"); } + #[rustversion::since(1.41)] // https://github.com/rust-lang/rust/pull/66847 + #[derive(Display)] + #[display(fmt = "Generic {_0}")] + struct InterpolatedUnnamedGenericStruct(T); + #[rustversion::since(1.41)] // https://github.com/rust-lang/rust/pull/66847 + #[test] + fn interpolated_unnamed_generic_struct() { + assert_eq!(InterpolatedUnnamedGenericStruct(2).to_string(), "Generic 2"); + } + #[derive(Display)] struct AutoUnnamedGenericStruct(T); #[test] @@ -208,6 +231,27 @@ mod generic { assert_eq!(GenericEnum::B::(2).to_string(), "Gen::B 2"); } + #[rustversion::since(1.41)] // https://github.com/rust-lang/rust/pull/66847 + #[derive(Display)] + enum InterpolatedGenericEnum { + #[display(fmt = "Gen::A {field}")] + A { field: A }, + #[display(fmt = "Gen::B {_0}")] + B(B), + } + #[rustversion::since(1.41)] // https://github.com/rust-lang/rust/pull/66847 + #[test] + fn interpolated_generic_enum() { + assert_eq!( + InterpolatedGenericEnum::A::<_, u8> { field: 1 }.to_string(), + "Gen::A 1", + ); + assert_eq!( + InterpolatedGenericEnum::B::(2).to_string(), + "Gen::B 2", + ); + } + #[derive(Display)] enum AutoGenericEnum { A { field: A }, @@ -231,6 +275,18 @@ mod generic { assert_eq!(s.to_string(), "8 255 <-> 10 0xff <-> 8 FF"); } + #[derive(Display)] + #[display(fmt = "{} {b} <-> {0:o} {1:#x} <-> {0:?} {1:X?}", a, b)] + struct InterpolatedMultiTraitNamedGenericStruct { + a: A, + b: B, + } + #[test] + fn interpolated_multi_trait_named_generic_struct() { + let s = InterpolatedMultiTraitNamedGenericStruct { a: 8u8, b: 255 }; + assert_eq!(s.to_string(), "8 255 <-> 10 0xff <-> 8 FF"); + } + #[derive(Display)] #[display(fmt = "{} {} {{}} {0:o} {1:#x} - {0:>4?} {1:^4X?}", "_0", "_1")] struct MultiTraitUnnamedGenericStruct(A, B); @@ -240,6 +296,17 @@ mod generic { assert_eq!(s.to_string(), "8 255 {} 10 0xff - 8 FF "); } + #[rustversion::since(1.41)] // https://github.com/rust-lang/rust/pull/66847 + #[derive(Display)] + #[display(fmt = "{} {_1} {{}} {0:o} {1:#x} - {0:>4?} {1:^4X?}", "_0", "_1")] + struct InterpolatedMultiTraitUnnamedGenericStruct(A, B); + #[rustversion::since(1.41)] // https://github.com/rust-lang/rust/pull/66847 + #[test] + fn interpolated_multi_trait_unnamed_generic_struct() { + let s = InterpolatedMultiTraitUnnamedGenericStruct(8u8, 255); + assert_eq!(s.to_string(), "8 255 {} 10 0xff - 8 FF "); + } + #[derive(Display)] #[display(fmt = "{}", "3 * 4")] struct UnusedGenericStruct(T); @@ -384,6 +451,17 @@ mod generic { assert_eq!(s.to_string(), "10 20"); } + #[rustversion::since(1.41)] // https://github.com/rust-lang/rust/pull/66847 + #[test] + fn underscored_simple() { + #[derive(Display)] + #[display(fmt = "{_0} {_1}")] + struct Struct(T1, T2); + + let s = Struct(10, 20); + assert_eq!(s.to_string(), "10 20"); + } + #[test] fn redundant() { #[derive(Display)] @@ -395,6 +473,18 @@ mod generic { assert_eq!(s.to_string(), "10 20"); } + #[rustversion::since(1.41)] // https://github.com/rust-lang/rust/pull/66847 + #[test] + fn underscored_redundant() { + #[derive(Display)] + #[display(bound = "T1: ::core::fmt::Display, T2: ::core::fmt::Display")] + #[display(fmt = "{_0} {_1}")] + struct Struct(T1, T2); + + let s = Struct(10, 20); + assert_eq!(s.to_string(), "10 20"); + } + #[test] fn complex() { trait Trait1 { @@ -425,5 +515,37 @@ mod generic { let s = Struct(10, 20); assert_eq!(s.to_string(), "WHAT 10 EVER 20"); } + + #[rustversion::since(1.41)] // https://github.com/rust-lang/rust/pull/66847 + #[test] + fn underscored_complex() { + trait Trait1 { + fn function1(&self) -> &'static str; + } + + trait Trait2 { + fn function2(&self) -> &'static str; + } + + impl Trait1 for i32 { + fn function1(&self) -> &'static str { + "WHAT" + } + } + + impl Trait2 for i32 { + fn function2(&self) -> &'static str { + "EVER" + } + } + + #[derive(Display)] + #[display(bound = "T1: Trait1 + Trait2, T2: Trait1 + Trait2")] + #[display(fmt = "{} {_0} {} {_1}", "_0.function1()", "_1.function2()")] + struct Struct(T1, T2); + + let s = Struct(10, 20); + assert_eq!(s.to_string(), "WHAT 10 EVER 20"); + } } } From 80194d5c17ff16560b9c9600af02b9fe45536330 Mon Sep 17 00:00:00 2001 From: ilslv Date: Thu, 20 Jan 2022 11:16:04 +0300 Subject: [PATCH 09/14] Add width and precision tests --- tests/display.rs | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/tests/display.rs b/tests/display.rs index b906e531..0fd4bca2 100644 --- a/tests/display.rs +++ b/tests/display.rs @@ -184,6 +184,26 @@ mod generic { ); } + #[derive(Display)] + #[display(fmt = "Generic {field:<>width$.prec$}")] + struct InterpolatedNamedGenericStructWidthPrecision { + field: T, + width: usize, + prec: usize, + } + #[test] + fn interpolated_named_generic_struct_width_precision() { + assert_eq!( + InterpolatedNamedGenericStructWidthPrecision { + field: 1.2345, + width: 9, + prec: 2, + } + .to_string(), + "Generic <<<<<1.23", + ); + } + #[derive(Display)] struct AutoNamedGenericStruct { field: T, From 91ff4442186a4b47d41071fee1b71de80bfdbf19 Mon Sep 17 00:00:00 2001 From: ilslv Date: Thu, 20 Jan 2022 11:34:07 +0300 Subject: [PATCH 10/14] Document --- doc/display.md | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/doc/display.md b/doc/display.md index eab878aa..ba311df6 100644 --- a/doc/display.md +++ b/doc/display.md @@ -28,6 +28,10 @@ The variables available in the arguments is `self` and each member of the varian with members of tuple structs being named with a leading underscore and their index, i.e. `_0`, `_1`, `_2`, etc. +Although [captured identifiers in format strings are supported only since `1.58`](https://blog.rust-lang.org/2022/01/13/Rust-1.58.0.html#captured-identifiers-in-format-strings) we support this feature on earlier version of Rust. This means that `#[display(fmt = "Prefix: {field}")]` is completely valid on MSRV. + +> __NOTE:__ Underscored named parameters like `#[display(fmt = "Prefix: {_0}")]` [are supported since `1.41`](https://github.com/rust-lang/rust/pull/66847) + ## Other formatting traits The syntax does not change, but the name of the attribute is the snake case version of the trait. @@ -110,11 +114,11 @@ use std::path::PathBuf; struct MyInt(i32); #[derive(DebugCustom)] -#[debug(fmt = "MyIntDbg(as hex: {:x}, as dec: {})", _0, _0)] +#[debug(fmt = "MyIntDbg(as hex: {_0:x}, as dec: {_0})")] struct MyIntDbg(i32); #[derive(Display)] -#[display(fmt = "({}, {})", x, y)] +#[display(fmt = "({x}, {y})")] struct Point2D { x: i32, y: i32, From 73c870a8fb6c7cc58e215fcc6a253ee6e68aac4e Mon Sep 17 00:00:00 2001 From: ilslv Date: Thu, 20 Jan 2022 11:50:10 +0300 Subject: [PATCH 11/14] Fix duplicated fields --- src/display.rs | 12 +++++++----- tests/display.rs | 4 ++-- 2 files changed, 9 insertions(+), 7 deletions(-) diff --git a/src/display.rs b/src/display.rs index 10906d0d..2d8e86a1 100644 --- a/src/display.rs +++ b/src/display.rs @@ -409,18 +409,20 @@ impl<'a, 'b> State<'a, 'b> { .into_iter() .flat_map(|p| { let map_argument = |arg| match arg { - Argument::Ident(i) => { - let ident = syn::Ident::new(&i, Span::call_site()); - Some(quote! { #ident = #ident, }) - } + Argument::Ident(i) => Some(i), Argument::Integer(_) => None, }; - map_argument(p.arg) .into_iter() .chain(p.width.and_then(map_argument)) .chain(p.precision.and_then(map_argument)) }) + .collect::>() + .into_iter() + .map(|ident| { + let ident = syn::Ident::new(&ident, Span::call_site()); + quote! { #ident = #ident, } + }) .collect::(); Ok(( diff --git a/tests/display.rs b/tests/display.rs index 0fd4bca2..e778afc8 100644 --- a/tests/display.rs +++ b/tests/display.rs @@ -185,7 +185,7 @@ mod generic { } #[derive(Display)] - #[display(fmt = "Generic {field:<>width$.prec$}")] + #[display(fmt = "Generic {field:<>width$.prec$} {field}")] struct InterpolatedNamedGenericStructWidthPrecision { field: T, width: usize, @@ -200,7 +200,7 @@ mod generic { prec: 2, } .to_string(), - "Generic <<<<<1.23", + "Generic <<<<<1.23 1.2345", ); } From 9ce2b69f42e93ae0bdf4ca6d4a8c70022ffa38d5 Mon Sep 17 00:00:00 2001 From: ilslv Date: Tue, 8 Feb 2022 15:55:50 +0300 Subject: [PATCH 12/14] Corrections --- Cargo.lock | 7 +++++++ src/display.rs | 32 +++++++++++++++++++++++++------- 2 files changed, 32 insertions(+), 7 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 0ad225fa..ad4c4a18 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -16,6 +16,7 @@ dependencies = [ "proc-macro2", "quote", "rustc_version", + "rustversion", "syn", "unicode-xid", ] @@ -47,6 +48,12 @@ dependencies = [ "semver", ] +[[package]] +name = "rustversion" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2cc38e8fa666e2de3c4aba7edeb5ffc5246c1c2ed0e3d17e560aeeba736b23f" + [[package]] name = "semver" version = "1.0.4" diff --git a/src/display.rs b/src/display.rs index d5f52e93..e332cfcc 100644 --- a/src/display.rs +++ b/src/display.rs @@ -349,6 +349,7 @@ impl<'a, 'b> State<'a, 'b> { } }; + // TODO: Check for a single `Display` group? match &list.nested[0] { syn::NestedMeta::Meta(syn::Meta::NameValue(syn::MetaNameValue { path, @@ -367,7 +368,6 @@ impl<'a, 'b> State<'a, 'b> { expected_affix_usage, )); } - // TODO: Check for a single `Display` group? if placeholders.len() > 1 || placeholders .first() @@ -420,7 +420,7 @@ impl<'a, 'b> State<'a, 'b> { .collect::>() .into_iter() .map(|ident| { - let ident = syn::Ident::new(&ident, Span::call_site()); + let ident = syn::Ident::new(&ident, fmt.span()); quote! { #ident = #ident, } }) .collect::(); @@ -669,7 +669,10 @@ impl<'a, 'b> State<'a, 'b> { _ => unreachable!(), }) .collect(); - let fmt_string = match &list.nested[0] { + if fmt_args.is_empty() { + return HashMap::default(); + } + let (fmt_string, fmt_span) = match &list.nested[0] { syn::NestedMeta::Meta(syn::Meta::NameValue(syn::MetaNameValue { path, lit: syn::Lit::Str(s), @@ -681,7 +684,7 @@ impl<'a, 'b> State<'a, 'b> { .ident == "fmt" => { - s.value() + (s.value(), s.span()) } // This one has been checked already in get_meta_fmt() method. _ => unreachable!(), @@ -692,9 +695,7 @@ impl<'a, 'b> State<'a, 'b> { |mut bounds, pl| { let arg = match pl.arg { Argument::Integer(i) => fmt_args.get(&i).cloned(), - Argument::Ident(i) => { - Some(syn::Ident::new(&i, Span::call_site()).into()) - } + Argument::Ident(i) => Some(syn::Ident::new(&i, fmt_span).into()), }; if let Some(arg) = &arg { @@ -741,9 +742,17 @@ impl<'a, 'b> State<'a, 'b> { } } +/// [`Placeholder`] argument. #[derive(Debug, PartialEq)] enum Argument { + /// [Positional parameter][1]. + /// + /// [1]: https://doc.rust-lang.org/stable/std/fmt/index.html#positional-parameters Integer(usize), + + /// [Named parameter][1]. + /// + /// [1]: https://doc.rust-lang.org/stable/std/fmt/index.html#named-parameters Ident(String), } @@ -761,8 +770,17 @@ impl<'a> From> for Argument { struct Placeholder { /// Position of formatting argument to be used for this placeholder. arg: Argument, + + /// [Width argument][1], if present. + /// + /// [1]: https://doc.rust-lang.org/stable/std/fmt/index.html#width width: Option, + + /// [Precision argument][1], if present. + /// + /// [1]: https://doc.rust-lang.org/stable/std/fmt/index.html#precision precision: Option, + /// Name of [`std::fmt`] trait to be used for rendering this placeholder. trait_name: &'static str, } From 3bb76fd75c0042893bbb02159457958bf13740ce Mon Sep 17 00:00:00 2001 From: ilslv Date: Tue, 8 Feb 2022 16:00:38 +0300 Subject: [PATCH 13/14] Remove early return --- src/display.rs | 3 --- 1 file changed, 3 deletions(-) diff --git a/src/display.rs b/src/display.rs index e332cfcc..ceb3dac2 100644 --- a/src/display.rs +++ b/src/display.rs @@ -669,9 +669,6 @@ impl<'a, 'b> State<'a, 'b> { _ => unreachable!(), }) .collect(); - if fmt_args.is_empty() { - return HashMap::default(); - } let (fmt_string, fmt_span) = match &list.nested[0] { syn::NestedMeta::Meta(syn::Meta::NameValue(syn::MetaNameValue { path, From 1d262f21da7159c73386eccbb7156c363e4949da Mon Sep 17 00:00:00 2001 From: tyranron Date: Wed, 9 Feb 2022 13:12:06 +0200 Subject: [PATCH 14/14] Corrections --- Cargo.toml | 6 ++--- doc/display.md | 8 +++++-- src/display.rs | 62 +++++++++++++++++++++++++------------------------- 3 files changed, 40 insertions(+), 36 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index c1ffcfb1..63b5aab6 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -33,12 +33,12 @@ syn = "1.0.81" convert_case = { version = "0.4", optional = true} unicode-xid = { version = "0.2.2", optional = true } -[dev-dependencies] -rustversion = "1.0.6" - [build-dependencies] rustc_version = { version = "0.4", optional = true } +[dev-dependencies] +rustversion = "1.0" + [badges] github = { repository = "JelteF/derive_more", workflow = "CI" } diff --git a/doc/display.md b/doc/display.md index ba311df6..1dcda404 100644 --- a/doc/display.md +++ b/doc/display.md @@ -28,9 +28,13 @@ The variables available in the arguments is `self` and each member of the varian with members of tuple structs being named with a leading underscore and their index, i.e. `_0`, `_1`, `_2`, etc. -Although [captured identifiers in format strings are supported only since `1.58`](https://blog.rust-lang.org/2022/01/13/Rust-1.58.0.html#captured-identifiers-in-format-strings) we support this feature on earlier version of Rust. This means that `#[display(fmt = "Prefix: {field}")]` is completely valid on MSRV. +Although [captured identifiers in format strings are supported since 1.58 +Rust](https://blog.rust-lang.org/2022/01/13/Rust-1.58.0.html#captured-identifiers-in-format-strings), +we support this feature on earlier versions of Rust too. This means that +`#[display(fmt = "Prefix: {field}")]` is completely valid on MSRV. -> __NOTE:__ Underscored named parameters like `#[display(fmt = "Prefix: {_0}")]` [are supported since `1.41`](https://github.com/rust-lang/rust/pull/66847) +> __NOTE:__ Underscored named parameters like `#[display(fmt = "Prefix: {_0}")]` +> [are supported only since 1.41 Rust](https://github.com/rust-lang/rust/pull/66847). ## Other formatting traits diff --git a/src/display.rs b/src/display.rs index ceb3dac2..a6b9708e 100644 --- a/src/display.rs +++ b/src/display.rs @@ -349,7 +349,6 @@ impl<'a, 'b> State<'a, 'b> { } }; - // TODO: Check for a single `Display` group? match &list.nested[0] { syn::NestedMeta::Meta(syn::Meta::NameValue(syn::MetaNameValue { path, @@ -371,7 +370,7 @@ impl<'a, 'b> State<'a, 'b> { if placeholders.len() > 1 || placeholders .first() - .map(|p| p.arg != Argument::Integer(0)) + .map(|p| p.arg != Parameter::Positional(0)) .unwrap_or_default() { return Err(Error::new( @@ -409,8 +408,8 @@ impl<'a, 'b> State<'a, 'b> { .into_iter() .flat_map(|p| { let map_argument = |arg| match arg { - Argument::Ident(i) => Some(i), - Argument::Integer(_) => None, + Parameter::Named(i) => Some(i), + Parameter::Positional(_) => None, }; map_argument(p.arg) .into_iter() @@ -691,10 +690,9 @@ impl<'a, 'b> State<'a, 'b> { HashMap::default(), |mut bounds, pl| { let arg = match pl.arg { - Argument::Integer(i) => fmt_args.get(&i).cloned(), - Argument::Ident(i) => Some(syn::Ident::new(&i, fmt_span).into()), + Parameter::Positional(i) => fmt_args.get(&i).cloned(), + Parameter::Named(i) => Some(syn::Ident::new(&i, fmt_span).into()), }; - if let Some(arg) = &arg { if fields_type_params.contains_key(arg) { bounds @@ -739,25 +737,27 @@ impl<'a, 'b> State<'a, 'b> { } } -/// [`Placeholder`] argument. -#[derive(Debug, PartialEq)] -enum Argument { +/// [Parameter][1] used in [`Placeholder`]. +/// +/// [1]: https://doc.rust-lang.org/stable/std/fmt/index.html#formatting-parameters +#[derive(Debug, Eq, PartialEq)] +enum Parameter { /// [Positional parameter][1]. /// /// [1]: https://doc.rust-lang.org/stable/std/fmt/index.html#positional-parameters - Integer(usize), + Positional(usize), /// [Named parameter][1]. /// /// [1]: https://doc.rust-lang.org/stable/std/fmt/index.html#named-parameters - Ident(String), + Named(String), } -impl<'a> From> for Argument { +impl<'a> From> for Parameter { fn from(arg: parsing::Argument<'a>) -> Self { match arg { - parsing::Argument::Integer(i) => Argument::Integer(i), - parsing::Argument::Identifier(i) => Argument::Ident(i.to_owned()), + parsing::Argument::Integer(i) => Parameter::Positional(i), + parsing::Argument::Identifier(i) => Parameter::Named(i.to_owned()), } } } @@ -765,18 +765,18 @@ impl<'a> From> for Argument { /// Representation of formatting placeholder. #[derive(Debug, PartialEq)] struct Placeholder { - /// Position of formatting argument to be used for this placeholder. - arg: Argument, + /// Formatting argument (either named or positional) to be used by this placeholder. + arg: Parameter, - /// [Width argument][1], if present. + /// [Width parameter][1], if present. /// /// [1]: https://doc.rust-lang.org/stable/std/fmt/index.html#width - width: Option, + width: Option, - /// [Precision argument][1], if present. + /// [Precision parameter][1], if present. /// /// [1]: https://doc.rust-lang.org/stable/std/fmt/index.html#precision - precision: Option, + precision: Option, /// Name of [`std::fmt`] trait to be used for rendering this placeholder. trait_name: &'static str, @@ -798,7 +798,7 @@ impl Placeholder { // Assign "the next argument". // https://doc.rust-lang.org/stable/std/fmt/index.html#positional-parameters n += 1; - Argument::Integer(n - 1) + Parameter::Positional(n - 1) }); Placeholder { @@ -831,38 +831,38 @@ mod placeholder_parse_fmt_string_spec { Placeholder::parse_fmt_string(&fmt_string), vec![ Placeholder { - arg: Argument::Integer(0), + arg: Parameter::Positional(0), width: None, precision: None, trait_name: "Display", }, Placeholder { - arg: Argument::Integer(1), + arg: Parameter::Positional(1), width: None, precision: None, trait_name: "Debug", }, Placeholder { - arg: Argument::Integer(1), - width: Some(Argument::Integer(0)), + arg: Parameter::Positional(1), + width: Some(Parameter::Positional(0)), precision: None, trait_name: "Display", }, Placeholder { - arg: Argument::Integer(2), + arg: Parameter::Positional(2), width: None, - precision: Some(Argument::Integer(1)), + precision: Some(Parameter::Positional(1)), trait_name: "LowerHex", }, Placeholder { - arg: Argument::Ident("par".to_owned()), + arg: Parameter::Named("par".to_owned()), width: None, precision: None, trait_name: "Debug", }, Placeholder { - arg: Argument::Integer(2), - width: Some(Argument::Ident("width".to_owned())), + arg: Parameter::Positional(2), + width: Some(Parameter::Named("width".to_owned())), precision: None, trait_name: "Display", },