still field access

src/AstVisitor.cpp

@@ -239,6 +239,8 @@ std::unique_ptr<sem::SemanticObject> StructureVisitor::visit(ast::FeatureCall& a
     else if (var) {
         if (sem::Field* field = dynamic_cast<sem::Field*>(var); field) {
             auto* thisExpr = scope.getVariable("this");
+            if (!thisExpr)
+                throw "no this found";
             return std::make_unique<sem::FieldAccessExpression>(std::make_unique<sem::LocalVariableExpression>(thisExpr), field);
         }
         else {

src/CodeGeneration.cpp

@@ -123,8 +123,8 @@ llvm::Function* generateFunction(llvm::Module* module, sem::Method* method)
         returnType = llvm::Type::getVoidTy(context);
     
     std::vector<Type*> argumentTypes;
-    if (method->containingType != nullptr) {
-        Type* enclosingType = method->containingType->llvmType;
+    if (method->thisExpression != nullptr) {
+        Type* enclosingType = method->thisExpression->type->getLlvmType(context);
         argumentTypes.push_back(enclosingType);
     }
     
@@ -143,8 +143,14 @@ llvm::Function* generateFunction(llvm::Module* module, sem::Method* method)
     Function* func = Function::Create(funcType, Function::ExternalLinkage, method->name, module);
     method->llvmNode = func;
     size_t index = 0;
-    for (auto& arg : func->args()) {
-        method->arguments[index]->allocaInst = &arg;
+    
+    if (method->thisExpression != nullptr) {
+        method->thisExpression->allocaInst = &*func->args().begin();
+        index++;
+    }
+    
+    for (auto arg = func->args().begin() + index; arg != func->args().end(); arg++) {
+        method->arguments[index]->allocaInst = &*arg;
 #ifdef DEBUGGING
         printf("allocaInst of arg '%s': %p\n", method->arguments[index]->name.c_str(), method->arguments[index]->allocaInst);
 #endif 

src/CodegenVisitor.cpp

@@ -276,10 +276,14 @@ llvm::Value* StatementVisitor::visit(sem::AssignmentStatement& assignment,
         dynamic_cast<sem::FieldAccessExpression*>(assignment.target.get()); targetVar) {
         
         logger.debug() << "assigning to FieldAccessExpression" << std::endl;
-    
-        llvm::Value* target = targetVar->target->accept(fg.expressionVisitor, builder);
-        auto elementPtr = builder.CreateGEP(target, llvm::ConstantInt::get(builder.getContext(), llvm::APInt(32, 0)));
-        builder.CreateStore(val, elementPtr);
+        if (targetVar->target) {
+            llvm::Value* target = targetVar->target->accept(fg.expressionVisitor, builder);
+            auto elementPtr = builder.CreateGEP(target, llvm::ConstantInt::get(builder.getContext(), llvm::APInt(32, 0)));
+            builder.CreateStore(val, elementPtr);
+        }
+        else {
+            throw "field access without target";
+        }
     }
     else {
         

src/Semantic.cpp

@@ -240,7 +240,10 @@ std::string MethodCallExpression::toString(void) const
 
 std::string FieldAccessExpression::toString(void) const
 {
-    return "FieldAccessExpression[" + accessed->toString() + "]";
+    if (this->target)
+        return "FieldAccessExpression[" + target->toString() + "." + accessed->toString() + "]";
+    else
+        return "FieldAccessExpression[" + accessed->toString() + "]";
 }
 
 

src/Semantic.h

@@ -135,6 +135,7 @@ struct qlow::sem::Method : public SemanticObject
     llvm::Function* llvmNode;
 
     inline Method(Scope& parentScope, std::shared_ptr<Type> returnType) :
+        containingType{ nullptr },
         returnType{ std::move(returnType) },
         scope{ parentScope, this },
         thisExpression{ std::make_unique<ThisExpression>(this) },
@@ -143,6 +144,7 @@ struct qlow::sem::Method : public SemanticObject
     }
     
     inline Method(ast::MethodDefinition* astNode, Scope& parentScope) :
+        containingType{ nullptr },
         astNode{ astNode },
         name{ astNode->name },
         scope{ parentScope, this },
@@ -382,6 +384,7 @@ struct qlow::sem::FieldAccessExpression : public Expression
     inline FieldAccessExpression(std::unique_ptr<Expression> target,
                                  Field* accessed ) :
         Expression{ accessed->type },
+        target{ std::move(target) },
         accessed{ accessed }
     {
     }

src/tests/structs.qlw

@@ -5,8 +5,9 @@ class Vec
     y: Integer
 
     yuhu: Integer do
-        x := 123
-        return x
+        //x := 123
+        //return x
+        return 123
     end
 end
 
@@ -16,6 +17,7 @@ main: Integer do
     value: Integer
     value := 5
 
+    var.x := 2
     value := var.yuhu
 //    var.x := 4
 //    var.hohoo := 4