refactor: refactor handling of array/pointer types

3 files changed, 27 insertions, 26 deletions

diff --git a/ast.c b/ast.c
index 83f65d9..3bcc9c7 100644
--- a/ast.c
+++ b/ast.c
@@ -16,7 +16,8 @@ struct AstNode;
 
 struct Type {
     TypeKind kind;
-    struct Type* to;
+    // Check `base` instead of `kind` to test if the type is an array or a pointer.
+    struct Type* base;
     int array_size;
     struct AstNode* def;
 };
@@ -28,17 +29,17 @@ Type* type_new(TypeKind kind) {
     return ty;
 }
 
-Type* type_new_ptr(Type* to) {
+Type* type_new_ptr(Type* base) {
     Type* ty = calloc(1, sizeof(Type));
     ty->kind = TypeKind_ptr;
-    ty->to = to;
+    ty->base = base;
     return ty;
 }
 
 Type* type_new_array(Type* elem, int size) {
     Type* ty = calloc(1, sizeof(Type));
     ty->kind = TypeKind_array;
-    ty->to = elem;
+    ty->base = elem;
     ty->array_size = size;
     return ty;
 }
@@ -48,7 +49,7 @@ Type* type_new_static_string(int len) {
 }
 
 Type* type_array_to_ptr(Type* ty) {
-    return type_new_ptr(ty->to);
+    return type_new_ptr(ty->base);
 }
 
 int type_is_unsized(Type* ty) {
@@ -76,7 +77,7 @@ int type_sizeof(Type* ty) {
     } else if (ty->kind == TypeKind_enum) {
         return 4;
     } else if (ty->kind == TypeKind_array) {
-        return type_sizeof(ty->to) * ty->array_size;
+        return type_sizeof(ty->base) * ty->array_size;
     } else {
         return type_sizeof_struct(ty);
     }
@@ -98,7 +99,7 @@ int type_alignof(Type* ty) {
     } else if (ty->kind == TypeKind_enum) {
         return 4;
     } else if (ty->kind == TypeKind_array) {
-        return type_alignof(ty->to);
+        return type_alignof(ty->base);
     } else {
         return type_alignof_struct(ty);
     }
@@ -264,17 +265,17 @@ AstNode* ast_new_assign_expr(int op, AstNode* lhs, AstNode* rhs) {
 }
 
 AstNode* ast_new_assign_add_expr(AstNode* lhs, AstNode* rhs) {
-    if (lhs->ty->kind == TypeKind_ptr || lhs->ty->kind == TypeKind_array) {
-        rhs = ast_new_binary_expr(TokenKind_star, rhs, ast_new_int(type_sizeof(lhs->ty->to)));
-    } else if (rhs->ty->kind == TypeKind_ptr || rhs->ty->kind == TypeKind_array) {
-        lhs = ast_new_binary_expr(TokenKind_star, lhs, ast_new_int(type_sizeof(rhs->ty->to)));
+    if (lhs->ty->base) {
+        rhs = ast_new_binary_expr(TokenKind_star, rhs, ast_new_int(type_sizeof(lhs->ty->base)));
+    } else if (rhs->ty->base) {
+        lhs = ast_new_binary_expr(TokenKind_star, lhs, ast_new_int(type_sizeof(rhs->ty->base)));
     }
     return ast_new_assign_expr(TokenKind_assign_add, lhs, rhs);
 }
 
 AstNode* ast_new_assign_sub_expr(AstNode* lhs, AstNode* rhs) {
-    if (lhs->ty->kind == TypeKind_ptr || lhs->ty->kind == TypeKind_array) {
-        rhs = ast_new_binary_expr(TokenKind_star, rhs, ast_new_int(type_sizeof(lhs->ty->to)));
+    if (lhs->ty->base) {
+        rhs = ast_new_binary_expr(TokenKind_star, rhs, ast_new_int(type_sizeof(lhs->ty->base)));
     }
     return ast_new_assign_expr(TokenKind_assign_sub, lhs, rhs);
 }
@@ -289,14 +290,14 @@ AstNode* ast_new_ref_expr(AstNode* operand) {
 AstNode* ast_new_deref_expr(AstNode* operand) {
     AstNode* e = ast_new(AstNodeKind_deref_expr);
     e->node_operand = operand;
-    e->ty = operand->ty->to;
+    e->ty = operand->ty->base;
     return e;
 }
 
 AstNode* ast_new_member_access_expr(AstNode* obj, const String* name) {
     AstNode* e = ast_new(AstNodeKind_deref_expr);
-    e->node_operand = ast_new_binary_expr(TokenKind_plus, obj, ast_new_int(type_offsetof(obj->ty->to, name)));
-    e->ty = type_member_typeof(obj->ty->to, name);
+    e->node_operand = ast_new_binary_expr(TokenKind_plus, obj, ast_new_int(type_offsetof(obj->ty->base, name)));
+    e->ty = type_member_typeof(obj->ty->base, name);
     e->node_operand->ty = type_new_ptr(e->ty);
     return e;
 }
diff --git a/codegen.c b/codegen.c
index d15fb4c..51254dc 100644
--- a/codegen.c
+++ b/codegen.c
@@ -125,7 +125,7 @@ void codegen_lval2rval(Type* ty) {
 void codegen_deref_expr(CodeGen* g, AstNode* ast, GenMode gen_mode) {
     codegen_expr(g, ast->node_operand, GenMode_rval);
     if (gen_mode == GenMode_rval) {
-        codegen_lval2rval(ast->node_operand->ty->to);
+        codegen_lval2rval(ast->node_operand->ty->base);
     }
 }
 
diff --git a/parse.c b/parse.c
index 70cf9d0..b9b8700 100644
--- a/parse.c
+++ b/parse.c
@@ -334,7 +334,7 @@ AstNode* parse_postfix_expr(Parser* p) {
             next_token(p);
             AstNode* idx = parse_expr(p);
             expect(p, TokenKind_bracket_r);
-            idx = ast_new_binary_expr(TokenKind_star, idx, ast_new_int(type_sizeof(ret->ty->to)));
+            idx = ast_new_binary_expr(TokenKind_star, idx, ast_new_int(type_sizeof(ret->ty->base)));
             ret = ast_new_deref_expr(ast_new_binary_expr(TokenKind_plus, ret, idx));
         } else if (tk == TokenKind_dot) {
             next_token(p);
@@ -498,27 +498,27 @@ AstNode* parse_additive_expr(Parser* p) {
         if (op == TokenKind_plus) {
             next_token(p);
             rhs = parse_multiplicative_expr(p);
-            if (lhs->ty->kind == TypeKind_ptr) {
+            if (lhs->ty->base) {
                 lhs = ast_new_binary_expr(
-                    op, lhs, ast_new_binary_expr(TokenKind_star, rhs, ast_new_int(type_sizeof(lhs->ty->to))));
-            } else if (rhs->ty->kind == TypeKind_ptr) {
+                    op, lhs, ast_new_binary_expr(TokenKind_star, rhs, ast_new_int(type_sizeof(lhs->ty->base))));
+            } else if (rhs->ty->base) {
                 lhs = ast_new_binary_expr(
-                    op, ast_new_binary_expr(TokenKind_star, lhs, ast_new_int(type_sizeof(rhs->ty->to))), rhs);
+                    op, ast_new_binary_expr(TokenKind_star, lhs, ast_new_int(type_sizeof(rhs->ty->base))), rhs);
             } else {
                 lhs = ast_new_binary_expr(op, lhs, rhs);
             }
         } else if (op == TokenKind_minus) {
             next_token(p);
             rhs = parse_multiplicative_expr(p);
-            if (lhs->ty->kind == TypeKind_ptr) {
-                if (rhs->ty->kind == TypeKind_ptr) {
+            if (lhs->ty->base) {
+                if (rhs->ty->base) {
                     // (a - b) / sizeof(a)
                     lhs = ast_new_binary_expr(TokenKind_slash, ast_new_binary_expr(op, lhs, rhs),
-                                              ast_new_int(type_sizeof(lhs->ty->to)));
+                                              ast_new_int(type_sizeof(lhs->ty->base)));
                 } else {
                     // a - b*sizeof(a)
                     lhs = ast_new_binary_expr(
-                        op, lhs, ast_new_binary_expr(TokenKind_star, rhs, ast_new_int(type_sizeof(lhs->ty->to))));
+                        op, lhs, ast_new_binary_expr(TokenKind_star, rhs, ast_new_int(type_sizeof(lhs->ty->base))));
                 }
             } else {
                 lhs = ast_new_binary_expr(op, lhs, rhs);