Make some progress, I guesstypes

1 files changed, 62 insertions, 36 deletions

diff --git a/src/chomp/visit.rs b/src/chomp/visit.rs
index bdef30e..5a81f4f 100644
--- a/src/chomp/visit.rs
+++ b/src/chomp/visit.rs
@@ -2,7 +2,8 @@ use proc_macro2::Span;
 
 use super::{
     ast::{
-        Alt, Call, Cat, Epsilon, Expression, Fix, Literal, NamedExpression, Parameter, Variable,
+        Alt, Call, Cat, Epsilon, Expression, Fix, Function, Global, Literal, NamedExpression,
+        Parameter,
     },
     Name,
 };
@@ -29,21 +30,28 @@ pub trait Visitor {
 
     fn visit_fix(&mut self, name: Option<&Name>, span: Option<Span>, fix: &Fix) -> Self::Out;
 
-    fn visit_variable(
+    fn visit_parameter(
         &mut self,
         name: Option<&Name>,
         span: Option<Span>,
-        var: &Variable,
+        param: &Parameter,
     ) -> Self::Out;
 
-    fn visit_parameter(
+    fn visit_global(
         &mut self,
         name: Option<&Name>,
         span: Option<Span>,
-        param: &Parameter,
+        global: &Global,
     ) -> Self::Out;
 
     fn visit_call(&mut self, name: Option<&Name>, span: Option<Span>, call: &Call) -> Self::Out;
+
+    fn visit_function(
+        &mut self,
+        name: Option<&Name>,
+        span: Option<Span>,
+        fun: &Function,
+    ) -> Self::Out;
 }
 
 pub trait Mapper {
@@ -69,18 +77,18 @@ pub trait Mapper {
 
     fn map_fix(&mut self, name: &mut Option<Name>, span: Option<Span>, fix: &mut Fix) -> Self::Out;
 
-    fn map_variable(
+    fn map_parameter(
         &mut self,
         name: &mut Option<Name>,
         span: Option<Span>,
-        var: &mut Variable,
+        param: &mut Parameter,
     ) -> Self::Out;
 
-    fn map_parameter(
+    fn map_global(
         &mut self,
         name: &mut Option<Name>,
         span: Option<Span>,
-        param: &mut Parameter,
+        global: &mut Global,
     ) -> Self::Out;
 
     fn map_call(
@@ -89,6 +97,13 @@ pub trait Mapper {
         span: Option<Span>,
         call: &mut Call,
     ) -> Self::Out;
+
+    fn map_function(
+        &mut self,
+        name: &mut Option<Name>,
+        span: Option<Span>,
+        fun: &mut Function,
+    ) -> Self::Out;
 }
 
 pub trait Folder {
@@ -104,9 +119,6 @@ pub trait Folder {
 
     fn fold_fix(&mut self, name: Option<Name>, span: Option<Span>, fix: Fix) -> Self::Out;
 
-    fn fold_variable(&mut self, name: Option<Name>, span: Option<Span>, var: Variable)
-        -> Self::Out;
-
     fn fold_parameter(
         &mut self,
         name: Option<Name>,
@@ -114,7 +126,12 @@ pub trait Folder {
         param: Parameter,
     ) -> Self::Out;
 
+    fn fold_global(&mut self, name: Option<Name>, span: Option<Span>, global: Global) -> Self::Out;
+
     fn fold_call(&mut self, name: Option<Name>, span: Option<Span>, call: Call) -> Self::Out;
+
+    fn fold_function(&mut self, name: Option<Name>, span: Option<Span>, fun: Function)
+        -> Self::Out;
 }
 
 pub trait Visitable {
@@ -127,41 +144,50 @@ pub trait Visitable {
 
 impl Visitable for NamedExpression {
     fn visit<V: Visitor>(&self, visitor: &mut V) -> <V as Visitor>::Out {
+        let name = self.name.as_ref();
+        let span = self.span;
         match &self.expr {
-            Expression::Epsilon(e) => visitor.visit_epsilon(self.name.as_ref(), self.span, e),
-            Expression::Literal(l) => visitor.visit_literal(self.name.as_ref(), self.span, l),
-            Expression::Cat(c) => visitor.visit_cat(self.name.as_ref(), self.span, c),
-            Expression::Alt(a) => visitor.visit_alt(self.name.as_ref(), self.span, a),
-            Expression::Fix(f) => visitor.visit_fix(self.name.as_ref(), self.span, f),
-            Expression::Variable(v) => visitor.visit_variable(self.name.as_ref(), self.span, v),
-            Expression::Parameter(p) => visitor.visit_parameter(self.name.as_ref(), self.span, p),
-            Expression::Call(c) => visitor.visit_call(self.name.as_ref(), self.span, c),
+            Expression::Epsilon(e) => visitor.visit_epsilon(name, span, e),
+            Expression::Literal(l) => visitor.visit_literal(name, span, l),
+            Expression::Cat(c) => visitor.visit_cat(name, span, c),
+            Expression::Alt(a) => visitor.visit_alt(name, span, a),
+            Expression::Fix(f) => visitor.visit_fix(name, span, f),
+            Expression::Parameter(p) => visitor.visit_parameter(name, span, p),
+            Expression::Global(g) => visitor.visit_global(name, span, g),
+            Expression::Call(c) => visitor.visit_call(name, span, c),
+            Expression::Function(f) => visitor.visit_function(name, span, f),
         }
     }
 
     fn map<M: Mapper>(&mut self, mapper: &mut M) -> <M as Mapper>::Out {
+        let name = &mut self.name;
+        let span = self.span;
         match &mut self.expr {
-            Expression::Epsilon(e) => mapper.map_epsilon(&mut self.name, self.span, e),
-            Expression::Literal(l) => mapper.map_literal(&mut self.name, self.span, l),
-            Expression::Cat(c) => mapper.map_cat(&mut self.name, self.span, c),
-            Expression::Alt(a) => mapper.map_alt(&mut self.name, self.span, a),
-            Expression::Fix(f) => mapper.map_fix(&mut self.name, self.span, f),
-            Expression::Variable(v) => mapper.map_variable(&mut self.name, self.span, v),
-            Expression::Parameter(p) => mapper.map_parameter(&mut self.name, self.span, p),
-            Expression::Call(c) => mapper.map_call(&mut self.name, self.span, c),
+            Expression::Epsilon(e) => mapper.map_epsilon(name, span, e),
+            Expression::Literal(l) => mapper.map_literal(name, span, l),
+            Expression::Cat(c) => mapper.map_cat(name, span, c),
+            Expression::Alt(a) => mapper.map_alt(name, span, a),
+            Expression::Fix(f) => mapper.map_fix(name, span, f),
+            Expression::Parameter(p) => mapper.map_parameter(name, span, p),
+            Expression::Global(g) => mapper.map_global(name, span, g),
+            Expression::Call(c) => mapper.map_call(name, span, c),
+            Expression::Function(f) => mapper.map_function(name, span, f),
         }
     }
 
     fn fold<F: Folder>(self, folder: &mut F) -> <F as Folder>::Out {
+        let name = self.name;
+        let span = self.span;
         match self.expr {
-            Expression::Epsilon(e) => folder.fold_epsilon(self.name, self.span, e),
-            Expression::Literal(l) => folder.fold_literal(self.name, self.span, l),
-            Expression::Cat(c) => folder.fold_cat(self.name, self.span, c),
-            Expression::Alt(a) => folder.fold_alt(self.name, self.span, a),
-            Expression::Fix(f) => folder.fold_fix(self.name, self.span, f),
-            Expression::Variable(v) => folder.fold_variable(self.name, self.span, v),
-            Expression::Parameter(p) => folder.fold_parameter(self.name, self.span, p),
-            Expression::Call(c) => folder.fold_call(self.name, self.span, c),
+            Expression::Epsilon(e) => folder.fold_epsilon(name, span, e),
+            Expression::Literal(l) => folder.fold_literal(name, span, l),
+            Expression::Cat(c) => folder.fold_cat(name, span, c),
+            Expression::Alt(a) => folder.fold_alt(name, span, a),
+            Expression::Fix(f) => folder.fold_fix(name, span, f),
+            Expression::Parameter(p) => folder.fold_parameter(name, span, p),
+            Expression::Global(g) => folder.fold_global(name, span, g),
+            Expression::Call(c) => folder.fold_call(name, span, c),
+            Expression::Function(f) => folder.fold_function(name, span, f),
         }
     }
 }