Remove flow

src/parser/expression.js

@@ -873,7 +873,7 @@ pp.parseFunctionBody = function (node, allowExpression) {
 
   // normal function
   if (!isExpression && node.body.directives.length) {
-    for (let directive of (node.body.directives: Array<Object>)) {
+    for (let directive of node.body.directives) {
       if (directive.value.value === "use strict") {
         isStrict = true;
         checkLVal = true;
@@ -895,7 +895,7 @@ pp.parseFunctionBody = function (node, allowExpression) {
     if (node.id) {
       this.checkLVal(node.id, true);
     }
-    for (let param of (node.params: Array<Object>)) {
+    for (let param of node.params) {
       this.checkLVal(param, true, nameHash);
     }
     this.state.strict = oldStrict;

src/parser/lval.js

@@ -20,7 +20,7 @@ pp.toAssignable = function (node, isBinding) {
 
       case "ObjectExpression":
         node.type = "ObjectPattern";
-        for (let prop of (node.properties: Array<Object>)) {
+        for (let prop of node.properties) {
           if (prop.type === "ObjectMethod") {
             if (prop.kind === "get" || prop.kind === "set") {
               this.raise(prop.key.start, "Object pattern can't contain getter or setter");
@@ -225,14 +225,14 @@ pp.checkLVal = function (expr, isBinding, checkClashes) {
       break;
 
     case "ObjectPattern":
-      for (let prop of (expr.properties: Array<Object>)) {
+      for (let prop of expr.properties) {
         if (prop.type === "ObjectProperty") prop = prop.value;
         this.checkLVal(prop, isBinding, checkClashes);
       }
       break;
 
     case "ArrayPattern":
-      for (let elem of (expr.elements: Array<Object>)) {
+      for (let elem of expr.elements) {
         if (elem) this.checkLVal(elem, isBinding, checkClashes);
       }
       break;

src/parser/node.js

@@ -6,19 +6,14 @@ import { SourceLocation } from "../util/location";
 const pp = Parser.prototype;
 
 class Node {
-  constructor(pos?: number, loc?: SourceLocation) {
+  constructor(pos, loc) {
     this.type = "";
     this.start = pos;
     this.end = 0;
     this.loc = new SourceLocation(loc);
   }
 
-  type: string;
-  start: ?number;
-  end: number;
-  loc: SourceLocation;
-
-  __clone(): Node {
+  __clone() {
     let node2 = new Node;
     for (let key in this) node2[key] = this[key];
     return node2;

src/parser/statement.js

@@ -404,7 +404,7 @@ pp.parseEmptyStatement = function (node) {
 };
 
 pp.parseLabeledStatement = function (node, maybeName, expr) {
-  for (let label of (this.state.labels: Array<Object>)){
+  for (let label of this.state.labels) {
     if (label.name === maybeName) {
       this.raise(expr.start, `Label '${maybeName}' is already declared`);
     }
@@ -438,7 +438,7 @@ pp.parseExpressionStatement = function (node, expr) {
 // strict"` declarations when `allowStrict` is true (used for
 // function bodies).
 
-pp.parseBlock = function (allowDirectives?) {
+pp.parseBlock = function (allowDirectives) {
   let node = this.startNode();
   this.expect(tt.braceL);
   this.parseBlockBody(node, allowDirectives, false, tt.braceR);
@@ -860,7 +860,7 @@ pp.parseExportSpecifiersMaybe = function (node) {
   }
 };
 
-pp.parseExportFrom = function (node, expect?) {
+pp.parseExportFrom = function (node, expect) {
   if (this.eatContextual("from")) {
     node.source = this.match(tt.string) ? this.parseExprAtom() : this.unexpected();
     this.checkExport(node);

src/plugins/flow.js

@@ -704,7 +704,7 @@ export default function (instance) {
   });
 
   instance.extend("parseParenItem", function () {
-    return function (node, startLoc, startPos, forceArrow?) {
+    return function (node, startLoc, startPos, forceArrow) {
       let canBeArrow = this.state.potentialArrowAt = startPos;
       if (this.match(tt.colon)) {
         let typeCastNode = this.startNodeAt(startLoc, startPos);

src/tokenizer/state.js

@@ -1,129 +1,83 @@
-import type { TokContext } from "./context";
-import type { Token } from "./index";
 import { Position } from "../util/location";
 import { types as ct } from "./context";
 import { types as tt } from "./types";
 
 export default class State {
-  init(options: Object, input: string) {
+  init(options, input) {
+    // TODO
     this.strict = options.strictMode === false ? false : options.sourceType === "module";
 
+    // TODO
     this.input = input;
 
+    // Used to signify the start of a potential arrow function
     this.potentialArrowAt = -1;
 
+    // Flags to track whether we are in a function, a generator.
     this.inMethod = this.inFunction = this.inGenerator = this.inAsync = false;
 
+    // Labels in scope.
     this.labels = [];
 
+    // Leading decorators.
     this.decorators = [];
 
+    // Token store.
     this.tokens = [];
 
+    // Comment store.
     this.comments = [];
 
+    // Comment attachment store
     this.trailingComments = [];
     this.leadingComments  = [];
     this.commentStack     = [];
 
+    // The current position of the tokenizer in the input.
     this.pos = this.lineStart = 0;
     this.curLine = 1;
 
+    // Properties of the current token:
+    // Its type
     this.type = tt.eof;
+
+    // For tokens that include more information than their type, the value
     this.value = null;
+
+    // Its start and end offset
     this.start = this.end = this.pos;
+
+    // And, if locations are used, the {line, column} object
+    // corresponding to those offsets
     this.startLoc = this.endLoc = this.curPosition();
 
+    // Position information for the previous token
     this.lastTokEndLoc = this.lastTokStartLoc = null;
     this.lastTokStart = this.lastTokEnd = this.pos;
 
+    // The context stack is used to superficially track syntactic
+    // context to predict whether a regular expression is allowed in a
+    // given position.
     this.context = [ct.b_stat];
     this.exprAllowed = true;
 
-    this.containsEsc = this.containsOctal = false;
+    // Used to signal to callers of `readWord1` whether the word
+    // contained any escape sequences. This is needed because words with
+    // escape sequences must not be interpreted as keywords.
+    this.containsEsc = false;
+
+    // TODO
+    this.containsOctal = false;
     this.octalPosition = null;
 
     return this;
   }
 
-  // TODO
-  strict: boolean;
-
-  // TODO
-  input: string;
-
-  // Used to signify the start of a potential arrow function
-  potentialArrowAt: number;
-
-  // Flags to track whether we are in a function, a generator.
-  inFunction: boolean;
-  inGenerator: boolean;
-  inMethod: boolean;
-
-  // Labels in scope.
-  labels: Array<Object>;
-
-  // Leading decorators.
-  decorators: Array<Object>;
-
-  // Token store.
-  tokens: Array<Object>;
-
-  // Comment store.
-  comments: Array<Object>;
-
-  // Comment attachment store
-  trailingComments: Array<Object>;
-  leadingComments: Array<Object>;
-  commentStack: Array<Object>;
-
-  // The current position of the tokenizer in the input.
-  pos: number;
-  lineStart: number;
-  curLine: number;
-
-  // Properties of the current token:
-  // Its type
-  type: Token;
-
-  // For tokens that include more information than their type, the value
-  value: any;
-
-  // Its start and end offset
-  start: number;
-  end: number;
-
-  // And, if locations are used, the {line, column} object
-  // corresponding to those offsets
-  startLoc: Position;
-  endLoc: Position;
-
-  // Position information for the previous token
-  lastTokEndLoc: ?Position;
-  lastTokStartLoc: ?Position;
-  lastTokStart: number;
-  lastTokEnd: number;
-
-  // The context stack is used to superficially track syntactic
-  // context to predict whether a regular expression is allowed in a
-  // given position.
-  context: Array<TokContext>;
-  exprAllowed: boolean;
-
-  // Used to signal to callers of `readWord1` whether the word
-  // contained any escape sequences. This is needed because words with
-  // escape sequences must not be interpreted as keywords.
-  containsEsc: boolean;
-
-  // TODO
-  containsOctal: boolean;
-  octalPosition: ?number;
-
   curPosition() {
     return new Position(this.curLine, this.pos - this.lineStart);
   }
 
-  clone(skipArrays?) {
+  clone(skipArrays) {
     let state = new State;
     for (let key in this) {
       let val = this[key];