Add multi-line comment support. Add escape new line symbol. Add back call syntax.

7 files changed, 274 insertions, 14 deletions

diff --git a/README.md b/README.md
index 7786bc7..968cc99 100644
--- a/README.md
+++ b/README.md
@@ -12,6 +12,63 @@ MoonPlus is a compiler with features from Moonscript language 0.5.0 and could be
 
 ## Changes
 
+* Add multi-line comment support.
+* Add usage for symbol `\` to escape new line. Will compile codes:
+```Moonscript
+str = --[[
+   This is a multi line comment.
+   It's OK.
+]] strA \ -- comment 1
+   .. strB \ -- comment 2
+   .. strC
+
+func --[[ip]] "192.168.126.110", --[[port]] 3000
+```
+  to:
+```Lua
+local str = strA .. strB .. strC
+func("192.168.126.110", 3000)
+```
+
+* Add back call features support with new operator and syntax. For example:
+```Moonscript
+{1,2,3} \
+  |> map((x)-> x * 2) \
+  |> filter((x)-> x > 4) \
+  |> reduce(0, (a,b)-> a + b) \
+  |> print
+
+do
+  (data) <- http.get "ajaxtest"
+  body[".result"]\html data
+  (processed) <- http.get "ajaxprocess", data
+  body[".result"]\append processed
+  print "done"
+```
+&emsp;&emsp;compiles to:
+```Lua
+print(reduce(filter(map({
+  1,
+  2,
+  3
+}, function(x)
+  return x * 2
+end), function(x)
+  return x > 4
+end), 0, function(a, b)
+  return a + b
+end))
+do
+  http.get("ajaxtest", function(data)
+    body[".result"]:html(data)
+    return http.get("ajaxprocess", data, function(processed)
+      body[".result"]:append(processed)
+      return print("done")
+    end)
+  end)
+end
+```
+
 * Add existential operator support. Generate codes from:
 ```Moonscript
 func?!
diff --git a/spec/inputs/backcall.moon b/spec/inputs/backcall.moon
new file mode 100644
index 0000000..407a5a7
--- /dev/null
+++ b/spec/inputs/backcall.moon
@@ -0,0 +1,46 @@
+
+{"abc", 123, 998} |> foreach print
+
+{1,2,3} \
+        |> map((x)-> x * 2) \
+        |> filter((x)-> x > 4) \
+        |> reduce(0, (a,b)-> a + b) \
+        |> print
+
+[i |> tostring for i = 0,10] |> table.concat(",") |> print
+
+b = 1 + 2 + (4 |> tostring |> print(1) or 123)
+
+if x = 233 |> math.max 998
+        print x
+
+998 |> func2 "abc", 233 |> func0 |> func1
+998 |> func0("abc", 233) |> func1 |> func2
+
+do
+        (data) <- http?.get "ajaxtest"
+        body[".result"]\html data
+        (processed) <- http.get "ajaxprocess", data
+        body[".result"]\append processed
+        <- setTimeout 1000
+        print "done"
+
+do
+        <- syncStatus
+        (err,data="nil") <- loadAsync "file.moon"
+        print err if err
+        (codes) <- compileAsync data
+        func = loadstring codes
+        func!
+
+do
+        <- f1
+        <- f2
+        do
+                <- f3
+                <- f4
+        <- f5
+        <- f6
+        f7!
+
+alert "hi"
diff --git a/spec/inputs/syntax.moon b/spec/inputs/syntax.moon
index bf0cf04..3ac9991 100644
--- a/spec/inputs/syntax.moon
+++ b/spec/inputs/syntax.moon
@@ -270,3 +270,13 @@ z = a- b
 
 
 -- cooool
+
+str = --[[
+This is a multi line comment.
+It's OK.
+]] strA \ -- comment 1
+        .. strB \ -- comment 2
+        .. strC
+
+func --[[port]] 3000, --[[ip]] "192.168.1.1"
+
diff --git a/src/MoonP/moon_ast.cpp b/src/MoonP/moon_ast.cpp
index 8b8a674..f14fa74 100644
--- a/src/MoonP/moon_ast.cpp
+++ b/src/MoonP/moon_ast.cpp
@@ -34,6 +34,7 @@ AST_IMPL(ImportLiteral)
 AST_IMPL(ImportFrom)
 AST_IMPL(ImportAs)
 AST_IMPL(Import)
+AST_IMPL(Backcall)
 AST_IMPL(ExpListLow)
 AST_IMPL(ExpList)
 AST_IMPL(Return)
@@ -59,6 +60,7 @@ AST_IMPL(Assign)
 AST_IMPL(update_op)
 AST_IMPL(Update)
 AST_IMPL(BinaryOperator)
+AST_IMPL(BackcallOperator)
 AST_IMPL(Assignable)
 AST_IMPL(AssignableChain)
 AST_IMPL(exp_op_value)
diff --git a/src/MoonP/moon_ast.h b/src/MoonP/moon_ast.h
index e71afe9..6969688 100644
--- a/src/MoonP/moon_ast.h
+++ b/src/MoonP/moon_ast.h
@@ -135,6 +135,15 @@ AST_NODE(Import, "Import"_id)
         AST_MEMBER(Import, &content)
 AST_END(Import)
 
+class FnArgsDef_t;
+class ChainValue_t;
+
+AST_NODE(Backcall, "Backcall"_id)
+        ast_ptr<false, FnArgsDef_t> argsDef;
+        ast_ptr<true, ChainValue_t> value;
+        AST_MEMBER(Backcall, &argsDef, &value)
+AST_END(Backcall)
+
 AST_NODE(ExpListLow, "ExpListLow"_id)
         ast_ptr<true, Seperator_t> sep;
         ast_list<true, Exp_t> exprs;
@@ -295,6 +304,9 @@ AST_END(Update)
 AST_LEAF(BinaryOperator, "BinaryOperator"_id)
 AST_END(BinaryOperator)
 
+AST_LEAF(BackcallOperator, "BackcallOperator"_id)
+AST_END(BackcallOperator)
+
 class AssignableChain_t;
 
 AST_NODE(Assignable, "Assignable"_id)
@@ -305,7 +317,7 @@ AST_END(Assignable)
 class Value_t;
 
 AST_NODE(exp_op_value, "exp_op_value"_id)
-        ast_ptr<true, BinaryOperator_t> op;
+        ast_sel<true, BinaryOperator_t, BackcallOperator_t> op;
         ast_ptr<true, Value_t> value;
         AST_MEMBER(exp_op_value, &op, &value)
 AST_END(exp_op_value)
@@ -586,7 +598,7 @@ AST_END(BreakLoop)
 AST_NODE(Statement, "Statement"_id)
         ast_sel<true, Import_t, While_t, For_t, ForEach_t,
                 Return_t, Local_t, Export_t, BreakLoop_t,
-                ExpListAssign_t> content;
+                Backcall_t, ExpListAssign_t> content;
         ast_ptr<false, statement_appendix_t> appendix;
         AST_MEMBER(Statement, &content, &appendix)
 AST_END(Statement)
diff --git a/src/MoonP/moon_compiler.cpp b/src/MoonP/moon_compiler.cpp
index 4723af4..6173389 100644
--- a/src/MoonP/moon_compiler.cpp
+++ b/src/MoonP/moon_compiler.cpp
@@ -739,6 +739,23 @@ private:
                                                                 break;
                                                         }
                                                 }
+                                        } else if (expList->exprs.size() == 1){
+                                                auto exp = static_cast<Exp_t*>(expList->exprs.back());
+                                                if (exp->opValues.size() > 0) {
+                                                        bool backcall = true;
+                                                        for (auto _opValue : exp->opValues.objects()) {
+                                                                auto opValue = static_cast<exp_op_value_t*>(_opValue);
+                                                                if (!opValue->op.is<BackcallOperator_t>()) {
+                                                                        backcall = false;
+                                                                        break;
+                                                                }
+                                                        }
+                                                        if (backcall) {
+                                                                transformExp(exp, out);
+                                                                out.back().append(nll(exp));
+                                                                break;
+                                                        }
+                                                }
                                         }
                                         throw std::logic_error(debugInfo("Expression list must appear at the end of body block."sv, expList));
                                 }
@@ -1593,11 +1610,55 @@ private:
         }
 
         void transformExp(Exp_t* exp, str_list& out) {
+                auto x = exp;
+                const auto& opValues = exp->opValues.objects();
+                for (auto it = opValues.begin(); it != opValues.end(); ++it) {
+                        auto opValue = static_cast<exp_op_value_t*>(*it);
+                        if (opValue->op.is<BackcallOperator_t>()) {
+                                if (auto chainValue = opValue->value->item.as<ChainValue_t>()) {
+                                        auto newExp = x->new_ptr<Exp_t>();
+                                        {
+                                                auto arg = x->new_ptr<Exp_t>();
+                                                arg->value.set(exp->value);
+                                                for (auto i = opValues.begin(); i != it; ++i) {
+                                                        arg->opValues.push_back(*i);
+                                                }
+                                                auto next = it; ++next;
+                                                for (auto i = next; i != opValues.end(); ++i) {
+                                                        newExp->opValues.push_back(*i);
+                                                }
+                                                if (isChainValueCall(chainValue)) {
+                                                        auto last = chainValue->items.back();
+                                                        if (auto invoke = ast_cast<InvokeArgs_t>(last)) {
+                                                                invoke->args.push_front(arg);
+                                                        } else {
+                                                                ast_to<Invoke_t>(last)->args.push_front(arg);
+                                                        }
+                                                } else {
+                                                        auto invoke = x->new_ptr<Invoke_t>();
+                                                        invoke->args.push_front(arg);
+                                                        chainValue->items.push_back(invoke);
+                                                }
+                                                auto value = x->new_ptr<Value_t>();
+                                                value->item.set(chainValue);
+                                                newExp->value.set(value);
+                                        }
+                                        transformExp(newExp, out);
+                                        return;
+                                } else {
+                                        throw std::logic_error(debugInfo("Backcall operator must be followed by chain value."sv, opValue->value));
+                                }
+                        }
+                }
                 str_list temp;
                 transformValue(exp->value, temp);
                 for (auto _opValue : exp->opValues.objects()) {
                         auto opValue = static_cast<exp_op_value_t*>(_opValue);
-                        transformBinaryOperator(opValue->op, temp);
+                        if (auto op = opValue->op.as<BinaryOperator_t>()) {
+                                transformBinaryOperator(op, temp);
+                        } else {
+                                temp.push_back(s("|>"sv));
+                        }
                         transformValue(opValue->value, temp);
                 }
                 out.push_back(join(temp, " "sv));
@@ -1731,8 +1792,68 @@ private:
         void transformCodes(const node_container& nodes, str_list& out, bool implicitReturn) {
                 LocalMode mode = LocalMode::None;
                 Local_t* any = nullptr, *capital = nullptr;
-                for (auto node : nodes) {
+                for (auto it = nodes.begin(); it != nodes.end(); ++it) {
+                        auto node = *it;
                         auto stmt = static_cast<Statement_t*>(node);
+                        if (auto backcall = stmt->content.as<Backcall_t>()) {
+                                auto x = *nodes.begin();
+                                auto newBlock = x->new_ptr<Block_t>();
+                                if (it != nodes.begin()) {
+                                        for (auto i = nodes.begin(); i != it; ++i) {
+                                                newBlock->statements.push_back(*i);
+                                        }
+                                }
+                                x = backcall;
+                                auto arg = x->new_ptr<Exp_t>();
+                                {
+                                        auto block = x->new_ptr<Block_t>();
+                                        auto next = it; ++next;
+                                        if (next != nodes.end()) {
+                                                for (auto i = next; i != nodes.end(); ++i) {
+                                                        block->statements.push_back(*i);
+                                                }
+                                        }
+                                        auto body = x->new_ptr<Body_t>();
+                                        body->content.set(block);
+                                        auto funLit = x->new_ptr<FunLit_t>();
+                                        funLit->argsDef.set(backcall->argsDef);
+                                        funLit->arrow.set(toAst<fn_arrow_t>("->"sv, fn_arrow, x));
+                                        funLit->body.set(body);
+                                        auto simpleValue = x->new_ptr<SimpleValue_t>();
+                                        simpleValue->value.set(funLit);
+                                        auto value = x->new_ptr<Value_t>();
+                                        value->item.set(simpleValue);
+                                        arg->value.set(value);
+                                }
+                                if (isChainValueCall(backcall->value)) {
+                                        auto last = backcall->value->items.back();
+                                        if (auto invoke = ast_cast<Invoke_t>(last)) {
+                                                invoke->args.push_back(arg);
+                                        } else {
+                                                ast_to<InvokeArgs_t>(last)->args.push_back(arg);
+                                        }
+                                } else {
+                                        auto invoke = x->new_ptr<Invoke_t>();
+                                        invoke->args.push_back(arg);
+                                        backcall->value->items.push_back(invoke);
+                                }
+                                auto newStmt = x->new_ptr<Statement_t>();
+                                {
+                                        auto chainValue = backcall->value.get();
+                                        auto value = x->new_ptr<Value_t>();
+                                        value->item.set(chainValue);
+                                        auto exp = x->new_ptr<Exp_t>();
+                                        exp->value.set(value);
+                                        auto expList = x->new_ptr<ExpList_t>();
+                                        expList->exprs.push_back(exp);
+                                        auto expListAssign = x->new_ptr<ExpListAssign_t>();
+                                        expListAssign->expList.set(expList);
+                                        newStmt->content.set(expListAssign);
+                                        newBlock->statements.push_back(newStmt);
+                                }
+                                transformBlock(newBlock, out, implicitReturn);
+                                return;
+                        }
                         if (auto local = stmt->content.as<Local_t>()) {
                                 if (auto flag = local->name.as<local_flag_t>()) {
                                         LocalMode newMode = toString(flag) == "*"sv ? LocalMode::Any : LocalMode::Capital;
@@ -1802,9 +1923,10 @@ private:
                         }
                 }
                 if (implicitReturn) {
+                        BLOCK_START
+                        BREAK_IF(nodes.empty());
                         auto last = static_cast<Statement_t*>(nodes.back());
                         auto x = last;
-                        BLOCK_START
                         auto expList = expListFrom(last);
                         BREAK_IF(!expList ||
                                 (last->appendix &&
@@ -1816,11 +1938,13 @@ private:
                         last->content.set(returnNode);
                         BLOCK_END
                 }
-                str_list temp;
-                for (auto node : nodes) {
-                        transformStatement(static_cast<Statement_t*>(node), temp);
+                if (!nodes.empty()) {
+                        str_list temp;
+                        for (auto node : nodes) {
+                                transformStatement(static_cast<Statement_t*>(node), temp);
+                        }
+                        out.push_back(join(temp));
                 }
-                out.push_back(join(temp));
         }
 
         void transformBody(Body_t* body, str_list& out, bool implicitReturn = false) {
diff --git a/src/MoonP/moon_parser.cpp b/src/MoonP/moon_parser.cpp
index 6d1b86c..baea9bf 100644
--- a/src/MoonP/moon_parser.cpp
+++ b/src/MoonP/moon_parser.cpp
@@ -37,8 +37,13 @@ rule Any = Break | any();
 rule White = *(set(" \t") | Break);
 rule Stop = Break | eof();
 rule Comment = "--" >> *(not_(set("\r\n")) >> Any) >> and_(Stop);
-rule Indent = *set(" \t");
-rule Space = plain_space >> -Comment;
+rule multi_line_open = expr("--[[");
+rule multi_line_close = expr("]]");
+rule multi_line_content = *(not_(multi_line_close) >> Any);
+rule MultiLineComment = multi_line_open >> multi_line_content >> multi_line_close;
+rule Indent = plain_space;
+rule EscapeNewLine = expr('\\') >> plain_space >> -Comment >> Break;
+rule Space = *(set(" \t") | MultiLineComment | EscapeNewLine) >> -Comment;
 rule SomeSpace = +set(" \t") >> -Comment;
 rule SpaceBreak = Space >> Break;
 rule EmptyLine = SpaceBreak;
@@ -287,13 +292,15 @@ rule BinaryOperator =
         expr("//") |
         set("+-*/%^><|&");
 
+rule BackcallOperator = expr("|>");
+
 extern rule AssignableChain;
 
 rule Assignable = AssignableChain | Space >> Variable | SelfName;
 
 extern rule Value;
 
-rule exp_op_value = Space >> BinaryOperator >> *SpaceBreak >> Value;
+rule exp_op_value = Space >> (BackcallOperator | BinaryOperator) >> *SpaceBreak >> Value;
 rule Exp = Value >> *exp_op_value;
 
 extern rule Chain, Callable, InvokeArgs, existential_op;
@@ -334,7 +341,7 @@ rule LuaStringClose = pl::user(lua_string_close, [](const item_t& item)
         return st->stringOpen == count;
 });
 
-rule LuaStringContent = *(not_(LuaStringClose) >> (Break | Any));
+rule LuaStringContent = *(not_(LuaStringClose) >> Any);
 
 rule LuaString = pl::user(LuaStringOpen >> -Break >> LuaStringContent >> LuaStringClose, [](const item_t& item)
 {
@@ -474,6 +481,8 @@ rule NameList = Seperator >> Space >> Variable >> *(sym(',') >> Space >> Variabl
 rule NameOrDestructure = Space >> Variable | TableLit;
 rule AssignableNameList = Seperator >> NameOrDestructure >> *(sym(',') >> NameOrDestructure);
 
+rule Backcall = -FnArgsDef >> Space >> symx("<-") >> Space >> ChainValue;
+
 rule ExpList = Seperator >> Exp >> *(sym(',') >> Exp);
 rule ExpListLow = Seperator >> Exp >> *((sym(',') | sym(';')) >> Exp);
 
@@ -518,7 +527,7 @@ rule Statement =
 (
         Import | While | For | ForEach |
         Return | Local | Export | Space >> BreakLoop |
-        ExpListAssign
+        Backcall | ExpListAssign
 ) >> Space >>
 -statement_appendix;