use chumsky::prelude::*;
use crate::parsing::{
Span,
ast::{
ContractDefinitionContent, Expression, GenericList, IdentName, ParsingState,
ValueExpression, ident_name_parser, value_expression_parser,
},
lexer::{Token, TokensData},
};
#[derive(Debug, Clone)]
pub struct AccessExpression {
pub span: Span,
pub entry: AccessExpressionEntry,
pub accessors: Vec<AccessExpressionAccessor>,
}
#[derive(Debug, Clone)]
pub enum AccessExpressionEntry {
ValueExpression(ValueExpression),
Parenthesized(Box<Expression>),
Ident(AccessExpressionIdent),
Self_(AccessExpressionSelfEntry),
}
#[derive(Debug, Clone)]
pub struct AccessExpressionSelfEntry {
pub span: Span,
}
#[derive(Debug, Clone)]
pub enum AccessExpressionAccessor {
Next(Box<AccessExpressionNextAccessor>),
Sub(Box<AccessExpressionSubAccessor>),
}
#[derive(Debug, Clone)]
pub enum AccessExpressionSubAccessor {
Arguments(AccessExpressionAccessorArguments),
Index(Expression),
}
#[derive(Debug, Clone)]
pub struct AccessExpressionAccessorArguments {
pub span: Span,
pub expressions: Vec<Expression>,
}
#[derive(Debug, Clone)]
pub enum AccessExpressionNextAccessor {
Item(AccessExpressionNextAccessorItem),
Ident(AccessExpressionIdent),
}
#[derive(Debug, Clone)]
pub struct AccessExpressionNextAccessorItem {
pub span: Span,
pub index: usize,
}
#[derive(Debug, Clone)]
pub struct AccessExpressionIdent {
pub span: Span,
pub ident: IdentName,
pub generic_list: Option<GenericList>,
}
pub(crate) fn access_expression_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, AccessExpression, 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,
{
access_expression_entry_parser(
tokens_data,
state,
expression_parser.clone(),
generic_list_parser.clone(),
contract_definition_content_parser,
)
.then(
choice((
just(Token::Dot).ignore_then(
access_expression_next_accessor_parser(tokens_data, state, generic_list_parser)
.map(|aena| AccessExpressionAccessor::Next(Box::new(aena))),
),
access_expression_sub_accessor_parser(expression_parser)
.map(|aesa| AccessExpressionAccessor::Sub(Box::new(aesa))),
))
.repeated()
.collect::<Vec<_>>(),
)
.map_with(|(entry, accessors), ex| AccessExpression {
span: ex.span(),
entry: entry,
accessors: accessors,
})
}
pub(crate) fn access_expression_entry_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, AccessExpressionEntry, 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,
{
access_expression_ident_parser(tokens_data, state, generic_list_parser)
.map(|aei| AccessExpressionEntry::Ident(aei))
.or(expression_parser
.clone()
.delimited_by(just(Token::OpenParen), just(Token::CloseParen))
.map(|expression| AccessExpressionEntry::Parenthesized(Box::new(expression))))
.or(value_expression_parser(
tokens_data,
state,
expression_parser,
contract_definition_content_parser,
)
.map(|ve| AccessExpressionEntry::ValueExpression(ve)))
.or(access_expression_self_entry_parser().map(|aese| AccessExpressionEntry::Self_(aese)))
}
pub(crate) fn access_expression_self_entry_parser<'src, I>()
-> impl Parser<'src, I, AccessExpressionSelfEntry, extra::Err<Rich<'src, Token, Span>>> + Clone
where
I: Input<'src, Token = Token, Span = Span>,
{
just(Token::LowSelfKw)
.to_span()
.map(|span| AccessExpressionSelfEntry { span: span })
}
pub(crate) fn access_expression_next_accessor_parser<'src, I, GLP>(
tokens_data: &'src TokensData,
state: &'src ParsingState,
generic_list_parser: GLP,
) -> impl Parser<'src, I, AccessExpressionNextAccessor, 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,
{
access_expression_ident_parser(tokens_data, state, generic_list_parser)
.map(|aei| AccessExpressionNextAccessor::Ident(aei))
.or(access_expression_next_accessor_item_parser(tokens_data)
.map(|aenai| AccessExpressionNextAccessor::Item(aenai)))
}
pub(crate) fn access_expression_sub_accessor_parser<'src, I, EP>(
expression_parser: EP,
) -> impl Parser<'src, I, AccessExpressionSubAccessor, 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,
{
access_expression_accessor_arguments_parser(expression_parser.clone())
.map(|aeaa| AccessExpressionSubAccessor::Arguments(aeaa))
.or(access_expression_accessor_index_parser(expression_parser)
.map(|expression| AccessExpressionSubAccessor::Index(expression)))
}
pub(crate) fn access_expression_accessor_index_parser<'src, I, EP>(
expression_parser: EP,
) -> impl Parser<'src, I, Expression, 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,
{
expression_parser.delimited_by(just(Token::OpenBracket), just(Token::CloseBracket))
}
pub(crate) fn access_expression_accessor_arguments_parser<'src, I, EP>(
expression_parser: EP,
) -> impl Parser<'src, I, AccessExpressionAccessorArguments, 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,
{
crate::parsing::ast::empty_parentheses_parser()
.map(|span| AccessExpressionAccessorArguments {
span,
expressions: Vec::new(),
})
.or(expression_parser
.separated_by(just(Token::Comma))
.allow_trailing()
.collect::<Vec<_>>()
.delimited_by(just(Token::OpenParen), just(Token::CloseParen))
.map_with(|expressions, ex| AccessExpressionAccessorArguments {
span: ex.span(),
expressions,
}))
}
pub(crate) fn access_expression_next_accessor_item_parser<'src, I>(
tokens_data: &'src TokensData,
) -> impl Parser<'src, I, AccessExpressionNextAccessorItem, extra::Err<Rich<'src, Token, Span>>> + Clone
where
I: Input<'src, Token = Token, Span = Span>,
{
select!(Token::IntAny(id) => tokens_data.get_i128(id))
.try_map(|value, span| {
usize::try_from(value)
.map_err(|_| Rich::custom(span, "tuple index does not fit in usize"))
})
.map_with(|idx, ex| AccessExpressionNextAccessorItem {
span: ex.span(),
index: idx,
})
}
pub(crate) fn access_expression_ident_parser<'src, I, GLP>(
tokens_data: &'src TokensData,
state: &'src ParsingState,
generic_list_parser: GLP,
) -> impl Parser<'src, I, AccessExpressionIdent, 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,
{
ident_name_parser(tokens_data, state)
.then(generic_list_parser.or_not())
.map_with(|(ident, gl), ex| AccessExpressionIdent {
span: ex.span(),
ident: ident,
generic_list: gl,
})
}