Converted assignment

src/Parser/Parser.cpp

@@ -207,7 +207,6 @@ shared_ptr<Statement> Parser::matchStatementFunction() {
             break;
         case ParseeResultsGroupKind::NO_MATCH:
             return nullptr;
-            break;
         case ParseeResultsGroupKind::FAILURE:
             hasError = true;
             break;
@@ -465,58 +464,87 @@ shared_ptr<Statement> Parser::matchStatementBlock(vector<TokenKind> terminalToke
 }
 
 shared_ptr<Statement> Parser::matchStatementAssignment() {
-    int startIndex = currentIndex;
+    ParseeResultsGroup resultsGroup;
 
-    if (!tryMatchingTokenKinds({TokenKind::IDENTIFIER}, true, false))
+    string identifier;
-        return nullptr;
-    shared_ptr<Token> identifierToken = tokens.at(currentIndex++);
     shared_ptr<Expression> indexExpression;
+    shared_ptr<Expression> expression;
 
-    if (tryMatchingTokenKinds({TokenKind::LEFT_SQUARE_BRACKET}, true, true)) {
+    // identifier
-        indexExpression = nextExpression();
+    resultsGroup = parseeResultsGroupForParseeGroup(
-        if (indexExpression == nullptr)
+        ParseeGroup(
+            {
+                Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true),
+            },
+            {}
+        )
+    );
+
+    if (resultsGroup.getKind() != ParseeResultsGroupKind::SUCCESS)
         return nullptr;
 
-        if (!tryMatchingTokenKinds({TokenKind::RIGHT_SQUARE_BRACKET}, true, true)) {
+    identifier = resultsGroup.getResults().at(0).getToken()->getLexme();
-            markError(TokenKind::RIGHT_SQUARE_BRACKET, {});
-            return nullptr;
-        }
-    }
 
-    // assignment requires left arrow, otherwise abort
+    // index expression
-    if (!tryMatchingTokenKinds({TokenKind::LEFT_ARROW}, true, true)) {
+    resultsGroup = parseeResultsGroupForParseeGroup(
-        currentIndex = startIndex;
+        ParseeGroup(
+            {
+                Parsee::tokenParsee(TokenKind::LEFT_SQUARE_BRACKET, true, false),
+                Parsee::expressionParsee(true),
+                Parsee::tokenParsee(TokenKind::RIGHT_SQUARE_BRACKET, true, false),
+            },
+            {}
+        )
+    );
+
+    switch (resultsGroup.getKind()) {
+        case ParseeResultsGroupKind::SUCCESS:
+            indexExpression = resultsGroup.getResults().at(0).getExpression();
+            break;
+        case ParseeResultsGroupKind::NO_MATCH:
+            break;
+        case ParseeResultsGroupKind::FAILURE:
             return nullptr;
     }
 
-    shared_ptr<Expression> expression = nextExpression();
+    // expression
-    if (expression == nullptr)
+    resultsGroup = parseeResultsGroupForParseeGroup(
-        return nullptr;
+        ParseeGroup(
+            {
+                Parsee::tokenParsee(TokenKind::LEFT_ARROW, true, false),
+                Parsee::expressionParsee(true)
+            },
+            {}
+        )
+    );
 
-    return make_shared<StatementAssignment>(identifierToken->getLexme(), indexExpression, expression);
+    switch (resultsGroup.getKind()) {
+        case ParseeResultsGroupKind::SUCCESS:
+            expression = resultsGroup.getResults().at(0).getExpression();
+            break;
+        case ParseeResultsGroupKind::NO_MATCH:
+        case ParseeResultsGroupKind::FAILURE:
+            return nullptr;
+    }
+
+    return make_shared<StatementAssignment>(identifier, indexExpression, expression);
 }
 
 shared_ptr<Statement> Parser::matchStatementReturn() {
-    shared_ptr<Expression> expression;
-
     ParseeResultsGroup resultsGroup = parseeResultsGroupForParseeGroup(
         ParseeGroup(
             {
                 Parsee::tokenParsee(TokenKind::RETURN, true, false),
                 Parsee::expressionParsee(false)
             },
-            { }
+            {}
         )
     );
 
-    switch (resultsGroup.getKind()) {
+    if (resultsGroup.getKind() != ParseeResultsGroupKind::SUCCESS)
-        case ParseeResultsGroupKind::SUCCESS:
-            expression = !resultsGroup.getResults().empty() ? resultsGroup.getResults().at(0).getExpression() : nullptr;
-            break;
-        case ParseeResultsGroupKind::NO_MATCH:
-        case ParseeResultsGroupKind::FAILURE:
         return nullptr;
-    }
+
+    shared_ptr<Expression> expression = !resultsGroup.getResults().empty() ? resultsGroup.getResults().at(0).getExpression() : nullptr;
 
     return make_shared<StatementReturn>(expression);
 }