Tests added for ASTExpression literals

src/ast/ast_node.rs

@@ -0,0 +1,3 @@
+pub trait ASTNode {
+    fn repr_c(&self) -> String;
+}

src/ast/evaluable.rs

@@ -1,4 +0,0 @@
-/// A node that is evaluable to type `T`
-pub trait Evaluable<T> {
-    fn evaluate(&self) -> T;
-}

src/ast/expression.rs

@@ -1,23 +1,6 @@
 use crate::ast::literal::Literal;
+use crate::ast::ast_node::ASTNode;
 
 pub enum Expression {
-    Identifier(String),
     Literal(Literal),
-
-    Addition(Box<Expression>, Box<Expression>),
-    Subtraction(Box<Expression>, Box<Expression>),
-    Multiplication(Box<Expression>, Box<Expression>),
-    Division(Box<Expression>, Box<Expression>),
-    Remainder(Box<Expression>, Box<Expression>),
-    Negation(Box<Expression>),
-
-    And(Box<Expression>, Box<Expression>),
-    Or(Box<Expression>, Box<Expression>),
-
-    Equal(Box<Expression>, Box<Expression>),
-    NotEqual(Box<Expression>, Box<Expression>),
-    Less(Box<Expression>, Box<Expression>),
-    LessEqual(Box<Expression>, Box<Expression>),
-    Greater(Box<Expression>, Box<Expression>),
-    GreaterEqual(Box<Expression>, Box<Expression>),
 }

src/ast/literal.rs

@@ -1,5 +1,7 @@
+#[derive(Debug)]
 pub enum Literal {
     Int(i64),
     Float(f64),
     Bool(bool),
 }
+

src/ast/mod.rs

@@ -1,4 +1,4 @@
-mod evaluable;
+mod ast_node;
 pub mod literal;
 pub mod expression;
 pub mod logical;

src/expressions.lalrpop

@@ -1,9 +1,18 @@
-use crate::ast::expression::Expression;
+use crate::ast::literal::Literal;
+
 
 grammar;
 
-pub ASTExpression: Expression = {
+pub ASTExpression: Literal = {
-    <s: Identifier> => Expression::Identifier(String::from(s)),
+    <a: Atom> => a,
 };
 
-pub Identifier: &'input str = <s:r"[_a-zA-Z][_a-zA-Z0-9]*"> => s;
+pub Atom: Literal = {
+    <n:Int> => Literal::Int(n),
+    <f: Float> => Literal::Float(f),
+    "(" <f: Atom> ")" => f,
+};
+
+pub Int: i64 = <s:r"[0-9]|[1-9][0-9]*"> => s.parse::<i64>().unwrap();
+pub Float: f64 = <s:r"[+-]?([0-9]*[.][0-9]+|[0-9]*([.][0-9]+)?[Ee][+-]?[1-9][0-9]*)"> => s.parse::<f64>().unwrap();
+// pub Identifier: &'input str = <s:r"[_a-zA-Z][_a-zA-Z0-9]*"> => s;

src/literals.lalrpop

@@ -1,14 +0,0 @@
-use std::str::FromStr;
-use crate::ast::literal::Literal;
-
-grammar;
-
-pub Atom: Literal = {
-    <n:Int> => Literal::Int(n),
-    <f: Float> => Literal::Float(f),
-    "(" <f: Atom> ")" => f,
-};
-
-pub Int: i64 = <s:r"[0-9]|[1-9][0-9]*"> => i64::from_str(s).unwrap();
-pub Float: f64 = <s:r"[+-]?([0-9]*[.][0-9]+|[0-9]*([.][0-9]+)?[Ee][+-]?[1-9][0-9]*)"> => f64::from_str(s).unwrap();
-//pub StringLiteral: &'input str = <s:"\"[^\"]\""> => s;

src/main.rs

@@ -1,10 +1,8 @@
 use lalrpop_util::lalrpop_mod;
-
 mod ast;
 mod optimising;
 mod tests;
 
-lalrpop_mod!(pub literals);
 lalrpop_mod!(pub expressions);
 
 fn main() {

src/tests/expressions.rs

@@ -1,16 +1,16 @@
-
+//
-
+//
-#[test]
+// #[test]
-fn identifiers() {
+// fn identifiers() {
-    use crate::expressions::IdentifierParser as IdentParser;
+//     use crate::expressions::IdentifierParser as IdentParser;
-    assert!(IdentParser::new().parse("a").is_ok());
+//     assert!(IdentParser::new().parse("a").is_ok());
-    assert!(IdentParser::new().parse("_").is_ok());
+//     assert!(IdentParser::new().parse("_").is_ok());
-    assert!(IdentParser::new().parse("a_a_a_").is_ok());
+//     assert!(IdentParser::new().parse("a_a_a_").is_ok());
-    assert!(IdentParser::new().parse("_0").is_ok());
+//     assert!(IdentParser::new().parse("_0").is_ok());
-    assert!(IdentParser::new().parse("_a").is_ok());
+//     assert!(IdentParser::new().parse("_a").is_ok());
-    assert!(IdentParser::new().parse("__").is_ok());
+//     assert!(IdentParser::new().parse("__").is_ok());
-
+//
-    assert!(IdentParser::new().parse("0").is_err());
+//     assert!(IdentParser::new().parse("0").is_err());
-    assert!(IdentParser::new().parse("0123456").is_err());
+//     assert!(IdentParser::new().parse("0123456").is_err());
-    assert!(IdentParser::new().parse("0aaaa").is_err());
+//     assert!(IdentParser::new().parse("0aaaa").is_err());
-}
+// }

src/tests/literals.rs

@@ -1,6 +1,5 @@
-use crate::literals::AtomParser as Parser;
+use crate::ast::literal::Literal;
-use std::any::type_name_of_val;
+use crate::expressions::AtomParser as Parser;
-use std::convert::identity;
 
 #[test]
 fn int_literals() {
@@ -28,7 +27,7 @@ fn test_float_dots() {
 
 #[test]
 fn test_float_exps() {
-    let parser = crate::literals::FloatParser::new();
+    let parser = crate::expressions::FloatParser::new();
 
     let valid_float_exps: Vec<&str> = vec![
         "1e1", "-1e1", "1e-1", "-1e-1", "1.1e1", "1.1e-1", "-1.1e1", "-1.1e-1", ".1e1", "-.1e1",
@@ -36,14 +35,46 @@ fn test_float_exps() {
         "-.1E1", "-.1E-1",
     ];
 
-    let invalid_float_exps: Vec<&str> = vec!["AAAAAAAAAAAAAAA", "1.e1", "1e1.1", "1.1e1.1", "-1e1.1", "1e-1.1"];
+    let invalid_float_exps: Vec<&str> = vec![
+        "AAAAAAAAAAAAAAA",
+        "1.e1",
+        "1e1.1",
+        "1.1e1.1",
+        "-1e1.1",
+        "1e-1.1",
+    ];
 
     assert!(
         valid_float_exps
             .into_iter()
             .all(|s| parser.parse(s).is_ok())
     );
-    assert!(invalid_float_exps
+    assert!(
+        invalid_float_exps
             .into_iter()
-        .all(|s| parser.parse(s).is_err()));
+            .all(|s| parser.parse(s).is_err())
+    );
+}
+
+#[test]
+fn test_atom_parser() {
+    use crate::ast::literal::Literal;
+    let parser = crate::expressions::AtomParser::new();
+
+    let parsed_int_atom = parser.parse("123");
+    assert!(matches!(parsed_int_atom, Ok(Literal::Int(_))));
+
+    let parsed_int_atom = parser.parse("-1.12345");
+    assert!(matches!(parsed_int_atom, Ok(Literal::Float(_))));
+}
+
+#[test]
+fn test_expr_parser() {
+    let parser = crate::expressions::ASTExpressionParser::new();
+
+    let parsed_int_expr = parser.parse("123");
+    assert!(matches!(parsed_int_expr, Ok(Literal::Int(_))));
+
+    let parsed_int_expr = parser.parse("-4.20E-69");
+    assert!(matches!(parsed_int_expr, Ok(Literal::Float(_))));
 }