use chumsky::prelude::*;
use crate::parsing::{
Span,
ast::{
ContractAccessPath, ContractDefinitionContent, IdentName, Lifetime, ParsingState,
ValueType, contract_access_path_parser, ident_name_parser, lifetime_parser,
value_type_parser,
},
lexer::{Token, TokensData},
};
#[derive(Debug, Clone)]
pub struct GenericList {
pub span: Span,
pub items: (GenericItem, Vec<GenericItem>),
}
#[derive(Debug, Clone)]
pub enum GenericItem {
Lifetime(Lifetime),
ValueType(ValueType),
}
impl GenericItem {
pub fn span(&self) -> Span {
match self {
GenericItem::Lifetime(item) => item.span,
GenericItem::ValueType(item) => item.span(),
}
}
}
#[derive(Debug, Clone)]
pub struct GenericDeclarationList {
pub span: Span,
pub items: (GenericDeclarationItem, Vec<GenericDeclarationItem>),
}
#[derive(Debug, Clone)]
pub enum GenericDeclarationItem {
Lifetime(Lifetime),
Type(Box<GenericDeclarationTypeItem>),
}
impl GenericDeclarationItem {
pub fn span(&self) -> Span {
match self {
GenericDeclarationItem::Lifetime(item) => item.span,
GenericDeclarationItem::Type(item) => item.span,
}
}
}
#[derive(Debug, Clone)]
pub struct GenericDeclarationTypeItem {
pub span: Span,
pub ident: IdentName,
pub constraints: Vec<GenericDeclarationTypeItemConstraint>,
}
#[derive(Debug, Clone)]
pub enum GenericDeclarationTypeItemConstraint {
Lifetime(Box<Lifetime>),
Type(Box<ContractAccessPath>),
}
impl GenericDeclarationTypeItemConstraint {
pub fn span(&self) -> Span {
match self {
Self::Lifetime(lt) => lt.span,
Self::Type(ty) => ty.span,
}
}
}
pub(crate) fn generic_list_parser<'src, I, CDCP>(
tokens_data: &'src TokensData,
state: &'src ParsingState,
contract_definition_content_parser: CDCP,
) -> impl Parser<'src, I, GenericList, 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,
{
recursive(|generic_list_parser| {
generic_item_parser(
tokens_data,
state,
generic_list_parser.clone(),
contract_definition_content_parser.clone(),
)
.then(
just(Token::Comma)
.ignore_then(generic_item_parser(
tokens_data,
state,
generic_list_parser,
contract_definition_content_parser,
))
.repeated()
.collect::<Vec<_>>(),
)
.then_ignore(just(Token::Comma).or_not())
.delimited_by(just(Token::LeftAngle), just(Token::RightAngle))
.map_with(|(first, rest), ex| GenericList {
span: ex.span(),
items: (first, rest),
})
})
}
pub(crate) fn generic_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, GenericItem, 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,
{
lifetime_parser(tokens_data, state)
.map(|lt| GenericItem::Lifetime(lt))
.or(value_type_parser(
tokens_data,
state,
generic_list_parser,
contract_definition_content_parser,
)
.map(|vt| GenericItem::ValueType(vt)))
}
pub(crate) fn generic_declaration_list_parser<'src, I, GLP>(
tokens_data: &'src TokensData,
state: &'src ParsingState,
generic_list_parser: GLP,
) -> impl Parser<'src, I, GenericDeclarationList, 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,
{
generic_declaration_item_parser(tokens_data, state, generic_list_parser.clone())
.then(
just(Token::Comma)
.ignore_then(generic_declaration_item_parser(
tokens_data,
state,
generic_list_parser,
))
.repeated()
.collect::<Vec<_>>(),
)
.then_ignore(just(Token::Comma).or_not())
.delimited_by(just(Token::LeftAngle), just(Token::RightAngle))
.map_with(|(first, rest), ex| GenericDeclarationList {
span: ex.span(),
items: (first, rest),
})
}
pub(crate) fn generic_declaration_item_parser<'src, I, GLP>(
tokens_data: &'src TokensData,
state: &'src ParsingState,
generic_list_parser: GLP,
) -> impl Parser<'src, I, GenericDeclarationItem, 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,
{
lifetime_parser(tokens_data, state)
.map(|lt| GenericDeclarationItem::Lifetime(lt))
.or(
generic_declaration_type_item_parser(tokens_data, state, generic_list_parser)
.map(|gdti| GenericDeclarationItem::Type(Box::new(gdti))),
)
}
pub(crate) fn generic_declaration_type_item_parser<'src, I, GLP>(
tokens_data: &'src TokensData,
state: &'src ParsingState,
generic_list_parser: GLP,
) -> impl Parser<'src, I, GenericDeclarationTypeItem, 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(
just(Token::Colon)
.ignore_then(
generic_declaration_type_item_constraint_parser(
tokens_data,
state,
generic_list_parser,
)
.separated_by(just(Token::Plus))
.at_least(1)
.collect::<Vec<_>>(),
)
.or_not()
.map(Option::unwrap_or_default),
)
.map_with(|(ident, constraints), ex| GenericDeclarationTypeItem {
span: ex.span(),
ident: ident,
constraints: constraints,
})
}
pub(crate) fn generic_declaration_type_item_constraint_parser<'src, I, GLP>(
tokens_data: &'src TokensData,
state: &'src ParsingState,
generic_list_parser: GLP,
) -> impl Parser<'src, I, GenericDeclarationTypeItemConstraint, 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,
{
lifetime_parser(tokens_data, state)
.map(|lt| GenericDeclarationTypeItemConstraint::Lifetime(Box::new(lt)))
.or(
contract_access_path_parser(tokens_data, state, generic_list_parser)
.map(|path| GenericDeclarationTypeItemConstraint::Type(Box::new(path))),
)
}