Okay so the issue was coming from LLVMConstNull. So i made a helper function to try and find the correct type and set it accordinally.

Author: Connor Harris

src/llvm/expr/defer.c

@@ -130,9 +130,10 @@ void generate_cleanup_blocks(CodeGenContext *ctx) {
   if (LLVMGetTypeKind(return_type) == LLVMVoidTypeKind) {
     LLVMBuildRetVoid(ctx->builder);
   } else {
-    // Return default value for the type
-    LLVMValueRef default_val = LLVMConstNull(return_type);
-    LLVMBuildRet(ctx->builder, default_val);
+    LLVMValueRef default_val = get_default_value(return_type);
+    if (default_val) {
+      LLVMBuildRet(ctx->builder, default_val);
+    }
   }
 }
 

src/llvm/expr/expr.c

@@ -118,11 +118,7 @@ LLVMValueRef codegen_expr_literal(CodeGenContext *ctx, AstNode *node) {
   }
 
   case LITERAL_NULL:
-    if (!ctx->common_types.i8_ptr) {
-      fprintf(stderr, "Error: i8_ptr type not initialized\n");
-      return NULL;
-    }
-    return LLVMConstNull(ctx->common_types.i8_ptr);
+    return get_default_value(ctx->common_types.i8_ptr);
 
   default:
     fprintf(stderr, "ERROR: Unknown literal type: %d\n",

src/llvm/llvm.h

@@ -268,6 +268,7 @@ bool is_float_type(LLVMTypeRef type);
 bool pointer_type(LLVMTypeRef type);
 bool types_are_equal(LLVMTypeRef a, LLVMTypeRef b);
 bool needs_conversion(LLVMTypeRef from, LLVMTypeRef to);
+LLVMValueRef get_default_value(LLVMTypeRef type);
 
 LLVMValueRef alloca_and_store(CodeGenContext *ctx, LLVMTypeRef type,
                               LLVMValueRef value, const char *name);

src/llvm/stmt/stmt.c

@@ -127,19 +127,25 @@ LLVMValueRef codegen_stmt_var_decl(CodeGenContext *ctx, AstNode *node) {
         } else {
           fprintf(stderr,
                   "Error: Global variable initializer must be constant\n");
-          LLVMSetInitializer(var_ref, LLVMConstNull(var_type));
+          LLVMValueRef def = get_default_value(var_type);
+          if (def)
+            LLVMSetInitializer(var_ref, def);
         }
       } else {
         LLVMBuildStore(ctx->builder, init_val, var_ref);
       }
     } else {
       if (ctx->current_function == NULL) {
-        LLVMSetInitializer(var_ref, LLVMConstNull(var_type));
+        LLVMValueRef def = get_default_value(var_type);
+        if (def)
+          LLVMSetInitializer(var_ref, def);
       }
     }
   } else {
     if (ctx->current_function == NULL) {
-      LLVMSetInitializer(var_ref, LLVMConstNull(var_type));
+      LLVMValueRef def = get_default_value(var_type);
+      if (def)
+        LLVMSetInitializer(var_ref, def);
     }
   }
 
@@ -356,7 +362,11 @@ generate_body: {
   if (LLVMGetTypeKind(return_type) == LLVMVoidTypeKind) {
     LLVMBuildRetVoid(ctx->builder);
   } else {
-    LLVMValueRef default_val = LLVMConstNull(return_type);
+    LLVMValueRef default_val = get_default_value(return_type);
+    if (!default_val) {
+      fprintf(stderr, "Error: Cannot create default value for return type\n");
+      return NULL;
+    }
     LLVMBuildRet(ctx->builder, default_val);
   }
 

src/llvm/struct/struct_helpers.c

@@ -46,7 +46,7 @@ LLVMValueRef create_struct_zero_initializer(CodeGenContext *ctx, const char *str
         return NULL;
     }
 
-    return LLVMConstNull(struct_info->llvm_type);
+    return get_default_value(struct_info->llvm_type);
 }
 
 // Create a copy of a struct
@@ -235,33 +235,10 @@ LLVMValueRef initialize_struct_with_defaults(CodeGenContext *ctx, const char *st
 
     // Initialize each field with appropriate default
     for (size_t i = 0; i < struct_info->field_count; i++) {
-        LLVMValueRef default_value;
-        LLVMTypeKind kind = LLVMGetTypeKind(struct_info->field_types[i]);
-        
-        switch (kind) {
-            case LLVMIntegerTypeKind:
-                default_value = LLVMConstInt(struct_info->field_types[i], 0, false);
-                break;
-            case LLVMFloatTypeKind:
-                default_value = LLVMConstReal(struct_info->field_types[i], 0.0);
-                break;
-            case LLVMDoubleTypeKind:
-                default_value = LLVMConstReal(struct_info->field_types[i], 0.0);
-                break;
-            case LLVMPointerTypeKind:
-                if (!struct_info->field_types[i]) {
-                  fprintf(stderr, "Error: field_types[%zu] is NULL\n", i);
-                  return NULL;
-                }
-                default_value = LLVMConstNull(struct_info->field_types[i]);
-                break;
-            default:
-                if (!struct_info->field_types[i]) {
-                  fprintf(stderr, "Error: field_types[%zu] is NULL\n", i);
-                  return NULL;
-                }
-                default_value = LLVMConstNull(struct_info->field_types[i]);
-                break;
+        LLVMValueRef default_value = get_default_value(struct_info->field_types[i]);
+        if (!default_value) {
+            fprintf(stderr, "Error: Cannot create default value for field %zu\n", i);
+            return NULL;
         }
 
         LLVMValueRef field_ptr = LLVMBuildStructGEP2(

src/llvm/types/type_cache.c

@@ -80,6 +80,26 @@ bool pointer_type(LLVMTypeRef type) {
 
 bool types_are_equal(LLVMTypeRef a, LLVMTypeRef b) { return a == b; }
 
+LLVMValueRef get_default_value(LLVMTypeRef type) {
+  if (!type)
+    return NULL;
+
+  switch (LLVMGetTypeKind(type)) {
+  case LLVMIntegerTypeKind:
+  case LLVMFloatTypeKind:
+  case LLVMDoubleTypeKind:
+  case LLVMStructTypeKind:
+  case LLVMArrayTypeKind:
+    return LLVMConstNull(type);
+
+  case LLVMPointerTypeKind:
+    return LLVMConstPointerNull(type);
+
+  default:
+    return NULL;
+  }
+}
+
 // Check if conversion is needed
 bool needs_conversion(LLVMTypeRef from, LLVMTypeRef to) {
   if (from == to)