Implemented value assignment

src/Parser/Parser.cpp

@@ -11,6 +11,7 @@
 
 #include "Parser/Statement/StatementFunction.h"
 #include "Parser/Statement/StatementVariable.h"
+#include "Parser/Statement/StatementAssignment.h"
 #include "Parser/Statement/StatementReturn.h"
 #include "Parser/Statement/StatementExpression.h"
 #include "Parser/Statement/StatementMetaExternFunction.h"
@@ -51,6 +52,10 @@ shared_ptr<Statement> Parser::nextStatement() {
     if (statement != nullptr)
         return statement;
 
+    statement = matchStatementAssignment();
+    if (statement != nullptr)
+        return statement;
+
     statement = matchStatementReturn();
     if (statement != nullptr)
         return statement;
@@ -163,6 +168,25 @@ shared_ptr<Statement> Parser::matchStatementVariable() {
     return make_shared<StatementVariable>(identifierToken->getLexme(), valueType, expression);
 }
 
+shared_ptr<Statement> Parser::matchStatementAssignment() {
+    if (!tryMatchingTokenKinds({TokenKind::IDENTIFIER, TokenKind::LEFT_ARROW}, true, false))
+        return nullptr;
+     
+    shared_ptr<Token> identifierToken = tokens.at(currentIndex);
+    currentIndex++; // identifier
+    currentIndex++; // arrow
+
+    shared_ptr<Expression> expression = nextExpression();
+    if (expression == nullptr || !expression->isValid())
+        return matchStatementInvalid("Expected expression");
+
+    // Expect new line
+    if (!tryMatchingTokenKinds({TokenKind::NEW_LINE}, false, true))
+        return matchStatementInvalid("Expected a new line after variable declaration");
+
+    return make_shared<StatementAssignment>(identifierToken->getLexme(), expression);
+}
+
 shared_ptr<Statement> Parser::matchStatementReturn() {
     if (!tryMatchingTokenKinds({TokenKind::RETURN}, true, true))
         return nullptr;
@@ -396,14 +420,14 @@ shared_ptr<Expression> Parser::matchPrimary() {
     if (expression != nullptr)
         return expression;
 
-    expression = matchExpressionVariable();
-    if (expression != nullptr)
-    return expression;
-        
     expression = matchExpressionCall();
     if (expression != nullptr)
         return expression;
 
+    expression = matchExpressionVariable();
+    if (expression != nullptr)
+    return expression;
+
     return nullptr;
 }
 

src/Parser/Parser.h

@@ -21,6 +21,7 @@ private:
     shared_ptr<Statement> nextStatement();
     shared_ptr<Statement> matchStatementFunction();
     shared_ptr<Statement> matchStatementVariable();
+    shared_ptr<Statement> matchStatementAssignment();
     shared_ptr<Statement> matchStatementReturn();
     shared_ptr<Statement> matchStatementLoop();
     shared_ptr<Statement> matchStatementExpression();

src/Parser/Statement/Statement.h

@@ -13,6 +13,7 @@ enum class StatementKind {
     RETURN,
     FUNCTION,
     VARIABLE,
+    ASSIGNMENT,
     LOOP,
     META_EXTERN_FUNCTION,
     INVALID

src/Parser/Statement/StatementAssignment.cpp

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

src/Parser/Statement/StatementAssignment.h

@@ -0,0 +1,14 @@
+#include "Parser/Statement/Statement.h"
+
+class Expression;
+
+class StatementAssignment: public Statement {
+private:
+    string name;
+    shared_ptr<Expression> expression;
+
+public:
+    StatementAssignment(string name, shared_ptr<Expression> expression);
+    string getName();
+    shared_ptr<Expression> getExpression();
+};