1 files changed, 112 insertions, 18 deletions

diff --git a/src/ast.rs b/src/ast.rs
index ec5f953..7fc71a6 100644
--- a/src/ast.rs
+++ b/src/ast.rs
@@ -59,6 +59,16 @@ pub enum Pattern {
     },
 }
 
+impl std::fmt::Display for Pattern {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Begin => write!(f, "BEGIN"),
+            Self::End=> write!(f, "END"),
+            Self::Tree { modifier, matcher } => write!(f, "{modifier} {matcher}"),
+        }
+    }
+}
+
 impl Pattern {
     pub fn matches(&self, node: tree_sitter::Node) -> bool {
         match self {
@@ -75,12 +85,39 @@ pub enum Modifier {
     Leave,
 }
 
+impl std::fmt::Display for Modifier {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Modifier::Enter => write!(f, "enter"),
+            Modifier::Leave => write!(f, "leave"),
+        }
+    }
+}
+
 #[derive(Debug, Eq, PartialEq, Clone)]
 pub enum TreePattern {
     Atom(String),
     List(Vec<TreePattern>),
 }
 
+impl std::fmt::Display for TreePattern {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Atom(a) => write!(f, "{a}"),
+            Self::List(l) => {
+                write!(
+                    f,
+                    "({})",
+                    l.iter()
+                        .map(|i| i.to_string())
+                        .collect::<Vec<_>>()
+                        .join(" ")
+                )
+            }
+        }
+    }
+}
+
 impl TreePattern {
     pub fn matches(&self, node: tree_sitter::Node) -> bool {
         match self {
@@ -112,17 +149,6 @@ pub enum Statement {
     Declaration(Declaration),
 }
 
-impl Statement {
-    #[cfg(test)]
-    pub fn decl(ty: Type, ident: &str, init: Expr) -> Self {
-        Self::Declaration(Declaration {
-            ty,
-            name: ident.to_owned(),
-            init: Some(init.boxed()),
-        })
-    }
-}
-
 #[derive(Debug, Eq, PartialEq, Clone)]
 pub enum Expr {
     Node,
@@ -162,13 +188,6 @@ impl Expr {
             parameters: params.to_vec(),
         })
     }
-
-    #[cfg(test)]
-    pub fn list<const N: usize>(items: [Expr; N]) -> Expr {
-        Self::List(List {
-            items: items.to_vec(),
-        })
-    }
 }
 
 #[derive(Debug, Eq, PartialEq, Clone, Copy)]
@@ -176,6 +195,14 @@ pub enum UnaryOp {
     Not,
 }
 
+impl std::fmt::Display for UnaryOp {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Not => write!(f, "!"),
+        }
+    }
+}
+
 #[derive(Debug, Eq, PartialEq, Clone, Copy)]
 pub enum BinOp {
     Arith(ArithOp),
@@ -223,6 +250,17 @@ impl std::str::FromStr for BinOp {
     }
 }
 
+impl std::fmt::Display for BinOp {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Cmp(op) => write!(f, "{op}"),
+            Self::Arith(op) => write!(f, "{op}"),
+            Self::Logic(op) => write!(f, "{op}"),
+            Self::Assign(op) => write!(f, "{op}"),
+        }
+    }
+}
+
 // + - * /
 #[derive(Debug, Eq, PartialEq, Clone, Copy)]
 pub enum ArithOp {
@@ -233,6 +271,18 @@ pub enum ArithOp {
     Mod,
 }
 
+impl std::fmt::Display for ArithOp {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Add => write!(f, "+"),
+            Self::Sub => write!(f, "-"),
+            Self::Mul => write!(f, "*"),
+            Self::Div => write!(f, "/"),
+            Self::Mod => write!(f, "%"),
+        }
+    }
+}
+
 // && ||
 #[derive(Debug, Eq, PartialEq, Clone, Copy)]
 pub enum LogicOp {
@@ -240,6 +290,15 @@ pub enum LogicOp {
     Or,
 }
 
+impl std::fmt::Display for LogicOp {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::And => write!(f, "&&"),
+            Self::Or => write!(f, "||"),
+        }
+    }
+}
+
 // == != > < >= <=
 #[derive(Debug, Eq, PartialEq, Clone, Copy)]
 pub enum CmpOp {
@@ -251,12 +310,34 @@ pub enum CmpOp {
     Lte,
 }
 
+impl std::fmt::Display for CmpOp {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Eq => write!(f, "=="),
+            Self::Neq => write!(f, "!="),
+            Self::Gt => write!(f, ">"),
+            Self::Lt => write!(f, "<"),
+            Self::Gte => write!(f, ">="),
+            Self::Lte => write!(f, "<="),
+        }
+    }
+}
+
 // =, +=, -=, *=, /=
 #[derive(Debug, Eq, PartialEq, Clone, Copy)]
 pub struct AssignOp {
     pub op: Option<ArithOp>,
 }
 
+impl std::fmt::Display for AssignOp {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self.op {
+            None => write!(f, "="),
+            Some(op) => write!(f, "{op}="),
+        }
+    }
+}
+
 pub type Identifier = String;
 
 #[derive(Debug, Eq, PartialEq, Clone)]
@@ -301,6 +382,19 @@ pub enum Type {
     List,
 }
 
+impl std::fmt::Display for Type {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { 
+        match self {
+            Self::Unit => write!(f, "unit"),
+            Self::Integer => write!(f, "int"),
+            Self::String => write!(f, "string"),
+            Self::Boolean => write!(f, "bool"),
+            Self::Node => write!(f, "node"),
+            Self::List => write!(f, "list"),
+        }
+    }
+}
+
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub struct Declaration {
     pub ty: Type,