Unnamed repository; edit this file 'description' to name the repository.
Diffstat (limited to 'crates/ide_db/src/helpers/format_string.rs')
| -rw-r--r-- | crates/ide_db/src/helpers/format_string.rs | 265 |
1 files changed, 263 insertions, 2 deletions
diff --git a/crates/ide_db/src/helpers/format_string.rs b/crates/ide_db/src/helpers/format_string.rs index c615d07250..29f61a95e7 100644 --- a/crates/ide_db/src/helpers/format_string.rs +++ b/crates/ide_db/src/helpers/format_string.rs @@ -1,5 +1,8 @@ //! Tools to work with format string literals for the `format_args!` family of macros. -use syntax::{ast, AstNode, AstToken}; +use syntax::{ + ast::{self, IsString}, + AstNode, AstToken, TextRange, +}; pub fn is_format_string(string: &ast::String) -> bool { // Check if `string` is a format string argument of a macro invocation. @@ -10,7 +13,7 @@ pub fn is_format_string(string: &ast::String) -> bool { // // This setup lets us correctly highlight the components of `concat!("{}", "bla")` format // strings. It still fails for `concat!("{", "}")`, but that is rare. - + format!("{string} {bar}", bar = string); (|| { let macro_call = string.syntax().ancestors().find_map(ast::MacroCall::cast)?; let name = macro_call.path()?.segment()?.name_ref()?; @@ -29,3 +32,261 @@ pub fn is_format_string(string: &ast::String) -> bool { })() .is_some() } + +#[derive(Debug)] +pub enum FormatSpecifier { + Open, + Close, + Integer, + Identifier, + Colon, + Fill, + Align, + Sign, + NumberSign, + Zero, + DollarSign, + Dot, + Asterisk, + QuestionMark, +} + +pub fn lex_format_specifiers( + string: &ast::String, + mut callback: &mut dyn FnMut(TextRange, FormatSpecifier), +) { + let mut char_ranges = Vec::new(); + string.escaped_char_ranges(&mut |range, res| char_ranges.push((range, res))); + let mut chars = char_ranges + .iter() + .filter_map(|(range, res)| Some((*range, *res.as_ref().ok()?))) + .peekable(); + + while let Some((range, first_char)) = chars.next() { + if let '{' = first_char { + // Format specifier, see syntax at https://doc.rust-lang.org/std/fmt/index.html#syntax + if let Some((_, '{')) = chars.peek() { + // Escaped format specifier, `{{` + chars.next(); + continue; + } + + callback(range, FormatSpecifier::Open); + + // check for integer/identifier + let (_, int_char) = chars.peek().copied().unwrap_or_default(); + match int_char { + // integer + '0'..='9' => read_integer(&mut chars, &mut callback), + // identifier + c if c == '_' || c.is_alphabetic() => read_identifier(&mut chars, &mut callback), + _ => {} + } + + if let Some((_, ':')) = chars.peek() { + skip_char_and_emit(&mut chars, FormatSpecifier::Colon, &mut callback); + + // check for fill/align + let mut cloned = chars.clone().take(2); + let (_, first) = cloned.next().unwrap_or_default(); + let (_, second) = cloned.next().unwrap_or_default(); + match second { + '<' | '^' | '>' => { + // alignment specifier, first char specifies fillment + skip_char_and_emit(&mut chars, FormatSpecifier::Fill, &mut callback); + skip_char_and_emit(&mut chars, FormatSpecifier::Align, &mut callback); + } + _ => { + if let '<' | '^' | '>' = first { + skip_char_and_emit(&mut chars, FormatSpecifier::Align, &mut callback); + } + } + } + + // check for sign + match chars.peek().copied().unwrap_or_default().1 { + '+' | '-' => { + skip_char_and_emit(&mut chars, FormatSpecifier::Sign, &mut callback); + } + _ => {} + } + + // check for `#` + if let Some((_, '#')) = chars.peek() { + skip_char_and_emit(&mut chars, FormatSpecifier::NumberSign, &mut callback); + } + + // check for `0` + let mut cloned = chars.clone().take(2); + let first = cloned.next().map(|next| next.1); + let second = cloned.next().map(|next| next.1); + + if first == Some('0') && second != Some('$') { + skip_char_and_emit(&mut chars, FormatSpecifier::Zero, &mut callback); + } + + // width + match chars.peek().copied().unwrap_or_default().1 { + '0'..='9' => { + read_integer(&mut chars, &mut callback); + if let Some((_, '$')) = chars.peek() { + skip_char_and_emit( + &mut chars, + FormatSpecifier::DollarSign, + &mut callback, + ); + } + } + c if c == '_' || c.is_alphabetic() => { + read_identifier(&mut chars, &mut callback); + + if chars.peek().map(|&(_, c)| c) == Some('?') { + skip_char_and_emit( + &mut chars, + FormatSpecifier::QuestionMark, + &mut callback, + ); + } + + // can be either width (indicated by dollar sign, or type in which case + // the next sign has to be `}`) + let next = chars.peek().map(|&(_, c)| c); + + match next { + Some('$') => skip_char_and_emit( + &mut chars, + FormatSpecifier::DollarSign, + &mut callback, + ), + Some('}') => { + skip_char_and_emit( + &mut chars, + FormatSpecifier::Close, + &mut callback, + ); + continue; + } + _ => continue, + }; + } + _ => {} + } + + // precision + if let Some((_, '.')) = chars.peek() { + skip_char_and_emit(&mut chars, FormatSpecifier::Dot, &mut callback); + + match chars.peek().copied().unwrap_or_default().1 { + '*' => { + skip_char_and_emit( + &mut chars, + FormatSpecifier::Asterisk, + &mut callback, + ); + } + '0'..='9' => { + read_integer(&mut chars, &mut callback); + if let Some((_, '$')) = chars.peek() { + skip_char_and_emit( + &mut chars, + FormatSpecifier::DollarSign, + &mut callback, + ); + } + } + c if c == '_' || c.is_alphabetic() => { + read_identifier(&mut chars, &mut callback); + if chars.peek().map(|&(_, c)| c) != Some('$') { + continue; + } + skip_char_and_emit( + &mut chars, + FormatSpecifier::DollarSign, + &mut callback, + ); + } + _ => { + continue; + } + } + } + + // type + match chars.peek().copied().unwrap_or_default().1 { + '?' => { + skip_char_and_emit( + &mut chars, + FormatSpecifier::QuestionMark, + &mut callback, + ); + } + c if c == '_' || c.is_alphabetic() => { + read_identifier(&mut chars, &mut callback); + + if chars.peek().map(|&(_, c)| c) == Some('?') { + skip_char_and_emit( + &mut chars, + FormatSpecifier::QuestionMark, + &mut callback, + ); + } + } + _ => {} + } + } + + if let Some((_, '}')) = chars.peek() { + skip_char_and_emit(&mut chars, FormatSpecifier::Close, &mut callback); + } + continue; + } + } + + fn skip_char_and_emit<I, F>( + chars: &mut std::iter::Peekable<I>, + emit: FormatSpecifier, + callback: &mut F, + ) where + I: Iterator<Item = (TextRange, char)>, + F: FnMut(TextRange, FormatSpecifier), + { + let (range, _) = chars.next().unwrap(); + callback(range, emit); + } + + fn read_integer<I, F>(chars: &mut std::iter::Peekable<I>, callback: &mut F) + where + I: Iterator<Item = (TextRange, char)>, + F: FnMut(TextRange, FormatSpecifier), + { + let (mut range, c) = chars.next().unwrap(); + assert!(c.is_ascii_digit()); + while let Some(&(r, next_char)) = chars.peek() { + if next_char.is_ascii_digit() { + chars.next(); + range = range.cover(r); + } else { + break; + } + } + callback(range, FormatSpecifier::Integer); + } + + fn read_identifier<I, F>(chars: &mut std::iter::Peekable<I>, callback: &mut F) + where + I: Iterator<Item = (TextRange, char)>, + F: FnMut(TextRange, FormatSpecifier), + { + let (mut range, c) = chars.next().unwrap(); + assert!(c.is_alphabetic() || c == '_'); + while let Some(&(r, next_char)) = chars.peek() { + if next_char == '_' || next_char.is_ascii_digit() || next_char.is_alphabetic() { + chars.next(); + range = range.cover(r); + } else { + break; + } + } + callback(range, FormatSpecifier::Identifier); + } +} |