Fix bug with string literals

src/ast.h

@@ -25,6 +25,7 @@ namespace AST {
     public:
         Expression(token::Metadata meta) : Node{ meta } {}
         virtual codegen::StackValue codegen(codegen::Builder& builder, codegen::Scope& scope) = 0;
+        virtual std::shared_ptr<types::Type> get_codegen_type(codegen::Scope& scope) = 0;
         virtual std::shared_ptr<types::Type> typecheck(
             typecheck::State& state,
             typecheck::Scope& scope,
@@ -55,6 +56,7 @@ namespace AST {
         virtual ~IntLiteralExpression() override = default;
         virtual std::string formatted() override;
         virtual codegen::StackValue codegen(codegen::Builder& builder, codegen::Scope& scope) override;
+        virtual std::shared_ptr<types::Type> get_codegen_type(codegen::Scope& scope) override;
         virtual std::shared_ptr<types::Type> typecheck(
             typecheck::State& state,
             typecheck::Scope& scope,
@@ -71,6 +73,7 @@ namespace AST {
         virtual ~StringLiteralExpression() override = default;
         virtual std::string formatted() override;
         virtual codegen::StackValue codegen(codegen::Builder& builder, codegen::Scope& scope) override;
+        virtual std::shared_ptr<types::Type> get_codegen_type(codegen::Scope& scope) override;
         virtual std::shared_ptr<types::Type> typecheck(
             typecheck::State& state,
             typecheck::Scope& scope,
@@ -87,6 +90,7 @@ namespace AST {
         virtual ~ValueReferenceExpression() override = default;
         virtual std::string formatted() override;
         virtual codegen::StackValue codegen(codegen::Builder& builder, codegen::Scope& scope) override;
+        virtual std::shared_ptr<types::Type> get_codegen_type(codegen::Scope& scope) override;
         virtual std::shared_ptr<types::Type> typecheck(
             typecheck::State& state,
             typecheck::Scope& scope,
@@ -114,6 +118,7 @@ namespace AST {
         virtual ~BinaryOperationExpression() override = default;
         virtual std::string formatted() override;
         virtual codegen::StackValue codegen(codegen::Builder& builder, codegen::Scope& scope) override;
+        virtual std::shared_ptr<types::Type> get_codegen_type(codegen::Scope& scope) override;
         virtual std::shared_ptr<types::Type> typecheck(
             typecheck::State& state,
             typecheck::Scope& scope,
@@ -138,6 +143,7 @@ namespace AST {
         virtual ~FunctionCallExpression() override = default;
         virtual std::string formatted() override;
         virtual codegen::StackValue codegen(codegen::Builder& builder, codegen::Scope& scope) override;
+        virtual std::shared_ptr<types::Type> get_codegen_type(codegen::Scope& scope) override;
         virtual std::shared_ptr<types::Type> typecheck(
             typecheck::State& state,
             typecheck::Scope& scope,
@@ -162,6 +168,7 @@ namespace AST {
         virtual ~CastExpression() override = default;
         virtual std::string formatted() override;
         virtual codegen::StackValue codegen(codegen::Builder& builder, codegen::Scope& scope) override;
+        virtual std::shared_ptr<types::Type> get_codegen_type(codegen::Scope& scope) override;
         virtual std::shared_ptr<types::Type> typecheck(
             typecheck::State& state,
             typecheck::Scope& scope,
@@ -183,6 +190,7 @@ namespace AST {
         virtual ~RefExpression() override = default;
         virtual std::string formatted() override;
         virtual codegen::StackValue codegen(codegen::Builder& builder, codegen::Scope& scope) override;
+        virtual std::shared_ptr<types::Type> get_codegen_type(codegen::Scope& scope) override;
         virtual std::shared_ptr<types::Type> typecheck(
             typecheck::State& state,
             typecheck::Scope& scope,
@@ -204,6 +212,7 @@ namespace AST {
         virtual ~DerefExpression() override = default;
         virtual std::string formatted() override;
         virtual codegen::StackValue codegen(codegen::Builder& builder, codegen::Scope& scope) override;
+        virtual std::shared_ptr<types::Type> get_codegen_type(codegen::Scope& scope) override;
         virtual std::shared_ptr<types::Type> typecheck(
             typecheck::State& state,
             typecheck::Scope& scope,
@@ -228,6 +237,7 @@ namespace AST {
         virtual ~IndexAccessExpression() override = default;
         virtual std::string formatted() override;
         virtual codegen::StackValue codegen(codegen::Builder& builder, codegen::Scope& scope) override;
+        virtual std::shared_ptr<types::Type> get_codegen_type(codegen::Scope& scope) override;
         virtual std::shared_ptr<types::Type> typecheck(
             typecheck::State& state,
             typecheck::Scope& scope,

src/codegen.cpp

@@ -16,6 +16,10 @@ namespace codegen {
 }
 
 namespace AST {
+    std::shared_ptr<types::Type> IntLiteralExpression::get_codegen_type(codegen::Scope&) {
+        return this->m_ty;
+    }
+
     codegen::StackValue IntLiteralExpression::codegen(codegen::Builder& builder, codegen::Scope&) {
         auto ty = this->m_ty->codegen(builder);
 
@@ -25,7 +29,15 @@ namespace AST {
         };
     }
 
-    codegen::StackValue StringLiteralExpression::codegen(codegen::Builder& builder, codegen::Scope&) {
+    std::shared_ptr<types::Type> StringLiteralExpression::get_codegen_type(codegen::Scope&) {
+        auto stack_type = new types::ArrayType{
+            std::make_unique<types::FundamentalType>(types::FundamentalTypeKind::Char),
+            static_cast<uint32_t>(this->m_value.size()) + 1
+        };
+        return std::shared_ptr<types::Type> {stack_type};
+    }
+
+    codegen::StackValue StringLiteralExpression::codegen(codegen::Builder& builder, codegen::Scope& scope) {
         auto stack_type = new types::ArrayType{
             std::make_unique<types::FundamentalType>(types::FundamentalTypeKind::Char),
             static_cast<uint32_t>(this->m_value.size()) + 1
@@ -34,10 +46,28 @@ namespace AST {
         auto str = llvm::StringRef{ this->m_value.c_str() };
         auto global_str = builder.builder->CreateGlobalString(str);
 
-        return codegen::StackValue{
+        if (scope.is_lvalue) {
-            builder.builder->CreateLoad(stack_type->codegen(builder), global_str, "literal"),
+            return codegen::StackValue{
-            std::unique_ptr<types::Type>{stack_type},
+                global_str,
-        };
+                std::unique_ptr<types::Type>{stack_type},
+            };
+        }
+        else {
+            return codegen::StackValue{
+                builder.builder->CreateLoad(stack_type->codegen(builder), global_str, "literal"),
+                std::unique_ptr<types::Type>{stack_type},
+            };
+        }
+    }
+
+    std::shared_ptr<types::Type> ValueReferenceExpression::get_codegen_type(codegen::Scope& scope) {
+        auto value = scope.values.find(this->m_name);
+        if (value != scope.values.end()) {
+            return value->second.ty;
+        }
+        else {
+            throw CompileError("Value " + this->m_name + " not found", this->m_meta);
+        }
     }
 
     codegen::StackValue ValueReferenceExpression::codegen(codegen::Builder& builder, codegen::Scope& scope) {
@@ -59,6 +89,30 @@ namespace AST {
         }
     }
 
+    std::shared_ptr<types::Type> BinaryOperationExpression::get_codegen_type(codegen::Scope& scope) {
+        auto lhs = this->m_lhs->get_codegen_type(scope);
+        auto rhs = this->m_rhs->get_codegen_type(scope);
+        try {
+            switch (this->m_binop) {
+            case types::BinOp::Assignment:
+                return rhs;
+            default:
+                auto binop = types::find_binop(
+                    scope.binops,
+                    lhs,
+                    this->m_binop,
+                    rhs);
+                if (binop) {
+                    return binop->result(*binop, lhs, rhs);
+                }
+                throw CompileError("invalid binop", this->m_meta);
+            }
+        }
+        catch (std::runtime_error& error) {
+            throw CompileError(error.what(), this->m_meta);
+        }
+    }
+
     codegen::StackValue BinaryOperationExpression::codegen(codegen::Builder& builder, codegen::Scope& scope) {
         auto lvalued = scope.with_lvalue();
         auto lhs = this->m_lhs->codegen(builder, this->m_binop == types::BinOp::Assignment ? lvalued : scope);
@@ -88,6 +142,11 @@ namespace AST {
         }
     }
 
+    std::shared_ptr<types::Type> FunctionCallExpression::get_codegen_type(codegen::Scope& scope) {
+        auto fn_ty = this->m_fn_expr->get_codegen_type(scope);
+        return *fn_ty->return_type();
+    }
+
     codegen::StackValue FunctionCallExpression::codegen(codegen::Builder& builder, codegen::Scope& scope) {
         std::vector<llvm::Value*> args{};
         for (auto& arg : this->m_args) {
@@ -102,24 +161,54 @@ namespace AST {
         };
     }
 
+    std::shared_ptr<types::Type> CastExpression::get_codegen_type(codegen::Scope&) {
+        return this->m_ty;
+    }
+
     codegen::StackValue CastExpression::codegen(codegen::Builder& builder, codegen::Scope& scope) {
-        auto expr = this->m_expr->codegen(builder, scope);
+        auto expr_ty = this->m_expr->get_codegen_type(scope);
-        auto cast = types::find_cast(scope.casts, expr.ty, this->m_ty);
+        if ((expr_ty->m_kind == types::TypeKind::Array
-        if (cast) {
+            || expr_ty->m_kind == types::TypeKind::Pointer)
-            if (cast->target_ty->m_kind == types::TypeKind::Pointer && cast->casted_ty->m_kind == types::TypeKind::Array) {
+            && this->m_ty->m_kind == types::TypeKind::Pointer) {
-                auto allocated = builder.builder->CreateAlloca(cast->casted_ty->codegen(builder));
+            std::cout << expr_ty->formatted() << std::endl;
-                builder.builder->CreateStore(expr.value, allocated);
+            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{
+            else {
-                cast->codegen(builder, cast->target_ty, expr.value),
+                return expr;
-                cast->target_ty
+            }
-            };
         }
-        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;
+        }
+    }
+
+    std::shared_ptr<types::Type> RefExpression::get_codegen_type(codegen::Scope& scope) {
+        return std::shared_ptr<types::Type> {
+            new types::PointerType{ this->m_expr->get_codegen_type(scope) }
+        };
     }
 
     codegen::StackValue RefExpression::codegen(codegen::Builder& builder, codegen::Scope& scope) {
@@ -127,6 +216,17 @@ namespace AST {
         return this->m_expr->codegen(builder, with_lvalue);
     }
 
+    std::shared_ptr<types::Type> DerefExpression::get_codegen_type(codegen::Scope& scope) {
+        auto ty = this->m_expr->get_codegen_type(scope);
+        if (ty->m_kind == types::TypeKind::Pointer) {
+            auto ptr_ty = dynamic_cast<types::PointerType*>(ty.get());
+            return ptr_ty->m_inner;
+        }
+        else {
+            throw new CompileError("Tried to deref a non-pointer!", this->m_meta);
+        }
+    }
+
     codegen::StackValue DerefExpression::codegen(codegen::Builder& builder, codegen::Scope& scope) {
         auto value = this->m_expr->codegen(builder, scope);
         if (value.ty->m_kind == types::TypeKind::Pointer) {
@@ -141,6 +241,21 @@ namespace AST {
         }
     }
 
+    std::shared_ptr<types::Type> IndexAccessExpression::get_codegen_type(codegen::Scope& scope) {
+        auto ty = this->m_expr->get_codegen_type(scope);
+        if (ty->m_kind == types::TypeKind::Array) {
+            auto ptr_ty = dynamic_cast<types::ArrayType*>(ty.get());
+            return ptr_ty->m_inner;
+        }
+        else if (ty->m_kind == types::TypeKind::Pointer) {
+            auto ptr_ty = dynamic_cast<types::PointerType*>(ty.get());
+            return ptr_ty->m_inner;
+        }
+        else {
+            throw CompileError("Tried indexing a non-pointer", this->m_meta);
+        }
+    }
+
 
     codegen::StackValue IndexAccessExpression::codegen(codegen::Builder& builder, codegen::Scope& scope) {
         auto lvalue_scope = scope.with_lvalue();
@@ -171,23 +286,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
+                // Must be an array otherwise
-            auto arr_ty = dynamic_cast<types::ArrayType*>(ptr_ty->m_inner.get());
+                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");
+                auto gep_value = builder.builder->CreateGEP(arr_ty->m_inner->codegen(builder), value.value, idx_list, "GEP");
-            if (scope.is_lvalue) {
+                if (scope.is_lvalue) {
-                return codegen::StackValue{
+                    return codegen::StackValue{
-                    gep_value,
+                        gep_value,
-                    value.ty,
+                        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 gep_value = builder.builder->CreateGEP(ptr_ty->m_inner->codegen(builder), value.value, idx_list, "GEP");
-                auto loaded = inner_ptr_ty.load(builder, gep_value);
+                if (scope.is_lvalue) {
-                return codegen::StackValue{
+                    return codegen::StackValue{
-                    loaded.first,
+                        gep_value,
-                    loaded.second
+                        value.ty,
-                };
+                    };
+                }
+                else {
+                    auto loaded = value.ty->load(builder, gep_value);
+                    return codegen::StackValue{
+                        loaded.first,
+                        loaded.second
+                    };
+                }
             }
         }
 
@@ -295,19 +429,32 @@ namespace AST {
 
             int counter = 0;
             for (auto& param : this->m_params) {
-                builder.builder->SetInsertPoint(BB);
+                if (param.second->m_kind == types::TypeKind::Pointer) {
-                auto arg_ptr = builder.builder->CreateAlloca(param_ty_ptrs[counter]->codegen(builder));
+                    auto ty = param_ty_ptrs[counter];
-                auto param_ty_ptr = std::shared_ptr<types::Type>{
+                    auto arg = function->getArg(counter++);
-                    new types::PointerType { param_ty_ptrs[counter]}
+                    if (param.first) {
-                };
+                        arg->setName(*param.first);
-                auto arg = function->getArg(counter++);
+                        inner_scope.values[*param.first] = codegen::StackValue{
-                builder.builder->CreateStore(arg, arg_ptr);
+                            arg,
-                if (param.first) {
+                            ty,
-                    arg->setName(*param.first);
+                        };
-                    inner_scope.values[*param.first] = codegen::StackValue{
+                    }
-                        arg_ptr,
+                }
-                        param_ty_ptr,
+                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,
+                        };
+                    }
                 }
             }
 

src/parsing.cpp

@@ -391,7 +391,25 @@ namespace parsing {
                 std::optional<std::string> param_name{};
                 if (inner.peek().type == token::Type::Ident) {
                     param_name = inner.expect(token::Type::Ident).content;
+
+                    std::cout << inner.peek().formatted() << std::endl;
+                    auto postfix = parse_array_postfix(inner, true);
+                    while (postfix.ok()) {
+                        auto array_postfix = postfix.unwrap();
+                        if (array_postfix) {
+                            param_ty = std::shared_ptr<types::Type>{
+                                new types::PointerType(param_ty)
+                            };
+                        }
+                        else {
+                            param_ty = std::shared_ptr<types::Type>{
+                                new types::PointerType(param_ty)
+                            };
+                        }
+                        postfix = parse_array_postfix(inner, true);
+                    }
                 }
+
                 params.push_back(std::pair(param_name, std::move(param_ty)));
             }
 

test.c

@@ -6,8 +6,8 @@ int fibonacci(int n) {
     return fibonacci(n - 1) + fibonacci(n - 2);
 }
 
-void modify_value(char* otus) {
+void change_first(char otus[5]) {
-    *otus = 20;
+    otus[0] = 115;
 }
 
 int main() {
@@ -17,8 +17,7 @@ int main() {
     char somelist[5];
 
     somelist[0] = 15;
-    somelist[1] = 20;
+    change_first(somelist);
-    somelist[2] = 25;
 
     return somelist[0];
 }