From 75ecfb4e86bb4e0110bae04163db298c09fdff40 Mon Sep 17 00:00:00 2001 From: greg Date: Fri, 23 Feb 2018 03:04:19 -0800 Subject: [PATCH] Move bx! macro up to mod.rs And make use of it in parser --- src/schala_lang/mod.rs | 5 +++++ src/schala_lang/parsing.rs | 34 ++++++++++++++++----------------- src/schala_lang/typechecking.rs | 5 ----- 3 files changed, 22 insertions(+), 22 deletions(-) diff --git a/src/schala_lang/mod.rs b/src/schala_lang/mod.rs index 5d4a147..c2a24e2 100644 --- a/src/schala_lang/mod.rs +++ b/src/schala_lang/mod.rs @@ -1,6 +1,11 @@ use itertools::Itertools; use schala_lib::{ProgrammingLanguageInterface, EvalOptions, TraceArtifact, ReplOutput}; +macro_rules! bx { + ($e:expr) => { Box::new($e) } +} + + mod tokenizing; mod parsing; //mod type_check; diff --git a/src/schala_lang/parsing.rs b/src/schala_lang/parsing.rs index bb6e3c9..a266380 100644 --- a/src/schala_lang/parsing.rs +++ b/src/schala_lang/parsing.rs @@ -568,7 +568,7 @@ impl Parser { }; let rhs = self.precedence_expr(new_precedence)?; let operation = Operation(op_str); - lhs = Expression(ExpressionType::BinExp(operation, Box::new(lhs), Box::new(rhs)), None); + lhs = Expression(ExpressionType::BinExp(operation, bx!(lhs), bx!(rhs)), None); } self.parse_level -= 1; Ok(lhs) @@ -583,7 +583,7 @@ impl Parser { }; let expr = self.primary()?; Ok(Expression( - ExpressionType::PrefixExp(Operation(op_str), Box::new(expr)), + ExpressionType::PrefixExp(Operation(op_str), bx!(expr)), None)) }, _ => self.primary() @@ -628,13 +628,13 @@ impl Parser { LParen => { let arguments = self.call_expr()?; //TODO make this be more general - let f = Box::new(Expression(Value(identifier, vec![]), None)); + let f = bx!(Expression(Value(identifier, vec![]), None)); Expression(Call { f, arguments }, None) }, LSquareBracket => { let indexers = self.index_expr()?; Expression(Index { - indexee: Box::new(Expression(Value(identifier, vec![]), None)), + indexee: bx!(Expression(Value(identifier, vec![]), None)), indexers, }, None) } @@ -671,7 +671,7 @@ impl Parser { })()?; let then_clause = self.block()?; let else_clause = self.else_clause()?; - Ok(Expression(ExpressionType::IfExpression(Box::new(condition), then_clause, else_clause), None)) + Ok(Expression(ExpressionType::IfExpression(bx!(condition), then_clause, else_clause), None)) }); parse_method!(else_clause(&mut self) -> ParseResult>> { @@ -694,7 +694,7 @@ impl Parser { //expect!(self, LCurlyBrace, "Expected '{'"); let body = self.match_body()?; //expect!(self, RCurlyBrace, "Expected '}'"); - Ok(Expression(ExpressionType::MatchExpression(Box::new(expr), body), None)) + Ok(Expression(ExpressionType::MatchExpression(bx!(expr), body), None)) }); parse_method!(match_body(&mut self) -> ParseResult> { @@ -871,10 +871,10 @@ mod parse_tests { ($string:expr) => { assert!(parse(tokenize($string)).0.is_err()) } } macro_rules! binexp { - ($op:expr, $lhs:expr, $rhs:expr) => { BinExp(op!($op), Box::new(Expression($lhs, None)), Box::new(Expression($rhs, None))) } + ($op:expr, $lhs:expr, $rhs:expr) => { BinExp(op!($op), bx!(Expression($lhs, None)), bx!(Expression($rhs, None))) } } macro_rules! prefexp { - ($op:expr, $lhs:expr) => { PrefixExp(op!($op), Box::new(Expression($lhs, None))) } + ($op:expr, $lhs:expr) => { PrefixExp(op!($op), bx!(Expression($lhs, None))) } } macro_rules! op { ($op:expr) => { Operation(Rc::new($op.to_string())) } @@ -957,7 +957,7 @@ mod parse_tests { //parse_test!("a[b]", AST(vec![Expression( //parse_test!("a[]", <- TODO THIS NEEDS TO FAIL //parse_test!(damn()[a] ,<- TODO needs to succeed - parse_test!("a[b,c]", AST(vec![exprstatement!(Index { indexee: Box::new(ex!(val!("a"))), indexers: vec![ex!(val!("b")), ex!(val!("c"))]} )])); + parse_test!("a[b,c]", AST(vec![exprstatement!(Index { indexee: bx!(ex!(val!("a"))), indexers: vec![ex!(val!("b")), ex!(val!("c"))]} )])); parse_test!("None", AST(vec![exprstatement!(val!("None"))])); parse_test!("Pandas { a: x + y }", AST(vec![ @@ -984,9 +984,9 @@ mod parse_tests { #[test] fn parsing_functions() { parse_test!("fn oi()", AST(vec![Declaration(FuncSig(Signature { name: rc!(oi), params: vec![], type_anno: None }))])); - parse_test!("oi()", AST(vec![exprstatement!(Call { f: Box::new(ex!(val!("oi"))), arguments: vec![] })])); + parse_test!("oi()", AST(vec![exprstatement!(Call { f: bx!(ex!(val!("oi"))), arguments: vec![] })])); parse_test!("oi(a, 2 + 2)", AST(vec![exprstatement!(Call - { f: Box::new(ex!(val!("oi"))), + { f: bx!(ex!(val!("oi"))), arguments: vec![ex!(val!("a")), ex!(binexp!("+", IntLiteral(2), IntLiteral(2)))] })])); parse_error!("a(b,,c)"); @@ -999,7 +999,7 @@ mod parse_tests { parse_test!("fn a(x) { x() }", AST(vec![Declaration( FuncDecl(Signature { name: rc!(a), params: vec![(rc!(x),None)], type_anno: None }, - vec![exprstatement!(Call { f: Box::new(ex!(val!("x"))), arguments: vec![] })]))])); + vec![exprstatement!(Call { f: bx!(ex!(val!("x"))), arguments: vec![] })]))])); } #[test] @@ -1045,8 +1045,8 @@ mod parse_tests { #[test] fn parsing_block_expressions() { parse_test!("if a() { b(); c() }", AST(vec![exprstatement!( - IfExpression(Box::new(ex!(Call { f: Box::new(ex!(val!("a"))), arguments: vec![]})), - vec![exprstatement!(Call { f: Box::new(ex!(val!("b"))), arguments: vec![]}), exprstatement!(Call { f: Box::new(ex!(val!("c"))), arguments: vec![] })], + IfExpression(bx!(ex!(Call { f: bx!(ex!(val!("a"))), arguments: vec![]})), + vec![exprstatement!(Call { f: bx!(ex!(val!("b"))), arguments: vec![]}), exprstatement!(Call { f: bx!(ex!(val!("c"))), arguments: vec![] })], None) )])); parse_test!(r#" @@ -1056,19 +1056,19 @@ mod parse_tests { } else { c }"#, - AST(vec![exprstatement!(IfExpression(Box::new(ex!(BoolLiteral(true))), + AST(vec![exprstatement!(IfExpression(bx!(ex!(BoolLiteral(true))), vec![Declaration(Binding { name: rc!(a), constant: true, expr: ex!(IntLiteral(10)) }), exprstatement!(Value(rc!(b), vec![]))], Some(vec![exprstatement!(Value(rc!(c), vec![]))])))]) ); parse_test!("if a { b } else { c }", AST(vec![exprstatement!( - IfExpression(Box::new(ex!(val!("a"))), + IfExpression(bx!(ex!(val!("a"))), vec![exprstatement!(val!("b"))], Some(vec![exprstatement!(val!("c"))])))])); parse_test!("if (A {a: 1}) { b } else { c }", AST(vec![exprstatement!( - IfExpression(Box::new(ex!(Value(rc!(A), vec![(rc!(a), ex!(IntLiteral(1)))]))), + IfExpression(bx!(ex!(Value(rc!(A), vec![(rc!(a), ex!(IntLiteral(1)))]))), vec![exprstatement!(val!("b"))], Some(vec![exprstatement!(val!("c"))])))])); diff --git a/src/schala_lang/typechecking.rs b/src/schala_lang/typechecking.rs index 6c23f3d..dab25d9 100644 --- a/src/schala_lang/typechecking.rs +++ b/src/schala_lang/typechecking.rs @@ -1,10 +1,6 @@ use std::rc::Rc; use std::collections::HashMap; -macro_rules! bx { - ($e:expr) => { Box::new($e) } -} - use schala_lang::parsing; pub struct TypeContext { @@ -115,7 +111,6 @@ impl TypeContext { } }, /* - BinExp(Operation, Box, Box), PrefixExp(Operation, Box), TupleLiteral(Vec), Value(Rc, Vec<(Rc, Expression)>),