4 files changed, 237 insertions, 374 deletions

diff --git a/MoonParser/ast.hpp b/MoonParser/ast.hpp
index e7ae74f..1077f5d 100644
--- a/MoonParser/ast.hpp
+++ b/MoonParser/ast.hpp
@@ -25,8 +25,7 @@ typedef std::vector<ast_node*> ast_stack;
 extern int ast_type_id;
 
 template<class T>
-int ast_type()
-{
+int ast_type() {
         static int type = ast_type_id++;
         return type;
 }
@@ -211,7 +210,7 @@ public:
 
         template <class T>
         T* to() const {
-                assert(m_ptr->getId() == ast_type<T>());
+                assert(m_ptr->getId() != ast_type<T>());
                 return static_cast<T*>(m_ptr);
         }
 
@@ -313,13 +312,13 @@ inline ast_ptr<T, false, false> new_ptr() {
         return ast_ptr<T, false, false>(new T);
 }
 
-template <class ...Args> class ast_choice : public _ast_ptr {
+template <class ...Args> class ast_sel : public _ast_ptr {
 public:
-    ast_choice() : _ast_ptr(nullptr, true) {}
+    ast_sel() : _ast_ptr(nullptr, true) {}
 
-    ast_choice(const ast_choice<Args...>& other) : _ast_ptr(other.get(), true) {}
+    ast_sel(const ast_sel<Args...>& other) : _ast_ptr(other.get(), true) {}
 
-    ast_choice<Args...>& operator=(const ast_choice<Args...>& other) {
+    ast_sel<Args...>& operator=(const ast_sel<Args...>& other) {
         set(other.get());
         return *this;
         }
@@ -340,7 +339,7 @@ public:
 
         ast_node* node = st.back();
 
-        if (!ast_choice::accept(node)) throw std::logic_error("invalid AST node");
+        if (!ast_sel::accept(node)) throw std::logic_error("invalid AST node");
 
         st.pop_back();
 
@@ -351,7 +350,7 @@ private:
     virtual bool accept(ast_node* node) override {
         if (!node) return false;
                 using swallow = bool[];
-                bool* result = nullptr;
+                bool result = false;
                 (void)swallow{result || (result = ast_type<Args>() == node->get_type())...};
                 return result;
         }
@@ -449,6 +448,49 @@ private:
         }
 };
 
+template <class ...Args> class ast_sel_list : public _ast_list {
+public:
+    ///the default constructor.
+    ast_sel_list() {}
+
+    ast_sel_list(const ast_sel_list<Args...>& other) {
+        clear();
+        dup(other);
+        }
+
+    ast_sel_list<Args...>& operator=(const ast_sel_list<Args...>& other) {
+        clear();
+        dup(other);
+        return *this;
+        }
+
+    /** Pops objects of type T from the stack until no more objects can be popped.
+        @param st stack.
+     */
+    virtual void construct(ast_stack &st) override {
+        while (!st.empty()) {
+            ast_node* node = st.back();
+
+            //if the object was not not of the appropriate type,
+            //end the list parsing
+            if (!ast_sel_list<Args...>::accept(node)) return;
+
+            st.pop_back();
+
+            //insert the object in the list, in reverse order
+            m_objects.push_front(node);
+            node->retain();
+        }
+    }
+private:
+    virtual bool accept(ast_node* node) override {
+        if (!node) return false;
+                using swallow = bool[];
+                bool result = false;
+                (void)swallow{result || (result = ast_type<Args>() == node->get_type())...};
+                return result;
+        }
+};
 
 /** AST function which creates an object of type T
     and pushes it to the node stack.
diff --git a/MoonParser/moon_ast.cpp b/MoonParser/moon_ast.cpp
index af34395..f7dcae6 100644
--- a/MoonParser/moon_ast.cpp
+++ b/MoonParser/moon_ast.cpp
@@ -82,20 +82,11 @@ AST_IMPL(double_string_content)
 AST_IMPL(DoubleString)
 AST_IMPL(String)
 AST_IMPL(Parens)
-AST_IMPL(FnArgs)
-AST_IMPL(chain_call)
-AST_IMPL(chain_item)
 AST_IMPL(DotChainItem)
 AST_IMPL(ColonChainItem)
-AST_IMPL(chain_dot_chain)
-AST_IMPL(ChainItem)
-AST_IMPL(ChainItems)
-AST_IMPL(invoke_chain)
-AST_IMPL(ColonChain)
 AST_IMPL(default_value)
 AST_IMPL(Slice)
 AST_IMPL(Invoke)
-AST_IMPL(TableValue)
 AST_IMPL(TableLit)
 AST_IMPL(TableBlock)
 AST_IMPL(class_member_list)
@@ -107,7 +98,6 @@ AST_IMPL(export_op)
 AST_IMPL(Export)
 AST_IMPL(variable_pair)
 AST_IMPL(normal_pair)
-AST_IMPL(KeyValue)
 AST_IMPL(FnArgDef)
 AST_IMPL(FnArgDefList)
 AST_IMPL(outer_var_shadow)
@@ -116,8 +106,6 @@ AST_IMPL(fn_arrow)
 AST_IMPL(FunLit)
 AST_IMPL(NameOrDestructure)
 AST_IMPL(AssignableNameList)
-AST_IMPL(ArgBlock)
-AST_IMPL(invoke_args_with_table)
 AST_IMPL(InvokeArgs)
 AST_IMPL(const_value)
 AST_IMPL(unary_exp)
@@ -354,7 +342,7 @@ private:
                                 case "DotChainItem"_id:
                                 case "ColonChainItem"_id:
                                 case "Slice"_id:
-                                case "Index"_id:
+                                case "Exp"_id:
                                 case "Callable"_id:
                                 case "String"_id:
                                         return traversal::Stop;
@@ -373,7 +361,7 @@ private:
                                 case "DotChainItem"_id:
                                 case "ColonChainItem"_id:
                                 case "Slice"_id:
-                                case "Index"_id:
+                                case "Exp"_id:
                                 case "Callable"_id:
                                 case "String"_id:
                                         last = node;
@@ -389,24 +377,22 @@ private:
                 }
         }
 
-        std::vector<ast_node*> getChainList(ast_node* chain) {
-                std::vector<ast_node*> list;
-                chain->traverse([&](ast_node* node) {
-                        switch (node->getId()) {
-                                case "Invoke"_id:
-                                case "DotChainItem"_id:
-                                case "ColonChainItem"_id:
-                                case "Slice"_id:
-                                case "Index"_id:
-                                case "Callable"_id:
-                                case "String"_id:
-                                        list.push_back(node);
-                                        return traversal::Return;
-                                default:
-                                        return traversal::Continue;
-                        }
-                });
-                return list;
+        std::vector<ast_node*> getChainList(ChainValue_t* chainValue) {
+                std::vector<ast_node*> temp;
+                switch (chainValue->caller->getId()) {
+                        case "Callable"_id:
+                                temp.push_back(chainValue->caller);
+                                break;
+                        case "Chain"_id:
+                                const auto& items = chainValue->caller.to<Chain_t>()->items.objects();
+                                temp.resize(items.size());
+                                std::copy(items.begin(), items.end(), temp.begin());
+                                break;
+                }
+                if (chainValue->arguments) {
+                        temp.push_back(chainValue->arguments);
+                }
+                return temp;
         }
 
         void transformStatement(Statement_t* statement, std::vector<std::string>& out) {
@@ -1055,99 +1041,64 @@ private:
                 }
         }
 
-        void transformChain(Chain_t* chain, std::vector<std::string>& out) {
-                auto item = chain->item.get();
-                switch (item->getId()) {
-                        case "chain_call"_id: transform_chain_call(static_cast<chain_call_t*>(item), out); break;
-                        case "chain_item"_id: transformChainItems(static_cast<chain_item_t*>(item)->chain, out); break;
-                        case "chain_dot_chain"_id: transform_chain_dot_chain(item, out); break;
-                        case "ColonChain"_id: transformColonChain(static_cast<ColonChain_t*>(item), out); break;
-                        default: break;
-                }
-        }
-
-        void transform_chain_call(chain_call_t* chain_call, std::vector<std::string>& out) {
+        void transformChain(Chain_t* chain, std::vector<std::string>& out, bool argsFollowed = false) {
                 std::vector<std::string> temp;
-                auto caller = chain_call->caller.get();
-                switch (caller->getId()) {
-                        case "Callable"_id: {
-                                transformCallable(static_cast<Callable_t*>(caller), temp, startWithInvoke(chain_call->chain));
-                                break;
-                        }
-                        case "String"_id: transformString(static_cast<String_t*>(caller), temp); break;
-                        default: break;
-                }
-                transformChainItems(chain_call->chain, temp);
-                out.push_back(join(temp));
-        }
+                const auto& chainList = chain->items.objects();
+                if (!argsFollowed && chainList.size() == 2 && chainList.back()->getId() == "ColonChainItem"_id) {
 
-        void transformChainItems(ChainItems_t* chainItems, std::vector<std::string>& out) {
-                std::vector<std::string> temp;
-                for (auto _chainItem : chainItems->simpleChain.objects()) {
-                        auto chainItem = static_cast<ChainItem_t*>(_chainItem);
-                        transformChainItem(chainItem, temp);
                 }
-                if (chainItems->colonChain) {
-                        transformColonChain(chainItems->colonChain, temp);
+                for (auto it = chainList.begin(); it != chainList.end(); ++it) {
+                        auto item = *it;
+                        switch (item->getId()) {
+                                case "Invoke"_id: transformInvoke(static_cast<Invoke_t*>(item), temp); break;
+                                case "DotChainItem"_id: transformDotChainItem(static_cast<DotChainItem_t*>(item), temp); break;
+                                case "ColonChainItem"_id: transformColonChainItem(static_cast<ColonChainItem_t*>(item), temp); break;
+                                case "Slice"_id: transformSlice(static_cast<Slice_t*>(item), temp); break;
+                                case "Callable"_id: {
+                                        auto next = it; ++next;
+                                        auto followItem = next != chainList.end() ? *next : nullptr;
+                                        transformCallable(static_cast<Callable_t*>(item), temp,
+                                                followItem && followItem->getId() == "Invoke"_id);
+                                        break;
+                                }
+                                case "String"_id:
+                                        transformString(static_cast<String_t*>(item), temp);
+                                        temp.back() = s("("sv) + temp.back() + s(")"sv);
+                                        break;
+                                case "Exp"_id:
+                                        transformExp(static_cast<Exp_t*>(item), temp);
+                                        temp.back() = s("["sv) + temp.back() + s("]"sv);
+                                        break;
+                                default: break;
+                        }
                 }
                 out.push_back(join(temp));
         }
 
-        void transformChainItem(ChainItem_t* chainItem, std::vector<std::string>& out) {
-                auto item = chainItem->item.get();
-                switch (item->getId()) {
-                        case "Invoke"_id: transformInvoke(static_cast<Invoke_t*>(item), out); break;
-                        case "DotChainItem"_id:
-                                out.push_back(s("."sv) + toString(item->getFirstChild()));
-                                break;
-                        case "Slice"_id: transformSlice(item, out); break;
-                        case "Exp"_id:
-                                transformExp(static_cast<Exp_t*>(item), out);
-                                out.back() = s("["sv) + out.back() + s("]"sv);
-                                break;
-                        default: break;
-                }
+        void transformDotChainItem(DotChainItem_t* dotChainItem, std::vector<std::string>& out) {
+                out.push_back(s("."sv) + toString(dotChainItem->name));
         }
 
-        void transformInvoke(Invoke_t* invoke, std::vector<std::string>& out) {
-                auto argument = invoke->argument.get();
-                switch (argument->getId()) {
-                        case "FnArgs"_id: transformFnArgs(static_cast<FnArgs_t*>(argument), out); break;
-                        case "SingleString"_id: transformSingleString(static_cast<SingleString_t*>(argument), out); break;
-                        case "DoubleString"_id: transformDoubleString(static_cast<DoubleString_t*>(argument), out); break;
-                        case "LuaString"_id: transformLuaString(static_cast<LuaString_t*>(argument), out); break;
-                        default: break;
-                }
-                out.back() = s("("sv) + out.back() + s(")"sv);
+        void transformColonChainItem(ColonChainItem_t* colonChainItem, std::vector<std::string>& out) {
+                out.push_back(s(colonChainItem->switchToDot ? "."sv : ":"sv) + toString(colonChainItem->name));
         }
 
-        void transformFnArgs(FnArgs_t* fnArgs, std::vector<std::string>& out) {
-                std::vector<std::string> temp;
-                for (auto node : fnArgs->args.objects()) {
-                        transformExp(static_cast<Exp_t*>(node), temp);
-                }
-                std::string args = join(temp, ", "sv);
-                out.push_back(args);
+        void transformSlice(Slice_t* slice, std::vector<std::string>& out) {
+                noop(slice, out);
         }
 
-        void transformColonChain(ColonChain_t* colonChain, std::vector<std::string>& out) {
-                std::vector<std::string> temp;
-                temp.push_back(
-                        s(colonChain->colonChain->switchToDot ? "."sv : ":"sv) +
-                        toString(colonChain->colonChain->name));
-                if (colonChain->invokeChain) {
-                        transform_invoke_chain(colonChain->invokeChain, temp);
-                }
-                out.push_back(join(temp));
-        }
-
-        void transform_invoke_chain(invoke_chain_t* invoke_chain, std::vector<std::string>& out) {
+        void transformInvoke(Invoke_t* invoke, std::vector<std::string>& out) {
                 std::vector<std::string> temp;
-                transformInvoke(invoke_chain->invoke, temp);
-                if (invoke_chain->chain) {
-                        transformChainItems(invoke_chain->chain, temp);
+                for (auto arg : invoke->args.objects()) {
+                        switch (arg->getId()) {
+                                case "Exp"_id: transformExp(static_cast<Exp_t*>(arg), temp); break;
+                                case "SingleString"_id: transformSingleString(static_cast<SingleString_t*>(arg), temp); break;
+                                case "DoubleString"_id: transformDoubleString(static_cast<DoubleString_t*>(arg), temp); break;
+                                case "LuaString"_id: transformLuaString(static_cast<LuaString_t*>(arg), temp); break;
+                                default: break;
+                        }
                 }
-                out.push_back(join(temp));
+                out.push_back(s("("sv) + join(temp, ", "sv) + s(")"sv));
         }
 
         void transform_unary_exp(unary_exp_t* unary_exp, std::vector<std::string>& out) {
@@ -1168,22 +1119,21 @@ private:
         void transformTableLit(TableLit_t* tableLit, std::vector<std::string>& out) {
                 std::vector<std::string> temp;
                 ast_node* lastNode = nullptr;
-                for (auto _tableValue : tableLit->values.objects()) {
-                        auto tableValue = static_cast<TableValue_t*>(_tableValue);
-                        auto value = tableValue->value.get();
+                for (auto value : tableLit->values.objects()) {
                         switch (value->getId()) {
-                                case "KeyValue"_id:
+                                case "variable_pair"_id:
+                                        transform_variable_pair(static_cast<variable_pair_t*>(value), temp);
+                                        break;
+                                case "normal_pair"_id:
+                                        transform_normal_pair(static_cast<normal_pair_t*>(value), temp);
+                                        break;
                                 case "Exp"_id:
-                                        if (value->getId() == "Exp"_id) {
-                                                transformExp(static_cast<Exp_t*>(value), temp);
-                                        } else {
-                                                transformKeyValue(static_cast<KeyValue_t*>(value), temp);
-                                        }
-                                        temp.back() = (lastNode ? s(","sv) + nll(lastNode) : Empty) + indent(1) + temp.back();
-                                        lastNode = value;
+                                        transformExp(static_cast<Exp_t*>(value), temp);
                                         break;
                                 default: break;
                         }
+                        temp.back() = (lastNode ? s(","sv) + nll(lastNode) : Empty) + indent(1) + temp.back();
+                        lastNode = value;
                 }
                 out.push_back(s("{"sv) + nll(tableLit) + join(temp) + nlr(tableLit) + indent() + s("}"sv));
         }
@@ -1329,14 +1279,12 @@ private:
 
         void transformInvokeArgs(InvokeArgs_t* invokeArgs, std::vector<std::string>& out) {
                 std::vector<std::string> temp;
-                if (invokeArgs->argsList) {
-                        transformExpList(invokeArgs->argsList, temp);
-                }
-                if (invokeArgs->argsTableBlock) {
-                        transform_invoke_args_with_table(invokeArgs->argsTableBlock, temp);
-                }
-                if (invokeArgs->tableBlock) {
-                        transformTableBlock(invokeArgs->tableBlock, temp);
+                for (auto arg : invokeArgs->args.objects()) {
+                        switch (arg->getId()) {
+                                case "Exp"_id: transformExp(static_cast<Exp_t*>(arg), temp); break;
+                                case "TableBlock"_id: transformTableBlock(arg, temp); break;
+                                default: break;
+                        }
                 }
                 out.push_back(join(temp, ", "sv));
         }
@@ -1529,37 +1477,35 @@ private:
                 out.push_back(join(temp));
         }
 
-        void transformKeyValue(KeyValue_t* keyValue, std::vector<std::string>& out) {
-                auto item = keyValue->item.get();
-                switch (item->getId()) {
-                        case "variable_pair"_id:
-                                out.push_back(toString(static_cast<variable_pair_t*>(item)->name));
+        void transform_variable_pair(variable_pair_t* pair, std::vector<std::string>& out) {
+                out.push_back(toString(pair->name));
+        }
+
+        void transform_normal_pair(normal_pair_t* pair, std::vector<std::string>& out) {
+                auto key = pair->key.get();
+                std::vector<std::string> temp;
+                switch (key->getId()) {
+                        case "KeyName"_id: transformKeyName(static_cast<KeyName_t*>(key), temp); break;
+                        case "Exp"_id:
+                                transformExp(static_cast<Exp_t*>(key), temp);
+                                temp.back() = s("["sv) + temp.back() + s("]"sv);
                                 break;
-                        case "normal_pair"_id: {
-                                auto pair = static_cast<normal_pair_t*>(item);
-                                auto key = pair->key.get();
-                                std::vector<std::string> temp;
-                                switch (key->getId()) {
-                                        case "KeyName"_id: transformKeyName(static_cast<KeyName_t*>(key), temp); break;
-                                        case "Exp"_id:
-                                                transformExp(static_cast<Exp_t*>(key), temp);
-                                                temp.back() = s("["sv) + temp.back() + s("]"sv);
-                                                break;
-                                        case "DoubleString"_id: transformDoubleString(static_cast<DoubleString_t*>(key), temp); break;
-                                        case "SingleString"_id: transformSingleString(static_cast<SingleString_t*>(key), temp); break;
-                                        default: break;
-                                }
-                                auto value = pair->value.get();
-                                switch (value->getId()) {
-                                        case "Exp"_id: transformExp(static_cast<Exp_t*>(value), temp); break;
-                                        case "TableBlock"_id: transformTableBlock(static_cast<TableBlock_t*>(value), temp); break;
-                                        default: break;
-                                }
-                                out.push_back(temp[0] + s(" = "sv) + temp[1]);
+                        case "DoubleString"_id:
+                                transformDoubleString(static_cast<DoubleString_t*>(key), temp);
+                                temp.back() = s("["sv) + temp.back() + s("]"sv);
+                                break;
+                        case "SingleString"_id: transformSingleString(static_cast<SingleString_t*>(key), temp);
+                                temp.back() = s("["sv) + temp.back() + s("]"sv);
                                 break;
-                        }
                         default: break;
                 }
+                auto value = pair->value.get();
+                switch (value->getId()) {
+                        case "Exp"_id: transformExp(static_cast<Exp_t*>(value), temp); break;
+                        case "TableBlock"_id: transformTableBlock(static_cast<TableBlock_t*>(value), temp); break;
+                        default: break;
+                }
+                out.push_back(temp[0] + s(" = "sv) + temp[1]);
         }
 
         void transformKeyName(KeyName_t* keyName, std::vector<std::string>& out) {
@@ -1802,16 +1748,14 @@ private:
 
         void transform_class_member_list(class_member_list_t* class_member_list, std::list<ClassMember>& out, const std::string& classVar) {
                 std::vector<std::string> temp;
-                for (auto _keyValue : class_member_list->values.objects()) {
-                        auto keyValue = static_cast<KeyValue_t*>(_keyValue);
+                for (auto keyValue : class_member_list->values.objects()) {
                         bool isBuiltin = false;
                         do {
-                                auto keyName = static_cast<KeyName_t*>(
-                                        keyValue->getByPath({"normal_pair"_id, "KeyName"_id})
-                                );
+                                auto normal_pair = ast_cast<normal_pair_t>(keyValue);
+                                if (!normal_pair) break;
+                                auto keyName = normal_pair->key.as<KeyName_t>();
                                 if (!keyName) break;
-                                auto normal_pair = static_cast<normal_pair_t*>(keyValue->getFirstChild());
-                                auto nameNode = keyName->getByPath({"Name"_id});
+                                auto nameNode = keyName->name.as<Name_t>();
                                 if (!nameNode) break;
                                 auto name = toString(nameNode);
                                 input newSuperCall;
@@ -1827,8 +1771,8 @@ private:
                                         if (auto chainValue = ast_cast<ChainValue_t>(node)) {
                                                 if (auto var = chainValue->caller->getByPath({"Variable"_id})) {
                                                         if (toString(var) == "super"sv) {
-                                                                if (chainValue->arguments && chainValue->arguments->argsList) {
-                                                                        chainValue->arguments->argsList->exprs.push_front(toAst<Exp_t>("self"sv, Exp));
+                                                                if (chainValue->arguments) {
+                                                                        chainValue->arguments->args.push_front(toAst<Exp_t>("self"sv, Exp));
                                                                         _codeCache.push_back(newSuperCall);
                                                                         var->m_begin.m_it = _codeCache.back().begin();
                                                                         var->m_end.m_it = _codeCache.back().end();
@@ -1838,44 +1782,33 @@ private:
                                                                         var->m_end.m_it = _codeCache.back().end();
                                                                 }
                                                         }
-                                                } else if (auto var = chainValue->caller->getByPath({"chain_call"_id, "Callable"_id, "Variable"_id})) {
+                                                } else if (auto var = chainValue->caller->getByPath({"Callable"_id, "Variable"_id})) {
                                                         if (toString(var) == "super"sv) {
-                                                                auto chainList = getChainList(chainValue->caller);
-                                                                if (auto args = chainValue->getByPath({"InvokeArgs"_id, "ExpList"_id})) {
-                                                                        chainList.push_back(args);
-                                                                }
                                                                 auto insertSelfToArguments = [&](ast_node* item) {
                                                                         switch (item->getId()) {
-                                                                                case "ExpList"_id:
-                                                                                        static_cast<ExpList_t*>(item)->exprs.push_front(toAst<Exp_t>("self"sv, Exp));
-                                                                                        break;
+                                                                                case "InvokeArgs"_id: {
+                                                                                        auto invoke = static_cast<InvokeArgs_t*>(item);
+                                                                                        invoke->args.push_front(toAst<Exp_t>("self"sv, Exp));
+                                                                                        return true;
+                                                                                }
                                                                                 case "Invoke"_id: {
                                                                                         auto invoke = static_cast<Invoke_t*>(item);
-                                                                                        if (auto fnArgs = invoke->argument.as<FnArgs_t>()) {
-                                                                                                fnArgs->args.push_front(toAst<Exp_t>("self"sv, Exp));
-                                                                                        } else {
-                                                                                                auto string = new_ptr<String_t>();
-                                                                                                string->str.set(invoke->argument);
-                                                                                                auto value = new_ptr<Value_t>();
-                                                                                                value->item.set(string);
-                                                                                                auto exp = new_ptr<Exp_t>();
-                                                                                                exp->value.set(value);
-                                                                                                auto newFnArgs = new_ptr<FnArgs_t>();
-                                                                                                fnArgs->args.push_back(toAst<Exp_t>("self"sv, Exp));
-                                                                                                newFnArgs->args.push_back(exp);
-                                                                                                invoke->argument.set(newFnArgs);
-                                                                                        }
-                                                                                        break;
+                                                                                        invoke->args.push_front(toAst<Exp_t>("self"sv, Exp));
+                                                                                        return true;
                                                                                 }
-                                                                                default: break;
+                                                                                default:
+                                                                                        return false;
                                                                         }
                                                                 };
+                                                                auto chainList = getChainList(chainValue);
                                                                 if (chainList.size() == 2) {
-                                                                        _codeCache.push_back(newSuperCall);
+                                                                        if (insertSelfToArguments(chainList.back())) {
+                                                                                _codeCache.push_back(newSuperCall);
+                                                                        } else {
+                                                                                _codeCache.push_back(_converter.from_bytes(classVar) + L".__parent");
+                                                                        }
                                                                         var->m_begin.m_it = _codeCache.back().begin();
                                                                         var->m_end.m_it = _codeCache.back().end();
-                                                                        auto item = chainList.back();
-                                                                        insertSelfToArguments(item);
                                                                 } else if (chainList.size() > 2) {
                                                                         _codeCache.push_back(_converter.from_bytes(classVar) + L".__parent");
                                                                         var->m_begin.m_it = _codeCache.back().begin();
@@ -1896,7 +1829,14 @@ private:
                                         return traversal::Continue;
                                 });
                         } while (false);
-                        transformKeyValue(keyValue, temp);
+                        switch (keyValue->getId()) {
+                                case "variable_pair"_id:
+                                        transform_variable_pair(static_cast<variable_pair_t*>(keyValue), temp);
+                                        break;
+                                case "normal_pair"_id:
+                                        transform_normal_pair(static_cast<normal_pair_t*>(keyValue), temp);
+                                        break;
+                        }
                         out.push_back({temp.back(), isBuiltin, keyValue});
                         temp.clear();
                 }
@@ -1926,7 +1866,6 @@ private:
         void transform_const_value(ast_node* node, std::vector<std::string>& out) {noop(node, out);}
         void transformDo(ast_node* node, std::vector<std::string>& out) {noop(node, out);}
         void transformTblComprehension(ast_node* node, std::vector<std::string>& out) {noop(node, out);}
-        void transform_chain_dot_chain(ast_node* node, std::vector<std::string>& out) {noop(node, out);}
         void transformSlice(ast_node* node, std::vector<std::string>& out) {noop(node, out);}
         void transformCompFor(ast_node* node, std::vector<std::string>& out) {noop(node, out);}
         void transformCompClause(ast_node* node, std::vector<std::string>& out) {noop(node, out);}
@@ -1938,64 +1877,18 @@ const std::string MoonCompliler::Empty;
 
 int main()
 {
-        std::string s = R"TestCodesHere(class Hello
-  new: (@test, @world) =>
-    print "creating object.."
-  hello: =>
-    print @test, @world
-  __tostring: => "hello world"
-
-x = Hello 1,2
-x\hello()
-
-print x
-
-class Simple
-  cool: => print "cool"
-
-class Yikes extends Simple
-  new: => print "created hello"
-
-x = Yikes()
-x\cool()
-
-
-class Hi
-  new: (arg) =>
-    print "init arg", arg
-
-  cool: (num) =>
-    print "num", num
-
-
-class Simple extends Hi
-  new: => super "man"
-  cool: => super 120302
-
-x = Simple()
-x\cool()
-
-print x.__class == Simple
-
-
-class Okay
-  -- what is going on
-  something: 20323
-  -- yeaha
-
-
-class Biggie extends Okay
-  something: =>
-    super 1,2,3,4
-    super.something another_self, 1,2,3,4
-    assert super == Okay
-
-
-class Yeah
-  okay: =>
-    super\something 1,2,3,4
-)TestCodesHere";
-
+        std::string s = R"TestCodesHere(my_func 5,6,7,
+  6, another_func 6,7,8,
+    9,1,2,
+  5,4, :name, :value)TestCodesHere";
+/*
+return my_func(5, 6, 7, 6, another_func(6, 7, 8, 9, 1, 2), 5, 4)
+
+with Hello!
+  x = \something!
+  print x
+  x!
+*/
         MoonCompliler{}.complile(s);
 
         return 0;
diff --git a/MoonParser/moon_ast.h b/MoonParser/moon_ast.h
index 9733bf9..c4f20c3 100644
--- a/MoonParser/moon_ast.h
+++ b/MoonParser/moon_ast.h
@@ -290,11 +290,18 @@ AST_NODE(ChainValue, "ChainValue"_id)
         ast_ptr<InvokeArgs_t, true> arguments;
 AST_END(ChainValue)
 
-class KeyValue_t;
+AST_NODE(variable_pair, "variable_pair"_id)
+        ast_ptr<Variable_t> name;
+AST_END(variable_pair)
+
+AST_NODE(normal_pair, "normal_pair"_id)
+        ast_ptr<ast_node> key; // KeyName_t | [Exp_t] | DoubleString_t | SingleString_t
+        ast_ptr<ast_node> value; // Exp_t | TableBlock_t
+AST_END(normal_pair)
 
 AST_NODE(simple_table, "simple_table"_id)
         ast_ptr<Seperator_t> sep;
-        ast_list<KeyValue_t> pairs;
+        ast_sel_list<variable_pair_t, normal_pair_t> pairs;
 AST_END(simple_table)
 
 class String_t;
@@ -308,14 +315,6 @@ AST_NODE(SimpleValue, "SimpleValue"_id)
         */
 AST_END(SimpleValue)
 
-AST_NODE(Chain, "Chain"_id)
-        ast_ptr<ast_node> item; // chain_call_t | chain_item_t | chain_dot_chain_t | ColonChain_t
-AST_END(Chain)
-
-AST_NODE(Value, "Value"_id)
-        ast_ptr<ast_node> item; // SimpleValue_t | simple_table_t | ChainValue_t | String_t
-AST_END(Value)
-
 AST_LEAF(LuaString, "LuaString"_id)
 AST_END(LuaString)
 
@@ -338,26 +337,6 @@ AST_NODE(String, "String"_id)
         ast_ptr<ast_node> str; // DoubleString_t | SingleString_t | LuaString_t
 AST_END(String)
 
-AST_NODE(Parens, "Parens"_id)
-        ast_ptr<Exp_t> expr;
-AST_END(Parens)
-
-AST_NODE(FnArgs, "FnArgs"_id)
-        ast_ptr<Seperator_t> sep;
-        ast_list<Exp_t> args;
-AST_END(FnArgs)
-
-class ChainItems_t;
-
-AST_NODE(chain_call, "chain_call"_id)
-        ast_ptr<ast_node> caller; // Callable_t | String_t
-        ast_ptr<ChainItems_t> chain;
-AST_END(chain_call)
-
-AST_NODE(chain_item, "chain_item"_id)
-        ast_ptr<ChainItems_t> chain;
-AST_END(chain_item)
-
 AST_NODE(DotChainItem, "DotChainItem"_id)
         ast_ptr<Name_t> name;
 AST_END(DotChainItem)
@@ -367,67 +346,46 @@ AST_NODE(ColonChainItem, "ColonChainItem"_id)
         bool switchToDot = false;
 AST_END(ColonChainItem)
 
-AST_NODE(chain_dot_chain, "chain_dot_chain"_id)
-        ast_ptr<DotChainItem_t> caller;
-        ast_ptr<ChainItems_t, true> chain;
-AST_END(chain_dot_chain)
-
-class ColonChain_t;
-class Invoke_t;
-class Slice_t;
-
-AST_NODE(ChainItem, "ChainItem"_id)
-        ast_ptr<ast_node> item; // Invoke_t | DotChainItem_t | Slice_t | [Exp_t]
-AST_END(ChainItem)
-
-AST_NODE(ChainItems, "ChainItems"_id)
-        ast_ptr<Seperator_t> sep;
-        ast_list<ChainItem_t> simpleChain;
-        ast_ptr<ColonChain_t, true> colonChain;
-AST_END(ChainItems)
-
-AST_NODE(invoke_chain, "invoke_chain"_id)
-        ast_ptr<Invoke_t> invoke;
-        ast_ptr<ChainItems_t, true> chain;
-AST_END(invoke_chain)
-
-AST_NODE(ColonChain, "ColonChain"_id)
-        ast_ptr<ColonChainItem_t> colonChain;
-        ast_ptr<invoke_chain_t, true> invokeChain;
-AST_END(ColonChain)
-
-AST_LEAF(default_value, "default_value"_id)
-AST_END(default_value)
-
 AST_NODE(Slice, "Slice"_id)
         ast_ptr<ast_node> startValue; // Exp_t | default_value_t
         ast_ptr<ast_node> stopValue; // Exp_t | default_value_t
         ast_ptr<ast_node> stepValue; // Exp_t | default_value_t
 AST_END(Slice)
 
+AST_NODE(Parens, "Parens"_id)
+        ast_ptr<Exp_t> expr;
+AST_END(Parens)
+
 AST_NODE(Invoke, "Invoke"_id)
-        ast_ptr<ast_node> argument; // FnArgs_t | SingleString_t | DoubleString_t | LuaString_t
+        ast_ptr<Seperator_t> sep;
+        ast_sel_list<Exp_t, SingleString_t, DoubleString_t, LuaString_t> args;
 AST_END(Invoke)
 
-class KeyValue_t;
+AST_NODE(Chain, "Chain"_id)
+        ast_ptr<Seperator_t> sep;
+        ast_sel_list<Callable_t, Invoke_t, DotChainItem_t, ColonChainItem_t, Slice_t, Exp_t> items;
+AST_END(Chain)
 
-AST_NODE(TableValue, "TableValue"_id)
-        ast_ptr<ast_node> value; // KeyValue_t | Exp_t
-AST_END(TableValue)
+AST_NODE(Value, "Value"_id)
+        ast_ptr<ast_node> item; // SimpleValue_t | simple_table_t | ChainValue_t | String_t
+AST_END(Value)
+
+AST_LEAF(default_value, "default_value"_id)
+AST_END(default_value)
 
 AST_NODE(TableLit, "TableLit"_id)
         ast_ptr<Seperator_t> sep;
-        ast_list<TableValue_t> values;
+        ast_sel_list<variable_pair_t, normal_pair_t, Exp_t> values;
 AST_END(TableLit)
 
 AST_NODE(TableBlock, "TableBlock"_id)
         ast_ptr<Seperator_t> sep;
-        ast_list<KeyValue_t> values;
+        ast_sel_list<variable_pair_t, normal_pair_t> values;
 AST_END(TableBlock)
 
 AST_NODE(class_member_list, "class_member_list"_id)
         ast_ptr<Seperator_t> sep;
-        ast_list<KeyValue_t> values;
+        ast_sel_list<variable_pair_t, normal_pair_t> values;
 AST_END(class_member_list)
 
 AST_NODE(ClassLine, "ClassLine"_id)
@@ -457,19 +415,6 @@ AST_NODE(Export, "Export"_id)
         ast_ptr<ast_node> item; // ClassDecl_t | export_op_t | export_values_t
 AST_END(Export)
 
-AST_NODE(variable_pair, "variable_pair"_id)
-        ast_ptr<Variable_t> name;
-AST_END(variable_pair)
-
-AST_NODE(normal_pair, "normal_pair"_id)
-        ast_ptr<ast_node> key; // KeyName_t | [Exp_t] | DoubleString_t | SingleString_t
-        ast_ptr<ast_node> value; // Exp_t | TableBlock_t
-AST_END(normal_pair)
-
-AST_NODE(KeyValue, "KeyValue"_id)
-        ast_ptr<ast_node> item; // variable_pair_t | normal_pair_t
-AST_END(KeyValue)
-
 AST_NODE(FnArgDef, "FnArgDef"_id)
         ast_ptr<ast_node> name; // Variable_t | SelfName_t
         ast_ptr<Exp_t, true> defaultValue;
@@ -508,20 +453,9 @@ AST_NODE(AssignableNameList, "AssignableNameList"_id)
         ast_list<NameOrDestructure_t> items;
 AST_END(AssignableNameList)
 
-AST_NODE(ArgBlock, "ArgBlock"_id)
-        ast_ptr<Seperator_t> sep;
-        ast_list<Exp_t> arguments;
-AST_END(ArgBlock)
-
-AST_NODE(invoke_args_with_table, "invoke_args_with_table"_id)
-        ast_ptr<ArgBlock_t, true> argBlock;
-        ast_ptr<TableBlock_t, true> tableBlock;
-AST_END(invoke_args_with_table)
-
 AST_NODE(InvokeArgs, "InvokeArgs"_id)
-        ast_ptr<ExpList_t, true> argsList;
-        ast_ptr<invoke_args_with_table_t, true> argsTableBlock;
-        ast_ptr<TableBlock_t, true> tableBlock;
+        ast_ptr<Seperator_t> sep;
+        ast_sel_list<Exp_t, TableBlock_t> args;
 AST_END(InvokeArgs)
 
 AST_LEAF(const_value, "const_value"_id)
diff --git a/MoonParser/moon_parser.cpp b/MoonParser/moon_parser.cpp
index ec8df38..8917e58 100644
--- a/MoonParser/moon_parser.cpp
+++ b/MoonParser/moon_parser.cpp
@@ -312,30 +312,24 @@ rule Parens = sym('(') >> *SpaceBreak >> Exp >> *SpaceBreak >> sym(')');
 rule Callable = Space >> Variable | SelfName | VarArg | Parens;
 rule FnArgsExpList = Exp >> *((Break | sym(',')) >> White >> Exp);
 
-rule FnArgs = Seperator >>
-(
-        (
-                symx('(') >> *SpaceBreak >> -FnArgsExpList >> *SpaceBreak >> sym(')')
-        ) | (
-                sym('!') >> not_(expr('='))
-        )
-);
+rule FnArgs = (symx('(') >> *SpaceBreak >> -FnArgsExpList >> *SpaceBreak >> sym(')')) |
+        (sym('!') >> not_(expr('=')));
 
 extern rule ChainItems, DotChainItem, ColonChain;
 
 rule chain_call = (Callable | String) >> ChainItems;
-rule chain_item = not_(set(".\\")) >> ChainItems;
+rule chain_item = and_(set(".\\")) >> ChainItems;
 rule chain_dot_chain = DotChainItem >> -ChainItems;
 
-rule Chain =
+rule Chain = Seperator >> (
         chain_call |
         chain_item |
-        Space >> (chain_dot_chain | ColonChain);
+        Space >> (chain_dot_chain | ColonChain));
 
 extern rule ChainItem;
 
 rule chain_with_colon = +ChainItem >> -ColonChain;
-rule ChainItems = Seperator >> (chain_with_colon | ColonChain);
+rule ChainItems = chain_with_colon | ColonChain;
 
 extern rule Invoke, Slice;
 
@@ -355,11 +349,11 @@ rule Slice =
         (sym(',') >> Exp | default_value) >>
         sym(']');
 
-rule Invoke =
+rule Invoke = Seperator >> (
         FnArgs |
         SingleString |
         DoubleString |
-        and_(expr('[')) >> LuaString;
+        and_(expr('[')) >> LuaString);
 
 extern rule TableValueList, TableLitLine;
 
@@ -448,7 +442,7 @@ rule ExpList = Seperator >> Exp >> *(sym(',') >> Exp);
 rule ExpListLow = Seperator >> Exp >> *((sym(',') | sym(';')) >> Exp);
 
 rule ArgLine = CheckIndent >> Exp >> *(sym(',') >> Exp);
-rule ArgBlock = Seperator >> ArgLine >> *(sym(',') >> SpaceBreak >> ArgLine) >> PopIndent;
+rule ArgBlock = ArgLine >> *(sym(',') >> SpaceBreak >> ArgLine) >> PopIndent;
 
 rule invoke_args_with_table =
         sym(',') >>
@@ -458,9 +452,9 @@ rule invoke_args_with_table =
         );
 
 rule InvokeArgs =
-        not_(expr('-')) >>
+        not_(expr('-')) >> Seperator >> 
         (
-                ExpList >> -(invoke_args_with_table | TableBlock) |
+                Exp >> *(sym(',') >> Exp) >> -(invoke_args_with_table | TableBlock) |
                 TableBlock
         );