Fixed weird issue with struct functions not being called from the module correctly as well as made a couple of otehr minor fixes

Author: TheDevConnor

src/helper/help.h

@@ -28,7 +28,7 @@
 /** Enable debug logs for arena allocator (comment to disable) */
 #define DEBUG_ARENA_ALLOC 1
 
-#define Luma_Compiler_version "v0.1.4"
+#define Luma_Compiler_version "v0.1.6"
 
 /** Error codes returned by the compiler */
 typedef enum {

src/llvm/expr.c

@@ -513,30 +513,49 @@ LLVMValueRef codegen_expr_call(CodeGenContext *ctx, AstNode *node) {
   // Check if this is a method call (obj.method())
   if (callee->type == AST_EXPR_MEMBER && !callee->expr.member.is_compiletime) {
     // Method call: obj.method(arg1, arg2)
-    // The typechecker has already injected 'self' as the first argument
-    // So we just need to codegen all arguments as-is
-
-    // Get the method function
     const char *member_name = callee->expr.member.member;
+    
+    // **FIX: The typechecker already injected self into args[0]!**
+    // Just look up the method and use args as-is
+    
+    LLVMValueRef method_func = NULL;
 
-    // Look up the method in the current module
+    // First try current module
     LLVMModuleRef current_llvm_module =
         ctx->current_module ? ctx->current_module->module : ctx->module;
-    LLVMValueRef method_func =
-        LLVMGetNamedFunction(current_llvm_module, member_name);
+    method_func = LLVMGetNamedFunction(current_llvm_module, member_name);
 
+    // If not found in current module, search all other modules
     if (!method_func) {
-      fprintf(stderr, "Error: Method '%s' not found\n", member_name);
+      for (ModuleCompilationUnit *unit = ctx->modules; unit;
+           unit = unit->next) {
+        if (unit == ctx->current_module)
+          continue;
+
+        LLVMValueRef found_func = LLVMGetNamedFunction(unit->module, member_name);
+        if (found_func) {
+          // CRITICAL FIX: Create external declaration in current module
+          LLVMTypeRef func_type = LLVMGlobalGetValueType(found_func);
+          method_func = LLVMAddFunction(current_llvm_module, member_name, func_type);
+          LLVMSetLinkage(method_func, LLVMExternalLinkage);
+          break;
+        }
+      }
+    }
+
+    if (!method_func) {
+      fprintf(stderr, "Error: Method '%s' not found in any module\n",
+              member_name);
       return NULL;
     }
 
     callee_value = method_func;
 
-    // Allocate space for all arguments (including injected self)
+    // Allocate space for arguments (typechecker already added self!)
     args = (LLVMValueRef *)arena_alloc(
         ctx->arena, sizeof(LLVMValueRef) * arg_count, alignof(LLVMValueRef));
 
-    // Codegen all arguments (self is already in args[0] from typechecker)
+    // Generate all arguments (including self at index 0)
     for (size_t i = 0; i < arg_count; i++) {
       args[i] = codegen_expr(ctx, node->expr.call.args[i]);
       if (!args[i]) {
@@ -545,8 +564,7 @@ LLVMValueRef codegen_expr_call(CodeGenContext *ctx, AstNode *node) {
                 member_name);
         return NULL;
       }
-    }
-
+    } 
   } else {
     // Regular function call or compile-time member access (module::func)
     callee_value = codegen_expr(ctx, callee);
@@ -572,14 +590,10 @@ LLVMValueRef codegen_expr_call(CodeGenContext *ctx, AstNode *node) {
 
   // Check if return type is void
   if (LLVMGetTypeKind(return_type) == LLVMVoidTypeKind) {
-    // For void functions, don't assign a name to the call
     LLVMBuildCall2(ctx->builder, func_type, callee_value, args, arg_count, "");
-    // Return a void constant since we can't return NULL
     return LLVMConstNull(LLVMVoidTypeInContext(ctx->context));
   } else {
-    // For non-void functions, assign a name as usual
-    return LLVMBuildCall2(ctx->builder, func_type, callee_value, args,
-                          arg_count, "call");
+    return LLVMBuildCall2(ctx->builder, func_type, callee_value, args, arg_count, "call");
   }
 }
 

src/llvm/llvm.c

@@ -51,24 +51,25 @@ void generate_external_declarations(CodeGenContext *ctx,
     if (source_module == target_module)
       continue;
 
-    // Look through source module's symbols for public functions
-    for (LLVM_Symbol *sym = source_module->symbols; sym; sym = sym->next) {
-      if (sym->is_function) {
-        // Check if this function is already declared in target module
-        LLVMValueRef existing =
-            LLVMGetNamedFunction(target_module->module, sym->name);
+    // Iterate through ALL functions in the source module (not just symbols)
+    LLVMValueRef func = LLVMGetFirstFunction(source_module->module);
+    while (func) {
+      // Check if this function has external linkage (is public)
+      if (LLVMGetLinkage(func) == LLVMExternalLinkage) {
+        const char *func_name = LLVMGetValueName(func);
+        
+        // Check if already declared in target module
+        LLVMValueRef existing = LLVMGetNamedFunction(target_module->module, func_name);
         if (!existing) {
           // Create external declaration
-          LLVMTypeRef func_type = LLVMGlobalGetValueType(sym->value);
+          LLVMTypeRef func_type = LLVMGlobalGetValueType(func);
           LLVMValueRef external_func =
-              LLVMAddFunction(target_module->module, sym->name, func_type);
+              LLVMAddFunction(target_module->module, func_name, func_type);
           LLVMSetLinkage(external_func, LLVMExternalLinkage);
-
-          // Add to target module's symbol table
-          add_symbol_to_module(target_module, sym->name, external_func,
-                               func_type, true);
         }
       }
+      
+      func = LLVMGetNextFunction(func);
     }
   }
 }

src/typechecker/expr.c

@@ -885,21 +885,20 @@ AstNode *typecheck_member_expr(AstNode *expr, Scope *scope,
       if (pointee && pointee->type == AST_TYPE_BASIC) {
         const char *type_name = pointee->type_data.basic.name;
 
-        // First try direct lookup
+        // Try lookup through normal scope chain first
         Symbol *struct_symbol = scope_lookup(scope, type_name);
 
-        // If not found, try looking in imported modules
+        // If not found through normal lookup, explicitly search imported modules
         if (!struct_symbol) {
-          // Check each imported module for this type
           Scope *current = scope;
           while (current && !struct_symbol) {
             for (size_t i = 0; i < current->imported_modules.count; i++) {
               ModuleImport *import =
                   (ModuleImport *)((char *)current->imported_modules.data +
                                    i * sizeof(ModuleImport));
 
-              // Try to find the type in the imported module's scope
-              struct_symbol = scope_lookup_current_only_with_visibility(
+              // CRITICAL FIX: Use full scope_lookup with visibility
+              struct_symbol = scope_lookup_with_visibility(
                   import->module_scope, type_name, scope);
 
               if (struct_symbol && struct_symbol->type &&
@@ -925,10 +924,10 @@ AstNode *typecheck_member_expr(AstNode *expr, Scope *scope,
     if (base_type->type == AST_TYPE_BASIC) {
       const char *type_name = base_type->type_data.basic.name;
 
-      // First try direct lookup
+      // Try lookup through normal scope chain first
       Symbol *struct_symbol = scope_lookup(scope, type_name);
 
-      // If not found, try looking in imported modules
+      // If not found through normal lookup, explicitly search imported modules
       if (!struct_symbol) {
         Scope *current = scope;
         while (current && !struct_symbol) {
@@ -937,7 +936,8 @@ AstNode *typecheck_member_expr(AstNode *expr, Scope *scope,
                 (ModuleImport *)((char *)current->imported_modules.data +
                                  i * sizeof(ModuleImport));
 
-            struct_symbol = scope_lookup_current_only_with_visibility(
+            // CRITICAL FIX: Use full scope_lookup with visibility
+            struct_symbol = scope_lookup_with_visibility(
                 import->module_scope, type_name, scope);
 
             if (struct_symbol && struct_symbol->type &&
@@ -977,7 +977,6 @@ AstNode *typecheck_member_expr(AstNode *expr, Scope *scope,
     }
   }
 }
-
 AstNode *typecheck_deref_expr(AstNode *expr, Scope *scope,
                               ArenaAllocator *arena) {
   if (expr->expr.deref.object->type == AST_EXPR_IDENTIFIER) {

src/typechecker/scope.c

@@ -168,6 +168,21 @@ Symbol *scope_lookup_with_visibility(Scope *scope, const char *name,
         return NULL;
       }
     }
+    
+    for (size_t i = 0; i < current->imported_modules.count; i++) {
+      ModuleImport *import =
+          (ModuleImport *)((char *)current->imported_modules.data +
+                           i * sizeof(ModuleImport));
+      
+      // Search in the imported module's scope
+      Symbol *found = scope_lookup_current_only_with_visibility(
+          import->module_scope, name, scope);
+      
+      if (found) {
+        return found;
+      }
+    }
+    
     current = current->parent;
   }
 

src/typechecker/type.c

@@ -326,7 +326,10 @@ AstNode *get_struct_member_type(AstNode *struct_type, const char *member_name) {
     return NULL;
   }
 
+  // fprintf(stderr, "DEBUG: Looking for member '%s' in struct with %zu members:\n",
+          // member_name, struct_type->type_data.struct_type.member_count);
   for (size_t i = 0; i < struct_type->type_data.struct_type.member_count; i++) {
+    // fprintf(stderr, "  - %s\n", struct_type->type_data.struct_type.member_names[i]);
     if (strcmp(struct_type->type_data.struct_type.member_names[i],
                member_name) == 0) {
       return struct_type->type_data.struct_type.member_types[i];

std/arena.lx

@@ -5,6 +5,7 @@
 @use "io" as io
 
 const ARENA_DEFAULT_SIZE: int = 1024 * 1024;
+const NULL: *void = cast<*void>(0);
 
 pub const Arena -> struct {
 pub:
@@ -37,7 +38,7 @@ pub const reset_arena -> fn (a: *Arena) void {
 #takes_ownership
 pub const free_arena -> fn (a: *Arena) void {
     free(a.buf);
-    a.buf = cast<*byte>(0);
+    a.buf = NULL;
     a.buf_len = 0;
     a.curr_offset = 0;
     a.prev_offset = 0;
@@ -51,7 +52,7 @@ pub const alloc_arena -> fn (a: *Arena, size: int) *void {
     if (aligned_offset + size > a.buf_len) {
         io::print_err("Arena allocator: insufficient space (requested: %d bytes, available: %d bytes)\n", 
                 [size, (a.buf_len - aligned_offset)]);
-        return cast<*void>(0);
+        return NULL;
     }
 
     let ptr: *void = cast<*void>(cast<int>(a.buf) + aligned_offset);

std/vector.lx

@@ -0,0 +1,124 @@
+@module "vector"
+
+@use "memory" as memory
+
+const DEFAULT_VECTOR_CAPACITY: int = 1024;
+const NULL: *void = cast<*void>(0);
+
+pub const Vector -> struct {
+pub:
+    data: *void,
+    capacity: int,
+    size: int,          
+    element_size: int, 
+
+    insert -> fn (elem: *void, index: int) int {
+        if (index < 0 || index > self.size) return 0;
+
+        if (self.size >= self.capacity) {
+            self.capacity = self.capacity * 2;
+            self.data = memory::realloc(
+                self.data,
+                self.capacity * self.element_size
+            );
+        }
+
+        // shift elements right
+        let src: *void = cast<*void>(
+            cast<int>(self.data) + (index * self.element_size)
+        );
+
+        let dst: *void = cast<*void>(
+            cast<int>(self.data) + ((index + 1) * self.element_size)
+        );
+
+        let bytes: int = (self.size - index) * self.element_size;
+        memory::memcpy(dst, src, bytes);
+
+        // write new element
+        memory::memcpy(src, elem, self.element_size);
+        self.size = self.size + 1;
+        return 1;
+    },
+
+    push_back -> fn (elem: *void) void {
+        if (self.size >= self.capacity) {
+            self.capacity = self.capacity * 2;
+            self.data = memory::realloc(self.data, self.capacity * self.element_size);
+        }
+
+        let dest: *void = cast<*void>(
+            cast<int>(self.data) + (self.size * self.element_size)
+        );
+
+        memory::memcpy(dest, elem, self.element_size);
+        self.size = self.size + 1;
+    },
+
+
+    pop_back -> fn (out: *void) int {
+        if (self.size == 0) return 0;
+
+        self.size = self.size - 1;
+
+        if (out != NULL) {
+            let src: *void = cast<*void>(
+                cast<int>(self.data) + (self.size * self.element_size)
+            );
+            memory::memcpy(out, src, self.element_size);
+        }
+
+        return 1;
+    },
+
+    remove_at -> fn (index: int) int {
+        if (index < 0 || index >= self.size) return 0;
+
+        let src: *void = cast<*void>(
+            cast<int>(self.data) + ((index + 1) * self.element_size)
+        );
+
+        let dst: *void = cast<*void>(
+            cast<int>(self.data) + (index * self.element_size)
+        );
+
+        let bytes_to_move: int =
+            (self.size - index - 1) * self.element_size;
+
+        memory::memcpy(dst, src, bytes_to_move);
+
+        self.size = self.size - 1;
+        return 1;
+    },
+
+    get -> fn (index: int) *void {
+        if (index < 0 || index >= self.size) return NULL;
+        return cast<*void>(
+            cast<int>(self.data) + (index * self.element_size)
+        );
+    }
+};
+
+#returns_ownership
+pub const create_vector_capacity -> fn (init_capacity: int, element_size: int) Vector {
+    let v: Vector;
+    v.data = cast<*void>(alloc(init_capacity * element_size));
+    v.size = 0;
+    v.capacity = init_capacity;
+    v.element_size = element_size;
+    return v;
+} 
+
+#returns_ownership
+pub const create_vector -> fn (element_size: int) Vector {
+    return create_vector_capacity(DEFAULT_VECTOR_CAPACITY, element_size);
+}
+
+#takes_ownership
+pub const free_vector -> fn (v: *Vector) void {
+    free(v.data);
+    v.data = NULL;
+    v.capacity = 0;
+    v.size = 0;
+    v.element_size = 0;
+}