Type-check tokenizer/types.js

src/parser/util.js

@@ -83,7 +83,7 @@ export default class UtilParser extends Tokenizer {
   // instead of a message string.
 
   unexpected(pos: ?number, messageOrType: string | TokenType = "Unexpected token"): empty {
-    if (messageOrType && typeof messageOrType === "object" && messageOrType.label) {
+    if (typeof messageOrType !== "string") {
       messageOrType = `Unexpected token, expected ${messageOrType.label}`;
     }
     throw this.raise(pos != null ? pos : this.state.start, messageOrType);

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

src/tokenizer/types.js

@@ -1,3 +1,5 @@
+// @flow
+
 // ## Token types
 
 // The assignment of fine-grained, information-carrying type objects
@@ -23,8 +25,33 @@ const isAssign = true;
 const prefix = true;
 const postfix = true;
 
+type TokenOptions = {
+  keyword?: string;
+
+  beforeExpr?: boolean;
+  startsExpr?: boolean;
+  rightAssociative?: boolean;
+  isLoop?: boolean;
+  isAssign?: boolean;
+  prefix?: boolean;
+  postfix?: boolean;
+  binop?: ?number;
+};
+
 export class TokenType {
-  constructor(label, conf = {}) {
+  label: string;
+  keyword: ?string;
+  beforeExpr: boolean;
+  startsExpr: boolean;
+  rightAssociative: boolean;
+  isLoop: boolean;
+  isAssign: boolean;
+  prefix: boolean;
+  postfix: boolean;
+  binop: ?number;
+  updateContext: ?((prevType: TokenType) => void);
+
+  constructor(label: string, conf: TokenOptions = {}) {
     this.label = label;
     this.keyword = conf.keyword;
     this.beforeExpr = !!conf.beforeExpr;
@@ -40,20 +67,20 @@ export class TokenType {
 }
 
 class KeywordTokenType extends TokenType {
-  constructor(name, options = {}) {
+  constructor(name: string, options: TokenOptions = {}) {
     options.keyword = name;
 
     super(name, options);
   }
 }
 
 export class BinopTokenType extends TokenType {
-  constructor(name, prec) {
+  constructor(name: string, prec: number) {
     super(name, { beforeExpr, binop: prec });
   }
 }
 
-export const types = {
+export const types: { [name: string]: TokenType } = {
   num: new TokenType("num", { startsExpr }),
   regexp: new TokenType("regexp", { startsExpr }),
   string: new TokenType("string", { startsExpr }),