research/argus
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

chore(argus): bump chumsky alpha version

Browse source
This commit is contained in:
Anand Balakrishnan 2023-10-11 14:19:06 -07:00
parent d68527029f
commit 9d0f7ef2ee
3 changed files with 21 additions and 17 deletions
Download patch file Download diff file Expand all files Collapse all files

2
argus/Cargo.toml
View file

@ -11,7 +11,7 @@ readme.workspace = true
[dependencies]
argus-derive = { version = "0.1.0", path = "../argus-derive" }
ariadne = { version = "0.3.0", optional = true }
chumsky = { version = "1.0.0-alpha.4", features = ["default", "label"] }
chumsky = { version = "1.0.0-alpha.6", features = ["default", "label"] }
derive_more = "0.99.17"
enum_dispatch = "0.3.12"
itertools = "0.11"

18
argus/src/parser/lexer.rs
View file

@ -85,7 +85,7 @@ impl<'src> fmt::Display for Token<'src> {
pub fn lexer<'src>() -> impl Parser<'src, &'src str, Output<'src>, Error<'src>> {
// A parser for numbers
let digits = text::digits(10).slice();
let digits = text::digits(10).to_slice();
let frac = just('.').then(digits);
@ -94,20 +94,23 @@ pub fn lexer<'src>() -> impl Parser<'src, &'src str, Output<'src>, Error<'src>>
let floating_number = just('-')
.or_not()
.then(digits)
.then(choice((frac.then(exp).slice(), frac.slice(), exp.slice())))
.then(choice((frac.then(exp).to_slice(), frac.to_slice(), exp.to_slice())))
// .then(frac.or_not())
// .then(exp.or_not())
.map_slice(|s: &str| Token::Float(s.parse().unwrap()))
.to_slice()
.map(|s: &str| Token::Float(s.parse().unwrap()))
.boxed();
let signed_int = one_of("+-")
// .or_not()
.then(digits)
.then(frac.not().or(exp.not()))
.map_slice(|s: &str| Token::Int(s.parse().unwrap()));
.to_slice()
.map(|s: &str| Token::Int(s.parse().unwrap()));
let unsigned_int = digits
.then(frac.not().or(exp.not()))
.map_slice(|s: &str| Token::UInt(s.parse().unwrap()));
.to_slice()
.map(|s: &str| Token::UInt(s.parse().unwrap()));
let number = choice((floating_number, signed_int, unsigned_int));
@ -163,7 +166,8 @@ pub fn lexer<'src>() -> impl Parser<'src, &'src str, Output<'src>, Error<'src>>
let quoted_ident = just('"')
.ignore_then(none_of('"').repeated())
.then_ignore(just('"'))
.map_slice(Token::Ident);
.to_slice()
.map(Token::Ident);
// A parser for identifiers and keywords
let ident = text::ident().map(|ident: &str| match ident {
@ -192,7 +196,7 @@ pub fn lexer<'src>() -> impl Parser<'src, &'src str, Output<'src>, Error<'src>>
let comment = just("//").then(any().and_is(just('\n').not()).repeated()).padded();
token
.map_with_span(|tok, span| (tok, span))
.map_with(|tok, e| (tok, e.span()))
.padded_by(comment.repeated())
.padded()
// If we encounter an error, skip and attempt to lex the next character as a token instead

18
argus/src/parser/syntax.rs
View file

@ -204,7 +204,7 @@ fn num_expr_parser<'tokens, 'src: 'tokens>(
let num_atom = var
.or(num_literal)
.map_with_span(|expr, span: Span| (expr, span))
.map_with(|expr, e| (expr, e.span()))
// Atoms can also just be normal expressions, but surrounded with parentheses
.or(num_expr.clone().delimited_by(just(Token::LParen), just(Token::RParen)))
// Attempt to recover anything that looks like a parenthesised expression but contains errors
@ -217,9 +217,9 @@ fn num_expr_parser<'tokens, 'src: 'tokens>(
.boxed();
let neg_op = just(Token::Minus)
.map_with_span(|_, span: Span| (UnaryOps::Neg, span))
.map_with(|_, e| (UnaryOps::Neg, e.span()))
.repeated()
.foldr(num_atom, |op, rhs| {
.foldr(num_atom, |op: Spanned<UnaryOps>, rhs: Spanned<Expr<'src>>| {
let span = op.1.start..rhs.1.end;
(Expr::unary_op(op.0, rhs, None), span.into())
});
@ -265,7 +265,7 @@ pub fn parser<'tokens, 'src: 'tokens>(
Token::UInt(val) => Expr::UInt(val),
Token::Float(val) => Expr::Float(val),
}
.map_with_span(|lit, span: Span| (lit, span));
.map_with(|lit, e| (lit, e.span()));
let sep = just(Token::Comma).or(just(Token::DotDot));
num_literal
@ -273,13 +273,13 @@ pub fn parser<'tokens, 'src: 'tokens>(
.then_ignore(sep)
.then(num_literal.or_not())
.delimited_by(just(Token::LBracket), just(Token::RBracket))
.map_with_span(|(a, b), span| {
.map_with(|(a, b), e| {
(
Interval {
a: a.map(Box::new),
b: b.map(Box::new),
},
span,
e.span(),
)
})
.boxed()
@ -317,7 +317,7 @@ pub fn parser<'tokens, 'src: 'tokens>(
.labelled("atomic predicate");
let atom = relational_op
.or(var.or(literal).map_with_span(|expr, span| (expr, span)))
.or(var.or(literal).map_with(|expr, e| (expr, e.span())))
// Atoms can also just be normal expressions, but surrounded with parentheses
.or(expr.clone().delimited_by(just(Token::LParen), just(Token::RParen)))
// Attempt to recover anything that looks like a parenthesised expression but contains errors
@ -330,7 +330,7 @@ pub fn parser<'tokens, 'src: 'tokens>(
.boxed();
let not_op = just(Token::Not)
.map_with_span(|_, span: Span| (UnaryOps::Not, span))
.map_with(|_, e| (UnaryOps::Not, e.span()))
.repeated()
.foldr(atom, |op, rhs| {
let span = op.1.start..rhs.1.end;
@ -344,7 +344,7 @@ pub fn parser<'tokens, 'src: 'tokens>(
just(Token::Eventually).to(UnaryOps::Eventually),
just(Token::Always).to(UnaryOps::Always),
));
op.map_with_span(|op, span: Span| (op, span))
op.map_with(|op, e| (op, e.span()))
.then(interval.clone().or_not())
.repeated()
.foldr(not_op, |(op, interval), rhs| {