Mirrors/rust-analyzer
2
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer synced 2024-12-26 13:03:31 +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,
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() {
match first_char {
Ok('{') => {
if let '{' = first_char {
// 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, `{{`
chars.next();
continue;
}
callback(*range, FormatSpecifier::Open);
callback(range, FormatSpecifier::Open);
// check for integer/identifier
match chars
.peek()
.and_then(|next| next.1.as_ref().ok())
.copied()
.unwrap_or_default()
{
'0'..='9' => {
let (_, int_char) = chars.peek().copied().unwrap_or_default();
match int_char {
// integer
read_integer(&mut chars, &mut callback);
}
c if c == '_' || c.is_alphabetic() => {
'0'..='9' => read_integer(&mut chars, &mut callback),
// 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);
// check for fill/align
let mut cloned = chars.clone().take(2);
let first = cloned
.next()
.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();
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::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,
);
}
_ => match first {
'<' | '^' | '>' => {
skip_char_and_emit(
&mut chars,
FormatSpecifier::Align,
&mut callback,
);
}
_ => {}
},
}
// check for sign
match chars
.peek()
.and_then(|next| next.1.as_ref().ok())
.copied()
.unwrap_or_default()
{
match chars.peek().copied().unwrap_or_default().1 {
'+' | '-' => {
skip_char_and_emit(
&mut chars,
FormatSpecifier::Sign,
&mut callback,
);
skip_char_and_emit(&mut chars, FormatSpecifier::Sign, &mut callback);
}
_ => {}
}
// check for `#`
if let Some((_, Ok('#'))) = chars.peek() {
skip_char_and_emit(
&mut chars,
FormatSpecifier::NumberSign,
&mut callback,
);
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().and_then(|next| next.1.as_ref().ok()).copied();
let second = cloned.next().and_then(|next| next.1.as_ref().ok()).copied();
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()
.and_then(|next| next.1.as_ref().ok())
.copied()
.unwrap_or_default()
{
match chars.peek().copied().unwrap_or_default().1 {
'0'..='9' => {
read_integer(&mut chars, &mut callback);
if let Some((_, Ok('$'))) = chars.peek() {
if let Some((_, '$')) = chars.peek() {
skip_char_and_emit(
&mut chars,
FormatSpecifier::DollarSign,
@ -416,9 +377,7 @@ pub trait HasFormatSpecifier: AstToken {
c if c == '_' || c.is_alphabetic() => {
read_identifier(&mut chars, &mut callback);
if chars.peek().and_then(|next| next.1.as_ref().ok()).copied()
== Some('?')
{
if chars.peek().map(|&(_, c)| c) == Some('?') {
skip_char_and_emit(
&mut chars,
FormatSpecifier::QuestionMark,
@ -428,8 +387,7 @@ pub trait HasFormatSpecifier: AstToken {
// can be either width (indicated by dollar sign, or type in which case
// the next sign has to be `}`)
let next =
chars.peek().and_then(|next| next.1.as_ref().ok()).copied();
let next = chars.peek().map(|&(_, c)| c);
match next {
Some('$') => skip_char_and_emit(
@ -452,15 +410,10 @@ pub trait HasFormatSpecifier: AstToken {
}
// precision
if let Some((_, Ok('.'))) = chars.peek() {
if let Some((_, '.')) = chars.peek() {
skip_char_and_emit(&mut chars, FormatSpecifier::Dot, &mut callback);
match chars
.peek()
.and_then(|next| next.1.as_ref().ok())
.copied()
.unwrap_or_default()
{
match chars.peek().copied().unwrap_or_default().1 {
'*' => {
skip_char_and_emit(
&mut chars,
@ -470,7 +423,7 @@ pub trait HasFormatSpecifier: AstToken {
}
'0'..='9' => {
read_integer(&mut chars, &mut callback);
if let Some((_, Ok('$'))) = chars.peek() {
if let Some((_, '$')) = chars.peek() {
skip_char_and_emit(
&mut chars,
FormatSpecifier::DollarSign,
@ -480,9 +433,7 @@ pub trait HasFormatSpecifier: AstToken {
}
c if c == '_' || c.is_alphabetic() => {
read_identifier(&mut chars, &mut callback);
if chars.peek().and_then(|next| next.1.as_ref().ok()).copied()
!= Some('$')
{
if chars.peek().map(|&(_, c)| c) != Some('$') {
continue;
}
skip_char_and_emit(
@ -498,12 +449,7 @@ pub trait HasFormatSpecifier: AstToken {
}
// type
match chars
.peek()
.and_then(|next| next.1.as_ref().ok())
.copied()
.unwrap_or_default()
{
match chars.peek().copied().unwrap_or_default().1 {
'?' => {
skip_char_and_emit(
&mut chars,
@ -514,9 +460,7 @@ pub trait HasFormatSpecifier: AstToken {
c if c == '_' || c.is_alphabetic() => {
read_identifier(&mut chars, &mut callback);
if chars.peek().and_then(|next| next.1.as_ref().ok()).copied()
== Some('?')
{
if chars.peek().map(|&(_, c)| c) == Some('?') {
skip_char_and_emit(
&mut chars,
FormatSpecifier::QuestionMark,
@ -528,47 +472,36 @@ pub trait HasFormatSpecifier: AstToken {
}
}
match chars.peek() {
Some((_, Ok('}'))) => {
if let Some((_, '}')) = chars.peek() {
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>,
emit: FormatSpecifier,
callback: &mut F,
) where
I: Iterator<Item = &'a (TextRange, Result<char, rustc_lexer::unescape::EscapeError>)>,
I: Iterator<Item = (TextRange, char)>,
F: FnMut(TextRange, FormatSpecifier),
{
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
I: Iterator<Item = &'a (TextRange, Result<char, rustc_lexer::unescape::EscapeError>)>,
I: Iterator<Item = (TextRange, char)>,
F: FnMut(TextRange, FormatSpecifier),
{
let (mut range, c) = chars.next().unwrap();
assert!(c.as_ref().unwrap().is_ascii_digit());
while let Some((r, Ok(next_char))) = chars.peek() {
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);
range = range.cover(r);
} else {
break;
}
@ -576,17 +509,17 @@ pub trait HasFormatSpecifier: AstToken {
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
I: Iterator<Item = &'a (TextRange, Result<char, rustc_lexer::unescape::EscapeError>)>,
I: Iterator<Item = (TextRange, char)>,
F: FnMut(TextRange, FormatSpecifier),
{
let (mut range, c) = chars.next().unwrap();
assert!(c.as_ref().unwrap().is_alphabetic() || *c.as_ref().unwrap() == '_');
while let Some((r, Ok(next_char))) = chars.peek() {
if *next_char == '_' || next_char.is_ascii_digit() || next_char.is_alphabetic() {
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);
range = range.cover(r);
} else {
break;
}