Revert changes adding exprContext to parsing functions

Author: wcjohnson

src/parser/statement.js

@@ -53,7 +53,7 @@ pp.stmtToDirective = function (stmt) {
 // `if (foo) /blah/.exec(foo)`, where looking at the previous token
 // does not help.
 
-pp.parseStatement = function (declaration, topLevel, isExprContext) {
+pp.parseStatement = function (declaration, topLevel) {
   if (this.match(tt.at)) {
     this.parseDecorators(true);
   }
@@ -66,12 +66,7 @@ pp.parseStatement = function (declaration, topLevel, isExprContext) {
   // complexity.
 
   switch (starttype) {
-    case tt._break:
-      if (this.hasPlugin("lightscript") && isExprContext) this.unexpected(null, "break is illegal inside LightScript expressions");
-    case tt._continue:
-      if (this.hasPlugin("lightscript") && isExprContext) this.unexpected(null, "continue is illegal inside LightScript expressions");
-      return this.parseBreakContinueStatement(node, starttype.keyword);
-
+    case tt._break: case tt._continue: return this.parseBreakContinueStatement(node, starttype.keyword);
     case tt._debugger: return this.parseDebuggerStatement(node);
     case tt._do: return this.parseDoStatement(node);
     case tt._for: return this.parseForStatement(node);
@@ -84,11 +79,7 @@ pp.parseStatement = function (declaration, topLevel, isExprContext) {
       return this.parseClass(node, true);
 
     case tt._if: return this.parseIfStatement(node);
-
-    case tt._return:
-      if (this.hasPlugin("lightscript") && isExprContext) this.unexpected(null, "return is illegal inside LightScript expressions");
-      return this.parseReturnStatement(node);
-
+    case tt._return: return this.parseReturnStatement(node);
     case tt._switch: return this.parseSwitchStatement(node);
     case tt._throw: return this.parseThrowStatement(node);
     case tt._try: return this.parseTryStatement(node);
@@ -573,10 +564,10 @@ pp.parseExpressionStatement = function (node, expr) {
 // strict"` declarations when `allowStrict` is true (used for
 // function bodies).
 
-pp.parseBlock = function (allowDirectives?, isExprContext?) {
+pp.parseBlock = function (allowDirectives?) {
   const node = this.startNode();
   this.expect(tt.braceL);
-  this.parseBlockBody(node, allowDirectives, false, tt.braceR, isExprContext);
+  this.parseBlockBody(node, allowDirectives, false, tt.braceR);
   return this.finishNode(node, "BlockStatement");
 };
 
@@ -586,7 +577,7 @@ pp.isValidDirective = function (stmt) {
     !stmt.expression.extra.parenthesized;
 };
 
-pp.parseBlockBody = function (node, allowDirectives, topLevel, end, isExprContext) {
+pp.parseBlockBody = function (node, allowDirectives, topLevel, end) {
   node.body = [];
   node.directives = [];
 
@@ -606,7 +597,7 @@ pp.parseBlockBody = function (node, allowDirectives, topLevel, end, isExprContex
       octalPosition = this.state.octalPosition;
     }
 
-    const stmt = this.parseStatement(true, topLevel, isExprContext);
+    const stmt = this.parseStatement(true, topLevel);
 
     if (allowDirectives && !parsedNonDirective && this.isValidDirective(stmt)) {
       const directive = this.stmtToDirective(stmt);

src/plugins/flow.js

@@ -880,14 +880,14 @@ export default function (instance) {
 
   // interfaces
   instance.extend("parseStatement", function (inner) {
-    return function (declaration, topLevel, isExprContext) {
+    return function (declaration, topLevel) {
       // strict mode handling of `interface` since it's a reserved word
       if (this.state.strict && this.match(tt.name) && this.state.value === "interface") {
         const node = this.startNode();
         this.next();
         return this.flowParseInterface(node);
       } else {
-        return inner.call(this, declaration, topLevel, isExprContext);
+        return inner.call(this, declaration, topLevel);
       }
     };
   });

src/plugins/lightscript.js

@@ -178,35 +178,35 @@ pp.finishWhiteBlock = function(node, allowEmptyBody) {
   return this.finishNode(node, "BlockStatement");
 };
 
-pp.parseInlineWhiteBlock = function(node, isExprContext, allowEmptyBody) {
+pp.parseInlineWhiteBlock = function(node, allowEmptyBody) {
   if (this.state.type.startsExpr) return this.parseMaybeAssign();
   // oneline statement case
-  node.body = this.couldBeginStatement() ? [this.parseStatement(true, false, isExprContext)] : [];
+  node.body = this.couldBeginStatement() ? [this.parseStatement(true)] : [];
   node.directives = [];
   return this.finishWhiteBlock(node, allowEmptyBody);
 };
 
-pp.parseMultilineWhiteBlock = function(node, indentLevel, isExprContext, allowEmptyBody) {
-  this.parseBlockBody(node, false, false, indentLevel, isExprContext);
+pp.parseMultilineWhiteBlock = function(node, indentLevel, allowEmptyBody) {
+  this.parseBlockBody(node, false, false, indentLevel);
   return this.finishWhiteBlock(node, allowEmptyBody);
 };
 
-pp.parseWhiteBlock = function (isExprContext?) {
+pp.parseWhiteBlock = function (isExpression?) {
   const node = this.startNode(), indentLevel = this.state.indentLevel;
 
   if (!this.eat(tt.colon)) this.unexpected(null, "Whitespace Block must start with a colon or arrow");
 
   // Oneline whiteblock
   if (!this.isLineBreak()) {
-    if (isExprContext) {
-      return this.parseInlineWhiteBlock(node, true, false);
+    if (isExpression) {
+      return this.parseInlineWhiteBlock(node, false);
     } else {
-      return this.parseStatement(false, false, false);
+      return this.parseStatement(false);
     }
   }
 
   // TODO: document the fact that directives aren't parsed
-  return this.parseMultilineWhiteBlock(node, indentLevel, isExprContext, false);
+  return this.parseMultilineWhiteBlock(node, indentLevel, false);
 };
 
 pp.expectCommaOrLineBreak = function () {
@@ -352,10 +352,10 @@ pp.parseArrowFunctionBody = function (node) {
       this.addExtra(node.body, "curly", true);
       node.body = this.finishNode(node.body, "BlockStatement");
     } else {
-      node.body = this.parseInlineWhiteBlock(node.body, false, true);
+      node.body = this.parseInlineWhiteBlock(node.body, true);
     }
   } else {
-    node.body = this.parseMultilineWhiteBlock(node.body, indentLevel, false, true);
+    node.body = this.parseMultilineWhiteBlock(node.body, indentLevel, true);
   }
 
   if (node.body.type !== "BlockStatement") {
@@ -427,7 +427,7 @@ pp.parseIf = function (node, isExpression) {
 
   if (isExpression) {
     if (this.match(tt.braceL)) {
-      node.consequent = this.parseBlock(false, true);
+      node.consequent = this.parseBlock(false);
     } else if (!isColon) {
       node.consequent = this.parseMaybeAssign();
     } else {
@@ -476,7 +476,7 @@ pp.parseIfAlternate = function (node, isExpression, ifIsWhiteBlock, ifIndentLeve
 
     if (isExpression) {
       if (this.match(tt.braceL)) {
-        return this.parseBlock(false, true);
+        return this.parseBlock(false);
       } else if (!this.match(tt.colon)) {
         return this.parseMaybeAssign();
       } else {
@@ -835,9 +835,9 @@ export default function (instance) {
   // whitespace following a colon
 
   instance.extend("parseBlock", function (inner) {
-    return function (allowDirectives, isExprContext) {
+    return function () {
       if (this.match(tt.colon)) {
-        return this.parseWhiteBlock(isExprContext);
+        return this.parseWhiteBlock();
       }
       const block = inner.apply(this, arguments);
       this.addExtra(block, "curly", true);