Parse field accesses

src/ast.cpp

@@ -68,6 +68,13 @@ namespace AST {
         return out.str();
     }
 
+    std::string FieldAccessExpression::formatted() {
+        std::stringstream out{ "" };
+        out << this->m_expr->formatted();
+        out << "." << this->m_field;
+        return out.str();
+    }
+
     std::string ListInitializerExpression::formatted() {
         std::stringstream out{ "" };
         out << "{ ";
@@ -149,4 +156,8 @@ namespace AST {
         }
         return out.str();
     }
+
+    std::string TopLevelTypedef::formatted() {
+        return this->m_ty->formatted();
+    }
 }

src/ast.h

@@ -245,6 +245,32 @@ namespace AST {
         ) override;
     };
 
+    /// @brief Same as value.field
+    class FieldAccessExpression : public Expression {
+    private:
+        std::unique_ptr<Expression> m_expr;
+        std::string m_field;
+    public:
+        FieldAccessExpression(
+            token::Metadata meta,
+            std::unique_ptr<Expression> expr,
+            std::string field)
+            : Expression{ meta }
+            , m_expr{ std::move(expr) }
+            , m_field{ field } {
+        }
+        virtual ~FieldAccessExpression() 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,
+            std::optional<std::shared_ptr<types::Type>> expected_ty
+        ) override;
+    };
+
+    /// @brief Same as {value1, value2}
     class ListInitializerExpression : public Expression {
     private:
         std::vector<std::unique_ptr<Expression>> m_expressions;
@@ -373,6 +399,22 @@ namespace AST {
         virtual void codegen(codegen::Builder& builder, codegen::Scope& scope) override;
         virtual void typecheck(typecheck::State& state, typecheck::Scope& scope) override;
     };
+
+    class TopLevelTypedef : public TopLevelStatement {
+    private:
+        std::shared_ptr<types::Type> m_ty;
+    public:
+        TopLevelTypedef(
+            token::Metadata meta,
+            std::shared_ptr<types::Type> type)
+            : TopLevelStatement{ meta }
+            , m_ty{ type } {
+        }
+        virtual ~TopLevelTypedef() override = default;
+        virtual std::string formatted() override;
+        virtual void codegen(codegen::Builder& builder, codegen::Scope& scope) override;
+        virtual void typecheck(typecheck::State& state, typecheck::Scope& scope) override;
+    };
 }
 
 #endif

src/builder.h

@@ -1,6 +1,8 @@
 #ifndef BUILDER_H
 #define BUILDER_H
 
+#include <map>
+
 #include <llvm/IR/LLVMContext.h>
 #include <llvm/IR/IRBuilder.h>
 
@@ -11,6 +13,8 @@ namespace codegen {
         std::unique_ptr<llvm::IRBuilder<>> builder;
         llvm::BasicBlock* block;
     };
+
+    typedef std::map<std::string, llvm::Type*> TypeMap;
 }
 
 #endif

src/casting.cpp

@@ -32,13 +32,15 @@ namespace types {
                 if (target_ty->is_signed()) {
                     casts.push_back(CastDefinition{ source_ty, target_ty, allow_implicit,
                         [](codegen::Builder& builder, std::shared_ptr<Type> target, llvm::Value* value) {
-                            return builder.builder->CreateSExtOrTrunc(value, target->codegen(builder), "cast");
+                            codegen::TypeMap empty {};
+                            return builder.builder->CreateSExtOrTrunc(value, target->codegen(builder, empty), "cast");
                         } });
                 }
                 else {
                     casts.push_back(CastDefinition{ source_ty, target_ty, allow_implicit,
                         [](codegen::Builder& builder, std::shared_ptr<Type> target, llvm::Value* value) {
-                            return builder.builder->CreateZExtOrTrunc(value, target->codegen(builder), "cast");
+                            codegen::TypeMap empty {};
+                            return builder.builder->CreateZExtOrTrunc(value, target->codegen(builder, empty), "cast");
                         } });
                 }
             }
@@ -60,14 +62,6 @@ namespace types {
                 return {};
             return CastDefinition{ casted_ty, target_ty, true,
                 [](codegen::Builder&, std::shared_ptr<Type>, llvm::Value* value) {
-                    // auto ptr_ty = dynamic_cast<types::PointerType*>(target.get());
-
-                    // std::vector<llvm::Value*> indices {};
-                    // indices.push_back(llvm::ConstantInt::get(
-                    //     builder.builder->getInt32Ty(),
-                    //     0
-                    // ));
-                    // return builder.builder->CreateGEP(ptr_ty->m_inner->codegen(builder), value, indices, "arraydecay");
                     return value;
             } };
         }

src/codegen.cpp

@@ -11,7 +11,7 @@
 
 namespace codegen {
     Scope Scope::with_lvalue() {
-        return Scope{ this->binops, this->casts, this->values, true };
+        return Scope{ this->binops, this->casts, this->structs, this->values, true };
     }
 }
 
@@ -20,8 +20,8 @@ namespace AST {
         return this->m_ty;
     }
 
-    codegen::StackValue IntLiteralExpression::codegen(codegen::Builder& builder, codegen::Scope&) {
-        auto ty = this->m_ty->codegen(builder);
+    codegen::StackValue IntLiteralExpression::codegen(codegen::Builder& builder, codegen::Scope& scope) {
+        auto ty = this->m_ty->codegen(builder, scope.structs);
 
         return codegen::StackValue{
             llvm::ConstantInt::get(ty, this->m_value),
@@ -56,7 +56,7 @@ namespace AST {
         }
         else {
             return codegen::StackValue{
-                builder.builder->CreateLoad(stack_type->codegen(builder), global_str, "literal"),
+                builder.builder->CreateLoad(stack_type->codegen(builder, scope.structs), global_str, "literal"),
                 std::unique_ptr<types::Type>{stack_type},
             };
         }
@@ -83,7 +83,7 @@ namespace AST {
                 return value->second;
             }
             else {
-                auto loaded = value->second.ty->load(builder, value->second.value);
+                auto loaded = value->second.ty->load(builder, value->second.value, scope.structs);
                 return codegen::StackValue{
                     loaded.first,
                     loaded.second
@@ -160,7 +160,7 @@ namespace AST {
         }
         auto function = this->m_fn_expr->codegen(builder, scope);
 
-        auto value = builder.builder->CreateCall(llvm::dyn_cast<llvm::FunctionType>(function.ty->codegen(builder)), function.value, args, "call");
+        auto value = builder.builder->CreateCall(llvm::dyn_cast<llvm::FunctionType>(function.ty->codegen(builder, scope.structs)), function.value, args, "call");
         return codegen::StackValue{
             value,
             *function.ty->return_type(),
@@ -226,7 +226,7 @@ namespace AST {
     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) {
-            auto loaded = value.ty->load(builder, value.value);
+            auto loaded = value.ty->load(builder, value.value, scope.structs);
             return codegen::StackValue{
                 loaded.first,
                 loaded.second
@@ -267,7 +267,7 @@ namespace AST {
             if (ptr_ty->m_inner->m_kind == types::TypeKind::Pointer) {
                 auto inner_ptr_ty = dynamic_cast<types::PointerType*>(ptr_ty->m_inner.get());
 
-                auto gep_value = builder.builder->CreateGEP(inner_ptr_ty->m_inner->codegen(builder), value.value, idx_list, "GEP");
+                auto gep_value = builder.builder->CreateGEP(inner_ptr_ty->m_inner->codegen(builder, scope.structs), value.value, idx_list, "GEP");
                 if (scope.is_lvalue) {
                     return codegen::StackValue{
                         gep_value,
@@ -275,7 +275,7 @@ namespace AST {
                     };
                 }
                 else {
-                    auto loaded = value.ty->load(builder, gep_value);
+                    auto loaded = value.ty->load(builder, gep_value, scope.structs);
                     return codegen::StackValue{
                         loaded.first,
                         loaded.second
@@ -283,11 +283,9 @@ 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");
+                auto gep_value = builder.builder->CreateGEP(arr_ty->m_inner->codegen(builder, scope.structs), value.value, idx_list, "GEP");
                 if (scope.is_lvalue) {
                     return codegen::StackValue{
                         gep_value,
@@ -296,7 +294,7 @@ namespace AST {
                 }
                 else {
                     auto inner_ptr_ty = types::PointerType{ arr_ty->m_inner };
-                    auto loaded = inner_ptr_ty.load(builder, gep_value);
+                    auto loaded = inner_ptr_ty.load(builder, gep_value, scope.structs);
                     return codegen::StackValue{
                         loaded.first,
                         loaded.second
@@ -304,7 +302,7 @@ namespace AST {
                 }
             }
             else {
-                auto gep_value = builder.builder->CreateGEP(ptr_ty->m_inner->codegen(builder), value.value, idx_list, "GEP");
+                auto gep_value = builder.builder->CreateGEP(ptr_ty->m_inner->codegen(builder, scope.structs), value.value, idx_list, "GEP");
                 if (scope.is_lvalue) {
                     return codegen::StackValue{
                         gep_value,
@@ -312,7 +310,7 @@ namespace AST {
                     };
                 }
                 else {
-                    auto loaded = value.ty->load(builder, gep_value);
+                    auto loaded = value.ty->load(builder, gep_value, scope.structs);
                     return codegen::StackValue{
                         loaded.first,
                         loaded.second
@@ -325,13 +323,79 @@ namespace AST {
     }
 
 
+    std::shared_ptr<types::Type> FieldAccessExpression::get_codegen_type(codegen::Scope& scope) {
+        auto ty = this->m_expr->get_codegen_type(scope);
+        if (ty->m_kind == types::TypeKind::Struct) {
+            auto struct_ty = dynamic_cast<types::StructType*>(ty.get());
+            if (struct_ty->m_fields) {
+                for (auto& field : *struct_ty->m_fields) {
+                    if (field.first == this->m_field)
+                        return field.second;
+                }
+                throw CompileError("Unknown field", this->m_meta);
+            }
+            throw CompileError("Cannot access a field of opaque struct", this->m_meta);
+        }
+        else {
+            throw CompileError("Tried accessing a non-struct", this->m_meta);
+        }
+    }
+
+    codegen::StackValue FieldAccessExpression::codegen(codegen::Builder& builder, codegen::Scope& scope) {
+        auto lvalued = scope.with_lvalue();
+        auto struct_ptr = this->m_expr->codegen(builder, lvalued);
+        if (struct_ptr.ty->m_kind == types::TypeKind::Pointer) {
+            auto ptr_ty = dynamic_cast<types::PointerType*>(struct_ptr.ty.get());
+            if (ptr_ty->m_inner->m_kind == types::TypeKind::Struct) {
+                auto struct_ty = dynamic_cast<types::StructType*>(ptr_ty->m_inner.get());
+
+                int idx = -1;
+                auto field_ty = std::shared_ptr<types::Type>{};
+
+                for (int i = 0; i < static_cast<int>(struct_ty->m_fields->size()); i++) {
+                    auto field = (*struct_ty->m_fields)[i];
+                    if (field.first == this->m_field) {
+                        idx = i;
+                        field_ty = field.second;
+                        break;
+                    }
+                }
+
+                auto gep = builder.builder->CreateStructGEP(
+                    ptr_ty->m_inner->codegen(builder, scope.structs), struct_ptr.value, idx);
+
+                auto ptr_ty = std::shared_ptr<types::Type>{
+                    new types::PointerType { field_ty }
+                };
+
+                if (scope.is_lvalue) {
+                    return codegen::StackValue{
+                        gep,
+                        ptr_ty
+                    };
+                }
+                else {
+                    auto loaded = ptr_ty->load(builder, gep, scope.structs);
+                    return codegen::StackValue{ loaded.first, loaded.second };
+                }
+            }
+            else {
+                throw CompileError("Tried field-accessing a non-struct-pointer", this->m_meta);
+            }
+        }
+        else {
+            throw CompileError("Tried field-accessing a non-pointer", this->m_meta);
+        }
+    }
+
+
 
     std::shared_ptr<types::Type> ListInitializerExpression::get_codegen_type(codegen::Scope&) {
         return this->m_ty;
     }
 
     codegen::StackValue ListInitializerExpression::codegen(codegen::Builder& builder, codegen::Scope& scope) {
-        auto array_ptr = builder.builder->CreateAlloca(this->m_ty->codegen(builder));
+        auto value_ptr = builder.builder->CreateAlloca(this->m_ty->codegen(builder, scope.structs));
 
         if (this->m_ty->m_kind == types::TypeKind::Array) {
             auto array_ty = dynamic_cast<types::ArrayType*>(this->m_ty.get());
@@ -341,7 +405,7 @@ namespace AST {
                 std::vector<llvm::Value*> indices{};
                 indices.push_back(llvm::ConstantInt::get(builder.builder->getInt32Ty(), counter++));
                 auto gep = builder.builder->CreateGEP(
-                    array_ty->m_inner->codegen(builder), array_ptr, indices, "GEP");
+                    array_ty->m_inner->codegen(builder, scope.structs), value_ptr, indices, "GEP");
                 builder.builder->CreateStore(expr->codegen(builder, scope).value, gep);
             }
 
@@ -350,13 +414,38 @@ namespace AST {
             };
 
             if (scope.is_lvalue) {
-                return codegen::StackValue{ array_ptr, ptr_ty };
+                return codegen::StackValue{ value_ptr, ptr_ty };
             }
             else {
-                auto loaded = ptr_ty->load(builder, array_ptr);
+                auto loaded = ptr_ty->load(builder, value_ptr, scope.structs);
                 return codegen::StackValue{ loaded.first, loaded.second };
             }
         }
+        else if (this->m_ty->m_kind == types::TypeKind::Struct) {
+            auto struct_ty = dynamic_cast<types::StructType*>(this->m_ty.get());
+
+            for (int i = 0; i < static_cast<int>(this->m_expressions.size()); i++) {
+                std::vector<llvm::Value*> indices{};
+                auto gep = builder.builder->CreateStructGEP(
+                    struct_ty->codegen(builder, scope.structs), value_ptr, i, "struct_gep"
+                );
+                builder.builder->CreateStore(
+                    this->m_expressions[i]->codegen(builder, scope).value, gep);
+            }
+
+            auto ptr_ty = std::shared_ptr<types::Type>{
+                new types::PointerType{this->m_ty}
+            };
+
+            if (scope.is_lvalue) {
+                return codegen::StackValue{ value_ptr, ptr_ty };
+            }
+            else {
+                auto loaded = ptr_ty->load(builder, value_ptr, scope.structs);
+                return codegen::StackValue{ loaded.first, loaded.second };
+            }
+
+        }
         else {
             throw CompileError("Tried to list-initialize a non-array!", this->m_meta);
         }
@@ -387,7 +476,7 @@ namespace AST {
 
         builder.builder->SetInsertPoint(builder.block);
 
-        auto ty = this->m_type->codegen(builder);
+        auto ty = this->m_type->codegen(builder, scope.structs);
         auto ptr = builder.builder->CreateAlloca(ty);
         if (this->m_expr.has_value()) {
             auto value = this->m_expr->get()->codegen(builder, scope);
@@ -445,7 +534,7 @@ namespace AST {
 
         auto fn_ty_ptr = std::shared_ptr<types::Type>{ new types::FunctionType{ ret_ty_ptr, param_ty_ptrs, this->m_is_vararg } };
 
-        auto fn_ty = fn_ty_ptr->codegen(builder);
+        auto fn_ty = fn_ty_ptr->codegen(builder, scope.structs);
         auto function = llvm::Function::Create(
             llvm::dyn_cast<llvm::FunctionType>(fn_ty),
             llvm::GlobalValue::LinkageTypes::ExternalLinkage,
@@ -476,7 +565,7 @@ namespace AST {
                 }
                 else {
                     builder.builder->SetInsertPoint(BB);
-                    auto arg_ptr = builder.builder->CreateAlloca(param_ty_ptrs[counter]->codegen(builder));
+                    auto arg_ptr = builder.builder->CreateAlloca(param_ty_ptrs[counter]->codegen(builder, scope.structs));
                     auto param_ty_ptr = std::shared_ptr<types::Type>{
                         new types::PointerType { param_ty_ptrs[counter]}
                     };
@@ -503,10 +592,20 @@ namespace AST {
 
         builder.block = nullptr;
     }
+
+    void TopLevelTypedef::codegen(codegen::Builder& builder, codegen::Scope& scope) {
+        auto ty = this->m_ty->codegen(builder, scope.structs);
+        if (this->m_ty->m_kind == types::TypeKind::Struct) {
+            auto struct_ty = dynamic_cast<types::StructType*>(this->m_ty.get());
+            if (struct_ty->m_name) {
+                scope.structs[*struct_ty->m_name] = ty;
+            }
+        }
+    }
 }
 
 namespace types {
-    llvm::Type* FundamentalType::codegen(codegen::Builder& builder) {
+    llvm::Type* FundamentalType::codegen(codegen::Builder& builder, codegen::TypeMap&) {
         switch (this->m_ty) {
         case FundamentalTypeKind::Int:
             return builder.builder->getInt32Ty();
@@ -521,23 +620,55 @@ namespace types {
         }
     }
 
-    llvm::Type* FunctionType::codegen(codegen::Builder& builder) {
+    llvm::Type* FunctionType::codegen(codegen::Builder& builder, codegen::TypeMap& structs) {
         std::vector<llvm::Type*> params{};
 
         for (auto& param : this->m_param_tys) {
-            params.push_back(param->codegen(builder));
+            params.push_back(param->codegen(builder, structs));
         }
 
-        auto ret_ty = this->m_ret_ty->codegen(builder);
+        auto ret_ty = this->m_ret_ty->codegen(builder, structs);
 
         return llvm::FunctionType::get(ret_ty, params, this->m_vararg);
     }
 
-    llvm::Type* PointerType::codegen(codegen::Builder& builder) {
+    llvm::Type* PointerType::codegen(codegen::Builder& builder, codegen::TypeMap&) {
         return llvm::PointerType::get(*builder.context, 0);
     }
 
-    llvm::Type* ArrayType::codegen(codegen::Builder& builder) {
-        return llvm::ArrayType::get(this->m_inner->codegen(builder), this->m_size);
+    llvm::Type* ArrayType::codegen(codegen::Builder& builder, codegen::TypeMap& structs) {
+        return llvm::ArrayType::get(this->m_inner->codegen(builder, structs), this->m_size);
     }
+
+    llvm::Type* StructType::codegen(codegen::Builder& builder, codegen::TypeMap& structs) {
+        if (this->m_is_ref) {
+            if (this->m_name) {
+                return structs[*this->m_name];
+            }
+            else {
+                throw CompileError("reference to nonexistant struct", {});
+            }
+        }
+        if (this->m_fields) {
+            std::vector<llvm::Type*> fields{};
+            for (auto& field : *this->m_fields) {
+                fields.push_back(field.second->codegen(builder, structs));
+            }
+
+            auto ty = llvm::StructType::create(*builder.context, fields);
+            if (this->m_name)
+                ty->setName(*this->m_name);
+            return ty;
+        }
+        else {
+            auto ty = llvm::StructType::create(*builder.context);
+            if (this->m_name)
+                ty->setName(*this->m_name);
+            return ty;
+        }
+    }
+
+    // llvm::Type* StructRef::codegen(codegen::Builder&, codegen::TypeMap& structs) {
+    //     return structs[this->m_name];
+    // }
 }

src/codegen.h

@@ -22,7 +22,9 @@ namespace codegen {
         std::vector<types::BinopDefinition>& binops;
         std::vector<types::CastDefinition>& casts;
 
+        TypeMap structs;
         std::map<std::string, StackValue> values;
+
         bool is_lvalue;
 
         Scope with_lvalue();

src/main.cpp

@@ -70,12 +70,14 @@ std::optional<CompileOutput> compile(std::string_view in_filename) {
     }
 
     // Parse tokens
+    parsing::Scope parse_scope{};
+
     auto stream = token::TokenStream{ tokens };
     std::vector<std::unique_ptr<AST::TopLevelStatement>> statements;
-    auto statement = parsing::parse_top_level_statement(stream);
+    auto statement = parsing::parse_top_level_statement(stream, parse_scope);
     while (statement.ok()) {
         statements.push_back(statement.unwrap());
-        statement = parsing::parse_top_level_statement(stream);
+        statement = parsing::parse_top_level_statement(stream, parse_scope);
     }
     if (stream.peek().type != token::Type::Eof) {
         std::cerr << statement.unwrap_err() << std::endl;
@@ -122,6 +124,7 @@ std::optional<CompileOutput> compile(std::string_view in_filename) {
     codegen::Scope cg_scope{
         .binops = typecheck_state.binops,
         .casts = typecheck_state.casts,
+        .structs = {},
         .values = {},
         .is_lvalue = false,
     };
@@ -162,7 +165,7 @@ std::optional<CompileOutput> compile(std::string_view in_filename) {
     builder.mod->print(llvm_ir_dest, nullptr);
     llvm_ir_dest.flush();
 
-    std::cout << llvm_ir_string << std::endl;
+    // std::cout << llvm_ir_string << std::endl;
 
     // Print output to obj-file
     std::error_code EC;

src/parsing.cpp

@@ -5,32 +5,82 @@
 
 namespace parsing {
     namespace {
-        Result<std::unique_ptr<AST::Expression>, std::string> parse_expression(token::TokenStream& stream);
+        Result<std::unique_ptr<AST::Expression>, std::string> parse_expression(token::TokenStream& stream, Scope& scope);
 
-        Result<std::shared_ptr<types::Type>, std::string> parse_type(token::TokenStream& stream) {
+        Result<std::shared_ptr<types::Type>, std::string> parse_type(token::TokenStream& stream, Scope& scope) {
             token::TokenStream inner{ stream };
             try {
                 auto token = inner.expect(token::Type::Ident);
 
-                // TODO eventually make this be potentially more than one word
-                std::string type_name = token.content;
-
                 std::shared_ptr<types::Type> returned{};
 
-                if (type_name == "int") {
-                    auto ty = new types::FundamentalType{ types::FundamentalTypeKind::Int };
-                    returned = std::shared_ptr<types::Type>{ ty };
-                }
-                else if (type_name == "char") {
-                    auto ty = new types::FundamentalType{ types::FundamentalTypeKind::Char };
-                    returned = std::shared_ptr<types::Type>{ ty };
-                }
-                else if (type_name == "void") {
-                    auto ty = new types::FundamentalType{ types::FundamentalTypeKind::Void };
-                    returned = std::shared_ptr<types::Type>{ ty };
+                if (token.content == "struct") {
+                    std::optional<std::string> struct_name{};
+
+                    if (inner.peek().type == token::Type::Ident) {
+                        struct_name = inner.expect(token::Type::Ident).content;
+                    }
+
+                    std::optional<std::vector<types::StructField>> maybe_fields{};
+
+                    if (inner.peek().content == "{") {
+                        std::vector<types::StructField> fields{};
+
+                        inner.expect(token::Type::Symbol, "{");
+
+                        int counter = 0;
+                        while (inner.peek().content != "}") {
+                            if (counter++ > 0)
+                                inner.expect(token::Type::Symbol, ";");
+
+                            auto ty = parse_type(inner, scope);
+                            if (!ty.ok())
+                                break;
+
+                            auto field_name = inner.expect(token::Type::Ident);
+                            fields.push_back(types::StructField{ field_name.content, ty.unwrap() });
+                        }
+
+                        inner.expect(token::Type::Symbol, "}");
+
+                        maybe_fields = fields;
+                    }
+
+
+                    if (!struct_name && !maybe_fields) {
+                        throw std::runtime_error("Struct must have a name or fields!");
+                    }
+
+                    if (struct_name && !maybe_fields && scope.structs.find(*struct_name) != scope.structs.end()) {
+                        auto original_ty = scope.structs[*struct_name];
+                        auto original_struct_ty = dynamic_cast<types::StructType*>(original_ty.get());
+                        auto ty = new types::StructType{ struct_name, original_struct_ty->m_fields, true };
+                        returned = std::shared_ptr<types::Type>{ ty };
+                    }
+                    else {
+                        auto ty = new types::StructType{ struct_name, maybe_fields, false };
+                        returned = std::shared_ptr<types::Type>{ ty };
+                    }
                 }
                 else {
-                    throw std::runtime_error("Expected type name, got " + type_name);
+                    // TODO eventually make this be potentially more than one word
+                    std::string type_name = token.content;
+
+                    if (type_name == "int") {
+                        auto ty = new types::FundamentalType{ types::FundamentalTypeKind::Int };
+                        returned = std::shared_ptr<types::Type>{ ty };
+                    }
+                    else if (type_name == "char") {
+                        auto ty = new types::FundamentalType{ types::FundamentalTypeKind::Char };
+                        returned = std::shared_ptr<types::Type>{ ty };
+                    }
+                    else if (type_name == "void") {
+                        auto ty = new types::FundamentalType{ types::FundamentalTypeKind::Void };
+                        returned = std::shared_ptr<types::Type>{ ty };
+                    }
+                    else {
+                        throw std::runtime_error("Expected type name, got " + type_name);
+                    }
                 }
 
                 while (inner.peek().type == token::Type::Symbol && inner.peek().content == "*") {
@@ -49,7 +99,7 @@ namespace parsing {
             }
         }
 
-        Result<std::optional<uint32_t>, std::string> parse_array_postfix(token::TokenStream& stream, bool allow_empty) {
+        Result<std::optional<uint32_t>, std::string> parse_array_postfix(token::TokenStream& stream, bool allow_empty, Scope&) {
             token::TokenStream inner{ stream };
             try {
                 std::optional<uint32_t> returned{};
@@ -71,7 +121,7 @@ namespace parsing {
             }
         }
 
-        Result<std::unique_ptr<AST::Expression>, std::string> parse_list_initializer(token::TokenStream& stream) {
+        Result<std::unique_ptr<AST::Expression>, std::string> parse_list_initializer(token::TokenStream& stream, Scope& scope) {
             token::TokenStream inner{ stream };
             try {
                 auto before_meta = inner.metadata();
@@ -85,7 +135,7 @@ namespace parsing {
                     if (counter++ > 0) {
                         inner.expect(token::Type::Symbol, ",");
                     }
-                    expressions.push_back(parse_expression(inner).unwrap());
+                    expressions.push_back(parse_expression(inner, scope).unwrap());
                 }
 
                 inner.expect(token::Type::Symbol, "}");
@@ -105,10 +155,10 @@ namespace parsing {
             }
         }
 
-        Result<std::unique_ptr<AST::Expression>, std::string> parse_plain_expression(token::TokenStream& stream) {
+        Result<std::unique_ptr<AST::Expression>, std::string> parse_plain_expression(token::TokenStream& stream, Scope& scope) {
             token::TokenStream inner{ stream };
             try {
-                if (auto list_init = parse_list_initializer(inner); list_init.ok()) {
+                if (auto list_init = parse_list_initializer(inner, scope); list_init.ok()) {
                     stream.m_position = inner.m_position;
 
                     return std::unique_ptr<AST::Expression> { list_init.unwrap() };
@@ -142,11 +192,11 @@ namespace parsing {
             }
         }
 
-        Result<std::shared_ptr<types::Type>, std::string> parse_cast(token::TokenStream& stream) {
+        Result<std::shared_ptr<types::Type>, std::string> parse_cast(token::TokenStream& stream, Scope& scope) {
             token::TokenStream inner{ stream };
             try {
                 inner.expect(token::Type::Symbol, "(");
-                auto ty = parse_type(inner).unwrap();
+                auto ty = parse_type(inner, scope).unwrap();
                 inner.expect(token::Type::Symbol, ")");
 
                 stream.m_position = inner.m_position;
@@ -158,14 +208,14 @@ namespace parsing {
             }
         }
 
-        Result<std::unique_ptr<AST::Expression>, std::string> parse_primary_expression(token::TokenStream& stream) {
+        Result<std::unique_ptr<AST::Expression>, std::string> parse_primary_expression(token::TokenStream& stream, Scope& scope) {
             token::TokenStream inner{ stream };
             try {
                 auto before_meta = inner.metadata();
 
 
-                if (auto cast = parse_cast(inner); cast.ok()) {
-                    auto expr = parse_primary_expression(inner).unwrap();
+                if (auto cast = parse_cast(inner, scope); cast.ok()) {
+                    auto expr = parse_primary_expression(inner, scope).unwrap();
                     stream.m_position = inner.m_position;
                     return std::unique_ptr<AST::Expression>{
                         new AST::CastExpression{
@@ -177,14 +227,14 @@ namespace parsing {
                 }
                 else if (inner.peek().content == "(") {
                     inner.next();
-                    auto expr = parse_expression(inner).unwrap();
+                    auto expr = parse_expression(inner, scope).unwrap();
                     inner.expect(token::Type::Symbol, ")");
                     stream.m_position = inner.m_position;
                     return expr;
                 }
                 else if (inner.peek().content == "&") {
                     inner.next();
-                    auto expr = parse_primary_expression(inner).unwrap();
+                    auto expr = parse_primary_expression(inner, scope).unwrap();
                     stream.m_position = inner.m_position;
                     return std::unique_ptr<AST::Expression> {
                         new AST::RefExpression(before_meta + inner.metadata(), std::move(expr))
@@ -192,15 +242,15 @@ namespace parsing {
                 }
                 else if (inner.peek().content == "*") {
                     inner.next();
-                    auto expr = parse_primary_expression(inner).unwrap();
+                    auto expr = parse_primary_expression(inner, scope).unwrap();
                     stream.m_position = inner.m_position;
                     return std::unique_ptr<AST::Expression> {
                         new AST::DerefExpression(before_meta + inner.metadata(), std::move(expr))
                     };
                 }
 
-                auto plain_expr = parse_plain_expression(inner);
-                while (inner.peek().content == "(" || inner.peek().content == "[") {
+                auto plain_expr = parse_plain_expression(inner, scope);
+                while (inner.peek().content == "(" || inner.peek().content == "[" || inner.peek().content == ".") {
                     if (inner.peek().content == "(") {
                         inner.next();
 
@@ -210,7 +260,7 @@ namespace parsing {
                         while (inner.peek().content != ")") {
                             if (counter++ > 0)
                                 inner.expect(token::Type::Symbol, ",");
-                            args.push_back(parse_expression(inner).unwrap());
+                            args.push_back(parse_expression(inner, scope).unwrap());
                         }
 
                         inner.expect(token::Type::Symbol, ")");
@@ -218,11 +268,19 @@ namespace parsing {
                         auto fn_call = new AST::FunctionCallExpression{ before_meta + inner.metadata(), plain_expr.unwrap(), std::move(args) };
                         plain_expr = std::unique_ptr<AST::Expression>{ fn_call };
                     }
-                    else if (auto postfix = parse_array_postfix(inner, false); postfix.ok()) {
+                    else if (auto postfix = parse_array_postfix(inner, false, scope); postfix.ok()) {
                         auto idx_expr = new AST::IndexAccessExpression{
                             before_meta + inner.metadata(), plain_expr.unwrap(), *postfix.unwrap() };
                         plain_expr = std::unique_ptr<AST::Expression>{ idx_expr };
                     }
+                    else if (inner.peek().content == ".") {
+                        inner.next();
+                        std::string field_name = inner.expect(token::Type::Ident).content;
+
+                        plain_expr = std::unique_ptr<AST::Expression>{
+                            new AST::FieldAccessExpression{before_meta + inner.metadata(), plain_expr.unwrap(), field_name}
+                        };
+                    }
                 }
 
 
@@ -234,7 +292,7 @@ namespace parsing {
             }
         }
 
-        Result<types::BinOp, std::string> parse_binop(token::TokenStream& stream) {
+        Result<types::BinOp, std::string> parse_binop(token::TokenStream& stream, Scope&) {
             token::TokenStream inner{ stream };
             try {
                 auto token = inner.next();
@@ -270,32 +328,32 @@ namespace parsing {
         }
 
         std::unique_ptr<AST::Expression> parse_rhs(
-            token::TokenStream& stream, std::unique_ptr<AST::Expression> lhs, int prev_precedence) {
+            token::TokenStream& stream, std::unique_ptr<AST::Expression> lhs, int prev_precedence, Scope& scope) {
 
             auto before = stream.metadata();
 
-            auto binop_res = parse_binop(stream);
+            auto binop_res = parse_binop(stream, scope);
             while (binop_res.ok()) {
                 auto binop = binop_res.unwrap();
-                auto rhs = parse_primary_expression(stream).unwrap();
+                auto rhs = parse_primary_expression(stream, scope).unwrap();
 
                 if (types::operator_precedence(binop) > prev_precedence) {
-                    rhs = parse_rhs(stream, std::move(rhs), types::operator_precedence(binop));
+                    rhs = parse_rhs(stream, std::move(rhs), types::operator_precedence(binop), scope);
                 }
 
                 auto binop_expr = new AST::BinaryOperationExpression{ before + stream.metadata(), std::move(lhs), binop, std::move(rhs) };
                 lhs = std::unique_ptr<AST::Expression>{ binop_expr };
 
-                binop_res = parse_binop(stream);
+                binop_res = parse_binop(stream, scope);
             }
 
             return lhs;
         }
 
-        Result<std::unique_ptr<AST::Expression>, std::string> parse_expression(token::TokenStream& stream) {
+        Result<std::unique_ptr<AST::Expression>, std::string> parse_expression(token::TokenStream& stream, Scope& scope) {
             try {
-                auto lhs = parse_primary_expression(stream).unwrap();
-                return std::unique_ptr{ parse_rhs(stream, std::move(lhs), 0) };
+                auto lhs = parse_primary_expression(stream, scope).unwrap();
+                return std::unique_ptr{ parse_rhs(stream, std::move(lhs), 0, scope) };
             }
             catch (std::runtime_error& error) {
                 return std::string{ error.what() };
@@ -304,16 +362,16 @@ namespace parsing {
 
 
 
-        Result<std::unique_ptr<AST::InitializationStatement>, std::string> parse_init_statement(token::TokenStream& stream) {
+        Result<std::unique_ptr<AST::InitializationStatement>, std::string> parse_init_statement(token::TokenStream& stream, Scope& scope) {
             token::TokenStream inner{ stream };
 
             auto before_meta = inner.metadata();
 
             try {
-                auto ty = parse_type(inner).unwrap();
+                auto ty = parse_type(inner, scope).unwrap();
                 auto name = inner.expect(token::Type::Ident);
 
-                auto array_postfix = parse_array_postfix(inner, false);
+                auto array_postfix = parse_array_postfix(inner, false, scope);
                 while (array_postfix.ok()) {
                     auto postfix = array_postfix.unwrap();
                     if (postfix) {
@@ -326,13 +384,13 @@ namespace parsing {
                             new types::PointerType(ty)
                         };
                     }
-                    array_postfix = parse_array_postfix(inner, false);
+                    array_postfix = parse_array_postfix(inner, false, scope);
                 }
 
                 std::optional<std::unique_ptr<AST::Expression>> expr = {};
                 if (inner.peek().type == token::Type::Symbol && inner.peek().content == "=") {
                     inner.expect(token::Type::Symbol, "=");
-                    expr = parse_expression(inner).unwrap();
+                    expr = parse_expression(inner, scope).unwrap();
                 }
 
                 inner.expect(token::Type::Symbol, ";");
@@ -346,13 +404,13 @@ namespace parsing {
             }
         }
 
-        Result<std::unique_ptr<AST::Statement>, std::string> parse_statement(token::TokenStream& stream) {
+        Result<std::unique_ptr<AST::Statement>, std::string> parse_statement(token::TokenStream& stream, Scope& scope) {
             token::TokenStream inner{ stream };
             auto before_meta = inner.metadata();
             try {
                 if (inner.peek().type == token::Type::ReturnKeyword) {
                     inner.next();
-                    auto expression = parse_expression(inner).unwrap();
+                    auto expression = parse_expression(inner, scope).unwrap();
                     inner.expect(token::Type::Symbol, ";");
 
                     stream.m_position = inner.m_position;
@@ -363,14 +421,14 @@ namespace parsing {
                 else if (inner.peek().type == token::Type::IfKeyword) {
                     inner.next();
                     inner.expect(token::Type::Symbol, "(");
-                    auto expression = parse_expression(inner).unwrap();
+                    auto expression = parse_expression(inner, scope).unwrap();
                     inner.expect(token::Type::Symbol, ")");
 
-                    auto then_statement = parse_statement(inner).unwrap();
+                    auto then_statement = parse_statement(inner, scope).unwrap();
                     std::optional<std::unique_ptr<AST::Statement>> else_statement{};
                     if (inner.peek().type == token::Type::ElseKeyword) {
                         inner.next();
-                        else_statement = parse_statement(inner).unwrap();
+                        else_statement = parse_statement(inner, scope).unwrap();
                     }
 
                     stream.m_position = inner.m_position;
@@ -383,11 +441,11 @@ namespace parsing {
                     };
                     return std::unique_ptr<AST::Statement>{ statement };
                 }
-                else if (auto init = parse_init_statement(inner); init.ok()) {
+                else if (auto init = parse_init_statement(inner, scope); init.ok()) {
                     stream.m_position = inner.m_position;
                     return std::unique_ptr<AST::Statement>{ init.unwrap() };
                 }
-                else if (auto expr = parse_expression(inner); expr.ok()) {
+                else if (auto expr = parse_expression(inner, scope); expr.ok()) {
                     stream.m_position = inner.m_position;
                     stream.expect(token::Type::Symbol, ";");
                     auto expr_statement = new AST::ExpressionStatement{ before_meta + stream.metadata(), expr.unwrap() };
@@ -404,11 +462,11 @@ namespace parsing {
         }
     }
 
-    Result<std::unique_ptr<AST::TopLevelStatement>, std::string> parse_top_level_statement(token::TokenStream& stream) {
+    Result<std::unique_ptr<AST::TopLevelStatement>, std::string> parse_function(token::TokenStream& stream, Scope& scope) {
         token::TokenStream inner{ stream };
         auto before_meta = inner.metadata();
         try {
-            auto type = parse_type(inner).unwrap();
+            auto type = parse_type(inner, scope).unwrap();
             auto name_token = inner.expect(token::Type::Ident);
             inner.expect(token::Type::Symbol, "(");
 
@@ -427,13 +485,12 @@ namespace parsing {
                     break;
                 }
 
-                auto param_ty = parse_type(inner).unwrap();
+                auto param_ty = parse_type(inner, scope).unwrap();
                 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);
+                    auto postfix = parse_array_postfix(inner, true, scope);
                     while (postfix.ok()) {
                         auto array_postfix = postfix.unwrap();
                         if (array_postfix) {
@@ -446,7 +503,7 @@ namespace parsing {
                                 new types::PointerType(param_ty)
                             };
                         }
-                        postfix = parse_array_postfix(inner, true);
+                        postfix = parse_array_postfix(inner, true, scope);
                     }
                 }
 
@@ -455,16 +512,18 @@ namespace parsing {
 
             inner.expect(token::Type::Symbol, ")");
 
+            auto inner_scope = parsing::Scope{ scope };
+
             std::optional<std::vector<std::unique_ptr<AST::Statement>>> statements{};
             if (inner.peek().content == "{") {
                 inner.expect(token::Type::Symbol, "{");
 
                 std::vector<std::unique_ptr<AST::Statement>> statement_list{};
 
-                auto statement = parse_statement(inner);
+                auto statement = parse_statement(inner, inner_scope);
                 while (statement.ok()) {
                     statement_list.push_back(statement.unwrap());
-                    statement = parse_statement(inner);
+                    statement = parse_statement(inner, inner_scope);
                 }
 
                 statements = std::optional{ std::move(statement_list) };
@@ -490,4 +549,50 @@ namespace parsing {
             return std::string(error.what());
         }
     }
+
+    Result<std::unique_ptr<AST::TopLevelStatement>, std::string> parse_tl_typedef(token::TokenStream& stream, Scope& scope) {
+        token::TokenStream inner{ stream };
+        auto before_meta = inner.metadata();
+        try {
+            auto ty = parse_type(inner, scope).unwrap();
+            inner.expect(token::Type::Symbol, ";");
+
+            if (ty->m_kind == types::TypeKind::Struct) {
+                auto struct_ty = dynamic_cast<types::StructType*>(ty.get());
+                if (!struct_ty->m_is_ref && struct_ty->m_name) {
+                    scope.structs[*struct_ty->m_name] = ty;
+                }
+            }
+
+            stream.m_position = inner.m_position;
+            auto tl_typedef = new AST::TopLevelTypedef{
+                before_meta + stream.metadata(), ty
+            };
+            return std::unique_ptr<AST::TopLevelStatement>{tl_typedef};
+        }
+        catch (std::runtime_error& error) {
+            return std::string(error.what());
+        }
+    }
+
+    Result<std::unique_ptr<AST::TopLevelStatement>, std::string> parse_top_level_statement(token::TokenStream& stream, Scope& scope) {
+        token::TokenStream inner{ stream };
+        auto before_meta = inner.metadata();
+        try {
+            if (auto func = parse_function(inner, scope); func.ok()) {
+                stream.m_position = inner.m_position;
+                return func.unwrap();
+            }
+            else if (auto tl_typedef = parse_tl_typedef(inner, scope); tl_typedef.ok()) {
+                stream.m_position = inner.m_position;
+                return tl_typedef.unwrap();
+            }
+            else {
+                throw std::runtime_error("Expected top-level statement, got " + inner.peek().formatted());
+            }
+        }
+        catch (std::runtime_error& error) {
+            return std::string(error.what());
+        }
+    }
 }

src/parsing.h

@@ -1,12 +1,19 @@
 #ifndef PARSING_H
 #define PARSING_H
 
+#include <map>
+
 #include "ast.h"
 #include "result.h"
 #include "tokens.h"
 
 namespace parsing {
-    Result<std::unique_ptr<AST::TopLevelStatement>, std::string> parse_top_level_statement(token::TokenStream& stream);
+    struct Scope {
+        std::map<std::string, std::shared_ptr<types::Type>> structs;
+    };
+
+    Result<std::unique_ptr<AST::TopLevelStatement>, std::string> parse_top_level_statement(
+        token::TokenStream& stream, Scope& scope);
 }
 
 #endif

src/typechecker.cpp

@@ -309,6 +309,39 @@ namespace AST {
         };
     }
 
+    std::shared_ptr<types::Type> FieldAccessExpression::typecheck(
+        typecheck::State& state,
+        typecheck::Scope& scope,
+        std::optional<std::shared_ptr<types::Type>>
+    ) {
+        auto expr_ty = this->m_expr->typecheck(state, scope, {});
+        if (expr_ty->m_kind != types::TypeKind::Struct) {
+            state.errors.push_back(
+                CompileError("Tried to access " + expr_ty->formatted() + "." + this->m_field, this->m_meta));
+            return std::shared_ptr<types::Type> {
+                new types::FundamentalType{ types::FundamentalTypeKind::Void }
+            };
+        }
+
+        auto struct_ty = dynamic_cast<types::StructType*>(expr_ty.get());
+        if (struct_ty->m_fields) {
+            for (auto& field : *struct_ty->m_fields) {
+                if (field.first == this->m_field) {
+                    return field.second;
+                }
+            }
+            state.errors.push_back(CompileError("No such field", this->m_meta));
+            return std::shared_ptr<types::Type> {
+                new types::FundamentalType{ types::FundamentalTypeKind::Void }
+            };
+        }
+
+        state.errors.push_back(CompileError("Cannot access fields of opaque struct", this->m_meta));
+        return std::shared_ptr<types::Type> {
+            new types::FundamentalType{ types::FundamentalTypeKind::Void }
+        };
+    }
+
     std::shared_ptr<types::Type> ListInitializerExpression::typecheck(
         typecheck::State& state,
         typecheck::Scope& scope,
@@ -330,6 +363,41 @@ namespace AST {
                     }
                 };
             }
+            else if ((*expected_ty)->m_kind == types::TypeKind::Struct) {
+                auto struct_ty = dynamic_cast<types::StructType*>(expected_ty->get());
+
+                if (struct_ty->m_fields) {
+                    if (this->m_expressions.size() > struct_ty->m_fields->size()) {
+                        state.errors.push_back(CompileError(
+                            "Too many initializer values for " + struct_ty->formatted(),
+                            this->m_meta));
+                        return *expected_ty;
+                    }
+
+                    for (int i = 0; i < static_cast<int>(this->m_expressions.size()); i++) {
+                        auto expected_field = (*struct_ty->m_fields)[i];
+                        auto expr_ty = this->m_expressions[i]->typecheck(state, scope, expected_field.second);
+                        auto res = check_type(state, expr_ty, expected_field.second);
+                        this->m_expressions[i] = handle_res(std::move(this->m_expressions[i]), res, state);
+                    }
+
+                    this->m_ty = *expected_ty;
+                    return this->m_ty;
+                }
+                else {
+                    if (this->m_expressions.size() > 0) {
+                        state.errors.push_back(CompileError(
+                            "Too many initializer values for " + struct_ty->formatted(),
+                            this->m_meta));
+                        return *expected_ty;
+                    }
+                    else {
+                        this->m_ty = *expected_ty;
+                        return this->m_ty;
+                    }
+                }
+
+            }
             else {
                 return std::shared_ptr<types::Type> {
                     new types::FundamentalType{ types::FundamentalTypeKind::Void }
@@ -428,4 +496,21 @@ namespace AST {
             }
         }
     }
+
+    void TopLevelTypedef::typecheck(typecheck::State& state, typecheck::Scope& scope) {
+        if (this->m_ty->m_kind == types::TypeKind::Struct) {
+            auto struct_ty = dynamic_cast<types::StructType*>(this->m_ty.get());
+            if (struct_ty->m_is_ref) {
+                return;
+            }
+            if (struct_ty->m_name) {
+                if (scope.structs.find(*struct_ty->m_name) == scope.structs.end()) {
+                    scope.structs[*struct_ty->m_name] = this->m_ty;
+                }
+                else {
+                    state.errors.push_back(CompileError("Struct " + *struct_ty->m_name + " declared twice!", this->m_meta));
+                }
+            }
+        }
+    }
 }

src/typechecker.h

@@ -11,6 +11,7 @@
 namespace typecheck {
     struct Scope {
         std::map<std::string, std::shared_ptr<types::Type>> symbols;
+        std::map<std::string, std::shared_ptr<types::Type>> structs;
         std::optional<std::shared_ptr<types::Type>> return_ty;
     };
 

src/types.cpp

@@ -4,6 +4,7 @@
 
 #include "types.h"
 #include "binops.h"
+#include "builder.h"
 
 namespace types {
     int operator_precedence(BinOp& op) {
@@ -63,7 +64,7 @@ namespace types {
         return false;
     }
 
-    std::pair<llvm::Value*, std::shared_ptr<Type>> FundamentalType::load(codegen::Builder&, llvm::Value* ptr) {
+    std::pair<llvm::Value*, std::shared_ptr<Type>> FundamentalType::load(codegen::Builder&, llvm::Value* ptr, codegen::TypeMap&) {
         auto self = std::make_shared<FundamentalType>(*this);
         return std::pair(ptr, self);
     }
@@ -118,7 +119,7 @@ namespace types {
         return this->m_ret_ty;
     }
 
-    std::pair<llvm::Value*, std::shared_ptr<Type>> FunctionType::load(codegen::Builder&, llvm::Value* ptr) {
+    std::pair<llvm::Value*, std::shared_ptr<Type>> FunctionType::load(codegen::Builder&, llvm::Value* ptr, codegen::TypeMap&) {
         auto self = std::make_shared<FunctionType>(*this);
         return std::pair(ptr, self);
     }
@@ -133,9 +134,9 @@ namespace types {
         return out.str();
     }
 
-    std::pair<llvm::Value*, std::shared_ptr<Type>> PointerType::load(codegen::Builder& builder, llvm::Value* ptr) {
+    std::pair<llvm::Value*, std::shared_ptr<Type>> PointerType::load(codegen::Builder& builder, llvm::Value* ptr, codegen::TypeMap& structs) {
         return std::pair(
-            builder.builder->CreateLoad(this->m_inner->codegen(builder), ptr),
+            builder.builder->CreateLoad(this->m_inner->codegen(builder, structs), ptr),
             this->m_inner
         );
     }
@@ -151,7 +152,7 @@ namespace types {
         return out.str();
     }
 
-    std::pair<llvm::Value*, std::shared_ptr<Type>> ArrayType::load(codegen::Builder&, llvm::Value* ptr) {
+    std::pair<llvm::Value*, std::shared_ptr<Type>> ArrayType::load(codegen::Builder&, llvm::Value* ptr, codegen::TypeMap&) {
         auto self = std::make_shared<ArrayType>(*this);
         return std::pair(ptr, self);
     }
@@ -160,18 +161,63 @@ namespace types {
         return this->m_size * this->m_inner->size();
     }
 
-    bool types_equal(std::shared_ptr<types::Type> type1, std::shared_ptr<types::Type> type2) {
-        // if (type1->m_kind == TypeKind::Array && type2->m_kind == TypeKind::Pointer) {
-        //     auto ty1 = dynamic_cast<ArrayType*>(type1.get());
-        //     auto ty2 = dynamic_cast<PointerType*>(type2.get());
-        //     return types_equal(ty1->m_inner, ty2->m_inner);
-        // }
-        // else if (type1->m_kind == TypeKind::Pointer && type2->m_kind == TypeKind::Array) {
-        //     auto ty1 = dynamic_cast<PointerType*>(type1.get());
-        //     auto ty2 = dynamic_cast<ArrayType*>(type2.get());
-        //     return types_equal(ty1->m_inner, ty2->m_inner);
-        // }
+    std::string StructType::formatted() {
+        std::stringstream out{ "" };
+        out << "struct";
+        if (this->m_is_ref)
+            out << "(ref)";
+        out << " ";
 
+        if (this->m_name) {
+            out << *this->m_name << " ";
+        }
+        if (this->m_fields) {
+            out << "{ ";
+            int counter = 0;
+            for (auto& field : *this->m_fields) {
+                if (counter++ > 0)
+                    out << ", ";
+                out << field.first << ": " << field.second->formatted() << " ";
+            }
+            out << "}";
+        }
+
+        return out.str();
+    }
+
+    std::pair<llvm::Value*, std::shared_ptr<Type>> StructType::load(codegen::Builder&, llvm::Value* ptr, codegen::TypeMap&) {
+        auto self = std::make_shared<StructType>(*this);
+        return std::pair(ptr, self);
+    }
+
+    uint32_t StructType::size() {
+        uint32_t size{ 0 };
+        if (this->m_fields) {
+            for (auto& field : *this->m_fields) {
+                size += field.second->size();
+            }
+        }
+
+        return size;
+    }
+
+
+    // std::string StructRef::formatted() {
+    //     std::stringstream out{ "" };
+    //     out << "struct(ref) " << this->m_name;
+    //     return out.str();
+    // }
+
+    // std::pair<llvm::Value*, std::shared_ptr<Type>> StructRef::load(codegen::Builder&, llvm::Value* ptr, codegen::TypeMap&) {
+    //     auto self = std::make_shared<StructRef>(*this);
+    //     return std::pair(ptr, self);
+    // }
+
+    // uint32_t StructRef::size() {
+    //     return this->m_referred->size();
+    // }
+
+    bool types_equal(std::shared_ptr<types::Type> type1, std::shared_ptr<types::Type> type2) {
         if (type1->m_kind != type2->m_kind)
             return false;
 
@@ -212,6 +258,28 @@ namespace types {
 
             return types_equal(ty1->m_inner, ty2->m_inner) && ty1->m_size == ty2->m_size;
         }
+        else if (type1->m_kind == TypeKind::Struct) {
+            auto ty1 = dynamic_cast<StructType*>(type1.get());
+            auto ty2 = dynamic_cast<StructType*>(type2.get());
+
+            if (ty1->m_fields.has_value() != ty2->m_fields.has_value())
+                return false;
+
+            if (ty1->m_fields) {
+                if (ty1->m_fields->size() != ty2->m_fields->size())
+                    return false;
+
+                for (int i = 0; i < static_cast<int>(ty1->m_fields->size()); i++) {
+                    auto field1 = (*ty1->m_fields)[i];
+                    auto field2 = (*ty2->m_fields)[i];
+                    if (!types_equal(field1.second, field2.second))
+                        return false;
+                }
+            }
+
+            return true;
+
+        }
         else {
             return false;
         }

src/types.h

@@ -12,6 +12,7 @@ namespace types {
         Function,
         Pointer,
         Array,
+        Struct,
     };
 
     enum FundamentalTypeKind {
@@ -29,8 +30,8 @@ namespace types {
         Type(TypeKind kind) : m_kind{ kind } {}
         virtual ~Type() = default;
         virtual std::string formatted() = 0;
-        virtual llvm::Type* codegen(codegen::Builder& builder) = 0;
-        virtual std::pair<llvm::Value*, std::shared_ptr<Type>> load(codegen::Builder& builder, llvm::Value* ptr) = 0;
+        virtual llvm::Type* codegen(codegen::Builder& builder, codegen::TypeMap& structs) = 0;
+        virtual std::pair<llvm::Value*, std::shared_ptr<Type>> load(codegen::Builder& builder, llvm::Value* ptr, codegen::TypeMap& structs) = 0;
         virtual std::optional<std::shared_ptr<Type>> return_type();
         virtual bool is_signed();
         virtual uint32_t size() = 0;
@@ -42,8 +43,8 @@ namespace types {
         FundamentalType(FundamentalTypeKind kind) : Type(TypeKind::Fundamental), m_ty{ kind } {}
         virtual ~FundamentalType() override = default;
         virtual std::string formatted() override;
-        virtual llvm::Type* codegen(codegen::Builder& builder) override;
-        virtual std::pair<llvm::Value*, std::shared_ptr<Type>> load(codegen::Builder& builder, llvm::Value* ptr) override;
+        virtual llvm::Type* codegen(codegen::Builder& builder, codegen::TypeMap& structs) override;
+        virtual std::pair<llvm::Value*, std::shared_ptr<Type>> load(codegen::Builder& builder, llvm::Value* ptr, codegen::TypeMap& structs) override;
         virtual bool is_signed() override;
         virtual uint32_t size() override;
     };
@@ -62,8 +63,8 @@ namespace types {
         }
         virtual ~FunctionType() override = default;
         virtual std::string formatted() override;
-        virtual llvm::Type* codegen(codegen::Builder& builder) override;
-        virtual std::pair<llvm::Value*, std::shared_ptr<Type>> load(codegen::Builder& builder, llvm::Value* ptr) override;
+        virtual llvm::Type* codegen(codegen::Builder& builder, codegen::TypeMap& structs) override;
+        virtual std::pair<llvm::Value*, std::shared_ptr<Type>> load(codegen::Builder& builder, llvm::Value* ptr, codegen::TypeMap& structs) override;
         virtual std::optional<std::shared_ptr<Type>> return_type() override;
         virtual uint32_t size() override;
     };
@@ -77,8 +78,8 @@ namespace types {
         }
         virtual ~PointerType() override = default;
         virtual std::string formatted() override;
-        virtual llvm::Type* codegen(codegen::Builder& builder) override;
-        virtual std::pair<llvm::Value*, std::shared_ptr<Type>> load(codegen::Builder& builder, llvm::Value* ptr) override;
+        virtual llvm::Type* codegen(codegen::Builder& builder, codegen::TypeMap& structs) override;
+        virtual std::pair<llvm::Value*, std::shared_ptr<Type>> load(codegen::Builder& builder, llvm::Value* ptr, codegen::TypeMap& structs) override;
         virtual uint32_t size() override;
     };
 
@@ -92,11 +93,44 @@ namespace types {
         }
         virtual ~ArrayType() override = default;
         virtual std::string formatted() override;
-        virtual llvm::Type* codegen(codegen::Builder& builder) override;
-        virtual std::pair<llvm::Value*, std::shared_ptr<Type>> load(codegen::Builder& builder, llvm::Value* ptr) override;
+        virtual llvm::Type* codegen(codegen::Builder& builder, codegen::TypeMap& structs) override;
+        virtual std::pair<llvm::Value*, std::shared_ptr<Type>> load(codegen::Builder& builder, llvm::Value* ptr, codegen::TypeMap& structs) override;
         virtual uint32_t size() override;
     };
 
+    typedef std::pair<std::string, std::shared_ptr<types::Type>> StructField;
+
+    class StructType : public Type {
+    public:
+        std::optional<std::string> m_name;
+        std::optional<std::vector<StructField>> m_fields;
+        bool m_is_ref;
+
+        StructType(std::optional<std::string> name, std::optional<std::vector<StructField>> fields, bool is_ref)
+            : Type(TypeKind::Struct), m_name{ name }, m_fields{ fields }, m_is_ref{ is_ref } {
+        }
+        virtual ~StructType() override = default;
+        virtual std::string formatted() override;
+        virtual llvm::Type* codegen(codegen::Builder& builder, codegen::TypeMap& structs) override;
+        virtual std::pair<llvm::Value*, std::shared_ptr<Type>> load(codegen::Builder& builder, llvm::Value* ptr, codegen::TypeMap& structs) override;
+        virtual uint32_t size() override;
+    };
+
+    // class StructRef : public Type {
+    // public:
+    //     std::string m_name;
+    //     std::shared_ptr<types::Type> m_referred;
+
+    //     StructRef(std::string name, std::shared_ptr<types::Type> referred)
+    //         : Type(TypeKind::StructRef), m_name{ name }, m_referred{ referred } {
+    //     }
+    //     virtual ~StructRef() override = default;
+    //     virtual std::string formatted() override;
+    //     virtual llvm::Type* codegen(codegen::Builder& builder, codegen::TypeMap& structs) override;
+    //     virtual std::pair<llvm::Value*, std::shared_ptr<Type>> load(codegen::Builder& builder, llvm::Value* ptr, codegen::TypeMap& structs) override;
+    //     virtual uint32_t size() override;
+    // };
+
     bool types_equal(std::shared_ptr<types::Type> type1, std::shared_ptr<types::Type> type2);
 }
 

test.c

@@ -10,6 +10,10 @@ void change_first(char otus[5]) {
     otus[0] = 115;
 }
 
+struct Otus {
+    int field
+};
+
 int main() {
     char text[29] = "10th fibonacci number is %d!";
     printf(text, fibonacci(10));
@@ -18,5 +22,11 @@ int main() {
 
     change_first(somelist);
 
-    return somelist[0];
+    printf(" first element: %d!", somelist[0]);
+
+    struct Otus otus = { 5 };
+
+    printf(" first field: %d!", otus.field);
+
+    return 0;
 }