use chumsky::prelude::*;
use crate::parsing::{
Span,
ast::{
AccessExpression, ContractDefinitionContent, Expression, GenericList, IdentName, Mutable,
ParsingState, ValueType, access_expression_parser, ident_name_parser, mutable_parser,
value_type_parser,
},
lexer::{Token, TokensData},
};
#[derive(Debug, Clone)]
pub enum Statement {
Declaration(Box<DeclarationStatement>),
Assignment(Box<AssignmentStatement>),
Expression(Box<Expression>),
Return(Box<ReturnStatement>),
}
#[derive(Debug, Clone)]
pub struct DeclarationStatement {
pub span: Span,
pub item: DeclarationStatementItem,
pub expression: Option<Expression>,
}
#[derive(Debug, Clone)]
pub enum DeclarationStatementItem {
Ident(Box<DeclarationStatementIdentItem>),
Group(Box<DeclarationStatementGroupItem>),
}
#[derive(Debug, Clone)]
pub struct DeclarationStatementGroupItem {
pub span: Span,
pub items: (DeclarationStatementItem, Vec<DeclarationStatementItem>),
}
#[derive(Debug, Clone)]
pub struct DeclarationStatementIdentItem {
pub span: Span,
pub mutable: Option<Mutable>,
pub ident: IdentName,
pub value_type: Option<ValueType>,
}
#[derive(Debug, Clone)]
pub struct AssignmentStatement {
pub span: Span,
pub dereference_count: usize,
pub access: AccessExpression,
pub operator: AssignmentOperator,
pub expression: Expression,
}
#[derive(Debug, Clone)]
pub struct AssignmentOperator {
pub span: Span,
pub kind: AssignmentOperatorKind,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AssignmentOperatorKind {
Set,
Add,
Sub,
Multiply,
Divide,
ShiftLeft,
ShiftRight,
}
#[derive(Debug, Clone)]
pub struct ReturnStatement {
pub span: Span,
pub expression: Option<Expression>,
}
pub(crate) fn statement_parser<'src, I, EP, GLP, CDCP>(
tokens_data: &'src TokensData,
state: &'src ParsingState,
expression_parser: EP,
generic_list_parser: GLP,
contract_definition_content_parser: CDCP,
) -> impl Parser<'src, I, Statement, extra::Err<Rich<'src, Token, Span>>> + Clone
where
I: Input<'src, Token = Token, Span = Span>,
EP: Parser<'src, I, Expression, extra::Err<Rich<'src, Token, Span>>> + Clone + 'src,
GLP: Parser<'src, I, GenericList, extra::Err<Rich<'src, Token, Span>>> + Clone + 'src,
CDCP: Parser<'src, I, ContractDefinitionContent, extra::Err<Rich<'src, Token, Span>>>
+ Clone
+ 'src,
{
choice((
assignment_statement_parser(
tokens_data,
state,
expression_parser.clone(),
generic_list_parser.clone(),
contract_definition_content_parser.clone(),
)
.map(|assignment| Statement::Assignment(Box::new(assignment))),
expression_parser
.clone()
.map(|expression| Statement::Expression(Box::new(expression))),
declaration_statement_parser(
tokens_data,
state,
expression_parser.clone(),
generic_list_parser,
contract_definition_content_parser,
)
.map(|ds| Statement::Declaration(Box::new(ds))),
return_statement_parser(expression_parser).map(|rs| Statement::Return(Box::new(rs))),
))
}
pub(crate) fn declaration_statement_parser<'src, I, EP, GLP, CDCP>(
tokens_data: &'src TokensData,
state: &'src ParsingState,
expression_parser: EP,
generic_list_parser: GLP,
contract_definition_content_parser: CDCP,
) -> impl Parser<'src, I, DeclarationStatement, extra::Err<Rich<'src, Token, Span>>> + Clone
where
I: Input<'src, Token = Token, Span = Span>,
EP: Parser<'src, I, Expression, extra::Err<Rich<'src, Token, Span>>> + Clone + 'src,
GLP: Parser<'src, I, GenericList, extra::Err<Rich<'src, Token, Span>>> + Clone + 'src,
CDCP: Parser<'src, I, ContractDefinitionContent, extra::Err<Rich<'src, Token, Span>>>
+ Clone
+ 'src,
{
just(Token::LetKw)
.ignore_then(declaration_statement_item_parser(
tokens_data,
state,
generic_list_parser,
contract_definition_content_parser,
))
.then(just(Token::Eq).ignore_then(expression_parser).or_not())
.map_with(|(dsi, expression), ex| DeclarationStatement {
span: ex.span(),
item: dsi,
expression: expression,
})
}
pub(crate) fn declaration_statement_item_parser<'src, I, GLP, CDCP>(
tokens_data: &'src TokensData,
state: &'src ParsingState,
generic_list_parser: GLP,
contract_definition_content_parser: CDCP,
) -> impl Parser<'src, I, DeclarationStatementItem, extra::Err<Rich<'src, Token, Span>>> + Clone
where
I: Input<'src, Token = Token, Span = Span>,
GLP: Parser<'src, I, GenericList, extra::Err<Rich<'src, Token, Span>>> + Clone + 'src,
CDCP: Parser<'src, I, ContractDefinitionContent, extra::Err<Rich<'src, Token, Span>>>
+ Clone
+ 'src,
{
recursive(|declaration_statement_item_parser| {
let group_parser = declaration_statement_item_parser
.clone()
.then(
just(Token::Comma).ignore_then(
declaration_statement_item_parser
.separated_by(just(Token::Comma))
.allow_trailing()
.collect::<Vec<_>>(),
),
)
.delimited_by(just(Token::OpenParen), just(Token::CloseParen))
.map_with(|(first, rest), ex| DeclarationStatementGroupItem {
span: ex.span(),
items: (first, rest),
});
group_parser
.map(|dsgi| DeclarationStatementItem::Group(Box::new(dsgi)))
.or(declaration_statement_ident_item_parser(
tokens_data,
state,
generic_list_parser,
contract_definition_content_parser,
)
.map(|dsii| DeclarationStatementItem::Ident(Box::new(dsii))))
})
}
pub(crate) fn declaration_statement_ident_item_parser<'src, I, GLP, CDCP>(
tokens_data: &'src TokensData,
state: &'src ParsingState,
generic_list_parser: GLP,
contract_definition_content_parser: CDCP,
) -> impl Parser<'src, I, DeclarationStatementIdentItem, extra::Err<Rich<'src, Token, Span>>> + Clone
where
I: Input<'src, Token = Token, Span = Span>,
GLP: Parser<'src, I, GenericList, extra::Err<Rich<'src, Token, Span>>> + Clone + 'src,
CDCP: Parser<'src, I, ContractDefinitionContent, extra::Err<Rich<'src, Token, Span>>>
+ Clone
+ 'src,
{
mutable_parser()
.or_not()
.then(ident_name_parser(tokens_data, state))
.then(
just(Token::Colon)
.ignore_then(value_type_parser(
tokens_data,
state,
generic_list_parser,
contract_definition_content_parser,
))
.or_not(),
)
.map_with(|((mutable, ident), vt), ex| DeclarationStatementIdentItem {
span: ex.span(),
mutable: mutable,
ident: ident,
value_type: vt,
})
}
pub(crate) fn assignment_statement_parser<'src, I, EP, GLP, CDCP>(
tokens_data: &'src TokensData,
state: &'src ParsingState,
expression_parser: EP,
generic_list_parser: GLP,
contract_definition_content_parser: CDCP,
) -> impl Parser<'src, I, AssignmentStatement, extra::Err<Rich<'src, Token, Span>>> + Clone
where
I: Input<'src, Token = Token, Span = Span>,
EP: Parser<'src, I, Expression, extra::Err<Rich<'src, Token, Span>>> + Clone + 'src,
GLP: Parser<'src, I, GenericList, extra::Err<Rich<'src, Token, Span>>> + Clone + 'src,
CDCP: Parser<'src, I, ContractDefinitionContent, extra::Err<Rich<'src, Token, Span>>>
+ Clone
+ 'src,
{
just(Token::Asterisk)
.repeated()
.collect::<Vec<_>>()
.then(access_expression_parser(
tokens_data,
state,
expression_parser.clone(),
generic_list_parser,
contract_definition_content_parser,
))
.then(assignment_operator_parser())
.then(expression_parser)
.map_with(
|(((dereferences, access), operator), expression), ex| AssignmentStatement {
span: ex.span(),
dereference_count: dereferences.len(),
access,
operator,
expression,
},
)
}
pub(crate) fn assignment_operator_parser<'src, I>()
-> impl Parser<'src, I, AssignmentOperator, extra::Err<Rich<'src, Token, Span>>> + Clone
where
I: Input<'src, Token = Token, Span = Span>,
{
select! {
Token::Eq => AssignmentOperatorKind::Set,
Token::PlusEq => AssignmentOperatorKind::Add,
Token::MinusEq => AssignmentOperatorKind::Sub,
Token::AsteriskEq => AssignmentOperatorKind::Multiply,
Token::SlashEq => AssignmentOperatorKind::Divide,
Token::ShiftLeftEq => AssignmentOperatorKind::ShiftLeft,
Token::ShiftRightEq => AssignmentOperatorKind::ShiftRight,
}
.map_with(|kind, ex| AssignmentOperator {
span: ex.span(),
kind,
})
}
pub(crate) fn return_statement_parser<'src, I, EP>(
expression_parser: EP,
) -> impl Parser<'src, I, ReturnStatement, extra::Err<Rich<'src, Token, Span>>> + Clone
where
I: Input<'src, Token = Token, Span = Span>,
EP: Parser<'src, I, Expression, extra::Err<Rich<'src, Token, Span>>> + Clone + 'src,
{
just(Token::ReturnKw)
.ignore_then(expression_parser.or_not())
.map_with(|expression, ex| ReturnStatement {
span: ex.span(),
expression: expression,
})
}