Add visitable trait.

Signed-off-by: James Goppert <james.goppert@gmail.com>

Author: jgoppert

src/lalrpop.rs

@@ -0,0 +1,8 @@
+
+use lalrpop_util::lalrpop_mod;
+
+lalrpop_mod!(
+    #[rustfmt::skip]
+    modelica,
+    "/s1_parser/modelica.rs"
+);

src/lib.rs

@@ -1,10 +1,11 @@
 pub mod s0_lexer;
 pub mod s1_parser;
+pub mod s2_analysis;
 
 #[macro_use]
 extern crate macro_rules_attribute;
 
 pub use s1_parser::ast;
-pub use s1_parser::print_visitor::PrintVisitor;
-pub use s1_parser::visitor::Visitor;
-pub use s1_parser::walker::Walker;
+pub use s2_analysis::parser_helper::parse_file;
+pub use s2_analysis::print_visitor::PrintVisitor;
+pub use s2_analysis::visitor::Visitable;

src/main.rs

@@ -1,7 +1,5 @@
 use clap::Parser;
-
-use rumoca_parser::PrintVisitor;
-use rumoca_parser::Walker;
+use rumoca_parser::{PrintVisitor, Visitable};
 
 #[derive(Parser, Debug)]
 #[command(version, about = "Rumoca Modelica Parser", long_about = None)]
@@ -17,13 +15,13 @@ struct Args {
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     let args = Args::parse();
-    let def = rumoca_parser::s1_parser::parse_file(&args.model_file);
+    let def = rumoca_parser::parse_file(&args.model_file);
 
     if args.verbose {
         println!("{:#?}", def);
     }
 
     let mut visitor = PrintVisitor::default();
-    Walker::walk_stored_definition(&mut visitor, &def);
+    def.accept(&mut visitor);
     Ok(())
 }

src/s1_parser/ast.rs

@@ -252,10 +252,15 @@ pub enum UnaryOp {
     Paren,
     Not,
     Negative,
+    Positive,
+    ElemNegative,
+    ElemPositive,
 }
 
 #[derive(CommonTraits!)]
 pub enum BinaryOp {
+    Paren,
+    Not,
     Add,
     Sub,
     Mul,

src/s1_parser/mod.rs

@@ -1,14 +1,8 @@
 pub mod ast;
-pub mod parser_helper;
-pub use parser_helper::parse_file;
-pub mod print_visitor;
-pub mod visitor;
-pub mod walker;
-
 use lalrpop_util::lalrpop_mod;
 
 lalrpop_mod!(
     #[rustfmt::skip]
-    modelica,
+    pub modelica,
     "/s1_parser/modelica.rs"
 );

src/s1_parser/modelica.lalrpop

@@ -158,7 +158,7 @@ pub StoredDefinition: ast::StoredDefinition = {
     }
 }
 
-pub ClassDefinitionWithFinal: ast::ClassDefinition = {
+ClassDefinitionWithFinal: ast::ClassDefinition = {
     <is_final: "final"?> <mut class: ClassDefinition> => {
         class.is_final = is_final.is_some();
         class
@@ -851,7 +851,7 @@ pub ForStatement: ast::Statement = {
 
 //✅ for-indices :
 //✅    for-index { "," for-index }
-pub ForIndices: Vec<ast::ForIndex> = {
+ForIndices: Vec<ast::ForIndex> = {
     <indices: SeparatedList<ForIndex, ",">> => indices
 }
 
@@ -928,7 +928,7 @@ pub ConnectEquation: ast::Equation = {
 //✅     logical-expression
 //🟥     [ ":" logical-expression [ ":" logical-expression ] ]
 pub Expression: ast::Expression = {
-    <simp:SimpleExpression> =>  <>,
+    <SimpleExpression> =>  <>,
     "if" <if_cond:SimpleExpression> "then"
     <then_expr:SimpleExpression>
     <else_if_blocks: ElseIfExpressionBlock*>
@@ -966,7 +966,44 @@ pub ElseExpressionBlock: ast::Expression = {
 
 pub ParenthesisExpression = SimpleExpression;
 
-pub SimpleExpression: ast::Expression = {
+//✅ relational-operator :
+//✅    "<" | "<=" | ">" | ">=" | "==" | "<>"
+RelationalOperator : ast::BinaryOp = {
+    "<" => ast::BinaryOp::LessThan,
+    "<=" => ast::BinaryOp::LessThanOrEqual,
+    ">" => ast::BinaryOp::GreaterThan,
+    ">=" => ast::BinaryOp::GreaterThanOrEqual,
+    "==" => ast::BinaryOp::Equal,
+    "<>" => ast::BinaryOp::NotEqual,
+}
+
+//✅ add-operator :
+//✅    "+" | "-" | ".+" | ".-"
+AddBinaryOperator : ast::BinaryOp = {
+    "+" => ast::BinaryOp::Add,
+    "-" => ast::BinaryOp::Sub,
+    ".+" => ast::BinaryOp::ElemAdd,
+    ".-" => ast::BinaryOp::ElemSub,
+}
+AddUnaryOperator : ast::UnaryOp = {
+    "-" => ast::UnaryOp::Negative,
+}
+
+FactorOperator : ast::BinaryOp = {
+    "^" => ast::BinaryOp::Exp,
+    ".^" => ast::BinaryOp::ElemExp,
+}
+
+//✅ mul-operator :
+//✅    "*" | "/" | ".*" | "./"
+MulOperator : ast::BinaryOp = {
+    "*" => ast::BinaryOp::Mul,
+    "/" => ast::BinaryOp::Div,
+    ".*" => ast::BinaryOp::ElemMul,
+    "./" => ast::BinaryOp::ElemDiv,
+}
+
+SimpleExpression: ast::Expression = {
 //✅ simple-expression :
 //✅    logical-expression [ ":" logical-expression [ ":" logical-expression ] ]
     #[precedence(level="11")] #[assoc(side="left")]
@@ -1008,95 +1045,33 @@ pub SimpleExpression: ast::Expression = {
     },
 //✅ relation :
 //✅    arithmetic-expression [ relational-operator arithmetic-expression ]
-//✅ relational-operator :
-//✅    "<" | "<=" | ">" | ">=" | "==" | "<>"
     #[precedence(level="7")] #[assoc(side="left")]
-    <lhs:SimpleExpression> "<" <rhs:SimpleExpression> => {
-        ast::Expression::Binary {
-            op: ast::BinaryOp::LessThan,
-            lhs: Box::new(lhs),
-            rhs: Box::new(rhs),
-        }
-    },
-    <lhs:SimpleExpression> ">" <rhs:SimpleExpression> => {
-        ast::Expression::Binary {
-            op: ast::BinaryOp::GreaterThan,
-            lhs: Box::new(lhs),
-            rhs: Box::new(rhs),
-        }
-    },
-    <lhs:SimpleExpression> "<=" <rhs:SimpleExpression> => {
+    <lhs:SimpleExpression> <op:RelationalOperator> <rhs:SimpleExpression> => {
         ast::Expression::Binary {
-            op: ast::BinaryOp::LessThanOrEqual,
+            op,
             lhs: Box::new(lhs),
             rhs: Box::new(rhs),
         }
     },
-    <lhs:SimpleExpression> ">=" <rhs:SimpleExpression> => {
-        ast::Expression::Binary {
-            op: ast::BinaryOp::GreaterThanOrEqual,
-            lhs: Box::new(lhs),
-            rhs: Box::new(rhs),
-        }
-    },
-    <lhs:SimpleExpression> "==" <rhs:SimpleExpression> => {
-        ast::Expression::Binary {
-            op: ast::BinaryOp::Equal,
-            lhs: Box::new(lhs),
-            rhs: Box::new(rhs),
-        }
-    },
-    <lhs:SimpleExpression> "<>" <rhs:SimpleExpression> => {
-        ast::Expression::Binary {
-            op: ast::BinaryOp::NotEqual,
-            lhs: Box::new(lhs),
-            rhs: Box::new(rhs),
-        }
-    },
-    #[precedence(level="12")] #[assoc(side="left")]
-    "-" <rhs:SimpleExpression> => {
-        ast::Expression::Unary {
-            op: ast::UnaryOp::Negative,
-            rhs: Box::new(rhs),
-        }
-    },
 //✅ arithmetic-expression :
 //✅    [ add-operator ] term { add-operator term }
-//✅ add-operator :
-//✅    "+" | "-" | ".+" | ".-"
-    #[precedence(level="5")] #[assoc(side="left")]
-    <lhs:SimpleExpression> "+" <rhs:SimpleExpression> => {
-        ast::Expression::Binary {
-            op: ast::BinaryOp::Add,
-            lhs: Box::new(lhs),
-            rhs: Box::new(rhs),
-        }
-    },
-    <lhs:SimpleExpression> ".+" <rhs:SimpleExpression> => {
-        ast::Expression::Binary {
-            op: ast::BinaryOp::ElemAdd,
-            lhs: Box::new(lhs),
-            rhs: Box::new(rhs),
-        }
-    },
-    <lhs:SimpleExpression> "-" <rhs:SimpleExpression> => {
-        ast::Expression::Binary {
-            op: ast::BinaryOp::Sub,
-            lhs: Box::new(lhs),
+    #[precedence(level="6")] #[assoc(side="right")]
+    <op:AddUnaryOperator> <rhs:SimpleExpression> => {
+        ast::Expression::Unary {
+            op,
             rhs: Box::new(rhs),
         }
     },
-    <lhs:SimpleExpression> ".-" <rhs:SimpleExpression> => {
+    #[precedence(level="5")] #[assoc(side="left")]
+    <lhs:SimpleExpression> <op:AddBinaryOperator> <rhs:SimpleExpression> => {
         ast::Expression::Binary {
-            op: ast::BinaryOp::ElemSub,
+            op,
             lhs: Box::new(lhs),
             rhs: Box::new(rhs),
         }
     },
 //✅ term :
 //✅    factor { mul-operator factor }
-//✅ mul-operator :
-//✅    "*" | "/" | ".*" | "./"
     #[precedence(level="4")] #[assoc(side="left")]
     <lhs:SimpleExpression> "*" <rhs:SimpleExpression> => {
         ast::Expression::Binary {
@@ -1129,16 +1104,9 @@ pub SimpleExpression: ast::Expression = {
 //✅ factor :
 //✅    primary [ ( "^" | ".^" ) primary ]
     #[precedence(level="3")] #[assoc(side="left")]
-    <lhs:SimpleExpression> "^" <rhs:SimpleExpression> => {
-        ast::Expression::Binary {
-            op: ast::BinaryOp::Exp,
-            lhs: Box::new(lhs),
-            rhs: Box::new(rhs),
-        }
-    },
-    <lhs:SimpleExpression> ".^" <rhs:SimpleExpression> => {
+    <lhs:SimpleExpression> <op:FactorOperator> <rhs:SimpleExpression> => {
         ast::Expression::Binary {
-            op: ast::BinaryOp::ElemExp,
+            op,
             lhs: Box::new(lhs),
             rhs: Box::new(rhs),
         }