Use parsee results

src/Parser/Parsee/Parsee.cpp

@@ -10,9 +10,9 @@ Parsee Parsee::tokenParsee(TokenKind tokenKind, bool isRequired, bool shouldRetu
     return parsee;
 }
 
-Parsee Parsee::typeParsee() {
+Parsee Parsee::valueTypeParsee() {
-    Parsee  parsee;
+    Parsee parsee;
-    parsee.kind = ParseeKind::TYPE;
+    parsee.kind = ParseeKind::VALUE_TYPE;
 
     return parsee;
 }

src/Parser/Parsee/Parsee.h

@@ -5,7 +5,7 @@ enum class TokenKind;
 
 enum class ParseeKind {
     TOKEN,
-    TYPE
+    VALUE_TYPE
 };
 
 class Parsee {
@@ -14,15 +14,13 @@ private:
     TokenKind tokenKind;
     bool isRequired;
     bool shouldReturn;
-    
     Parsee();
 
 public:
     static Parsee tokenParsee(TokenKind tokenKind, bool isRequired, bool shouldReturn);
-    static Parsee typeParsee();
+    static Parsee valueTypeParsee();
 
     ParseeKind getKind();
-
     TokenKind getTokenKind();
     bool getIsRequired();
     bool getShouldReturn();

src/Parser/Parsee/ParseeResult.cpp

@@ -0,0 +1,33 @@
+#include "ParseeResult.h"
+
+#include "Lexer/Token.h"
+#include "Parser/ValueType.h"
+
+ParseeResult ParseeResult::tokenResult(shared_ptr<Token> token) {
+    ParseeResult parseeResult;
+    parseeResult.kind = ParseeResultKind::TOKEN;
+    parseeResult.token = token;
+    return parseeResult;
+}
+
+ParseeResult ParseeResult::valueTypeResult(shared_ptr<ValueType> valueType) {
+    ParseeResult parseeResult;
+    parseeResult.kind = ParseeResultKind::VALUE_TYPE;
+    parseeResult.valueType = valueType;
+    return parseeResult;    
+}
+
+ParseeResult::ParseeResult() { }
+
+
+ParseeResultKind ParseeResult::getKind() {
+    return kind;
+}
+
+shared_ptr<Token> ParseeResult::getToken() {
+    return token;
+}
+
+shared_ptr<ValueType> ParseeResult::getValueType() {
+    return valueType;
+}

src/Parser/Parsee/ParseeResult.h

@@ -0,0 +1,32 @@
+#ifndef PARSEE_RESULT_H
+#define PARSEE_RESULT_H
+
+#include <memory>
+
+class Token;
+class ValueType;
+
+using namespace std;
+
+enum class ParseeResultKind {
+    TOKEN,
+    VALUE_TYPE,
+};
+
+class ParseeResult {
+private:
+    ParseeResultKind kind;
+    shared_ptr<Token> token;
+    shared_ptr<ValueType> valueType;
+    ParseeResult();
+
+public:
+    static ParseeResult tokenResult(shared_ptr<Token> token);
+    static ParseeResult valueTypeResult(shared_ptr<ValueType> valueType);
+
+    ParseeResultKind getKind();
+    shared_ptr<Token> getToken();
+    shared_ptr<ValueType> getValueType();
+};
+
+#endif

src/Parser/Parser.cpp

@@ -27,6 +27,7 @@
 
 #include "Parsee/Parsee.h"
 #include "Parsee/ParseeGroup.h"
+#include "Parsee/ParseeResult.h"
 
 Parser::Parser(vector<shared_ptr<Token>> tokens) :
 tokens(tokens) { }
@@ -240,7 +241,7 @@ shared_ptr<Statement> Parser::matchStatementFunction() {
 
 shared_ptr<Statement> Parser::matchStatementRawFunction() {
     bool hasError = false;
-    optional<vector<shared_ptr<Token>>> groupTokens;
+    optional<vector<ParseeResult>> parseeResults;
 
     string name;
     string constraints;
@@ -248,7 +249,7 @@ shared_ptr<Statement> Parser::matchStatementRawFunction() {
     shared_ptr<ValueType> returnType = ValueType::NONE;
 
     // identifier
-    groupTokens = tokensForParseeGroup(
+    parseeResults = parseeResultsForParseeGroup(
         ParseeGroup(
             true,
             {
@@ -258,15 +259,15 @@ shared_ptr<Statement> Parser::matchStatementRawFunction() {
             {}
         )
     );
-    if (groupTokens) {
+    if (parseeResults) {
-        name = (*groupTokens).at(0)->getLexme();
+        name = (*parseeResults).at(0).getToken()->getLexme();
     } else {
         hasError = true;
     }
 
     // options
     if (!hasError) {
-        groupTokens = tokensForParseeGroup(
+        parseeResults = parseeResultsForParseeGroup(
             ParseeGroup(
                 false,
                 {
@@ -277,23 +278,23 @@ shared_ptr<Statement> Parser::matchStatementRawFunction() {
                 {}
             )
         );
-        if (groupTokens && !(*groupTokens).empty()) {
+        if (parseeResults && !(*parseeResults).empty()) {
-            constraints = (*groupTokens).at(0)->getLexme();
+            constraints = (*parseeResults).at(0).getToken()->getLexme();
-        } else if (!groupTokens) {
+        } else if (!parseeResults) {
             hasError = true;
         }
     }
 
     // arguments
     if (!hasError) {
-        groupTokens = tokensForParseeGroup(
+        parseeResults = parseeResultsForParseeGroup(
             ParseeGroup(
                 false,
                 {
                     Parsee::tokenParsee(TokenKind::COLON, true, false),
                     Parsee::tokenParsee(TokenKind::NEW_LINE, false, false),
                     Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true),
-                    Parsee::typeParsee()
+                    Parsee::valueTypeParsee()
                 },
                 ParseeGroup(
                     true,
@@ -301,36 +302,41 @@ shared_ptr<Statement> Parser::matchStatementRawFunction() {
                         Parsee::tokenParsee(TokenKind::COMMA, true, false),
                         Parsee::tokenParsee(TokenKind::NEW_LINE, false, false),
                         Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true),
-                        Parsee::typeParsee()
+                        Parsee::valueTypeParsee()
                     },
                     {}
                 )
             )
         );
-        if (groupTokens && !(*groupTokens).empty()) {
+        if (parseeResults && !(*parseeResults).empty()) {
-
+            for (int i=0; i<(*parseeResults).size(); i+=2) {
-        } else if (!groupTokens) {
+                pair<string, shared_ptr<ValueType>> arg;
+                arg.first = (*parseeResults).at(i).getToken()->getLexme();
+                arg.second = (*parseeResults).at(i+1).getValueType();
+                arguments.push_back(arg);
+            }
+        } else if (!parseeResults) {
             hasError = true;
         }
     }
 
     // return type 
     if (!hasError) {
-        groupTokens = tokensForParseeGroup(
+        parseeResults = parseeResultsForParseeGroup(
             ParseeGroup(
                 false,
                 {
                     Parsee::tokenParsee(TokenKind::RIGHT_ARROW, true, false),
                     Parsee::tokenParsee(TokenKind::NEW_LINE, false, false),
-                    Parsee::typeParsee()
+                    Parsee::valueTypeParsee()
                 },
                 {}
             )
         );
 
-        if (groupTokens && !(*groupTokens).empty()) {
+        if (parseeResults && !(*parseeResults).empty()) {
-
+            returnType = (*parseeResults).at(0).getValueType();
-        } else if (!groupTokens) {
+        } else if (!parseeResults) {
             hasError = true;
         }
     }
@@ -872,9 +878,9 @@ shared_ptr<ValueType> Parser::matchValueType() {
     return ValueType::valueTypeForToken(typeToken, subType, valueArg);
 }
 
-optional<vector<shared_ptr<Token>>> Parser::tokensForParseeGroup(ParseeGroup group) {
+optional<vector<ParseeResult>> Parser::parseeResultsForParseeGroup(ParseeGroup group) {
     int nextIndex = currentIndex;
-    vector<shared_ptr<Token>> returnTokens;
+    vector<ParseeResult> results;
     bool mustFulfill = false;
 
     for (Parsee &parsee : group.getParsees()) {
@@ -883,11 +889,11 @@ optional<vector<shared_ptr<Token>>> Parser::tokensForParseeGroup(ParseeGroup gro
 
         // if doesn't match on optional group
         if (!matches && parsee.getIsRequired() && !group.getIsRequired() && mustFulfill)
-            return vector<shared_ptr<Token>>();
+            return vector<ParseeResult>();
 
         // return matching token?
         if (matches && parsee.getShouldReturn())
-            returnTokens.push_back(currentToken);
+            results.push_back(ParseeResult::tokenResult(currentToken));
 
         // decide if we're decoding the expected sequence
         if (!parsee.getIsRequired() && nextIndex > currentIndex)
@@ -907,7 +913,7 @@ optional<vector<shared_ptr<Token>>> Parser::tokensForParseeGroup(ParseeGroup gro
 
     currentIndex = nextIndex;
 
-    return returnTokens;
+    return results;
 }
 
 bool Parser::tryMatchingTokenKinds(vector<TokenKind> kinds, bool shouldMatchAll, bool shouldAdvance) {

src/Parser/Parser.h

@@ -13,6 +13,7 @@ class Expression;
 class Statement;
 
 class ParseeGroup;
+class ParseeResult;
 
 using namespace std;
 
@@ -54,7 +55,7 @@ private:
 
     shared_ptr<ValueType> matchValueType();
 
-    optional<vector<shared_ptr<Token>>> tokensForParseeGroup(ParseeGroup group);
+    optional<vector<ParseeResult>> parseeResultsForParseeGroup(ParseeGroup group);
     bool tryMatchingTokenKinds(vector<TokenKind> kinds, bool shouldMatchAll, bool shouldAdvance);
 
     void markError(optional<TokenKind> expectedTokenKind, optional<string> message);