Revert "aa"

This reverts commit 7c7471f628698c62bc51723cd398a1dd09effa2b.

src/Ast.cpp

@@ -0,0 +1,62 @@
+#include "Ast.h"
+#include "AstVisitor.h"
+#include "Semantic.h"
+
+#include <cstdlib>
+
+using namespace qlow::ast;
+
+
+AstObject::~AstObject(void)
+{
+}
+
+
+#define ACCEPT_DEFINITION(ClassName, Visitor) \
+std::unique_ptr<qlow::sem::SemanticObject> ClassName::accept(Visitor& v, sem::Scope& scope) \
+{ \
+    return v.visit(*this, scope); \
+}
+
+ACCEPT_DEFINITION(Class, StructureVisitor)
+ACCEPT_DEFINITION(FeatureDeclaration, StructureVisitor)
+ACCEPT_DEFINITION(FieldDeclaration, StructureVisitor)
+ACCEPT_DEFINITION(MethodDefinition, StructureVisitor)
+ACCEPT_DEFINITION(VariableDeclaration, StructureVisitor)
+
+ACCEPT_DEFINITION(Statement, StructureVisitor)
+ACCEPT_DEFINITION(DoEndBlock, StructureVisitor)
+ACCEPT_DEFINITION(IfElseBlock, StructureVisitor)
+ACCEPT_DEFINITION(WhileBlock, StructureVisitor)
+ACCEPT_DEFINITION(Expression, StructureVisitor)
+ACCEPT_DEFINITION(FeatureCall, StructureVisitor)
+ACCEPT_DEFINITION(AssignmentStatement, StructureVisitor)
+ACCEPT_DEFINITION(ReturnStatement, StructureVisitor)
+ACCEPT_DEFINITION(LocalVariableStatement, StructureVisitor)
+ACCEPT_DEFINITION(AddressExpression, StructureVisitor)
+ACCEPT_DEFINITION(IntConst, StructureVisitor)
+ACCEPT_DEFINITION(UnaryOperation, StructureVisitor)
+ACCEPT_DEFINITION(BinaryOperation, StructureVisitor)
+ACCEPT_DEFINITION(NewArrayExpression, StructureVisitor)
+ACCEPT_DEFINITION(CastExpression, StructureVisitor)
+
+
+Statement::~Statement(void)
+{
+}
+
+
+qlow::ast::IntConst::IntConst(std::string&& val, const qlow::CodePosition& p) :
+    AstObject{ p },
+    Expression{ p },
+    value{ strtoull(val.c_str(), nullptr, 0) }
+{
+}
+
+
+
+
+
+
+
+

src/Ast.h

@@ -0,0 +1,569 @@
+// =============================================================================
+//
+// This file is part of the qlow compiler.
+//
+// Copyright (C) 2014-2015 Nicolas Winkler
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+// =============================================================================
+
+#ifndef QLOW_AST_H
+#define QLOW_AST_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <utility>
+#include <map>
+
+#include "Visitor.h"
+#include "Util.h"
+#include "ErrorReporting.h"
+
+namespace qlow
+{
+    struct CodePosition;
+    
+    class StructureVisitor;
+    namespace ast
+    {
+        // base class
+        struct AstObject;
+
+        struct Class;
+
+        struct Type;
+        struct ClassType;
+        struct ArrayType;
+        struct PointerType;
+        
+        struct FeatureDeclaration;
+
+        struct FieldDeclaration;
+        struct MethodDefinition;
+
+        struct VariableDeclaration;
+        struct ArgumentDeclaration;
+
+        struct Statement;
+        
+        struct DoEndBlock;
+        struct IfElseBlock;
+        struct WhileBlock;
+
+        struct Expression;
+
+        struct FeatureCall;
+        struct AssignmentStatement;
+        struct ReturnStatement;
+        struct LocalVariableStatement;
+        struct AddressExpression;
+        struct IntConst;
+
+        struct Operation;
+        struct UnaryOperation;
+        struct BinaryOperation;
+        
+        struct NewArrayExpression;
+        
+        struct CastExpression;
+    }
+
+    namespace sem
+    {
+        struct SemanticObject;
+        struct Class;
+        
+        class Scope;
+
+//        template<typename T>
+//        using SymbolTable = std::map<std::string, std::unique_ptr<T>>;
+    }
+}
+
+
+
+struct qlow::ast::AstObject :
+    public Visitable<std::unique_ptr<sem::SemanticObject>, sem::Scope&, StructureVisitor>
+{
+    CodePosition pos;
+    
+    inline AstObject(const CodePosition& cp) :
+        pos{ cp } {}
+        
+    virtual ~AstObject(void);
+};
+
+
+struct qlow::ast::Class : public AstObject
+{
+    std::string name;
+    OwningList<FeatureDeclaration> features;
+    
+    inline Class(const std::string& name, OwningList<FeatureDeclaration>& features, const CodePosition& cp) :
+        AstObject{ cp },
+        name{ name }, features(std::move(features))
+    {
+    }
+
+    virtual std::unique_ptr<sem::SemanticObject> accept(StructureVisitor& v, sem::Scope&) override;
+};
+
+
+struct qlow::ast::Type : public AstObject
+{
+    inline Type(const CodePosition& cp) :
+        AstObject{ cp }
+    {
+    }
+    
+    virtual std::string asString(void) const = 0;
+    virtual inline std::unique_ptr<sem::SemanticObject> accept(StructureVisitor& v, sem::Scope&) override {}
+};
+
+
+struct qlow::ast::ClassType : public ast::Type
+{
+    std::string typeName;
+    
+    inline ClassType(const std::string& typeName, const CodePosition& cp) :
+        Type{ cp },
+        typeName{ typeName }
+    {
+    }
+    
+    inline ClassType(std::string&& typeName, const CodePosition& cp) :
+        Type{ cp },
+        typeName{ std::move(typeName) }
+    {
+    }
+    
+    inline std::string asString(void) const override { return typeName; }
+};
+
+
+struct qlow::ast::ArrayType : public ast::Type 
+{
+    std::unique_ptr<ast::Type> arrayType;
+    
+    inline ArrayType(std::unique_ptr<ast::Type> arrayType, const CodePosition& cp) :
+        Type{ cp },
+        arrayType{ std::move(arrayType) }
+    {
+    }
+    
+    inline std::string asString(void) const override {
+        return std::string("[") + arrayType->asString() + "]";
+    }
+};
+
+
+struct qlow::ast::PointerType : public ast::Type 
+{
+    std::unique_ptr<ast::Type> derefType;
+    
+    inline PointerType(std::unique_ptr<ast::Type> derefType, const CodePosition& cp) :
+        Type{ cp },
+        derefType{ std::move(derefType) }
+    {
+    }
+    
+    inline std::string asString(void) const override {
+        return derefType->asString() + "*";
+    }
+};
+
+
+struct qlow::ast::FeatureDeclaration : public AstObject
+{
+    std::string name;
+    std::unique_ptr<ast::Type> type;
+
+    inline FeatureDeclaration(std::unique_ptr<ast::Type> type, const std::string& name, const CodePosition& cp) :
+        AstObject{ cp },
+        name{ name },
+        type{ std::move(type) }
+    {
+    }
+
+    virtual std::unique_ptr<sem::SemanticObject> accept(StructureVisitor& v, sem::Scope&);
+};
+
+
+struct qlow::ast::FieldDeclaration : public FeatureDeclaration
+{
+    inline FieldDeclaration(std::unique_ptr<ast::Type> type, const std::string& name, const CodePosition& cp) :
+        FeatureDeclaration{ std::move(type), name, cp }
+    {
+    }
+
+    virtual std::unique_ptr<sem::SemanticObject> accept(StructureVisitor& v, sem::Scope&);
+};
+
+
+struct qlow::ast::MethodDefinition : public FeatureDeclaration
+{
+    OwningList<ArgumentDeclaration> arguments;
+    
+    /// pointer to method body. If this is a null pointer, the method has only
+    /// been declared and not defined (with extern)
+    std::unique_ptr<DoEndBlock> body;
+
+    inline MethodDefinition(std::unique_ptr<ast::Type> type, const std::string& name,
+            std::unique_ptr<DoEndBlock> body, const CodePosition& cp) :
+        FeatureDeclaration{ std::move(type), name, cp },
+        body{ std::move(body) }
+    {
+    }
+
+
+    inline MethodDefinition(std::unique_ptr<ast::Type> type, const std::string& name,
+            OwningList<ArgumentDeclaration>&& arguments, std::unique_ptr<DoEndBlock> body, const CodePosition& cp) :
+        FeatureDeclaration{ std::move(type), name, cp },
+        arguments(std::move(arguments)),
+        body{ std::move(body) }
+    {
+    }
+
+    
+    inline MethodDefinition(std::unique_ptr<ast::Type> type, const std::string& name,
+            const CodePosition& cp) :
+        FeatureDeclaration{ std::move(type), name, cp },
+        body{ nullptr }
+    {
+    }
+    
+
+    inline MethodDefinition(std::unique_ptr<ast::Type> type, const std::string& name,
+            OwningList<ArgumentDeclaration>&& arguments, const CodePosition& cp) :
+        FeatureDeclaration{ std::move(type), name, cp },
+        arguments(std::move(arguments)),
+        body{ nullptr }
+    {
+    }
+
+    virtual std::unique_ptr<sem::SemanticObject> accept(StructureVisitor& v, sem::Scope&);
+};
+
+
+struct qlow::ast::VariableDeclaration : public AstObject
+{
+    std::unique_ptr<ast::Type> type;
+    std::string name;
+    inline VariableDeclaration(std::unique_ptr<ast::Type> type, std::string&& name, const CodePosition& cp) :
+        AstObject{ cp },
+        type{ std::move(type) },
+        name{ std::move(name) }
+    {
+    }
+
+    virtual std::unique_ptr<sem::SemanticObject> accept(StructureVisitor& v, sem::Scope&);
+};
+
+
+struct qlow::ast::ArgumentDeclaration :
+    public VariableDeclaration
+{
+    inline ArgumentDeclaration(std::unique_ptr<ast::Type> type, std::string&& name, const CodePosition& cp) :
+        VariableDeclaration{ std::move(type), std::move(name), cp }
+    {
+    }
+
+    //virtual std::unique_ptr<sem::SemanticObject> accept(StructureVisitor& v, sem::Scope&);
+};
+
+
+struct qlow::ast::Statement : public virtual AstObject
+{
+    inline Statement(const CodePosition& cp) :
+        AstObject{ cp } {}
+        
+    virtual ~Statement(void);
+
+    virtual std::unique_ptr<sem::SemanticObject> accept(StructureVisitor& v, sem::Scope&);
+};
+
+
+struct qlow::ast::DoEndBlock : public Statement 
+{
+    OwningList<Statement> statements;
+    
+    inline DoEndBlock(OwningList<Statement>&& statements, const CodePosition& cp) :
+        AstObject{ cp },
+        Statement{ cp },
+        statements(std::move(statements))
+    {
+    }
+
+    virtual std::unique_ptr<sem::SemanticObject> accept(StructureVisitor& v, sem::Scope&);
+};
+
+
+struct qlow::ast::IfElseBlock : public Statement
+{
+    std::unique_ptr<Expression> condition;
+    std::unique_ptr<DoEndBlock> ifBlock;
+    std::unique_ptr<DoEndBlock> elseBlock;
+    
+    inline IfElseBlock(std::unique_ptr<Expression> condition,
+                       std::unique_ptr<DoEndBlock> ifBlock,
+                       std::unique_ptr<DoEndBlock> elseBlock,
+                       const CodePosition& cp) :
+        AstObject{ cp },
+        Statement{ cp },
+        condition{ std::move(condition) },
+        ifBlock{ std::move(ifBlock) },
+        elseBlock{ std::move(elseBlock) }
+    {
+    }
+
+    virtual std::unique_ptr<sem::SemanticObject> accept(StructureVisitor& v, sem::Scope&);
+};
+
+
+struct qlow::ast::WhileBlock : public Statement
+{
+    std::unique_ptr<Expression> condition;
+    std::unique_ptr<DoEndBlock> body;
+    
+    inline WhileBlock(std::unique_ptr<Expression> condition,
+                      std::unique_ptr<DoEndBlock> body,
+                      const CodePosition& cp) :
+        AstObject{ cp },
+        Statement{ cp },
+        condition{ std::move(condition) },
+        body{ std::move(body) }
+    {
+    }
+
+    virtual std::unique_ptr<sem::SemanticObject> accept(StructureVisitor& v, sem::Scope&);
+};
+
+
+struct qlow::ast::Expression : public virtual AstObject
+{
+    inline Expression(const CodePosition& cp) :
+        AstObject{ cp } {}
+        
+    virtual std::unique_ptr<sem::SemanticObject> accept(StructureVisitor& v, sem::Scope&);
+};
+
+
+struct qlow::ast::FeatureCall : public Expression, public Statement
+{
+    std::unique_ptr<Expression> target;
+    std::string name;
+    OwningList<Expression> arguments;
+
+    inline FeatureCall(std::unique_ptr<Expression> target, const std::string& name, const CodePosition& cp) :
+        AstObject{ cp },
+        Expression{ cp }, Statement{ cp },
+        target(std::move(target)), name(name)
+    {
+    }
+
+
+    inline FeatureCall(std::unique_ptr<Expression> target, const std::string& name,
+            OwningList<Expression>&& arguments, const CodePosition& cp) :
+        AstObject{ cp },
+        Expression{ cp }, Statement{ cp },
+        target(std::move(target)), name(name), arguments(std::move(arguments))
+    {
+    }
+
+    virtual std::unique_ptr<sem::SemanticObject> accept(StructureVisitor& v, sem::Scope&);
+};
+
+
+struct qlow::ast::ReturnStatement : public Statement
+{
+    std::unique_ptr<Expression> expr;
+
+    inline ReturnStatement(std::unique_ptr<Expression>&& expr, const CodePosition& cp) :
+        AstObject{ cp },
+        Statement{ cp },
+        expr{ std::move(expr) }
+    {
+    }
+
+    virtual std::unique_ptr<sem::SemanticObject> accept(StructureVisitor& v, sem::Scope&);
+};
+
+
+struct qlow::ast::AssignmentStatement : public Statement
+{
+    std::unique_ptr<Expression> target;
+    std::unique_ptr<Expression> expr;
+
+    inline AssignmentStatement(std::unique_ptr<Expression>&& target, std::unique_ptr<Expression>&& expr, const CodePosition& cp) :
+        AstObject{ cp },
+        Statement{ cp },
+        target{ std::move(target) }, expr{ std::move(expr) }
+    {
+    }
+
+    virtual std::unique_ptr<sem::SemanticObject> accept(StructureVisitor& v, sem::Scope&);
+};
+
+
+struct qlow::ast::LocalVariableStatement : public Statement
+{
+    std::string name;
+    std::unique_ptr<ast::Type> type;
+    inline LocalVariableStatement(std::string&& name, std::unique_ptr<Type> type, const CodePosition& cp) :
+        AstObject{ cp },
+        Statement{ cp },
+       name{ name },
+       type{ std::move(type) }
+    {
+    } 
+
+    virtual std::unique_ptr<sem::SemanticObject> accept(StructureVisitor& v, sem::Scope&);
+};
+
+
+struct qlow::ast::AddressExpression : public Expression
+{
+    std::unique_ptr<Expression> target;
+    inline AddressExpression(std::unique_ptr<Expression> target,
+                             const CodePosition& cp) :
+        AstObject{ cp },
+        Expression{ cp },
+       target{ std::move(target) }
+    {
+    } 
+
+    virtual std::unique_ptr<sem::SemanticObject> accept(StructureVisitor& v, sem::Scope&);
+};
+
+
+struct qlow::ast::IntConst : public Expression
+{
+    unsigned long long value;
+    
+    IntConst(unsigned long long v, const CodePosition& p) :
+        AstObject(p),
+        Expression(p),
+        value{ v } {}
+        
+    IntConst(std::string&& val, const CodePosition& p);
+    virtual std::unique_ptr<sem::SemanticObject> accept(StructureVisitor& v, sem::Scope&);
+};
+
+
+struct qlow::ast::Operation : public Expression
+{
+    std::string opString;
+    CodePosition opPos;
+
+    inline Operation(const std::string& opString, const CodePosition& cp,
+                     const CodePosition& opPos) :
+        AstObject{ cp },
+        Expression{ cp },
+        opString{ opString },
+        opPos{ opPos }
+    {
+    }
+};
+
+
+struct qlow::ast::UnaryOperation : public Operation
+{
+    enum Side
+    {
+        PREFIX,
+        SUFFIX,
+    };
+
+    Side side;
+    std::unique_ptr<Expression> expr;
+
+    inline UnaryOperation(std::unique_ptr<Expression> expr, Side side,
+                          const std::string& op, const CodePosition& cp,
+                          const CodePosition& opPos
+                         ) :
+        AstObject{ cp },
+        Operation{ op, cp, opPos },
+        side{ side },
+        expr{ std::move(expr) }
+    {
+    }
+
+    virtual std::unique_ptr<sem::SemanticObject> accept(StructureVisitor& v, sem::Scope&);
+};
+
+
+struct qlow::ast::BinaryOperation : public Operation
+{
+    std::unique_ptr<Expression> left;
+    std::unique_ptr<Expression> right;
+
+    inline BinaryOperation(std::unique_ptr<Expression> left,
+                           std::unique_ptr<Expression> right,
+                           const std::string& op,
+                           const CodePosition& cp,
+                           const CodePosition& opPos
+                          ) :
+        AstObject{ cp },
+        Operation{ op, cp, opPos },
+        left{ std::move(left) },
+        right{ std::move(right) }
+    {
+    }
+
+    virtual std::unique_ptr<sem::SemanticObject> accept(StructureVisitor& v, sem::Scope&);
+};
+
+
+struct qlow::ast::NewArrayExpression : public Expression
+{
+    std::unique_ptr<ast::Type> type;
+    std::unique_ptr<Expression> length;
+    inline NewArrayExpression(std::unique_ptr<ast::Type> type,
+                              std::unique_ptr<Expression> length,
+                              const CodePosition& cp) :
+        AstObject{ cp },
+        Expression{ cp },
+        type{ std::move(type) },
+        length{ std::move(length) }
+    {
+    }
+    
+    virtual std::unique_ptr<sem::SemanticObject> accept(StructureVisitor& v, sem::Scope&);
+};
+
+
+struct qlow::ast::CastExpression : public Expression
+{
+    std::unique_ptr<ast::Expression> expression;
+    std::unique_ptr<ast::Type> targetType;
+    
+    inline CastExpression(std::unique_ptr<ast::Expression> expression,
+                          std::unique_ptr<ast::Type> targetType,
+                          const CodePosition& cp) :
+        AstObject{ cp },
+        Expression{ cp },
+        expression{ std::move(expression) },
+        targetType{ std::move(targetType) }
+    {
+    }
+    
+    virtual std::unique_ptr<sem::SemanticObject> accept(StructureVisitor& v, sem::Scope&);
+};
+
+
+#endif // QLOW_AST_H
+
+

src/AstVisitor.cpp

@@ -0,0 +1,419 @@
+#include "AstVisitor.h"
+#include "Ast.h"
+#include "ErrorReporting.h"
+
+#include <typeinfo>
+
+#include "Util.h"
+
+using namespace qlow;
+
+
+std::unique_ptr<sem::SemanticObject> StructureVisitor::visit(ast::Class& ast, sem::Scope& scope)
+{
+    //auto c = std::make_unique<sem::Class>();
+    //c->name = ast.name;
+    //return c;
+    throw "shouldn't be called";
+}
+
+
+std::unique_ptr<sem::SemanticObject> StructureVisitor::visit(ast::FeatureDeclaration& ast, sem::Scope& scope)
+{
+    // not needed, because 
+    throw "shouldn't be called";
+}
+
+
+std::unique_ptr<sem::SemanticObject> StructureVisitor::visit(ast::FieldDeclaration& ast, sem::Scope& scope)
+{
+    auto f = std::make_unique<sem::Field>();
+    f->name = ast.name;
+    auto type = scope.getType(*ast.type);
+    if (type) {
+        f->type = type;
+    }
+    else {
+        throw SemanticError(SemanticError::UNKNOWN_TYPE,
+            ast.type->asString(),
+            ast.type->pos
+        );
+    }
+    return f;
+}
+
+
+std::unique_ptr<sem::SemanticObject> StructureVisitor::visit(ast::MethodDefinition& ast, sem::Scope& scope)
+{
+    auto returnType = scope.getType(*ast.type);
+    if (!returnType) {
+        throw SemanticError(SemanticError::UNKNOWN_TYPE,
+            ast.type->asString(),
+            ast.type->pos
+        );
+    }
+    auto m = std::make_unique<sem::Method>(scope, returnType);
+    m->name = ast.name;
+    m->astNode = &ast;
+    
+    for (auto& arg : ast.arguments) {
+        auto var = arg->accept(*this, scope);
+        if (dynamic_cast<sem::Variable*>(var.get())) {
+            std::unique_ptr<sem::Variable> variable =
+                unique_dynamic_cast<sem::Variable>(std::move(var));
+            variable->isParameter = true;
+            m->arguments.push_back(variable.get());
+            std::string varname = variable->name;
+            m->scope.putVariable(varname, std::move(variable));
+        }
+        else {
+            throw "internal error creating argument";
+        }
+    }
+    
+    return m;
+    //throw "  std::unique_ptr<sem::SemanticObject> StructureVisitor::visit(ast::MethodDefinition& ast, sem::Scope& scope) shouldn't be called";
+}
+
+
+std::unique_ptr<sem::SemanticObject> StructureVisitor::visit(ast::VariableDeclaration& ast, sem::Scope& scope)
+{
+    auto v = std::make_unique<sem::Variable>();
+    v->name = ast.name;
+    auto type = scope.getType(*ast.type);
+    if (type) {
+        v->type = std::move(type);
+    }
+    else {
+        throw SemanticError(SemanticError::UNKNOWN_TYPE,
+            ast.type->asString(),
+            ast.type->pos
+        );
+    }
+    return v;
+}
+
+
+std::unique_ptr<sem::SemanticObject> StructureVisitor::visit(ast::Statement& ast, sem::Scope& scope)
+{
+    printf("at: %d:%d to %d:%d\n", ast.pos.first_line, ast.pos.first_column, ast.pos.last_line, ast.pos.last_column);
+    printf("type: %s\n", typeid(ast).name());
+    throw "visit(Statement) shouldn't be called";
+}
+
+
+std::unique_ptr<sem::SemanticObject> StructureVisitor::visit(ast::DoEndBlock& ast, sem::Scope& scope)
+{
+    sem::LocalScope* lscope = dynamic_cast<sem::LocalScope*>(&scope);
+    if (!lscope)
+        throw "error: non-method scope inside method";
+    auto body = std::make_unique<sem::DoEndBlock>(*lscope);
+    for (auto& statement : ast.statements) {
+        
+        if (ast::LocalVariableStatement* nvs = dynamic_cast<ast::LocalVariableStatement*>(statement.get()); nvs) {
+            auto type = body->scope.getType(*nvs->type);
+
+            if (!type)
+                throw SemanticError(SemanticError::UNKNOWN_TYPE,
+                                    nvs->type->asString(),
+                                    nvs->type->pos);
+            auto var = std::make_unique<sem::Variable>(std::move(type), nvs->name);
+            body->scope.putVariable(nvs->name, std::move(var));
+            continue;
+        }
+        
+        auto v = statement->accept(*this, body->scope);
+        if (dynamic_cast<sem::MethodCallExpression*>(v.get()) != nullptr) {
+            body->statements.push_back(
+                std::make_unique<sem::FeatureCallStatement>(
+                unique_dynamic_cast<sem::MethodCallExpression>(std::move(v))));
+        }
+        else {
+            body->statements.push_back(unique_dynamic_cast<sem::Statement>(std::move(v)));
+        }
+    }
+    return body;
+}
+
+
+std::unique_ptr<sem::SemanticObject> StructureVisitor::visit(ast::IfElseBlock& ast, sem::Scope& scope)
+{
+    auto condition = ast.condition->accept(*this, scope);
+    auto ifB = ast.ifBlock->accept(*this, scope);
+    auto eB= ast.elseBlock->accept(*this, scope);
+    
+    if (!dynamic_cast<sem::DoEndBlock*>(ifB.get())
+        || !dynamic_cast<sem::DoEndBlock*>(eB.get())
+        || !dynamic_cast<sem::Expression*>(condition.get()))
+        throw "internal error, invalid if block";
+    
+    auto condExpr = unique_dynamic_cast<sem::Expression>(std::move(condition));
+    auto ifBBlock = unique_dynamic_cast<sem::DoEndBlock>(std::move(ifB));
+    auto eBBlock= unique_dynamic_cast<sem::DoEndBlock>(std::move(eB));
+    
+    auto ieb = std::make_unique<sem::IfElseBlock>(std::move(condExpr), std::move(ifBBlock), std::move(eBBlock));
+    
+    return ieb;
+}
+
+
+std::unique_ptr<sem::SemanticObject> StructureVisitor::visit(ast::WhileBlock& ast, sem::Scope& scope)
+{
+    auto condition = ast.condition->accept(*this, scope);
+    auto body = ast.body->accept(*this, scope);
+    
+    if (!dynamic_cast<sem::DoEndBlock*>(body.get()) ||
+        !dynamic_cast<sem::Expression*>(condition.get()))
+        throw "internal error, invalid while block";
+    
+    auto condExpr = unique_dynamic_cast<sem::Expression>(std::move(condition));
+    auto bodyblock = unique_dynamic_cast<sem::DoEndBlock>(std::move(body));
+    
+    auto wb = std::make_unique<sem::WhileBlock>(std::move(condExpr), std::move(bodyblock));
+    
+    return wb;
+}
+
+
+std::unique_ptr<sem::SemanticObject> StructureVisitor::visit(ast::Expression& ast, sem::Scope& scope)
+{
+    throw "visit(Expression) shouldn't be called";
+}
+
+
+std::unique_ptr<sem::SemanticObject> StructureVisitor::visit(ast::FeatureCall& ast, sem::Scope& scope)
+{
+    std::unique_ptr<sem::Expression> target = nullptr;
+    if (ast.target) {
+        target = unique_dynamic_cast<sem::Expression>(
+            ast.target->accept(*this, scope));
+    }
+    
+    sem::Method* method;
+    sem::Variable* var;
+    
+    if (target) {
+        method = target->type->getScope().getMethod(ast.name);
+        var = target->type->getScope().getVariable(ast.name);
+    }
+    else {
+        method = scope.getMethod(ast.name);
+        var = scope.getVariable(ast.name);
+    }
+    
+    if (target) {
+        if (var) {
+            return std::make_unique<sem::FieldAccessExpression>(std::move(target), dynamic_cast<sem::Field*>(var));
+        }
+        else if (method) {
+            auto fce = std::make_unique<sem::MethodCallExpression>(
+                std::move(target), method);
+    
+            if (ast.arguments.size() != method->arguments.size())
+                throw SemanticError(SemanticError::WRONG_NUMBER_OF_ARGUMENTS, ast.name, ast.pos);
+            for (size_t i = 0; i < ast.arguments.size(); i++) {
+                auto& arg = ast.arguments[i];
+                auto& argTypeShouldHave = method->arguments[i]->type;
+                auto argument = arg->accept(*this, scope);
+                if (sem::Expression* expr =
+                        dynamic_cast<sem::Expression*>(argument.get()); expr) {
+                    if (!expr->type->equals(*argTypeShouldHave))
+                        throw SemanticError(SemanticError::TYPE_MISMATCH,
+                            "argument passed to function has wrong type: '" +
+                            expr->type->asString() + "' instead of '" +
+                            argTypeShouldHave->asString() + "'",
+                            arg->pos
+                        );
+                    fce->arguments.push_back(
+                        unique_dynamic_cast<sem::Expression>(std::move(argument)));
+                }
+                else {
+                    throw "internal error: non-expression passed as function parameter";
+                }
+            }
+            return fce;
+        }
+        else {
+            throw SemanticError(SemanticError::FEATURE_NOT_FOUND, ast.name, ast.pos);
+        }
+    }
+    else if (var) {
+        if (sem::Field* field = dynamic_cast<sem::Field*>(var); field) {
+            auto* thisExpr = scope.getVariable("this");
+            if (!thisExpr)
+                throw "no this found";
+            Logger::getInstance().debug() << "feature call " << var->toString() << " is a field\n";
+            return std::make_unique<sem::FieldAccessExpression>(std::make_unique<sem::LocalVariableExpression>(thisExpr), field);
+        }
+        else {
+            Logger::getInstance().debug() << "feature call " << var->toString() << " is not a field\n";
+            return std::make_unique<sem::LocalVariableExpression>(var);
+        }
+    }
+    else if (method) {
+        auto fce = std::make_unique<sem::MethodCallExpression>(nullptr, method);
+        for (auto& arg : ast.arguments) {
+            auto argument = arg->accept(*this, scope);
+            if (dynamic_cast<sem::Expression*>(argument.get())) {
+                fce->arguments.push_back(unique_dynamic_cast<sem::Expression>(std::move(argument)));
+            }
+            else {
+                throw "internal error: non-expression passed as function parameter";
+            }
+        }
+        fce->callee = method;
+        return fce;
+    }
+    else {
+#ifdef DEBUGGING
+        printf("var not found: %s\n", ast.name.c_str());
+        printf("current scope: %s\n", scope.toString().c_str());
+#endif
+        throw SemanticError(SemanticError::FEATURE_NOT_FOUND, ast.name, ast.pos);
+    }
+}
+
+
+std::unique_ptr<sem::SemanticObject> StructureVisitor::visit(ast::AssignmentStatement& ast, sem::Scope& scope)
+{
+    auto as = std::make_unique<sem::AssignmentStatement>();
+    
+//    as->value = unique_dynamic_cast<sem::Expression>(visit(*ast.expr, classes));
+//    as->target = unique_dynamic_cast<sem::Expression>(visit(*ast.target, classes));
+    as->value = unique_dynamic_cast<sem::Expression>(ast.expr->accept(*this, scope));
+    as->target = unique_dynamic_cast<sem::Expression>(ast.target->accept(*this, scope));
+    
+    if (as->target->type->equals(*as->value->type)) {
+        return as;
+    }
+    else {
+        throw SemanticError(
+            SemanticError::TYPE_MISMATCH,
+            "Can't assign expression of type '" + as->value->type->asString() +
+            "' to value of type '" + as->target->type->asString() + "'.",
+            ast.pos
+        );
+    }
+}
+
+
+std::unique_ptr<sem::SemanticObject> StructureVisitor::visit(ast::ReturnStatement& ast, sem::Scope& scope)
+{
+    auto shouldReturn = scope.getReturnableType();
+    
+    if (shouldReturn == nullptr) {
+        if (ast.expr == nullptr)
+            return std::make_unique<sem::ReturnStatement>();
+        else
+            throw SemanticError(
+                SemanticError::INVALID_RETURN_TYPE,
+                "This method should not return any value.",
+                ast.expr->pos
+            );
+    }
+    else if (ast.expr == nullptr) {
+        throw SemanticError(
+            SemanticError::INVALID_RETURN_TYPE,
+            "This method should return a value.",
+            ast.pos
+        );
+    }
+    
+    auto returnValue = unique_dynamic_cast<sem::Expression>(ast.expr->accept(*this, scope));
+    
+    if (!shouldReturn->equals(*returnValue->type)) {
+        throw SemanticError(
+            SemanticError::INVALID_RETURN_TYPE,
+            "return value must be of type '" + shouldReturn->asString() + "' (not '" +
+            returnValue->type->asString() + "')",
+            ast.expr->pos
+        );
+    }
+    
+    auto as = std::make_unique<sem::ReturnStatement>();
+    as->value = std::move(returnValue);
+    return as;
+}
+
+
+std::unique_ptr<sem::SemanticObject> StructureVisitor::visit(ast::LocalVariableStatement& ast, sem::Scope& scope)
+{
+    throw "shouldn't be called";
+}
+
+
+std::unique_ptr<sem::SemanticObject> StructureVisitor::visit(
+    ast::AddressExpression& ast, sem::Scope& scope)
+{
+    auto target = unique_dynamic_cast<sem::Expression>(ast.target->accept(*this, scope));
+    auto& targetType = target->type;
+    
+    if (!target->isLValue()) {
+        throw NotLValue(targetType->asString(), ast.pos);
+    }
+    
+    return std::make_unique<sem::AddressExpression>(std::move(target));
+}
+
+
+std::unique_ptr<sem::SemanticObject> StructureVisitor::visit(ast::IntConst& ast, sem::Scope& scope)
+{
+    return std::make_unique<sem::IntConst>(ast.value);
+}
+
+
+std::unique_ptr<sem::SemanticObject> StructureVisitor::visit(ast::UnaryOperation& ast, sem::Scope& scope)
+{
+    auto argument = unique_dynamic_cast<sem::Expression>(ast.expr->accept(*this, scope));
+    auto ret = std::make_unique<sem::UnaryOperation>(argument->type);
+            // TODO not a feasible assumption
+    ret->opString = ast.opString;
+    ret->side = ast.side;
+    ret->arg = std::move(argument);
+    return ret;
+}
+
+
+std::unique_ptr<sem::SemanticObject> StructureVisitor::visit(ast::BinaryOperation& ast, sem::Scope& scope)
+{
+    auto leftEval = unique_dynamic_cast<sem::Expression>(ast.left->accept(*this, scope));
+    auto rightEval = unique_dynamic_cast<sem::Expression>(ast.right->accept(*this, scope));
+    
+    sem::Method* operationMethod = leftEval->type->getScope().resolveMethod(
+        ast.opString, { rightEval->type }
+    );
+    
+    Logger::getInstance().debug() << "looked for operation method for operator " <<
+    ast.opString << std::endl;
+    if (!operationMethod) {
+        throw SemanticError(SemanticError::OPERATOR_NOT_FOUND,
+            "operator " + ast.opString + " not found for types '" +
+            leftEval->type->asString() + "' and '" + rightEval->type->asString() + "'",
+            ast.opPos);
+    }
+    
+    auto ret = std::make_unique<sem::BinaryOperation>(leftEval->type, &ast);
+    
+    ret->operationMethod = operationMethod;
+    ret->opString = ast.opString;
+    ret->left = std::move(leftEval);
+    ret->right = std::move(rightEval);
+    return ret;
+}
+
+
+std::unique_ptr<sem::SemanticObject> StructureVisitor::visit(ast::NewArrayExpression& ast, sem::Scope& scope)
+{
+    auto ret = std::make_unique<sem::NewArrayExpression>(scope.getType(*ast.type));
+    return ret;
+}
+
+
+std::unique_ptr<sem::SemanticObject> StructureVisitor::visit(ast::CastExpression& ast, sem::Scope& scope)
+{
+    auto expr = unique_dynamic_cast<sem::Expression>(ast.expression->accept(*this, scope));
+    auto type = scope.getType(*ast.targetType);
+    return std::make_unique<sem::CastExpression>(
+        std::move(expr), std::move(type), &ast);
+}
+

src/AstVisitor.h

@@ -0,0 +1,87 @@
+#ifndef QLOW_AST_VISITOR_H
+#define QLOW_AST_VISITOR_H
+
+#include "Visitor.h"
+#include "Ast.h"
+#include "Semantic.h"
+#include "Builtin.h"
+#include "Scope.h"
+
+
+#include <memory>
+
+
+namespace qlow
+{
+    namespace ast
+    {
+        template<typename T>
+        using List = std::vector<std::unique_ptr<T>>;
+    }
+}
+
+
+namespace qlow
+{
+    class StructureVisitor;
+}
+
+
+class qlow::StructureVisitor :
+    public Visitor<
+        std::unique_ptr<sem::SemanticObject>,
+        sem::Scope&,
+
+        ast::Class,
+        ast::FeatureDeclaration,
+        ast::FieldDeclaration,
+        ast::MethodDefinition,
+        ast::VariableDeclaration,
+        ast::Statement,
+        ast::DoEndBlock,
+        ast::IfElseBlock,
+        ast::WhileBlock,
+        ast::Expression,
+        ast::FeatureCall,
+        ast::AssignmentStatement,
+        ast::ReturnStatement,
+        ast::LocalVariableStatement,
+        ast::AddressExpression,
+        ast::IntConst,
+        ast::UnaryOperation,
+        ast::BinaryOperation,
+        ast::NewArrayExpression,
+        ast::CastExpression
+    >
+{
+public:
+    using ReturnType = std::unique_ptr<sem::SemanticObject>;
+
+    ReturnType visit(ast::Class& ast, sem::Scope& scope) override;
+    ReturnType visit(ast::FeatureDeclaration& ast, sem::Scope& scope) override;
+    ReturnType visit(ast::FieldDeclaration& ast, sem::Scope& scope) override;
+    ReturnType visit(ast::MethodDefinition& ast, sem::Scope& scope) override;
+    ReturnType visit(ast::VariableDeclaration& ast, sem::Scope& scope) override;
+    ReturnType visit(ast::Statement& ast, sem::Scope& scope) override;
+    ReturnType visit(ast::DoEndBlock& ast, sem::Scope& scope) override;
+    ReturnType visit(ast::IfElseBlock& ast, sem::Scope& scope) override;
+    ReturnType visit(ast::WhileBlock& ast, sem::Scope& scope) override;
+    ReturnType visit(ast::Expression& ast, sem::Scope& scope) override;
+    ReturnType visit(ast::FeatureCall& ast, sem::Scope& scope) override;
+    ReturnType visit(ast::AssignmentStatement& ast, sem::Scope& scope) override;
+    ReturnType visit(ast::ReturnStatement& ast, sem::Scope& scope) override;
+    ReturnType visit(ast::LocalVariableStatement& ast, sem::Scope& scope) override;
+    ReturnType visit(ast::AddressExpression& ast, sem::Scope& scope) override;
+    ReturnType visit(ast::IntConst& ast, sem::Scope& scope) override;
+    ReturnType visit(ast::UnaryOperation& ast, sem::Scope& scope) override;
+    ReturnType visit(ast::BinaryOperation& ast, sem::Scope& scope) override;
+    ReturnType visit(ast::NewArrayExpression& ast, sem::Scope& scope) override;
+    ReturnType visit(ast::CastExpression& ast, sem::Scope& scope) override;
+};
+
+
+
+
+#endif // QLOW_AST_VISITOR_H
+
+

src/CodeGeneration.cpp

@@ -0,0 +1,336 @@
+#include "CodeGeneration.h"
+
+#include <llvm/IR/LLVMContext.h>
+#include <llvm/IR/LegacyPassManager.h>
+#include <llvm/Transforms/IPO/PassManagerBuilder.h>
+#include <llvm/IR/Type.h>
+#include <llvm/IR/DerivedTypes.h>
+#include <llvm/IR/Constants.h>
+#include <llvm/IR/BasicBlock.h>
+#include <llvm/IR/Verifier.h>
+#include <llvm/IR/IRBuilder.h>
+#include <llvm/IR/Attributes.h>
+#include <llvm/Target/TargetMachine.h>
+#include <llvm/Support/TargetRegistry.h>
+#include <llvm/Support/TargetSelect.h>
+#include <llvm/Support/FileSystem.h>
+#include <llvm/Support/raw_os_ostream.h>
+
+
+using namespace qlow;
+
+static llvm::LLVMContext context;
+
+namespace qlow
+{
+namespace gen
+{
+
+std::unique_ptr<llvm::Module> generateModule(const sem::GlobalScope& objects)
+{
+    using llvm::Module;
+    using llvm::Function;
+    using llvm::Argument;
+    using llvm::Type;
+    using llvm::FunctionType;
+    using llvm::BasicBlock;
+    using llvm::Value;
+    using llvm::IRBuilder;
+    
+    Logger& logger = Logger::getInstance();
+    
+#ifdef DEBUGGING
+        printf("creating llvm module\n"); 
+#endif 
+
+    std::unique_ptr<Module> module = llvm::make_unique<Module>("qlow_module", context);
+
+    // create llvm structs
+    // TODO implement detection of circles
+    for (auto& [name, cl] : objects.classes) {
+        llvm::StructType* st;
+        std::vector<llvm::Type*> fields;
+#ifdef DEBUGGING
+        printf("creating llvm struct for %s\n", name.c_str());
+#endif
+        int llvmStructIndex = 0;
+        for (auto& [name, field] : cl->fields) {
+            field->llvmStructIndex = llvmStructIndex;
+            fields.push_back(field->type->getLlvmType(context));
+            if (fields[fields.size() - 1] == nullptr)
+                throw "internal error: possible circular dependency";
+            
+            llvmStructIndex++;
+        }
+        st = llvm::StructType::create(context, fields, name);
+        cl->llvmType = st;
+    }
+    
+    llvm::AttrBuilder ab;
+    ab.addAttribute(llvm::Attribute::AttrKind::NoInline);
+    ab.addAttribute(llvm::Attribute::AttrKind::NoUnwind);
+    //ab.addAttribute(llvm::Attribute::AttrKind::OptimizeNone);
+    //ab.addAttribute(llvm::Attribute::AttrKind::UWTable);
+    ab.addAttribute("no-frame-pointer-elim", "true");
+    ab.addAttribute("no-frame-pointer-elim-non-leaf");
+    llvm::AttributeSet as = llvm::AttributeSet::get(context, ab);
+    
+    
+    std::vector<llvm::Function*> functions;
+    auto verifyStream = llvm::raw_os_ostream(logger.debug());
+    
+    // create all llvm functions
+    for (auto& [name, cl] : objects.classes) {
+        for (auto& [name, method] : cl->methods) {
+            Function* func = generateFunction(module.get(), method.get());
+            for (auto a : as) {
+                func->addFnAttr(a);
+            }
+            functions.push_back(func);
+        }
+    }
+    
+    for (auto& [name, method] : objects.functions) {
+        Function* func = generateFunction(module.get(), method.get());
+        for (auto a : as) {
+            func->addFnAttr(a);
+        }
+        functions.push_back(func);
+    }
+
+    for (auto& [name, cl] : objects.classes){
+        for (auto& [name, method] : cl->methods) {
+            if (!method->body)
+                continue;
+            
+            FunctionGenerator fg(*method, module.get(), as);
+            Function* f = fg.generate();
+            logger.debug() << "verifying function: " << method->name << std::endl;
+            bool corrupt = llvm::verifyFunction(*f, &verifyStream);
+            if (corrupt) {
+                module->print(verifyStream, nullptr);
+                throw "corrupt llvm function";
+            }
+#ifdef DEBUGGING
+            printf("verified function: %s\n", method->name.c_str());
+#endif
+        }
+    }
+    for (auto& [name, method] : objects.functions) {
+        if (!method->body)
+            continue;
+        
+        FunctionGenerator fg(*method, module.get(), as);
+        Function* f = fg.generate();
+        logger.debug() << "verifying function: " << method->name << std::endl;
+        bool corrupt = llvm::verifyFunction(*f, &verifyStream);
+        if (corrupt) {
+            module->print(verifyStream, nullptr);
+            throw "corrupt llvm function";
+        }
+#ifdef DEBUGGING
+        printf("verified function: %s\n", method->name.c_str());
+#endif
+    }
+    return module;
+}
+
+
+llvm::Function* generateFunction(llvm::Module* module, sem::Method* method)
+{
+    using llvm::Function;
+    using llvm::Argument;
+    using llvm::Type;
+    using llvm::FunctionType;
+    
+    Type* returnType;
+    if (method->returnType)
+        returnType = method->returnType->getLlvmType(context);
+    else
+        returnType = llvm::Type::getVoidTy(context);
+    
+    std::vector<Type*> argumentTypes;
+    if (method->thisExpression != nullptr) {
+        Type* enclosingType = method->thisExpression->type->getLlvmType(context);
+        argumentTypes.push_back(enclosingType);
+    }
+    
+    for (auto& arg : method->arguments) {
+        Type* argumentType = arg->type->getLlvmType(context);
+        argumentTypes.push_back(argumentType);
+    }
+    
+    FunctionType* funcType = FunctionType::get(
+        returnType, argumentTypes, false);
+#ifdef DEBUGGING
+    printf("looking up llvm type of %s\n", method->name.c_str());
+#endif 
+    if (returnType == nullptr)
+        throw "invalid return type";
+    Function* func = Function::Create(funcType, Function::ExternalLinkage, method->name, module);
+    method->llvmNode = func;
+    
+    // linking alloca instances for funcs
+    auto argIterator = func->arg_begin();
+    if (method->thisExpression != nullptr) {
+        method->thisExpression->allocaInst = &*argIterator;
+        Logger::getInstance().debug() << "allocaInst of this";
+        argIterator++;
+    }
+    
+    size_t argIndex = 0;
+    for (; argIterator != func->arg_end(); argIterator++) {
+        if (argIndex > method->arguments.size())
+            throw "internal error";
+        method->arguments[argIndex]->allocaInst = &*argIterator;
+#ifdef DEBUGGING
+        printf("allocaInst of arg '%s': %p\n", method->arguments[argIndex]->name.c_str(), method->arguments[argIndex]->allocaInst);
+#endif 
+        argIndex++;
+    }
+    
+    //printf("UEEEEEEEE %s\n", method->name.c_str());
+    return func;
+}
+
+
+void generateObjectFile(const std::string& filename, std::unique_ptr<llvm::Module> module, int optLevel)
+{
+    using llvm::legacy::PassManager;
+    using llvm::PassManagerBuilder;
+    using llvm::raw_fd_ostream;
+    using llvm::Target;
+    using llvm::TargetMachine;
+    using llvm::TargetRegistry;
+    using llvm::TargetOptions;
+
+    Logger& logger = Logger::getInstance();
+    logger.debug() << "verifying mod" << std::endl;
+    auto ostr = llvm::raw_os_ostream(logger.debug());
+#ifdef DEBUGGING
+    module->print(ostr, nullptr);
+#endif
+    bool broken = llvm::verifyModule(*module);
+    
+    if (broken)
+        throw "invalid llvm module";
+    
+    logger.debug() << "mod verified" << std::endl;
+
+    llvm::InitializeAllTargetInfos();
+    llvm::InitializeAllTargets();
+    llvm::InitializeAllTargetMCs();
+    llvm::InitializeAllAsmParsers();
+    llvm::InitializeAllAsmPrinters();
+
+    PassManager pm;
+    
+    int sizeLevel = 0;
+    PassManagerBuilder builder;
+    builder.OptLevel = optLevel;
+    builder.SizeLevel = sizeLevel;
+    if (optLevel >= 2) {
+        builder.DisableUnitAtATime = false;
+        builder.DisableUnrollLoops = false;
+        builder.LoopVectorize = true;
+        builder.SLPVectorize = true;
+    }
+
+    builder.populateModulePassManager(pm);
+
+    const char cpu[] = "generic";
+    const char features[] = "";
+
+    std::string error;
+    std::string targetTriple = llvm::sys::getDefaultTargetTriple();
+    const Target* target = TargetRegistry::lookupTarget(targetTriple, error);
+
+    if (!target) {
+        logger.debug() << "could not create target: " << error << std::endl;
+        throw "internal error";
+    }
+
+    TargetOptions targetOptions;
+    auto relocModel = llvm::Optional<llvm::Reloc::Model>(llvm::Reloc::Model::PIC_);
+    std::unique_ptr<TargetMachine> targetMachine(
+        target->createTargetMachine(targetTriple, cpu,
+            features, targetOptions, relocModel));
+
+    std::error_code errorCode;
+    raw_fd_ostream dest(filename, errorCode, llvm::sys::fs::F_None);
+    targetMachine->addPassesToEmitFile(pm, dest,
+//        llvm::LLVMTargetMachine::CGFT_ObjectFile,
+        llvm::TargetMachine::CGFT_ObjectFile);
+
+    pm.run(*module);
+    dest.flush();
+    dest.close();
+
+    return;
+}
+
+} // namespace gen
+} // namespace qlow
+
+
+llvm::Function* qlow::gen::FunctionGenerator::generate(void)
+{
+    using llvm::Function;
+    using llvm::Argument;
+    using llvm::Type;
+    using llvm::FunctionType;
+    using llvm::BasicBlock;
+    using llvm::Value;
+    using llvm::IRBuilder;
+    
+#ifdef DEBUGGING
+    printf("generate function %s\n", method.name.c_str()); 
+#endif
+
+    Function* func = module->getFunction(method.name);
+
+    if (func == nullptr) {
+        throw "internal error: function not found";
+    }
+
+    BasicBlock* bb = BasicBlock::Create(context, "entry", func);
+
+    pushBlock(bb);
+
+    IRBuilder<> builder(context);
+    builder.SetInsertPoint(bb);
+    for (auto& [name, var] : method.body->scope.getLocals()) {
+        if (var.get() == nullptr)
+            throw "wtf null variable";
+        if (var->type == nullptr)
+            throw "wtf null type";
+        
+        llvm::AllocaInst* v = builder.CreateAlloca(var->type->getLlvmType(context));
+        var->allocaInst = v;
+    }
+    
+    for (auto& statement : method.body->statements) {
+#ifdef DEBUGGING
+        printf("statement visit %s\n", statement->toString().c_str());
+#endif
+        statement->accept(statementVisitor, *this);
+    }
+    
+
+#ifdef DEBUGGING
+    printf("End of Function\n");
+#endif
+    
+    //Value* val = llvm::ConstantFP::get(context, llvm::APFloat(5.0));
+    
+    builder.SetInsertPoint(getCurrentBlock());
+    if (method.returnType->equals(sem::NativeType(sem::NativeType::Type::VOID))) {
+        if (!getCurrentBlock()->getTerminator())
+            builder.CreateRetVoid();
+    }
+
+    return func;
+}
+
+
+

src/CodeGeneration.h

@@ -0,0 +1,57 @@
+#ifndef QLOW_CODE_GENERATION_H
+#define QLOW_CODE_GENERATION_H
+
+#include "Semantic.h"
+#include "Builtin.h"
+#include "CodegenVisitor.h"
+
+#include <stack>
+
+#include <llvm/IR/Module.h>
+
+namespace qlow
+{
+namespace gen
+{
+    std::unique_ptr<llvm::Module> generateModule(const sem::GlobalScope& objects);
+    llvm::Function* generateFunction (llvm::Module* module, sem::Method* method);
+    void generateObjectFile(const std::string& name, std::unique_ptr<llvm::Module> module, int optLevel);
+
+    class FunctionGenerator;
+}
+}
+
+class qlow::gen::FunctionGenerator
+{
+    const sem::Method& method;
+    llvm::Module* module;
+    llvm::AttributeSet& attributes;
+
+    std::stack<llvm::BasicBlock*> basicBlocks;
+
+public:
+
+    StatementVisitor statementVisitor;
+    ExpressionCodegenVisitor expressionVisitor;
+    LValueVisitor lvalueVisitor;
+
+    inline FunctionGenerator(const sem::Method& m, llvm::Module* module,
+        llvm::AttributeSet& attributes) :
+        method{ m },
+        module{ module },
+        attributes{ attributes },
+        expressionVisitor{ *this }
+    {
+    }
+
+    llvm::Function* generate(void);
+
+    inline llvm::Module* getModule(void) const { return module; }
+    inline llvm::LLVMContext& getContext(void) const { return module->getContext(); }
+    inline llvm::BasicBlock* getCurrentBlock(void) const { return basicBlocks.top(); }
+    inline void pushBlock(llvm::BasicBlock* bb) { basicBlocks.push(bb); }
+    inline llvm::BasicBlock* popBlock(void) { auto* bb = basicBlocks.top(); basicBlocks.pop(); return bb; }
+};
+
+
+#endif // QLOW_CODE_GENERATION_H

src/Driver.cpp

@@ -0,0 +1,221 @@
+#include "Driver.h"
+
+#include "Ast.h"
+#include "Semantic.h"
+#include "Builtin.h"
+#include "CodeGeneration.h"
+
+#include "Logging.h"
+
+#include <cstdio>
+
+extern std::unique_ptr<std::vector<std::unique_ptr<qlow::ast::AstObject>>> parsedClasses;
+extern FILE* qlow_parser_in;
+extern int qlow_parser_parse(void);
+extern const char* qlow_parser_filename;
+
+using namespace qlow;
+
+Options Options::parseOptions(int argc, char** argv)
+{
+    static const std::map<std::string, bool Options::*> boolArgs = 
+    {
+        {"-S",              &Options::emitAssembly},
+        {"--emit-assembly", &Options::emitAssembly},
+        {"-L",              &Options::emitLlvm},
+        {"--emit-llvm",     &Options::emitLlvm},
+    };
+    
+    Options options{};
+    
+    for (int i = 1; i < argc; i++) {
+        std::string arg = argv[i];
+        if (boolArgs.find(arg) != boolArgs.end()) {
+            bool Options::* attr = boolArgs.find(arg)->second;
+            options.*attr = true;
+        }
+        else if (arg == "-o" || arg == "--out") {
+            if (argc > i + 1) {
+                options.outfile = argv[++i];
+            }
+            else {
+                throw "Please specify a filename after '-o'";
+            }
+        }
+        else if (arg.rfind("-O", 0) == 0) {
+            if (arg.size() > 2) {
+                options.optLevel = std::stoi(arg.substr(2));
+            }
+            else {
+                options.optLevel = 2;
+            }
+        }
+        else {
+            if (options.outfile == "")
+                options.outfile = arg + ".o";
+            options.infiles.push_back(std::move(arg));
+        }
+    }
+    if (options.outfile == "")
+        options.outfile = "a.out";
+    return options;
+}
+
+
+Driver::Driver(int argc, char** argv) :
+    options{ Options::parseOptions(argc, argv) }
+{
+}
+
+
+int Driver::run(void)
+{
+    Logger& logger = Logger::getInstance();
+    
+    logger.debug() << "starting parser" << std::endl;
+    //logger.logError("driver not yet implemented", {options.emitAssembly ? "asm" : "noasm", 10, 11, 12, 13});
+    
+    std::vector<std::unique_ptr<qlow::ast::AstObject>> objects;
+    bool errorOccurred = false;
+    
+    for (auto& filename : options.infiles) {
+        std::FILE* file = std::fopen(filename.c_str(), "r");
+        ::qlow_parser_filename = filename.c_str();
+        
+        try {
+            auto newObjects = parseFile(file);
+            objects.insert(objects.end(),
+                           std::make_move_iterator(newObjects.begin()),
+                           std::make_move_iterator(newObjects.end()));
+        }
+        catch (const CompileError& ce) {
+            ce.print(logger);
+            errorOccurred = true;
+        }
+        catch (const char* errMsg) {
+            reportError(errMsg);
+            errorOccurred = true;
+        }
+        catch (...) {
+            reportError("an unknown error occurred.");
+            errorOccurred = true;
+        }
+        
+        if (file)
+            std::fclose(file);
+    }
+    
+    if (errorOccurred) {
+        logger << "Aborting due to syntax errors." << std::endl;
+        return 1;
+    }
+    
+    std::unique_ptr<qlow::sem::GlobalScope> semClasses = nullptr;
+    try {
+        semClasses =
+            qlow::sem::createFromAst(objects);
+    }
+    catch(SemanticError& se) {
+        se.print(logger);
+        errorOccurred = true;
+    }
+    catch(const char* err) {
+        reportError(err);
+        errorOccurred = true;
+    }
+    catch (...) {
+        reportError("an unknown error occurred.");
+        errorOccurred = true;
+    }
+    
+    if (errorOccurred) {
+        logger << "Aborting due to semantic errors." << std::endl;
+        return 1;
+    }
+    
+
+    for (auto& [a, b] : semClasses->classes) {
+        logger.debug() << a << ": " << b->toString() << std::endl;
+    }
+    
+    
+
+    /*auto main = semClasses->classes.find("Main");
+    qlow::sem::Class* mainClass = nullptr;
+    if (main == semClasses->classes.end()) {
+        logger.logError("No Main class found");
+        return 1;
+    }
+    else {
+        mainClass = main->second.get();
+    }*/
+    
+    auto* mainMethod = semClasses->getMethod("main");
+    if (mainMethod == nullptr && false) {
+        // TODO handle main ckeck well
+        logger.logError("no main method found");
+        return 1;
+    }
+    
+    logger.debug() << "starting code generation!" << std::endl;
+
+    std::unique_ptr<llvm::Module> mod = nullptr;
+    
+    try {
+        mod = qlow::gen::generateModule(*semClasses);
+    }
+    catch (const char* err) {
+        reportError(err);
+        return 1;
+    }
+    catch (SemanticError& err) {
+        err.print(logger);
+        return 1;
+    }
+    catch (...) {
+        reportError("unknown error during code generation");
+        return 1;
+    }
+    
+    try {
+        qlow::gen::generateObjectFile(options.outfile, std::move(mod), options.optLevel);
+    }
+    catch (const char* msg) {
+        logger.logError(msg);
+        return 1;
+    }
+    catch (...) {
+        logger.logError("unknown error during object file creation");
+        reportError("unknown error during object file creation");
+        return 1;
+    }
+    
+    logger.debug() << "object exported!" << std::endl;
+    
+    return 0;
+}
+
+
+std::vector<std::unique_ptr<qlow::ast::AstObject>> Driver::parseFile(FILE* file)
+{
+    ::qlow_parser_in = file;
+    if (!::qlow_parser_in)
+        throw "Could not run parser: Invalid file";
+    
+    ::qlow_parser_parse();
+    
+    auto retval = std::move(*parsedClasses);
+    parsedClasses.reset();
+    return retval;
+}
+
+
+
+
+
+
+
+
+
+
+

src/Driver.h

@@ -0,0 +1,52 @@
+#ifndef QLOW_DRIVER_H
+#define QLOW_DRIVER_H
+
+#include <vector>
+#include <optional>
+#include <memory>
+#include <string>
+#include <utility>
+
+namespace qlow
+{
+    struct Options;
+    
+    class Driver;
+    
+    
+    namespace ast
+    {
+        struct AstObject;
+    }
+}
+
+
+struct qlow::Options
+{
+    bool emitAssembly;
+    bool emitLlvm;
+    std::string outfile = "a.out";
+    std::vector<std::string> infiles;
+    
+    int optLevel = 0;
+    
+    static Options parseOptions(int argc, char** argv);
+};
+
+
+class qlow::Driver
+{
+    Options options;
+public:
+    Driver(void) = delete;
+    Driver(int argc, char** argv);
+    
+    int run(void);
+    
+    /// \brief runs the parser over a given stream
+    /// \warning Don't call concurrently. Not (yet) supported!
+    std::vector<std::unique_ptr<qlow::ast::AstObject>> parseFile(FILE* file);
+};
+
+
+#endif // QLOW_DRIVER_H

src/Scope.cpp

@@ -12,7 +12,7 @@ sem::Scope::~Scope(void)
 
 
 sem::Method* sem::Scope::resolveMethod(const std::string& name,
-    const std::vector<TypeId> argumentTypes)
+    const std::vector<std::shared_ptr<Type>> argumentTypes)
 {
     sem::Method* m = getMethod(name);
     if (!m)
@@ -45,7 +45,7 @@ sem::Method* sem::GlobalScope::getMethod(const std::string& name)
 }
 
 
-qlow::sem::TypeId sem::GlobalScope::getType(const ast::Type& name)
+std::shared_ptr<sem::Type> sem::GlobalScope::getType(const ast::Type& name)
 {
     if (const auto* arr = dynamic_cast<const ast::ArrayType*>(&name); arr) {
         return std::make_shared<sem::ArrayType>(getType(*arr->arrayType));

src/Scope.h

@@ -8,8 +8,6 @@
 #include <llvm/IR/Type.h>
 #include <llvm/IR/Value.h>
 
-#include "Util.h"
-
 namespace qlow
 {
     namespace ast
@@ -25,7 +23,7 @@ namespace qlow
         template<typename T>
         using SymbolTable = std::map<std::string, std::unique_ptr<T>>;
 
-        class Semantic;
+
         struct Class;
         struct Method;
         struct Variable;
@@ -40,8 +38,6 @@ namespace qlow
         class NativeTypeScope;
         
         class Type;
-        using TypeId = size_t;
-
         class NativeType;
     }
 }
@@ -49,25 +45,16 @@ namespace qlow
 
 class qlow::sem::Scope
 {
-protected:
-    const Semantic& semantic;
 public:
-    inline Scope(const Semantic& semantic) :
-        semantic{ semantic }
-    {
-    }
-
     virtual ~Scope(void);
     virtual Variable* getVariable(const std::string& name) = 0;
     virtual Method* getMethod(const std::string& name) = 0;
-    virtual std::optional<TypeId> getType(const ast::Type& name) = 0;
-    virtual std::optional<TypeId> getReturnableType(void) = 0;
+    virtual std::shared_ptr<Type> getType(const ast::Type& name) = 0;
+    virtual std::shared_ptr<Type> getReturnableType(void) = 0;
     virtual Method* resolveMethod(const std::string& name,
-        const std::vector<TypeId> argumentTypes);
+        const std::vector<std::shared_ptr<Type>> argumentTypes);
 
     virtual std::string toString(void) = 0;
-
-    inline const Semantic& getSemantic(void) const { return semantic; }
 };
 
 
@@ -78,18 +65,12 @@ public:
     SymbolTable<Method> functions;
     OwningList<Cast> casts;
 public:
-    inline GlobalScope(const Semantic& semantic) :
-        Scope{ semantic }
-    {
-    }
-
-
-    virtual Variable* getVariable(const std::string& name) override;
-    virtual Method* getMethod(const std::string& name) override;
-    virtual std::optional<TypeId> getType(const ast::Type& name) override;
-    virtual std::optional<TypeId> getReturnableType(void) override;
+    virtual Variable* getVariable(const std::string& name);
+    virtual Method* getMethod(const std::string& name);
+    virtual std::shared_ptr<Type> getType(const ast::Type& name);
+    virtual std::shared_ptr<Type> getReturnableType(void);
 
-    virtual std::string toString(void) override;
+    virtual std::string toString(void);
 };
 
 
@@ -99,14 +80,9 @@ class qlow::sem::NativeScope : public GlobalScope
 public:
     SymbolTable<std::shared_ptr<NativeType>> types;
 public:
-    inline NativeScope(const Semantic& semantic) :
-        GlobalScope{ semantic }
-    {
-    }
+    virtual std::shared_ptr<Type> getType(const ast::Type& name);
 
-    virtual std::optional<TypeId> getType(const ast::Type& name);
-
-    virtual std::string toString(void) override;
+    virtual std::string toString(void);
     
     static NativeScope& getInstance(void);
 };
@@ -119,17 +95,14 @@ class qlow::sem::ClassScope : public Scope
     Class* classRef;
 public:
     inline ClassScope(Scope& parentScope, Class* classRef) :
-        Scope{ parentScope.getSemantic() },
-        parentScope{ parentScope },
-        classRef{ classRef }
+        parentScope{ parentScope }, classRef{ classRef }
     {
     }
-
-    virtual Variable* getVariable(const std::string& name) override;
-    virtual Method* getMethod(const std::string& name) override;
-    virtual std::optional<TypeId> getType(const ast::Type& name) override;
-    virtual std::optional<TypeId> getReturnableType(void) override;
-    virtual std::string toString(void) override;
+    virtual Variable* getVariable(const std::string& name);
+    virtual Method* getMethod(const std::string& name);
+    virtual std::shared_ptr<Type> getType(const ast::Type& name);
+    virtual std::shared_ptr<Type> getReturnableType(void);
+    virtual std::string toString(void);
 };
 
 
@@ -137,7 +110,7 @@ class qlow::sem::LocalScope : public Scope
 {
     Scope& parentScope;
     SymbolTable<Variable> localVariables;
-    std::optional<TypeId> returnType;
+    std::shared_ptr<Type> returnType;
     Method* enclosingMethod;
 public:
     LocalScope(Scope& parentScope, Method* enclosingMethod);
@@ -146,11 +119,11 @@ public:
     void putVariable(const std::string& name, std::unique_ptr<Variable> v);
     SymbolTable<Variable>& getLocals(void);
 
-    virtual Variable* getVariable(const std::string& name) override;
-    virtual Method* getMethod(const std::string& name) override;
-    virtual std::optional<TypeId> getType(const ast::Type& name) override;
-    virtual std::optional<TypeId> getReturnableType(void) override;
-    virtual std::string toString(void) override;
+    virtual Variable* getVariable(const std::string& name);
+    virtual Method* getMethod(const std::string& name);
+    virtual std::shared_ptr<Type> getType(const ast::Type& name);
+    virtual std::shared_ptr<Type> getReturnableType(void);
+    virtual std::string toString(void);
 };
 
 
@@ -159,18 +132,17 @@ class qlow::sem::TypeScope : public Scope
 protected:
     Type& type;
 public:
-    inline TypeScope(const Semantic& semantic, Type& type) :
-        Scope{ semantic },
+    inline TypeScope(Type& type) :
         type{ type }
     {
     }
     
     
-    virtual Variable* getVariable(const std::string& name) override;
-    virtual Method* getMethod(const std::string& name) override;
-    virtual std::optional<TypeId> getType(const ast::Type& name) override;
-    virtual std::optional<TypeId> getReturnableType(void) override;
-    virtual std::string toString(void) override;
+    virtual Variable* getVariable(const std::string& name);
+    virtual Method* getMethod(const std::string& name);
+    virtual std::shared_ptr<Type> getType(const ast::Type& name);
+    virtual std::shared_ptr<Type> getReturnableType(void);
+    virtual std::string toString(void);
 };
 
 
@@ -178,14 +150,14 @@ class qlow::sem::NativeTypeScope : public TypeScope
 {
     NativeType& nativeType;
 public:
-    inline NativeTypeScope(const Semantic& semantic, NativeType& type) :
-        TypeScope{ semantic, (Type&) type },
+    inline NativeTypeScope(NativeType& type) :
+        TypeScope{ (Type&) type },
         nativeType{ type }
     {
     }
     
     
-    virtual Method* getMethod(const std::string& name) override;
+    virtual Method* getMethod(const std::string& name);
     std::shared_ptr<Type> implementInlineOperation(const std::string&, llvm::Value* a);
 };
 

src/main.cpp

@@ -1,9 +1,108 @@
+#include <iostream>
+
+#include <unistd.h>
+
+#include "Ast.h"
+#include "Semantic.h"
+#include "Builtin.h"
+#include "CodeGeneration.h"
+
 #include "Driver.h"
 
+
+extern std::unique_ptr<std::vector<std::unique_ptr<qlow::ast::Class>>> parsedClasses;
+extern FILE* qlow_parser_in;
+extern int qlow_parser_parse(void);
+
+
 int main(int argc, char** argv)
 {
+    /*int c;
+    while ((c = getopt(argc, argv, "c:")) != -1) {
+        switch (c) {
+            case 'c':
+                printf("c: %s", optarg);
+            break;
+            default:
+                printf("ay: %c\n", c);
+        }
+    }*/
+    
     qlow::Driver driver(argc, argv);
     return driver.run();
+
+    return 0;
+    /*
+    {
+    const char* filename = argv[optind];
+    
+    try {
+        ::qlow_parser_in = stdin;
+        
+        ::qlow_parser_in = fopen(filename, "r");
+        if (!::qlow_parser_in)
+            throw (std::string("File not found: ") + filename).c_str();
+        
+        ::qlow_parser_parse();
+        std::cout << parsedClasses->size() << std::endl;
+
+        std::cout << "parsing completed!" << std::endl;
+
+        std::unique_ptr<qlow::sem::GlobalScope> semClasses =
+            qlow::sem::createFromAst(*parsedClasses.get());
+
+        for (auto& [a, b] : semClasses->classes) {
+            std::cout << a << ": " << b->toString() << std::endl;
+        }
+
+        auto main = semClasses->classes.find("Main");
+        qlow::sem::Class* mainClass = nullptr;
+        if (main == semClasses->classes.end()) {
+            throw "No Main class found!";
+        }
+        else {
+            mainClass = main->second.get();
+        }
+        auto mainmain = mainClass->methods.find("main");
+        qlow::sem::Method* mainMethod = nullptr;
+        if (mainmain == mainClass->methods.end()) {
+            //throw "No main method found inside Main class!";
+        }
+        else {
+            mainMethod = mainmain->second.get();
+        }
+        
+        std::cout << "starting code generation!" << std::endl;
+
+        auto mod = qlow::gen::generateModule(semClasses->classes);
+        qlow::gen::generateObjectFile("obj.o", std::move(mod));
+        
+        std::cout << "object exported!" << std::endl;
+    }
+    catch (qlow::sem::SemanticException& se)
+    {
+        std::cerr << se.getMessage() << std::endl;
+    }
+    catch (const std::string& err)
+    {
+        std::cerr << err << std::endl;
+    }
+    catch (const char* err)
+    {
+        std::cerr << err << std::endl;
+    }
+    catch (...)
+    {
+        std::cerr << "an unknown error occurred" << std::endl;
+    }
+    
+    if (::qlow_parser_in != stdin)
+        fclose(::qlow_parser_in);
+    }
+
+    for (auto&& c : *parsedClasses) {
+        delete c.release();
+    }*/
 }
 
 

src/makefile

@@ -5,8 +5,8 @@ CXX := clang++
 
 LLVMCONFIG := llvm-config-5.0
 
-INCLUDEDIRS := -I$(shell $(LLVMCONFIG) --includedir) -I. -I.. -Isem/ -Iast/
-CXXFLAGS := -std=c++17 $(INCLUDEDIRS) -w $(FLAGS) # -Wall -Wextra
+INCLUDEDIRS := -I$(shell $(LLVMCONFIG) --includedir):. -I.. -Isem/
+CXXFLAGS := -std=c++17 $(INCLUDEDIRS) -w # -Wall -Wextra
 
 ifdef STATIC
 LDFLAGS := $(shell $(LLVMCONFIG) --link-static --ldflags --system-libs --libs all) -static -dead-strip -s

src/sem/Context.h

@@ -8,7 +8,7 @@ namespace qlow::sem
 {
     class Context;
     
-    using TypeId = size_tg
+    using TypeId = size_t;
 }
 
 

src/sem/Semantic.cpp

@@ -16,7 +16,8 @@ namespace qlow
 namespace sem
 {
 
-std::unique_ptr<Semantic> createFromAst(Ast& ast)
+std::unique_ptr<GlobalScope>
+    createFromAst(const std::vector<std::unique_ptr<qlow::ast::AstObject>>& objects)
 {
     
     Logger& logger = Logger::getInstance();
@@ -27,7 +28,7 @@ std::unique_ptr<Semantic> createFromAst(Ast& ast)
 
     // create classes
     std::unique_ptr<sem::GlobalScope> globalScope = std::make_unique<sem::GlobalScope>();
-    for (auto& astObject : ast.getObjects()) {
+    for (auto& astObject : objects) {
         if (auto* cls = dynamic_cast<ast::Class*>(astObject.get()); cls) {
             globalScope->classes[cls->name] = std::make_unique<sem::Class>(cls, *globalScope);
         }
@@ -105,7 +106,7 @@ std::unique_ptr<Semantic> createFromAst(Ast& ast)
     printf("created all method bodies\n");
 #endif
     
-    return std::make_unique<Semantic>(globalScope);
+    return globalScope;
 }
 
 }

src/sem/Semantic.h

@@ -18,10 +18,8 @@ namespace qlow
 {
     namespace sem
     {
-
-        class Semantic;
-
-        std::unique_ptr<Semantic> createFromAst(ast::Ast& ast);
+        std::unique_ptr<GlobalScope>
+            createFromAst(const std::vector<std::unique_ptr<qlow::ast::AstObject>>& objects);
 
         struct Class;
 
@@ -70,18 +68,6 @@ namespace qlow
 }
 
 
-class qlow::sem::Semantic
-{
-    std::unique_ptr<GlobalScope> globalScope;
-
-    std::vector<std::unique_ptr<Type>> types;
-public:
-    const SymbolTable<Class> getClasses(void) const;
-
-    TypeId getOrInsert(Class* cl);
-};
-
-
 struct qlow::sem::Class : public SemanticObject
 {
     qlow::ast::Class* astNode;
@@ -115,7 +101,7 @@ struct qlow::sem::Class : public SemanticObject
 
 struct qlow::sem::Variable : public SemanticObject
 {
-    TypeId type;
+    std::shared_ptr<Type> type;
     std::string name;
     bool isParameter;
 
@@ -124,13 +110,13 @@ struct qlow::sem::Variable : public SemanticObject
     llvm::Value* allocaInst;
     
     Variable(void) = default;
-    inline Variable(TypeId type, const std::string& name) :
-        type{ type },
+    inline Variable(std::shared_ptr<Type> type, const std::string& name) :
+        type{ std::move(type) },
         name{ name },
         allocaInst { nullptr }
     {
     }
-
+        
     virtual std::string toString(void) const override;
 };
 
@@ -145,7 +131,7 @@ struct qlow::sem::Field : public Variable
 struct qlow::sem::Method : public SemanticObject
 {
     Class* containingType;
-    std::optional<TypeId> returnType;
+    std::shared_ptr<Type> returnType;
     std::vector<Variable*> arguments;
     std::string name;
     ast::MethodDefinition* astNode;
@@ -156,7 +142,7 @@ struct qlow::sem::Method : public SemanticObject
 
     llvm::Function* llvmNode;
 
-    inline Method(Scope& parentScope, std::optional<TypeId> returnType) :
+    inline Method(Scope& parentScope, std::shared_ptr<Type> returnType) :
         containingType{ nullptr },
         returnType{ std::move(returnType) },
         scope{ parentScope, this },
@@ -185,7 +171,7 @@ struct qlow::sem::ThisExpression : public Variable
 {
     Method* method;
     inline ThisExpression(Method* method) :
-        Variable{ ClassType{ method->containingType }, "this" },
+        Variable{ std::make_shared<PointerType>(std::make_shared<ClassType>(method->containingType)), "this" },
         method{ method }
     {
     }
@@ -275,7 +261,7 @@ struct qlow::sem::Expression :
 {
     std::shared_ptr<sem::Type> type;
     
-    inline Expression(std::optional<TypeId> type) :
+    inline Expression(std::shared_ptr<Type> type) :
         type{ std::move(type) }
     {
     }
@@ -291,7 +277,7 @@ struct qlow::sem::Operation : public Expression
 {
     std::string opString;
     
-    inline Operation(std::optional<TypeId> type) :
+    inline Operation(std::shared_ptr<Type> type) :
         Expression{ std::move(type) }
     {
     }
@@ -339,7 +325,7 @@ struct qlow::sem::BinaryOperation : public Operation
     /// method that is called to execute the operator
     sem::Method* operationMethod;
     
-    inline BinaryOperation(std::optional<TypeId> type, ast::BinaryOperation* astNode) :
+    inline BinaryOperation(std::shared_ptr<Type> type, ast::BinaryOperation* astNode) :
         Operation{ std::move(type) },
         astNode{ astNode }
     {
@@ -354,12 +340,12 @@ struct qlow::sem::BinaryOperation : public Operation
 struct qlow::sem::CastExpression : public Expression
 {
     std::unique_ptr<Expression> expression;
-    std::optional<TypeId> targetType;
+    std::shared_ptr<Type> targetType;
     
     ast::CastExpression* astNode;
     
     inline CastExpression(std::unique_ptr<Expression> expression,
-                          std::optional<TypeId> type,
+                          std::shared_ptr<Type> type,
                           ast::CastExpression* astNode) :
         Expression{ type },
         expression{ std::move(expression) },
@@ -376,10 +362,10 @@ struct qlow::sem::CastExpression : public Expression
 
 struct qlow::sem::NewArrayExpression : public Expression
 {
-    std::optional<TypeId> arrayType;
+    std::shared_ptr<Type> arrayType;
     std::unique_ptr<Expression> length;
     
-    inline NewArrayExpression(std::optional<TypeId> arrayType) :
+    inline NewArrayExpression(std::shared_ptr<Type> arrayType) :
         Expression{ std::make_shared<ArrayType>(arrayType) },
         arrayType{ std::move(arrayType) }
     {
@@ -395,7 +381,7 @@ struct qlow::sem::UnaryOperation : public Operation
     qlow::ast::UnaryOperation::Side side;
     std::unique_ptr<Expression> arg;
     
-    inline UnaryOperation(std::optional<TypeId> type) :
+    inline UnaryOperation(std::shared_ptr<Type> type) :
         Operation{ std::move(type) }
     {
     }

src/sem/Type.h

@@ -26,7 +26,6 @@ namespace qlow
     namespace sem
     {
         struct SemanticObject;
-        class Semantic;
         
         class Type;
         
@@ -51,15 +50,7 @@ struct qlow::sem::SemanticObject
 
 class qlow::sem::Type : public SemanticObject
 {
-protected:
-    const Semantic& semantic;
 public:
-
-    inline Type(const Semantic& semantic) :
-        semantic{ semantic }
-    {
-    }
-
     virtual ~Type(void);
 
     /// \returns false by default
@@ -89,25 +80,24 @@ public:
 
 class qlow::sem::PointerType : public Type
 {
-    //std::shared_ptr<Type> derefType;
-    TypeId derefType;
+    std::shared_ptr<Type> derefType;
     sem::TypeScope scope;
 public:
-    inline PointerType(const Semantic& semantic) :
-        Type{ semantic },
-        scope{ semantic, *this }
+    inline PointerType(std::shared_ptr<Type> derefType) :
+        derefType{ derefType },
+        scope{ *this }
     {
     }
-
-    TypeId getDerefType(void) const { return derefType; }
-
+    
+    const std::shared_ptr<Type>& getDerefType(void) const { return derefType; }
+    
     inline bool isPointerType(void) const override { return true; }
-
+    
     virtual std::string asString(void) const override;
     virtual Scope& getScope(void) override;
-
+    
     virtual llvm::Type* getLlvmType(llvm::LLVMContext& context) const override;
-
+    
     virtual bool equals(const Type& other) const override;
 };
 
@@ -117,34 +107,32 @@ class qlow::sem::ClassType : public Type
     sem::Class* classType;
     sem::TypeScope scope;
 public:
-    inline ClassType(const Semantic& semantic, sem::Class* classType) :
-        Type{ semantic },
+    inline ClassType(sem::Class* classType) :
         classType{ classType },
-        scope{ semantic, *this }
+        scope{ *this }
     {
     }
-
+    
     inline bool isClassType(void) const override { return true; }
-
+    
     std::string asString(void) const;
     Scope& getScope(void);
-
+    
     virtual llvm::Type* getLlvmType(llvm::LLVMContext& context) const override;
     inline sem::Class* getClassType(void) { return classType; }
-    virtual bool equals(const Type& other) const override;
+    virtual bool equals(const Type& other) const;
 };
 
 
 class qlow::sem::ArrayType : public Type
 {
-    TypeId arrayType;
+    std::shared_ptr<sem::Type> arrayType;
     TypeScope scope;
 public:
     
-    inline ArrayType(const Semantic& semantic, TypeId arrayType) :
-        Type{ semantic },
-        arrayType{ arrayType },
-        scope{semantic, *this }
+    inline ArrayType(std::shared_ptr<sem::Type> arrayType) :
+        arrayType{ std::move(arrayType) },
+        scope{ *this }
     {
     }
     
@@ -154,8 +142,8 @@ public:
     Scope& getScope(void);
     
     virtual llvm::Type* getLlvmType(llvm::LLVMContext& context) const override;
-    inline TypeId getArrayType(void) { return arrayType; }
-    virtual bool equals(const Type& other) const override;
+    inline std::shared_ptr<sem::Type> getArrayType(void) { return arrayType; }
+    virtual bool equals(const Type& other) const;
 };
 
 
@@ -178,10 +166,9 @@ public:
     
     SymbolTable<NativeMethod> nativeMethods;
     
-    inline NativeType(const Semantic& semantic, Type type) :
-        sem::Type{ semantic },
+    inline NativeType(Type type) :
         type{ type },
-        scope{ semantic, *this }
+        scope{ *this }
     {
     }
     
@@ -193,7 +180,7 @@ public:
     bool isIntegerType(void) const;
     
     llvm::Type* getLlvmType(llvm::LLVMContext& context) const override;
-    virtual bool equals(const sem::Type& other) const override;
+    virtual bool equals(const sem::Type& other) const;
     
     /// cast an llvm::Value from another native type to this one
     llvm::Value* generateImplicitCast(llvm::Value* value);
@@ -201,4 +188,3 @@ public:
 
 
 #endif // QLOW_SEM_TYPE_H
-