use chumsky::prelude::*;
use crate::parsing::{
Span,
ast::{
Borrow, ContractAccessPath, ContractDefinition, ContractDefinitionContent, GenericList,
IdentName, Mutable, ParsingState, PubVisible, ValueType, borrow_parser,
contract_access_path_parser, contract_definition_parser, ident_name_parser, mutable_parser,
pub_visible_parser,
},
lexer::{Token, TokensData},
};
#[derive(Debug, Clone)]
pub struct FileContractDeclaration {
pub span: Span,
pub kind: ContractDeclarationKind,
}
#[derive(Debug, Clone)]
pub struct ContractDeclaration {
pub span: Span,
pub kind: ContractDeclarationKind,
pub definition: Option<ContractDefinition>,
}
#[derive(Debug, Clone)]
pub enum ContractDeclarationKind {
FunctionOnly(Box<FunctionContractDeclaration>),
LayoutOnly(LayoutContractDeclaration),
ConstantOnly(Box<ConstantContractDeclaration>),
AssociatedTypeOnly(Box<AssociatedTypeContractDeclaration>),
ExtensionOnly(Box<ExtensionContractDeclaration>),
FunctionAndLayout(Box<FunctionAndLayoutContractDeclaration>),
}
#[derive(Debug, Clone)]
pub struct ExtensionContractDeclaration {
pub span: Span,
pub target: ValueType,
}
#[derive(Debug, Clone)]
pub struct FunctionAndLayoutContractDeclaration {
pub span: Span,
pub function: FunctionContractDeclaration,
pub layout: LayoutContractDeclaration,
}
#[derive(Debug, Clone)]
pub enum LayoutContractDeclaration {
Void(VoidContractDeclaration),
Structure(StructureContractDeclaration),
Enum(EnumContractDeclaration),
Tuple(Box<TupleContractDeclaration>),
Trait(TraitContractDeclaration),
}
#[derive(Debug, Clone)]
pub struct FunctionContractDeclaration {
pub span: Span,
pub generic_list: Option<Box<GenericList>>,
pub argument_list: FunctionContractDeclarationArgumentList,
pub output: Option<ValueType>,
}
#[derive(Debug, Clone)]
pub struct FunctionContractDeclarationArgumentList {
pub span: Span,
pub self_argument: Option<FunctionContractDeclarationSelfArgument>,
pub other: Vec<FunctionContractDeclarationArgument>,
}
#[derive(Debug, Clone)]
pub struct FunctionContractDeclarationSelfArgument {
pub span: Span,
pub kind: FunctionContractDeclarationSelfArgumentKind,
}
#[derive(Debug, Clone)]
pub enum FunctionContractDeclarationSelfArgumentKind {
Borrow(Box<Borrow>),
Consume(Option<Mutable>),
}
#[derive(Debug, Clone)]
pub struct FunctionContractDeclarationArgument {
pub span: Span,
pub mutable: Option<Mutable>,
pub ident: IdentName,
pub value_type: ValueType,
}
#[derive(Debug, Clone)]
pub struct VoidContractDeclaration {
pub span: Span,
}
#[derive(Debug, Clone)]
pub struct StructureContractDeclaration {
pub span: Span,
}
#[derive(Debug, Clone)]
pub struct EnumContractDeclaration {
pub span: Span,
}
#[derive(Debug, Clone)]
pub struct TupleContractDeclaration {
pub span: Span,
pub items: (
TupleContractDeclarationItem,
Vec<TupleContractDeclarationItem>,
),
}
#[derive(Debug, Clone)]
pub struct TupleContractDeclarationItem {
pub span: Span,
pub pub_visible: Option<PubVisible>,
pub value_type: ValueType,
}
#[derive(Debug, Clone)]
pub struct ConstantContractDeclaration {
pub span: Span,
pub value_type: ValueType,
}
#[derive(Debug, Clone)]
pub struct AssociatedTypeContractDeclaration {
pub span: Span,
pub value_type: Option<ValueType>,
}
#[derive(Debug, Clone)]
pub struct TraitContractDeclaration {
pub span: Span,
pub supers: Vec<ContractAccessPath>,
}
pub(crate) fn file_contract_declaration_parser<'src, I, GLP, VTP>(
tokens_data: &'src TokensData,
state: &'src ParsingState,
generic_list_parser: GLP,
value_type_parser: VTP,
) -> impl Parser<'src, I, FileContractDeclaration, 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,
VTP: Parser<'src, I, ValueType, extra::Err<Rich<'src, Token, Span>>> + Clone + 'src,
{
just(Token::AsKw)
.ignore_then(contract_declaration_kind_parser(
tokens_data,
state,
generic_list_parser,
value_type_parser,
))
.map_with(|kind, ex| FileContractDeclaration {
span: ex.span(),
kind: kind,
})
}
pub(crate) fn contract_declaration_parser<'src, I, GLP, VTP, CDCP>(
tokens_data: &'src TokensData,
state: &'src ParsingState,
generic_list_parser: GLP,
value_type_parser: VTP,
contract_definition_content_parser: CDCP,
) -> impl Parser<'src, I, ContractDeclaration, 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,
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,
{
contract_declaration_kind_parser(tokens_data, state, generic_list_parser, value_type_parser)
.then(contract_definition_parser(contract_definition_content_parser).or_not())
.map_with(|(kind, def), ex| ContractDeclaration {
span: ex.span(),
kind: kind,
definition: def,
})
}
pub(crate) fn contract_declaration_kind_parser<'src, I, GLP, VTP>(
tokens_data: &'src TokensData,
state: &'src ParsingState,
generic_list_parser: GLP,
value_type_parser: VTP,
) -> impl Parser<'src, I, ContractDeclarationKind, 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,
VTP: Parser<'src, I, ValueType, extra::Err<Rich<'src, Token, Span>>> + Clone + 'src,
{
extension_contract_declaration_parser(value_type_parser.clone())
.map(|extension| ContractDeclarationKind::ExtensionOnly(Box::new(extension)))
.or(function_contract_declaration_parser(
tokens_data,
state,
generic_list_parser.clone(),
value_type_parser.clone(),
)
.then(
just(Token::Plus)
.ignore_then(layout_contract_declaration_parser(
tokens_data,
state,
generic_list_parser.clone(),
value_type_parser.clone(),
))
.or_not(),
)
.map_with(|(fcd, opt_lcd), ex| match opt_lcd {
Some(lcd) => ContractDeclarationKind::FunctionAndLayout(Box::new(
FunctionAndLayoutContractDeclaration {
span: ex.span(),
function: fcd,
layout: lcd,
},
)),
None => ContractDeclarationKind::FunctionOnly(Box::new(fcd)),
})
.or(layout_contract_declaration_parser(
tokens_data,
state,
generic_list_parser.clone(),
value_type_parser.clone(),
)
.then(
just(Token::Plus)
.ignore_then(function_contract_declaration_parser(
tokens_data,
state,
generic_list_parser,
value_type_parser.clone(),
))
.or_not(),
)
.map_with(|(lcd, opt_fcd), ex| match opt_fcd {
Some(fcd) => ContractDeclarationKind::FunctionAndLayout(Box::new(
FunctionAndLayoutContractDeclaration {
span: ex.span(),
function: fcd,
layout: lcd,
},
)),
None => ContractDeclarationKind::LayoutOnly(lcd),
}))
.or(
associated_type_contract_declaration_parser(value_type_parser.clone())
.map(|type_| ContractDeclarationKind::AssociatedTypeOnly(Box::new(type_))),
)
.or(constant_contract_declaration_parser(value_type_parser)
.map(|ccd| ContractDeclarationKind::ConstantOnly(Box::new(ccd)))))
}
pub(crate) fn associated_type_contract_declaration_parser<'src, I, VTP>(
value_type_parser: VTP,
) -> impl Parser<'src, I, AssociatedTypeContractDeclaration, 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::TypeKw)
.ignore_then(just(Token::Eq).ignore_then(value_type_parser).or_not())
.map_with(|value_type, extra| AssociatedTypeContractDeclaration {
span: extra.span(),
value_type,
})
}
pub(crate) fn extension_contract_declaration_parser<'src, I, VTP>(
value_type_parser: VTP,
) -> impl Parser<'src, I, ExtensionContractDeclaration, 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::ExtensionKw)
.ignore_then(just(Token::ForKw))
.ignore_then(value_type_parser)
.map_with(|target, extra| ExtensionContractDeclaration {
span: extra.span(),
target,
})
}
pub(crate) fn function_contract_declaration_parser<'src, I, GLP, VTP>(
tokens_data: &'src TokensData,
state: &'src ParsingState,
generic_list_parser: GLP,
value_type_parser: VTP,
) -> impl Parser<'src, I, FunctionContractDeclaration, 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,
VTP: Parser<'src, I, ValueType, extra::Err<Rich<'src, Token, Span>>> + Clone + 'src,
{
just(Token::FnKw)
.ignore_then(generic_list_parser.clone().map(|gl| Box::new(gl)).or_not())
.then(function_contract_declaration_argument_list_parser(
tokens_data,
state,
value_type_parser.clone(),
))
.then(just(Token::Arrow).ignore_then(value_type_parser).or_not())
.map_with(|((gl, al), op), ex| FunctionContractDeclaration {
span: ex.span(),
generic_list: gl,
argument_list: al,
output: op,
})
}
pub(crate) fn function_contract_declaration_argument_list_parser<'src, I, VTP>(
tokens_data: &'src TokensData,
state: &'src ParsingState,
value_type_parser: VTP,
) -> impl Parser<'src, I, FunctionContractDeclarationArgumentList, 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,
{
let other_arguments_parser =
function_contract_declaration_argument_parser(tokens_data, state, value_type_parser)
.separated_by(just(Token::Comma))
.allow_trailing()
.collect::<Vec<_>>();
crate::parsing::ast::empty_parentheses_parser()
.map(|span| FunctionContractDeclarationArgumentList {
span,
self_argument: None,
other: Vec::new(),
})
.or(
function_contract_declaration_self_argument_parser(tokens_data, state)
.then(
just(Token::Comma)
.ignore_then(other_arguments_parser.clone())
.or_not()
.map(|opt| opt.unwrap_or(Vec::new())),
)
.delimited_by(just(Token::OpenParen), just(Token::CloseParen))
.map_with(|(sa, oa), ex| FunctionContractDeclarationArgumentList {
span: ex.span(),
self_argument: Some(sa),
other: oa,
})
.or(other_arguments_parser
.delimited_by(just(Token::OpenParen), just(Token::CloseParen))
.map_with(|oa, ex| FunctionContractDeclarationArgumentList {
span: ex.span(),
self_argument: None,
other: oa,
})),
)
}
pub(crate) fn function_contract_declaration_self_argument_parser<'src, I>(
tokens_data: &'src TokensData,
state: &'src ParsingState,
) -> impl Parser<'src, I, FunctionContractDeclarationSelfArgument, extra::Err<Rich<'src, Token, Span>>>
+ Clone
where
I: Input<'src, Token = Token, Span = Span>,
{
function_contract_declaration_self_argument_kind_parser(tokens_data, state)
.then_ignore(just(Token::LowSelfKw))
.map_with(|kind, ex| FunctionContractDeclarationSelfArgument {
span: ex.span(),
kind: kind,
})
}
pub(crate) fn function_contract_declaration_self_argument_kind_parser<'src, I>(
tokens_data: &'src TokensData,
state: &'src ParsingState,
) -> impl Parser<
'src,
I,
FunctionContractDeclarationSelfArgumentKind,
extra::Err<Rich<'src, Token, Span>>,
> + Clone
where
I: Input<'src, Token = Token, Span = Span>,
{
borrow_parser(tokens_data, state)
.map(|borrow| FunctionContractDeclarationSelfArgumentKind::Borrow(Box::new(borrow)))
.or(mutable_parser()
.or_not()
.map(|mutable| FunctionContractDeclarationSelfArgumentKind::Consume(mutable)))
}
pub(crate) fn function_contract_declaration_argument_parser<'src, I, VTP>(
tokens_data: &'src TokensData,
state: &'src ParsingState,
value_type_parser: VTP,
) -> impl Parser<'src, I, FunctionContractDeclarationArgument, 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,
{
mutable_parser()
.or_not()
.then(ident_name_parser(tokens_data, state))
.then_ignore(just(Token::Colon))
.then(value_type_parser)
.map_with(
|((mutable, ident), vt), ex| FunctionContractDeclarationArgument {
span: ex.span(),
mutable: mutable,
ident: ident,
value_type: vt,
},
)
}
pub(crate) fn layout_contract_declaration_parser<'src, I, GLP, VTP>(
tokens_data: &'src TokensData,
state: &'src ParsingState,
generic_list_parser: GLP,
value_type_parser: VTP,
) -> impl Parser<'src, I, LayoutContractDeclaration, 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,
VTP: Parser<'src, I, ValueType, extra::Err<Rich<'src, Token, Span>>> + Clone + 'src,
{
void_contract_declaration_parser()
.map(|vcd| LayoutContractDeclaration::Void(vcd))
.or(tuple_contract_declaration_parser(value_type_parser)
.map(|tcd| LayoutContractDeclaration::Tuple(Box::new(tcd))))
.or(structure_contract_declaration_parser()
.map(|scd| LayoutContractDeclaration::Structure(scd)))
.or(enum_contract_declaration_parser().map(|ecd| LayoutContractDeclaration::Enum(ecd)))
.or(
trait_contract_declaration_parser(tokens_data, state, generic_list_parser)
.map(|tcd| LayoutContractDeclaration::Trait(tcd)),
)
}
pub(crate) fn void_contract_declaration_parser<'src, I>()
-> impl Parser<'src, I, VoidContractDeclaration, extra::Err<Rich<'src, Token, Span>>> + Clone
where
I: Input<'src, Token = Token, Span = Span>,
{
crate::parsing::ast::empty_parentheses_parser().map(|span| VoidContractDeclaration { span })
}
pub(crate) fn structure_contract_declaration_parser<'src, I>()
-> impl Parser<'src, I, StructureContractDeclaration, extra::Err<Rich<'src, Token, Span>>> + Clone
where
I: Input<'src, Token = Token, Span = Span>,
{
just(Token::StructKw)
.to_span()
.map(|span| StructureContractDeclaration { span })
}
pub(crate) fn enum_contract_declaration_parser<'src, I>()
-> impl Parser<'src, I, EnumContractDeclaration, extra::Err<Rich<'src, Token, Span>>> + Clone
where
I: Input<'src, Token = Token, Span = Span>,
{
just(Token::EnumKw)
.to_span()
.map(|span| EnumContractDeclaration { span })
}
pub(crate) fn tuple_contract_declaration_parser<'src, I, VTP>(
value_type_parser: VTP,
) -> impl Parser<'src, I, TupleContractDeclaration, 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,
{
tuple_contract_declaration_item_parser(value_type_parser.clone())
.then_ignore(just(Token::Comma))
.then(
tuple_contract_declaration_item_parser(value_type_parser)
.separated_by(just(Token::Comma))
.allow_trailing()
.collect::<Vec<_>>(),
)
.delimited_by(just(Token::OpenParen), just(Token::CloseParen))
.map_with(|(first, rest), ex| TupleContractDeclaration {
span: ex.span(),
items: (first, rest),
})
}
pub(crate) fn tuple_contract_declaration_item_parser<'src, I, VTP>(
value_type_parser: VTP,
) -> impl Parser<'src, I, TupleContractDeclarationItem, 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,
{
pub_visible_parser()
.or_not()
.then(value_type_parser)
.map_with(|(pv, vt), ex| TupleContractDeclarationItem {
span: ex.span(),
pub_visible: pv,
value_type: vt,
})
}
pub(crate) fn constant_contract_declaration_parser<'src, I, VTP>(
value_type_parser: VTP,
) -> impl Parser<'src, I, ConstantContractDeclaration, 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::ConstKw)
.ignore_then(value_type_parser)
.map_with(|vt, ex| ConstantContractDeclaration {
span: ex.span(),
value_type: vt,
})
}
pub(crate) fn trait_contract_declaration_parser<'src, I, GLP>(
tokens_data: &'src TokensData,
state: &'src ParsingState,
generic_list_parser: GLP,
) -> impl Parser<'src, I, TraitContractDeclaration, 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,
{
just(Token::TraitKw)
.ignore_then(
just(Token::Colon)
.ignore_then(
contract_access_path_parser(tokens_data, state, generic_list_parser)
.separated_by(just(Token::Plus))
.at_least(1)
.collect::<Vec<_>>(),
)
.or_not(),
)
.map_with(|supers, extra| TraitContractDeclaration {
span: extra.span(),
supers: supers.unwrap_or_default(),
})
}