172 lines
5.3 KiB
Rust
172 lines
5.3 KiB
Rust
use chumsky::prelude::*;
|
|
|
|
use crate::{
|
|
ast::{self, ArgBy, ArgName},
|
|
expr::UntypedExpr,
|
|
parser::{annotation, error::ParseError, expr, token::Token},
|
|
};
|
|
|
|
use super::function::param;
|
|
|
|
pub fn parser() -> impl Parser<Token, ast::UntypedDefinition, Error = ParseError> {
|
|
just(Token::Validator)
|
|
.ignore_then(select! {Token::Name {name} => name})
|
|
.then(
|
|
param(true)
|
|
.separated_by(just(Token::Comma))
|
|
.allow_trailing()
|
|
.delimited_by(just(Token::LeftParen), just(Token::RightParen))
|
|
.map_with_span(|arguments, span| (arguments, span))
|
|
.or_not(),
|
|
)
|
|
// so far: validator my_validator(arg1: Whatever)
|
|
.then(
|
|
select! {Token::Name {name} => name}
|
|
.then(args_and_body())
|
|
.map(|(name, mut function)| {
|
|
function.name = name;
|
|
|
|
function
|
|
})
|
|
.repeated()
|
|
.then(just(Token::Else).ignore_then(args_and_body()).or_not())
|
|
.delimited_by(just(Token::LeftBrace), just(Token::RightBrace)),
|
|
)
|
|
.map_with_span(
|
|
|((name, opt_extra_params), (handlers, opt_catch_all)), span| {
|
|
let (params, params_span) = opt_extra_params.unwrap_or((
|
|
vec![],
|
|
ast::Span {
|
|
start: 0,
|
|
end: span.start + "validator".len(),
|
|
},
|
|
));
|
|
|
|
ast::UntypedDefinition::Validator(ast::Validator {
|
|
doc: None,
|
|
name,
|
|
handlers,
|
|
location: ast::Span {
|
|
start: span.start,
|
|
// capture the span from the optional params
|
|
end: params_span.end,
|
|
},
|
|
params,
|
|
end_position: span.end - 1,
|
|
fallback: opt_catch_all.unwrap_or(ast::Function {
|
|
arguments: vec![ast::UntypedArg {
|
|
by: ArgBy::ByName(ArgName::Discarded {
|
|
name: "_ctx".to_string(),
|
|
label: "_ctx".to_string(),
|
|
location: ast::Span::empty(),
|
|
}),
|
|
location: ast::Span::empty(),
|
|
annotation: None,
|
|
doc: None,
|
|
is_validator_param: false,
|
|
}],
|
|
body: UntypedExpr::fail(None, ast::Span::empty()),
|
|
doc: None,
|
|
location: ast::Span::empty(),
|
|
end_position: span.end - 1,
|
|
name: "else".to_string(),
|
|
public: true,
|
|
return_annotation: None,
|
|
return_type: (),
|
|
on_test_failure: ast::OnTestFailure::FailImmediately,
|
|
}),
|
|
})
|
|
},
|
|
)
|
|
}
|
|
|
|
pub fn args_and_body() -> impl Parser<Token, ast::UntypedFunction, Error = ParseError> {
|
|
param(false)
|
|
.separated_by(just(Token::Comma))
|
|
.allow_trailing()
|
|
.delimited_by(just(Token::LeftParen), just(Token::RightParen))
|
|
.map_with_span(|arguments, span| (arguments, span))
|
|
.then(just(Token::RArrow).ignore_then(annotation()).or_not())
|
|
.then(
|
|
expr::sequence()
|
|
.or_not()
|
|
.delimited_by(just(Token::LeftBrace), just(Token::RightBrace)),
|
|
)
|
|
.map_with_span(
|
|
|(((arguments, args_span), return_annotation), body), span| ast::Function {
|
|
arguments,
|
|
body: body.unwrap_or_else(|| UntypedExpr::todo(None, span)),
|
|
doc: None,
|
|
location: ast::Span {
|
|
start: span.start,
|
|
end: return_annotation
|
|
.as_ref()
|
|
.map(|l| l.location().end)
|
|
.unwrap_or_else(|| args_span.end),
|
|
},
|
|
end_position: span.end - 1,
|
|
name: "temp".to_string(),
|
|
public: true,
|
|
return_annotation,
|
|
return_type: (),
|
|
on_test_failure: ast::OnTestFailure::FailImmediately,
|
|
},
|
|
)
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use crate::assert_definition;
|
|
|
|
#[test]
|
|
fn validator() {
|
|
assert_definition!(
|
|
r#"
|
|
validator hello {
|
|
spend (datum, rdmr, ctx) {
|
|
True
|
|
}
|
|
}
|
|
"#
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn double_validator() {
|
|
assert_definition!(
|
|
r#"
|
|
validator thing {
|
|
spend (datum, rdmr, ctx) {
|
|
True
|
|
}
|
|
|
|
mint (rdmr, ctx) {
|
|
True
|
|
}
|
|
}
|
|
"#
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn fallback() {
|
|
assert_definition!(
|
|
r#"
|
|
validator thing {
|
|
spend (datum, rdmr, ctx) {
|
|
True
|
|
}
|
|
|
|
mint (rdmr, ctx) {
|
|
True
|
|
}
|
|
|
|
else (_) {
|
|
fail
|
|
}
|
|
}
|
|
"#
|
|
);
|
|
}
|
|
}
|