use super::prelude::*;
#[derive(Debug, Clone, PartialEq, strum::EnumIs)]
pub(crate) enum Statement<'s> {
Empty(TokenRef<'s>),
Expression(Box<Expression<'s>>, TokenRef<'s>),
BlockExpression(Box<Expression<'s>>),
Module(
Option<TokenRef<'s>>,
TokenRef<'s>,
TokenRef<'s>,
Box<Expression<'s>>,
),
Bind(
Option<TokenRef<'s>>,
TokenRef<'s>,
Box<Pattern<'s>>,
TokenRef<'s>,
Box<Expression<'s>>,
TokenRef<'s>,
),
Rebind(
Box<Pattern<'s>>,
TokenRef<'s>,
Box<Expression<'s>>,
TokenRef<'s>,
),
Const(
Option<TokenRef<'s>>,
TokenRef<'s>,
TokenRef<'s>,
TokenRef<'s>,
Box<Expression<'s>>,
TokenRef<'s>,
),
Assign(
Box<Expression<'s>>,
TokenRef<'s>,
Box<Expression<'s>>,
TokenRef<'s>,
),
Function(
Option<TokenRef<'s>>,
TokenRef<'s>,
TokenRef<'s>,
Option<ParameterList<'s>>,
Box<Expression<'s>>,
),
Return(TokenRef<'s>, Option<Box<Expression<'s>>>, TokenRef<'s>),
Break(TokenRef<'s>, Option<Box<Expression<'s>>>, TokenRef<'s>),
Continue(TokenRef<'s>, TokenRef<'s>),
Unknown {
tokens: Vec<TokenRef<'s>>,
errors: Vec<SourceDiagnostic>,
},
}
impl<'s> Statement<'s> {
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;
Statement::Unknown {
tokens,
errors: vec![SourceDiagnostic::new(range, error)],
}
}
#[allow(dead_code)]
pub(crate) fn unknown_range<T: Into<Vec<TokenRef<'s>>>>(
tokens: T,
error_range: SourceRange,
error: DiagnosticCode,
) -> Self {
Statement::Unknown {
tokens: tokens.into(),
errors: vec![SourceDiagnostic::new(error_range, error)],
}
}
#[allow(dead_code)]
pub(crate) fn unknown_errors<T: Into<Vec<TokenRef<'s>>>, E: Into<Vec<SourceDiagnostic>>>(
tokens: T,
errors: E,
) -> Self {
Statement::Unknown {
tokens: tokens.into(),
errors: errors.into(),
}
}
}
impl<'s> AstWalker<'s> for Statement<'s> {
fn collect_diagnostics(&mut self, collector: &mut DiagnosticsCollector<'_, '_>) {
use Statement::*;
match self {
Empty(c) => c.collect_diagnostics(collector),
Expression(expr, c) => {
expr.collect_diagnostics(collector);
c.collect_diagnostics(collector);
}
BlockExpression(expr) => expr.collect_diagnostics(collector),
Module(kw_pub, kw_mod, id, body) => {
kw_pub.collect_diagnostics(collector);
kw_mod.collect_diagnostics(collector);
id.collect_diagnostics(collector);
body.collect_diagnostics(collector);
}
Bind(kw_pub, kw_let, pattern, eq, expr, c) => {
kw_pub.collect_diagnostics(collector);
kw_let.collect_diagnostics(collector);
pattern.collect_diagnostics(collector);
eq.collect_diagnostics(collector);
expr.collect_diagnostics(collector);
c.collect_diagnostics(collector);
}
Rebind(pattern, eq, expr, c) => {
pattern.collect_diagnostics(collector);
eq.collect_diagnostics(collector);
expr.collect_diagnostics(collector);
c.collect_diagnostics(collector);
}
Const(kw_pub, kw_const, id, eq, expr, c) => {
kw_pub.collect_diagnostics(collector);
kw_const.collect_diagnostics(collector);
id.collect_diagnostics(collector);
eq.collect_diagnostics(collector);
expr.collect_diagnostics(collector);
c.collect_diagnostics(collector);
}
Assign(exp, eq, expr, c) => {
exp.collect_diagnostics(collector);
eq.collect_diagnostics(collector);
expr.collect_diagnostics(collector);
c.collect_diagnostics(collector);
}
Function(kw_pub, kw_fn, id, params, body) => {
kw_pub.collect_diagnostics(collector);
kw_fn.collect_diagnostics(collector);
id.collect_diagnostics(collector);
params.collect_diagnostics(collector);
body.collect_diagnostics(collector);
}
Return(kw, expr, c) => {
kw.collect_diagnostics(collector);
expr.collect_diagnostics(collector);
c.collect_diagnostics(collector);
}
Break(kw, expr, c) => {
kw.collect_diagnostics(collector);
expr.collect_diagnostics(collector);
c.collect_diagnostics(collector);
}
Continue(kw, c) => {
kw.collect_diagnostics(collector);
c.collect_diagnostics(collector);
}
Unknown { tokens, errors } => {
collector.append(errors);
tokens.collect_diagnostics(collector);
}
}
}
fn range(&self) -> SourceRange {
use Statement::*;
match self {
Empty(c) => c.range(),
Expression(expr, c) => expr.range().start..c.range.end,
BlockExpression(expr) => expr.range(),
Module(kw_pub, kw_mod, _, body) => {
kw_pub.as_ref().unwrap_or(kw_mod).range.start..body.range().end
}
Bind(kw_pub, kw_let, _, _, _, c) => {
kw_pub.as_ref().unwrap_or(kw_let).range.start..c.range.end
}
Rebind(pattern, _, _, c) => pattern.range().start..c.range.end,
Const(kw_pub, kw_const, _, _, _, c) => {
kw_pub.as_ref().unwrap_or(kw_const).range.start..c.range.end
}
Assign(exp, _, _, c) => exp.range().start..c.range.end,
Function(kw_pub, kw_fn, _, _, body) => {
kw_pub.as_ref().unwrap_or(kw_fn).range.start..body.range().end
}
Return(kw, _, c) | Break(kw, _, c) | Continue(kw, c) => kw.range.start..c.range.end,
Unknown { tokens, errors: _ } => tokens.range(),
}
}
}