Parser - Handle methods correctly

3 files changed, 42 insertions, 10 deletions

diff --git a/src/ast/ast.cpp b/src/ast/ast.cpp
index 438aa2cd..fe6f2add 100644
--- a/src/ast/ast.cpp
+++ b/src/ast/ast.cpp
@@ -220,6 +220,10 @@ void ExprNode_CallPath::visit(NodeVisitor& nv) {
     nv.visit(*this);

 }

 

+void ExprNode_CallMethod::visit(NodeVisitor& nv) {

+    nv.visit(*this);

+}

+

 void ExprNode_CallObject::visit(NodeVisitor& nv) {

     nv.visit(*this);

 }

diff --git a/src/ast/ast_expr.hpp b/src/ast/ast_expr.hpp
index 1b0a876d..9b659bfd 100644
--- a/src/ast/ast_expr.hpp
+++ b/src/ast/ast_expr.hpp
@@ -97,6 +97,22 @@ struct ExprNode_CallPath:
     
     virtual void visit(NodeVisitor& nv) override;
 };
+struct ExprNode_CallMethod:
+    public ExprNode
+{
+    unique_ptr<ExprNode>    m_val;
+    PathNode    m_method;
+    ::std::vector<unique_ptr<ExprNode>> m_args;
+
+    ExprNode_CallMethod(unique_ptr<ExprNode>&& obj, PathNode&& method, ::std::vector<unique_ptr<ExprNode>>&& args):
+        m_val( move(obj) ),
+        m_method( move(method) ),
+        m_args( move(args) )
+    {
+    }
+    
+    virtual void visit(NodeVisitor& nv) override;
+};
 // Call an object (Fn/FnMut/FnOnce)
 struct ExprNode_CallObject:
     public ExprNode
@@ -272,6 +288,11 @@ public:
         for( auto& arg : node.m_args )
             visit(arg);
     }
+    virtual void visit(ExprNode_CallMethod& node) {
+        visit(node.m_val);
+        for( auto& arg : node.m_args )
+            visit(arg);
+    }
     virtual void visit(ExprNode_CallObject& node) {
         visit(node.m_val);
         for( auto& arg : node.m_args )
diff --git a/src/parse/expr.cpp b/src/parse/expr.cpp
index 478673e3..fa9d43e9 100644
--- a/src/parse/expr.cpp
+++ b/src/parse/expr.cpp
@@ -406,18 +406,25 @@ ExprNodeP Parse_ExprFC(TokenStream& lex)
             lex.putback(tok);

             val = NEWNODE( AST::ExprNode_CallObject, ::std::move(val), Parse_ParenList(lex) );

             break;

-        case TOK_DOT:

-            // Field access

+        case TOK_DOT: {

+            // Field access / method call

             // TODO: What about tuple indexing?

             GET_CHECK_TOK(tok, lex, TOK_IDENT);

-            val = NEWNODE( AST::ExprNode_Field, ::std::move(val), ::std::string(tok.str()) );

-            //if( GET_TOK(tok, lex) == TOK_PAREN_OPEN || tok.type() == TOK_DOUBLE_COLON ) {

-            //    throw ParseError::Todo("method calls");

-            //}

-            //else {

-            //    lex.putback(tok);

-            //}

-            break;

+            ::std::string name = tok.str();

+            switch( GET_TOK(tok, lex) )

+            {

+            case TOK_PAREN_OPEN:

+                lex.putback(tok);

+                val = NEWNODE( AST::ExprNode_CallMethod, ::std::move(val), AST::PathNode(name, {}), Parse_ParenList(lex) );

+                break;

+            case TOK_DOUBLE_COLON:

+                throw ParseError::Todo("method calls - generic");

+            default:

+                val = NEWNODE( AST::ExprNode_Field, ::std::move(val), ::std::string(name) );

+                lex.putback(tok);

+                break;

+            }

+            break; }

         default:

             lex.putback(tok);

             return val;