use super::{Delimiter, Token};
const COUNTED_KEYWORDS: [&str; 25] = [
"as", "async", "become", "box", "break", "const", "dyn", "fn", "for", "if", "impl", "let",
"loop", "match", "mod", "move", "mut", "ref", "return", "static", "try", "unsafe", "where",
"while", "yield",
];
const CONTINUING_WORDS: [&str; 3] = ["as", "else", "in"];
const KEYWORDS: [&str; 52] = [
"Self", "abstract", "as", "async", "await", "become", "box", "break", "const", "continue",
"crate", "do", "dyn", "else", "enum", "extern", "false", "final", "fn", "for", "gen", "if",
"impl", "in", "let", "loop", "macro", "match", "mod", "move", "mut", "override", "priv", "pub",
"ref", "return", "self", "static", "struct", "super", "trait", "true", "try", "type", "typeof",
"unsafe", "unsized", "use", "virtual", "where", "while", "yield",
];
const OPERAND_KEYWORDS: [&str; 7] = ["Self", "await", "crate", "false", "self", "super", "true"];
const BLOCK_OWNERS: [&str; 11] = [
"async", "const", "for", "if", "loop", "match", "move", "static", "try", "unsafe", "while",
];
pub(super) const USE_SEPARATOR_UNITS: usize = 16;
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
enum Scrutinee {
#[default]
None,
Clear,
Doubt,
}
const DOUBLED_UNITS: usize = 2;
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
enum Kind {
#[default]
Plain,
TokenTree,
Arms,
}
#[derive(Debug, Default, Clone, Copy)]
struct Lists {
bar: bool,
use_declaration: bool,
where_clause: bool,
}
#[derive(Debug, Default, Clone, Copy)]
struct Level {
count: usize,
angles: usize,
kind: Kind,
lists: Lists,
after_brace: bool,
in_pattern: bool,
scrutinee: Scrutinee,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Mark {
None,
Attribute,
Lifetime,
}
#[derive(Debug, Clone, Copy)]
struct Before {
mark: Mark,
operand: bool,
macro_call: bool,
}
pub(super) struct Recursion {
levels: Vec<Level>,
value: usize,
peak: usize,
attribute: bool,
after_lifetime: bool,
after_operand: bool,
macro_call: u8,
}
impl Recursion {
pub(super) fn new() -> Self {
Self {
levels: vec![Level::default()],
value: 0,
peak: 0,
attribute: false,
after_lifetime: false,
after_operand: false,
macro_call: 0,
}
}
pub(super) fn peak(&self) -> usize {
self.peak
}
fn top(&mut self) -> &mut Level {
let last = self.levels.len() - 1;
&mut self.levels[last]
}
fn add(&mut self, units: usize) {
self.top().count += units;
self.value += units;
self.peak = self.peak.max(self.value);
}
fn end(&mut self, statement: bool) {
let level = self.top();
let count = level.count;
level.count = 0;
if statement {
level.angles = 0;
level.lists = Lists::default();
level.in_pattern = false;
level.scrutinee = Scrutinee::None;
}
self.value -= count;
}
fn open(&mut self, delimiter: Delimiter, before: Before) {
let level = self.top();
let inherited = level.kind == Kind::TokenTree;
let kind = if inherited || before.macro_call {
Kind::TokenTree
} else if delimiter == Delimiter::Brace
&& level.scrutinee == Scrutinee::Clear
&& before.operand
{
Kind::Arms
} else {
Kind::Plain
};
let use_declaration = level.lists.use_declaration;
if delimiter == Delimiter::Brace {
level.lists.where_clause = false;
if level.scrutinee != Scrutinee::None {
level.scrutinee = if kind == Kind::Arms {
Scrutinee::None
} else {
Scrutinee::Doubt
};
}
}
if !(inherited
|| before.macro_call
|| before.mark == Mark::Attribute && delimiter == Delimiter::Bracket)
{
self.add(1);
}
self.levels.push(Level {
kind,
lists: Lists {
use_declaration,
..Lists::default()
},
in_pattern: kind == Kind::Arms,
..Level::default()
});
self.value += 1;
self.peak = self.peak.max(self.value);
}
fn close(&mut self, brace: bool) {
if self.levels.len() > 1 {
let closed = self.levels.pop().map_or(0, |level| level.count);
self.value -= closed + 1;
if brace {
self.top().after_brace = true;
}
}
}
fn before(&mut self, token: Token<'_>) -> Before {
let macro_call = std::mem::take(&mut self.macro_call);
self.macro_call = match token {
Token::Ident(word) if !KEYWORDS.contains(&word) => {
if macro_call == 2 {
3
} else {
1
}
}
Token::Bang if macro_call == 1 => 2,
_ => 0,
};
let operand = std::mem::replace(
&mut self.after_operand,
match token {
Token::Ident(word) => !KEYWORDS.contains(&word) || OPERAND_KEYWORDS.contains(&word),
Token::Literal | Token::Float | Token::CloseOther => true,
_ => false,
},
);
let mark = if std::mem::take(&mut self.attribute) {
Mark::Attribute
} else if std::mem::take(&mut self.after_lifetime) {
Mark::Lifetime
} else {
Mark::None
};
Before {
mark,
operand,
macro_call: macro_call >= 2,
}
}
pub(super) fn feed(&mut self, token: Token<'_>, width: usize) -> usize {
let before = self.before(token);
if self.top().kind == Kind::TokenTree {
match token {
Token::Open(delimiter) => self.open(delimiter, before),
Token::CloseBrace | Token::CloseOther => self.close(false),
_ => {}
}
return self.value;
}
let level = self.top();
if std::mem::take(&mut level.after_brace) && ends_block_statement(token) {
self.end(true);
let level = self.top();
level.in_pattern = level.kind == Kind::Arms;
}
let level = self.top();
if level.scrutinee == Scrutinee::Clear && takes_a_block(token, before) {
level.scrutinee = Scrutinee::Doubt;
}
match token {
Token::Ident(word) => self.word(word),
Token::Open(delimiter) => self.open(delimiter, before),
Token::CloseBrace | Token::CloseOther => self.close(token == Token::CloseBrace),
_ => self.punctuation(token, width, before),
}
self.value
}
fn punctuation(&mut self, token: Token<'_>, width: usize, before: Before) {
match token {
Token::Semi | Token::FatArrow => self.end(true),
Token::Comma => {
let level = self.top();
if level.angles == 0 && !level.lists.bar && !level.lists.where_clause {
level.in_pattern = level.kind == Kind::Arms;
self.end(false);
}
}
Token::Lt => {
self.top().angles += 1;
self.add(DOUBLED_UNITS * width);
}
Token::Gt => {
let level = self.top();
level.angles = level.angles.saturating_sub(1);
self.add(width);
}
Token::Pipe => {
let level = self.top();
if level.in_pattern {
self.end(false);
} else {
level.lists.bar = !level.lists.bar;
self.add(width);
}
}
Token::Hash => self.attribute = true,
Token::Bang => {
if before.mark == Mark::Attribute {
self.attribute = true;
} else {
self.add(width);
}
}
Token::Amp | Token::AmpAmp => self.add(DOUBLED_UNITS * width),
Token::Minus | Token::Star | Token::PipePipe | Token::Operator => self.add(width),
Token::Float => self.add(1),
Token::Colon => {
if before.mark == Mark::Lifetime {
self.add(1);
}
}
Token::PathSep => {
if self.top().lists.use_declaration {
self.add(USE_SEPARATOR_UNITS);
}
}
Token::Lifetime => self.after_lifetime = true,
Token::Ident(_)
| Token::Open(_)
| Token::CloseBrace
| Token::CloseOther
| Token::Literal
| Token::Other => {}
}
}
fn word(&mut self, word: &str) {
let level = self.top();
match word {
"use" => level.lists.use_declaration = true,
"where" => level.lists.where_clause = true,
"if" => level.in_pattern = false,
"match" => {
level.scrutinee = if level.scrutinee == Scrutinee::None {
Scrutinee::Clear
} else {
Scrutinee::Doubt
};
}
_ => {}
}
if COUNTED_KEYWORDS.contains(&word) {
self.add(1);
}
}
}
fn takes_a_block(token: Token<'_>, before: Before) -> bool {
match token {
Token::Ident(word) => BLOCK_OWNERS.contains(&word),
Token::Pipe | Token::PipePipe => true,
Token::Colon => before.mark == Mark::Lifetime,
_ => false,
}
}
fn ends_block_statement(token: Token<'_>) -> bool {
match token {
Token::Ident(word) => !CONTINUING_WORDS.contains(&word),
Token::Literal | Token::Float | Token::Lifetime | Token::Hash => true,
_ => false,
}
}