use chumsky::prelude::*;
use crate::parsing::{
Span,
ast::{
ContractDefinitionContent, Expression, FileContractDeclaration, GenericList, ParsingState,
ValueType, contract_definition_content_parser,
contract_definition_content_with_file_contract_declarations_parser, expression_parser,
generic_list_parser, value_type_parser,
},
lexer::{Token, TokensData},
};
#[derive(Debug, Clone)]
pub struct File {
pub file_contract_declarations: Vec<FileContractDeclaration>,
pub contract_definition_content: ContractDefinitionContent,
}
pub(crate) fn complete_file_parser<'src, I>(
tokens_data: &'src TokensData,
state: &'src ParsingState,
) -> impl Parser<'src, I, File, extra::Err<Rich<'src, Token, Span>>> + Clone
where
I: Input<'src, Token = Token, Span = Span>,
{
let mut expression = Recursive::declare();
let mut generic_list = Recursive::declare();
let mut value_type = Recursive::declare();
let mut content = Recursive::declare();
expression.define(expression_parser(
tokens_data,
state,
generic_list.clone(),
content.clone(),
));
generic_list.define(generic_list_parser(tokens_data, state, content.clone()));
value_type.define(value_type_parser(
tokens_data,
state,
generic_list.clone(),
content.clone(),
));
content.define(contract_definition_content_parser(
tokens_data,
state,
expression.clone(),
generic_list.clone(),
value_type.clone(),
));
file_parser(
tokens_data,
state,
expression,
generic_list,
value_type,
content,
)
}
pub(crate) fn file_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, File, 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,
{
contract_definition_content_with_file_contract_declarations_parser(
tokens_data,
state,
expression_parser,
generic_list_parser,
value_type_parser,
contract_definition_content_parser,
)
.map(|(content, contracts)| File {
file_contract_declarations: contracts,
contract_definition_content: content,
})
.then_ignore(just(Token::Eof))
}