Factor out overridable parseNewArguments to replace parseNewTypeArgum…

…ents

src/parser/expression.js

@@ -793,26 +793,22 @@ export default class ExpressionParser extends LValParser {
     }
 
     node.callee = this.parseNoCallExpr();
-    const optional = this.eat(tt.questionDot);
-
-    this.parseNewTypeArguments(node);
+    if (this.eat(tt.questionDot)) node.optional = true;
+    this.parseNewArguments(node);
+    return this.finishNode(node, "NewExpression");
+  }
 
+  parseNewArguments(node: N.NewExpression): void {
     if (this.eat(tt.parenL)) {
-      node.arguments = this.parseExprList(tt.parenR);
-      this.toReferencedList(node.arguments);
+      const args = this.parseExprList(tt.parenR);
+      this.toReferencedList(args);
+      // $FlowFixMe (parseExprList should be all non-null in this case)
+      node.arguments = args;
     } else {
       node.arguments = [];
     }
-    if (optional) {
-      node.optional = true;
-    }
-
-    return this.finishNode(node, "NewExpression");
   }
 
-  // eslint-disable-next-line no-unused-vars
-  parseNewTypeArguments(node: N.NewExpression) {}
-
   // Parse template expression.
 
   parseTemplateElement(isTagged: boolean): N.TemplateElement {

src/plugins/typescript.js

@@ -1147,16 +1147,16 @@ export default (superClass: Class<Parser>): Class<Parser> => class extends super
     return super.parseSubscript(base, startPos, startLoc, noCalls, state);
   }
 
-  parseNewTypeArguments(node: N.NewExpression): void {
-    if (!this.isRelational("<")) { // tsTryParseAndCatch is expensive, so avoid if not necessary.
-      return;
+  parseNewArguments(node: N.NewExpression): void {
+    if (this.isRelational("<")) { // tsTryParseAndCatch is expensive, so avoid if not necessary.
+      // 99% certain this is `new C<T>();`. But may be `new C < T;`, which is also legal.
+      const typeParameters = this.tsTryParseAndCatch(this.tsParseTypeArguments.bind(this));
+      if (typeParameters) {
+        node.typeParameters = typeParameters;
+      }
     }
 
-    // 99% certain this is `new C<T>();`. But may be `new C < T;`, which is also legal.
-    const typeParameters = this.tsTryParseAndCatch(this.tsParseTypeArguments.bind(this));
-    if (typeParameters) {
-      node.typeParameters = typeParameters;
-    }
+    super.parseNewArguments(node);
   }
 
   parseExprOp(

src/types.js

@@ -487,6 +487,7 @@ export type CallExpression = CallOrNewBase & {
 
 export type NewExpression = CallOrNewBase & {
   type: "NewExpression";
+  optional?: boolean; // TODO: Not in spec
 };
 
 export type SequenceExpression = NodeBase & {