Reland "Fix: check if param is assignable when parsing arrow return type annotation"

packages/babel-parser/src/parser/expression.js

@@ -1453,7 +1453,7 @@ export default class ExpressionParser extends LValParser {
     if (
       canBeArrow &&
       this.shouldParseArrow() &&
-      (arrowNode = this.parseArrow(arrowNode))
+      (arrowNode = this.parseArrow(arrowNode, exprList))
     ) {
       if (!this.isAwaitAllowed() && !this.state.maybeInAsyncArrowHead) {
         this.state.awaitPos = oldAwaitPos;
@@ -1509,7 +1509,10 @@ export default class ExpressionParser extends LValParser {
     return !this.canInsertSemicolon();
   }
 
-  parseArrow(node: N.ArrowFunctionExpression): ?N.ArrowFunctionExpression {
+  parseArrow(
+    node: N.ArrowFunctionExpression,
+    exprList: N.Node[], // eslint-disable-line no-unused-vars
+  ): ?N.ArrowFunctionExpression {
     if (this.eat(tt.arrow)) {
       return node;
     }

packages/babel-parser/src/parser/lval.js

@@ -51,10 +51,60 @@ export default class LValParser extends NodeUtils {
   +parseDecorator: () => Decorator;
   */
 
+  /**
+   * Check if a node can be converted to a binding identifier or binding pattern.
+   * https://tc39.es/ecma262/#prod-BindingIdentifier
+   * https://tc39.es/ecma262/#prod-BindingPattern
+   * Note that although a mebmer expression can serve as a LHS in the init of for loop,
+   * i.e. `for (a.b of []);`, it is not a binding pattern
+   *
+   * @param {Node} node
+   * @returns {boolean}
+   * @memberof LValParser
+   */
+  isAssignable(node: Node): boolean {
+    switch (node.type) {
+      case "Identifier":
+      case "ObjectPattern":
+      case "ArrayPattern":
+      case "AssignmentPattern":
+      case "RestElement":
+        return true;
+
+      case "ObjectExpression": {
+        const last = node.properties.length - 1;
+        return node.properties.every((prop, i) => {
+          return (
+            prop.type !== "ObjectMethod" &&
+            (i === last || prop.type === "SpreadElement") &&
+            this.isAssignable(prop)
+          );
+        });
+      }
+
+      case "ObjectProperty":
+        return this.isAssignable(node.value);
+
+      case "SpreadElement":
+        return this.isAssignable(node.argument);
+
+      case "ArrayExpression":
+        return node.elements.every(element => this.isAssignable(element));
+
+      case "AssignmentExpression":
+        return node.operator === "=";
+
+      case "ParenthesizedExpression":
+        return this.isAssignable(node.expression);
+
+      default:
+        return false;
+    }
+  }
+
   // Convert existing expression atom to assignable pattern
   // if possible.
-  // NOTE: There is a corresponding "isAssignable" method in flow.js.
-  // When this one is updated, please check if also that one needs to be updated.
+  // When this one is updated, please check if `isAssignable` also needs to be updated.
 
   toAssignable(node: Node): Node {
     let parenthesized = undefined;

packages/babel-parser/src/plugins/flow.js

@@ -1943,7 +1943,7 @@ export default (superClass: Class<Parser>): Class<Parser> =>
       }
 
       return partition(arrows, node =>
-        node.params.every(param => this.isAssignable(param, true)),
+        node.params.every(param => this.isAssignable(param)),
       );
     }
 
@@ -2146,47 +2146,12 @@ export default (superClass: Class<Parser>): Class<Parser> =>
       }
     }
 
-    isAssignable(node: N.Node, isBinding?: boolean): boolean {
+    isAssignable(node: N.Node): boolean {
       switch (node.type) {
-        case "Identifier":
-        case "ObjectPattern":
-        case "ArrayPattern":
-        case "AssignmentPattern":
-          return true;
-
-        case "ObjectExpression": {
-          const last = node.properties.length - 1;
-          return node.properties.every((prop, i) => {
-            return (
-              prop.type !== "ObjectMethod" &&
-              (i === last || prop.type === "SpreadElement") &&
-              this.isAssignable(prop)
-            );
-          });
-        }
-
-        case "ObjectProperty":
-          return this.isAssignable(node.value);
-
-        case "SpreadElement":
-          return this.isAssignable(node.argument);
-
-        case "ArrayExpression":
-          return node.elements.every(element => this.isAssignable(element));
-
-        case "AssignmentExpression":
-          return node.operator === "=";
-
-        case "ParenthesizedExpression":
         case "TypeCastExpression":
           return this.isAssignable(node.expression);
-
-        case "MemberExpression":
-        case "OptionalMemberExpression":
-          return !isBinding;
-
         default:
-          return false;
+          return super.isAssignable(node);
       }
     }
 
@@ -2772,7 +2737,10 @@ export default (superClass: Class<Parser>): Class<Parser> =>
     }
 
     // handle return types for arrow functions
-    parseArrow(node: N.ArrowFunctionExpression): ?N.ArrowFunctionExpression {
+    parseArrow(
+      node: N.ArrowFunctionExpression,
+      exprList: N.Node[],
+    ): ?N.ArrowFunctionExpression {
       if (this.match(tt.colon)) {
         const result = this.tryParse(() => {
           const oldNoAnonFunctionType = this.state.noAnonFunctionType;
@@ -2806,7 +2774,7 @@ export default (superClass: Class<Parser>): Class<Parser> =>
           : null;
       }
 
-      return super.parseArrow(node);
+      return super.parseArrow(node, exprList);
     }
 
     shouldParseArrow(): boolean {
@@ -2977,7 +2945,8 @@ export default (superClass: Class<Parser>): Class<Parser> =>
     ): ?N.ArrowFunctionExpression {
       const node = this.startNodeAt(startPos, startLoc);
       this.parseFunctionParams(node);
-      if (!this.parseArrow(node)) return;
+      // set exprList to `[]` as the parameters has been validated in `parseFunctionParams`
+      if (!this.parseArrow(node, [])) return;
       return this.parseArrowExpression(
         node,
         /* params */ undefined,

packages/babel-parser/src/plugins/typescript/index.js

@@ -2540,7 +2540,10 @@ export default (superClass: Class<Parser>): Class<Parser> =>
       }
     }
 
-    parseArrow(node: N.ArrowFunctionExpression): ?N.ArrowFunctionExpression {
+    parseArrow(
+      node: N.ArrowFunctionExpression,
+      exprList,
+    ): ?N.ArrowFunctionExpression {
       if (this.match(tt.colon)) {
         // This is different from how the TS parser does it.
         // TS uses lookahead. The Babel Parser parses it as a parenthesized expression and converts.
@@ -2550,6 +2553,10 @@ export default (superClass: Class<Parser>): Class<Parser> =>
             tt.colon,
           );
           if (this.canInsertSemicolon() || !this.match(tt.arrow)) abort();
+          // check if the exprList is assignable because `: TSType` can be part of conditional expression
+          // i.e. we can only know `: v` is not a return type by checking that `sum(v)` can not be a pattern.
+          // 0 ? v => (sum(v)) : v => 0
+          if (exprList.some(param => !this.isAssignable(param))) abort();
           return returnType;
         });
 
@@ -2561,7 +2568,7 @@ export default (superClass: Class<Parser>): Class<Parser> =>
         }
       }
 
-      return super.parseArrow(node);
+      return super.parseArrow(node, exprList);
     }
 
     // Allow type annotations inside of a parameter list.
@@ -2580,6 +2587,18 @@ export default (superClass: Class<Parser>): Class<Parser> =>
       return param;
     }
 
+    isAssignable(node: N.Node): boolean {
+      switch (node.type) {
+        case "TSAsExpression":
+        case "TSNonNullExpression":
+        case "TSTypeAssertion":
+        case "TSTypeCastExpression":
+          return this.isAssignable(node.expression);
+        default:
+          return super.isAssignable(node);
+      }
+    }
+
     toAssignable(node: N.Node): N.Node {
       switch (node.type) {
         case "TSTypeCastExpression":

packages/babel-parser/test/fixtures/typescript/arrow-function/ambiguous-ternary-arrow-return-type-typescript-issue-16241/input.ts

@@ -0,0 +1 @@
+0 ? v => (v) : v => 0;

packages/babel-parser/test/fixtures/typescript/arrow-function/ambiguous-ternary-arrow-return-type-typescript-issue-16241/options.json

@@ -0,0 +1,7 @@
+{
+  "sourceType": "module",
+  "plugins": [
+    "typescript"
+  ],
+  "throws": "Unexpected token, expected \":\" (1:21)"
+}

packages/babel-parser/test/fixtures/typescript/arrow-function/return-type-like-conditional/input.ts

@@ -0,0 +1,4 @@
+0 ? v => (sum += v) : v => 0;
+0 ? v => (sum(v)) : v => 0;
+0 ? v => (v.w) : v => 0;
+0 ? v => ([ v.w ]) : v => {};

packages/babel-parser/test/fixtures/typescript/arrow-function/return-type-like-conditional/options.json

@@ -0,0 +1,3 @@
+{
+  "plugins": ["typescript"]
+}