Allow the calling of methods on attributes

Author: robertDurst

examples/stack.fish

@@ -64,10 +64,7 @@ Cfn Stack {
         if | own...is_empty() == true | {
             // do nothing
         } else {
-            // super hacky way of accessing methods on attributes
-            dec Node temp = new Node { next: void, data: 0 }
-            temp = own.head
-            i = temp...data()            
+            i = own.head...data()            
         }
 
         return i

examples/test.fish

@@ -0,0 +1,30 @@
+Cat Foo {
+    int i
+    Foo f
+}
+
+Cfn Foo {
+    fun get_i
+    <- void
+    -> int
+    {
+        return own.i
+    }
+
+    fun bar
+    <- void
+    -> int
+    {
+        dec int i = 10
+        i = own.f...get_i()
+        return i
+    }
+}
+
+start {
+    dec Foo f = new Foo { i: 1, f: void }
+    dec Foo b = new Foo { i: 20, f: f }
+    
+    display_int(b...bar())
+    display_str("\n")
+}

out.c

@@ -71,9 +71,7 @@ peek(Stack* own)
 }
 else 
 {
-    Node*temp = construct_Node(NULL,0);
-    temp = own->head;
-    i = data(temp);
+    i = data(own->head);
 }
 
     return i;
@@ -143,9 +141,6 @@ main()
     print_str("\n");
     pop(s);
     pop(s);
-    pop(s);
-    pop(s);
-    pop(s);
     print_str("Size: ");
     print_int(size(s));
     print_str("\tTop: ");

src/ast/Ast.h

@@ -6,6 +6,7 @@
 
 #include "Assignment.h"
 #include "AttributeAccess.h"
+#include "AttributeMethodAccess.h"
 #include "BinaryCompOrArith.h"
 #include "BinaryExpression.h"
 #include "Block.h"

src/ast/AttributeMethodAccess.h

@@ -0,0 +1,67 @@
+/*
+ * Robert Durst 2019
+ * Sailfish Programming Language
+ */
+#pragma once
+#include "Ast.h"
+#include "AttributeAccess.h"
+#include "FunctionCall.h"
+#include "Node.h"
+#include "Primary.h"
+
+namespace ast
+{
+class AttributeMethodAccess : public Primary, public Node
+{
+  private:
+    Identifier* name;
+    AttributeAccess* attribute;
+    FunctionCall* func;
+    Identifier* udt;
+
+  public:
+    // constructor
+    AttributeMethodAccess(Identifier* n, AttributeAccess* a, FunctionCall* f,
+                          Identifier* u, int lineNum)
+        : Node(lineNum)
+    {
+        name = n;
+        attribute = a;
+        func = f;
+        udt = u;
+    };
+    // destructor
+    ~AttributeMethodAccess()
+    {
+        delete name;
+        delete func;
+    };
+    // implement Primary
+    /* virtual */ PrimaryType
+    getPrimaryType()
+    {
+        return Primary::AttributeMethodAccessLiteral;
+    }
+    // get method
+    Identifier*
+    getName()
+    {
+        return name;
+    }
+    AttributeAccess*
+    getAttribute()
+    {
+        return attribute;
+    }
+    FunctionCall*
+    getFunctionCall()
+    {
+        return func;
+    }
+    Identifier*
+    getUDT()
+    {
+        return udt;
+    }
+};
+}

src/ast/Primary.h

@@ -17,6 +17,7 @@ class Primary
         IntegerLiteral,
         FloatLiteral,
         AttributeAccessLiteral,
+        AttributeMethodAccessLiteral,
         MethodAccessLiteral,
         FunctionCallLiteral,
     };

src/parser/Parser.cpp

@@ -547,8 +547,9 @@ Parser::parseGroupingExpression()
 
 /**
  * AttributeAccess := Identifier '.' Identifier
+ * AttributeMethodAccess := AttributeAccess '...' FunctionCall
  */
-ast::AttributeAccess*
+ast::Primary*
 Parser::parseAttributeAccess(ast::Identifier* udtName)
 {
     ast::Identifier* name = new ast::Identifier(currentToken->getValue(),
@@ -557,7 +558,57 @@ Parser::parseAttributeAccess(ast::Identifier* udtName)
     // consume identifier
     getNextUsefulToken();
 
-    return new ast::AttributeAccess(name, udtName, currentToken->getLineNum());
+    ast::AttributeAccess* aa =
+        new ast::AttributeAccess(name, udtName, currentToken->getLineNum());
+
+    // catch the AttributeMethodAccess
+    if (currentToken->getKind() == Kind::TRIPLE_DOT_TOKEN)
+    {
+        // consume '...'
+        getNextUsefulToken();
+
+        return (ast::Primary*)parseAttributeMethodAccess(aa);
+    }
+
+    return (ast::Primary*)aa;
+}
+
+/**
+ * MethodAccess := Identifier '...' Identifier FunctionCall
+ */
+ast::AttributeMethodAccess*
+Parser::parseAttributeMethodAccess(ast::AttributeAccess* aa)
+{
+    ast::Identifier* name = new ast::Identifier(currentToken->getValue(),
+                                                currentToken->getLineNum());
+
+    // consume identifier
+    getNextUsefulToken();
+
+    // consume '('
+    getNextUsefulToken();
+
+    std::vector<ast::Primary*> idents;
+
+    while (currentToken->getKind() != Kind::RPAREN_TOKEN)
+    {
+        idents.push_back(parsePrimary());
+
+        if (currentToken->isEOF())
+        {
+            errorHandler->handle(new Error(currentToken->getLineNum(),
+                                           "Missing a right parenthesis."));
+        }
+    }
+
+    // consume ')'
+    getNextUsefulToken();
+
+    ast::FunctionCall* fc =
+        new ast::FunctionCall(name, idents, currentToken->getLineNum());
+
+    return new ast::AttributeMethodAccess(name, aa, fc, aa->getUDT(),
+                                          currentToken->getLineNum());
 }
 
 /**

src/parser/Parser.h

@@ -49,7 +49,9 @@ class Parser
 
     ast::GroupingExpression* parseGroupingExpression();
 
-    ast::AttributeAccess* parseAttributeAccess(ast::Identifier*);
+    ast::Primary* parseAttributeAccess(ast::Identifier*);
+    ast::AttributeMethodAccess*
+    parseAttributeMethodAccess(ast::AttributeAccess*);
     ast::MethodAccess* parseMethodAccess(ast::Identifier*);
 
     ast::UnaryExpression* parseUnaryExpression();

src/semantics/TypeChecker.cpp

@@ -255,6 +255,84 @@ TypeChecker::getType(ast::Primary* primary)
 
         return truncateType(fullAttributeType);
     }
+    case ast::Primary::AttributeMethodAccessLiteral:
+    {
+        ast::AttributeMethodAccess* node =
+            dynamic_cast<ast::AttributeMethodAccess*>(primary);
+
+        // -------       first extract the attribute       ------- //
+        ast::AttributeAccess* subsubnode = node->getAttribute();
+
+        std::string attributeName = subsubnode->getAttribute()->getValue();
+        std::string variableName = subsubnode->getUDT()->getValue();
+
+        // hacks: REMOVE ASAP
+        if (variableName == "own")
+        {
+            variableName = curUDT;
+        }
+        else
+        {
+            // ensure variable exists - double checked so no need for another
+            // error message
+            if (!symbolTable->hasVariable(variableName))
+            {
+                return "unknown";
+            }
+
+            std::string udtTypeFull = symbolTable->getSymbolType(variableName);
+            variableName = udtTypeFull.substr(1, udtTypeFull.length());
+        }
+
+        // ensure udt exists - double checked so no need for another
+        // error message
+        if (!udtTable->hasUDT(variableName))
+        {
+            return "unknown";
+        }
+
+        // ensure attribute exists for udt - double checked so only return error
+        // once
+        if (!udtTable->getAttributeSymbolTable(variableName)
+                 ->hasVariable(attributeName))
+        {
+            return "unknown";
+        }
+
+        // std::string fullAttributeType =
+        //     udtTable->getAttributeSymbolTable(variableName)
+        //         ->getSymbolType(attributeName);
+
+        // -------       now extract the method       ------- //
+        std::string methodName = node->getName()->getValue();
+        std::string variableUDTname = getType(node->getAttribute());
+
+        // hacks: REMOVE ASAP
+        if (variableUDTname == "own")
+        {
+            variableUDTname = curUDT;
+        }
+        else
+        {
+            // ensure variable's udt exists - double checked so no need for
+            // another error message
+            if (!udtTable->hasUDT(variableUDTname))
+            {
+                return "unknown";
+            }
+        }
+
+        // ensure metho exists for udt - double checked so no need for another
+        // error message
+        if (!udtTable->getMethodSymbolTable(variableUDTname)
+                 ->hasVariable(methodName))
+        {
+            return "unknown";
+        }
+
+        return truncateType(udtTable->getMethodSymbolTable(variableUDTname)
+                                ->getSymbolType(methodName));
+    }
     case ast::Primary::MethodAccessLiteral:
     {
         ast::MethodAccess* node = dynamic_cast<ast::MethodAccess*>(primary);
@@ -1069,6 +1147,63 @@ TypeChecker::visit(ast::AttributeAccess* node)
     }
 }
 
+void
+TypeChecker::visit(ast::AttributeMethodAccess* node)
+{
+    visit(node->getAttribute());
+
+    std::string methodName = node->getName()->getValue();
+    std::string variableUDTname = getType(node->getAttribute());
+
+    std::cout << "HERE: " << variableUDTname << "\n";
+
+    // hacks: REMOVE ASAP
+    if (variableUDTname == "own")
+        variableUDTname = curUDT;
+
+    else
+    {
+        // ensure variable's udt exists
+        if (!udtTable->hasUDT(variableUDTname))
+        {
+            semanticErrorHandler->handle(new Error(
+                node->getUDT()->getLineNum(),
+                "Method: " + methodName + " called on nonexistent udt type: " +
+                    variableUDTname + "."));
+
+            return;
+        }
+    }
+
+    std::string udtType = variableUDTname;
+
+    // ensure metho exists for udt
+    if (!udtTable->getMethodSymbolTable(udtType)->hasVariable(methodName))
+    {
+        semanticErrorHandler->handle(
+            new Error(node->getName()->getLineNum(),
+                      "Method: " + methodName +
+                          " does not exist for udt type: " + udtType + "."));
+        // abort
+        return;
+    }
+
+    // visit function call
+    std::string fulltype =
+        udtTable->getMethodSymbolTable(udtType)->getSymbolType(methodName);
+
+    std::vector<std::string> inputs = getFunctionParamTypes(fulltype);
+
+    // ensure that each of the arguments is supplied and of the proper type
+    std::vector<ast::Primary*> args = node->getFunctionCall()->getArguments();
+
+    compareFunctions(inputs, args, methodName,
+                     node->getFunctionCall()->getLineNum());
+
+    for (auto const& arg : args)
+        visit(arg);
+}
+
 void
 TypeChecker::visit(ast::MethodAccess* node)
 {

src/semantics/TypeChecker.h

@@ -96,6 +96,7 @@ class TypeChecker : public Visitor
 
     // udt attribute and method access
     void visit(ast::AttributeAccess*);
+    void visit(ast::AttributeMethodAccess*);
     void visit(ast::MethodAccess*);
 
     // function call