From ae154c86edd9dfed4337b4079e8a03b3e0f3ef0e Mon Sep 17 00:00:00 2001
From: Daniel Tschinder <daniel@tschinder.de>
Date: Tue, 15 Jan 2019 00:03:39 -0800
Subject: [PATCH 01/21] perf: Minor optimizations

---
 packages/babel-parser/src/tokenizer/index.js | 39 +++++++++++++-------
 1 file changed, 25 insertions(+), 14 deletions(-)

diff --git a/packages/babel-parser/src/tokenizer/index.js b/packages/babel-parser/src/tokenizer/index.js
index 368ffb6866..3a7312b486 100644
--- a/packages/babel-parser/src/tokenizer/index.js
+++ b/packages/babel-parser/src/tokenizer/index.js
@@ -311,6 +311,11 @@ export default class Tokenizer extends LocationParser {
     loop: while (this.state.pos < this.input.length) {
       const ch = this.input.charCodeAt(this.state.pos);
       switch (ch) {
+        case charCodes.space:
+        case charCodes.nonBreakingSpace:
+        case charCodes.tab:
+          ++this.state.pos;
+          break;
         case charCodes.carriageReturn:
           if (
             this.input.charCodeAt(this.state.pos + 1) === charCodes.lineFeed
@@ -651,10 +656,6 @@ export default class Tokenizer extends LocationParser {
 
   getTokenFromCode(code: number): void {
     switch (code) {
-      case charCodes.numberSign:
-        this.readToken_numberSign();
-        return;
-
       // The interpretation of a dot depends on whether it is followed
       // by a digit or another two dots.
 
@@ -720,10 +721,6 @@ export default class Tokenizer extends LocationParser {
       case charCodes.questionMark:
         this.readToken_question();
         return;
-      case charCodes.atSign:
-        ++this.state.pos;
-        this.finishToken(tt.at);
-        return;
 
       case charCodes.graveAccent:
         ++this.state.pos;
@@ -809,6 +806,15 @@ export default class Tokenizer extends LocationParser {
       case charCodes.tilde:
         this.finishOp(tt.tilde, 1);
         return;
+
+      case charCodes.atSign:
+        ++this.state.pos;
+        this.finishToken(tt.at);
+        return;
+
+      case charCodes.numberSign:
+        this.readToken_numberSign();
+        return;
     }
 
     this.raise(
@@ -1266,10 +1272,11 @@ export default class Tokenizer extends LocationParser {
   // as a micro-optimization.
 
   readWord1(): string {
+    let word = "";
     this.state.containsEsc = false;
-    let word = "",
-      first = true,
-      chunkStart = this.state.pos;
+    const start = this.state.pos;
+    let chunkStart = this.state.pos;
+
     while (this.state.pos < this.input.length) {
       const ch = this.input.codePointAt(this.state.pos);
       if (isIdentifierChar(ch)) {
@@ -1281,6 +1288,8 @@ export default class Tokenizer extends LocationParser {
 
         word += this.input.slice(chunkStart, this.state.pos);
         const escStart = this.state.pos;
+        const identifierCheck =
+          this.state.pos === start ? isIdentifierStart : isIdentifierChar;
 
         if (this.input.charCodeAt(++this.state.pos) !== charCodes.lowercaseU) {
           this.raise(
@@ -1291,8 +1300,11 @@ export default class Tokenizer extends LocationParser {
 
         ++this.state.pos;
         const esc = this.readCodePoint(true);
-        // $FlowFixMe (thinks esc may be null, but throwOnInvalid is true)
-        if (!(first ? isIdentifierStart : isIdentifierChar)(esc, true)) {
+
+        if (
+          // $FlowFixMe (thinks esc may be null, but throwOnInvalid is true)
+          !identifierCheck(esc, true)
+        ) {
           this.raise(escStart, "Invalid Unicode escape");
         }
 
@@ -1302,7 +1314,6 @@ export default class Tokenizer extends LocationParser {
       } else {
         break;
       }
-      first = false;
     }
     return word + this.input.slice(chunkStart, this.state.pos);
   }

From 2dc1c91955791eac031bdd2eaa79e8f2338ce14e Mon Sep 17 00:00:00 2001
From: Daniel Tschinder <daniel@tschinder.de>
Date: Tue, 15 Jan 2019 12:45:36 -0800
Subject: [PATCH 02/21] perf: Move input to state and precalculate length

This also fixes a bug with async functions
---
 packages/babel-parser/src/parser/base.js      |   1 -
 .../babel-parser/src/parser/expression.js     |  11 +-
 packages/babel-parser/src/parser/index.js     |   1 -
 packages/babel-parser/src/parser/location.js  |   2 +-
 packages/babel-parser/src/parser/statement.js |  10 +-
 packages/babel-parser/src/parser/util.js      |   2 +-
 packages/babel-parser/src/plugins/flow.js     |  20 +-
 .../babel-parser/src/plugins/jsx/index.js     |  34 +--
 .../babel-parser/src/tokenizer/context.js     |   4 +-
 packages/babel-parser/src/tokenizer/index.js  | 197 ++++++++++--------
 packages/babel-parser/src/tokenizer/state.js  |   2 +
 .../export-invalid/options.json               |   2 +-
 12 files changed, 160 insertions(+), 126 deletions(-)

diff --git a/packages/babel-parser/src/parser/base.js b/packages/babel-parser/src/parser/base.js
index 7c84857752..96fd7fed83 100644
--- a/packages/babel-parser/src/parser/base.js
+++ b/packages/babel-parser/src/parser/base.js
@@ -16,7 +16,6 @@ export default class BaseParser {
 
   // Initialized by Tokenizer
   state: State;
-  input: string;
 
   isReservedWord(word: string): boolean {
     if (word === "await") {
diff --git a/packages/babel-parser/src/parser/expression.js b/packages/babel-parser/src/parser/expression.js
index fb390e1361..12174c78f3 100644
--- a/packages/babel-parser/src/parser/expression.js
+++ b/packages/babel-parser/src/parser/expression.js
@@ -1146,7 +1146,11 @@ export default class ExpressionParser extends LValParser {
 
     const node = this.startNodeAt(startPos, startLoc);
     this.addExtra(node, "rawValue", value);
-    this.addExtra(node, "raw", this.input.slice(startPos, this.state.end));
+    this.addExtra(
+      node,
+      "raw",
+      this.state.input.slice(startPos, this.state.end),
+    );
     node.value = value;
     this.next();
     return this.finishNode(node, type);
@@ -1365,7 +1369,7 @@ export default class ExpressionParser extends LValParser {
       }
     }
     elem.value = {
-      raw: this.input
+      raw: this.state.input
         .slice(this.state.start, this.state.end)
         .replace(/\r\n?/g, "\n"),
       cooked: this.state.value,
@@ -1967,7 +1971,8 @@ export default class ExpressionParser extends LValParser {
       if (
         (name === "class" || name === "function") &&
         (this.state.lastTokEnd !== this.state.lastTokStart + 1 ||
-          this.input.charCodeAt(this.state.lastTokStart) !== charCodes.dot)
+          this.state.input.charCodeAt(this.state.lastTokStart) !==
+            charCodes.dot)
       ) {
         this.state.context.pop();
       }
diff --git a/packages/babel-parser/src/parser/index.js b/packages/babel-parser/src/parser/index.js
index 6d6d9cfd8b..35e7e01f6c 100644
--- a/packages/babel-parser/src/parser/index.js
+++ b/packages/babel-parser/src/parser/index.js
@@ -22,7 +22,6 @@ export default class Parser extends StatementParser {
 
     this.options = options;
     this.inModule = this.options.sourceType === "module";
-    this.input = input;
     this.plugins = pluginsMap(this.options.plugins);
     this.filename = options.sourceFilename;
   }
diff --git a/packages/babel-parser/src/parser/location.js b/packages/babel-parser/src/parser/location.js
index 79db584a49..f73724004b 100644
--- a/packages/babel-parser/src/parser/location.js
+++ b/packages/babel-parser/src/parser/location.js
@@ -21,7 +21,7 @@ export default class LocationParser extends CommentsParser {
       code?: string,
     } = {},
   ): empty {
-    const loc = getLineInfo(this.input, pos);
+    const loc = getLineInfo(this.state.input, pos);
     message += ` (${loc.line}:${loc.column})`;
     // $FlowIgnore
     const err: SyntaxError & { pos: number, loc: Position } = new SyntaxError(
diff --git a/packages/babel-parser/src/parser/statement.js b/packages/babel-parser/src/parser/statement.js
index a024411140..6f17c54709 100644
--- a/packages/babel-parser/src/parser/statement.js
+++ b/packages/babel-parser/src/parser/statement.js
@@ -44,7 +44,7 @@ export default class StatementParser extends ExpressionParser {
     const directiveLiteral = this.startNodeAt(expr.start, expr.loc.start);
     const directive = this.startNodeAt(stmt.start, stmt.loc.start);
 
-    const raw = this.input.slice(expr.start, expr.end);
+    const raw = this.state.input.slice(expr.start, expr.end);
     const val = (directiveLiteral.value = raw.slice(1, -1)); // remove quotes
 
     this.addExtra(directiveLiteral, "raw", raw);
@@ -551,7 +551,9 @@ export default class StatementParser extends ExpressionParser {
   parseThrowStatement(node: N.ThrowStatement): N.ThrowStatement {
     this.next();
     if (
-      lineBreak.test(this.input.slice(this.state.lastTokEnd, this.state.start))
+      lineBreak.test(
+        this.state.input.slice(this.state.lastTokEnd, this.state.start),
+      )
     ) {
       this.raise(this.state.lastTokEnd, "Illegal newline after throw");
     }
@@ -1521,7 +1523,7 @@ export default class StatementParser extends ExpressionParser {
   isAsyncFunction() {
     if (!this.isContextual("async")) return false;
 
-    const { input, pos } = this.state;
+    const { input, pos, length } = this.state;
 
     skipWhiteSpace.lastIndex = pos;
     const skip = skipWhiteSpace.exec(input);
@@ -1533,7 +1535,7 @@ export default class StatementParser extends ExpressionParser {
     return (
       !lineBreak.test(input.slice(pos, next)) &&
       input.slice(next, next + 8) === "function" &&
-      (next + 8 === input.length || !isIdentifierChar(input.charAt(next + 8)))
+      (next + 8 === length || !isIdentifierChar(input.charCodeAt(next + 8)))
     );
   }
 
diff --git a/packages/babel-parser/src/parser/util.js b/packages/babel-parser/src/parser/util.js
index d889982f83..6538ee7f1b 100644
--- a/packages/babel-parser/src/parser/util.js
+++ b/packages/babel-parser/src/parser/util.js
@@ -87,7 +87,7 @@ export default class UtilParser extends Tokenizer {
 
   hasPrecedingLineBreak(): boolean {
     return lineBreak.test(
-      this.input.slice(this.state.lastTokEnd, this.state.start),
+      this.state.input.slice(this.state.lastTokEnd, this.state.start),
     );
   }
 
diff --git a/packages/babel-parser/src/plugins/flow.js b/packages/babel-parser/src/plugins/flow.js
index 8e190929c6..50e4e7fa3c 100644
--- a/packages/babel-parser/src/plugins/flow.js
+++ b/packages/babel-parser/src/plugins/flow.js
@@ -1124,7 +1124,7 @@ export default (superClass: Class<Parser>): Class<Parser> =>
       node.types = [];
       this.expect(tt.bracketL);
       // We allow trailing commas
-      while (this.state.pos < this.input.length && !this.match(tt.bracketR)) {
+      while (this.state.pos < this.state.length && !this.match(tt.bracketR)) {
         node.types.push(this.flowParseType());
         if (this.match(tt.bracketR)) break;
         this.expect(tt.comma);
@@ -1934,7 +1934,7 @@ export default (superClass: Class<Parser>): Class<Parser> =>
 
     // ensure that inside flow types, we bypass the jsx parser plugin
     readToken(code: number): void {
-      const next = this.input.charCodeAt(this.state.pos + 1);
+      const next = this.state.input.charCodeAt(this.state.pos + 1);
       if (
         this.state.inType &&
         (code === charCodes.greaterThan || code === charCodes.lessThan)
@@ -2686,7 +2686,7 @@ export default (superClass: Class<Parser>): Class<Parser> =>
     }
 
     readToken_mult_modulo(code: number): void {
-      const next = this.input.charCodeAt(this.state.pos + 1);
+      const next = this.state.input.charCodeAt(this.state.pos + 1);
       if (
         code === charCodes.asterisk &&
         next === charCodes.slash &&
@@ -2728,7 +2728,7 @@ export default (superClass: Class<Parser>): Class<Parser> =>
       }
 
       if (this.hasPlugin("flow") && this.state.hasFlowComment) {
-        const end = this.input.indexOf("*-/", (this.state.pos += 2));
+        const end = this.state.input.indexOf("*-/", (this.state.pos += 2));
         if (end === -1) this.raise(this.state.pos - 2, "Unterminated comment");
         this.state.pos = end + 3;
         return;
@@ -2742,20 +2742,22 @@ export default (superClass: Class<Parser>): Class<Parser> =>
       let shiftToFirstNonWhiteSpace = 2;
       while (
         [charCodes.space, charCodes.tab].includes(
-          this.input.charCodeAt(pos + shiftToFirstNonWhiteSpace),
+          this.state.input.charCodeAt(pos + shiftToFirstNonWhiteSpace),
         )
       ) {
         shiftToFirstNonWhiteSpace++;
       }
 
-      const ch2 = this.input.charCodeAt(shiftToFirstNonWhiteSpace + pos);
-      const ch3 = this.input.charCodeAt(shiftToFirstNonWhiteSpace + pos + 1);
+      const ch2 = this.state.input.charCodeAt(shiftToFirstNonWhiteSpace + pos);
+      const ch3 = this.state.input.charCodeAt(
+        shiftToFirstNonWhiteSpace + pos + 1,
+      );
 
       if (ch2 === charCodes.colon && ch3 === charCodes.colon) {
         return shiftToFirstNonWhiteSpace + 2; // check for /*::
       }
       if (
-        this.input.slice(
+        this.state.input.slice(
           shiftToFirstNonWhiteSpace + pos,
           shiftToFirstNonWhiteSpace + pos + 12,
         ) === "flow-include"
@@ -2769,7 +2771,7 @@ export default (superClass: Class<Parser>): Class<Parser> =>
     }
 
     hasFlowCommentCompletion(): void {
-      const end = this.input.indexOf("*/", this.state.pos);
+      const end = this.state.input.indexOf("*/", this.state.pos);
       if (end === -1) {
         this.raise(this.state.pos, "Unterminated comment");
       }
diff --git a/packages/babel-parser/src/plugins/jsx/index.js b/packages/babel-parser/src/plugins/jsx/index.js
index 0271aeffed..7a814cfbce 100644
--- a/packages/babel-parser/src/plugins/jsx/index.js
+++ b/packages/babel-parser/src/plugins/jsx/index.js
@@ -79,11 +79,11 @@ export default (superClass: Class<Parser>): Class<Parser> =>
       let out = "";
       let chunkStart = this.state.pos;
       for (;;) {
-        if (this.state.pos >= this.input.length) {
+        if (this.state.pos >= this.state.length) {
           this.raise(this.state.start, "Unterminated JSX contents");
         }
 
-        const ch = this.input.charCodeAt(this.state.pos);
+        const ch = this.state.input.charCodeAt(this.state.pos);
 
         switch (ch) {
           case charCodes.lessThan:
@@ -95,18 +95,18 @@ export default (superClass: Class<Parser>): Class<Parser> =>
               }
               return this.getTokenFromCode(ch);
             }
-            out += this.input.slice(chunkStart, this.state.pos);
+            out += this.state.input.slice(chunkStart, this.state.pos);
             return this.finishToken(tt.jsxText, out);
 
           case charCodes.ampersand:
-            out += this.input.slice(chunkStart, this.state.pos);
+            out += this.state.input.slice(chunkStart, this.state.pos);
             out += this.jsxReadEntity();
             chunkStart = this.state.pos;
             break;
 
           default:
             if (isNewLine(ch)) {
-              out += this.input.slice(chunkStart, this.state.pos);
+              out += this.state.input.slice(chunkStart, this.state.pos);
               out += this.jsxReadNewLine(true);
               chunkStart = this.state.pos;
             } else {
@@ -117,12 +117,12 @@ export default (superClass: Class<Parser>): Class<Parser> =>
     }
 
     jsxReadNewLine(normalizeCRLF: boolean): string {
-      const ch = this.input.charCodeAt(this.state.pos);
+      const ch = this.state.input.charCodeAt(this.state.pos);
       let out;
       ++this.state.pos;
       if (
         ch === charCodes.carriageReturn &&
-        this.input.charCodeAt(this.state.pos) === charCodes.lineFeed
+        this.state.input.charCodeAt(this.state.pos) === charCodes.lineFeed
       ) {
         ++this.state.pos;
         out = normalizeCRLF ? "\n" : "\r\n";
@@ -139,25 +139,25 @@ export default (superClass: Class<Parser>): Class<Parser> =>
       let out = "";
       let chunkStart = ++this.state.pos;
       for (;;) {
-        if (this.state.pos >= this.input.length) {
+        if (this.state.pos >= this.state.length) {
           this.raise(this.state.start, "Unterminated string constant");
         }
 
-        const ch = this.input.charCodeAt(this.state.pos);
+        const ch = this.state.input.charCodeAt(this.state.pos);
         if (ch === quote) break;
         if (ch === charCodes.ampersand) {
-          out += this.input.slice(chunkStart, this.state.pos);
+          out += this.state.input.slice(chunkStart, this.state.pos);
           out += this.jsxReadEntity();
           chunkStart = this.state.pos;
         } else if (isNewLine(ch)) {
-          out += this.input.slice(chunkStart, this.state.pos);
+          out += this.state.input.slice(chunkStart, this.state.pos);
           out += this.jsxReadNewLine(false);
           chunkStart = this.state.pos;
         } else {
           ++this.state.pos;
         }
       }
-      out += this.input.slice(chunkStart, this.state.pos++);
+      out += this.state.input.slice(chunkStart, this.state.pos++);
       return this.finishToken(tt.string, out);
     }
 
@@ -165,11 +165,11 @@ export default (superClass: Class<Parser>): Class<Parser> =>
       let str = "";
       let count = 0;
       let entity;
-      let ch = this.input[this.state.pos];
+      let ch = this.state.input[this.state.pos];
 
       const startPos = ++this.state.pos;
-      while (this.state.pos < this.input.length && count++ < 10) {
-        ch = this.input[this.state.pos++];
+      while (this.state.pos < this.state.length && count++ < 10) {
+        ch = this.state.input[this.state.pos++];
         if (ch === ";") {
           if (str[0] === "#") {
             if (str[1] === "x") {
@@ -208,11 +208,11 @@ export default (superClass: Class<Parser>): Class<Parser> =>
       let ch;
       const start = this.state.pos;
       do {
-        ch = this.input.charCodeAt(++this.state.pos);
+        ch = this.state.input.charCodeAt(++this.state.pos);
       } while (isIdentifierChar(ch) || ch === charCodes.dash);
       return this.finishToken(
         tt.jsxName,
-        this.input.slice(start, this.state.pos),
+        this.state.input.slice(start, this.state.pos),
       );
     }
 
diff --git a/packages/babel-parser/src/tokenizer/context.js b/packages/babel-parser/src/tokenizer/context.js
index 6bb2b94912..6add1a4cf7 100644
--- a/packages/babel-parser/src/tokenizer/context.js
+++ b/packages/babel-parser/src/tokenizer/context.js
@@ -107,7 +107,9 @@ tt._function.updateContext = tt._class.updateContext = function(prevType) {
     prevType !== tt._else &&
     !(
       prevType === tt._return &&
-      lineBreak.test(this.input.slice(this.state.lastTokEnd, this.state.start))
+      lineBreak.test(
+        this.state.input.slice(this.state.lastTokEnd, this.state.start),
+      )
     ) &&
     !(
       (prevType === tt.colon || prevType === tt.braceL) &&
diff --git a/packages/babel-parser/src/tokenizer/index.js b/packages/babel-parser/src/tokenizer/index.js
index 3a7312b486..558cd069cb 100644
--- a/packages/babel-parser/src/tokenizer/index.js
+++ b/packages/babel-parser/src/tokenizer/index.js
@@ -185,7 +185,7 @@ export default class Tokenizer extends LocationParser {
     this.state.pos = this.state.start;
     while (this.state.pos < this.state.lineStart) {
       this.state.lineStart =
-        this.input.lastIndexOf("\n", this.state.lineStart - 2) + 1;
+        this.state.input.lastIndexOf("\n", this.state.lineStart - 2) + 1;
       --this.state.curLine;
     }
     this.nextToken();
@@ -206,7 +206,7 @@ export default class Tokenizer extends LocationParser {
     this.state.octalPosition = null;
     this.state.start = this.state.pos;
     this.state.startLoc = this.state.curPosition();
-    if (this.state.pos >= this.input.length) {
+    if (this.state.pos >= this.state.length) {
       this.finishToken(tt.eof);
       return;
     }
@@ -214,7 +214,7 @@ export default class Tokenizer extends LocationParser {
     if (curContext.override) {
       curContext.override(this);
     } else {
-      this.readToken(this.input.codePointAt(this.state.pos));
+      this.readToken(this.state.input.codePointAt(this.state.pos));
     }
   }
 
@@ -254,14 +254,14 @@ export default class Tokenizer extends LocationParser {
   skipBlockComment(): void {
     const startLoc = this.state.curPosition();
     const start = this.state.pos;
-    const end = this.input.indexOf("*/", (this.state.pos += 2));
+    const end = this.state.input.indexOf("*/", (this.state.pos += 2));
     if (end === -1) this.raise(this.state.pos - 2, "Unterminated comment");
 
     this.state.pos = end + 2;
     lineBreakG.lastIndex = start;
     let match;
     while (
-      (match = lineBreakG.exec(this.input)) &&
+      (match = lineBreakG.exec(this.state.input)) &&
       match.index < this.state.pos
     ) {
       ++this.state.curLine;
@@ -270,7 +270,7 @@ export default class Tokenizer extends LocationParser {
 
     this.pushComment(
       true,
-      this.input.slice(start + 2, end),
+      this.state.input.slice(start + 2, end),
       start,
       this.state.pos,
       startLoc,
@@ -281,22 +281,22 @@ export default class Tokenizer extends LocationParser {
   skipLineComment(startSkip: number): void {
     const start = this.state.pos;
     const startLoc = this.state.curPosition();
-    let ch = this.input.charCodeAt((this.state.pos += startSkip));
-    if (this.state.pos < this.input.length) {
+    let ch = this.state.input.charCodeAt((this.state.pos += startSkip));
+    if (this.state.pos < this.state.length) {
       while (
         ch !== charCodes.lineFeed &&
         ch !== charCodes.carriageReturn &&
         ch !== charCodes.lineSeparator &&
         ch !== charCodes.paragraphSeparator &&
-        ++this.state.pos < this.input.length
+        ++this.state.pos < this.state.length
       ) {
-        ch = this.input.charCodeAt(this.state.pos);
+        ch = this.state.input.charCodeAt(this.state.pos);
       }
     }
 
     this.pushComment(
       false,
-      this.input.slice(start + startSkip, this.state.pos),
+      this.state.input.slice(start + startSkip, this.state.pos),
       start,
       this.state.pos,
       startLoc,
@@ -308,8 +308,8 @@ export default class Tokenizer extends LocationParser {
   // whitespace and comments, and.
 
   skipSpace(): void {
-    loop: while (this.state.pos < this.input.length) {
-      const ch = this.input.charCodeAt(this.state.pos);
+    loop: while (this.state.pos < this.state.length) {
+      const ch = this.state.input.charCodeAt(this.state.pos);
       switch (ch) {
         case charCodes.space:
         case charCodes.nonBreakingSpace:
@@ -318,7 +318,8 @@ export default class Tokenizer extends LocationParser {
           break;
         case charCodes.carriageReturn:
           if (
-            this.input.charCodeAt(this.state.pos + 1) === charCodes.lineFeed
+            this.state.input.charCodeAt(this.state.pos + 1) ===
+            charCodes.lineFeed
           ) {
             ++this.state.pos;
           }
@@ -332,7 +333,7 @@ export default class Tokenizer extends LocationParser {
           break;
 
         case charCodes.slash:
-          switch (this.input.charCodeAt(this.state.pos + 1)) {
+          switch (this.state.input.charCodeAt(this.state.pos + 1)) {
             case charCodes.asterisk:
               this.skipBlockComment();
               break;
@@ -387,7 +388,7 @@ export default class Tokenizer extends LocationParser {
     }
 
     const nextPos = this.state.pos + 1;
-    const next = this.input.charCodeAt(nextPos);
+    const next = this.state.input.charCodeAt(nextPos);
     if (next >= charCodes.digit0 && next <= charCodes.digit9) {
       this.raise(this.state.pos, "Unexpected digit after hash token");
     }
@@ -410,13 +411,13 @@ export default class Tokenizer extends LocationParser {
   }
 
   readToken_dot(): void {
-    const next = this.input.charCodeAt(this.state.pos + 1);
+    const next = this.state.input.charCodeAt(this.state.pos + 1);
     if (next >= charCodes.digit0 && next <= charCodes.digit9) {
       this.readNumber(true);
       return;
     }
 
-    const next2 = this.input.charCodeAt(this.state.pos + 2);
+    const next2 = this.state.input.charCodeAt(this.state.pos + 2);
     if (next === charCodes.dot && next2 === charCodes.dot) {
       this.state.pos += 3;
       this.finishToken(tt.ellipsis);
@@ -434,7 +435,7 @@ export default class Tokenizer extends LocationParser {
       return;
     }
 
-    const next = this.input.charCodeAt(this.state.pos + 1);
+    const next = this.state.input.charCodeAt(this.state.pos + 1);
     if (next === charCodes.equalsTo) {
       this.finishOp(tt.assign, 2);
     } else {
@@ -443,12 +444,12 @@ export default class Tokenizer extends LocationParser {
   }
 
   readToken_interpreter(): boolean {
-    if (this.state.pos !== 0 || this.state.input.length < 2) return false;
+    if (this.state.pos !== 0 || this.state.length < 2) return false;
 
     const start = this.state.pos;
     this.state.pos += 1;
 
-    let ch = this.input.charCodeAt(this.state.pos);
+    let ch = this.state.input.charCodeAt(this.state.pos);
     if (ch !== charCodes.exclamationMark) return false;
 
     while (
@@ -456,12 +457,12 @@ export default class Tokenizer extends LocationParser {
       ch !== charCodes.carriageReturn &&
       ch !== charCodes.lineSeparator &&
       ch !== charCodes.paragraphSeparator &&
-      ++this.state.pos < this.input.length
+      ++this.state.pos < this.state.length
     ) {
-      ch = this.input.charCodeAt(this.state.pos);
+      ch = this.state.input.charCodeAt(this.state.pos);
     }
 
-    const value = this.input.slice(start + 2, this.state.pos);
+    const value = this.state.input.slice(start + 2, this.state.pos);
 
     this.finishToken(tt.interpreterDirective, value);
 
@@ -472,13 +473,13 @@ export default class Tokenizer extends LocationParser {
     // '%*'
     let type = code === charCodes.asterisk ? tt.star : tt.modulo;
     let width = 1;
-    let next = this.input.charCodeAt(this.state.pos + 1);
+    let next = this.state.input.charCodeAt(this.state.pos + 1);
     const exprAllowed = this.state.exprAllowed;
 
     // Exponentiation operator **
     if (code === charCodes.asterisk && next === charCodes.asterisk) {
       width++;
-      next = this.input.charCodeAt(this.state.pos + 2);
+      next = this.state.input.charCodeAt(this.state.pos + 2);
       type = tt.exponent;
     }
 
@@ -492,10 +493,12 @@ export default class Tokenizer extends LocationParser {
 
   readToken_pipe_amp(code: number): void {
     // '|&'
-    const next = this.input.charCodeAt(this.state.pos + 1);
+    const next = this.state.input.charCodeAt(this.state.pos + 1);
 
     if (next === code) {
-      if (this.input.charCodeAt(this.state.pos + 2) === charCodes.equalsTo) {
+      if (
+        this.state.input.charCodeAt(this.state.pos + 2) === charCodes.equalsTo
+      ) {
         this.finishOp(tt.assign, 3);
       } else {
         this.finishOp(
@@ -531,7 +534,7 @@ export default class Tokenizer extends LocationParser {
 
   readToken_caret(): void {
     // '^'
-    const next = this.input.charCodeAt(this.state.pos + 1);
+    const next = this.state.input.charCodeAt(this.state.pos + 1);
     if (next === charCodes.equalsTo) {
       this.finishOp(tt.assign, 2);
     } else {
@@ -541,14 +544,17 @@ export default class Tokenizer extends LocationParser {
 
   readToken_plus_min(code: number): void {
     // '+-'
-    const next = this.input.charCodeAt(this.state.pos + 1);
+    const next = this.state.input.charCodeAt(this.state.pos + 1);
 
     if (next === code) {
       if (
         next === charCodes.dash &&
         !this.inModule &&
-        this.input.charCodeAt(this.state.pos + 2) === charCodes.greaterThan &&
-        lineBreak.test(this.input.slice(this.state.lastTokEnd, this.state.pos))
+        this.state.input.charCodeAt(this.state.pos + 2) ===
+          charCodes.greaterThan &&
+        lineBreak.test(
+          this.state.input.slice(this.state.lastTokEnd, this.state.pos),
+        )
       ) {
         // A `-->` line comment
         this.skipLineComment(3);
@@ -569,16 +575,20 @@ export default class Tokenizer extends LocationParser {
 
   readToken_lt_gt(code: number): void {
     // '<>'
-    const next = this.input.charCodeAt(this.state.pos + 1);
+    const next = this.state.input.charCodeAt(this.state.pos + 1);
     let size = 1;
 
     if (next === code) {
       size =
         code === charCodes.greaterThan &&
-        this.input.charCodeAt(this.state.pos + 2) === charCodes.greaterThan
+        this.state.input.charCodeAt(this.state.pos + 2) ===
+          charCodes.greaterThan
           ? 3
           : 2;
-      if (this.input.charCodeAt(this.state.pos + size) === charCodes.equalsTo) {
+      if (
+        this.state.input.charCodeAt(this.state.pos + size) ===
+        charCodes.equalsTo
+      ) {
         this.finishOp(tt.assign, size + 1);
         return;
       }
@@ -590,8 +600,8 @@ export default class Tokenizer extends LocationParser {
       next === charCodes.exclamationMark &&
       code === charCodes.lessThan &&
       !this.inModule &&
-      this.input.charCodeAt(this.state.pos + 2) === charCodes.dash &&
-      this.input.charCodeAt(this.state.pos + 3) === charCodes.dash
+      this.state.input.charCodeAt(this.state.pos + 2) === charCodes.dash &&
+      this.state.input.charCodeAt(this.state.pos + 3) === charCodes.dash
     ) {
       // `<!--`, an XML-style comment that should be interpreted as a line comment
       this.skipLineComment(4);
@@ -610,11 +620,11 @@ export default class Tokenizer extends LocationParser {
 
   readToken_eq_excl(code: number): void {
     // '=!'
-    const next = this.input.charCodeAt(this.state.pos + 1);
+    const next = this.state.input.charCodeAt(this.state.pos + 1);
     if (next === charCodes.equalsTo) {
       this.finishOp(
         tt.equality,
-        this.input.charCodeAt(this.state.pos + 2) === charCodes.equalsTo
+        this.state.input.charCodeAt(this.state.pos + 2) === charCodes.equalsTo
           ? 3
           : 2,
       );
@@ -631,8 +641,8 @@ export default class Tokenizer extends LocationParser {
 
   readToken_question(): void {
     // '?'
-    const next = this.input.charCodeAt(this.state.pos + 1);
-    const next2 = this.input.charCodeAt(this.state.pos + 2);
+    const next = this.state.input.charCodeAt(this.state.pos + 1);
+    const next2 = this.state.input.charCodeAt(this.state.pos + 2);
     if (next === charCodes.questionMark && !this.state.inType) {
       if (next2 === charCodes.equalsTo) {
         // '??='
@@ -692,7 +702,8 @@ export default class Tokenizer extends LocationParser {
       case charCodes.leftCurlyBrace:
         if (
           this.hasPlugin("flow") &&
-          this.input.charCodeAt(this.state.pos + 1) === charCodes.verticalBar
+          this.state.input.charCodeAt(this.state.pos + 1) ===
+            charCodes.verticalBar
         ) {
           this.finishOp(tt.braceBarL, 2);
         } else {
@@ -709,7 +720,7 @@ export default class Tokenizer extends LocationParser {
       case charCodes.colon:
         if (
           this.hasPlugin("functionBind") &&
-          this.input.charCodeAt(this.state.pos + 1) === charCodes.colon
+          this.state.input.charCodeAt(this.state.pos + 1) === charCodes.colon
         ) {
           this.finishOp(tt.doubleColon, 2);
         } else {
@@ -728,7 +739,7 @@ export default class Tokenizer extends LocationParser {
         return;
 
       case charCodes.digit0: {
-        const next = this.input.charCodeAt(this.state.pos + 1);
+        const next = this.state.input.charCodeAt(this.state.pos + 1);
         // '0x', '0X' - hex number
         if (next === charCodes.lowercaseX || next === charCodes.uppercaseX) {
           this.readRadixNumber(16);
@@ -824,7 +835,7 @@ export default class Tokenizer extends LocationParser {
   }
 
   finishOp(type: TokenType, size: number): void {
-    const str = this.input.slice(this.state.pos, this.state.pos + size);
+    const str = this.state.input.slice(this.state.pos, this.state.pos + size);
     this.state.pos += size;
     this.finishToken(type, str);
   }
@@ -833,10 +844,10 @@ export default class Tokenizer extends LocationParser {
     const start = this.state.pos;
     let escaped, inClass;
     for (;;) {
-      if (this.state.pos >= this.input.length) {
+      if (this.state.pos >= this.state.length) {
         this.raise(start, "Unterminated regular expression");
       }
-      const ch = this.input.charAt(this.state.pos);
+      const ch = this.state.input.charAt(this.state.pos);
       if (lineBreak.test(ch)) {
         this.raise(start, "Unterminated regular expression");
       }
@@ -854,14 +865,14 @@ export default class Tokenizer extends LocationParser {
       }
       ++this.state.pos;
     }
-    const content = this.input.slice(start, this.state.pos);
+    const content = this.state.input.slice(start, this.state.pos);
     ++this.state.pos;
 
     let mods = "";
 
-    while (this.state.pos < this.input.length) {
-      const char = this.input[this.state.pos];
-      const charCode = this.input.codePointAt(this.state.pos);
+    while (this.state.pos < this.state.length) {
+      const char = this.state.input[this.state.pos];
+      const charCode = this.state.input.codePointAt(this.state.pos);
 
       if (VALID_REGEX_FLAGS.indexOf(char) > -1) {
         if (mods.indexOf(char) > -1) {
@@ -908,12 +919,12 @@ export default class Tokenizer extends LocationParser {
     let total = 0;
 
     for (let i = 0, e = len == null ? Infinity : len; i < e; ++i) {
-      const code = this.input.charCodeAt(this.state.pos);
+      const code = this.state.input.charCodeAt(this.state.pos);
       let val;
 
       if (this.hasPlugin("numericSeparator")) {
-        const prev = this.input.charCodeAt(this.state.pos - 1);
-        const next = this.input.charCodeAt(this.state.pos + 1);
+        const prev = this.state.input.charCodeAt(this.state.pos - 1);
+        const next = this.state.input.charCodeAt(this.state.pos + 1);
         if (code === charCodes.underscore) {
           if (allowedSiblings.indexOf(next) === -1) {
             this.raise(this.state.pos, "Invalid or unexpected token");
@@ -967,18 +978,22 @@ export default class Tokenizer extends LocationParser {
     }
 
     if (this.hasPlugin("bigInt")) {
-      if (this.input.charCodeAt(this.state.pos) === charCodes.lowercaseN) {
+      if (
+        this.state.input.charCodeAt(this.state.pos) === charCodes.lowercaseN
+      ) {
         ++this.state.pos;
         isBigInt = true;
       }
     }
 
-    if (isIdentifierStart(this.input.codePointAt(this.state.pos))) {
+    if (isIdentifierStart(this.state.input.codePointAt(this.state.pos))) {
       this.raise(this.state.pos, "Identifier directly after number");
     }
 
     if (isBigInt) {
-      const str = this.input.slice(start, this.state.pos).replace(/[_n]/g, "");
+      const str = this.state.input
+        .slice(start, this.state.pos)
+        .replace(/[_n]/g, "");
       this.finishToken(tt.bigint, str);
       return;
     }
@@ -998,7 +1013,7 @@ export default class Tokenizer extends LocationParser {
     }
     let octal =
       this.state.pos - start >= 2 &&
-      this.input.charCodeAt(start) === charCodes.digit0;
+      this.state.input.charCodeAt(start) === charCodes.digit0;
     if (octal) {
       if (this.state.strict) {
         this.raise(
@@ -1006,30 +1021,30 @@ export default class Tokenizer extends LocationParser {
           "Legacy octal literals are not allowed in strict mode",
         );
       }
-      if (/[89]/.test(this.input.slice(start, this.state.pos))) {
+      if (/[89]/.test(this.state.input.slice(start, this.state.pos))) {
         octal = false;
       }
     }
 
-    let next = this.input.charCodeAt(this.state.pos);
+    let next = this.state.input.charCodeAt(this.state.pos);
     if (next === charCodes.dot && !octal) {
       ++this.state.pos;
       this.readInt(10);
       isFloat = true;
-      next = this.input.charCodeAt(this.state.pos);
+      next = this.state.input.charCodeAt(this.state.pos);
     }
 
     if (
       (next === charCodes.uppercaseE || next === charCodes.lowercaseE) &&
       !octal
     ) {
-      next = this.input.charCodeAt(++this.state.pos);
+      next = this.state.input.charCodeAt(++this.state.pos);
       if (next === charCodes.plusSign || next === charCodes.dash) {
         ++this.state.pos;
       }
       if (this.readInt(10) === null) this.raise(start, "Invalid number");
       isFloat = true;
-      next = this.input.charCodeAt(this.state.pos);
+      next = this.state.input.charCodeAt(this.state.pos);
     }
 
     if (this.hasPlugin("bigInt")) {
@@ -1041,12 +1056,14 @@ export default class Tokenizer extends LocationParser {
       }
     }
 
-    if (isIdentifierStart(this.input.codePointAt(this.state.pos))) {
+    if (isIdentifierStart(this.state.input.codePointAt(this.state.pos))) {
       this.raise(this.state.pos, "Identifier directly after number");
     }
 
     // remove "_" for numeric literal separator, and "n" for BigInts
-    const str = this.input.slice(start, this.state.pos).replace(/[_n]/g, "");
+    const str = this.state.input
+      .slice(start, this.state.pos)
+      .replace(/[_n]/g, "");
 
     if (isBigInt) {
       this.finishToken(tt.bigint, str);
@@ -1060,13 +1077,13 @@ export default class Tokenizer extends LocationParser {
   // Read a string value, interpreting backslash-escapes.
 
   readCodePoint(throwOnInvalid: boolean): number | null {
-    const ch = this.input.charCodeAt(this.state.pos);
+    const ch = this.state.input.charCodeAt(this.state.pos);
     let code;
 
     if (ch === charCodes.leftCurlyBrace) {
       const codePos = ++this.state.pos;
       code = this.readHexChar(
-        this.input.indexOf("}", this.state.pos) - this.state.pos,
+        this.state.input.indexOf("}", this.state.pos) - this.state.pos,
         throwOnInvalid,
       );
       ++this.state.pos;
@@ -1091,13 +1108,13 @@ export default class Tokenizer extends LocationParser {
     let out = "",
       chunkStart = ++this.state.pos;
     for (;;) {
-      if (this.state.pos >= this.input.length) {
+      if (this.state.pos >= this.state.length) {
         this.raise(this.state.start, "Unterminated string constant");
       }
-      const ch = this.input.charCodeAt(this.state.pos);
+      const ch = this.state.input.charCodeAt(this.state.pos);
       if (ch === quote) break;
       if (ch === charCodes.backslash) {
-        out += this.input.slice(chunkStart, this.state.pos);
+        out += this.state.input.slice(chunkStart, this.state.pos);
         // $FlowFixMe
         out += this.readEscapedChar(false);
         chunkStart = this.state.pos;
@@ -1113,7 +1130,7 @@ export default class Tokenizer extends LocationParser {
         ++this.state.pos;
       }
     }
-    out += this.input.slice(chunkStart, this.state.pos++);
+    out += this.state.input.slice(chunkStart, this.state.pos++);
     this.finishToken(tt.string, out);
   }
 
@@ -1124,14 +1141,14 @@ export default class Tokenizer extends LocationParser {
       chunkStart = this.state.pos,
       containsInvalid = false;
     for (;;) {
-      if (this.state.pos >= this.input.length) {
+      if (this.state.pos >= this.state.length) {
         this.raise(this.state.start, "Unterminated template");
       }
-      const ch = this.input.charCodeAt(this.state.pos);
+      const ch = this.state.input.charCodeAt(this.state.pos);
       if (
         ch === charCodes.graveAccent ||
         (ch === charCodes.dollarSign &&
-          this.input.charCodeAt(this.state.pos + 1) ===
+          this.state.input.charCodeAt(this.state.pos + 1) ===
             charCodes.leftCurlyBrace)
       ) {
         if (this.state.pos === this.state.start && this.match(tt.template)) {
@@ -1145,12 +1162,12 @@ export default class Tokenizer extends LocationParser {
             return;
           }
         }
-        out += this.input.slice(chunkStart, this.state.pos);
+        out += this.state.input.slice(chunkStart, this.state.pos);
         this.finishToken(tt.template, containsInvalid ? null : out);
         return;
       }
       if (ch === charCodes.backslash) {
-        out += this.input.slice(chunkStart, this.state.pos);
+        out += this.state.input.slice(chunkStart, this.state.pos);
         const escaped = this.readEscapedChar(true);
         if (escaped === null) {
           containsInvalid = true;
@@ -1159,11 +1176,13 @@ export default class Tokenizer extends LocationParser {
         }
         chunkStart = this.state.pos;
       } else if (isNewLine(ch)) {
-        out += this.input.slice(chunkStart, this.state.pos);
+        out += this.state.input.slice(chunkStart, this.state.pos);
         ++this.state.pos;
         switch (ch) {
           case charCodes.carriageReturn:
-            if (this.input.charCodeAt(this.state.pos) === charCodes.lineFeed) {
+            if (
+              this.state.input.charCodeAt(this.state.pos) === charCodes.lineFeed
+            ) {
               ++this.state.pos;
             }
           case charCodes.lineFeed:
@@ -1186,7 +1205,7 @@ export default class Tokenizer extends LocationParser {
 
   readEscapedChar(inTemplate: boolean): string | null {
     const throwOnInvalid = !inTemplate;
-    const ch = this.input.charCodeAt(++this.state.pos);
+    const ch = this.state.input.charCodeAt(++this.state.pos);
     ++this.state.pos;
     switch (ch) {
       case charCodes.lowercaseN:
@@ -1210,7 +1229,9 @@ export default class Tokenizer extends LocationParser {
       case charCodes.lowercaseF:
         return "\f";
       case charCodes.carriageReturn:
-        if (this.input.charCodeAt(this.state.pos) === charCodes.lineFeed) {
+        if (
+          this.state.input.charCodeAt(this.state.pos) === charCodes.lineFeed
+        ) {
           ++this.state.pos;
         }
       case charCodes.lineFeed:
@@ -1221,7 +1242,7 @@ export default class Tokenizer extends LocationParser {
         if (ch >= charCodes.digit0 && ch <= charCodes.digit7) {
           const codePos = this.state.pos - 1;
           // $FlowFixMe
-          let octalStr = this.input
+          let octalStr = this.state.input
             .substr(this.state.pos - 1, 3)
             .match(/^[0-7]+/)[0];
           let octal = parseInt(octalStr, 8);
@@ -1277,8 +1298,8 @@ export default class Tokenizer extends LocationParser {
     const start = this.state.pos;
     let chunkStart = this.state.pos;
 
-    while (this.state.pos < this.input.length) {
-      const ch = this.input.codePointAt(this.state.pos);
+    while (this.state.pos < this.state.length) {
+      const ch = this.state.input.codePointAt(this.state.pos);
       if (isIdentifierChar(ch)) {
         this.state.pos += ch <= 0xffff ? 1 : 2;
       } else if (this.state.isIterator && ch === charCodes.atSign) {
@@ -1286,12 +1307,14 @@ export default class Tokenizer extends LocationParser {
       } else if (ch === charCodes.backslash) {
         this.state.containsEsc = true;
 
-        word += this.input.slice(chunkStart, this.state.pos);
+        word += this.state.input.slice(chunkStart, this.state.pos);
         const escStart = this.state.pos;
         const identifierCheck =
           this.state.pos === start ? isIdentifierStart : isIdentifierChar;
 
-        if (this.input.charCodeAt(++this.state.pos) !== charCodes.lowercaseU) {
+        if (
+          this.state.input.charCodeAt(++this.state.pos) !== charCodes.lowercaseU
+        ) {
           this.raise(
             this.state.pos,
             "Expecting Unicode escape sequence \\uXXXX",
@@ -1315,7 +1338,7 @@ export default class Tokenizer extends LocationParser {
         break;
       }
     }
-    return word + this.input.slice(chunkStart, this.state.pos);
+    return word + this.state.input.slice(chunkStart, this.state.pos);
   }
 
   isIterator(word: string): boolean {
@@ -1369,7 +1392,7 @@ export default class Tokenizer extends LocationParser {
       (prevType === tt.name && this.state.exprAllowed)
     ) {
       return lineBreak.test(
-        this.input.slice(this.state.lastTokEnd, this.state.start),
+        this.state.input.slice(this.state.lastTokEnd, this.state.start),
       );
     }
 
diff --git a/packages/babel-parser/src/tokenizer/state.js b/packages/babel-parser/src/tokenizer/state.js
index e03c4b1f2b..794bc32014 100644
--- a/packages/babel-parser/src/tokenizer/state.js
+++ b/packages/babel-parser/src/tokenizer/state.js
@@ -24,6 +24,7 @@ type TopicContextState = {
 export default class State {
   strict: boolean;
   input: string;
+  length: number;
 
   curLine: number;
 
@@ -37,6 +38,7 @@ export default class State {
       options.strictMode === false ? false : options.sourceType === "module";
 
     this.input = input;
+    this.length = input.length;
 
     this.curLine = options.startLine;
     this.startLoc = this.endLoc = this.curPosition();
diff --git a/packages/babel-parser/test/fixtures/es2017/async-functions/export-invalid/options.json b/packages/babel-parser/test/fixtures/es2017/async-functions/export-invalid/options.json
index 5da632286f..758834b289 100644
--- a/packages/babel-parser/test/fixtures/es2017/async-functions/export-invalid/options.json
+++ b/packages/babel-parser/test/fixtures/es2017/async-functions/export-invalid/options.json
@@ -1,4 +1,4 @@
 {
   "sourceType": "module",
-  "throws": "Unexpected token, expected \"function\" (1:21)"
+  "throws": "Unexpected token, expected \"=>\" (1:31)"
 }

From 59c4bbb4abef918a24e93201c9213a3b8e31f3ba Mon Sep 17 00:00:00 2001
From: Daniel Tschinder <daniel@tschinder.de>
Date: Tue, 15 Jan 2019 12:54:57 -0800
Subject: [PATCH 03/21] perf: Make plugins a map instead of object

Fix plugin options
---
 packages/babel-parser/src/parser/base.js  |  5 +++--
 packages/babel-parser/src/parser/index.js | 10 ++++------
 2 files changed, 7 insertions(+), 8 deletions(-)

diff --git a/packages/babel-parser/src/parser/base.js b/packages/babel-parser/src/parser/base.js
index 96fd7fed83..796abb0df2 100644
--- a/packages/babel-parser/src/parser/base.js
+++ b/packages/babel-parser/src/parser/base.js
@@ -26,10 +26,11 @@ export default class BaseParser {
   }
 
   hasPlugin(name: string): boolean {
-    return Object.hasOwnProperty.call(this.plugins, name);
+    return this.plugins.has(name);
   }
 
   getPluginOption(plugin: string, name: string) {
-    if (this.hasPlugin(plugin)) return this.plugins[plugin][name];
+    // $FlowIssue
+    if (this.hasPlugin(plugin)) return this.plugins.get(plugin)[name];
   }
 }
diff --git a/packages/babel-parser/src/parser/index.js b/packages/babel-parser/src/parser/index.js
index 35e7e01f6c..00617bd863 100644
--- a/packages/babel-parser/src/parser/index.js
+++ b/packages/babel-parser/src/parser/index.js
@@ -6,9 +6,7 @@ import type { PluginList } from "../plugin-utils";
 import { getOptions } from "../options";
 import StatementParser from "./statement";
 
-export type PluginsMap = {
-  [key: string]: { [option: string]: any },
-};
+export type PluginsMap = Map<string, { [string]: any }>;
 
 export default class Parser extends StatementParser {
   // Forward-declaration so typescript plugin can override jsx plugin
@@ -35,10 +33,10 @@ export default class Parser extends StatementParser {
 }
 
 function pluginsMap(plugins: PluginList): PluginsMap {
-  const pluginMap: PluginsMap = (Object.create(null): Object);
+  const pluginMap: PluginsMap = new Map();
   for (const plugin of plugins) {
-    const [name, options = {}] = Array.isArray(plugin) ? plugin : [plugin, {}];
-    if (!pluginMap[name]) pluginMap[name] = options || {};
+    const [name, options] = Array.isArray(plugin) ? plugin : [plugin, {}];
+    if (!pluginMap.has(name)) pluginMap.set(name, options || {});
   }
   return pluginMap;
 }

From 48fd387779dba1e1c1f9554966000edc9d5bbaaf Mon Sep 17 00:00:00 2001
From: Daniel Tschinder <daniel@tschinder.de>
Date: Tue, 15 Jan 2019 12:56:24 -0800
Subject: [PATCH 04/21] perf: precalculate length

---
 packages/babel-parser/src/parser/lval.js     | 10 +++++++---
 packages/babel-parser/src/util/identifier.js |  2 +-
 2 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/packages/babel-parser/src/parser/lval.js b/packages/babel-parser/src/parser/lval.js
index 76613bba31..1a9a690388 100644
--- a/packages/babel-parser/src/parser/lval.js
+++ b/packages/babel-parser/src/parser/lval.js
@@ -56,9 +56,13 @@ export default class LValParser extends NodeUtils {
 
         case "ObjectExpression":
           node.type = "ObjectPattern";
-          for (let index = 0; index < node.properties.length; index++) {
-            const prop = node.properties[index];
-            const isLast = index === node.properties.length - 1;
+          for (
+            let i = 0, length = node.properties.length, last = length - 1;
+            i < length;
+            i++
+          ) {
+            const prop = node.properties[i];
+            const isLast = i === last;
             this.toAssignableObjectExpressionProp(prop, isBinding, isLast);
           }
           break;
diff --git a/packages/babel-parser/src/util/identifier.js b/packages/babel-parser/src/util/identifier.js
index 1c50fcaf27..a312c9ac8d 100644
--- a/packages/babel-parser/src/util/identifier.js
+++ b/packages/babel-parser/src/util/identifier.js
@@ -64,7 +64,7 @@ const astralIdentifierCodes = [509,0,227,0,150,4,294,9,1368,2,2,1,6,3,41,2,5,0,1
 // rare.
 function isInAstralSet(code: number, set: $ReadOnlyArray<number>): boolean {
   let pos = 0x10000;
-  for (let i = 0; i < set.length; i += 2) {
+  for (let i = 0, length = set.length; i < length; i += 2) {
     pos += set[i];
     if (pos > code) return false;
 

From 25a8db2a299d14d67ad786d419f3137b527a25cf Mon Sep 17 00:00:00 2001
From: Daniel Tschinder <daniel@tschinder.de>
Date: Tue, 15 Jan 2019 12:57:28 -0800
Subject: [PATCH 05/21] perf: use normal equality check in stead of indexOf

---
 packages/babel-parser/src/parser/lval.js | 21 +++++++++------------
 packages/babel-parser/src/parser/node.js |  8 +++++---
 2 files changed, 14 insertions(+), 15 deletions(-)

diff --git a/packages/babel-parser/src/parser/lval.js b/packages/babel-parser/src/parser/lval.js
index 1a9a690388..2d1f13ad2e 100644
--- a/packages/babel-parser/src/parser/lval.js
+++ b/packages/babel-parser/src/parser/lval.js
@@ -149,12 +149,10 @@ export default class LValParser extends NodeUtils {
         const arg = last.argument;
         this.toAssignable(arg, isBinding, contextDescription);
         if (
-          [
-            "Identifier",
-            "MemberExpression",
-            "ArrayPattern",
-            "ObjectPattern",
-          ].indexOf(arg.type) === -1
+          arg.type !== "Identifier" &&
+          arg.type !== "MemberExpression" &&
+          arg.type !== "ArrayPattern" &&
+          arg.type !== "ObjectPattern"
         ) {
           this.unexpected(arg.start);
         }
@@ -430,13 +428,12 @@ export default class LValParser extends NodeUtils {
   }
 
   checkToRestConversion(node: SpreadElement): void {
-    const validArgumentTypes = ["Identifier", "MemberExpression"];
-
-    if (validArgumentTypes.indexOf(node.argument.type) !== -1) {
-      return;
+    if (
+      node.argument.type !== "Identifier" &&
+      node.argument.type !== "MemberExpression"
+    ) {
+      this.raise(node.argument.start, "Invalid rest operator's argument");
     }
-
-    this.raise(node.argument.start, "Invalid rest operator's argument");
   }
 
   checkCommaAfterRest(close: TokenType, kind: string): void {
diff --git a/packages/babel-parser/src/parser/node.js b/packages/babel-parser/src/parser/node.js
index 73223eea85..5ed447018d 100644
--- a/packages/babel-parser/src/parser/node.js
+++ b/packages/babel-parser/src/parser/node.js
@@ -7,8 +7,6 @@ import type { Comment, Node as NodeType, NodeBase } from "../types";
 
 // Start an AST node, attaching a start offset.
 
-const commentKeys = ["leadingComments", "trailingComments", "innerComments"];
-
 class Node implements NodeBase {
   constructor(parser: Parser, pos: number, loc: Position) {
     this.type = "";
@@ -34,7 +32,11 @@ class Node implements NodeBase {
     const node2: any = new Node();
     Object.keys(this).forEach(key => {
       // Do not clone comments that are already attached to the node
-      if (commentKeys.indexOf(key) < 0) {
+      if (
+        key !== "leadingComments" &&
+        key !== "trailingComments" &&
+        key !== "innerComments"
+      ) {
         // $FlowIgnore
         node2[key] = this[key];
       }

From a7757ec4d036bccc27234ea0a30f276857cb4d5e Mon Sep 17 00:00:00 2001
From: Daniel Tschinder <daniel@tschinder.de>
Date: Tue, 15 Jan 2019 12:58:07 -0800
Subject: [PATCH 06/21] perf: Use increment operator

---
 packages/babel-parser/src/tokenizer/index.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/babel-parser/src/tokenizer/index.js b/packages/babel-parser/src/tokenizer/index.js
index 558cd069cb..3e72b8a837 100644
--- a/packages/babel-parser/src/tokenizer/index.js
+++ b/packages/babel-parser/src/tokenizer/index.js
@@ -1303,7 +1303,7 @@ export default class Tokenizer extends LocationParser {
       if (isIdentifierChar(ch)) {
         this.state.pos += ch <= 0xffff ? 1 : 2;
       } else if (this.state.isIterator && ch === charCodes.atSign) {
-        this.state.pos += 1;
+        ++this.state.pos;
       } else if (ch === charCodes.backslash) {
         this.state.containsEsc = true;
 

From e4b8cfc768cd6b1457f61ea6991630630a4ca3dc Mon Sep 17 00:00:00 2001
From: Daniel Tschinder <daniel@tschinder.de>
Date: Tue, 15 Jan 2019 12:58:59 -0800
Subject: [PATCH 07/21] perf: use Set instead of string indexOf

---
 packages/babel-parser/src/tokenizer/index.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/packages/babel-parser/src/tokenizer/index.js b/packages/babel-parser/src/tokenizer/index.js
index 3e72b8a837..b940da2c97 100644
--- a/packages/babel-parser/src/tokenizer/index.js
+++ b/packages/babel-parser/src/tokenizer/index.js
@@ -20,7 +20,7 @@ import {
 } from "../util/whitespace";
 import State from "./state";
 
-const VALID_REGEX_FLAGS = "gmsiyu";
+const VALID_REGEX_FLAGS = new Set(["g", "m", "s", "i", "y", "u"]);
 
 // The following character codes are forbidden from being
 // an immediate sibling of NumericLiteralSeparator _
@@ -874,7 +874,7 @@ export default class Tokenizer extends LocationParser {
       const char = this.state.input[this.state.pos];
       const charCode = this.state.input.codePointAt(this.state.pos);
 
-      if (VALID_REGEX_FLAGS.indexOf(char) > -1) {
+      if (VALID_REGEX_FLAGS.has(char)) {
         if (mods.indexOf(char) > -1) {
           this.raise(this.state.pos + 1, "Duplicate regular expression flag");
         }

From 8df0500f55c861b9b2761126fe4b5e5d975ef1ac Mon Sep 17 00:00:00 2001
From: Daniel Tschinder <daniel@tschinder.de>
Date: Tue, 15 Jan 2019 13:00:27 -0800
Subject: [PATCH 08/21] perf: Simplify reading of tokens.

This avoids checking isIdentifierStart for every single token
---
 packages/babel-parser/src/plugins/flow.js     |  4 ++--
 .../babel-parser/src/plugins/jsx/index.js     |  8 +++----
 .../babel-parser/src/plugins/typescript.js    |  4 ++--
 packages/babel-parser/src/tokenizer/index.js  | 22 +++++++++----------
 4 files changed, 19 insertions(+), 19 deletions(-)

diff --git a/packages/babel-parser/src/plugins/flow.js b/packages/babel-parser/src/plugins/flow.js
index 50e4e7fa3c..49370d4549 100644
--- a/packages/babel-parser/src/plugins/flow.js
+++ b/packages/babel-parser/src/plugins/flow.js
@@ -1933,7 +1933,7 @@ export default (superClass: Class<Parser>): Class<Parser> =>
     }
 
     // ensure that inside flow types, we bypass the jsx parser plugin
-    readToken(code: number): void {
+    getTokenFromCode(code: number): void {
       const next = this.state.input.charCodeAt(this.state.pos + 1);
       if (
         this.state.inType &&
@@ -1944,7 +1944,7 @@ export default (superClass: Class<Parser>): Class<Parser> =>
         this.state.isIterator = true;
         return super.readWord();
       } else {
-        return super.readToken(code);
+        return super.getTokenFromCode(code);
       }
     }
 
diff --git a/packages/babel-parser/src/plugins/jsx/index.js b/packages/babel-parser/src/plugins/jsx/index.js
index 7a814cfbce..a129c6d27a 100644
--- a/packages/babel-parser/src/plugins/jsx/index.js
+++ b/packages/babel-parser/src/plugins/jsx/index.js
@@ -93,7 +93,7 @@ export default (superClass: Class<Parser>): Class<Parser> =>
                 ++this.state.pos;
                 return this.finishToken(tt.jsxTagStart);
               }
-              return this.getTokenFromCode(ch);
+              return super.getTokenFromCode(ch);
             }
             out += this.state.input.slice(chunkStart, this.state.pos);
             return this.finishToken(tt.jsxText, out);
@@ -520,8 +520,8 @@ export default (superClass: Class<Parser>): Class<Parser> =>
       }
     }
 
-    readToken(code: number): void {
-      if (this.state.inPropertyName) return super.readToken(code);
+    getTokenFromCode(code: number): void {
+      if (this.state.inPropertyName) return super.getTokenFromCode(code);
 
       const context = this.curContext();
 
@@ -557,7 +557,7 @@ export default (superClass: Class<Parser>): Class<Parser> =>
         return this.finishToken(tt.jsxTagStart);
       }
 
-      return super.readToken(code);
+      return super.getTokenFromCode(code);
     }
 
     updateContext(prevType: TokenType): void {
diff --git a/packages/babel-parser/src/plugins/typescript.js b/packages/babel-parser/src/plugins/typescript.js
index c73bc6fe9d..9758ac1569 100644
--- a/packages/babel-parser/src/plugins/typescript.js
+++ b/packages/babel-parser/src/plugins/typescript.js
@@ -2213,11 +2213,11 @@ export default (superClass: Class<Parser>): Class<Parser> =>
     }
 
     // ensure that inside types, we bypass the jsx parser plugin
-    readToken(code: number): void {
+    getTokenFromCode(code: number): void {
       if (this.state.inType && (code === 62 || code === 60)) {
         return this.finishOp(tt.relational, 1);
       } else {
-        return super.readToken(code);
+        return super.getTokenFromCode(code);
       }
     }
 
diff --git a/packages/babel-parser/src/tokenizer/index.js b/packages/babel-parser/src/tokenizer/index.js
index b940da2c97..038d58948e 100644
--- a/packages/babel-parser/src/tokenizer/index.js
+++ b/packages/babel-parser/src/tokenizer/index.js
@@ -214,17 +214,7 @@ export default class Tokenizer extends LocationParser {
     if (curContext.override) {
       curContext.override(this);
     } else {
-      this.readToken(this.state.input.codePointAt(this.state.pos));
-    }
-  }
-
-  readToken(code: number): void {
-    // Identifier or keyword. '\uXXXX' sequences are allowed in
-    // identifiers, so '\' also dispatches to that.
-    if (isIdentifierStart(code) || code === charCodes.backslash) {
-      this.readWord();
-    } else {
-      this.getTokenFromCode(code);
+      this.getTokenFromCode(this.state.input.codePointAt(this.state.pos));
     }
   }
 
@@ -826,6 +816,16 @@ export default class Tokenizer extends LocationParser {
       case charCodes.numberSign:
         this.readToken_numberSign();
         return;
+
+      case charCodes.backslash:
+        this.readWord();
+        return;
+
+      default:
+        if (isIdentifierStart(code)) {
+          this.readWord();
+          return;
+        }
     }
 
     this.raise(

From 0370af58f1bf351be5d998832f8a6306fbc567e7 Mon Sep 17 00:00:00 2001
From: Daniel Tschinder <daniel@tschinder.de>
Date: Tue, 15 Jan 2019 13:13:58 -0800
Subject: [PATCH 09/21] perf: Use strict equals

---
 packages/babel-parser/src/parser/expression.js        | 2 +-
 packages/babel-parser/src/parser/statement.js         | 8 ++++----
 packages/babel-parser/src/parser/util.js              | 2 +-
 packages/babel-parser/src/plugins/flow.js             | 2 +-
 packages/babel-parser/test/helpers/runFixtureTests.js | 2 +-
 5 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/packages/babel-parser/src/parser/expression.js b/packages/babel-parser/src/parser/expression.js
index 12174c78f3..7a485837b2 100644
--- a/packages/babel-parser/src/parser/expression.js
+++ b/packages/babel-parser/src/parser/expression.js
@@ -525,7 +525,7 @@ export default class ExpressionParser extends LValParser {
     } else if (this.match(tt.questionDot)) {
       this.expectPlugin("optionalChaining");
       state.optionalChainMember = true;
-      if (noCalls && this.lookahead().type == tt.parenL) {
+      if (noCalls && this.lookahead().type === tt.parenL) {
         state.stop = true;
         return base;
       }
diff --git a/packages/babel-parser/src/parser/statement.js b/packages/babel-parser/src/parser/statement.js
index 6f17c54709..315324d512 100644
--- a/packages/babel-parser/src/parser/statement.js
+++ b/packages/babel-parser/src/parser/statement.js
@@ -161,7 +161,7 @@ export default class StatementParser extends ExpressionParser {
         this.next();
 
         let result;
-        if (starttype == tt._import) {
+        if (starttype === tt._import) {
           result = this.parseImport(node);
 
           if (
@@ -693,9 +693,9 @@ export default class StatementParser extends ExpressionParser {
     node.body = this.parseStatement(declaration);
 
     if (
-      node.body.type == "ClassDeclaration" ||
-      (node.body.type == "VariableDeclaration" && node.body.kind !== "var") ||
-      (node.body.type == "FunctionDeclaration" &&
+      node.body.type === "ClassDeclaration" ||
+      (node.body.type === "VariableDeclaration" && node.body.kind !== "var") ||
+      (node.body.type === "FunctionDeclaration" &&
         (this.state.strict || node.body.generator || node.body.async))
     ) {
       this.raise(node.body.start, "Invalid labeled declaration");
diff --git a/packages/babel-parser/src/parser/util.js b/packages/babel-parser/src/parser/util.js
index 6538ee7f1b..1a8fa35a13 100644
--- a/packages/babel-parser/src/parser/util.js
+++ b/packages/babel-parser/src/parser/util.js
@@ -25,7 +25,7 @@ export default class UtilParser extends Tokenizer {
 
   isLookaheadRelational(op: "<" | ">"): boolean {
     const l = this.lookahead();
-    return l.type == tt.relational && l.value == op;
+    return l.type === tt.relational && l.value === op;
   }
 
   // TODO
diff --git a/packages/babel-parser/src/plugins/flow.js b/packages/babel-parser/src/plugins/flow.js
index 49370d4549..59dd4de0c3 100644
--- a/packages/babel-parser/src/plugins/flow.js
+++ b/packages/babel-parser/src/plugins/flow.js
@@ -1630,7 +1630,7 @@ export default (superClass: Class<Parser>): Class<Parser> =>
         this.match(tt.name) &&
         (this.state.value === "type" ||
           this.state.value === "interface" ||
-          this.state.value == "opaque")
+          this.state.value === "opaque")
       ) {
         return false;
       }
diff --git a/packages/babel-parser/test/helpers/runFixtureTests.js b/packages/babel-parser/test/helpers/runFixtureTests.js
index c910d6af15..623c56623d 100644
--- a/packages/babel-parser/test/helpers/runFixtureTests.js
+++ b/packages/babel-parser/test/helpers/runFixtureTests.js
@@ -126,7 +126,7 @@ function ppJSON(v) {
 }
 
 function addPath(str, pt) {
-  if (str.charAt(str.length - 1) == ")") {
+  if (str.charAt(str.length - 1) === ")") {
     return str.slice(0, str.length - 1) + "/" + pt + ")";
   } else {
     return str + " (" + pt + ")";

From a1eac37bd234551d374130a61ed13f04fad4b7d3 Mon Sep 17 00:00:00 2001
From: Daniel Tschinder <daniel@tschinder.de>
Date: Tue, 15 Jan 2019 13:45:09 -0800
Subject: [PATCH 10/21] Generate prettier comments

---
 packages/babel-parser/package.json                         | 2 +-
 packages/babel-parser/scripts/generate-identifier-regex.js | 4 ++++
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/packages/babel-parser/package.json b/packages/babel-parser/package.json
index e3898084ae..942d67a80b 100644
--- a/packages/babel-parser/package.json
+++ b/packages/babel-parser/package.json
@@ -30,7 +30,7 @@
   "devDependencies": {
     "@babel/helper-fixtures": "^7.2.0",
     "charcodes": "0.1.0",
-    "unicode-11.0.0": "^0.7.7"
+    "unicode-11.0.0": "^0.7.8"
   },
   "bin": {
     "parser": "./bin/babel-parser.js"
diff --git a/packages/babel-parser/scripts/generate-identifier-regex.js b/packages/babel-parser/scripts/generate-identifier-regex.js
index c0c53de64e..083adcde0a 100644
--- a/packages/babel-parser/scripts/generate-identifier-regex.js
+++ b/packages/babel-parser/scripts/generate-identifier-regex.js
@@ -60,11 +60,15 @@ function generate(chars) {
 const startData = generate(start);
 const contData = generate(cont);
 
+console.log("/* prettier-ignore */");
 console.log('let nonASCIIidentifierStartChars = "' + startData.nonASCII + '";');
+console.log("/* prettier-ignore */");
 console.log('let nonASCIIidentifierChars = "' + contData.nonASCII + '";');
+console.log("/* prettier-ignore */");
 console.log(
   "const astralIdentifierStartCodes = " + JSON.stringify(startData.astral) + ";"
 );
+console.log("/* prettier-ignore */");
 console.log(
   "const astralIdentifierCodes = " + JSON.stringify(contData.astral) + ";"
 );

From c2e41588aa33cf6cb27de8d29bc9460e3e9c78be Mon Sep 17 00:00:00 2001
From: Daniel Tschinder <daniel@tschinder.de>
Date: Tue, 15 Jan 2019 16:22:38 -0800
Subject: [PATCH 11/21] perf: run flow code in flow plugin

---
 packages/babel-parser/src/plugins/flow.js    | 18 +++++++++++++++++-
 packages/babel-parser/src/tokenizer/index.js | 20 +++-----------------
 2 files changed, 20 insertions(+), 18 deletions(-)

diff --git a/packages/babel-parser/src/plugins/flow.js b/packages/babel-parser/src/plugins/flow.js
index 59dd4de0c3..8dcbdf7a54 100644
--- a/packages/babel-parser/src/plugins/flow.js
+++ b/packages/babel-parser/src/plugins/flow.js
@@ -1935,7 +1935,9 @@ export default (superClass: Class<Parser>): Class<Parser> =>
     // ensure that inside flow types, we bypass the jsx parser plugin
     getTokenFromCode(code: number): void {
       const next = this.state.input.charCodeAt(this.state.pos + 1);
-      if (
+      if (code === charCodes.leftCurlyBrace && next === charCodes.verticalBar) {
+        return this.finishOp(tt.braceBarL, 2);
+      } else if (
         this.state.inType &&
         (code === charCodes.greaterThan || code === charCodes.lessThan)
       ) {
@@ -2701,6 +2703,20 @@ export default (superClass: Class<Parser>): Class<Parser> =>
       super.readToken_mult_modulo(code);
     }
 
+    readToken_pipe_amp(code: number): void {
+      const next = this.state.input.charCodeAt(this.state.pos + 1);
+      if (
+        code === charCodes.verticalBar &&
+        next === charCodes.rightCurlyBrace
+      ) {
+        // '|}'
+        this.finishOp(tt.braceBarR, 2);
+        return;
+      }
+
+      super.readToken_pipe_amp(code);
+    }
+
     parseTopLevel(file: N.File, program: N.Program): N.File {
       const fileNode = super.parseTopLevel(file, program);
       if (this.state.hasFlowComment) {
diff --git a/packages/babel-parser/src/tokenizer/index.js b/packages/babel-parser/src/tokenizer/index.js
index 038d58948e..4b5a7adc49 100644
--- a/packages/babel-parser/src/tokenizer/index.js
+++ b/packages/babel-parser/src/tokenizer/index.js
@@ -482,7 +482,7 @@ export default class Tokenizer extends LocationParser {
   }
 
   readToken_pipe_amp(code: number): void {
-    // '|&'
+    // '||' '&&' '||=' '&&='
     const next = this.state.input.charCodeAt(this.state.pos + 1);
 
     if (next === code) {
@@ -504,10 +504,6 @@ export default class Tokenizer extends LocationParser {
       if (next === charCodes.greaterThan) {
         this.finishOp(tt.pipeline, 2);
         return;
-      } else if (next === charCodes.rightCurlyBrace && this.hasPlugin("flow")) {
-        // '|}'
-        this.finishOp(tt.braceBarR, 2);
-        return;
       }
     }
 
@@ -688,20 +684,10 @@ export default class Tokenizer extends LocationParser {
         ++this.state.pos;
         this.finishToken(tt.bracketR);
         return;
-
       case charCodes.leftCurlyBrace:
-        if (
-          this.hasPlugin("flow") &&
-          this.state.input.charCodeAt(this.state.pos + 1) ===
-            charCodes.verticalBar
-        ) {
-          this.finishOp(tt.braceBarL, 2);
-        } else {
-          ++this.state.pos;
-          this.finishToken(tt.braceL);
-        }
+        ++this.state.pos;
+        this.finishToken(tt.braceL);
         return;
-
       case charCodes.rightCurlyBrace:
         ++this.state.pos;
         this.finishToken(tt.braceR);

From 49f7bcf2715d6872cbf9ca1a90a9d1423bd8d1db Mon Sep 17 00:00:00 2001
From: Daniel Tschinder <daniel@tschinder.de>
Date: Tue, 15 Jan 2019 19:35:50 -0800
Subject: [PATCH 12/21] perf: Remove unnecessary check for flow plugin inside
 of flow plugin

---
 packages/babel-parser/src/plugins/flow.js | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/packages/babel-parser/src/plugins/flow.js b/packages/babel-parser/src/plugins/flow.js
index 8dcbdf7a54..e0a729334a 100644
--- a/packages/babel-parser/src/plugins/flow.js
+++ b/packages/babel-parser/src/plugins/flow.js
@@ -2726,11 +2726,7 @@ export default (superClass: Class<Parser>): Class<Parser> =>
     }
 
     skipBlockComment(): void {
-      if (
-        this.hasPlugin("flow") &&
-        this.hasPlugin("flowComments") &&
-        this.skipFlowComment()
-      ) {
+      if (this.hasPlugin("flowComments") && this.skipFlowComment()) {
         if (this.state.hasFlowComment) {
           this.unexpected(
             null,
@@ -2743,7 +2739,7 @@ export default (superClass: Class<Parser>): Class<Parser> =>
         return;
       }
 
-      if (this.hasPlugin("flow") && this.state.hasFlowComment) {
+      if (this.state.hasFlowComment) {
         const end = this.state.input.indexOf("*-/", (this.state.pos += 2));
         if (end === -1) this.raise(this.state.pos - 2, "Unterminated comment");
         this.state.pos = end + 3;

From 455e003567c52326a4809da37383a6a3e6b012e1 Mon Sep 17 00:00:00 2001
From: Daniel Tschinder <daniel@tschinder.de>
Date: Tue, 15 Jan 2019 23:30:46 -0800
Subject: [PATCH 13/21] perf: Optimize regex

This saves some steps, as the regex parser does not have to backtrack for character classes, but is has to for alternates
---
 packages/babel-parser/src/util/whitespace.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/babel-parser/src/util/whitespace.js b/packages/babel-parser/src/util/whitespace.js
index d82d87413d..2fdbc3d423 100644
--- a/packages/babel-parser/src/util/whitespace.js
+++ b/packages/babel-parser/src/util/whitespace.js
@@ -4,7 +4,7 @@ import * as charCodes from "charcodes";
 
 // Matches a whole line break (where CRLF is considered a single
 // line break). Used to count lines.
-export const lineBreak = /\r\n?|\n|\u2028|\u2029/;
+export const lineBreak = /\r\n?|[\n\u2028\u2029]/;
 export const lineBreakG = new RegExp(lineBreak.source, "g");
 
 // https://tc39.github.io/ecma262/#sec-line-terminators

From 58768072effe299da7d121fa69e92ed579c3c9ad Mon Sep 17 00:00:00 2001
From: Daniel Tschinder <daniel@tschinder.de>
Date: Tue, 15 Jan 2019 23:32:18 -0800
Subject: [PATCH 14/21] perf: Ensure canInsertSemicolon is always called last

It does a lot of checks and a regex test
---
 packages/babel-parser/src/parser/expression.js | 11 ++++++-----
 packages/babel-parser/src/plugins/flow.js      |  2 +-
 2 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/packages/babel-parser/src/parser/expression.js b/packages/babel-parser/src/parser/expression.js
index 7a485837b2..b65d057470 100644
--- a/packages/babel-parser/src/parser/expression.js
+++ b/packages/babel-parser/src/parser/expression.js
@@ -869,9 +869,9 @@ export default class ExpressionParser extends LValParser {
           return this.parseFunction(node, false, false, true);
         } else if (
           canBeArrow &&
-          !this.canInsertSemicolon() &&
           id.name === "async" &&
-          this.match(tt.name)
+          this.match(tt.name) &&
+          !this.canInsertSemicolon()
         ) {
           const oldYOAIPAP = this.state.yieldOrAwaitInPossibleArrowParameters;
           const oldInAsync = this.state.inAsync;
@@ -886,7 +886,8 @@ export default class ExpressionParser extends LValParser {
           return node;
         }
 
-        if (canBeArrow && !this.canInsertSemicolon() && this.eat(tt.arrow)) {
+        if (canBeArrow && this.match(tt.arrow) && !this.canInsertSemicolon()) {
+          this.next();
           const oldYOAIPAP = this.state.yieldOrAwaitInPossibleArrowParameters;
           this.state.yieldOrAwaitInPossibleArrowParameters = null;
           this.parseArrowExpression(node, [id]);
@@ -2076,8 +2077,8 @@ export default class ExpressionParser extends LValParser {
     this.next();
     if (
       this.match(tt.semi) ||
-      this.canInsertSemicolon() ||
-      (!this.match(tt.star) && !this.state.type.startsExpr)
+      (!this.match(tt.star) && !this.state.type.startsExpr) ||
+      this.canInsertSemicolon()
     ) {
       node.delegate = false;
       node.argument = null;
diff --git a/packages/babel-parser/src/plugins/flow.js b/packages/babel-parser/src/plugins/flow.js
index e0a729334a..878cc4c308 100644
--- a/packages/babel-parser/src/plugins/flow.js
+++ b/packages/babel-parser/src/plugins/flow.js
@@ -1398,7 +1398,7 @@ export default (superClass: Class<Parser>): Class<Parser> =>
       const startPos = this.state.start,
         startLoc = this.state.startLoc;
       let type = this.flowParsePrimaryType();
-      while (!this.canInsertSemicolon() && this.match(tt.bracketL)) {
+      while (this.match(tt.bracketL) && !this.canInsertSemicolon()) {
         const node = this.startNodeAt(startPos, startLoc);
         node.elementType = type;
         this.expect(tt.bracketL);

From 10555c719ee236ad3d2abc9e90c030cadd7380dd Mon Sep 17 00:00:00 2001
From: Daniel Tschinder <daniel@tschinder.de>
Date: Tue, 15 Jan 2019 23:34:18 -0800
Subject: [PATCH 15/21] Build the parser also for node 6.9 and up

---
 babel.config.js | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/babel.config.js b/babel.config.js
index ce4eb1d565..12f4bb16ca 100644
--- a/babel.config.js
+++ b/babel.config.js
@@ -14,12 +14,16 @@ module.exports = function(api) {
   let convertESM = true;
   let ignoreLib = true;
   let includeRuntime = false;
+  const nodeVersion = "6.9";
 
   switch (env) {
     // Configs used during bundling builds.
     case "babel-parser":
       convertESM = false;
       ignoreLib = false;
+      envOpts.targets = {
+        node: nodeVersion,
+      };
       break;
     case "standalone":
       convertESM = false;
@@ -29,7 +33,7 @@ module.exports = function(api) {
     case "production":
       // Config during builds before publish.
       envOpts.targets = {
-        node: "6.9",
+        node: nodeVersion,
       };
       break;
     case "development":

From 3a3d5cbe9cc650c0cfa6006fb859b6d4e385e175 Mon Sep 17 00:00:00 2001
From: Daniel Tschinder <daniel@tschinder.de>
Date: Wed, 16 Jan 2019 02:11:46 -0800
Subject: [PATCH 16/21] perf: Check for plugin only once before looping

---
 packages/babel-parser/src/parser/statement.js | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/packages/babel-parser/src/parser/statement.js b/packages/babel-parser/src/parser/statement.js
index 315324d512..0babf3a271 100644
--- a/packages/babel-parser/src/parser/statement.js
+++ b/packages/babel-parser/src/parser/statement.js
@@ -865,6 +865,7 @@ export default class StatementParser extends ExpressionParser {
     kind: TokenType,
   ): N.VariableDeclaration {
     const declarations = (node.declarations = []);
+    const isTypescript = this.hasPlugin("typescript");
     // $FlowFixMe
     node.kind = kind.keyword;
     for (;;) {
@@ -879,7 +880,7 @@ export default class StatementParser extends ExpressionParser {
         ) {
           // `const` with no initializer is allowed in TypeScript.
           // It could be a declaration like `const x: number;`.
-          if (!this.hasPlugin("typescript")) {
+          if (!isTypescript) {
             this.unexpected();
           }
         } else if (

From f2169753784dbc683d7941cf0a29406c6dc46d91 Mon Sep 17 00:00:00 2001
From: Daniel Tschinder <daniel@tschinder.de>
Date: Wed, 16 Jan 2019 02:20:25 -0800
Subject: [PATCH 17/21] perf: call isLineTerminator as last check

---
 packages/babel-parser/src/parser/statement.js   | 2 +-
 packages/babel-parser/src/plugins/typescript.js | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/packages/babel-parser/src/parser/statement.js b/packages/babel-parser/src/parser/statement.js
index 0babf3a271..86659a2fd8 100644
--- a/packages/babel-parser/src/parser/statement.js
+++ b/packages/babel-parser/src/parser/statement.js
@@ -1281,7 +1281,7 @@ export default class StatementParser extends ExpressionParser {
     } else if (
       isSimple &&
       (key.name === "get" || key.name === "set") &&
-      !(this.isLineTerminator() && this.match(tt.star))
+      !(this.match(tt.star) && this.isLineTerminator())
     ) {
       // `get\n*` is an uninitialized property named 'get' followed by a generator.
       // a getter or setter
diff --git a/packages/babel-parser/src/plugins/typescript.js b/packages/babel-parser/src/plugins/typescript.js
index 9758ac1569..c01a93a1b1 100644
--- a/packages/babel-parser/src/plugins/typescript.js
+++ b/packages/babel-parser/src/plugins/typescript.js
@@ -1319,7 +1319,7 @@ export default (superClass: Class<Parser>): Class<Parser> =>
     }
 
     tsCheckLineTerminatorAndMatch(tokenType: TokenType, next: boolean) {
-      return !this.isLineTerminator() && (next || this.match(tokenType));
+      return (next || this.match(tokenType)) && !this.isLineTerminator();
     }
 
     tsTryParseGenericAsyncArrowFunction(

From f12905b531a89fbe8819466c5d7c06ef38d28070 Mon Sep 17 00:00:00 2001
From: Daniel Tschinder <daniel@tschinder.de>
Date: Wed, 16 Jan 2019 19:35:07 -0800
Subject: [PATCH 18/21] perf: Use for loops while cloning classes

---
 packages/babel-parser/src/parser/node.js     | 12 +++++++-----
 packages/babel-parser/src/tokenizer/state.js |  7 +++++--
 2 files changed, 12 insertions(+), 7 deletions(-)

diff --git a/packages/babel-parser/src/parser/node.js b/packages/babel-parser/src/parser/node.js
index 5ed447018d..ea04076bf3 100644
--- a/packages/babel-parser/src/parser/node.js
+++ b/packages/babel-parser/src/parser/node.js
@@ -29,8 +29,10 @@ class Node implements NodeBase {
 
   __clone(): this {
     // $FlowIgnore
-    const node2: any = new Node();
-    Object.keys(this).forEach(key => {
+    const newNode: any = new Node();
+    const keys = Object.keys(this);
+    for (let i = 0, length = keys.length; i < length; i++) {
+      const key = keys[i];
       // Do not clone comments that are already attached to the node
       if (
         key !== "leadingComments" &&
@@ -38,11 +40,11 @@ class Node implements NodeBase {
         key !== "innerComments"
       ) {
         // $FlowIgnore
-        node2[key] = this[key];
+        newNode[key] = this[key];
       }
-    });
+    }
 
-    return node2;
+    return newNode;
   }
 }
 
diff --git a/packages/babel-parser/src/tokenizer/state.js b/packages/babel-parser/src/tokenizer/state.js
index 794bc32014..9bc2b81c02 100644
--- a/packages/babel-parser/src/tokenizer/state.js
+++ b/packages/babel-parser/src/tokenizer/state.js
@@ -178,7 +178,9 @@ export default class State {
 
   clone(skipArrays?: boolean): State {
     const state = new State();
-    Object.keys(this).forEach(key => {
+    const keys = Object.keys(this);
+    for (let i = 0, length = keys.length; i < length; i++) {
+      const key = keys[i];
       // $FlowIgnore
       let val = this[key];
 
@@ -188,7 +190,8 @@ export default class State {
 
       // $FlowIgnore
       state[key] = val;
-    });
+    }
+
     return state;
   }
 }

From b66d921053ee04fd8d43f4c6b8caf8d471e4c57d Mon Sep 17 00:00:00 2001
From: Daniel Tschinder <daniel@tschinder.de>
Date: Thu, 17 Jan 2019 00:46:43 -0800
Subject: [PATCH 19/21] perf: Use === or Set.has instead of array.indexOf for
 keyword checks

---
 packages/babel-parser/src/parser/base.js      |  4 +-
 .../babel-parser/src/parser/expression.js     |  9 +-
 packages/babel-parser/src/util/identifier.js  | 82 ++++++++++++++-----
 .../babel-parser/test/unit/util/identifier.js | 18 ++++
 4 files changed, 89 insertions(+), 24 deletions(-)
 create mode 100644 packages/babel-parser/test/unit/util/identifier.js

diff --git a/packages/babel-parser/src/parser/base.js b/packages/babel-parser/src/parser/base.js
index 796abb0df2..f147cc88e7 100644
--- a/packages/babel-parser/src/parser/base.js
+++ b/packages/babel-parser/src/parser/base.js
@@ -1,7 +1,7 @@
 // @flow
 
 import type { Options } from "../options";
-import { reservedWords } from "../util/identifier";
+import { isES2015ReservedWord } from "../util/identifier";
 
 import type State from "../tokenizer/state";
 import type { PluginsMap } from "./index";
@@ -21,7 +21,7 @@ export default class BaseParser {
     if (word === "await") {
       return this.inModule;
     } else {
-      return reservedWords[6](word);
+      return isES2015ReservedWord(word);
     }
   }
 
diff --git a/packages/babel-parser/src/parser/expression.js b/packages/babel-parser/src/parser/expression.js
index b65d057470..8f51c9b80e 100644
--- a/packages/babel-parser/src/parser/expression.js
+++ b/packages/babel-parser/src/parser/expression.js
@@ -21,7 +21,10 @@
 import { types as tt, type TokenType } from "../tokenizer/types";
 import * as N from "../types";
 import LValParser from "./lval";
-import { reservedWords } from "../util/identifier";
+import {
+  isStrictReservedWord,
+  isStrictBindReservedWord,
+} from "../util/identifier";
 import type { Pos, Position } from "../util/location";
 import * as charCodes from "charcodes";
 
@@ -1997,8 +2000,8 @@ export default class ExpressionParser extends LValParser {
   ): void {
     if (
       this.state.strict &&
-      (reservedWords.strict(word) ||
-        (isBinding && reservedWords.strictBind(word)))
+      (isStrictReservedWord(word) ||
+        (isBinding && isStrictBindReservedWord(word)))
     ) {
       this.raise(startLoc, word + " is a reserved word in strict mode");
     }
diff --git a/packages/babel-parser/src/util/identifier.js b/packages/babel-parser/src/util/identifier.js
index a312c9ac8d..847a61f878 100644
--- a/packages/babel-parser/src/util/identifier.js
+++ b/packages/babel-parser/src/util/identifier.js
@@ -4,28 +4,72 @@
 
 import * as charCodes from "charcodes";
 
-function makePredicate(words: string): (str: string) => boolean {
-  const wordsArr = words.split(" ");
-  return function(str) {
-    return wordsArr.indexOf(str) >= 0;
-  };
-}
-
-// Reserved word lists for various dialects of the language
-
-export const reservedWords = {
-  "6": makePredicate("enum await"),
-  strict: makePredicate(
-    "implements interface let package private protected public static yield",
-  ),
-  strictBind: makePredicate("eval arguments"),
+export const isES2015ReservedWord = (word: string): boolean => {
+  return word === "enum" || word === "await";
 };
 
-// And the keywords
+const reservedWordsStrict = new Set([
+  "implements",
+  "interface",
+  "let",
+  "package",
+  "private",
+  "protected",
+  "public",
+  "static",
+  "yield",
+]);
+export function isStrictReservedWord(word: string): boolean {
+  return reservedWordsStrict.has(word);
+}
 
-export const isKeyword = makePredicate(
-  "break case catch continue debugger default do else finally for function if return switch throw try var while with null true false instanceof typeof void delete new in this let const class extends export import yield super",
-);
+export function isStrictBindReservedWord(word: string): boolean {
+  return word === "eval" || word === "arguments";
+}
+
+const keywords = new Set([
+  "break",
+  "case",
+  "catch",
+  "continue",
+  "debugger",
+  "default",
+  "do",
+  "else",
+  "finally",
+  "for",
+  "function",
+  "if",
+  "return",
+  "switch",
+  "throw",
+  "try",
+  "var",
+  "while",
+  "with",
+  "null",
+  "true",
+  "false",
+  "instanceof",
+  "typeof",
+  "void",
+  "delete",
+  "new",
+  "in",
+  "this",
+  "let",
+  "const",
+  "class",
+  "extends",
+  "export",
+  "import",
+  "yield",
+  "super",
+]);
+
+export function isKeyword(word: string): boolean {
+  return keywords.has(word);
+}
 
 // ## Character categories
 
diff --git a/packages/babel-parser/test/unit/util/identifier.js b/packages/babel-parser/test/unit/util/identifier.js
new file mode 100644
index 0000000000..a0d6bb16d2
--- /dev/null
+++ b/packages/babel-parser/test/unit/util/identifier.js
@@ -0,0 +1,18 @@
+import { isKeyword } from "../../../src/util/identifier";
+
+describe("identifier", () => {
+  describe("isKeyword", () => {
+    it("break is a keyword", () => {
+      expect(isKeyword("break")).toBe(true);
+    });
+    it("let is a keyword", () => {
+      expect(isKeyword("let")).toBe(true);
+    });
+    it("super is a keyword", () => {
+      expect(isKeyword("super")).toBe(true);
+    });
+    it("abc is not a keyword", () => {
+      expect(isKeyword("abc")).toBe(false);
+    });
+  });
+});

From 4e5e319d5b818f29b4123cf95e90b3e82fc46c07 Mon Sep 17 00:00:00 2001
From: Daniel Tschinder <daniel@tschinder.de>
Date: Thu, 17 Jan 2019 01:46:22 -0800
Subject: [PATCH 20/21] perf: remove double check for keywords in readWord

Instead of calling isKeyword we simple check directly if the keyword token is available
---
 .../babel-parser/src/parser/expression.js     |   3 +-
 packages/babel-parser/src/plugins/flow.js     |  17 +--
 packages/babel-parser/src/tokenizer/index.js  |  22 +---
 packages/babel-parser/src/tokenizer/types.js  | 112 ++++++++++--------
 4 files changed, 70 insertions(+), 84 deletions(-)

diff --git a/packages/babel-parser/src/parser/expression.js b/packages/babel-parser/src/parser/expression.js
index 8f51c9b80e..ac24a5910c 100644
--- a/packages/babel-parser/src/parser/expression.js
+++ b/packages/babel-parser/src/parser/expression.js
@@ -24,6 +24,7 @@ import LValParser from "./lval";
 import {
   isStrictReservedWord,
   isStrictBindReservedWord,
+  isKeyword,
 } from "../util/identifier";
 import type { Pos, Position } from "../util/location";
 import * as charCodes from "charcodes";
@@ -2020,7 +2021,7 @@ export default class ExpressionParser extends LValParser {
       );
     }
 
-    if (this.isReservedWord(word) || (checkKeywords && this.isKeyword(word))) {
+    if (this.isReservedWord(word) || (checkKeywords && isKeyword(word))) {
       this.raise(startLoc, word + " is a reserved word");
     }
   }
diff --git a/packages/babel-parser/src/plugins/flow.js b/packages/babel-parser/src/plugins/flow.js
index 878cc4c308..16543413a5 100644
--- a/packages/babel-parser/src/plugins/flow.js
+++ b/packages/babel-parser/src/plugins/flow.js
@@ -1190,9 +1190,6 @@ export default (superClass: Class<Parser>): Class<Parser> =>
         case "any":
           return this.finishNode(node, "AnyTypeAnnotation");
 
-        case "void":
-          return this.finishNode(node, "VoidTypeAnnotation");
-
         case "bool":
         case "boolean":
           return this.finishNode(node, "BooleanTypeAnnotation");
@@ -1369,6 +1366,10 @@ export default (superClass: Class<Parser>): Class<Parser> =>
             "NumberLiteralTypeAnnotation",
           );
 
+        case tt._void:
+          this.next();
+          return this.finishNode(node, "VoidTypeAnnotation");
+
         case tt._null:
           this.next();
           return this.finishNode(node, "NullLiteralTypeAnnotation");
@@ -1922,16 +1923,6 @@ export default (superClass: Class<Parser>): Class<Parser> =>
       }
     }
 
-    // don't consider `void` to be a keyword as then it'll use the void token type
-    // and set startExpr
-    isKeyword(name: string): boolean {
-      if (this.state.inType && name === "void") {
-        return false;
-      } else {
-        return super.isKeyword(name);
-      }
-    }
-
     // ensure that inside flow types, we bypass the jsx parser plugin
     getTokenFromCode(code: number): void {
       const next = this.state.input.charCodeAt(this.state.pos + 1);
diff --git a/packages/babel-parser/src/tokenizer/index.js b/packages/babel-parser/src/tokenizer/index.js
index 4b5a7adc49..d527c96913 100644
--- a/packages/babel-parser/src/tokenizer/index.js
+++ b/packages/babel-parser/src/tokenizer/index.js
@@ -3,11 +3,7 @@
 import type { Options } from "../options";
 import type { Position } from "../util/location";
 import * as charCodes from "charcodes";
-import {
-  isIdentifierStart,
-  isIdentifierChar,
-  isKeyword,
-} from "../util/identifier";
+import { isIdentifierStart, isIdentifierChar } from "../util/identifier";
 import { types as tt, keywords as keywordTypes, type TokenType } from "./types";
 import { type TokContext, types as ct } from "./context";
 import LocationParser from "../parser/location";
@@ -157,12 +153,6 @@ export default class Tokenizer extends LocationParser {
 
   // TODO
 
-  isKeyword(word: string): boolean {
-    return isKeyword(word);
-  }
-
-  // TODO
-
   lookahead(): State {
     const old = this.state;
     this.state = old.clone(true);
@@ -1336,14 +1326,10 @@ export default class Tokenizer extends LocationParser {
 
   readWord(): void {
     const word = this.readWord1();
-    let type = tt.name;
+    const type = keywordTypes[word] || tt.name;
 
-    if (this.isKeyword(word)) {
-      if (this.state.containsEsc) {
-        this.raise(this.state.pos, `Escape sequence in keyword ${word}`);
-      }
-
-      type = keywordTypes[word];
+    if (type.keyword && this.state.containsEsc) {
+      this.raise(this.state.pos, `Escape sequence in keyword ${word}`);
     }
 
     // Allow @@iterator and @@asyncIterator as a identifier only inside type
diff --git a/packages/babel-parser/src/tokenizer/types.js b/packages/babel-parser/src/tokenizer/types.js
index 5212e62608..6775ee5375 100644
--- a/packages/babel-parser/src/tokenizer/types.js
+++ b/packages/babel-parser/src/tokenizer/types.js
@@ -133,20 +133,20 @@ export const types: { [name: string]: TokenType } = {
   incDec: new TokenType("++/--", { prefix, postfix, startsExpr }),
   bang: new TokenType("!", { beforeExpr, prefix, startsExpr }),
   tilde: new TokenType("~", { beforeExpr, prefix, startsExpr }),
-  pipeline: new BinopTokenType("|>", 0),
-  nullishCoalescing: new BinopTokenType("??", 1),
-  logicalOR: new BinopTokenType("||", 1),
-  logicalAND: new BinopTokenType("&&", 2),
-  bitwiseOR: new BinopTokenType("|", 3),
-  bitwiseXOR: new BinopTokenType("^", 4),
-  bitwiseAND: new BinopTokenType("&", 5),
-  equality: new BinopTokenType("==/!=", 6),
-  relational: new BinopTokenType("</>", 7),
-  bitShift: new BinopTokenType("<</>>", 8),
+  pipeline: BinopTokenType("|>", 0),
+  nullishCoalescing: BinopTokenType("??", 1),
+  logicalOR: BinopTokenType("||", 1),
+  logicalAND: BinopTokenType("&&", 2),
+  bitwiseOR: BinopTokenType("|", 3),
+  bitwiseXOR: BinopTokenType("^", 4),
+  bitwiseAND: BinopTokenType("&", 5),
+  equality: BinopTokenType("==/!=", 6),
+  relational: BinopTokenType("</>", 7),
+  bitShift: BinopTokenType("<</>>", 8),
   plusMin: new TokenType("+/-", { beforeExpr, binop: 9, prefix, startsExpr }),
-  modulo: new BinopTokenType("%", 10),
-  star: new BinopTokenType("*", 10),
-  slash: new BinopTokenType("/", 10),
+  modulo: BinopTokenType("%", 10),
+  star: BinopTokenType("*", 10),
+  slash: BinopTokenType("/", 10),
   exponent: new TokenType("**", {
     beforeExpr,
     binop: 11,
@@ -154,45 +154,53 @@ export const types: { [name: string]: TokenType } = {
   }),
 };
 
-export const keywords = {
-  break: new KeywordTokenType("break"),
-  case: new KeywordTokenType("case", { beforeExpr }),
-  catch: new KeywordTokenType("catch"),
-  continue: new KeywordTokenType("continue"),
-  debugger: new KeywordTokenType("debugger"),
-  default: new KeywordTokenType("default", { beforeExpr }),
-  do: new KeywordTokenType("do", { isLoop, beforeExpr }),
-  else: new KeywordTokenType("else", { beforeExpr }),
-  finally: new KeywordTokenType("finally"),
-  for: new KeywordTokenType("for", { isLoop }),
-  function: new KeywordTokenType("function", { startsExpr }),
-  if: new KeywordTokenType("if"),
-  return: new KeywordTokenType("return", { beforeExpr }),
-  switch: new KeywordTokenType("switch"),
-  throw: new KeywordTokenType("throw", { beforeExpr, prefix, startsExpr }),
-  try: new KeywordTokenType("try"),
-  var: new KeywordTokenType("var"),
-  let: new KeywordTokenType("let"),
-  const: new KeywordTokenType("const"),
-  while: new KeywordTokenType("while", { isLoop }),
-  with: new KeywordTokenType("with"),
-  new: new KeywordTokenType("new", { beforeExpr, startsExpr }),
-  this: new KeywordTokenType("this", { startsExpr }),
-  super: new KeywordTokenType("super", { startsExpr }),
-  class: new KeywordTokenType("class", { startsExpr }),
-  extends: new KeywordTokenType("extends", { beforeExpr }),
-  export: new KeywordTokenType("export"),
-  import: new KeywordTokenType("import", { startsExpr }),
-  yield: new KeywordTokenType("yield", { beforeExpr, startsExpr }),
-  null: new KeywordTokenType("null", { startsExpr }),
-  true: new KeywordTokenType("true", { startsExpr }),
-  false: new KeywordTokenType("false", { startsExpr }),
-  in: new KeywordTokenType("in", { beforeExpr, binop: 7 }),
-  instanceof: new KeywordTokenType("instanceof", { beforeExpr, binop: 7 }),
-  typeof: new KeywordTokenType("typeof", { beforeExpr, prefix, startsExpr }),
-  void: new KeywordTokenType("void", { beforeExpr, prefix, startsExpr }),
-  delete: new KeywordTokenType("delete", { beforeExpr, prefix, startsExpr }),
-};
+function makeKeywordProps(
+  name: string,
+  conf: any,
+): PropertyDescriptor<TokenType> {
+  return { value: KeywordTokenType(name, conf), enumerable: true };
+}
+
+// $FlowIssue
+export const keywords = Object.create(null, {
+  break: makeKeywordProps("break"),
+  case: makeKeywordProps("case", { beforeExpr }),
+  catch: makeKeywordProps("catch"),
+  continue: makeKeywordProps("continue"),
+  debugger: makeKeywordProps("debugger"),
+  default: makeKeywordProps("default", { beforeExpr }),
+  do: makeKeywordProps("do", { isLoop, beforeExpr }),
+  else: makeKeywordProps("else", { beforeExpr }),
+  finally: makeKeywordProps("finally"),
+  for: makeKeywordProps("for", { isLoop }),
+  function: makeKeywordProps("function", { startsExpr }),
+  if: makeKeywordProps("if"),
+  return: makeKeywordProps("return", { beforeExpr }),
+  switch: makeKeywordProps("switch"),
+  throw: makeKeywordProps("throw", { beforeExpr, prefix, startsExpr }),
+  try: makeKeywordProps("try"),
+  var: makeKeywordProps("var"),
+  let: makeKeywordProps("let"),
+  const: makeKeywordProps("const"),
+  while: makeKeywordProps("while", { isLoop }),
+  with: makeKeywordProps("with"),
+  new: makeKeywordProps("new"),
+  this: makeKeywordProps("this", { startsExpr }),
+  super: makeKeywordProps("super", { startsExpr }),
+  class: makeKeywordProps("class", { startsExpr }),
+  extends: makeKeywordProps("extends", { beforeExpr }),
+  export: makeKeywordProps("export"),
+  import: makeKeywordProps("import", { startsExpr }),
+  yield: makeKeywordProps("yield", { beforeExpr, startsExpr }),
+  null: makeKeywordProps("null", { startsExpr }),
+  true: makeKeywordProps("true", { startsExpr }),
+  false: makeKeywordProps("false", { startsExpr }),
+  in: makeKeywordProps("in", { beforeExpr, binop: 7 }),
+  instanceof: makeKeywordProps("instanceof", { beforeExpr, binop: 7 }),
+  typeof: makeKeywordProps("typeof", { beforeExpr, prefix, startsExpr }),
+  void: makeKeywordProps("void", { beforeExpr, prefix, startsExpr }),
+  delete: makeKeywordProps("delete", { beforeExpr, prefix, startsExpr }),
+});
 
 // Map keyword names to token types.
 Object.keys(keywords).forEach(name => {

From 2d6231fd3da179508a088d29a7b5f2f35244a315 Mon Sep 17 00:00:00 2001
From: Daniel Tschinder <daniel@tschinder.de>
Date: Thu, 17 Jan 2019 16:05:39 -0800
Subject: [PATCH 21/21] Update flow whitelist

---
 scripts/tests/flow/flow_tests_whitelist.txt | 1 -
 1 file changed, 1 deletion(-)

diff --git a/scripts/tests/flow/flow_tests_whitelist.txt b/scripts/tests/flow/flow_tests_whitelist.txt
index 0b49c7623a..c5a154762b 100644
--- a/scripts/tests/flow/flow_tests_whitelist.txt
+++ b/scripts/tests/flow/flow_tests_whitelist.txt
@@ -26,7 +26,6 @@ decorators/migrated_0003.js
 decorators/migrated_0007.js
 private_class_properties/multiple.js
 private_class_properties/super.js
-types/annotations/void_is_reserved_param.js
 types/member/reserved_words.js
 types/parameter_defaults/migrated_0032.js
 class_method_kinds/polymorphic_getter.js