1 //! Tools to work with format string literals for the `format_args!` family of macros.
4 AstNode, AstToken, TextRange, TextSize,
7 pub fn is_format_string(string: &ast::String) -> bool {
8 // Check if `string` is a format string argument of a macro invocation.
9 // `string` is a string literal, mapped down into the innermost macro expansion.
10 // Since `format_args!` etc. remove the format string when expanding, but place all arguments
11 // in the expanded output, we know that the string token is (part of) the format string if it
12 // appears in `format_args!` (otherwise it would have been mapped down further).
14 // This setup lets us correctly highlight the components of `concat!("{}", "bla")` format
15 // strings. It still fails for `concat!("{", "}")`, but that is rare.
17 let macro_call = string.syntax().parent_ancestors().find_map(ast::MacroCall::cast)?;
18 let name = macro_call.path()?.segment()?.name_ref()?;
22 "format_args" | "format_args_nl" | "const_format_args" | "panic_2015" | "panic_2021"
27 // NB: we match against `panic_2015`/`panic_2021` here because they have a special-cased arm for
28 // `"{}"`, which otherwise wouldn't get highlighted.
36 pub enum FormatSpecifier {
54 pub fn lex_format_specifiers(
56 mut callback: &mut dyn FnMut(TextRange, FormatSpecifier),
58 let mut char_ranges = Vec::new();
59 string.escaped_char_ranges(&mut |range, res| char_ranges.push((range, res)));
60 let mut chars = char_ranges
62 .filter_map(|(range, res)| Some((*range, *res.as_ref().ok()?)))
65 while let Some((range, first_char)) = chars.next() {
66 if let '{' = first_char {
67 // Format specifier, see syntax at https://doc.rust-lang.org/std/fmt/index.html#syntax
68 if let Some((_, '{')) = chars.peek() {
69 // Escaped format specifier, `{{`
70 read_escaped_format_specifier(&mut chars, &mut callback);
74 callback(range, FormatSpecifier::Open);
76 // check for integer/identifier
77 let (_, int_char) = chars.peek().copied().unwrap_or_default();
80 '0'..='9' => read_integer(&mut chars, &mut callback),
82 c if c == '_' || c.is_alphabetic() => read_identifier(&mut chars, &mut callback),
86 if let Some((_, ':')) = chars.peek() {
87 skip_char_and_emit(&mut chars, FormatSpecifier::Colon, &mut callback);
89 // check for fill/align
90 let mut cloned = chars.clone().take(2);
91 let (_, first) = cloned.next().unwrap_or_default();
92 let (_, second) = cloned.next().unwrap_or_default();
95 // alignment specifier, first char specifies fillment
96 skip_char_and_emit(&mut chars, FormatSpecifier::Fill, &mut callback);
97 skip_char_and_emit(&mut chars, FormatSpecifier::Align, &mut callback);
100 if let '<' | '^' | '>' = first {
101 skip_char_and_emit(&mut chars, FormatSpecifier::Align, &mut callback);
107 match chars.peek().copied().unwrap_or_default().1 {
109 skip_char_and_emit(&mut chars, FormatSpecifier::Sign, &mut callback);
115 if let Some((_, '#')) = chars.peek() {
116 skip_char_and_emit(&mut chars, FormatSpecifier::NumberSign, &mut callback);
120 let mut cloned = chars.clone().take(2);
121 let first = cloned.next().map(|next| next.1);
122 let second = cloned.next().map(|next| next.1);
124 if first == Some('0') && second != Some('$') {
125 skip_char_and_emit(&mut chars, FormatSpecifier::Zero, &mut callback);
129 match chars.peek().copied().unwrap_or_default().1 {
131 read_integer(&mut chars, &mut callback);
132 if let Some((_, '$')) = chars.peek() {
135 FormatSpecifier::DollarSign,
140 c if c == '_' || c.is_alphabetic() => {
141 read_identifier(&mut chars, &mut callback);
143 if chars.peek().map(|&(_, c)| c) == Some('?') {
146 FormatSpecifier::QuestionMark,
151 // can be either width (indicated by dollar sign, or type in which case
152 // the next sign has to be `}`)
153 let next = chars.peek().map(|&(_, c)| c);
156 Some('$') => skip_char_and_emit(
158 FormatSpecifier::DollarSign,
164 FormatSpecifier::Close,
176 if let Some((_, '.')) = chars.peek() {
177 skip_char_and_emit(&mut chars, FormatSpecifier::Dot, &mut callback);
179 match chars.peek().copied().unwrap_or_default().1 {
183 FormatSpecifier::Asterisk,
188 read_integer(&mut chars, &mut callback);
189 if let Some((_, '$')) = chars.peek() {
192 FormatSpecifier::DollarSign,
197 c if c == '_' || c.is_alphabetic() => {
198 read_identifier(&mut chars, &mut callback);
199 if chars.peek().map(|&(_, c)| c) != Some('$') {
204 FormatSpecifier::DollarSign,
215 match chars.peek().copied().unwrap_or_default().1 {
219 FormatSpecifier::QuestionMark,
223 c if c == '_' || c.is_alphabetic() => {
224 read_identifier(&mut chars, &mut callback);
226 if chars.peek().map(|&(_, c)| c) == Some('?') {
229 FormatSpecifier::QuestionMark,
238 if let Some((_, '}')) = chars.peek() {
239 skip_char_and_emit(&mut chars, FormatSpecifier::Close, &mut callback);
242 } else if let '}' = first_char {
243 if let Some((_, '}')) = chars.peek() {
244 // Escaped format specifier, `}}`
245 read_escaped_format_specifier(&mut chars, &mut callback);
250 fn skip_char_and_emit<I, F>(
251 chars: &mut std::iter::Peekable<I>,
252 emit: FormatSpecifier,
255 I: Iterator<Item = (TextRange, char)>,
256 F: FnMut(TextRange, FormatSpecifier),
258 let (range, _) = chars.next().unwrap();
259 callback(range, emit);
262 fn read_integer<I, F>(chars: &mut std::iter::Peekable<I>, callback: &mut F)
264 I: Iterator<Item = (TextRange, char)>,
265 F: FnMut(TextRange, FormatSpecifier),
267 let (mut range, c) = chars.next().unwrap();
268 assert!(c.is_ascii_digit());
269 while let Some(&(r, next_char)) = chars.peek() {
270 if next_char.is_ascii_digit() {
272 range = range.cover(r);
277 callback(range, FormatSpecifier::Integer);
280 fn read_identifier<I, F>(chars: &mut std::iter::Peekable<I>, callback: &mut F)
282 I: Iterator<Item = (TextRange, char)>,
283 F: FnMut(TextRange, FormatSpecifier),
285 let (mut range, c) = chars.next().unwrap();
286 assert!(c.is_alphabetic() || c == '_');
287 while let Some(&(r, next_char)) = chars.peek() {
288 if next_char == '_' || next_char.is_ascii_digit() || next_char.is_alphabetic() {
290 range = range.cover(r);
295 callback(range, FormatSpecifier::Identifier);
298 fn read_escaped_format_specifier<I, F>(chars: &mut std::iter::Peekable<I>, callback: &mut F)
300 I: Iterator<Item = (TextRange, char)>,
301 F: FnMut(TextRange, FormatSpecifier),
303 let (range, _) = chars.peek().unwrap();
304 let offset = TextSize::from(1);
305 callback(TextRange::new(range.start() - offset, range.end()), FormatSpecifier::Escape);