Add dead code elimination to AST tree

1 files changed, 73 insertions, 3 deletions

diff --git a/src/parser.c b/src/parser.c
index 3e6abc2..d1a5e7a 100644
--- a/src/parser.c
+++ b/src/parser.c
@@ -459,6 +459,50 @@ check_object_scope(Environment *env, Object *obj, Errors *errors) {
     }
 }
 
+void
+remove_unused_expr(Object *obj) {
+    if (obj == NULL) {
+        return;
+    }
+    switch (obj->type) {
+        case OBJ_TYPE_DEF:
+        case OBJ_TYPE_SET: {
+            remove_unused_expr(obj->var_expr);
+        } break;
+        case OBJ_TYPE_IF: {
+            remove_unused_expr(obj->condition);
+            remove_unused_expr(obj->expr_true);
+            remove_unused_expr(obj->expr_false);
+        } break;
+        case OBJ_TYPE_PAIR: {
+            remove_unused_expr(obj->head);
+            remove_unused_expr(obj->tail);
+        } break;
+        case OBJ_TYPE_LAMBDA: {
+            Object **new_body = NULL;
+            array_init(new_body, 0);
+            for (size_t i = 0; i < array_size(obj->body); i++) {
+                Object *expr = obj->body[i];
+                if (i != array_size(obj->body) - 1) {
+                    if (IS_FIXNUM(expr) ||
+                        IS_STRING(expr) ||
+                        IS_SYMBOL(expr) ||
+                        IS_LAMBDA(expr) ||
+                        IS_BOOL(expr)   ||
+                        IS_NIL(expr)) {
+                        continue;
+                    }
+                }
+                remove_unused_expr(expr);
+                array_push(new_body, expr);
+            }
+            array_free(obj->body);
+            obj->body = new_body;
+        } break;
+        default: break;
+    }
+}
+
 Root *
 parse(Token *tokens, Errors *errors) {
     array_init(roots, 0);
@@ -472,9 +516,8 @@ parse(Token *tokens, Errors *errors) {
     // Build initial ASTs. This also ensures the core grammar is correct.
     while (has_next_token(&parser)) {
         Object *root = parse_tree(&parser, errors);
-        OBJ_PRINT(root);
         if (errors->n != 0) {
-            break;
+            return NULL;
         }
         array_push(roots, root);
     }
@@ -498,9 +541,36 @@ parse(Token *tokens, Errors *errors) {
     for (size_t i = 0; i < array_size(roots); i++) {
         Object *root = roots[i];
         check_object_scope(global_env, root, errors);
+        if (errors->n != 0) {
+            return NULL;
+        }
+    }
+
+    // Remove unnecessary statements.
+    Root *final_roots = NULL;
+    array_init(final_roots, 0);
+    for (size_t i = 0; i < array_size(roots); i++) {
+        Object *root = roots[i];
+        if (i != array_size(roots) - 1) {
+            if (IS_FIXNUM(root) ||
+                IS_STRING(root) ||
+                IS_SYMBOL(root) ||
+                IS_LAMBDA(root) ||
+                IS_BOOL(root)   ||
+                IS_NIL(root)) {
+                continue;
+            }
+        }
+        array_push(final_roots, root);
+
+        remove_unused_expr(root);
+        if (errors->n != 0) {
+            return NULL;
+        }
     }
+    array_free(roots);
+    roots = final_roots;
 
-    // TODO: Remove unnecessary statements.
     return roots;
 }