refactor: cleanup AST code (#32)

**Description**

This PR refactors the code in `src/grammar/rules_actions.rs` to use `let
ast = &mut compiler_context.ast;` as it reduced some noise added by
having to use `compiler_context.ast` for every interaction with the AST

It removes some functions for `push|pop` out of the expression and term
stacks as those fields are now public to be consistent with the way we
use the other AST stacks

It also wraps the repeated code for `log_error_and_exist` into
`log_ast_error` function

Author: LeanSerra

src/compiler/ast.rs

@@ -11,8 +11,8 @@ use std::{
 
 pub struct Ast {
     tree: [Rc<Node>; mem::variant_count::<AstPtr>()],
-    pub stack_t: Vec<Rc<Node>>,
-    pub stack_e: Vec<Rc<Node>>,
+    pub term_stack: Vec<Rc<Node>>,
+    pub expression_stack: Vec<Rc<Node>>,
     pub comparision_op_stack: Vec<ComparisonOp>,
     pub comparision_expressions_stack: Vec<Rc<Node>>,
     pub boolean_expression_stack: Vec<Rc<Node>>,
@@ -23,8 +23,8 @@ pub struct Ast {
 
 impl Debug for Ast {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        writeln!(f, "{:?}", self.stack_t)?;
-        writeln!(f, "{:?}", self.stack_e)?;
+        writeln!(f, "{:?}", self.term_stack)?;
+        writeln!(f, "{:?}", self.expression_stack)?;
         writeln!(f, "{:?}", self.comparision_op_stack)?;
         writeln!(f, "{:?}", self.comparision_expressions_stack)
     }
@@ -132,6 +132,7 @@ pub enum AstAction {
     Read,
     Write,
     S,
+    Negative,
     Noop,
 }
 
@@ -159,6 +160,7 @@ impl Display for AstAction {
             Self::Read => write!(f, "READ"),
             Self::Write => write!(f, "WRITE"),
             Self::S => write!(f, "S"),
+            Self::Negative => write!(f, "NEG"),
             Self::Noop => write!(f, "NOOP"),
         }
     }
@@ -181,8 +183,8 @@ impl Default for Ast {
     fn default() -> Self {
         Self {
             tree: array::from_fn(|_| Rc::new(Node::new_leaf(NodeValue::Value("".to_string())))),
-            stack_e: Vec::new(),
-            stack_t: Vec::new(),
+            expression_stack: Vec::new(),
+            term_stack: Vec::new(),
             comparision_op_stack: Vec::new(),
             comparision_expressions_stack: Vec::new(),
             boolean_expression_stack: Vec::new(),
@@ -286,32 +288,6 @@ impl Ast {
         Ok(node_count)
     }
 
-    pub fn push_t_stack(&mut self, node: AstNodeRef) {
-        let node = match node {
-            AstNodeRef::Node(node) => node,
-            AstNodeRef::Ptr(ptr) => self.tree[ptr as usize].clone(),
-        };
-
-        self.stack_t.push(node);
-    }
-
-    pub fn pop_t_stack(&mut self) -> Option<Rc<Node>> {
-        self.stack_t.pop()
-    }
-
-    pub fn push_e_stack(&mut self, node: AstNodeRef) {
-        let node = match node {
-            AstNodeRef::Node(node) => node,
-            AstNodeRef::Ptr(ptr) => self.tree[ptr as usize].clone(),
-        };
-
-        self.stack_e.push(node);
-    }
-
-    pub fn pop_e_stack(&mut self) -> Option<Rc<Node>> {
-        self.stack_e.pop()
-    }
-
     pub fn get_node_from_ptr(&self, from: AstPtr) -> Rc<Node> {
         self.tree[from as usize].clone()
     }