ts: Check if param is assignable when parsing arrow return type (#13581)

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

@@ -1503,7 +1503,7 @@ export default class ExpressionParser extends LValParser {
     let arrowNode = this.startNodeAt(startPos, startLoc);
     if (
       canBeArrow &&
-      this.shouldParseArrow() &&
+      this.shouldParseArrow(exprList) &&
       (arrowNode = this.parseArrow(arrowNode))
     ) {
       this.expressionScope.validateAsPattern();
@@ -1544,7 +1544,8 @@ export default class ExpressionParser extends LValParser {
     return parenExpression;
   }
 
-  shouldParseArrow(): boolean {
+  // eslint-disable-next-line no-unused-vars -- `params` is used in typescript plugin
+  shouldParseArrow(params: Array<N.Node>): boolean {
     return !this.canInsertSemicolon();
   }
 

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

@@ -60,7 +60,7 @@ export default class LValParser extends NodeUtils {
    - RestElement is not the last element
    - Missing `=` in assignment pattern
 
-   NOTE: There is a corresponding "isAssignable" method in flow.js.
+   NOTE: There is a corresponding "isAssignable" method.
    When this one is updated, please check if also that one needs to be updated.
 
    * @param {Node} node The expression atom
@@ -100,6 +100,7 @@ export default class LValParser extends NodeUtils {
       case "ObjectPattern":
       case "ArrayPattern":
       case "AssignmentPattern":
+      case "RestElement":
         break;
 
       case "ObjectExpression":
@@ -229,6 +230,50 @@ export default class LValParser extends NodeUtils {
     return exprList;
   }
 
+  isAssignable(node: Node, isBinding?: boolean): 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);
+
+      case "MemberExpression":
+      case "OptionalMemberExpression":
+        return !isBinding;
+
+      default:
+        return false;
+    }
+  }
+
   // Convert list of expression atoms to a list of
 
   toReferencedList(

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

@@ -330,6 +330,13 @@ export default (superClass: Class<Parser>): Class<Parser> =>
       return (node: any);
     }
 
+    isAssignable(node: N.Node, isBinding?: boolean): boolean {
+      if (node != null && this.isObjectProperty(node)) {
+        return this.isAssignable(node.value, isBinding);
+      }
+      return super.isAssignable(node, isBinding);
+    }
+
     toAssignable(node: N.Node, isLHS: boolean = false): N.Node {
       if (node != null && this.isObjectProperty(node)) {
         this.toAssignable(node.value, isLHS);

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

@@ -2257,46 +2257,10 @@ export default (superClass: Class<Parser>): Class<Parser> =>
     }
 
     isAssignable(node: N.Node, isBinding?: boolean): 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;
+      if (node.type === "TypeCastExpression") {
+        return this.isAssignable(node.expression, isBinding);
+      } else {
+        return super.isAssignable(node, isBinding);
       }
     }
 
@@ -2989,8 +2953,8 @@ export default (superClass: Class<Parser>): Class<Parser> =>
       return super.parseArrow(node);
     }
 
-    shouldParseArrow(): boolean {
-      return this.match(tt.colon) || super.shouldParseArrow();
+    shouldParseArrow(params: Array<N.Node>): boolean {
+      return this.match(tt.colon) || super.shouldParseArrow(params);
     }
 
     setArrowFunctionParameters(

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

@@ -2877,6 +2877,17 @@ export default (superClass: Class<Parser>): Class<Parser> =>
       return param;
     }
 
+    isAssignable(node: N.Node, isBinding?: boolean): boolean {
+      switch (node.type) {
+        case "TSTypeCastExpression":
+          return this.isAssignable(node.expression, isBinding);
+        case "TSParameterProperty":
+          return true;
+        default:
+          return super.isAssignable(node, isBinding);
+      }
+    }
+
     toAssignable(node: N.Node, isLHS: boolean = false): N.Node {
       switch (node.type) {
         case "TSTypeCastExpression":
@@ -3071,8 +3082,11 @@ export default (superClass: Class<Parser>): Class<Parser> =>
       return node.expression;
     }
 
-    shouldParseArrow() {
-      return this.match(tt.colon) || super.shouldParseArrow();
+    shouldParseArrow(params: Array<N.Node>) {
+      if (this.match(tt.colon)) {
+        return params.every(expr => this.isAssignable(expr, true));
+      }
+      return super.shouldParseArrow(params);
     }
 
     shouldParseAsyncArrow(): boolean {