Add lifetimes to visitor to enable tree annotation.

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

Author: jgoppert

.gitignore

@@ -2,3 +2,4 @@
 .vscode
 *.py
 *.orig
+*.swp

Cargo.lock

@@ -2,7 +2,7 @@
 name = "rumoca_parser"
 authors = ["James Goppert", "Benjamin Perseghetti"]
 description = "A Modelica translator with focus on Casadi, Sympy, JAX, and Collimator generation"
-version = "0.6.1"
+version = "0.6.2"
 edition = "2021"
 license = "Apache-2.0"
 

Cargo.toml

@@ -1,7 +1,7 @@
 use serde::{Deserialize, Serialize};
 
 derive_alias! {
-    #[derive(CommonTraits!)] = #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Hash)];
+    #[derive(CommonTraits!)] = #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Hash)];
 }
 
 #[derive(CommonTraits!, Default)]

src/s1_parser/ast.rs

@@ -21,7 +21,7 @@ impl Default for PrintVisitor {
     }
 }
 
-impl Visitor for PrintVisitor {
+impl<'a> Visitor<'a> for PrintVisitor {
     fn enter_any(&mut self) {
         self.level += 1;
     }
@@ -30,21 +30,21 @@ impl Visitor for PrintVisitor {
         self.level -= 1;
     }
 
-    fn enter_stored_definition(&mut self, _def: &ast::StoredDefinition) {
+    fn enter_stored_definition(&mut self, _def: &'a ast::StoredDefinition) {
         self.print("Stored Definition");
     }
 
-    fn enter_class_definition(&mut self, class: &ast::ClassDefinition) {
+    fn enter_class_definition(&mut self, class: &'a ast::ClassDefinition) {
         if let ast::ClassSpecifier::Long { name, .. } = &class.specifier {
             self.print(&format!("class {}", name));
         }
     }
 
-    fn exit_class_definition(&mut self, _class: &ast::ClassDefinition) {
+    fn exit_class_definition(&mut self, _class: &'a ast::ClassDefinition) {
         println!("\n");
     }
 
-    fn enter_expression(&mut self, expr: &ast::Expression) {
+    fn enter_expression(&mut self, expr: &'a ast::Expression) {
         match expr {
             ast::Expression::Binary { op, .. } => {
                 self.print(&format!("{:?}", op));
@@ -79,7 +79,7 @@ impl Visitor for PrintVisitor {
         }
     }
 
-    fn enter_equation(&mut self, eq: &ast::Equation) {
+    fn enter_equation(&mut self, eq: &'a ast::Equation) {
         match eq {
             ast::Equation::Connect { .. } => {
                 self.print("connect");
@@ -94,7 +94,7 @@ impl Visitor for PrintVisitor {
         }
     }
 
-    fn exit_element(&mut self, elem: &ast::Element) {
+    fn exit_element(&mut self, elem: &'a ast::Element) {
         match elem {
             ast::Element::ComponentClause { clause, .. } => {
                 for comp in clause.components.iter() {
@@ -109,7 +109,7 @@ impl Visitor for PrintVisitor {
         }
     }
 
-    fn exit_component_reference(&mut self, comp: &ast::ComponentReference) {
+    fn exit_component_reference(&mut self, comp: &'a ast::ComponentReference) {
         let mut s: String = "".to_string();
         for (index, part) in comp.parts.iter().enumerate() {
             if index != 0 || comp.local {

src/s1_parser/print_visitor.rs

@@ -1,27 +1,28 @@
 use crate::s1_parser::ast;
 
-pub trait Visitor {
+pub trait Visitor<'a> {
     fn enter_any(&mut self) {}
     fn exit_any(&mut self) {}
 
-    fn enter_expression(&mut self, _expr: &ast::Expression) {}
-    fn exit_expression(&mut self, _expr: &ast::Expression) {}
+    #[allow(unused_variables)]
+    fn enter_expression(&mut self, _expr: &'a ast::Expression) {}
+    fn exit_expression(&mut self, _expr: &'a ast::Expression) {}
 
-    fn enter_element(&mut self, _expr: &ast::Element) {}
-    fn exit_element(&mut self, _expr: &ast::Element) {}
+    fn enter_element(&mut self, _elem: &'a ast::Element) {}
+    fn exit_element(&mut self, _elem: &'a ast::Element) {}
 
-    fn enter_class_definition(&mut self, _class: &ast::ClassDefinition) {}
-    fn exit_class_definition(&mut self, _class: &ast::ClassDefinition) {}
+    fn enter_class_definition(&mut self, _class: &'a ast::ClassDefinition) {}
+    fn exit_class_definition(&mut self, _class: &'a ast::ClassDefinition) {}
 
-    fn enter_equation(&mut self, _eq: &ast::Equation) {}
-    fn exit_equation(&mut self, _eq: &ast::Equation) {}
+    fn enter_equation(&mut self, _eq: &'a ast::Equation) {}
+    fn exit_equation(&mut self, _eq: &'a ast::Equation) {}
 
-    fn enter_statement(&mut self, _stmt: &ast::Statement) {}
-    fn exit_statement(&mut self, _stmt: &ast::Statement) {}
+    fn enter_statement(&mut self, _stmt: &'a ast::Statement) {}
+    fn exit_statement(&mut self, _stmt: &'a ast::Statement) {}
 
-    fn enter_stored_definition(&mut self, _def: &ast::StoredDefinition) {}
-    fn exit_stored_definition(&mut self, _def: &ast::StoredDefinition) {}
+    fn enter_stored_definition(&mut self, _def: &'a ast::StoredDefinition) {}
+    fn exit_stored_definition(&mut self, _def: &'a ast::StoredDefinition) {}
 
-    fn enter_component_reference(&mut self, _def: &ast::ComponentReference) {}
-    fn exit_component_reference(&mut self, _def: &ast::ComponentReference) {}
+    fn enter_component_reference(&mut self, _comp: &'a ast::ComponentReference) {}
+    fn exit_component_reference(&mut self, _comp: &'a ast::ComponentReference) {}
 }

src/s1_parser/visitor.rs

@@ -3,7 +3,10 @@ use crate::s1_parser::ast;
 use crate::s1_parser::visitor::Visitor;
 
 impl Walker {
-    pub fn walk_stored_definition<V: Visitor>(visitor: &mut V, def: &ast::StoredDefinition) {
+    pub fn walk_stored_definition<'a, V: Visitor<'a>>(
+        visitor: &mut V,
+        def: &'a ast::StoredDefinition,
+    ) {
         visitor.enter_any();
         visitor.enter_stored_definition(def);
         for class in def.classes.iter() {
@@ -13,7 +16,10 @@ impl Walker {
         visitor.exit_any();
     }
 
-    pub fn walk_class_definition<V: Visitor>(visitor: &mut V, class: &ast::ClassDefinition) {
+    pub fn walk_class_definition<'a, V: Visitor<'a>>(
+        visitor: &mut V,
+        class: &'a ast::ClassDefinition,
+    ) {
         visitor.enter_any();
         visitor.enter_class_definition(class);
 
@@ -45,14 +51,14 @@ impl Walker {
         visitor.exit_any();
     }
 
-    pub fn walk_element<V: Visitor>(visitor: &mut V, eq: &ast::Element) {
+    pub fn walk_element<'a, V: Visitor<'a>>(visitor: &mut V, eq: &'a ast::Element) {
         visitor.enter_any();
         visitor.enter_element(eq);
         visitor.exit_element(eq);
         visitor.exit_any();
     }
 
-    pub fn walk_equation<V: Visitor>(visitor: &mut V, eq: &ast::Equation) {
+    pub fn walk_equation<'a, V: Visitor<'a>>(visitor: &mut V, eq: &'a ast::Equation) {
         visitor.enter_any();
         visitor.enter_equation(eq);
         match eq {
@@ -89,7 +95,7 @@ impl Walker {
         visitor.exit_any();
     }
 
-    pub fn walk_statement<V: Visitor>(visitor: &mut V, stmt: &ast::Statement) {
+    pub fn walk_statement<'a, V: Visitor<'a>>(visitor: &mut V, stmt: &'a ast::Statement) {
         visitor.enter_any();
         visitor.enter_statement(stmt);
         match stmt {
@@ -130,7 +136,7 @@ impl Walker {
         visitor.exit_any();
     }
 
-    pub fn walk_expression<V: Visitor>(visitor: &mut V, expr: &ast::Expression) {
+    pub fn walk_expression<'a, V: Visitor<'a>>(visitor: &mut V, expr: &'a ast::Expression) {
         visitor.enter_any();
         visitor.enter_expression(expr);
         match expr {
@@ -180,7 +186,10 @@ impl Walker {
         visitor.exit_any();
     }
 
-    pub fn walk_component_reference<V: Visitor>(visitor: &mut V, comp: &ast::ComponentReference) {
+    pub fn walk_component_reference<'a, V: Visitor<'a>>(
+        visitor: &mut V,
+        comp: &'a ast::ComponentReference,
+    ) {
         visitor.enter_any();
         visitor.enter_component_reference(comp);
         visitor.exit_component_reference(comp);