Mirrors/rust-analyzer
2
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer synced 2024-12-27 05:23:24 +00:00
Code Issues Projects Releases Packages Wiki Activity

Merge #11276

Browse source 
11276: internal: Slightly cleanup HasFormatSpecifier::lex_format_specifier r=Veykril a=Veykril

bors r+

Co-authored-by: Lukas Wirth <lukastw97@gmail.com>
This commit is contained in:
bors[bot] 2022-01-13 19:18:47 +00:00 committed by GitHub
commit b4c31481a5
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
1 changed files with 162 additions and 229 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

171
crates/syntax/src/ast/token_ext.rs
View file

@ -288,124 +288,85 @@ pub trait HasFormatSpecifier: AstToken {
Some(char_ranges) => char_ranges, Some(char_ranges) => char_ranges,
None => return, None => return,
}; };
let mut chars = char_ranges.iter().peekable(); 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() { while let Some((range, first_char)) = chars.next() {
match first_char { if let '{' = first_char {
Ok('{') => {
// Format specifier, see syntax at https://doc.rust-lang.org/std/fmt/index.html#syntax // Format specifier, see syntax at https://doc.rust-lang.org/std/fmt/index.html#syntax
if let Some((_, Ok('{'))) = chars.peek() { if let Some((_, '{')) = chars.peek() {
// Escaped format specifier, `{{` // Escaped format specifier, `{{`
chars.next(); chars.next();
continue; continue;
} }
callback(*range, FormatSpecifier::Open); callback(range, FormatSpecifier::Open);
// check for integer/identifier // check for integer/identifier
match chars let (_, int_char) = chars.peek().copied().unwrap_or_default();
.peek() match int_char {
.and_then(|next| next.1.as_ref().ok())
.copied()
.unwrap_or_default()
{
'0'..='9' => {
// integer // integer
read_integer(&mut chars, &mut callback); '0'..='9' => read_integer(&mut chars, &mut callback),
}
c if c == '_' || c.is_alphabetic() => {
// identifier // identifier
read_identifier(&mut chars, &mut callback); c if c == '_' || c.is_alphabetic() => {
read_identifier(&mut chars, &mut callback)
} }
_ => {} _ => {}
} }
if let Some((_, Ok(':'))) = chars.peek() { if let Some((_, ':')) = chars.peek() {
skip_char_and_emit(&mut chars, FormatSpecifier::Colon, &mut callback); skip_char_and_emit(&mut chars, FormatSpecifier::Colon, &mut callback);
// check for fill/align // check for fill/align
let mut cloned = chars.clone().take(2); let mut cloned = chars.clone().take(2);
let first = cloned let (_, first) = cloned.next().unwrap_or_default();
.next() let (_, second) = cloned.next().unwrap_or_default();
.and_then(|next| next.1.as_ref().ok())
.copied()
.unwrap_or_default();
let second = cloned
.next()
.and_then(|next| next.1.as_ref().ok())
.copied()
.unwrap_or_default();
match second { match second {
'<' | '^' | '>' => { '<' | '^' | '>' => {
// alignment specifier, first char specifies fillment // alignment specifier, first char specifies fillment
skip_char_and_emit( skip_char_and_emit(&mut chars, FormatSpecifier::Fill, &mut callback);
&mut chars, skip_char_and_emit(&mut chars, FormatSpecifier::Align, &mut callback);
FormatSpecifier::Fill, }
&mut callback, _ => {
); if let '<' | '^' | '>' = first {
skip_char_and_emit( skip_char_and_emit(
&mut chars, &mut chars,
FormatSpecifier::Align, FormatSpecifier::Align,
&mut callback, &mut callback,
); );
} }
_ => match first {
'<' | '^' | '>' => {
skip_char_and_emit(
&mut chars,
FormatSpecifier::Align,
&mut callback,
);
} }
_ => {}
},
} }
// check for sign // check for sign
match chars match chars.peek().copied().unwrap_or_default().1 {
.peek()
.and_then(|next| next.1.as_ref().ok())
.copied()
.unwrap_or_default()
{
'+' | '-' => { '+' | '-' => {
skip_char_and_emit( skip_char_and_emit(&mut chars, FormatSpecifier::Sign, &mut callback);
&mut chars,
FormatSpecifier::Sign,
&mut callback,
);
} }
_ => {} _ => {}
} }
// check for `#` // check for `#`
if let Some((_, Ok('#'))) = chars.peek() { if let Some((_, '#')) = chars.peek() {
skip_char_and_emit( skip_char_and_emit(&mut chars, FormatSpecifier::NumberSign, &mut callback);
&mut chars,
FormatSpecifier::NumberSign,
&mut callback,
);
} }
// check for `0` // check for `0`
let mut cloned = chars.clone().take(2); let mut cloned = chars.clone().take(2);
let first = cloned.next().and_then(|next| next.1.as_ref().ok()).copied(); let first = cloned.next().map(|next| next.1);
let second = cloned.next().and_then(|next| next.1.as_ref().ok()).copied(); let second = cloned.next().map(|next| next.1);
if first == Some('0') && second != Some('$') { if first == Some('0') && second != Some('$') {
skip_char_and_emit(&mut chars, FormatSpecifier::Zero, &mut callback); skip_char_and_emit(&mut chars, FormatSpecifier::Zero, &mut callback);
} }
// width // width
match chars match chars.peek().copied().unwrap_or_default().1 {
.peek()
.and_then(|next| next.1.as_ref().ok())
.copied()
.unwrap_or_default()
{
'0'..='9' => { '0'..='9' => {
read_integer(&mut chars, &mut callback); read_integer(&mut chars, &mut callback);
if let Some((_, Ok('$'))) = chars.peek() { if let Some((_, '$')) = chars.peek() {
skip_char_and_emit( skip_char_and_emit(
&mut chars, &mut chars,
FormatSpecifier::DollarSign, FormatSpecifier::DollarSign,
@ -416,9 +377,7 @@ pub trait HasFormatSpecifier: AstToken {
c if c == '_' || c.is_alphabetic() => { c if c == '_' || c.is_alphabetic() => {
read_identifier(&mut chars, &mut callback); read_identifier(&mut chars, &mut callback);
if chars.peek().and_then(|next| next.1.as_ref().ok()).copied() if chars.peek().map(|&(_, c)| c) == Some('?') {
== Some('?')
{
skip_char_and_emit( skip_char_and_emit(
&mut chars, &mut chars,
FormatSpecifier::QuestionMark, FormatSpecifier::QuestionMark,
@ -428,8 +387,7 @@ pub trait HasFormatSpecifier: AstToken {
// can be either width (indicated by dollar sign, or type in which case // can be either width (indicated by dollar sign, or type in which case
// the next sign has to be `}`) // the next sign has to be `}`)
let next = let next = chars.peek().map(|&(_, c)| c);
chars.peek().and_then(|next| next.1.as_ref().ok()).copied();
match next { match next {
Some('$') => skip_char_and_emit( Some('$') => skip_char_and_emit(
@ -452,15 +410,10 @@ pub trait HasFormatSpecifier: AstToken {
} }
// precision // precision
if let Some((_, Ok('.'))) = chars.peek() { if let Some((_, '.')) = chars.peek() {
skip_char_and_emit(&mut chars, FormatSpecifier::Dot, &mut callback); skip_char_and_emit(&mut chars, FormatSpecifier::Dot, &mut callback);
match chars match chars.peek().copied().unwrap_or_default().1 {
.peek()
.and_then(|next| next.1.as_ref().ok())
.copied()
.unwrap_or_default()
{
'*' => { '*' => {
skip_char_and_emit( skip_char_and_emit(
&mut chars, &mut chars,
@ -470,7 +423,7 @@ pub trait HasFormatSpecifier: AstToken {
} }
'0'..='9' => { '0'..='9' => {
read_integer(&mut chars, &mut callback); read_integer(&mut chars, &mut callback);
if let Some((_, Ok('$'))) = chars.peek() { if let Some((_, '$')) = chars.peek() {
skip_char_and_emit( skip_char_and_emit(
&mut chars, &mut chars,
FormatSpecifier::DollarSign, FormatSpecifier::DollarSign,
@ -480,9 +433,7 @@ pub trait HasFormatSpecifier: AstToken {
} }
c if c == '_' || c.is_alphabetic() => { c if c == '_' || c.is_alphabetic() => {
read_identifier(&mut chars, &mut callback); read_identifier(&mut chars, &mut callback);
if chars.peek().and_then(|next| next.1.as_ref().ok()).copied() if chars.peek().map(|&(_, c)| c) != Some('$') {
!= Some('$')
{
continue; continue;
} }
skip_char_and_emit( skip_char_and_emit(
@ -498,12 +449,7 @@ pub trait HasFormatSpecifier: AstToken {
} }
// type // type
match chars match chars.peek().copied().unwrap_or_default().1 {
.peek()
.and_then(|next| next.1.as_ref().ok())
.copied()
.unwrap_or_default()
{
'?' => { '?' => {
skip_char_and_emit( skip_char_and_emit(
&mut chars, &mut chars,
@ -514,9 +460,7 @@ pub trait HasFormatSpecifier: AstToken {
c if c == '_' || c.is_alphabetic() => { c if c == '_' || c.is_alphabetic() => {
read_identifier(&mut chars, &mut callback); read_identifier(&mut chars, &mut callback);
if chars.peek().and_then(|next| next.1.as_ref().ok()).copied() if chars.peek().map(|&(_, c)| c) == Some('?') {
== Some('?')
{
skip_char_and_emit( skip_char_and_emit(
&mut chars, &mut chars,
FormatSpecifier::QuestionMark, FormatSpecifier::QuestionMark,
@ -528,47 +472,36 @@ pub trait HasFormatSpecifier: AstToken {
} }
} }
match chars.peek() { if let Some((_, '}')) = chars.peek() {
Some((_, Ok('}'))) => {
skip_char_and_emit(&mut chars, FormatSpecifier::Close, &mut callback); skip_char_and_emit(&mut chars, FormatSpecifier::Close, &mut callback);
} }
Some((_, _)) | None => continue, continue;
} }
} }
_ => {
while let Some((_, Ok(next_char))) = chars.peek() {
if next_char == &'{' {
break;
}
chars.next();
}
}
};
}
fn skip_char_and_emit<'a, I, F>( fn skip_char_and_emit<I, F>(
chars: &mut std::iter::Peekable<I>, chars: &mut std::iter::Peekable<I>,
emit: FormatSpecifier, emit: FormatSpecifier,
callback: &mut F, callback: &mut F,
) where ) where
I: Iterator<Item = &'a (TextRange, Result<char, rustc_lexer::unescape::EscapeError>)>, I: Iterator<Item = (TextRange, char)>,
F: FnMut(TextRange, FormatSpecifier), F: FnMut(TextRange, FormatSpecifier),
{ {
let (range, _) = chars.next().unwrap(); let (range, _) = chars.next().unwrap();
callback(*range, emit); callback(range, emit);
} }
fn read_integer<'a, I, F>(chars: &mut std::iter::Peekable<I>, callback: &mut F) fn read_integer<I, F>(chars: &mut std::iter::Peekable<I>, callback: &mut F)
where where
I: Iterator<Item = &'a (TextRange, Result<char, rustc_lexer::unescape::EscapeError>)>, I: Iterator<Item = (TextRange, char)>,
F: FnMut(TextRange, FormatSpecifier), F: FnMut(TextRange, FormatSpecifier),
{ {
let (mut range, c) = chars.next().unwrap(); let (mut range, c) = chars.next().unwrap();
assert!(c.as_ref().unwrap().is_ascii_digit()); assert!(c.is_ascii_digit());
while let Some((r, Ok(next_char))) = chars.peek() { while let Some(&(r, next_char)) = chars.peek() {
if next_char.is_ascii_digit() { if next_char.is_ascii_digit() {
chars.next(); chars.next();
range = range.cover(*r); range = range.cover(r);
} else { } else {
break; break;
} }
@ -576,17 +509,17 @@ pub trait HasFormatSpecifier: AstToken {
callback(range, FormatSpecifier::Integer); callback(range, FormatSpecifier::Integer);
} }
fn read_identifier<'a, I, F>(chars: &mut std::iter::Peekable<I>, callback: &mut F) fn read_identifier<I, F>(chars: &mut std::iter::Peekable<I>, callback: &mut F)
where where
I: Iterator<Item = &'a (TextRange, Result<char, rustc_lexer::unescape::EscapeError>)>, I: Iterator<Item = (TextRange, char)>,
F: FnMut(TextRange, FormatSpecifier), F: FnMut(TextRange, FormatSpecifier),
{ {
let (mut range, c) = chars.next().unwrap(); let (mut range, c) = chars.next().unwrap();
assert!(c.as_ref().unwrap().is_alphabetic() || *c.as_ref().unwrap() == '_'); assert!(c.is_alphabetic() || c == '_');
while let Some((r, Ok(next_char))) = chars.peek() { while let Some(&(r, next_char)) = chars.peek() {
if *next_char == '_' || next_char.is_ascii_digit() || next_char.is_alphabetic() { if next_char == '_' || next_char.is_ascii_digit() || next_char.is_alphabetic() {
chars.next(); chars.next();
range = range.cover(*r); range = range.cover(r);
} else { } else {
break; break;
} }