use crate::parser::helper::unknown_range;
use super::prelude::*;
#[derive(Debug, Clone, PartialEq, strum::EnumIs)]
pub(crate) enum Pattern<'s> {
Grouping(TokenRef<'s>, Box<Pattern<'s>>, TokenRef<'s>),
Literal(Option<TokenRef<'s>>, TokenRef<'s>),
Constant(TokenRef<'s>),
Relation(TokenRef<'s>, Box<Pattern<'s>>),
Range(Box<Pattern<'s>>, TokenRef<'s>, Box<Pattern<'s>>),
Discard(TokenRef<'s>),
Bind(Option<TokenRef<'s>>, TokenRef<'s>),
Record(TokenRef<'s>, Vec<RecordPattern<'s>>, TokenRef<'s>),
Array(TokenRef<'s>, Vec<ArrayPattern<'s>>, TokenRef<'s>),
SpreadDiscard(usize),
And(Box<Pattern<'s>>, TokenRef<'s>, Box<Pattern<'s>>),
Or(Box<Pattern<'s>>, TokenRef<'s>, Box<Pattern<'s>>),
Not(TokenRef<'s>, Box<Pattern<'s>>),
Unknown {
recovered: Option<Box<Pattern<'s>>>,
tokens: Vec<TokenRef<'s>>,
errors: Vec<SourceDiagnostic>,
},
}
impl<'s> Pattern<'s> {
pub(crate) fn wrap_as_unknown<T: Into<Vec<TokenRef<'s>>>>(
self,
tokens: T,
error: DiagnosticCode,
) -> Self {
let tokens = tokens.into();
assert!(!tokens.is_empty());
let mut range = tokens[0].range.clone();
range.end = tokens.last().unwrap().range.end;
Pattern::Unknown {
recovered: Some(Box::new(self)),
tokens,
errors: vec![SourceDiagnostic::new(range, error)],
}
}
pub(crate) fn unknown<T: Into<Vec<TokenRef<'s>>>>(tokens: T, error: DiagnosticCode) -> Self {
let tokens = tokens.into();
assert!(!tokens.is_empty());
let mut range = tokens[0].range.clone();
range.end = tokens.last().unwrap().range.end;
Pattern::Unknown {
recovered: None,
tokens,
errors: vec![SourceDiagnostic::new(range, error)],
}
}
pub(crate) fn unknown_range<T: Into<Vec<TokenRef<'s>>>>(
tokens: T,
error_range: SourceRange,
error: DiagnosticCode,
) -> Self {
Pattern::Unknown {
recovered: None,
tokens: tokens.into(),
errors: vec![SourceDiagnostic::new(error_range, error)],
}
}
pub(crate) fn unknown_errors<T: Into<Vec<TokenRef<'s>>>, E: Into<Vec<SourceDiagnostic>>>(
tokens: T,
errors: E,
) -> Self {
Pattern::Unknown {
recovered: None,
tokens: tokens.into(),
errors: errors.into(),
}
}
}
impl<'s> AstWalker<'s> for Pattern<'s> {
fn collect_diagnostics(&mut self, collector: &mut DiagnosticsCollector<'_, '_>) {
use Pattern::*;
match self {
Grouping(o, p, e) => {
o.collect_diagnostics(collector);
p.collect_diagnostics(collector);
e.collect_diagnostics(collector);
}
Literal(p, t) => {
p.collect_diagnostics(collector);
t.collect_diagnostics(collector);
}
Constant(t) => {
t.collect_diagnostics(collector);
}
Relation(o, p) => {
o.collect_diagnostics(collector);
p.collect_diagnostics(collector);
}
Range(s, o, e) => {
s.collect_diagnostics(collector);
o.collect_diagnostics(collector);
e.collect_diagnostics(collector);
}
Discard(t) => t.collect_diagnostics(collector),
Bind(p, t) => {
p.collect_diagnostics(collector);
t.collect_diagnostics(collector);
}
Record(s, p, e) => {
s.collect_diagnostics(collector);
for sub_pattern in p.iter_mut() {
sub_pattern.collect_diagnostics(collector);
}
e.collect_diagnostics(collector);
}
Array(s, p, e) => {
s.collect_diagnostics(collector);
for sub_pattern in p.iter_mut() {
sub_pattern.collect_diagnostics(collector);
}
e.collect_diagnostics(collector);
}
SpreadDiscard(_) => {}
And(l, o, r) => {
l.collect_diagnostics(collector);
o.collect_diagnostics(collector);
r.collect_diagnostics(collector);
}
Or(l, o, r) => {
l.collect_diagnostics(collector);
o.collect_diagnostics(collector);
r.collect_diagnostics(collector);
}
Not(o, p) => {
o.collect_diagnostics(collector);
p.collect_diagnostics(collector);
}
Unknown {
recovered,
tokens,
errors,
} => {
collector.append(errors);
tokens.collect_diagnostics(collector);
if let Some(mut recovered) = std::mem::take(recovered) {
recovered.collect_diagnostics(collector);
*self = *recovered;
}
}
}
}
fn range(&self) -> SourceRange {
use Pattern::*;
match self {
Grouping(o, _, e) | Record(o, _, e) | Array(o, _, e) => o.range.start..e.range.end,
Range(o, _, e) => o.range().start..e.range().end,
SpreadDiscard(pos) => *pos..*pos,
Relation(op, pattern) => op.range.start..pattern.range().end,
Discard(underscore) => underscore.range(),
Literal(None, token) | Bind(None, token) => token.range(),
Literal(Some(op), token) | Bind(Some(op), token) => op.range.start..token.range.end,
Constant(token) => token.range(),
And(left, _, right) | Or(left, _, right) => left.range().start..right.range().end,
Not(op, pattern) => op.range.start..pattern.range().end,
Unknown {
recovered,
tokens,
errors: _,
} => unknown_range(recovered, tokens),
}
}
}