From e76540182f3175a0478fd8e2e54be2ccc6038e27 Mon Sep 17 00:00:00 2001
From: Sofia <sofia@teascade.net>
Date: Tue, 14 Apr 2026 19:18:10 +0300
Subject: [PATCH] Possibly fix passing of arrays

---
 a.out           | Bin 16040 -> 0 bytes
 src/codegen.cpp | 126 +++++++++++++++++++++++++++++++++---------------
 src/parsing.cpp |   2 +-
 3 files changed, 89 insertions(+), 39 deletions(-)
 delete mode 100755 a.out

diff --git a/a.out b/a.out
deleted file mode 100755
index 0abd102242ccff8d29c31e152e897daeb1f786ea..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 16040
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
a2ZBq#u9oK3^ZT!&A0`kzZ}=%7s(%AxkXYaV

diff --git a/src/codegen.cpp b/src/codegen.cpp
index 5d11dea..df4c8fa 100644
--- a/src/codegen.cpp
+++ b/src/codegen.cpp
@@ -158,23 +158,41 @@ namespace AST {
     }
 
     codegen::StackValue CastExpression::codegen(codegen::Builder& builder, codegen::Scope& scope) {
-        auto expr = this->m_expr->codegen(builder, scope);
-        auto cast = types::find_cast(scope.casts, expr.ty, this->m_ty);
-        if (cast) {
-            if (cast->target_ty->m_kind == types::TypeKind::Pointer && cast->casted_ty->m_kind == types::TypeKind::Array) {
-                auto allocated = builder.builder->CreateAlloca(cast->casted_ty->codegen(builder));
-                builder.builder->CreateStore(expr.value, allocated);
+        auto expr_ty = this->m_expr->get_codegen_type(scope);
+        if (expr_ty->m_kind == types::TypeKind::Pointer && this->m_ty->m_kind == types::TypeKind::Pointer) {
+            std::cout << expr_ty->formatted() << std::endl;
+            auto lvalued = scope.with_lvalue();
+            auto expr = this->m_expr->codegen(builder, lvalued);
+            auto cast = types::find_cast(scope.casts, expr.ty, this->m_ty);
+            if (cast) {
                 return codegen::StackValue{
-                    cast->codegen(builder, cast->target_ty, allocated),
+                    cast->codegen(builder, cast->target_ty, expr.value),
                     cast->target_ty
                 };
             }
-            return codegen::StackValue{
-                cast->codegen(builder, cast->target_ty, expr.value),
-                cast->target_ty
-            };
+            else {
+                return expr;
+            }
+        }
+        else {
+            auto expr = this->m_expr->codegen(builder, scope);
+            auto cast = types::find_cast(scope.casts, expr.ty, this->m_ty);
+            if (cast) {
+                // if (cast->target_ty->m_kind == types::TypeKind::Pointer && cast->casted_ty->m_kind == types::TypeKind::Array) {
+                //     auto allocated = builder.builder->CreateAlloca(cast->casted_ty->codegen(builder));
+                //     builder.builder->CreateStore(expr.value, allocated);
+                //     return codegen::StackValue{
+                //         cast->codegen(builder, cast->target_ty, allocated),
+                //         cast->target_ty
+                //     };
+                // }
+                return codegen::StackValue{
+                    cast->codegen(builder, cast->target_ty, expr.value),
+                    cast->target_ty
+                };
+            }
+            return expr;
         }
-        return expr;
     }
 
     std::shared_ptr<types::Type> RefExpression::get_codegen_type(codegen::Scope& scope) {
@@ -258,23 +276,42 @@ namespace AST {
                     };
                 }
             }
+            else if (ptr_ty->m_inner->m_kind == types::TypeKind::Array) {
+                std::cout << ptr_ty->m_inner->formatted() << std::endl;
 
-            // Must be an array otherwise
-            auto arr_ty = dynamic_cast<types::ArrayType*>(ptr_ty->m_inner.get());
-            auto gep_value = builder.builder->CreateGEP(arr_ty->m_inner->codegen(builder), value.value, idx_list, "GEP");
-            if (scope.is_lvalue) {
-                return codegen::StackValue{
-                    gep_value,
-                    value.ty,
-                };
+                // Must be an array otherwise
+                auto arr_ty = dynamic_cast<types::ArrayType*>(ptr_ty->m_inner.get());
+                auto gep_value = builder.builder->CreateGEP(arr_ty->m_inner->codegen(builder), value.value, idx_list, "GEP");
+                if (scope.is_lvalue) {
+                    return codegen::StackValue{
+                        gep_value,
+                        value.ty,
+                    };
+                }
+                else {
+                    auto inner_ptr_ty = types::PointerType{ arr_ty->m_inner };
+                    auto loaded = inner_ptr_ty.load(builder, gep_value);
+                    return codegen::StackValue{
+                        loaded.first,
+                        loaded.second
+                    };
+                }
             }
             else {
-                auto inner_ptr_ty = types::PointerType{ arr_ty->m_inner };
-                auto loaded = inner_ptr_ty.load(builder, gep_value);
-                return codegen::StackValue{
-                    loaded.first,
-                    loaded.second
-                };
+                auto gep_value = builder.builder->CreateGEP(ptr_ty->m_inner->codegen(builder), value.value, idx_list, "GEP");
+                if (scope.is_lvalue) {
+                    return codegen::StackValue{
+                        gep_value,
+                        value.ty,
+                    };
+                }
+                else {
+                    auto loaded = value.ty->load(builder, gep_value);
+                    return codegen::StackValue{
+                        loaded.first,
+                        loaded.second
+                    };
+                }
             }
         }
 
@@ -382,19 +419,32 @@ namespace AST {
 
             int counter = 0;
             for (auto& param : this->m_params) {
-                builder.builder->SetInsertPoint(BB);
-                auto arg_ptr = builder.builder->CreateAlloca(param_ty_ptrs[counter]->codegen(builder));
-                auto param_ty_ptr = std::shared_ptr<types::Type>{
-                    new types::PointerType { param_ty_ptrs[counter]}
-                };
-                auto arg = function->getArg(counter++);
-                builder.builder->CreateStore(arg, arg_ptr);
-                if (param.first) {
-                    arg->setName(*param.first);
-                    inner_scope.values[*param.first] = codegen::StackValue{
-                        arg_ptr,
-                        param_ty_ptr,
+                if (param.second->m_kind == types::TypeKind::Pointer) {
+                    auto ty = param_ty_ptrs[counter];
+                    auto arg = function->getArg(counter++);
+                    if (param.first) {
+                        arg->setName(*param.first);
+                        inner_scope.values[*param.first] = codegen::StackValue{
+                            arg,
+                            ty,
+                        };
+                    }
+                }
+                else {
+                    builder.builder->SetInsertPoint(BB);
+                    auto arg_ptr = builder.builder->CreateAlloca(param_ty_ptrs[counter]->codegen(builder));
+                    auto param_ty_ptr = std::shared_ptr<types::Type>{
+                        new types::PointerType { param_ty_ptrs[counter]}
                     };
+                    auto arg = function->getArg(counter++);
+                    builder.builder->CreateStore(arg, arg_ptr);
+                    if (param.first) {
+                        arg->setName(*param.first);
+                        inner_scope.values[*param.first] = codegen::StackValue{
+                            arg_ptr,
+                            param_ty_ptr,
+                        };
+                    }
                 }
             }
 
diff --git a/src/parsing.cpp b/src/parsing.cpp
index b356a5a..bcc68cd 100644
--- a/src/parsing.cpp
+++ b/src/parsing.cpp
@@ -398,7 +398,7 @@ namespace parsing {
                         auto array_postfix = postfix.unwrap();
                         if (array_postfix) {
                             param_ty = std::shared_ptr<types::Type>{
-                                new types::ArrayType(param_ty, *array_postfix)
+                                new types::PointerType(param_ty)
                             };
                         }
                         else {