Pattern matching

commit 8c08a25
Author: William C. Johnson <wcjohnson@oigroup.net>
Date:   Sun May 14 00:01:56 2017 -0400

    0.7.0-alpha.2

commit 4d75189
Author: William C. Johnson <wcjohnson@oigroup.net>
Date:   Sat May 13 23:52:15 2017 -0400

    More fixtures

commit 351ef9c
Author: William C. Johnson <wcjohnson@oigroup.net>
Date:   Sat May 13 23:41:33 2017 -0400

    Update match parsing for whiteblock changes

commit d8b48c6
Author: William C. Johnson <wcjohnson@oigroup.net>
Date:   Sat May 13 23:24:59 2017 -0400

    Whiteblock statement fixes

    - Unify whiteblock parsing
    - Track expression context and error on illegal stmts

commit a8c0620
Author: William C. Johnson <wcjohnson@oigroup.net>
Date:   Sat May 13 20:54:47 2017 -0400

    Add parsing fixture for oneline fix

commit 0b0f5dc
Author: William C. Johnson <wcjohnson@oigroup.net>
Date:   Sat May 13 13:16:24 2017 -0400

    Fix for oneline if statement parsing

    commit 71edb07c58b6c2e7d46331dcebc2bb844c3ef2b1
    Author: William C. Johnson <wcjohnson@oigroup.net>
    Date:   Sat May 13 13:14:37 2017 -0400

        More comprehensive fixture

    commit 68315ee2bdaddf7361eddcee40972434f1b27d9e
    Author: William C. Johnson <wcjohnson@oigroup.net>
    Date:   Sat May 13 13:10:01 2017 -0400

        Fix if expr oneline block parsing

    commit d5c0a2455f7b7933b9b550d8bc03e81e6b6aa451
    Author: William C. Johnson <wcjohnson@oigroup.net>
    Date:   Sat May 13 13:02:00 2017 -0400

        Cleanup parseWhiteBlockBody

    commit 5aaed5d89c5133a70190752a925acd55a5641b9c
    Author: William C. Johnson <wcjohnson@oigroup.net>
    Date:   Sat May 13 13:01:47 2017 -0400

        Cleanup ASI code

    commit d769f57418d1d1c8b11547eff14eeabdd8f737d6
    Author: William C. Johnson <wcjohnson@oigroup.net>
    Date:   Sat May 13 13:01:39 2017 -0400

        Add parsing fixture

commit ebec649
Author: William C. Johnson <wcjohnson@oigroup.net>
Date:   Sat May 13 00:27:01 2017 -0400

    0.7.0-alpha.1

commit 24b3fea
Author: William C. Johnson <wcjohnson@oigroup.net>
Date:   Fri May 12 21:11:55 2017 -0400

    Add fixture for straight nesting

commit a86db93
Author: William C. Johnson <wcjohnson@oigroup.net>
Date:   Fri May 12 21:09:13 2017 -0400

    Allow brace blocks

commit 494f15e
Author: William C. Johnson <wcjohnson@oigroup.net>
Date:   Fri May 12 20:55:23 2017 -0400

    Match test parsing for `?` expressions

commit c03cfde
Author: William C. Johnson <wcjohnson@oigroup.net>
Date:   Fri May 12 20:22:38 2017 -0400

    `with`/`:` syntax

commit 38cfc28
Author: William C. Johnson <wcjohnson@oigroup.net>
Date:   Fri May 12 19:44:02 2017 -0400

    Fix numeric subscripts; update fixtures

commit 014e15a
Author: William C. Johnson <wcjohnson@oigroup.net>
Date:   Fri May 12 19:43:39 2017 -0400

    Remove fixtures dealing with removed bitwise ops

commit 90c17f5
Author: Alex Rattray <rattray.alex@gmail.com>
Date:   Mon Apr 24 16:39:27 2017 -0700

    Pattern Matching

    Merge from upstream

    # Conflicts:
    #	src/plugins/lightscript.js

Author: wcjohnson

src/parser/expression.js

@@ -244,6 +244,12 @@ pp.parseExprOp = function(left, leftStartPos, leftStartLoc, minPrec, noIn) {
     if (this.match(tt.plusMin) && !this.isNextCharWhitespace()) {
       return left;
     }
+    // if it's a `|` in a match/case on a newline, assume it's for the "case"
+    // TODO: consider using indentation to be more precise about this
+    // TODO: just remove all bitwise operators so this isn't necessary.
+    if (this.match(tt.bitwiseOR) && this.state.inMatchCaseConsequent) {
+      return left;
+    }
   }
 
   if (this.hasPlugin("lightscript") && this.isBitwiseOp()) {
@@ -288,7 +294,12 @@ pp.parseExprOp = function(left, leftStartPos, leftStartLoc, minPrec, noIn) {
 // Parse unary operators, both prefix and postfix.
 
 pp.parseMaybeUnary = function (refShorthandDefaultPos) {
-  if (this.state.type.prefix) {
+  const matchCaseBinaryPlusMin = this.hasPlugin("lightscript") &&
+    this.state.inMatchCaseTest &&
+    this.match(tt.plusMin) &&
+    this.isNextCharWhitespace();
+
+  if (this.state.type.prefix && !matchCaseBinaryPlusMin) {
     if (this.hasPlugin("lightscript") && this.match(tt.plusMin)) {
       if (this.isNextCharWhitespace()) this.unexpected(null, "Unary +/- cannot be followed by a space in lightscript.");
     }
@@ -407,7 +418,14 @@ pp.parseSubscripts = function (base, startPos, startLoc, noCalls) {
         this.unexpected();
       }
       base = this.finishNode(node, "SafeMemberExpression");
-    } else if (this.hasPlugin("lightscript") && this.match(tt.question) && this.state.lastTokEnd === (this.state.pos - 1)) {
+    } else if (
+      this.hasPlugin("lightscript") &&
+      this.match(tt.question) &&
+      (
+        this.state.inMatchCaseTest ||
+        this.state.lastTokEnd === (this.state.pos - 1)
+      )
+    ) {
       // A `?` immediately following an expr (no whitespace) could be a
       // safecall, ternary, or existential.
       const next = this.parseQuestionSubscript(base, startPos, startLoc, noCalls);
@@ -710,6 +728,11 @@ pp.parseExprAtom = function (refShorthandDefaultPos) {
         return this.parseIfExpression(node);
       }
 
+    case tt._match:
+      if (this.hasPlugin("lightscript")) {
+        return this.parseMatch();
+      }
+
     case tt.arrow:
       if (this.hasPlugin("lightscript")) {
         node = this.startNode();
@@ -730,11 +753,16 @@ pp.parseExprAtom = function (refShorthandDefaultPos) {
       }
 
     case tt.dot:
-      if (this.hasPlugin("lightscript") && this.lookahead().type === tt.num) {
+      if (this.hasPlugin("lightscript") && !this.allowMatchCasePlaceholder() && this.lookahead().type === tt.num) {
         this.unexpected(null, "Decimal numbers must be prefixed with a `0` in LightScript (eg; `0.1`).");
       }
 
     default:
+      if (this.hasPlugin("lightscript") && this.allowMatchCasePlaceholder()) {
+        // use the blank space as an empty value (perhaps 0-length would be better)
+        node = this.startNodeAt(this.state.lastTokEnd, this.state.lastTokEndLoc);
+        return this.finishNodeAt(node, "PlaceholderExpression", this.state.start, this.state.startLoc);
+      }
       this.unexpected();
   }
 };

src/plugins/jsx/index.js

@@ -434,6 +434,11 @@ export default function(instance) {
     return function(code) {
       if (this.state.inPropertyName) return inner.call(this, code);
 
+      // don't allow jsx inside match case tests
+      if (this.hasPlugin("lightscript") && this.state.inMatchCaseTest) {
+        return inner.call(this, code);
+      }
+
       const context = this.curContext();
 
       if (this.hasPlugin("lightscript") && code === 60) {

src/plugins/lightscript.js

@@ -620,6 +620,124 @@ pp.existentialToParameter = function(node) {
   return node.argument;
 };
 
+pp.parseMatch = function () {
+  const node = this.startNode();
+  this.expect(tt._match);
+  node.discriminant = this.parseParenExpression();
+
+  let isEnd;
+  if (this.match(tt.colon)) {
+    const indentLevel = this.state.indentLevel;
+    this.next();
+    isEnd = () => this.state.indentLevel <= indentLevel || this.match(tt.eof);
+  } else {
+    this.expect(tt.braceL);
+    isEnd = () => this.eat(tt.braceR);
+  }
+
+  node.cases = [];
+  let hasUsedElse = false;
+  while (!isEnd()) {
+    if (hasUsedElse) {
+      this.unexpected(null, "`else` must be last case.");
+    }
+
+    const matchCase = this.parseMatchCase();
+    if (matchCase.test && matchCase.test.type === "MatchElse") {
+      hasUsedElse = true;
+    }
+    node.cases.push(matchCase);
+  }
+
+  return this.finishNode(node, "MatchExpression");
+};
+
+pp.parseMatchCase = function () {
+  const node = this.startNode();
+
+  node.test = this.parseMatchCaseTest();
+
+  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;
+  } 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;
+  }
+
+  return this.finishNode(node, "MatchCase");
+};
+
+pp.parseMatchCaseTest = function () {
+  // can't be nested so no need to read/restore old value
+  this.state.inMatchCaseTest = true;
+
+  this.expect(tt.bitwiseOR);
+  if (this.isLineBreak()) this.unexpected(this.state.lastTokEnd, "Illegal newline.");
+
+  let test;
+  if (this.match(tt._else)) {
+    const elseNode = this.startNode();
+    this.next();
+    test = this.finishNode(elseNode, "MatchElse");
+  } else {
+    test = this.parseExprOps();
+  }
+
+  this.state.inMatchCaseTest = false;
+  return test;
+};
+
+pp.isBinaryTokenForMatchCase = function (tokenType) {
+  return (
+    tokenType.binop != null &&
+    tokenType !== tt.logicalOR &&
+    tokenType !== tt.logicalAND &&
+    tokenType !== tt.bitwiseOR
+  );
+};
+
+pp.isSubscriptTokenForMatchCase = function (tokenType) {
+  return (
+    tokenType === tt.dot ||
+    tokenType === tt.elvis ||
+    tokenType === tt.tilde ||
+    tokenType === tt.bracketL ||
+    tokenType === tt.question
+  );
+};
+
+pp.allowMatchCasePlaceholder = function () {
+  if (!this.state.inMatchCaseTest) {
+    return false;
+  }
+  const cur = this.state.type;
+  const prev = this.state.tokens[this.state.tokens.length - 1].type;
+
+  // don't allow two binary tokens in a row to use placeholders, eg; `+ *`
+  if (this.isBinaryTokenForMatchCase(cur)) {
+    return !this.isBinaryTokenForMatchCase(prev);
+  }
+  // don't allow two subscripts in a row to use placeholders, eg; `..`
+  if (this.isSubscriptTokenForMatchCase(cur)) {
+    return !this.isSubscriptTokenForMatchCase(prev);
+  }
+  return false;
+};
+
 export default function (instance) {
 
   // if, switch, while, with --> don't need no stinkin' parens no more

src/tokenizer/state.js

@@ -38,7 +38,11 @@ export default class State {
     this.pos = this.lineStart = 0;
     this.curLine = options.startLine;
 
+    // for lightscript
     this.indentLevel = 0;
+    this.inMatchCaseConsequent =
+      this.inMatchCaseTest =
+        false;
 
     this.type = tt.eof;
     this.value = null;

src/tokenizer/types.js

@@ -127,6 +127,7 @@ export const keywords = {
   "or": types.logicalOR,
   "and": types.logicalAND,
   "not": new KeywordTokenType("not", { beforeExpr, prefix, startsExpr }),
+  "match": new KeywordTokenType("match", { beforeExpr, startsExpr }),
 
   "break": new KeywordTokenType("break"),
   "case": new KeywordTokenType("case", { beforeExpr }),

src/util/identifier.js

@@ -0,0 +1,11 @@
+match x:
+  | a: 1
+  | b with b -> b
+  | c with (c) -> c
+  | d with ({ d }) -> d
+  | e with ({ e = 1 }) -> e
+  | f with ([ f ]) -> f
+  | g with ([ g = 1 ]) -> g
+  | h with => 1
+  | i with i => i
+  | j with (j) => j