type annotate babylon

src/tokenizer/context.js

@@ -1,3 +1,5 @@
+/* @flow */
+
 // The algorithm used to determine whether a regexp can appear at a
 // given point in the program is loosely based on sweet.js' approach.
 // See https://github.com/mozilla/sweet.js/wiki/design
@@ -5,12 +7,22 @@
 import { types as tt } from "./types";
 
 export class TokContext {
-  constructor(token, isExpr, preserveSpace, override) {
+  constructor(
+    token: string,
+    isExpr?: boolean,
+    preserveSpace?: boolean,
+    override?: Function,
+  ) {
     this.token = token;
     this.isExpr = !!isExpr;
     this.preserveSpace = !!preserveSpace;
     this.override = override;
   }
+
+  token: string;
+  isExpr: boolean;
+  preserveSpace: boolean;
+  override: ?Function;
 }
 
 export const types = {

src/tokenizer/index.js

@@ -1,3 +1,6 @@
+/* @flow */
+
+import type { TokenType } from "./types";
 import { isIdentifierStart, isIdentifierChar, isKeyword } from "../util/identifier";
 import { types as tt, keywords as keywordTypes } from "./types";
 import { types as ct } from "./context";
@@ -18,9 +21,11 @@ export class Token {
     this.loc = new SourceLocation(state.startLoc, state.endLoc);
   }
 
-  get range() {
-    return [this.start, this.end];
-  }
+  type: TokenType;
+  value: any;
+  start: number;
+  end: number;
+  loc: SourceLocation;
 }
 
 // ## Tokenizer
@@ -162,8 +167,7 @@ export default class Tokenizer {
       value: text,
       start: start,
       end: end,
-      loc: new SourceLocation(startLoc, endLoc),
-      range: [start, end]
+      loc: new SourceLocation(startLoc, endLoc)
     };
 
     if (!this.isLookahead) {

src/tokenizer/state.js

@@ -1,70 +1,120 @@
+/* @flow */
+
+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, input) {
-    // strict
+  init(options: Object, input: string) {
     this.strict = options.strictMode === false ? false : options.sourceType === "module";
 
     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.inFunction = this.inGenerator = 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;
 
-    // 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;
 
     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;
+
+  // 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;
+
   curPosition() {
     return new Position(this.curLine, this.pos - this.lineStart);
   }

src/tokenizer/types.js

@@ -1,3 +1,5 @@
+/* @flow */
+
 // ## Token types
 
 // The assignment of fine-grained, information-carrying type objects