feat: AST generation for compiler builtins convDate and isZero (#31)

**Description**

This PR adds AST generation for `convDate` and `isZero`

For convDate
- convDate: is implemented by getting the date: DD-MM-YYYY we have to
convert it to YYYYMMDD
   - If we treat each part of the date as an integer
     - YYYY * 1000 will give us: YYYY0000
     - MM * 100 will give us: MM00
     - DD * 1 will give us DD
- Adding up all these values will give us YYYYMMDD

For isZero
- isZero is implmented by after generating the AST for the expression
inside isZero creating a leaf with a 0 value and creating a node with
comparison "==" with the expression as the left_child and the 0 as the
right_child

Author: LeanSerra

src/compiler/ast.rs

@@ -50,6 +50,7 @@ pub enum AstPtr {
     While,
     Read,
     Write,
+    ConvDate,
 }
 
 pub enum AstNodeRef {

src/grammar/rules_actions.rs

@@ -494,6 +494,13 @@ pub fn function_is_zero_function_is_zero_call(
     compiler_context.write_to_parser_file(&format!(
         "<FunctionIsZero> -> {token_is_zero} {token_par_open} <E> {token_par_close}"
     ));
+    let zero_leaf = Rc::new(Node::new_leaf(NodeValue::Value("0".into())));
+    compiler_context.ast.create_node(
+        AstAction::EQ,
+        AstPtr::ArithmeticExpression.into(),
+        zero_leaf.into(),
+        AstPtr::IsZero,
+    );
     FunctionIsZero {
         token_is_zero,
         token_par_open,
@@ -514,6 +521,46 @@ pub fn function_conv_date_function_conv_date_variable_call(
     compiler_context.write_to_parser_file(&format!(
         "<FunctionConvDate> -> {token_conv_date} {token_par_open} {token_date} {token_par_close}"
     ));
+    let thousand_leaf = Rc::new(Node::new_leaf(NodeValue::Value("1000".into())));
+    let hundread_leaf = Rc::new(Node::new_leaf(NodeValue::Value("100".into())));
+    let one_leaf = Rc::new(Node::new_leaf(NodeValue::Value("1".into())));
+
+    let year_leaf = Rc::new(Node::new_leaf(NodeValue::Value(token_date.year.clone())));
+    let month_leaf = Rc::new(Node::new_leaf(NodeValue::Value(token_date.month.clone())));
+    let day_leaf = Rc::new(Node::new_leaf(NodeValue::Value(token_date.day.clone())));
+
+    let year_node = compiler_context.ast.create_node(
+        AstAction::Mult,
+        year_leaf.into(),
+        thousand_leaf.into(),
+        AstPtr::ConvDate,
+    );
+    let month_node = compiler_context.ast.create_node(
+        AstAction::Mult,
+        month_leaf.into(),
+        hundread_leaf.into(),
+        AstPtr::ConvDate,
+    );
+    let day_node = compiler_context.ast.create_node(
+        AstAction::Mult,
+        day_leaf.into(),
+        one_leaf.into(),
+        AstPtr::ConvDate,
+    );
+
+    let sum_year_month_node = compiler_context.ast.create_node(
+        AstAction::Plus,
+        year_node.into(),
+        month_node.into(),
+        AstPtr::ConvDate,
+    );
+    compiler_context.ast.create_node(
+        AstAction::Plus,
+        sum_year_month_node.into(),
+        day_node.into(),
+        AstPtr::ConvDate,
+    );
+
     FunctionConvDate {
         token_conv_date,
         token_par_open,
@@ -751,6 +798,13 @@ pub fn assignment_assignment_conv_date(
     compiler_context.write_to_parser_file(&format!(
         "<Assignment> -> {token_id} {token_assign} <FunctionConvDate>"
     ));
+    let leaf = Rc::new(Node::new_leaf(NodeValue::Value(token_id.clone())));
+    compiler_context.ast.create_node(
+        AstAction::Assign,
+        leaf.into(),
+        AstPtr::ConvDate.into(),
+        AstPtr::Assignment,
+    );
     Assignment::AssignmentConvDate(ConvDate {
         token_id,
         token_assign,