use chumsky::prelude::*;
use crate::parsing::{
Span,
ast::{
ContractDefinition, ContractDefinitionContent, Expression, IfExpression, LoopExpression,
ParsingState, StringId, VoidValueType, WhileExpression, contract_definition_parser,
if_expression_parser, loop_expression_parser, while_expression_parser,
},
lexer::{Token, TokensData},
};
#[derive(Debug, Clone)]
pub enum ValueExpression {
Void(VoidValueType),
Bool(BoolValueExpression),
Char(CharValueExpression),
IntAny(Box<IntAnyValueExpression>),
Int8(Int8ValueExpression),
Int16(Int16ValueExpression),
Int32(Int32ValueExpression),
Int64(Int64ValueExpression),
Isize(IsizeValueExpression),
Uint8(Uint8ValueExpression),
Uint16(Uint16ValueExpression),
Uint32(Uint32ValueExpression),
Uint64(Uint64ValueExpression),
Usize(UsizeValueExpression),
FloatAny(FloatAnyValueExpression),
Float32(Float32ValueExpression),
Float64(Float64ValueExpression),
String(StringValueExpression),
Array(Box<ArrayValueExpression>),
Contract(Box<ContractDefinition>),
Tuple(Box<TupleValueExpression>),
If(Box<IfExpression>),
While(Box<WhileExpression>),
Loop(Box<LoopExpression>),
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct BoolValueExpression {
pub span: Span,
pub value: bool,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct CharValueExpression {
pub span: Span,
pub value: char,
}
#[derive(Debug, Clone)]
pub struct ArrayValueExpression {
pub span: Span,
pub kind: ArrayValueExpressionKind,
}
#[derive(Debug, Clone)]
pub enum ArrayValueExpressionKind {
DefaultSized(ArrayValueExpressionDefaultSized),
ExpressionList(ArrayValueExpressionExpressionList),
}
#[derive(Debug, Clone)]
pub struct ArrayValueExpressionDefaultSized {
pub default_expression: Expression,
pub size_expression: Expression,
}
#[derive(Debug, Clone)]
pub struct ArrayValueExpressionExpressionList {
pub expressions: Vec<Expression>,
}
#[derive(Debug, Clone)]
pub struct IntAnyValueExpression {
pub span: Span,
pub value: i128,
}
#[derive(Debug, Clone)]
pub struct Int8ValueExpression {
pub span: Span,
pub value: i8,
}
#[derive(Debug, Clone)]
pub struct Int16ValueExpression {
pub span: Span,
pub value: i16,
}
#[derive(Debug, Clone)]
pub struct Int32ValueExpression {
pub span: Span,
pub value: i32,
}
#[derive(Debug, Clone)]
pub struct Int64ValueExpression {
pub span: Span,
pub value: i64,
}
#[derive(Debug, Clone)]
pub struct IsizeValueExpression {
pub span: Span,
pub value: isize,
}
#[derive(Debug, Clone)]
pub struct Uint8ValueExpression {
pub span: Span,
pub value: u8,
}
#[derive(Debug, Clone)]
pub struct Uint16ValueExpression {
pub span: Span,
pub value: u16,
}
#[derive(Debug, Clone)]
pub struct Uint32ValueExpression {
pub span: Span,
pub value: u32,
}
#[derive(Debug, Clone)]
pub struct Uint64ValueExpression {
pub span: Span,
pub value: u64,
}
#[derive(Debug, Clone)]
pub struct UsizeValueExpression {
pub span: Span,
pub value: usize,
}
#[derive(Debug, Clone)]
pub struct FloatAnyValueExpression {
pub span: Span,
pub value: f64,
}
#[derive(Debug, Clone)]
pub struct Float32ValueExpression {
pub span: Span,
pub value: f32,
}
#[derive(Debug, Clone)]
pub struct Float64ValueExpression {
pub span: Span,
pub value: f64,
}
#[derive(Debug, Clone)]
pub struct StringValueExpression {
pub span: Span,
pub string: StringId,
}
#[derive(Debug, Clone)]
pub struct TupleValueExpression {
pub span: Span,
pub item_expressions: (Expression, Vec<Expression>),
}
pub(crate) fn value_expression_parser<'src, I, EP, CDCP>(
tokens_data: &'src TokensData,
state: &'src ParsingState,
expression_parser: EP,
contract_definition_content_parser: CDCP,
) -> impl Parser<'src, I, ValueExpression, 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,
CDCP: Parser<'src, I, ContractDefinitionContent, extra::Err<Rich<'src, Token, Span>>>
+ Clone
+ 'src,
{
enum Value {
Void,
Bool(bool),
Char(char),
IntAny(i128),
Int8(i8),
Int16(i16),
Int32(i32),
Int64(i64),
Isize(isize),
Uint8(u8),
Uint16(u16),
Uint32(u32),
Uint64(u64),
Usize(usize),
FloatAny(f64),
Float32(f32),
Float64(f64),
String(StringId),
Array(Box<ArrayValueExpression>),
Contract(Box<ContractDefinition>),
Tuple(Box<TupleValueExpression>),
If(Box<IfExpression>),
While(Box<WhileExpression>),
Loop(Box<LoopExpression>),
}
select! {
Token::TrueKw => Value::Bool(true),
Token::FalseKw => Value::Bool(false),
Token::Char(value) => Value::Char(value),
Token::IntAny(id) => Value::IntAny(tokens_data.get_i128(id)),
Token::Int8(value) => Value::Int8(value),
Token::Int16(value) => Value::Int16(value),
Token::Int32(value) => Value::Int32(value),
Token::Int64(value) => Value::Int64(value),
Token::Isize(value) => Value::Isize(value),
Token::Uint8(value) => Value::Uint8(value),
Token::Uint16(value) => Value::Uint16(value),
Token::Uint32(value) => Value::Uint32(value),
Token::Uint64(value) => Value::Uint64(value),
Token::Usize(value) => Value::Usize(value),
Token::FloatAny(value) => Value::FloatAny(value),
Token::Float32(value) => Value::Float32(value),
Token::Float64(value) => Value::Float64(value),
Token::String(id) => Value::String(state.get_string_id(tokens_data.get_string(id)))
}
.or(crate::parsing::ast::empty_parentheses_parser().map(|_| Value::Void))
.or(tuple_value_expression_parser(expression_parser.clone())
.map(|tve| Value::Tuple(Box::new(tve))))
.or(array_value_expression_parser(expression_parser.clone())
.map(|ave| Value::Array(Box::new(ave))))
.or(
contract_definition_parser(contract_definition_content_parser)
.map(|cd| Value::Contract(Box::new(cd))),
)
.or(if_expression_parser(expression_parser.clone()).map(|ie| Value::If(Box::new(ie))))
.or(while_expression_parser(expression_parser.clone()).map(|we| Value::While(Box::new(we))))
.or(loop_expression_parser(expression_parser).map(|le| Value::Loop(Box::new(le))))
.map_with(|value, ex| {
let span = ex.span();
match value {
Value::Void => ValueExpression::Void(VoidValueType { span }),
Value::Bool(value) => ValueExpression::Bool(BoolValueExpression { span, value }),
Value::Char(value) => ValueExpression::Char(CharValueExpression { span, value }),
Value::IntAny(value) => {
ValueExpression::IntAny(Box::new(IntAnyValueExpression { span, value }))
}
Value::Int8(value) => ValueExpression::Int8(Int8ValueExpression { span, value }),
Value::Int16(value) => ValueExpression::Int16(Int16ValueExpression { span, value }),
Value::Int32(value) => ValueExpression::Int32(Int32ValueExpression { span, value }),
Value::Int64(value) => ValueExpression::Int64(Int64ValueExpression { span, value }),
Value::Isize(value) => ValueExpression::Isize(IsizeValueExpression { span, value }),
Value::Uint8(value) => ValueExpression::Uint8(Uint8ValueExpression { span, value }),
Value::Uint16(value) => ValueExpression::Uint16(Uint16ValueExpression { span, value }),
Value::Uint32(value) => ValueExpression::Uint32(Uint32ValueExpression { span, value }),
Value::Uint64(value) => ValueExpression::Uint64(Uint64ValueExpression { span, value }),
Value::Usize(value) => ValueExpression::Usize(UsizeValueExpression { span, value }),
Value::FloatAny(value) => {
ValueExpression::FloatAny(FloatAnyValueExpression { span, value })
}
Value::Float32(value) => {
ValueExpression::Float32(Float32ValueExpression { span, value })
}
Value::Float64(value) => {
ValueExpression::Float64(Float64ValueExpression { span, value })
}
Value::String(id) => {
ValueExpression::String(StringValueExpression { span, string: id })
}
Value::Array(ave) => ValueExpression::Array(ave),
Value::Contract(cd) => ValueExpression::Contract(cd),
Value::Tuple(tve) => ValueExpression::Tuple(tve),
Value::If(ie) => ValueExpression::If(ie),
Value::While(we) => ValueExpression::While(we),
Value::Loop(le) => ValueExpression::Loop(le),
}
})
}
pub(crate) fn string_value_expression_parser<'src, I>(
tokens_data: &'src TokensData,
state: &'src ParsingState,
) -> impl Parser<'src, I, StringValueExpression, extra::Err<Rich<'src, Token, Span>>> + Clone
where
I: Input<'src, Token = Token, Span = Span>,
{
select!(Token::String(id) => state.get_string_id(tokens_data.get_string(id))).map_with(
|id, ex| StringValueExpression {
span: ex.span(),
string: id,
},
)
}
pub(crate) fn tuple_value_expression_parser<'src, I>(
expression_parser: impl Parser<'src, I, Expression, extra::Err<Rich<'src, Token, Span>>> + Clone,
) -> impl Parser<'src, I, TupleValueExpression, extra::Err<Rich<'src, Token, Span>>> + Clone
where
I: Input<'src, Token = Token, Span = Span>,
{
expression_parser
.clone()
.then(
just(Token::Comma).ignore_then(
expression_parser
.separated_by(just(Token::Comma))
.allow_trailing()
.collect::<Vec<_>>(),
),
)
.delimited_by(just(Token::OpenParen), just(Token::CloseParen))
.map_with(|(first, rest), ex| TupleValueExpression {
span: ex.span(),
item_expressions: (first, rest),
})
}
pub(crate) fn array_value_expression_parser<'src, I>(
expression_parser: impl Parser<'src, I, Expression, extra::Err<Rich<'src, Token, Span>>> + Clone,
) -> impl Parser<'src, I, ArrayValueExpression, extra::Err<Rich<'src, Token, Span>>> + Clone
where
I: Input<'src, Token = Token, Span = Span>,
{
array_value_expression_default_sized_parser(expression_parser.clone())
.map(|(span, aveds)| ArrayValueExpression {
span: span,
kind: ArrayValueExpressionKind::DefaultSized(aveds),
})
.or(
array_value_expression_expression_list_parser(expression_parser).map(
|(span, aveel)| ArrayValueExpression {
span: span,
kind: ArrayValueExpressionKind::ExpressionList(aveel),
},
),
)
}
pub(crate) fn array_value_expression_default_sized_parser<'src, I>(
expression_parser: impl Parser<'src, I, Expression, extra::Err<Rich<'src, Token, Span>>> + Clone,
) -> impl Parser<'src, I, (Span, ArrayValueExpressionDefaultSized), extra::Err<Rich<'src, Token, Span>>>
+ Clone
where
I: Input<'src, Token = Token, Span = Span>,
{
expression_parser
.clone()
.then_ignore(just(Token::Semicolon))
.then(expression_parser)
.delimited_by(just(Token::OpenBracket), just(Token::CloseBracket))
.map_with(|(default, size), ex| {
(
ex.span(),
ArrayValueExpressionDefaultSized {
default_expression: default,
size_expression: size,
},
)
})
}
pub(crate) fn array_value_expression_expression_list_parser<'src, I>(
expression_parser: impl Parser<'src, I, Expression, extra::Err<Rich<'src, Token, Span>>> + Clone,
) -> impl Parser<
'src,
I,
(Span, ArrayValueExpressionExpressionList),
extra::Err<Rich<'src, Token, Span>>,
> + Clone
where
I: Input<'src, Token = Token, Span = Span>,
{
expression_parser
.separated_by(just(Token::Comma))
.allow_trailing()
.collect::<Vec<_>>()
.delimited_by(just(Token::OpenBracket), just(Token::CloseBracket))
.map_with(|expressions, ex| {
(
ex.span(),
ArrayValueExpressionExpressionList { expressions },
)
})
}