Port all babel-parser changes from 2018-10-01 to 2018-11-09

src/parser/plugins/flow.ts

@@ -453,6 +453,13 @@ function flowParseObjectType(allowStatic: boolean, allowExact: boolean, allowPro
 function flowParseObjectTypeProperty(): void {
   if (match(tt.ellipsis)) {
     expect(tt.ellipsis);
+    if (!eat(tt.comma)) {
+      eat(tt.semi);
+    }
+    // Explicit inexact object syntax.
+    if (match(tt.braceR)) {
+      return;
+    }
     flowParseType();
   } else {
     flowParseObjectPropertyKey();

src/parser/plugins/typescript.ts

@@ -28,6 +28,7 @@ import {
 } from "../traverser/expression";
 import {parseBindingList} from "../traverser/lval";
 import {
+  baseParseMaybeDecoratorArguments,
   parseBlockBody,
   parseClass,
   parseClassProperty,
@@ -418,12 +419,23 @@ function tsParseMappedType(): void {
 function tsParseTupleType(): void {
   tsParseBracketedList(
     ParsingContext.TupleElementTypes,
-    tsParseType,
+    tsParseTupleElementType,
     /* bracket */ true,
     /* skipFirstToken */ false,
   );
 }
 
+function tsParseTupleElementType(): void {
+  // parses `...TsType[]`
+  if (eat(tt.ellipsis)) {
+    tsParseType();
+    return;
+  }
+  // parses `TsType?`
+  tsParseType();
+  eat(tt.question);
+}
+
 function tsParseParenthesizedType(): void {
   expect(tt.parenL);
   tsParseType();
@@ -1402,3 +1414,10 @@ export function tsParseAssignableListItemTypes(): void {
   tsTryParseTypeAnnotation();
   popTypeContext(oldIsType);
 }
+
+export function tsParseMaybeDecoratorArguments(): void {
+  if (match(tt.lessThan)) {
+    tsParseTypeArguments();
+  }
+  baseParseMaybeDecoratorArguments();
+}

src/parser/traverser/expression.ts

@@ -449,7 +449,12 @@ export function parseExprAtom(): boolean {
         next();
         parseFunction(functionStart, false, false);
         return false;
-      } else if (canBeArrow && contextualKeyword === ContextualKeyword._async && match(tt.name)) {
+      } else if (
+        canBeArrow &&
+        !canInsertSemicolon() &&
+        contextualKeyword === ContextualKeyword._async &&
+        match(tt.name)
+      ) {
         parseIdentifier();
         expect(tt.arrow);
         // let foo = bar => {};

src/parser/traverser/statement.ts

@@ -25,6 +25,7 @@ import {
   tsParseExportDeclaration,
   tsParseIdentifierStatement,
   tsParseImportEqualsDeclaration,
+  tsParseMaybeDecoratorArguments,
   tsStartParseFunctionParams,
   tsTryParseClassMemberWithIsStatic,
   tsTryParseExport,
@@ -243,6 +244,18 @@ function parseDecorator(): void {
       parseIdentifier();
     }
   }
+  parseMaybeDecoratorArguments();
+}
+
+function parseMaybeDecoratorArguments(): void {
+  if (isTypeScriptEnabled) {
+    tsParseMaybeDecoratorArguments();
+  } else {
+    baseParseMaybeDecoratorArguments();
+  }
+}
+
+export function baseParseMaybeDecoratorArguments(): void {
   if (eat(tt.parenL)) {
     parseCallExpressionArguments(tt.parenR);
   }

test/flow-test.ts

@@ -328,4 +328,55 @@ describe("transform flow", () => {
     `,
     );
   });
+
+  it("allows explicit inexact types", () => {
+    assertFlowResult(
+      `
+      type T = {...};
+      type U = {x: number, ...};
+      type V = {x: number, ...V, ...U};
+    `,
+      `"use strict";
+
+
+
+    `,
+    );
+  });
+
+  it("allows function types as type parameters", () => {
+    assertFlowResult(
+      `
+      type T = Array<(string) => number> 
+    `,
+      `"use strict";
+
+    `,
+    );
+  });
+
+  it("allows underscore type arguments in invocations", () => {
+    assertFlowResult(
+      `
+      test<
+        _,
+        _,
+        number,
+        _,
+        _,
+      >();
+      new test<_>(); 
+    `,
+      `"use strict";
+      test
+
+
+
+
+
+();
+      new test(); 
+    `,
+    );
+  });
 });

test/sucrase-test.ts

@@ -629,4 +629,78 @@ describe("sucrase", () => {
       {transforms: ["imports", "typescript"]},
     );
   });
+
+  it("allows a class expression followed by a division operator", () => {
+    assertResult(
+      `
+      x = class {} / foo
+    `,
+      `
+      x = class {} / foo
+    `,
+      {transforms: []},
+    );
+  });
+
+  it("handles newline after async in paren-less arrow function", () => {
+    assertResult(
+      `
+      import async from 'foo';
+      async
+      x => x
+    `,
+      `"use strict";${IMPORT_DEFAULT_PREFIX}
+      var _foo = require('foo'); var _foo2 = _interopRequireDefault(_foo);
+      _foo2.default
+      x => x
+    `,
+      {transforms: ["imports"]},
+    );
+  });
+
+  it("handles various parser edge cases around regexes", () => {
+    assertResult(
+      `
+      for (const {a} of /b/) {}
+
+      for (let {a} of /b/) {}
+
+      for (var {a} of /b/) {}
+
+      function *f() { yield
+      {}/1/g
+      }
+
+      function* bar() { yield class {} }
+
+      <>
+      <Select prop={{ function: 'test' }} />
+      <Select prop={{ class: 'test' }} />
+      <Select prop={{ delete: 'test' }} />
+      <Select prop={{ enum: 'test' }} />
+      </>
+    `,
+      `const _jsxFileName = "";
+      for (const {a} of /b/) {}
+
+      for (let {a} of /b/) {}
+
+      for (var {a} of /b/) {}
+
+      function *f() { yield
+      {}/1/g
+      }
+
+      function* bar() { yield class {} }
+
+      React.createElement(React.Fragment, null
+      , React.createElement(Select, { prop: { function: 'test' }, __self: this, __source: {fileName: _jsxFileName, lineNumber: 15}} )
+      , React.createElement(Select, { prop: { class: 'test' }, __self: this, __source: {fileName: _jsxFileName, lineNumber: 16}} )
+      , React.createElement(Select, { prop: { delete: 'test' }, __self: this, __source: {fileName: _jsxFileName, lineNumber: 17}} )
+      , React.createElement(Select, { prop: { enum: 'test' }, __self: this, __source: {fileName: _jsxFileName, lineNumber: 18}} )
+      )
+    `,
+      {transforms: ["jsx"]},
+    );
+  });
 });

test/typescript-test.ts

@@ -1203,4 +1203,39 @@ describe("typescript transform", () => {
     `,
     );
   });
+
+  it("parses type arguments on decorators", () => {
+    assertTypeScriptResult(
+      `
+      @decorator<string>()
+      class Test {}
+    `,
+      `"use strict";
+      @decorator()
+      class Test {}
+    `,
+    );
+  });
+
+  it("properly parses tuple types with optional values", () => {
+    assertTypeScriptResult(
+      `
+      let x: [string, number?, (string | number)?];
+    `,
+      `"use strict";
+      let x;
+    `,
+    );
+  });
+
+  it("allows a rest element on a tuple type", () => {
+    assertTypeScriptResult(
+      `
+      let x: [string, ...number[]];
+    `,
+      `"use strict";
+      let x;
+    `,
+    );
+  });
 });