Oneline whiteblock parsing fixes

- Allow parsing of single statements in oneline whiteblocks
- Change if and arrow parsing to call new subroutine
- Allow ASI after existing semicolons and in other edge cases
- Add class to startsExpr so `ClassExpression`s don’t get parsed as stmts
- Added fixtures

Block parsing cleanup

- Move special parsing case for arrows into parseArrowBody
- Break up parseWhiteBlockBody

Whiteblocks don’t allow directives

Revert changes adding `exprContext` to parsing functions

Disallow empty whiteblocks (removes need for `couldBeginStatement`)

- Disallow empty whiteblocks
- Update fixtures
- Remove some obsolete fixtures
- Use idiomatic `-> return` in fixtures

Author: wcjohnson

src/parser/util.js

@@ -65,7 +65,18 @@ pp.isLineBreak = function () {
 pp.canInsertSemicolon = function () {
   return this.match(tt.eof) ||
     this.match(tt.braceR) ||
-    this.isLineBreak();
+    this.isLineBreak() ||
+    (this.hasPlugin("lightscript") && (
+      // LSC oneline statement ASI cases
+      // Allow if x: throw y else: throw z
+      this.match(tt._else) ||
+      this.match(tt._elif) ||
+      // Allow (-> throw new Error)()
+      this.match(tt.parenR) ||
+      // Technically it is legal to insert a ; after a ;.
+      // Allows -> throw new Error; f()
+      this.state.tokens[this.state.tokens.length - 1].type === tt.semi
+    ));
 };
 
 // TODO

src/plugins/lightscript.js

@@ -134,40 +134,41 @@ pp.parseObjectComprehension = function(node) {
   return this.finishNode(node, "ObjectComprehension");
 };
 
-// c/p parseBlock
+pp.parseInlineWhiteBlock = function(node) {
+  if (this.state.type.startsExpr) return this.parseMaybeAssign();
+  // oneline statement case
+  node.body = [this.parseStatement(true)];
+  node.directives = [];
+  this.addExtra(node, "curly", false);
+  return this.finishNode(node, "BlockStatement");
+};
+
+pp.parseMultilineWhiteBlock = function(node, indentLevel) {
+  this.parseBlockBody(node, false, false, indentLevel);
+  if (!node.body.length) {
+    this.unexpected(node.start, "Expected an Indent or Statement");
+  }
+
+  this.addExtra(node, "curly", false);
+  return this.finishNode(node, "BlockStatement");
+};
 
-pp.parseWhiteBlock = function (allowDirectives?, isExpression?) {
+pp.parseWhiteBlock = function (isExpression?) {
   const node = this.startNode(), indentLevel = this.state.indentLevel;
 
-  // must start with colon or arrow
-  if (isExpression) {
-    this.expect(tt.colon);
-    if (!this.isLineBreak()) return this.parseMaybeAssign();
-  } else if (this.eat(tt.colon)) {
-    if (!this.isLineBreak()) return this.parseStatement(false);
-  } else if (this.eat(tt.arrow)) {
-    if (!this.isLineBreak()) {
-      if (this.match(tt.braceL)) {
-        // restart node at brace start instead of arrow start
-        const node = this.startNode();
-        this.next();
-        this.parseBlockBody(node, allowDirectives, false, tt.braceR);
-        this.addExtra(node, "curly", true);
-        return this.finishNode(node, "BlockStatement");
-      } else {
-        return this.parseMaybeAssign();
-      }
+  if (!this.eat(tt.colon)) this.unexpected(null, "Whitespace Block must start with a colon or arrow");
+
+  // Oneline whiteblock
+  if (!this.isLineBreak()) {
+    if (isExpression) {
+      return this.parseInlineWhiteBlock(node);
+    } else {
+      return this.parseStatement(false);
     }
-  } else {
-    this.unexpected(null, "Whitespace Block must start with a colon or arrow");
   }
 
-  // never parse directives if curly braces aren't used (TODO: document)
-  this.parseBlockBody(node, false, false, indentLevel);
-  this.addExtra(node, "curly", false);
-  if (!node.body.length) this.unexpected(node.start, "Expected an Indent or Statement");
-
-  return this.finishNode(node, "BlockStatement");
+  // TODO: document the fact that directives aren't parsed
+  return this.parseMultilineWhiteBlock(node, indentLevel);
 };
 
 pp.expectCommaOrLineBreak = function () {
@@ -301,7 +302,23 @@ pp.parseArrowFunctionBody = function (node) {
   this.state.labels = [];
   this.state.inFunction = true;
 
-  node.body = this.parseWhiteBlock(true);
+  const indentLevel = this.state.indentLevel;
+  const nodeAtArrow = this.startNode();
+  this.expect(tt.arrow);
+  if (!this.isLineBreak()) {
+    if (this.match(tt.braceL)) {
+      // restart node at brace start instead of arrow start
+      node.body = this.startNode();
+      this.next();
+      this.parseBlockBody(node.body, true, false, tt.braceR);
+      this.addExtra(node.body, "curly", true);
+      node.body = this.finishNode(node.body, "BlockStatement");
+    } else {
+      node.body = this.parseInlineWhiteBlock(nodeAtArrow);
+    }
+  } else {
+    node.body = this.parseMultilineWhiteBlock(nodeAtArrow, indentLevel);
+  }
 
   if (node.body.type !== "BlockStatement") {
     node.expression = true;
@@ -376,7 +393,7 @@ pp.parseIf = function (node, isExpression) {
     } else if (!isColon) {
       node.consequent = this.parseMaybeAssign();
     } else {
-      node.consequent = this.parseWhiteBlock(false, true);
+      node.consequent = this.parseWhiteBlock(true);
     }
   } else {
     node.consequent = this.parseStatement(false);
@@ -425,7 +442,7 @@ pp.parseIfAlternate = function (node, isExpression, ifIsWhiteBlock, ifIndentLeve
       } else if (!this.match(tt.colon)) {
         return this.parseMaybeAssign();
       } else {
-        return this.parseWhiteBlock(false, true);
+        return this.parseWhiteBlock(true);
       }
     }
 
@@ -613,9 +630,9 @@ export default function (instance) {
   // whitespace following a colon
 
   instance.extend("parseBlock", function (inner) {
-    return function (allowDirectives) {
+    return function () {
       if (this.match(tt.colon)) {
-        return this.parseWhiteBlock(allowDirectives);
+        return this.parseWhiteBlock();
       }
       const block = inner.apply(this, arguments);
       this.addExtra(block, "curly", true);

src/tokenizer/types.js

@@ -80,7 +80,7 @@ export const types = {
   doubleColon: new TokenType("::", { beforeExpr }),
   dot: new TokenType("."),
   question: new TokenType("?", { beforeExpr }),
-  arrow: new TokenType("=>", { beforeExpr }),
+  arrow: new TokenType("=>", { beforeExpr, startsExpr }),
   template: new TokenType("template"),
   ellipsis: new TokenType("...", { beforeExpr }),
   backQuote: new TokenType("`", { startsExpr }),
@@ -152,7 +152,7 @@ export const keywords = {
   "new": new KeywordTokenType("new", { beforeExpr, startsExpr }),
   "this": new KeywordTokenType("this", { startsExpr }),
   "super": new KeywordTokenType("super", { startsExpr }),
-  "class": new KeywordTokenType("class"),
+  "class": new KeywordTokenType("class", { startsExpr }),
   "extends": new KeywordTokenType("extends", { beforeExpr }),
   "export": new KeywordTokenType("export"),
   "import": new KeywordTokenType("import", { startsExpr }),