use chumsky::prelude::*;
use crate::parsing::{
Span,
ast::{
ContractAccessDeclaration, ContractAccessPath, Expression, FileContractDeclaration,
GenericList, IdentName, ParsingState, PubVisible, Statement, ValueType,
contract_access_declaration_parser, contract_access_path_parser,
file_contract_declaration_parser, ident_name_parser, pub_visible_parser, statement_parser,
},
lexer::{Token, TokensData},
};
#[derive(Debug, Clone)]
pub struct ContractDefinition {
pub span: Span,
pub content: ContractDefinitionContent,
}
#[derive(Debug, Clone, Default)]
pub struct ContractDefinitionContent {
pub contract_accesses: Vec<ContractAccessDeclaration>,
pub field_declarations: Vec<StructureFieldDeclaration>,
pub variant_declarations: Vec<EnumVariantDeclaration>,
pub trait_implementations: Vec<TraitImplementationDeclaration>,
pub statements: Vec<Statement>,
}
#[derive(Debug, Clone)]
pub struct StructureFieldDeclaration {
pub span: Span,
pub pub_visible: Option<PubVisible>,
pub ident: IdentName,
pub value_type: ValueType,
pub default_expression: Option<Expression>,
}
#[derive(Debug, Clone)]
pub struct EnumVariantDeclaration {
pub span: Span,
pub ident: IdentName,
pub value_type: Option<ValueType>,
}
#[derive(Debug, Clone)]
pub struct TraitImplementationDeclaration {
pub span: Span,
pub trait_path: ContractAccessPath,
pub definition: Option<ContractDefinition>,
}
pub(crate) fn contract_definition_parser<'src, I, CDCP>(
contract_definition_content_parser: CDCP,
) -> impl Parser<'src, I, ContractDefinition, extra::Err<Rich<'src, Token, Span>>> + Clone
where
I: Input<'src, Token = Token, Span = Span>,
CDCP: Parser<'src, I, ContractDefinitionContent, extra::Err<Rich<'src, Token, Span>>>
+ Clone
+ 'src,
{
contract_definition_content_parser
.delimited_by(just(Token::OpenBrace), just(Token::CloseBrace))
.map_with(|content, ex| ContractDefinition {
span: ex.span(),
content: content,
})
}
#[derive(Debug, Clone)]
enum ContractDefinitionContentItem {
Acs(ContractAccessDeclaration),
Fld(StructureFieldDeclaration),
Var(EnumVariantDeclaration),
Impl(TraitImplementationDeclaration),
Statement(Statement),
}
impl ContractDefinitionContentItem {
fn push_to(self, content: &mut ContractDefinitionContent) {
match self {
ContractDefinitionContentItem::Acs(cad) => content.contract_accesses.push(cad),
ContractDefinitionContentItem::Fld(sfd) => content.field_declarations.push(sfd),
ContractDefinitionContentItem::Var(evd) => content.variant_declarations.push(evd),
ContractDefinitionContentItem::Impl(implementation) => {
content.trait_implementations.push(implementation)
}
ContractDefinitionContentItem::Statement(statement) => {
content.statements.push(statement)
}
}
}
}
fn contract_definition_content_item_parser<'src, I, EP, GLP, VTP, CDCP>(
tokens_data: &'src TokensData,
state: &'src ParsingState,
expression_parser: EP,
generic_list_parser: GLP,
value_type_parser: VTP,
contract_definition_content_parser: CDCP,
) -> impl Parser<'src, I, ContractDefinitionContentItem, 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,
VTP: Parser<'src, I, ValueType, extra::Err<Rich<'src, Token, Span>>> + Clone + 'src,
CDCP: Parser<'src, I, ContractDefinitionContent, extra::Err<Rich<'src, Token, Span>>>
+ Clone
+ 'src,
{
choice((
contract_access_declaration_parser(
tokens_data,
state,
generic_list_parser.clone(),
value_type_parser.clone(),
contract_definition_content_parser.clone(),
)
.map(ContractDefinitionContentItem::Acs),
structure_field_declaration_parser(
tokens_data,
state,
expression_parser.clone(),
value_type_parser.clone(),
)
.map(ContractDefinitionContentItem::Fld),
enum_variant_declaration_parser(tokens_data, state, value_type_parser)
.map(ContractDefinitionContentItem::Var),
trait_implementation_declaration_parser(
tokens_data,
state,
generic_list_parser.clone(),
contract_definition_content_parser.clone(),
)
.map(ContractDefinitionContentItem::Impl),
statement_parser(
tokens_data,
state,
expression_parser,
generic_list_parser,
contract_definition_content_parser,
)
.map(ContractDefinitionContentItem::Statement),
))
}
pub(crate) fn contract_definition_content_parser<'src, I, EP, GLP, VTP>(
tokens_data: &'src TokensData,
state: &'src ParsingState,
expression_parser: EP,
generic_list_parser: GLP,
value_type_parser: VTP,
) -> impl Parser<'src, I, ContractDefinitionContent, 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,
VTP: Parser<'src, I, ValueType, extra::Err<Rich<'src, Token, Span>>> + Clone + 'src,
{
recursive(|contract_definition_content_parser| {
empty().map(|_| ContractDefinitionContent::default()).foldl(
contract_definition_content_item_parser(
tokens_data,
state,
expression_parser,
generic_list_parser,
value_type_parser,
contract_definition_content_parser,
)
.then_ignore(just(Token::Semicolon).or_not())
.repeated(),
|mut content, item| {
item.push_to(&mut content);
content
},
)
})
}
pub(crate) fn contract_definition_content_with_file_contract_declarations_parser<
'src,
I,
EP,
GLP,
VTP,
CDCP,
>(
tokens_data: &'src TokensData,
state: &'src ParsingState,
expression_parser: EP,
generic_list_parser: GLP,
value_type_parser: VTP,
contract_definition_content_parser: CDCP,
) -> impl Parser<
'src,
I,
(ContractDefinitionContent, Vec<FileContractDeclaration>),
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,
VTP: Parser<'src, I, ValueType, extra::Err<Rich<'src, Token, Span>>> + Clone + 'src,
CDCP: Parser<'src, I, ContractDefinitionContent, extra::Err<Rich<'src, Token, Span>>>
+ Clone
+ 'src,
{
enum Item {
Content(ContractDefinitionContentItem),
FileContract(FileContractDeclaration),
}
let item_parser = choice((
contract_definition_content_item_parser(
tokens_data,
state,
expression_parser.clone(),
generic_list_parser.clone(),
value_type_parser.clone(),
contract_definition_content_parser.clone(),
)
.map(Item::Content),
file_contract_declaration_parser(
tokens_data,
state,
generic_list_parser,
value_type_parser,
)
.map(Item::FileContract),
));
empty()
.map(|_| (ContractDefinitionContent::default(), Vec::new()))
.foldl(
item_parser
.then_ignore(just(Token::Semicolon).or_not())
.repeated(),
|(mut content, mut file_contracts), item| {
match item {
Item::Content(item) => item.push_to(&mut content),
Item::FileContract(fc) => file_contracts.push(fc),
}
(content, file_contracts)
},
)
}
pub(crate) fn trait_implementation_declaration_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, TraitImplementationDeclaration, 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,
{
just(Token::ImplKw)
.ignore_then(contract_access_path_parser(
tokens_data,
state,
generic_list_parser,
))
.then(contract_definition_parser(contract_definition_content_parser).or_not())
.map_with(
|(trait_path, definition), extra| TraitImplementationDeclaration {
span: extra.span(),
trait_path,
definition,
},
)
}
pub(crate) fn structure_field_declaration_parser<'src, I, EP, VTP>(
tokens_data: &'src TokensData,
state: &'src ParsingState,
expression_parser: EP,
value_type_parser: VTP,
) -> impl Parser<'src, I, StructureFieldDeclaration, 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,
VTP: Parser<'src, I, ValueType, extra::Err<Rich<'src, Token, Span>>> + Clone + 'src,
{
pub_visible_parser()
.or_not()
.then_ignore(just(Token::FldKw))
.then(ident_name_parser(tokens_data, state))
.then_ignore(just(Token::Colon))
.then(value_type_parser)
.then(just(Token::Eq).ignore_then(expression_parser).or_not())
.map_with(
|(((pv, ident), vt), def_expr), ex| StructureFieldDeclaration {
span: ex.span(),
pub_visible: pv,
ident: ident,
value_type: vt,
default_expression: def_expr,
},
)
}
pub(crate) fn enum_variant_declaration_parser<'src, I, VTP>(
tokens_data: &'src TokensData,
state: &'src ParsingState,
value_type_parser: VTP,
) -> impl Parser<'src, I, EnumVariantDeclaration, extra::Err<Rich<'src, Token, Span>>> + Clone
where
I: Input<'src, Token = Token, Span = Span>,
VTP: Parser<'src, I, ValueType, extra::Err<Rich<'src, Token, Span>>> + Clone + 'src,
{
just(Token::VarKw)
.ignore_then(ident_name_parser(tokens_data, state))
.then(value_type_parser.or_not())
.map_with(|(ident, vt), ex| EnumVariantDeclaration {
span: ex.span(),
ident: ident,
value_type: vt,
})
}