complete parser, but compile time is slow

Author: anand-bala

argus-core/src/lib.rs

@@ -17,6 +17,8 @@ pub mod signals;
 
 use std::time::Duration;
 
+pub use expr::*;
+pub use signals::Signal;
 use thiserror::Error;
 
 /// Errors generated by all Argus components.

argus-parser/Cargo.toml

@@ -3,7 +3,15 @@ name = "argus-parser"
 version = "0.1.0"
 edition = "2021"
 
+[lib]
+name = "argus_parser"
+
+[[bin]]
+name = "argus_parser"
+path = "src/main.rs"
+
+
 [dependencies]
 argus-core = { version = "0.1.0", path = "../argus-core" }
 ariadne = "0.3.0"
-chumsky = "1.0.0-alpha.4"
+chumsky = { version = "1.0.0-alpha.4", features = ["default", "label"] }

argus-parser/src/lexer.rs

@@ -6,16 +6,19 @@ pub type Span = SimpleSpan<usize>;
 pub type Output<'a> = Vec<(Token<'a>, Span)>;
 pub type Error<'a> = extra::Err<Rich<'a, char, Span>>;
 
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq)]
 pub enum Token<'src> {
     Semicolon,
     LBracket,
     RBracket,
     LParen,
     RParen,
     Comma,
+    DotDot,
     Bool(bool),
-    Num(&'src str),
+    Int(i64),
+    UInt(u64),
+    Float(f64),
     Ident(&'src str),
     Minus,
     Plus,
@@ -49,8 +52,11 @@ impl<'src> fmt::Display for Token<'src> {
             Token::LParen => write!(f, "("),
             Token::RParen => write!(f, ")"),
             Token::Comma => write!(f, ","),
+            Token::DotDot => write!(f, ".."),
             Token::Bool(val) => write!(f, "{}", val),
-            Token::Num(val) => write!(f, "{}", val),
+            Token::Int(val) => write!(f, "{}", val),
+            Token::UInt(val) => write!(f, "{}", val),
+            Token::Float(val) => write!(f, "{}", val),
             Token::Ident(ident) => write!(f, "{}", ident),
             Token::Minus => write!(f, "-"),
             Token::Plus => write!(f, "+"),
@@ -85,14 +91,22 @@ pub fn lexer<'src>() -> impl Parser<'src, &'src str, Output<'src>, Error<'src>>
 
     let exp = just('e').or(just('E')).then(one_of("+-").or_not()).then(digits);
 
-    let number = just('-')
+    let floating_number = just('-')
         .or_not()
-        .then(text::int(10))
+        .then(digits)
         .then(frac.or_not())
         .then(exp.or_not())
-        .map_slice(Token::Num)
+        .map_slice(|s: &str| Token::Float(s.parse().unwrap()))
         .boxed();
 
+    let signed_int = one_of("+-")
+        .or_not()
+        .then(digits)
+        .map_slice(|s: &str| Token::Int(s.parse().unwrap()));
+    let unsigned_int = digits.map_slice(|s: &str| Token::UInt(s.parse().unwrap()));
+
+    let number = choice((floating_number, signed_int, unsigned_int));
+
     // A parser for control characters (delimiters, semicolons, etc.)
     let ctrl = choice((
         just(";").to(Token::Semicolon),
@@ -101,6 +115,7 @@ pub fn lexer<'src>() -> impl Parser<'src, &'src str, Output<'src>, Error<'src>>
         just("(").to(Token::LParen),
         just(")").to(Token::RParen),
         just(",").to(Token::Comma),
+        just("..").to(Token::DotDot),
     ));
 
     // Lexer for operator symbols

argus-parser/src/lib.rs

@@ -1,5 +1,7 @@
 //! # Argus logic syntax
-#![allow(dead_code)]
 
 mod lexer;
 mod parser;
+
+pub use lexer::{lexer, Error as LexError, Span, Token};
+pub use parser::{parser, Expr, Interval};

argus-parser/src/main.rs

@@ -0,0 +1,54 @@
+use std::{env, fs};
+
+use argus_parser::lexer;
+// use crate::parser::{parser, Error as ParseError};
+use ariadne::{sources, Color, Label, Report, ReportKind};
+use chumsky::Parser;
+
+fn main() {
+    let src = env::args().nth(1).expect("Expected expression");
+
+    let (tokens, mut errs) = lexer().parse(src.as_str()).into_output_errors();
+
+    println!("*** Outputting tokens ***");
+    if let Some(tokens) = &tokens {
+        for token in tokens {
+            println!("-> {:?}", token);
+        }
+    }
+
+    let parse_errs = if let Some(tokens) = &tokens {
+        let (ast, parse_errs) = parser()
+            .map_with_span(|ast, span| (ast, span))
+            .parse(tokens.as_slice().spanned((src.len()..src.len()).into()))
+            .into_output_errors();
+
+        println!("*** Outputting tokens ***");
+        println!("{:#?}", ast);
+
+        parse_errs
+    } else {
+        Vec::new()
+    };
+
+    errs.into_iter()
+        .map(|e| e.map_token(|c| c.to_string()))
+        // .chain(parse_errs.into_iter().map(|e| e.map_token(|tok| tok.to_string())))
+        .for_each(|e| {
+            Report::build(ReportKind::Error, src.clone(), e.span().start)
+                .with_message(e.to_string())
+                .with_label(
+                    Label::new((src.clone(), e.span().into_range()))
+                        .with_message(e.reason().to_string())
+                        .with_color(Color::Red),
+                )
+                .with_labels(e.contexts().map(|(label, span)| {
+                    Label::new((src.clone(), span.into_range()))
+                        .with_message(format!("while parsing this {}", label))
+                        .with_color(Color::Yellow)
+                }))
+                .finish()
+                .print(sources([(src.clone(), src.clone())]))
+                .unwrap()
+        });
+}