Pattern Matching

Author: rattrayalex

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.");
     }
@@ -716,6 +727,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();
@@ -741,6 +757,11 @@ pp.parseExprAtom = function (refShorthandDefaultPos) {
       }
 
     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

@@ -550,6 +550,113 @@ pp.isBitwiseOp = function () {
   );
 };
 
+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();
+  this.expect(tt.comma);
+
+  // parse arrow function expression. (TODO: consider allowing NamedArrowExpression)
+  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);
+  }
+
+  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 === this.state.type && this.isNumberStartingWithDot())
+  );
+};
+
+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) {
 

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, b -> b
+  | c, (c) -> c
+  | d, ({ d }) -> d
+  | e, ({ e = 1 }) -> e
+  | f, ([ f ]) -> f
+  | g, ([ g = 1 ]) -> g
+  | h, => 1
+  | i, i => i
+  | j, (j) => j