Match statements

commit a6224c4
Author: William C. Johnson <wcjohnson@oigroup.net>
Date:   Wed May 17 01:00:30 2017 -0400

    Revert "1.0.3"

    This reverts commit 084045a.

commit 084045a
Author: William C. Johnson <wcjohnson@oigroup.net>
Date:   Wed May 17 00:58:45 2017 -0400

    1.0.3

commit f2572dd
Author: William C. Johnson <wcjohnson@oigroup.net>
Date:   Tue May 16 22:34:24 2017 -0400

    Parse consequent bindings

commit 1a73a60
Author: William C. Johnson <wcjohnson@oigroup.net>
Date:   Tue May 16 21:51:45 2017 -0400

    Update fixtures

commit 586bf27
Author: William C. Johnson <wcjohnson@oigroup.net>
Date:   Tue May 16 21:50:12 2017 -0400

    Enable parsing for `MatchStatement`s

Author: wcjohnson

src/parser/expression.js

@@ -730,7 +730,7 @@ pp.parseExprAtom = function (refShorthandDefaultPos) {
 
     case tt._match:
       if (this.hasPlugin("lightscript")) {
-        return this.parseMatch();
+        return this.parseMatchExpression();
       }
 
     case tt.arrow:

src/parser/statement.js

@@ -116,6 +116,9 @@ pp.parseStatement = function (declaration, topLevel) {
       }
       return starttype === tt._import ? this.parseImport(node) : this.parseExport(node);
 
+    case tt._match:
+      if (this.hasPlugin("lightscript")) return this.parseMatchStatement(node);
+
     case tt.name:
       if (this.state.value === "async") {
         // peek ahead and see if next token is a function

src/plugins/lightscript.js

@@ -620,8 +620,15 @@ pp.existentialToParameter = function(node) {
   return node.argument;
 };
 
-pp.parseMatch = function () {
-  const node = this.startNode();
+pp.parseMatchStatement = function(node) {
+  return this.parseMatch(node);
+};
+
+pp.parseMatchExpression = function() {
+  return this.parseMatch(this.startNode(), true);
+};
+
+pp.parseMatch = function (node, isExpression) {
   this.expect(tt._match);
   node.discriminant = this.parseParenExpression();
 
@@ -649,34 +656,57 @@ pp.parseMatch = function () {
     node.cases.push(matchCase);
   }
 
-  return this.finishNode(node, "MatchExpression");
+  return this.finishNode(node, isExpression ? "MatchExpression" : "MatchStatement");
+};
+
+pp.parseMatchCaseConsequent = function(matchNode) {
+  // c/p parseIf
+  if (this.match(tt.braceL)) {
+    matchNode.consequent = this.parseBlock(false, true);
+  } else {
+    matchNode.consequent = this.parseWhiteBlock(true);
+  }
+};
+
+pp.parseMatchCaseWithConsequent = function(matchNode) {
+  // with (x) -> ..., with async, with ->
+  if (this.match(tt.parenL) || this.match(tt.arrow) || this.isContextual("async")) {
+    const consequent = this.parseMaybeAssign();
+    if (consequent.type !== "ArrowFunctionExpression") {
+      this.unexpected(consequent.start, tt.arrow);
+    }
+    matchNode.consequent = consequent;
+    matchNode.functional = true;
+    return;
+  }
+
+  // with <Identifier> -> ...
+  // with <BindingAtom>: ...
+  const node = this.startNode();
+  const bindingAtom = this.parseBindingAtom();
+  if (this.match(tt.arrow)) {
+    matchNode.consequent = this.parseArrowExpression(node, bindingAtom ? [bindingAtom] : [], false);
+    matchNode.functional = true;
+    return;
+  }
+
+  matchNode.binding = bindingAtom;
+  this.parseMatchCaseConsequent(matchNode);
 };
 
 pp.parseMatchCase = function () {
   const node = this.startNode();
 
   node.test = this.parseMatchCaseTest();
 
+  const oldInMatchCaseConsequent = this.state.inMatchCaseConsequent;
+  this.state.inMatchCaseConsequent = true;
   if (this.eat(tt._with)) {
-    const oldInMatchCaseConsequent = this.state.inMatchCaseConsequent;
-    this.state.inMatchCaseConsequent = true;
-    node.consequent = this.parseMaybeAssign();
-    this.state.inMatchCaseConsequent = oldInMatchCaseConsequent;
-    if (node.consequent.type !== "ArrowFunctionExpression") {
-      this.unexpected(node.consequent.start, tt.arrow);
-    }
-    node.functional = true;
+    this.parseMatchCaseWithConsequent(node);
   } else {
-    const oldInMatchCaseConsequent = this.state.inMatchCaseConsequent;
-    this.state.inMatchCaseConsequent = true;
-    // c/p parseIf
-    if (this.match(tt.braceL)) {
-      node.consequent = this.parseBlock(false, true);
-    } else {
-      node.consequent = this.parseWhiteBlock(true);
-    }
-    this.state.inMatchCaseConsequent = oldInMatchCaseConsequent;
+    this.parseMatchCaseConsequent(node);
   }
+  this.state.inMatchCaseConsequent = oldInMatchCaseConsequent;
 
   return this.finishNode(node, "MatchCase");
 };