Array assignment

src/Compiler/ModuleBuilder.cpp

@@ -159,7 +159,20 @@ void ModuleBuilder::buildAssignment(shared_ptr<StatementAssignment> statement) {
         return;
 
     llvm::Value *value = valueForExpression(statement->getExpression());
-    builder->CreateStore(value, alloca);
+
+    if (statement->getIndexExpression()) {
+        llvm::Value *indexValue = valueForExpression(statement->getIndexExpression());
+        llvm::Value *index[] = {
+            builder->getInt32(0),
+            indexValue
+        };
+        llvm::ArrayType *type = (llvm::ArrayType *)alloca->getAllocatedType();
+        llvm::Value *elementPtr = builder->CreateGEP(type, alloca, index, format("{}[]", statement->getName()));
+
+        builder->CreateStore(value, elementPtr);
+    } else {
+        builder->CreateStore(value, alloca);
+    }
 }
 
 void ModuleBuilder::buildBlock(shared_ptr<StatementBlock> statement) {

src/Parser/Parser.cpp

@@ -250,17 +250,35 @@ shared_ptr<Statement> Parser::matchStatementBlock(vector<TokenKind> terminalToke
 }
 
 shared_ptr<Statement> Parser::matchStatementAssignment() {
-    if (!tryMatchingTokenKinds({TokenKind::IDENTIFIER, TokenKind::LEFT_ARROW}, true, false))
+    int startIndex = currentIndex;
+
+    if (!tryMatchingTokenKinds({TokenKind::IDENTIFIER}, true, false))
         return nullptr;
-     
     shared_ptr<Token> identifierToken = tokens.at(currentIndex++);
-    currentIndex++; // arrow
+    shared_ptr<Expression> indexExpression;
+
+    if (tryMatchingTokenKinds({TokenKind::LEFT_SQUARE_BRACKET}, true, true)) {
+        indexExpression = nextExpression();
+        if (indexExpression == nullptr)
+            return nullptr;
+
+        if (!tryMatchingTokenKinds({TokenKind::RIGHT_SQUARE_BRACKET}, true, true)) {
+            markError(TokenKind::RIGHT_SQUARE_BRACKET, {});
+            return nullptr;
+        }
+    }
+
+    // assignment requires left arrow, otherwise abort
+    if (!tryMatchingTokenKinds({TokenKind::LEFT_ARROW}, true, true)) {
+        currentIndex = startIndex;
+        return nullptr;
+    }
 
     shared_ptr<Expression> expression = nextExpression();
     if (expression == nullptr)
         return nullptr;
 
-    return make_shared<StatementAssignment>(identifierToken->getLexme(), expression);
+    return make_shared<StatementAssignment>(identifierToken->getLexme(), indexExpression, expression);
 }
 
 shared_ptr<Statement> Parser::matchStatementReturn() {

src/Parser/Statement/StatementAssignment.cpp

@@ -1,12 +1,16 @@
 #include "StatementAssignment.h"
 
-StatementAssignment::StatementAssignment(string name, shared_ptr<Expression> expression):
-Statement(StatementKind::ASSIGNMENT), name(name), expression(expression) { }
+StatementAssignment::StatementAssignment(string name, shared_ptr<Expression> indexExpression, shared_ptr<Expression> expression):
+Statement(StatementKind::ASSIGNMENT), name(name), indexExpression(indexExpression), expression(expression) { }
 
 string StatementAssignment::getName() {
     return name;
 }
 
+shared_ptr<Expression> StatementAssignment::getIndexExpression() {
+    return indexExpression;
+}
+
 shared_ptr<Expression> StatementAssignment::getExpression() {
     return expression;
 }

src/Parser/Statement/StatementAssignment.h

@@ -5,10 +5,12 @@ class Expression;
 class StatementAssignment: public Statement {
 private:
     string name;
+    shared_ptr<Expression> indexExpression;
     shared_ptr<Expression> expression;
 
 public:
-    StatementAssignment(string name, shared_ptr<Expression> expression);
+    StatementAssignment(string name, shared_ptr<Expression> indexExpressio, shared_ptr<Expression> expression);
     string getName();
+    shared_ptr<Expression> getIndexExpression();
     shared_ptr<Expression> getExpression();
 };