From bc48c02a185c496505c999fc1f265acefb3913bc Mon Sep 17 00:00:00 2001
From: Marijn Haverbeke <marijnh@gmail.com>
Date: Mon, 23 Feb 2015 15:38:06 +0100
Subject: [PATCH] Move the parser state into an object

Makes almost everything in acorn.js a method of this object.

Performance is not significantly affected on a modern V8. Makes the
code reentrant and allows us to more easily expose more methods
externally in the future.

On the other hand, the proliferation of `this.` is unfortunate.
---
 acorn.js       | 3256 ++++++++++++++++++++++++------------------------
 test/driver.js |    3 +-
 2 files changed, 1607 insertions(+), 1652 deletions(-)

diff --git a/acorn.js b/acorn.js
index 2e33050623..dac6d21f94 100644
--- a/acorn.js
+++ b/acorn.js
@@ -1,9 +1,7 @@
 // Acorn is a tiny, fast JavaScript parser written in JavaScript.
 //
 // Acorn was written by Marijn Haverbeke and various contributors and
-// released under an MIT license. The Unicode regexps (for identifiers
-// and whitespace) were taken from [Esprima](http://esprima.org) by
-// Ariya Hidayat.
+// released under an MIT license.
 //
 // Git repositories for Acorn are available at
 //
@@ -33,19 +31,16 @@
   // The main exported interface (under `self.acorn` when in the
   // browser) is a `parse` function that takes a code string and
   // returns an abstract syntax tree as specified by [Mozilla parser
-  // API][api], with the caveat that inline XML is not recognized.
+  // API][api].
   //
   // [api]: https://developer.mozilla.org/en-US/docs/SpiderMonkey/Parser_API
 
-  var options, input, inputLen, sourceFile;
-
-  exports.parse = function(inpt, opts) {
-    input = String(inpt); inputLen = input.length;
-    setOptions(opts);
-    initTokenState();
-    var startPos = options.locations ? [tokPos, curPosition()] : tokPos;
-    initParserState();
-    return parseTopLevel(options.program || startNodeAt(startPos));
+  exports.parse = function(input, options) {
+    var p = new Parser(options, input);
+    var startPos = p.options.locations ? [p.pos, p.curPosition()] : p.pos;
+    p.skipSpace();
+    p.readToken();
+    return p.parseTopLevel(p.options.program || p.startNodeAt(startPos));
   };
 
   // A second optional argument can be given to further configure
@@ -129,51 +124,13 @@
   // offset in a string. Useful for parsing mixed-language formats
   // that embed JavaScript expressions.
 
-  exports.parseExpressionAt = function(inpt, pos, opts) {
-    input = String(inpt); inputLen = input.length;
-    setOptions(opts);
-    initTokenState(pos);
-    initParserState();
-    return parseExpression();
+  exports.parseExpressionAt = function(input, pos, options) {
+    var p = new Parser(options, input, pos);
+    p.skipSpace();
+    p.readToken();
+    return p.parseExpression();
   };
 
-  var isArray = function (obj) {
-    return Object.prototype.toString.call(obj) === "[object Array]";
-  };
-
-  function setOptions(opts) {
-    options = {};
-    for (var opt in defaultOptions)
-      options[opt] = opts && has(opts, opt) ? opts[opt] : defaultOptions[opt];
-    sourceFile = options.sourceFile || null;
-    if (isArray(options.onToken)) {
-      var tokens = options.onToken;
-      options.onToken = function (token) {
-        tokens.push(token);
-      };
-    }
-    if (isArray(options.onComment)) {
-      var comments = options.onComment;
-      options.onComment = function (block, text, start, end, startLoc, endLoc) {
-        var comment = {
-          type: block ? 'Block' : 'Line',
-          value: text,
-          start: start,
-          end: end
-        };
-        if (options.locations) {
-          comment.loc = new SourceLocation();
-          comment.loc.start = startLoc;
-          comment.loc.end = endLoc;
-        }
-        if (options.ranges)
-          comment.range = [start, end];
-        comments.push(comment);
-      };
-    }
-    isKeyword = options.ecmaVersion >= 6 ? isEcma6Keyword : isEcma5AndLessKeyword;
-  }
-
   // The `getLineInfo` function is mostly useful when the
   // `locations` option is off (for performance reasons) and you
   // want to find the line/column position for a given character
@@ -189,58 +146,61 @@
         cur = match.index + match[0].length;
       } else break;
     }
-    return {line: line, column: offset - cur};
+    return new Position(line, offset - cur);
   };
 
-  function Token() {
-    this.type = tokType;
-    this.value = tokVal;
-    this.start = tokStart;
-    this.end = tokEnd;
-    if (options.locations) {
-      this.loc = new SourceLocation();
-      this.loc.end = tokEndLoc;
-    }
-    if (options.ranges)
-      this.range = [tokStart, tokEnd];
-  }
+  // Object type used to represent tokens. Note that normally, tokens
+  // simply exist as properties on the parser object. This is only
+  // used for the onToken callback and the external tokenizer.
 
-  exports.Token = Token;
+  var Token = exports.Token = function(p) {
+    this.type = p.type;
+    this.value = p.value;
+    this.start = p.start;
+    this.end = p.end;
+    if (p.options.locations) {
+      this.loc = new SourceLocation(p);
+      this.loc.end = p.endLoc;
+    }
+    if (p.options.ranges)
+      this.range = [p.start, p.end];
+  };
 
   // Acorn is organized as a tokenizer and a recursive-descent parser.
   // The `tokenize` export provides an interface to the tokenizer.
   // Because the tokenizer is optimized for being efficiently used by
   // the Acorn parser itself, this interface is somewhat crude and not
-  // very modular. Performing another parse or call to `tokenize` will
-  // reset the internal state, and invalidate existing tokenizers.
+  // very modular.
 
-  exports.tokenize = function(inpt, opts) {
-    input = String(inpt); inputLen = input.length;
-    setOptions(opts);
-    initTokenState();
-    skipSpace();
+  exports.tokenize = function(input, options) {
+    var p = new Parser(options, input);
+    p.skipSpace();
 
     function getToken() {
-      lastEnd = tokEnd;
-      readToken();
-      return new Token();
+      p.lastTokEnd = p.end;
+      p.readToken();
+      return new Token(p);
     }
+
+    getToken.current = function() { return new Token(p); };
+
     getToken.jumpTo = function(pos, exprAllowed) {
-      tokPos = pos;
-      if (options.locations) {
-        tokCurLine = 1;
-        tokLineStart = lineBreak.lastIndex = 0;
+      p.pos = pos;
+      if (p.options.locations) {
+        p.curLine = 1;
+        p.lineStart = lineBreak.lastIndex = 0;
         var match;
-        while ((match = lineBreak.exec(input)) && match.index < pos) {
-          ++tokCurLine;
-          tokLineStart = match.index + match[0].length;
+        while ((match = lineBreak.exec(p.input)) && match.index < pos) {
+          ++p.curLine;
+          p.lineStart = match.index + match[0].length;
         }
       }
-      tokExprAllowed = !!exprAllowed;
-      skipSpace();
+      p.exprAllowed = !!exprAllowed;
+      p.skipSpace();
     };
-    getToken.current = function() { return new Token(); };
-    if (typeof Symbol !== 'undefined') {
+
+    // If we're in an ES6 environment, make this an iterator.
+    if (typeof Symbol !== "undefined") {
       getToken[Symbol.iterator] = function () {
         return {
           next: function () {
@@ -253,98 +213,45 @@
         };
       };
     }
-    getToken.options = options;
+
+    getToken.options = p.options;
     return getToken;
   };
 
-  // State is kept in (closure-)global variables. We already saw the
-  // `options`, `input`, and `inputLen` variables above.
+  // Interpret and default an options object
 
-  // The current position of the tokenizer in the input.
+  function parseOptions(opts) {
+    var options = {};
+    for (var opt in defaultOptions)
+      options[opt] = opts && has(opts, opt) ? opts[opt] : defaultOptions[opt];
 
-  var tokPos;
+    if (isArray(options.onToken)) {
+      var tokens = options.onToken;
+      options.onToken = function (token) { tokens.push(token); };
+    }
+    if (isArray(options.onComment))
+      options.onComment = pushComment(options, options.onComment);
 
-  // The start and end offsets of the current token.
-
-  var tokStart, tokEnd;
-
-  // When `options.locations` is true, these hold objects
-  // containing the tokens start and end line/column pairs.
-
-  var tokStartLoc, tokEndLoc;
-
-  // The type and value of the current token. Token types are objects,
-  // named by variables against which they can be compared, and
-  // holding properties that describe them (indicating, for example,
-  // the precedence of an infix operator, and the original name of a
-  // keyword token). The kind of value that's held in `tokVal` depends
-  // on the type of the token. For literals, it is the literal value,
-  // for operators, the operator name, and so on.
-
-  var tokType, tokVal;
-
-  // Internal state for the tokenizer. To distinguish between division
-  // operators and regular expressions, it remembers whether the last
-  // token was one that is allowed to be followed by an expression. In
-  // some cases, notably after ')' or '}' tokens, the situation
-  // depends on the context before the matching opening bracket, so
-  // tokContext keeps a stack of information about current bracketed
-  // forms.
-
-  var tokContext, tokExprAllowed;
-
-  // When `options.locations` is true, these are used to keep
-  // track of the current line, and know when a new line has been
-  // entered.
-
-  var tokCurLine, tokLineStart;
-
-  // These store the position of the previous token, which is useful
-  // when finishing a node and assigning its `end` position.
-
-  var lastStart, lastEnd, lastEndLoc;
-
-  // This is the parser's state. `inFunction` is used to reject
-  // `return` statements outside of functions, `inGenerator` to
-  // reject `yield`s outside of generators, `labels` to verify
-  // that `break` and `continue` have somewhere to jump to, and
-  // `strict` indicates whether strict mode is on.
-
-  var inFunction, inGenerator, labels, strict;
-
-  function initParserState() {
-    lastStart = lastEnd = tokPos;
-    if (options.locations) lastEndLoc = curPosition();
-    inFunction = inGenerator = false;
-    labels = [];
-    skipSpace();
-    readToken();
+    return options;
   }
 
-  // This function is used to raise exceptions on parse errors. It
-  // takes an offset integer (into the current `input`) to indicate
-  // the location of the error, attaches the position to the end
-  // of the error message, and then raises a `SyntaxError` with that
-  // message.
-
-  function raise(pos, message) {
-    var loc = getLineInfo(input, pos);
-    message += " (" + loc.line + ":" + loc.column + ")";
-    var err = new SyntaxError(message);
-    err.pos = pos; err.loc = loc; err.raisedAt = tokPos;
-    throw err;
-  }
-
-  function fullCharCodeAtPos() {
-    var code = input.charCodeAt(tokPos);
-    if (code <= 0xd7ff || code >= 0xe000) return code;
-    var next = input.charCodeAt(tokPos + 1);
-    return (code << 10) + next - 0x35fdc00;
-  }
-
-  function skipChar(code) {
-    if (code <= 0xffff) tokPos++;
-    else tokPos += 2;
+  function pushComment(options, array) {
+    return function (block, text, start, end, startLoc, endLoc) {
+      var comment = {
+        type: block ? 'Block' : 'Line',
+        value: text,
+        start: start,
+        end: end
+      };
+      if (options.locations) {
+        comment.loc = new SourceLocation(this);
+        comment.loc.start = startLoc;
+        comment.loc.end = endLoc;
+      }
+      if (options.ranges)
+        comment.range = [start, end];
+      array.push(comment);
+    };
   }
 
   // Reused empty array added for node fields that are always empty.
@@ -545,8 +452,6 @@
 
   var isEcma6Keyword = makePredicate(ecma5AndLessKeywords + " let const class extends export import yield");
 
-  var isKeyword = isEcma5AndLessKeyword;
-
   // ## Character categories
 
   // Big ugly regular expressions that match characters in the
@@ -626,7 +531,7 @@
   // ## Tokenizer
 
   // These are used when `options.locations` is on, for the
-  // `tokStartLoc` and `tokEndLoc` properties.
+  // `startLoc` and `endLoc` properties.
 
   function Position(line, col) {
     this.line = line;
@@ -637,670 +542,6 @@
     return new Position(this.line, this.column + n);
   };
 
-  function curPosition() {
-    return new Position(tokCurLine, tokPos - tokLineStart);
-  }
-
-  // Reset the token state. Used at the start of a parse.
-
-  function initTokenState(pos) {
-    if (pos) {
-      tokPos = pos;
-      tokLineStart = Math.max(0, input.lastIndexOf("\n", pos));
-      tokCurLine = input.slice(0, tokLineStart).split(newline).length;
-    } else {
-      tokCurLine = 1;
-      tokPos = tokLineStart = 0;
-    }
-    tokType = _eof;
-    tokContext = [b_stat];
-    tokExprAllowed = true;
-    strict = false;
-    if (tokPos === 0 && options.allowHashBang && input.slice(0, 2) === '#!') {
-      skipLineComment(2);
-    }
-  }
-
-  // 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
-
-  var b_stat = {token: "{", isExpr: false}, b_expr = {token: "{", isExpr: true}, b_tmpl = {token: "${", isExpr: true};
-  var p_stat = {token: "(", isExpr: false}, p_expr = {token: "(", isExpr: true};
-  var q_tmpl = {token: "`", isExpr: true}, f_expr = {token: "function", isExpr: true};
-
-  function curTokContext() {
-    return tokContext[tokContext.length - 1];
-  }
-
-  function braceIsBlock(prevType) {
-    var parent;
-    if (prevType === _colon && (parent = curTokContext()).token == "{")
-      return !parent.isExpr;
-    if (prevType === _return)
-      return newline.test(input.slice(lastEnd, tokStart));
-    if (prevType === _else || prevType === _semi || prevType === _eof)
-      return true;
-    if (prevType == _braceL)
-      return curTokContext() === b_stat;
-    return !tokExprAllowed;
-  }
-
-  // Called at the end of every token. Sets `tokEnd`, `tokVal`, and
-  // maintains `tokContext` and `tokExprAllowed`, and skips the space
-  // after the token, so that the next one's `tokStart` will point at
-  // the right position.
-
-  function finishToken(type, val) {
-    tokEnd = tokPos;
-    if (options.locations) tokEndLoc = curPosition();
-    var prevType = tokType, preserveSpace = false;
-    tokType = type;
-    tokVal = val;
-
-    // Update context info
-    if (type === _parenR || type === _braceR) {
-      var out = tokContext.pop();
-      if (out === b_tmpl) {
-        preserveSpace = true;
-      } else if (out === b_stat && curTokContext() === f_expr) {
-        tokContext.pop();
-        tokExprAllowed = false;
-      } else {
-        tokExprAllowed = !(out && out.isExpr);
-      }
-    } else if (type === _braceL) {
-      tokContext.push(braceIsBlock(prevType) ? b_stat : b_expr);
-      tokExprAllowed = true;
-    } else if (type === _dollarBraceL) {
-      tokContext.push(b_tmpl);
-      tokExprAllowed = true;
-    } else if (type == _parenL) {
-      var statementParens = prevType === _if || prevType === _for || prevType === _with || prevType === _while;
-      tokContext.push(statementParens ? p_stat : p_expr);
-      tokExprAllowed = true;
-    } else if (type == _incDec) {
-      // tokExprAllowed stays unchanged
-    } else if (type.keyword && prevType == _dot) {
-      tokExprAllowed = false;
-    } else if (type == _function) {
-      if (curTokContext() !== b_stat) {
-        tokContext.push(f_expr);
-      }
-      tokExprAllowed = false;
-    } else if (type === _backQuote) {
-      if (curTokContext() === q_tmpl) {
-        tokContext.pop();
-      } else {
-        tokContext.push(q_tmpl);
-        preserveSpace = true;
-      }
-      tokExprAllowed = false;
-    } else {
-      tokExprAllowed = type.beforeExpr;
-    }
-
-    if (!preserveSpace) skipSpace();
-  }
-
-  function skipBlockComment() {
-    var startLoc = options.onComment && options.locations && curPosition();
-    var start = tokPos, end = input.indexOf("*/", tokPos += 2);
-    if (end === -1) raise(tokPos - 2, "Unterminated comment");
-    tokPos = end + 2;
-    if (options.locations) {
-      lineBreak.lastIndex = start;
-      var match;
-      while ((match = lineBreak.exec(input)) && match.index < tokPos) {
-        ++tokCurLine;
-        tokLineStart = match.index + match[0].length;
-      }
-    }
-    if (options.onComment)
-      options.onComment(true, input.slice(start + 2, end), start, tokPos,
-                        startLoc, options.locations && curPosition());
-  }
-
-  function skipLineComment(startSkip) {
-    var start = tokPos;
-    var startLoc = options.onComment && options.locations && curPosition();
-    var ch = input.charCodeAt(tokPos+=startSkip);
-    while (tokPos < inputLen && ch !== 10 && ch !== 13 && ch !== 8232 && ch !== 8233) {
-      ++tokPos;
-      ch = input.charCodeAt(tokPos);
-    }
-    if (options.onComment)
-      options.onComment(false, input.slice(start + startSkip, tokPos), start, tokPos,
-                        startLoc, options.locations && curPosition());
-  }
-
-  // Called at the start of the parse and after every token. Skips
-  // whitespace and comments, and.
-
-  function skipSpace() {
-    while (tokPos < inputLen) {
-      var ch = input.charCodeAt(tokPos);
-      if (ch === 32) { // ' '
-        ++tokPos;
-      } else if (ch === 13) {
-        ++tokPos;
-        var next = input.charCodeAt(tokPos);
-        if (next === 10) {
-          ++tokPos;
-        }
-        if (options.locations) {
-          ++tokCurLine;
-          tokLineStart = tokPos;
-        }
-      } else if (ch === 10 || ch === 8232 || ch === 8233) {
-        ++tokPos;
-        if (options.locations) {
-          ++tokCurLine;
-          tokLineStart = tokPos;
-        }
-      } else if (ch > 8 && ch < 14) {
-        ++tokPos;
-      } else if (ch === 47) { // '/'
-        var next = input.charCodeAt(tokPos + 1);
-        if (next === 42) { // '*'
-          skipBlockComment();
-        } else if (next === 47) { // '/'
-          skipLineComment(2);
-        } else break;
-      } else if (ch === 160) { // '\xa0'
-        ++tokPos;
-      } else if (ch >= 5760 && nonASCIIwhitespace.test(String.fromCharCode(ch))) {
-        ++tokPos;
-      } else {
-        break;
-      }
-    }
-  }
-
-  // ### Token reading
-
-  // This is the function that is called to fetch the next token. It
-  // is somewhat obscure, because it works in character codes rather
-  // than characters, and because operator parsing has been inlined
-  // into it.
-  //
-  // All in the name of speed.
-  //
-  function readToken_dot() {
-    var next = input.charCodeAt(tokPos + 1);
-    if (next >= 48 && next <= 57) return readNumber(true);
-    var next2 = input.charCodeAt(tokPos + 2);
-    if (options.ecmaVersion >= 6 && next === 46 && next2 === 46) { // 46 = dot '.'
-      tokPos += 3;
-      return finishToken(_ellipsis);
-    } else {
-      ++tokPos;
-      return finishToken(_dot);
-    }
-  }
-
-  function readToken_slash() { // '/'
-    var next = input.charCodeAt(tokPos + 1);
-    if (tokExprAllowed) {++tokPos; return readRegexp();}
-    if (next === 61) return finishOp(_assign, 2);
-    return finishOp(_slash, 1);
-  }
-
-  function readToken_mult_modulo(code) { // '%*'
-    var next = input.charCodeAt(tokPos + 1);
-    if (next === 61) return finishOp(_assign, 2);
-    return finishOp(code === 42 ? _star : _modulo, 1);
-  }
-
-  function readToken_pipe_amp(code) { // '|&'
-    var next = input.charCodeAt(tokPos + 1);
-    if (next === code) return finishOp(code === 124 ? _logicalOR : _logicalAND, 2);
-    if (next === 61) return finishOp(_assign, 2);
-    return finishOp(code === 124 ? _bitwiseOR : _bitwiseAND, 1);
-  }
-
-  function readToken_caret() { // '^'
-    var next = input.charCodeAt(tokPos + 1);
-    if (next === 61) return finishOp(_assign, 2);
-    return finishOp(_bitwiseXOR, 1);
-  }
-
-  function readToken_plus_min(code) { // '+-'
-    var next = input.charCodeAt(tokPos + 1);
-    if (next === code) {
-      if (next == 45 && input.charCodeAt(tokPos + 2) == 62 &&
-          newline.test(input.slice(lastEnd, tokPos))) {
-        // A `-->` line comment
-        skipLineComment(3);
-        skipSpace();
-        return readToken();
-      }
-      return finishOp(_incDec, 2);
-    }
-    if (next === 61) return finishOp(_assign, 2);
-    return finishOp(_plusMin, 1);
-  }
-
-  function readToken_lt_gt(code) { // '<>'
-    var next = input.charCodeAt(tokPos + 1);
-    var size = 1;
-    if (next === code) {
-      size = code === 62 && input.charCodeAt(tokPos + 2) === 62 ? 3 : 2;
-      if (input.charCodeAt(tokPos + size) === 61) return finishOp(_assign, size + 1);
-      return finishOp(_bitShift, size);
-    }
-    if (next == 33 && code == 60 && input.charCodeAt(tokPos + 2) == 45 &&
-        input.charCodeAt(tokPos + 3) == 45) {
-      // `<!--`, an XML-style comment that should be interpreted as a line comment
-      skipLineComment(4);
-      skipSpace();
-      return readToken();
-    }
-    if (next === 61)
-      size = input.charCodeAt(tokPos + 2) === 61 ? 3 : 2;
-    return finishOp(_relational, size);
-  }
-
-  function readToken_eq_excl(code) { // '=!', '=>'
-    var next = input.charCodeAt(tokPos + 1);
-    if (next === 61) return finishOp(_equality, input.charCodeAt(tokPos + 2) === 61 ? 3 : 2);
-    if (code === 61 && next === 62 && options.ecmaVersion >= 6) { // '=>'
-      tokPos += 2;
-      return finishToken(_arrow);
-    }
-    return finishOp(code === 61 ? _eq : _prefix, 1);
-  }
-
-  function getTokenFromCode(code) {
-    switch (code) {
-    // The interpretation of a dot depends on whether it is followed
-    // by a digit or another two dots.
-    case 46: // '.'
-      return readToken_dot();
-
-    // Punctuation tokens.
-    case 40: ++tokPos; return finishToken(_parenL);
-    case 41: ++tokPos; return finishToken(_parenR);
-    case 59: ++tokPos; return finishToken(_semi);
-    case 44: ++tokPos; return finishToken(_comma);
-    case 91: ++tokPos; return finishToken(_bracketL);
-    case 93: ++tokPos; return finishToken(_bracketR);
-    case 123: ++tokPos; return finishToken(_braceL);
-    case 125: ++tokPos; return finishToken(_braceR);
-    case 58: ++tokPos; return finishToken(_colon);
-    case 63: ++tokPos; return finishToken(_question);
-
-    case 96: // '`'
-      if (options.ecmaVersion < 6) break;
-      ++tokPos;
-      return finishToken(_backQuote);
-
-    case 48: // '0'
-      var next = input.charCodeAt(tokPos + 1);
-      if (next === 120 || next === 88) return readRadixNumber(16); // '0x', '0X' - hex number
-      if (options.ecmaVersion >= 6) {
-        if (next === 111 || next === 79) return readRadixNumber(8); // '0o', '0O' - octal number
-        if (next === 98 || next === 66) return readRadixNumber(2); // '0b', '0B' - binary number
-      }
-    // Anything else beginning with a digit is an integer, octal
-    // number, or float.
-    case 49: case 50: case 51: case 52: case 53: case 54: case 55: case 56: case 57: // 1-9
-      return readNumber(false);
-
-    // Quotes produce strings.
-    case 34: case 39: // '"', "'"
-      return readString(code);
-
-    // Operators are parsed inline in tiny state machines. '=' (61) is
-    // often referred to. `finishOp` simply skips the amount of
-    // characters it is given as second argument, and returns a token
-    // of the type given by its first argument.
-
-    case 47: // '/'
-      return readToken_slash();
-
-    case 37: case 42: // '%*'
-      return readToken_mult_modulo(code);
-
-    case 124: case 38: // '|&'
-      return readToken_pipe_amp(code);
-
-    case 94: // '^'
-      return readToken_caret();
-
-    case 43: case 45: // '+-'
-      return readToken_plus_min(code);
-
-    case 60: case 62: // '<>'
-      return readToken_lt_gt(code);
-
-    case 61: case 33: // '=!'
-      return readToken_eq_excl(code);
-
-    case 126: // '~'
-      return finishOp(_prefix, 1);
-    }
-
-    raise(tokPos, "Unexpected character '" + codePointToString(code) + "'");
-  }
-
-  function readToken() {
-    tokStart = tokPos;
-    if (options.locations) tokStartLoc = curPosition();
-    if (tokPos >= inputLen) return finishToken(_eof);
-
-    if (curTokContext() === q_tmpl) {
-      return readTmplToken();
-    }
-
-    var code = fullCharCodeAtPos();
-
-    // Identifier or keyword. '\uXXXX' sequences are allowed in
-    // identifiers, so '\' also dispatches to that.
-    if (isIdentifierStart(code, options.ecmaVersion >= 6) || code === 92 /* '\' */) return readWord();
-
-    return getTokenFromCode(code);
-  }
-
-  function finishOp(type, size) {
-    var str = input.slice(tokPos, tokPos + size);
-    tokPos += size;
-    finishToken(type, str);
-  }
-
-  var regexpUnicodeSupport = false;
-  try { new RegExp("\uffff", "u"); regexpUnicodeSupport = true; }
-  catch(e) {}
-
-  // Parse a regular expression. Some context-awareness is necessary,
-  // since a '/' inside a '[]' set does not end the expression.
-
-  function readRegexp() {
-    var content = "", escaped, inClass, start = tokPos;
-    for (;;) {
-      if (tokPos >= inputLen) raise(start, "Unterminated regular expression");
-      var ch = input.charAt(tokPos);
-      if (newline.test(ch)) raise(start, "Unterminated regular expression");
-      if (!escaped) {
-        if (ch === "[") inClass = true;
-        else if (ch === "]" && inClass) inClass = false;
-        else if (ch === "/" && !inClass) break;
-        escaped = ch === "\\";
-      } else escaped = false;
-      ++tokPos;
-    }
-    var content = input.slice(start, tokPos);
-    ++tokPos;
-    // Need to use `readWord1` because '\uXXXX' sequences are allowed
-    // here (don't ask).
-    var mods = readWord1();
-    var tmp = content;
-    if (mods) {
-      var validFlags = /^[gmsiy]*$/;
-      if (options.ecmaVersion >= 6) validFlags = /^[gmsiyu]*$/;
-      if (!validFlags.test(mods)) raise(start, "Invalid regular expression flag");
-      if (mods.indexOf('u') >= 0 && !regexpUnicodeSupport) {
-        // Replace each astral symbol and every Unicode code point
-        // escape sequence that represents such a symbol with a single
-        // ASCII symbol to avoid throwing on regular expressions that
-        // are only valid in combination with the `/u` flag.
-        tmp = tmp
-          .replace(/\\u\{([0-9a-fA-F]{5,6})\}/g, "x")
-          .replace(/[\uD800-\uDBFF][\uDC00-\uDFFF]/g, "x");
-      }
-    }
-    // Detect invalid regular expressions.
-    try {
-      new RegExp(tmp);
-    } catch (e) {
-      if (e instanceof SyntaxError) raise(start, "Error parsing regular expression: " + e.message);
-      raise(e);
-    }
-    // Get a regular expression object for this pattern-flag pair, or `null` in
-    // case the current environment doesn't support the flags it uses.
-    try {
-      var value = new RegExp(content, mods);
-    } catch (err) {
-      value = null;
-    }
-    return finishToken(_regexp, {pattern: content, flags: mods, value: value});
-  }
-
-  // Read an integer in the given radix. Return null if zero digits
-  // were read, the integer value otherwise. When `len` is given, this
-  // will return `null` unless the integer has exactly `len` digits.
-
-  function readInt(radix, len) {
-    var start = tokPos, total = 0;
-    for (var i = 0, e = len == null ? Infinity : len; i < e; ++i) {
-      var code = input.charCodeAt(tokPos), val;
-      if (code >= 97) val = code - 97 + 10; // a
-      else if (code >= 65) val = code - 65 + 10; // A
-      else if (code >= 48 && code <= 57) val = code - 48; // 0-9
-      else val = Infinity;
-      if (val >= radix) break;
-      ++tokPos;
-      total = total * radix + val;
-    }
-    if (tokPos === start || len != null && tokPos - start !== len) return null;
-
-    return total;
-  }
-
-  function readRadixNumber(radix) {
-    tokPos += 2; // 0x
-    var val = readInt(radix);
-    if (val == null) raise(tokStart + 2, "Expected number in radix " + radix);
-    if (isIdentifierStart(fullCharCodeAtPos())) raise(tokPos, "Identifier directly after number");
-    return finishToken(_num, val);
-  }
-
-  // Read an integer, octal integer, or floating-point number.
-
-  function readNumber(startsWithDot) {
-    var start = tokPos, isFloat = false, octal = input.charCodeAt(tokPos) === 48;
-    if (!startsWithDot && readInt(10) === null) raise(start, "Invalid number");
-    if (input.charCodeAt(tokPos) === 46) {
-      ++tokPos;
-      readInt(10);
-      isFloat = true;
-    }
-    var next = input.charCodeAt(tokPos);
-    if (next === 69 || next === 101) { // 'eE'
-      next = input.charCodeAt(++tokPos);
-      if (next === 43 || next === 45) ++tokPos; // '+-'
-      if (readInt(10) === null) raise(start, "Invalid number");
-      isFloat = true;
-    }
-    if (isIdentifierStart(fullCharCodeAtPos())) raise(tokPos, "Identifier directly after number");
-
-    var str = input.slice(start, tokPos), val;
-    if (isFloat) val = parseFloat(str);
-    else if (!octal || str.length === 1) val = parseInt(str, 10);
-    else if (/[89]/.test(str) || strict) raise(start, "Invalid number");
-    else val = parseInt(str, 8);
-    return finishToken(_num, val);
-  }
-
-  // Read a string value, interpreting backslash-escapes.
-
-  function readCodePoint() {
-    var ch = input.charCodeAt(tokPos), code;
-
-    if (ch === 123) {
-      if (options.ecmaVersion < 6) unexpected();
-      ++tokPos;
-      code = readHexChar(input.indexOf('}', tokPos) - tokPos);
-      ++tokPos;
-      if (code > 0x10FFFF) unexpected();
-    } else {
-      code = readHexChar(4);
-    }
-    return code;
-  }
-
-  function codePointToString(code) {
-    // UTF-16 Encoding
-    if (code <= 0xFFFF) return String.fromCharCode(code);
-    return String.fromCharCode(((code - 0x10000) >> 10) + 0xD800,
-                               ((code - 0x10000) & 1023) + 0xDC00);
-  }
-
-  function readString(quote) {
-    var out = "", chunkStart = ++tokPos;
-    for (;;) {
-      if (tokPos >= inputLen) raise(tokStart, "Unterminated string constant");
-      var ch = input.charCodeAt(tokPos);
-      if (ch === quote) break;
-      if (ch === 92) { // '\'
-        out += input.slice(chunkStart, tokPos);
-        out += readEscapedChar();
-        chunkStart = tokPos;
-      } else {
-        if (isNewLine(ch)) raise(tokStart, "Unterminated string constant");
-        ++tokPos;
-      }
-    }
-    out += input.slice(chunkStart, tokPos++);
-    return finishToken(_string, out);
-  }
-
-  // Reads template string tokens.
-
-  function readTmplToken() {
-    var out = "", chunkStart = tokPos;
-    for (;;) {
-      if (tokPos >= inputLen) raise(tokStart, "Unterminated template");
-      var ch = input.charCodeAt(tokPos);
-      if (ch === 96 || ch === 36 && input.charCodeAt(tokPos + 1) === 123) { // '`', '${'
-        if (tokPos === tokStart && tokType === _template) {
-          if (ch === 36) {
-            tokPos += 2;
-            return finishToken(_dollarBraceL);
-          } else {
-            ++tokPos;
-            return finishToken(_backQuote);
-          }
-        }
-        out += input.slice(chunkStart, tokPos);
-        return finishToken(_template, out);
-      }
-      if (ch === 92) { // '\'
-        out += input.slice(chunkStart, tokPos);
-        out += readEscapedChar();
-        chunkStart = tokPos;
-      } else if (isNewLine(ch)) {
-        out += input.slice(chunkStart, tokPos);
-        ++tokPos;
-        if (ch === 13 && input.charCodeAt(tokPos) === 10) {
-          ++tokPos;
-          out += "\n";
-        } else {
-          out += String.fromCharCode(ch);
-        }
-        if (options.locations) {
-          ++tokCurLine;
-          tokLineStart = tokPos;
-        }
-        chunkStart = tokPos;
-      } else {
-        ++tokPos;
-      }
-    }
-  }
-
-  // Used to read escaped characters
-
-  function readEscapedChar() {
-    var ch = input.charCodeAt(++tokPos);
-    var octal = /^[0-7]+/.exec(input.slice(tokPos, tokPos + 3));
-    if (octal) octal = octal[0];
-    while (octal && parseInt(octal, 8) > 255) octal = octal.slice(0, -1);
-    if (octal === "0") octal = null;
-    ++tokPos;
-    if (octal) {
-      if (strict) raise(tokPos - 2, "Octal literal in strict mode");
-      tokPos += octal.length - 1;
-      return String.fromCharCode(parseInt(octal, 8));
-    } else {
-      switch (ch) {
-        case 110: return "\n"; // 'n' -> '\n'
-        case 114: return "\r"; // 'r' -> '\r'
-        case 120: return String.fromCharCode(readHexChar(2)); // 'x'
-        case 117: return codePointToString(readCodePoint()); // 'u'
-        case 116: return "\t"; // 't' -> '\t'
-        case 98: return "\b"; // 'b' -> '\b'
-        case 118: return "\u000b"; // 'v' -> '\u000b'
-        case 102: return "\f"; // 'f' -> '\f'
-        case 48: return "\0"; // 0 -> '\0'
-        case 13: if (input.charCodeAt(tokPos) === 10) ++tokPos; // '\r\n'
-        case 10: // ' \n'
-          if (options.locations) { tokLineStart = tokPos; ++tokCurLine; }
-          return "";
-        default: return String.fromCharCode(ch);
-      }
-    }
-  }
-
-  // Used to read character escape sequences ('\x', '\u', '\U').
-
-  function readHexChar(len) {
-    var n = readInt(16, len);
-    if (n === null) raise(tokStart, "Bad character escape sequence");
-    return n;
-  }
-
-  // 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.
-
-  var containsEsc;
-
-  // Read an identifier, and return it as a string. Sets `containsEsc`
-  // to whether the word contained a '\u' escape.
-  //
-  // Incrementally adds only escaped chars, adding other chunks as-is
-  // as a micro-optimization.
-
-  function readWord1() {
-    containsEsc = false;
-    var word = "", first = true, chunkStart = tokPos;
-    var astral = options.ecmaVersion >= 6;
-    while (tokPos < inputLen) {
-      var ch = fullCharCodeAtPos();
-      if (isIdentifierChar(ch, astral)) {
-        skipChar(ch);
-      } else if (ch === 92) { // "\"
-        containsEsc = true;
-        word += input.slice(chunkStart, tokPos);
-        var escStart = tokPos;
-        if (input.charCodeAt(++tokPos) != 117) // "u"
-          raise(tokPos, "Expecting Unicode escape sequence \\uXXXX");
-        ++tokPos;
-        var esc = readCodePoint();
-        if (!(first ? isIdentifierStart : isIdentifierChar)(esc, astral))
-          raise(escStart, "Invalid Unicode escape");
-        word += codePointToString(esc);
-        chunkStart = tokPos;
-      } else {
-        break;
-      }
-      first = false;
-    }
-    return word + input.slice(chunkStart, tokPos);
-  }
-
-  // Read an identifier or keyword token. Will check for reserved
-  // words when necessary.
-
-  function readWord() {
-    var word = readWord1();
-    var type = _name;
-    if ((options.ecmaVersion >= 6 || !containsEsc) && isKeyword(word))
-      type = keywordTypes[word];
-    return finishToken(type, word);
-  }
-
   // ## Parser
 
   // A recursive descent parser operates by defining functions for all
@@ -1321,176 +562,891 @@
   //
   // [opp]: http://en.wikipedia.org/wiki/Operator-precedence_parser
 
-  // ### Parser utilities
+  function Parser(options, input, startPos) {
+    this.options = parseOptions(options);
+    this.sourceFile = this.options.sourceFile || null;
+    this.isKeyword = this.options.ecmaVersion >= 6 ? isEcma6Keyword : isEcma5AndLessKeyword;
+    this.input = String(input);
 
-  // Continue to the next token.
+    // Set up token state
 
-  function next() {
-    if (options.onToken)
-      options.onToken(new Token());
+    // The current position of the tokenizer in the input.
+    if (startPos) {
+      this.pos = startPos;
+      this.lineStart = Math.max(0, this.input.lastIndexOf("\n", startPos));
+      this.curLine = this.input.slice(0, this.lineStart).split(newline).length;
+    } else {
+      this.pos = this.lineStart = 0;
+      this.curLine = 1;
+    }
 
-    lastStart = tokStart;
-    lastEnd = tokEnd;
-    lastEndLoc = tokEndLoc;
-    readToken();
+    // Properties of the current token:
+    // Its type
+    this.type = _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 = null;
+
+    // Position information for the previous token
+    this.lastTokEndLoc = 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 = [b_stat];
+    this.exprAllowed = true;
+
+    // Flags to track whether we are in strict mode, a function, a
+    // generator.
+    this.strict = this.inFunction = this.inGenerator = false;
+    // Labels in scope.
+    this.labels = [];
+
+    // If enabled, skip leading hashbang line.
+    if (this.pos === 0 && this.options.allowHashBang && this.input.slice(0, 2) === '#!')
+      this.skipLineComment(2);
   }
 
-  // Enter strict mode. Re-reads the next number or string to
-  // please pedantic tests ("use strict"; 010; -- should fail).
+  // Shorthand because we are going to be adding a _lot_ of methods to
+  // this.
+  var pp = Parser.prototype;
 
-  function setStrict(strct) {
-    strict = strct;
-    if (tokType !== _num && tokType !== _string) return;
-    tokPos = tokStart;
-    if (options.locations) {
-      while (tokPos < tokLineStart) {
-        tokLineStart = input.lastIndexOf("\n", tokLineStart - 2) + 1;
-        --tokCurLine;
+  // Move to the next token
+
+  pp.next = function() {
+    if (this.options.onToken)
+      this.options.onToken(new Token(this));
+
+    this.lastTokEnd = this.end;
+    this.lastTokStart = this.start;
+    this.lastTokEndLoc = this.endLoc;
+    this.readToken();
+  };
+
+  // Toggle strict mode. Re-reads the next number or string to please
+  // pedantic tests (`"use strict"; 010;` should fail).
+
+  pp.setStrict = function(strict) {
+    this.strict = strict;
+    if (this.type !== _num && this.type !== _string) return;
+    this.pos = this.start;
+    if (this.options.locations) {
+      while (this.pos < this.lineStart) {
+        this.lineStart = this.input.lastIndexOf("\n", this.lineStart - 2) + 1;
+        --this.curLine;
       }
     }
-    skipSpace();
-    readToken();
+    this.skipSpace();
+    this.readToken();
+  };
+
+  pp.curTokContext = function() {
+    return this.context[this.context.length - 1];
+  };
+
+  // Read a single token, updating the parser object's token-related
+  // properties.
+
+  pp.readToken = function() {
+    this.start = this.pos;
+    if (this.options.locations) this.startLoc = this.curPosition();
+    if (this.pos >= this.input.length) return this.finishToken(_eof);
+
+    if (this.curTokContext() === q_tmpl)
+      return this.readTmplToken();
+
+    var code = this.fullCharCodeAtPos();
+
+    // Identifier or keyword. '\uXXXX' sequences are allowed in
+    // identifiers, so '\' also dispatches to that.
+    if (isIdentifierStart(code, this.options.ecmaVersion >= 6) || code === 92 /* '\' */)
+      return this.readWord();
+
+    return this.getTokenFromCode(code);
+  };
+
+  pp.fullCharCodeAtPos = function() {
+    var code = this.input.charCodeAt(this.pos);
+    if (code <= 0xd7ff || code >= 0xe000) return code;
+    var next = this.input.charCodeAt(this.pos + 1);
+    return (code << 10) + next - 0x35fdc00;
+  };
+
+  pp.skipBlockComment = function() {
+    var startLoc = this.options.onComment && this.options.locations && this.curPosition();
+    var start = this.pos, end = this.input.indexOf("*/", this.pos += 2);
+    if (end === -1) this.raise(this.pos - 2, "Unterminated comment");
+    this.pos = end + 2;
+    if (this.options.locations) {
+      lineBreak.lastIndex = start;
+      var match;
+      while ((match = lineBreak.exec(this.input)) && match.index < this.pos) {
+        ++this.curLine;
+        this.lineStart = match.index + match[0].length;
+      }
+    }
+    if (this.options.onComment)
+      this.options.onComment(true, this.input.slice(start + 2, end), start, this.pos,
+                             startLoc, this.options.locations && this.curPosition());
+  };
+
+  pp.skipLineComment = function(startSkip) {
+    var start = this.pos;
+    var startLoc = this.options.onComment && this.options.locations && this.curPosition();
+    var ch = this.input.charCodeAt(this.pos+=startSkip);
+    while (this.pos < this.input.length && ch !== 10 && ch !== 13 && ch !== 8232 && ch !== 8233) {
+      ++this.pos;
+      ch = this.input.charCodeAt(this.pos);
+    }
+    if (this.options.onComment)
+      this.options.onComment(false, this.input.slice(start + startSkip, this.pos), start, this.pos,
+                             startLoc, this.options.locations && this.curPosition());
+  };
+
+  // Called at the start of the parse and after every token. Skips
+  // whitespace and comments, and.
+
+  pp.skipSpace = function() {
+    while (this.pos < this.input.length) {
+      var ch = this.input.charCodeAt(this.pos);
+      if (ch === 32) { // ' '
+        ++this.pos;
+      } else if (ch === 13) {
+        ++this.pos;
+        var next = this.input.charCodeAt(this.pos);
+        if (next === 10) {
+          ++this.pos;
+        }
+        if (this.options.locations) {
+          ++this.curLine;
+          this.lineStart = this.pos;
+        }
+      } else if (ch === 10 || ch === 8232 || ch === 8233) {
+        ++this.pos;
+        if (this.options.locations) {
+          ++this.curLine;
+          this.lineStart = this.pos;
+        }
+      } else if (ch > 8 && ch < 14) {
+        ++this.pos;
+      } else if (ch === 47) { // '/'
+        var next = this.input.charCodeAt(this.pos + 1);
+        if (next === 42) { // '*'
+          this.skipBlockComment();
+        } else if (next === 47) { // '/'
+          this.skipLineComment(2);
+        } else break;
+      } else if (ch === 160) { // '\xa0'
+        ++this.pos;
+      } else if (ch >= 5760 && nonASCIIwhitespace.test(String.fromCharCode(ch))) {
+        ++this.pos;
+      } else {
+        break;
+      }
+    }
+  };
+
+  pp.curPosition = function() {
+    return new Position(this.curLine, this.pos - this.lineStart);
+  };
+
+  // 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
+
+  var b_stat = {token: "{", isExpr: false}, b_expr = {token: "{", isExpr: true}, b_tmpl = {token: "${", isExpr: true};
+  var p_stat = {token: "(", isExpr: false}, p_expr = {token: "(", isExpr: true};
+  var q_tmpl = {token: "`", isExpr: true}, f_expr = {token: "function", isExpr: true};
+
+  pp.braceIsBlock = function(prevType) {
+    var parent;
+    if (prevType === _colon && (parent = this.curTokContext()).token == "{")
+      return !parent.isExpr;
+    if (prevType === _return)
+      return newline.test(this.input.slice(this.lastTokEnd, this.start));
+    if (prevType === _else || prevType === _semi || prevType === _eof)
+      return true;
+    if (prevType == _braceL)
+      return this.curTokContext() === b_stat;
+    return !this.exprAllowed;
+  };
+
+  // Called at the end of every token. Sets `end`, `val`, and
+  // maintains `context` and `exprAllowed`, and skips the space after
+  // the token, so that the next one's `start` will point at the
+  // right position.
+
+  pp.finishToken = function(type, val) {
+    this.end = this.pos;
+    if (this.options.locations) this.endLoc = this.curPosition();
+    var prevType = this.type, preserveSpace = false;
+    this.type = type;
+    this.value = val;
+
+    // Update context info
+    if (type === _parenR || type === _braceR) {
+      var out = this.context.pop();
+      if (out === b_tmpl) {
+        preserveSpace = true;
+      } else if (out === b_stat && this.curTokContext() === f_expr) {
+        this.context.pop();
+        this.exprAllowed = false;
+      } else {
+        this.exprAllowed = !(out && out.isExpr);
+      }
+    } else if (type === _braceL) {
+      this.context.push(this.braceIsBlock(prevType) ? b_stat : b_expr);
+      this.exprAllowed = true;
+    } else if (type === _dollarBraceL) {
+      this.context.push(b_tmpl);
+      this.exprAllowed = true;
+    } else if (type == _parenL) {
+      var statementParens = prevType === _if || prevType === _for || prevType === _with || prevType === _while;
+      this.context.push(statementParens ? p_stat : p_expr);
+      this.exprAllowed = true;
+    } else if (type == _incDec) {
+      // tokExprAllowed stays unchanged
+    } else if (type.keyword && prevType == _dot) {
+      this.exprAllowed = false;
+    } else if (type == _function) {
+      if (this.curTokContext() !== b_stat) {
+        this.context.push(f_expr);
+      }
+      this.exprAllowed = false;
+    } else if (type === _backQuote) {
+      if (this.curTokContext() === q_tmpl) {
+        this.context.pop();
+      } else {
+        this.context.push(q_tmpl);
+        preserveSpace = true;
+      }
+      this.exprAllowed = false;
+    } else {
+      this.exprAllowed = type.beforeExpr;
+    }
+
+    if (!preserveSpace) this.skipSpace();
+  };
+
+  // ### Token reading
+
+  // This is the function that is called to fetch the next token. It
+  // is somewhat obscure, because it works in character codes rather
+  // than characters, and because operator parsing has been inlined
+  // into it.
+  //
+  // All in the name of speed.
+  //
+  pp.readToken_dot = function() {
+    var next = this.input.charCodeAt(this.pos + 1);
+    if (next >= 48 && next <= 57) return this.readNumber(true);
+    var next2 = this.input.charCodeAt(this.pos + 2);
+    if (this.options.ecmaVersion >= 6 && next === 46 && next2 === 46) { // 46 = dot '.'
+      this.pos += 3;
+      return this.finishToken(_ellipsis);
+    } else {
+      ++this.pos;
+      return this.finishToken(_dot);
+    }
+  };
+
+  pp.readToken_slash = function() { // '/'
+    var next = this.input.charCodeAt(this.pos + 1);
+    if (this.exprAllowed) {++this.pos; return this.readRegexp();}
+    if (next === 61) return this.finishOp(_assign, 2);
+    return this.finishOp(_slash, 1);
+  };
+
+  pp.readToken_mult_modulo = function(code) { // '%*'
+    var next = this.input.charCodeAt(this.pos + 1);
+    if (next === 61) return this.finishOp(_assign, 2);
+    return this.finishOp(code === 42 ? _star : _modulo, 1);
+  };
+
+  pp.readToken_pipe_amp = function(code) { // '|&'
+    var next = this.input.charCodeAt(this.pos + 1);
+    if (next === code) return this.finishOp(code === 124 ? _logicalOR : _logicalAND, 2);
+    if (next === 61) return this.finishOp(_assign, 2);
+    return this.finishOp(code === 124 ? _bitwiseOR : _bitwiseAND, 1);
+  };
+
+  pp.readToken_caret = function() { // '^'
+    var next = this.input.charCodeAt(this.pos + 1);
+    if (next === 61) return this.finishOp(_assign, 2);
+    return this.finishOp(_bitwiseXOR, 1);
+  };
+
+  pp.readToken_plus_min = function(code) { // '+-'
+    var next = this.input.charCodeAt(this.pos + 1);
+    if (next === code) {
+      if (next == 45 && this.input.charCodeAt(this.pos + 2) == 62 &&
+          newline.test(this.input.slice(this.lastTokEnd, this.pos))) {
+        // A `-->` line comment
+        this.skipLineComment(3);
+        this.skipSpace();
+        return this.readToken();
+      }
+      return this.finishOp(_incDec, 2);
+    }
+    if (next === 61) return this.finishOp(_assign, 2);
+    return this.finishOp(_plusMin, 1);
+  };
+
+  pp.readToken_lt_gt = function(code) { // '<>'
+    var next = this.input.charCodeAt(this.pos + 1);
+    var size = 1;
+    if (next === code) {
+      size = code === 62 && this.input.charCodeAt(this.pos + 2) === 62 ? 3 : 2;
+      if (this.input.charCodeAt(this.pos + size) === 61) return this.finishOp(_assign, size + 1);
+      return this.finishOp(_bitShift, size);
+    }
+    if (next == 33 && code == 60 && this.input.charCodeAt(this.pos + 2) == 45 &&
+        this.input.charCodeAt(this.pos + 3) == 45) {
+      // `<!--`, an XML-style comment that should be interpreted as a line comment
+      this.skipLineComment(4);
+      this.skipSpace();
+      return this.readToken();
+    }
+    if (next === 61)
+      size = this.input.charCodeAt(this.pos + 2) === 61 ? 3 : 2;
+    return this.finishOp(_relational, size);
+  };
+
+  pp.readToken_eq_excl = function(code) { // '=!', '=>'
+    var next = this.input.charCodeAt(this.pos + 1);
+    if (next === 61) return this.finishOp(_equality, this.input.charCodeAt(this.pos + 2) === 61 ? 3 : 2);
+    if (code === 61 && next === 62 && this.options.ecmaVersion >= 6) { // '=>'
+      this.pos += 2;
+      return this.finishToken(_arrow);
+    }
+    return this.finishOp(code === 61 ? _eq : _prefix, 1);
+  };
+
+  pp.getTokenFromCode = function(code) {
+    switch (code) {
+    // The interpretation of a dot depends on whether it is followed
+    // by a digit or another two dots.
+    case 46: // '.'
+      return this.readToken_dot();
+
+    // Punctuation tokens.
+    case 40: ++this.pos; return this.finishToken(_parenL);
+    case 41: ++this.pos; return this.finishToken(_parenR);
+    case 59: ++this.pos; return this.finishToken(_semi);
+    case 44: ++this.pos; return this.finishToken(_comma);
+    case 91: ++this.pos; return this.finishToken(_bracketL);
+    case 93: ++this.pos; return this.finishToken(_bracketR);
+    case 123: ++this.pos; return this.finishToken(_braceL);
+    case 125: ++this.pos; return this.finishToken(_braceR);
+    case 58: ++this.pos; return this.finishToken(_colon);
+    case 63: ++this.pos; return this.finishToken(_question);
+
+    case 96: // '`'
+      if (this.options.ecmaVersion < 6) break;
+      ++this.pos;
+      return this.finishToken(_backQuote);
+
+    case 48: // '0'
+      var next = this.input.charCodeAt(this.pos + 1);
+      if (next === 120 || next === 88) return this.readRadixNumber(16); // '0x', '0X' - hex number
+      if (this.options.ecmaVersion >= 6) {
+        if (next === 111 || next === 79) return this.readRadixNumber(8); // '0o', '0O' - octal number
+        if (next === 98 || next === 66) return this.readRadixNumber(2); // '0b', '0B' - binary number
+      }
+    // Anything else beginning with a digit is an integer, octal
+    // number, or float.
+    case 49: case 50: case 51: case 52: case 53: case 54: case 55: case 56: case 57: // 1-9
+      return this.readNumber(false);
+
+    // Quotes produce strings.
+    case 34: case 39: // '"', "'"
+      return this.readString(code);
+
+    // Operators are parsed inline in tiny state machines. '=' (61) is
+    // often referred to. `finishOp` simply skips the amount of
+    // characters it is given as second argument, and returns a token
+    // of the type given by its first argument.
+
+    case 47: // '/'
+      return this.readToken_slash();
+
+    case 37: case 42: // '%*'
+      return this.readToken_mult_modulo(code);
+
+    case 124: case 38: // '|&'
+      return this.readToken_pipe_amp(code);
+
+    case 94: // '^'
+      return this.readToken_caret();
+
+    case 43: case 45: // '+-'
+      return this.readToken_plus_min(code);
+
+    case 60: case 62: // '<>'
+      return this.readToken_lt_gt(code);
+
+    case 61: case 33: // '=!'
+      return this.readToken_eq_excl(code);
+
+    case 126: // '~'
+      return this.finishOp(_prefix, 1);
+    }
+
+    this.raise(this.pos, "Unexpected character '" + codePointToString(code) + "'");
   }
 
+  pp.finishOp = function(type, size) {
+    var str = this.input.slice(this.pos, this.pos + size);
+    this.pos += size;
+    return this.finishToken(type, str);
+  };
+
+  var regexpUnicodeSupport = false;
+  try { new RegExp("\uffff", "u"); regexpUnicodeSupport = true; }
+  catch(e) {}
+
+  // Parse a regular expression. Some context-awareness is necessary,
+  // since a '/' inside a '[]' set does not end the expression.
+
+  pp.readRegexp = function() {
+    var content = "", escaped, inClass, start = this.pos;
+    for (;;) {
+      if (this.pos >= this.input.length) this.raise(start, "Unterminated regular expression");
+      var ch = this.input.charAt(this.pos);
+      if (newline.test(ch)) this.raise(start, "Unterminated regular expression");
+      if (!escaped) {
+        if (ch === "[") inClass = true;
+        else if (ch === "]" && inClass) inClass = false;
+        else if (ch === "/" && !inClass) break;
+        escaped = ch === "\\";
+      } else escaped = false;
+      ++this.pos;
+    }
+    var content = this.input.slice(start, this.pos);
+    ++this.pos;
+    // Need to use `readWord1` because '\uXXXX' sequences are allowed
+    // here (don't ask).
+    var mods = this.readWord1();
+    var tmp = content;
+    if (mods) {
+      var validFlags = /^[gmsiy]*$/;
+      if (this.options.ecmaVersion >= 6) validFlags = /^[gmsiyu]*$/;
+      if (!validFlags.test(mods)) this.raise(start, "Invalid regular expression flag");
+      if (mods.indexOf('u') >= 0 && !regexpUnicodeSupport) {
+        // Replace each astral symbol and every Unicode code point
+        // escape sequence that represents such a symbol with a single
+        // ASCII symbol to avoid throwing on regular expressions that
+        // are only valid in combination with the `/u` flag.
+        tmp = tmp
+          .replace(/\\u\{([0-9a-fA-F]{5,6})\}/g, "x")
+          .replace(/[\uD800-\uDBFF][\uDC00-\uDFFF]/g, "x");
+      }
+    }
+    // Detect invalid regular expressions.
+    try {
+      new RegExp(tmp);
+    } catch (e) {
+      if (e instanceof SyntaxError) this.raise(start, "Error parsing regular expression: " + e.message);
+      this.raise(e);
+    }
+    // Get a regular expression object for this pattern-flag pair, or `null` in
+    // case the current environment doesn't support the flags it uses.
+    try {
+      var value = new RegExp(content, mods);
+    } catch (err) {
+      value = null;
+    }
+    return this.finishToken(_regexp, {pattern: content, flags: mods, value: value});
+  };
+
+  // Read an integer in the given radix. Return null if zero digits
+  // were read, the integer value otherwise. When `len` is given, this
+  // will return `null` unless the integer has exactly `len` digits.
+
+  pp.readInt = function(radix, len) {
+    var start = this.pos, total = 0;
+    for (var i = 0, e = len == null ? Infinity : len; i < e; ++i) {
+      var code = this.input.charCodeAt(this.pos), val;
+      if (code >= 97) val = code - 97 + 10; // a
+      else if (code >= 65) val = code - 65 + 10; // A
+      else if (code >= 48 && code <= 57) val = code - 48; // 0-9
+      else val = Infinity;
+      if (val >= radix) break;
+      ++this.pos;
+      total = total * radix + val;
+    }
+    if (this.pos === start || len != null && this.pos - start !== len) return null;
+
+    return total;
+  };
+
+  pp.readRadixNumber = function(radix) {
+    this.pos += 2; // 0x
+    var val = this.readInt(radix);
+    if (val == null) this.raise(this.start + 2, "Expected number in radix " + radix);
+    if (isIdentifierStart(this.fullCharCodeAtPos())) this.raise(this.pos, "Identifier directly after number");
+    return this.finishToken(_num, val);
+  };
+
+  // Read an integer, octal integer, or floating-point number.
+
+  pp.readNumber = function(startsWithDot) {
+    var start = this.pos, isFloat = false, octal = this.input.charCodeAt(this.pos) === 48;
+    if (!startsWithDot && this.readInt(10) === null) this.raise(start, "Invalid number");
+    if (this.input.charCodeAt(this.pos) === 46) {
+      ++this.pos;
+      this.readInt(10);
+      isFloat = true;
+    }
+    var next = this.input.charCodeAt(this.pos);
+    if (next === 69 || next === 101) { // 'eE'
+      next = this.input.charCodeAt(++this.pos);
+      if (next === 43 || next === 45) ++this.pos; // '+-'
+      if (this.readInt(10) === null) this.raise(start, "Invalid number");
+      isFloat = true;
+    }
+    if (isIdentifierStart(this.fullCharCodeAtPos())) this.raise(this.pos, "Identifier directly after number");
+
+    var str = this.input.slice(start, this.pos), val;
+    if (isFloat) val = parseFloat(str);
+    else if (!octal || str.length === 1) val = parseInt(str, 10);
+    else if (/[89]/.test(str) || this.strict) this.raise(start, "Invalid number");
+    else val = parseInt(str, 8);
+    return this.finishToken(_num, val);
+  };
+
+  // Read a string value, interpreting backslash-escapes.
+
+  pp.readCodePoint = function() {
+    var ch = this.input.charCodeAt(this.pos), code;
+
+    if (ch === 123) {
+      if (this.options.ecmaVersion < 6) this.unexpected();
+      ++this.pos;
+      code = this.readHexChar(this.input.indexOf('}', this.pos) - this.pos);
+      ++this.pos;
+      if (code > 0x10FFFF) this.unexpected();
+    } else {
+      code = this.readHexChar(4);
+    }
+    return code;
+  }
+
+  function codePointToString(code) {
+    // UTF-16 Decoding
+    if (code <= 0xFFFF) return String.fromCharCode(code);
+    return String.fromCharCode(((code - 0x10000) >> 10) + 0xD800,
+                               ((code - 0x10000) & 1023) + 0xDC00);
+  }
+
+  pp.readString = function(quote) {
+    var out = "", chunkStart = ++this.pos;
+    for (;;) {
+      if (this.pos >= this.input.length) this.raise(this.start, "Unterminated string constant");
+      var ch = this.input.charCodeAt(this.pos);
+      if (ch === quote) break;
+      if (ch === 92) { // '\'
+        out += this.input.slice(chunkStart, this.pos);
+        out += this.readEscapedChar();
+        chunkStart = this.pos;
+      } else {
+        if (isNewLine(ch)) this.raise(this.start, "Unterminated string constant");
+        ++this.pos;
+      }
+    }
+    out += this.input.slice(chunkStart, this.pos++);
+    return this.finishToken(_string, out);
+  };
+
+  // Reads template string tokens.
+
+  pp.readTmplToken = function() {
+    var out = "", chunkStart = this.pos;
+    for (;;) {
+      if (this.pos >= this.input.length) this.raise(this.start, "Unterminated template");
+      var ch = this.input.charCodeAt(this.pos);
+      if (ch === 96 || ch === 36 && this.input.charCodeAt(this.pos + 1) === 123) { // '`', '${'
+        if (this.pos === this.start && this.type === _template) {
+          if (ch === 36) {
+            this.pos += 2;
+            return this.finishToken(_dollarBraceL);
+          } else {
+            ++this.pos;
+            return this.finishToken(_backQuote);
+          }
+        }
+        out += this.input.slice(chunkStart, this.pos);
+        return this.finishToken(_template, out);
+      }
+      if (ch === 92) { // '\'
+        out += this.input.slice(chunkStart, this.pos);
+        out += this.readEscapedChar();
+        chunkStart = this.pos;
+      } else if (isNewLine(ch)) {
+        out += this.input.slice(chunkStart, this.pos);
+        ++this.pos;
+        if (ch === 13 && this.input.charCodeAt(this.pos) === 10) {
+          ++this.pos;
+          out += "\n";
+        } else {
+          out += String.fromCharCode(ch);
+        }
+        if (this.options.locations) {
+          ++this.curLine;
+          this.lineStart = this.pos;
+        }
+        chunkStart = this.pos;
+      } else {
+        ++this.pos;
+      }
+    }
+  };
+
+  // Used to read escaped characters
+
+  pp.readEscapedChar = function() {
+    var ch = this.input.charCodeAt(++this.pos);
+    var octal = /^[0-7]+/.exec(this.input.slice(this.pos, this.pos + 3));
+    if (octal) octal = octal[0];
+    while (octal && parseInt(octal, 8) > 255) octal = octal.slice(0, -1);
+    if (octal === "0") octal = null;
+    ++this.pos;
+    if (octal) {
+      if (this.strict) this.raise(this.pos - 2, "Octal literal in strict mode");
+      this.pos += octal.length - 1;
+      return String.fromCharCode(parseInt(octal, 8));
+    } else {
+      switch (ch) {
+        case 110: return "\n"; // 'n' -> '\n'
+        case 114: return "\r"; // 'r' -> '\r'
+        case 120: return String.fromCharCode(this.readHexChar(2)); // 'x'
+        case 117: return codePointToString(this.readCodePoint()); // 'u'
+        case 116: return "\t"; // 't' -> '\t'
+        case 98: return "\b"; // 'b' -> '\b'
+        case 118: return "\u000b"; // 'v' -> '\u000b'
+        case 102: return "\f"; // 'f' -> '\f'
+        case 48: return "\0"; // 0 -> '\0'
+        case 13: if (this.input.charCodeAt(this.pos) === 10) ++this.pos; // '\r\n'
+        case 10: // ' \n'
+          if (this.options.locations) { this.lineStart = this.pos; ++this.curLine; }
+          return "";
+        default: return String.fromCharCode(ch);
+      }
+    }
+  };
+
+  // Used to read character escape sequences ('\x', '\u', '\U').
+
+  pp.readHexChar = function(len) {
+    var n = this.readInt(16, len);
+    if (n === null) this.raise(this.start, "Bad character escape sequence");
+    return n;
+  };
+
+  // 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.
+
+  var containsEsc;
+
+  // Read an identifier, and return it as a string. Sets `containsEsc`
+  // to whether the word contained a '\u' escape.
+  //
+  // Incrementally adds only escaped chars, adding other chunks as-is
+  // as a micro-optimization.
+
+  pp.readWord1 = function() {
+    containsEsc = false;
+    var word = "", first = true, chunkStart = this.pos;
+    var astral = this.options.ecmaVersion >= 6;
+    while (this.pos < this.input.length) {
+      var ch = this.fullCharCodeAtPos();
+      if (isIdentifierChar(ch, astral)) {
+        this.pos += ch <= 0xffff ? 1 : 2;
+      } else if (ch === 92) { // "\"
+        containsEsc = true;
+        word += this.input.slice(chunkStart, this.pos);
+        var escStart = this.pos;
+        if (this.input.charCodeAt(++this.pos) != 117) // "u"
+          this.raise(this.pos, "Expecting Unicode escape sequence \\uXXXX");
+        ++this.pos;
+        var esc = this.readCodePoint();
+        if (!(first ? isIdentifierStart : isIdentifierChar)(esc, astral))
+          this.raise(escStart, "Invalid Unicode escape");
+        word += codePointToString(esc);
+        chunkStart = this.pos;
+      } else {
+        break;
+      }
+      first = false;
+    }
+    return word + this.input.slice(chunkStart, this.pos);
+  };
+
+  // Read an identifier or keyword token. Will check for reserved
+  // words when necessary.
+
+  pp.readWord = function() {
+    var word = this.readWord1();
+    var type = _name;
+    if ((this.options.ecmaVersion >= 6 || !containsEsc) && this.isKeyword(word))
+      type = keywordTypes[word];
+    return this.finishToken(type, word);
+  };
+
+  // This function is used to raise exceptions on parse errors. It
+  // takes an offset integer (into the current `input`) to indicate
+  // the location of the error, attaches the position to the end
+  // of the error message, and then raises a `SyntaxError` with that
+  // message.
+
+  pp.raise = function(pos, message) {
+    var loc = getLineInfo(this.input, pos);
+    message += " (" + loc.line + ":" + loc.column + ")";
+    var err = new SyntaxError(message);
+    err.pos = pos; err.loc = loc; err.raisedAt = this.pos;
+    throw err;
+  };
+
+  pp.currentPos = function() {
+    return this.options.locations ? [this.start, this.startLoc] : this.start;
+  };
+
+  // ### Parser utilities
+
   // Start an AST node, attaching a start offset.
 
-  function Node() {
-    this.type = null;
-    this.start = tokStart;
-    this.end = null;
+  var Node = exports.Node = function() {};
+
+  function SourceLocation(p) {
+    this.start = p.startLoc;
+    if (p.sourceFile !== null) this.source = p.sourceFile;
   }
 
-  exports.Node = Node;
-
-  function SourceLocation() {
-    this.start = tokStartLoc;
-    this.end = null;
-    if (sourceFile !== null) this.source = sourceFile;
-  }
-
-  function startNode() {
-    var node = new Node();
-    if (options.locations)
-      node.loc = new SourceLocation();
-    if (options.directSourceFile)
-      node.sourceFile = options.directSourceFile;
-    if (options.ranges)
-      node.range = [tokStart, 0];
+  pp.startNode = function() {
+    var node = new Node;
+    node.start = this.start;
+    if (this.options.locations)
+      node.loc = new SourceLocation(this);
+    if (this.options.directSourceFile)
+      node.sourceFile = this.options.directSourceFile;
+    if (this.options.ranges)
+      node.range = [this.start, 0];
     return node;
-  }
+  };
 
-  // Sometimes, a node is only started *after* the token stream passed
-  // its start position. The functions below help storing a position
-  // and creating a node from a previous position.
-
-  function storeCurrentPos() {
-    return options.locations ? [tokStart, tokStartLoc] : tokStart;
-  }
-
-  function startNodeAt(pos) {
-    var node = new Node(), start = pos;
-    if (options.locations) {
-      node.loc = new SourceLocation();
+  pp.startNodeAt = function(pos) {
+    var node = new Node, start = pos;
+    if (this.options.locations) {
+      node.loc = new SourceLocation(this);
       node.loc.start = start[1];
       start = pos[0];
     }
     node.start = start;
-    if (options.directSourceFile)
-      node.sourceFile = options.directSourceFile;
-    if (options.ranges)
+    if (this.options.directSourceFile)
+      node.sourceFile = this.options.directSourceFile;
+    if (this.options.ranges)
       node.range = [start, 0];
-
     return node;
-  }
+  };
 
   // Finish an AST node, adding `type` and `end` properties.
 
-  function finishNode(node, type) {
+  pp.finishNode = function(node, type) {
     node.type = type;
-    node.end = lastEnd;
-    if (options.locations)
-      node.loc.end = lastEndLoc;
-    if (options.ranges)
-      node.range[1] = lastEnd;
+    node.end = this.lastTokEnd;
+    if (this.options.locations)
+      node.loc.end = this.lastTokEndLoc;
+    if (this.options.ranges)
+      node.range[1] = this.lastTokEnd;
     return node;
-  }
+  };
 
   // Finish node at given position
 
-  function finishNodeAt(node, type, pos) {
-    if (options.locations) { node.loc.end = pos[1]; pos = pos[0]; }
+  pp.finishNodeAt = function(node, type, pos) {
+    if (this.options.locations) { node.loc.end = pos[1]; pos = pos[0]; }
     node.type = type;
     node.end = pos;
-    if (options.ranges)
+    if (this.options.ranges)
       node.range[1] = pos;
     return node;
-  }
+  };
 
   // Test whether a statement node is the string literal `"use strict"`.
 
-  function isUseStrict(stmt) {
-    return options.ecmaVersion >= 5 && stmt.type === "ExpressionStatement" &&
+  pp.isUseStrict = function(stmt) {
+    return this.options.ecmaVersion >= 5 && stmt.type === "ExpressionStatement" &&
       stmt.expression.type === "Literal" && stmt.expression.value === "use strict";
-  }
+  };
 
   // Predicate that tests whether the next token is of the given
   // type, and if yes, consumes it as a side effect.
 
-  function eat(type) {
-    if (tokType === type) {
-      next();
+  pp.eat = function(type) {
+    if (this.type === type) {
+      this.next();
       return true;
     } else {
       return false;
     }
-  }
+  };
 
   // Tests whether parsed token is a contextual keyword.
 
-  function isContextual(name) {
-    return tokType === _name && tokVal === name;
-  }
+  pp.isContextual = function(name) {
+    return this.type === _name && this.value === name;
+  };
 
   // Consumes contextual keyword if possible.
 
-  function eatContextual(name) {
-    return tokVal === name && eat(_name);
-  }
+  pp.eatContextual = function(name) {
+    return this.value === name && this.eat(_name);
+  };
 
   // Asserts that following token is given contextual keyword.
 
-  function expectContextual(name) {
-    if (!eatContextual(name)) unexpected();
-  }
+  pp.expectContextual = function(name) {
+    if (!this.eatContextual(name)) this.unexpected();
+  };
 
   // Test whether a semicolon can be inserted at the current position.
 
-  function canInsertSemicolon() {
-    return !options.strictSemicolons &&
-      (tokType === _eof || tokType === _braceR || newline.test(input.slice(lastEnd, tokStart)));
-  }
+  pp.canInsertSemicolon = function() {
+    return !this.options.strictSemicolons &&
+      (this.type === _eof || this.type === _braceR || newline.test(this.input.slice(this.lastTokEnd, this.start)));
+  };
 
   // Consume a semicolon, or, failing that, see if we are allowed to
   // pretend that there is a semicolon at this position.
 
-  function semicolon() {
-    if (!eat(_semi) && !canInsertSemicolon()) unexpected();
-  }
+  pp.semicolon = function() {
+    if (!this.eat(_semi) && !this.canInsertSemicolon()) this.unexpected();
+  };
 
   // Expect a token of a given type. If found, consume it, otherwise,
   // raise an unexpected token error.
 
-  function expect(type) {
-    eat(type) || unexpected();
-  }
+  pp.expect = function(type) {
+    this.eat(type) || this.unexpected();
+  };
 
   // Raise an unexpected token error.
 
-  function unexpected(pos) {
-    raise(pos != null ? pos : tokStart, "Unexpected token");
+  pp.unexpected = function(pos) {
+    this.raise(pos != null ? pos : this.start, "Unexpected token");
+  };
+
+  function isArray(obj) {
+    return Object.prototype.toString.call(obj) === "[object Array]";
   }
 
-  // Checks if hash object has a property.
+  // Checks if an object has a property.
 
   function has(obj, propName) {
     return Object.prototype.hasOwnProperty.call(obj, propName);
@@ -1499,8 +1455,8 @@
   // Convert existing expression atom to assignable pattern
   // if possible.
 
-  function toAssignable(node, isBinding) {
-    if (options.ecmaVersion >= 6 && node) {
+  pp.toAssignable = function(node, isBinding) {
+    if (this.options.ecmaVersion >= 6 && node) {
       switch (node.type) {
         case "Identifier":
         case "ObjectPattern":
@@ -1512,21 +1468,21 @@
           node.type = "ObjectPattern";
           for (var i = 0; i < node.properties.length; i++) {
             var prop = node.properties[i];
-            if (prop.kind !== "init") raise(prop.key.start, "Object pattern can't contain getter or setter");
-            toAssignable(prop.value, isBinding);
+            if (prop.kind !== "init") this.raise(prop.key.start, "Object pattern can't contain getter or setter");
+            this.toAssignable(prop.value, isBinding);
           }
           break;
 
         case "ArrayExpression":
           node.type = "ArrayPattern";
-          toAssignableList(node.elements, isBinding);
+          this.toAssignableList(node.elements, isBinding);
           break;
 
         case "AssignmentExpression":
           if (node.operator === "=") {
             node.type = "AssignmentPattern";
           } else {
-            raise(node.left.end, "Only '=' operator can be used for specifying default value.");
+            this.raise(node.left.end, "Only '=' operator can be used for specifying default value.");
           }
           break;
 
@@ -1534,18 +1490,18 @@
           if (!isBinding) break;
 
         default:
-          raise(node.start, "Assigning to rvalue");
+          this.raise(node.start, "Assigning to rvalue");
       }
     }
     return node;
-  }
+  };
 
   // Convert list of expression atoms to binding list.
 
-  function toAssignableList(exprList, isBinding) {
+  pp.toAssignableList = function(exprList, isBinding) {
     if (exprList.length) {
       for (var i = 0; i < exprList.length - 1; i++) {
-        toAssignable(exprList[i], isBinding);
+        this.toAssignable(exprList[i], isBinding);
       }
       var last = exprList[exprList.length - 1];
       switch (last.type) {
@@ -1554,119 +1510,119 @@
         case "SpreadElement":
           last.type = "RestElement";
           var arg = last.argument;
-          toAssignable(arg, isBinding);
+          this.toAssignable(arg, isBinding);
           if (arg.type !== "Identifier" && arg.type !== "MemberExpression" && arg.type !== "ArrayPattern")
-            unexpected(arg.start);
+            this.unexpected(arg.start);
           break;
         default:
-          toAssignable(last, isBinding);
+          this.toAssignable(last, isBinding);
       }
     }
     return exprList;
-  }
+  };
 
   // Parses spread element.
 
-  function parseSpread(refShorthandDefaultPos) {
-    var node = startNode();
-    next();
-    node.argument = parseMaybeAssign(refShorthandDefaultPos);
-    return finishNode(node, "SpreadElement");
-  }
+  pp.parseSpread = function(refShorthandDefaultPos) {
+    var node = this.startNode();
+    this.next();
+    node.argument = this.parseMaybeAssign(refShorthandDefaultPos);
+    return this.finishNode(node, "SpreadElement");
+  };
 
-  function parseRest() {
-    var node = startNode();
-    next();
-    node.argument = tokType === _name || tokType === _bracketL ? parseBindingAtom() : unexpected();
-    return finishNode(node, "RestElement");
-  }
+  pp.parseRest = function() {
+    var node = this.startNode();
+    this.next();
+    node.argument = this.type === _name || this.type === _bracketL ? this.parseBindingAtom() : this.unexpected();
+    return this.finishNode(node, "RestElement");
+  };
 
   // Parses lvalue (assignable) atom.
 
-  function parseBindingAtom() {
-    if (options.ecmaVersion < 6) return parseIdent();
-    switch (tokType) {
+  pp.parseBindingAtom = function() {
+    if (this.options.ecmaVersion < 6) return this.parseIdent();
+    switch (this.type) {
       case _name:
-        return parseIdent();
+        return this.parseIdent();
 
       case _bracketL:
-        var node = startNode();
-        next();
-        node.elements = parseBindingList(_bracketR, true);
-        return finishNode(node, "ArrayPattern");
+        var node = this.startNode();
+        this.next();
+        node.elements = this.parseBindingList(_bracketR, true);
+        return this.finishNode(node, "ArrayPattern");
 
       case _braceL:
-        return parseObj(true);
+        return this.parseObj(true);
 
       default:
-        unexpected();
+        this.unexpected();
     }
-  }
+  };
 
-  function parseBindingList(close, allowEmpty) {
+  pp.parseBindingList = function(close, allowEmpty) {
     var elts = [], first = true;
-    while (!eat(close)) {
-      first ? first = false : expect(_comma);
-      if (tokType === _ellipsis) {
-        elts.push(parseRest());
-        expect(close);
+    while (!this.eat(close)) {
+      first ? first = false : this.expect(_comma);
+      if (this.type === _ellipsis) {
+        elts.push(this.parseRest());
+        this.expect(close);
         break;
       }
-      elts.push(allowEmpty && tokType === _comma ? null : parseMaybeDefault());
+      elts.push(allowEmpty && this.type === _comma ? null : this.parseMaybeDefault());
     }
     return elts;
-  }
+  };
 
   // Parses assignment pattern around given atom if possible.
 
-  function parseMaybeDefault(startPos, left) {
-    startPos = startPos || storeCurrentPos();
-    left = left || parseBindingAtom();
-    if (!eat(_eq)) return left;
-    var node = startNodeAt(startPos);
+  pp.parseMaybeDefault = function(startPos, left) {
+    startPos = startPos || this.currentPos();
+    left = left || this.parseBindingAtom();
+    if (!this.eat(_eq)) return left;
+    var node = this.startNodeAt(startPos);
     node.operator = "=";
     node.left = left;
-    node.right = parseMaybeAssign();
-    return finishNode(node, "AssignmentPattern");
-  }
+    node.right = this.parseMaybeAssign();
+    return this.finishNode(node, "AssignmentPattern");
+  };
 
   // Verify that argument names are not repeated, and it does not
   // try to bind the words `eval` or `arguments`.
 
-  function checkFunctionParam(param, nameHash) {
+  pp.checkFunctionParam = function(param, nameHash) {
     switch (param.type) {
       case "Identifier":
         if (isStrictReservedWord(param.name) || isStrictBadIdWord(param.name))
-          raise(param.start, "Defining '" + param.name + "' in strict mode");
+          this.raise(param.start, "Defining '" + param.name + "' in strict mode");
         if (has(nameHash, param.name))
-          raise(param.start, "Argument name clash in strict mode");
+          this.raise(param.start, "Argument name clash in strict mode");
         nameHash[param.name] = true;
         break;
 
       case "ObjectPattern":
         for (var i = 0; i < param.properties.length; i++)
-          checkFunctionParam(param.properties[i].value, nameHash);
+          this.checkFunctionParam(param.properties[i].value, nameHash);
         break;
 
       case "ArrayPattern":
         for (var i = 0; i < param.elements.length; i++) {
           var elem = param.elements[i];
-          if (elem) checkFunctionParam(elem, nameHash);
+          if (elem) this.checkFunctionParam(elem, nameHash);
         }
         break;
 
       case "RestElement":
-        return checkFunctionParam(param.argument, nameHash);
+        return this.checkFunctionParam(param.argument, nameHash);
     }
-  }
+  };
 
   // Check if property name clashes with already added.
   // Object/class getters and setters are not allowed to clash —
   // either with each other or with an init property — and in
   // strict mode, init properties are also not allowed to be repeated.
 
-  function checkPropClash(prop, propHash) {
-    if (options.ecmaVersion >= 6) return;
+  pp.checkPropClash = function(prop, propHash) {
+    if (this.options.ecmaVersion >= 6) return;
     var key = prop.key, name;
     switch (key.type) {
       case "Identifier": name = key.name; break;
@@ -1677,8 +1633,8 @@
     if (has(propHash, name)) {
       other = propHash[name];
       var isGetSet = kind !== "init";
-      if ((strict || isGetSet) && other[kind] || !(isGetSet ^ other.init))
-        raise(key.start, "Redefinition of property");
+      if ((this.strict || isGetSet) && other[kind] || !(isGetSet ^ other.init))
+        this.raise(key.start, "Redefinition of property");
     } else {
       other = propHash[name] = {
         init: false,
@@ -1687,46 +1643,46 @@
       };
     }
     other[kind] = true;
-  }
+  };
 
   // Verify that a node is an lval — something that can be assigned
   // to.
 
-  function checkLVal(expr, isBinding) {
+  pp.checkLVal = function(expr, isBinding) {
     switch (expr.type) {
       case "Identifier":
-        if (strict && (isStrictBadIdWord(expr.name) || isStrictReservedWord(expr.name)))
-          raise(expr.start, (isBinding ? "Binding " : "Assigning to ") + expr.name + " in strict mode");
+        if (this.strict && (isStrictBadIdWord(expr.name) || isStrictReservedWord(expr.name)))
+          this.raise(expr.start, (isBinding ? "Binding " : "Assigning to ") + expr.name + " in strict mode");
         break;
 
       case "MemberExpression":
-        if (isBinding) raise(expr.start, "Binding to member expression");
+        if (isBinding) this.raise(expr.start, "Binding to member expression");
         break;
 
       case "ObjectPattern":
         for (var i = 0; i < expr.properties.length; i++)
-          checkLVal(expr.properties[i].value, isBinding);
+          this.checkLVal(expr.properties[i].value, isBinding);
         break;
 
       case "ArrayPattern":
         for (var i = 0; i < expr.elements.length; i++) {
           var elem = expr.elements[i];
-          if (elem) checkLVal(elem, isBinding);
+          if (elem) this.checkLVal(elem, isBinding);
         }
         break;
 
       case "AssignmentPattern":
-        checkLVal(expr.left);
+        this.checkLVal(expr.left);
         break;
 
       case "RestElement":
-        checkLVal(expr.argument);
+        this.checkLVal(expr.argument);
         break;
 
       default:
-        raise(expr.start, "Assigning to rvalue");
+        this.raise(expr.start, "Assigning to rvalue");
     }
-  }
+  };
 
   // ### Statement parsing
 
@@ -1735,19 +1691,19 @@
   // `program` argument.  If present, the statements will be appended
   // to its body instead of creating a new node.
 
-  function parseTopLevel(node) {
+  pp.parseTopLevel = function(node) {
     var first = true;
     if (!node.body) node.body = [];
-    while (tokType !== _eof) {
-      var stmt = parseStatement(true, true);
+    while (this.type !== _eof) {
+      var stmt = this.parseStatement(true, true);
       node.body.push(stmt);
-      if (first && isUseStrict(stmt)) setStrict(true);
+      if (first && this.isUseStrict(stmt)) this.setStrict(true);
       first = false;
     }
 
-    next();
-    return finishNode(node, "Program");
-  }
+    this.next();
+    return this.finishNode(node, "Program");
+  };
 
   var loopLabel = {kind: "loop"}, switchLabel = {kind: "switch"};
 
@@ -1758,40 +1714,40 @@
   // `if (foo) /blah/.exec(foo);`, where looking at the previous token
   // does not help.
 
-  function parseStatement(declaration, topLevel) {
-    var starttype = tokType, node = startNode();
+  pp.parseStatement = function(declaration, topLevel) {
+    var starttype = this.type, node = this.startNode();
 
     // Most types of statements are recognized by the keyword they
     // start with. Many are trivial to parse, some require a bit of
     // complexity.
 
     switch (starttype) {
-    case _break: case _continue: return parseBreakContinueStatement(node, starttype.keyword);
-    case _debugger: return parseDebuggerStatement(node);
-    case _do: return parseDoStatement(node);
-    case _for: return parseForStatement(node);
+    case _break: case _continue: return this.parseBreakContinueStatement(node, starttype.keyword);
+    case _debugger: return this.parseDebuggerStatement(node);
+    case _do: return this.parseDoStatement(node);
+    case _for: return this.parseForStatement(node);
     case _function:
-      if (!declaration && options.ecmaVersion >= 6) unexpected();
-      return parseFunctionStatement(node);
+      if (!declaration && this.options.ecmaVersion >= 6) this.unexpected();
+      return this.parseFunctionStatement(node);
     case _class:
-      if (!declaration) unexpected();
-      return parseClass(node, true);
-    case _if: return parseIfStatement(node);
-    case _return: return parseReturnStatement(node);
-    case _switch: return parseSwitchStatement(node);
-    case _throw: return parseThrowStatement(node);
-    case _try: return parseTryStatement(node);
-    case _let: case _const: if (!declaration) unexpected(); // NOTE: falls through to _var
-    case _var: return parseVarStatement(node, starttype.keyword);
-    case _while: return parseWhileStatement(node);
-    case _with: return parseWithStatement(node);
-    case _braceL: return parseBlock(); // no point creating a function for this
-    case _semi: return parseEmptyStatement(node);
+      if (!declaration) this.unexpected();
+      return this.parseClass(node, true);
+    case _if: return this.parseIfStatement(node);
+    case _return: return this.parseReturnStatement(node);
+    case _switch: return this.parseSwitchStatement(node);
+    case _throw: return this.parseThrowStatement(node);
+    case _try: return this.parseTryStatement(node);
+    case _let: case _const: if (!declaration) this.unexpected(); // NOTE: falls through to _var
+    case _var: return this.parseVarStatement(node, starttype.keyword);
+    case _while: return this.parseWhileStatement(node);
+    case _with: return this.parseWithStatement(node);
+    case _braceL: return this.parseBlock(); // no point creating a function for this
+    case _semi: return this.parseEmptyStatement(node);
     case _export:
     case _import:
-      if (!topLevel && !options.allowImportExportEverywhere)
-        raise(tokStart, "'import' and 'export' may only appear at the top level");
-      return starttype === _import ? parseImport(node) : parseExport(node);
+      if (!topLevel && !this.options.allowImportExportEverywhere)
+        this.raise(this.start, "'import' and 'export' may only appear at the top level");
+      return starttype === _import ? this.parseImport(node) : this.parseExport(node);
 
       // If the statement does not start with a statement keyword or a
       // brace, it's an ExpressionStatement or LabeledStatement. We
@@ -1799,55 +1755,55 @@
       // next token is a colon and the expression was a simple
       // Identifier node, we switch to interpreting it as a label.
     default:
-      var maybeName = tokVal, expr = parseExpression();
-      if (starttype === _name && expr.type === "Identifier" && eat(_colon))
-        return parseLabeledStatement(node, maybeName, expr);
-      else return parseExpressionStatement(node, expr);
+      var maybeName = this.value, expr = this.parseExpression();
+      if (starttype === _name && expr.type === "Identifier" && this.eat(_colon))
+        return this.parseLabeledStatement(node, maybeName, expr);
+      else return this.parseExpressionStatement(node, expr);
     }
-  }
+  };
 
-  function parseBreakContinueStatement(node, keyword) {
+  pp.parseBreakContinueStatement = function(node, keyword) {
     var isBreak = keyword == "break";
-    next();
-    if (eat(_semi) || canInsertSemicolon()) node.label = null;
-    else if (tokType !== _name) unexpected();
+    this.next();
+    if (this.eat(_semi) || this.canInsertSemicolon()) node.label = null;
+    else if (this.type !== _name) this.unexpected();
     else {
-      node.label = parseIdent();
-      semicolon();
+      node.label = this.parseIdent();
+      this.semicolon();
     }
 
     // Verify that there is an actual destination to break or
     // continue to.
-    for (var i = 0; i < labels.length; ++i) {
-      var lab = labels[i];
+    for (var i = 0; i < this.labels.length; ++i) {
+      var lab = this.labels[i];
       if (node.label == null || lab.name === node.label.name) {
         if (lab.kind != null && (isBreak || lab.kind === "loop")) break;
         if (node.label && isBreak) break;
       }
     }
-    if (i === labels.length) raise(node.start, "Unsyntactic " + keyword);
-    return finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement");
-  }
+    if (i === this.labels.length) this.raise(node.start, "Unsyntactic " + keyword);
+    return this.finishNode(node, isBreak ? "BreakStatement" : "ContinueStatement");
+  };
 
-  function parseDebuggerStatement(node) {
-    next();
-    semicolon();
-    return finishNode(node, "DebuggerStatement");
-  }
+  pp.parseDebuggerStatement = function(node) {
+    this.next();
+    this.semicolon();
+    return this.finishNode(node, "DebuggerStatement");
+  };
 
-  function parseDoStatement(node) {
-    next();
-    labels.push(loopLabel);
-    node.body = parseStatement(false);
-    labels.pop();
-    expect(_while);
-    node.test = parseParenExpression();
-    if (options.ecmaVersion >= 6)
-      eat(_semi);
+  pp.parseDoStatement = function(node) {
+    this.next();
+    this.labels.push(loopLabel);
+    node.body = this.parseStatement(false);
+    this.labels.pop();
+    this.expect(_while);
+    node.test = this.parseParenExpression();
+    if (this.options.ecmaVersion >= 6)
+      this.eat(_semi);
     else
-      semicolon();
-    return finishNode(node, "DoWhileStatement");
-  }
+      this.semicolon();
+    return this.finishNode(node, "DoWhileStatement");
+  };
 
   // Disambiguating between a `for` and a `for`/`in` or `for`/`of`
   // loop is non-trivial. Basically, we have to parse the init `var`
@@ -1857,248 +1813,248 @@
   // part (semicolon immediately after the opening parenthesis), it
   // is a regular `for` loop.
 
-  function parseForStatement(node) {
-    next();
-    labels.push(loopLabel);
-    expect(_parenL);
-    if (tokType === _semi) return parseFor(node, null);
-    if (tokType === _var || tokType === _let) {
-      var init = startNode(), varKind = tokType.keyword, isLet = tokType === _let;
-      next();
-      parseVar(init, true, varKind);
-      finishNode(init, "VariableDeclaration");
-      if ((tokType === _in || (options.ecmaVersion >= 6 && isContextual("of"))) && init.declarations.length === 1 &&
+  pp.parseForStatement = function(node) {
+    this.next();
+    this.labels.push(loopLabel);
+    this.expect(_parenL);
+    if (this.type === _semi) return this.parseFor(node, null);
+    if (this.type === _var || this.type === _let) {
+      var init = this.startNode(), varKind = this.type.keyword, isLet = this.type === _let;
+      this.next();
+      this.parseVar(init, true, varKind);
+      this.finishNode(init, "VariableDeclaration");
+      if ((this.type === _in || (this.options.ecmaVersion >= 6 && this.isContextual("of"))) && init.declarations.length === 1 &&
           !(isLet && init.declarations[0].init))
-        return parseForIn(node, init);
-      return parseFor(node, init);
+        return this.parseForIn(node, init);
+      return this.parseFor(node, init);
     }
     var refShorthandDefaultPos = {start: 0};
-    var init = parseExpression(true, refShorthandDefaultPos);
-    if (tokType === _in || (options.ecmaVersion >= 6 && isContextual("of"))) {
-      toAssignable(init);
-      checkLVal(init);
-      return parseForIn(node, init);
+    var init = this.parseExpression(true, refShorthandDefaultPos);
+    if (this.type === _in || (this.options.ecmaVersion >= 6 && this.isContextual("of"))) {
+      this.toAssignable(init);
+      this.checkLVal(init);
+      return this.parseForIn(node, init);
     } else if (refShorthandDefaultPos.start) {
-      unexpected(refShorthandDefaultPos.start);
+      this.unexpected(refShorthandDefaultPos.start);
     }
-    return parseFor(node, init);
-  }
+    return this.parseFor(node, init);
+  };
 
-  function parseFunctionStatement(node) {
-    next();
-    return parseFunction(node, true);
-  }
+  pp.parseFunctionStatement = function(node) {
+    this.next();
+    return this.parseFunction(node, true);
+  };
 
-  function parseIfStatement(node) {
-    next();
-    node.test = parseParenExpression();
-    node.consequent = parseStatement(false);
-    node.alternate = eat(_else) ? parseStatement(false) : null;
-    return finishNode(node, "IfStatement");
-  }
+  pp.parseIfStatement = function(node) {
+    this.next();
+    node.test = this.parseParenExpression();
+    node.consequent = this.parseStatement(false);
+    node.alternate = this.eat(_else) ? this.parseStatement(false) : null;
+    return this.finishNode(node, "IfStatement");
+  };
 
-  function parseReturnStatement(node) {
-    if (!inFunction && !options.allowReturnOutsideFunction)
-      raise(tokStart, "'return' outside of function");
-    next();
+  pp.parseReturnStatement = function(node) {
+    if (!this.inFunction && !this.options.allowReturnOutsideFunction)
+      this.raise(this.start, "'return' outside of function");
+    this.next();
 
     // In `return` (and `break`/`continue`), the keywords with
     // optional arguments, we eagerly look for a semicolon or the
     // possibility to insert one.
 
-    if (eat(_semi) || canInsertSemicolon()) node.argument = null;
-    else { node.argument = parseExpression(); semicolon(); }
-    return finishNode(node, "ReturnStatement");
-  }
+    if (this.eat(_semi) || this.canInsertSemicolon()) node.argument = null;
+    else { node.argument = this.parseExpression(); this.semicolon(); }
+    return this.finishNode(node, "ReturnStatement");
+  };
 
-  function parseSwitchStatement(node) {
-    next();
-    node.discriminant = parseParenExpression();
+  pp.parseSwitchStatement = function(node) {
+    this.next();
+    node.discriminant = this.parseParenExpression();
     node.cases = [];
-    expect(_braceL);
-    labels.push(switchLabel);
+    this.expect(_braceL);
+    this.labels.push(switchLabel);
 
     // Statements under must be grouped (by label) in SwitchCase
     // nodes. `cur` is used to keep the node that we are currently
     // adding statements to.
 
-    for (var cur, sawDefault; tokType != _braceR;) {
-      if (tokType === _case || tokType === _default) {
-        var isCase = tokType === _case;
-        if (cur) finishNode(cur, "SwitchCase");
-        node.cases.push(cur = startNode());
+    for (var cur, sawDefault; this.type != _braceR;) {
+      if (this.type === _case || this.type === _default) {
+        var isCase = this.type === _case;
+        if (cur) this.finishNode(cur, "SwitchCase");
+        node.cases.push(cur = this.startNode());
         cur.consequent = [];
-        next();
-        if (isCase) cur.test = parseExpression();
+        this.next();
+        if (isCase) cur.test = this.parseExpression();
         else {
-          if (sawDefault) raise(lastStart, "Multiple default clauses"); sawDefault = true;
+          if (sawDefault) this.raise(this.lastTokStart, "Multiple default clauses"); sawDefault = true;
           cur.test = null;
         }
-        expect(_colon);
+        this.expect(_colon);
       } else {
-        if (!cur) unexpected();
-        cur.consequent.push(parseStatement(true));
+        if (!cur) this.unexpected();
+        cur.consequent.push(this.parseStatement(true));
       }
     }
-    if (cur) finishNode(cur, "SwitchCase");
-    next(); // Closing brace
-    labels.pop();
-    return finishNode(node, "SwitchStatement");
-  }
+    if (cur) this.finishNode(cur, "SwitchCase");
+    this.next(); // Closing brace
+    this.labels.pop();
+    return this.finishNode(node, "SwitchStatement");
+  };
 
-  function parseThrowStatement(node) {
-    next();
-    if (newline.test(input.slice(lastEnd, tokStart)))
-      raise(lastEnd, "Illegal newline after throw");
-    node.argument = parseExpression();
-    semicolon();
-    return finishNode(node, "ThrowStatement");
-  }
+  pp.parseThrowStatement = function(node) {
+    this.next();
+    if (newline.test(this.input.slice(this.lastTokEnd, this.start)))
+      this.raise(this.lastTokEnd, "Illegal newline after throw");
+    node.argument = this.parseExpression();
+    this.semicolon();
+    return this.finishNode(node, "ThrowStatement");
+  };
 
-  function parseTryStatement(node) {
-    next();
-    node.block = parseBlock();
+  pp.parseTryStatement = function(node) {
+    this.next();
+    node.block = this.parseBlock();
     node.handler = null;
-    if (tokType === _catch) {
-      var clause = startNode();
-      next();
-      expect(_parenL);
-      clause.param = parseBindingAtom();
-      checkLVal(clause.param, true);
-      expect(_parenR);
+    if (this.type === _catch) {
+      var clause = this.startNode();
+      this.next();
+      this.expect(_parenL);
+      clause.param = this.parseBindingAtom();
+      this.checkLVal(clause.param, true);
+      this.expect(_parenR);
       clause.guard = null;
-      clause.body = parseBlock();
-      node.handler = finishNode(clause, "CatchClause");
+      clause.body = this.parseBlock();
+      node.handler = this.finishNode(clause, "CatchClause");
     }
     node.guardedHandlers = empty;
-    node.finalizer = eat(_finally) ? parseBlock() : null;
+    node.finalizer = this.eat(_finally) ? this.parseBlock() : null;
     if (!node.handler && !node.finalizer)
-      raise(node.start, "Missing catch or finally clause");
-    return finishNode(node, "TryStatement");
-  }
+      this.raise(node.start, "Missing catch or finally clause");
+    return this.finishNode(node, "TryStatement");
+  };
 
-  function parseVarStatement(node, kind) {
-    next();
-    parseVar(node, false, kind);
-    semicolon();
-    return finishNode(node, "VariableDeclaration");
-  }
+  pp.parseVarStatement = function(node, kind) {
+    this.next();
+    this.parseVar(node, false, kind);
+    this.semicolon();
+    return this.finishNode(node, "VariableDeclaration");
+  };
 
-  function parseWhileStatement(node) {
-    next();
-    node.test = parseParenExpression();
-    labels.push(loopLabel);
-    node.body = parseStatement(false);
-    labels.pop();
-    return finishNode(node, "WhileStatement");
-  }
+  pp.parseWhileStatement = function(node) {
+    this.next();
+    node.test = this.parseParenExpression();
+    this.labels.push(loopLabel);
+    node.body = this.parseStatement(false);
+    this.labels.pop();
+    return this.finishNode(node, "WhileStatement");
+  };
 
-  function parseWithStatement(node) {
-    if (strict) raise(tokStart, "'with' in strict mode");
-    next();
-    node.object = parseParenExpression();
-    node.body = parseStatement(false);
-    return finishNode(node, "WithStatement");
-  }
+  pp.parseWithStatement = function(node) {
+    if (this.strict) this.raise(this.start, "'with' in strict mode");
+    this.next();
+    node.object = this.parseParenExpression();
+    node.body = this.parseStatement(false);
+    return this.finishNode(node, "WithStatement");
+  };
 
-  function parseEmptyStatement(node) {
-    next();
-    return finishNode(node, "EmptyStatement");
-  }
+  pp.parseEmptyStatement = function(node) {
+    this.next();
+    return this.finishNode(node, "EmptyStatement");
+  };
 
-  function parseLabeledStatement(node, maybeName, expr) {
-    for (var i = 0; i < labels.length; ++i)
-      if (labels[i].name === maybeName) raise(expr.start, "Label '" + maybeName + "' is already declared");
-    var kind = tokType.isLoop ? "loop" : tokType === _switch ? "switch" : null;
-    labels.push({name: maybeName, kind: kind});
-    node.body = parseStatement(true);
-    labels.pop();
+  pp.parseLabeledStatement = function(node, maybeName, expr) {
+    for (var i = 0; i < this.labels.length; ++i)
+      if (this.labels[i].name === maybeName) this.raise(expr.start, "Label '" + maybeName + "' is already declared");
+    var kind = this.type.isLoop ? "loop" : this.type === _switch ? "switch" : null;
+    this.labels.push({name: maybeName, kind: kind});
+    node.body = this.parseStatement(true);
+    this.labels.pop();
     node.label = expr;
-    return finishNode(node, "LabeledStatement");
-  }
+    return this.finishNode(node, "LabeledStatement");
+  };
 
-  function parseExpressionStatement(node, expr) {
+  pp.parseExpressionStatement = function(node, expr) {
     node.expression = expr;
-    semicolon();
-    return finishNode(node, "ExpressionStatement");
-  }
+    this.semicolon();
+    return this.finishNode(node, "ExpressionStatement");
+  };
 
   // Used for constructs like `switch` and `if` that insist on
   // parentheses around their expression.
 
-  function parseParenExpression() {
-    expect(_parenL);
-    var val = parseExpression();
-    expect(_parenR);
+  pp.parseParenExpression = function() {
+    this.expect(_parenL);
+    var val = this.parseExpression();
+    this.expect(_parenR);
     return val;
-  }
+  };
 
   // Parse a semicolon-enclosed block of statements, handling `"use
   // strict"` declarations when `allowStrict` is true (used for
   // function bodies).
 
-  function parseBlock(allowStrict) {
-    var node = startNode(), first = true, oldStrict;
+  pp.parseBlock = function(allowStrict) {
+    var node = this.startNode(), first = true, oldStrict;
     node.body = [];
-    expect(_braceL);
-    while (!eat(_braceR)) {
-      var stmt = parseStatement(true);
+    this.expect(_braceL);
+    while (!this.eat(_braceR)) {
+      var stmt = this.parseStatement(true);
       node.body.push(stmt);
-      if (first && allowStrict && isUseStrict(stmt)) {
-        oldStrict = strict;
-        setStrict(strict = true);
+      if (first && allowStrict && this.isUseStrict(stmt)) {
+        oldStrict = this.strict;
+        this.setStrict(this.strict = true);
       }
       first = false;
     }
-    if (oldStrict === false) setStrict(false);
-    return finishNode(node, "BlockStatement");
-  }
+    if (oldStrict === false) this.setStrict(false);
+    return this.finishNode(node, "BlockStatement");
+  };
 
   // Parse a regular `for` loop. The disambiguation code in
   // `parseStatement` will already have parsed the init statement or
   // expression.
 
-  function parseFor(node, init) {
+  pp.parseFor = function(node, init) {
     node.init = init;
-    expect(_semi);
-    node.test = tokType === _semi ? null : parseExpression();
-    expect(_semi);
-    node.update = tokType === _parenR ? null : parseExpression();
-    expect(_parenR);
-    node.body = parseStatement(false);
-    labels.pop();
-    return finishNode(node, "ForStatement");
-  }
+    this.expect(_semi);
+    node.test = this.type === _semi ? null : this.parseExpression();
+    this.expect(_semi);
+    node.update = this.type === _parenR ? null : this.parseExpression();
+    this.expect(_parenR);
+    node.body = this.parseStatement(false);
+    this.labels.pop();
+    return this.finishNode(node, "ForStatement");
+  };
 
   // Parse a `for`/`in` and `for`/`of` loop, which are almost
   // same from parser's perspective.
 
-  function parseForIn(node, init) {
-    var type = tokType === _in ? "ForInStatement" : "ForOfStatement";
-    next();
+  pp.parseForIn = function(node, init) {
+    var type = this.type === _in ? "ForInStatement" : "ForOfStatement";
+    this.next();
     node.left = init;
-    node.right = parseExpression();
-    expect(_parenR);
-    node.body = parseStatement(false);
-    labels.pop();
-    return finishNode(node, type);
-  }
+    node.right = this.parseExpression();
+    this.expect(_parenR);
+    node.body = this.parseStatement(false);
+    this.labels.pop();
+    return this.finishNode(node, type);
+  };
 
   // Parse a list of variable declarations.
 
-  function parseVar(node, noIn, kind) {
+  pp.parseVar = function(node, noIn, kind) {
     node.declarations = [];
     node.kind = kind;
     for (;;) {
-      var decl = startNode();
-      decl.id = parseBindingAtom();
-      checkLVal(decl.id, true);
-      decl.init = eat(_eq) ? parseMaybeAssign(noIn) : (kind === _const.keyword ? unexpected() : null);
-      node.declarations.push(finishNode(decl, "VariableDeclarator"));
-      if (!eat(_comma)) break;
+      var decl = this.startNode();
+      decl.id = this.parseBindingAtom();
+      this.checkLVal(decl.id, true);
+      decl.init = this.eat(_eq) ? this.parseMaybeAssign(noIn) : (kind === _const.keyword ? this.unexpected() : null);
+      node.declarations.push(this.finishNode(decl, "VariableDeclarator"));
+      if (!this.eat(_comma)) break;
     }
     return node;
-  }
+  };
 
   // ### Expression parsing
 
@@ -2115,22 +2071,22 @@
   // and object pattern might appear (so it's possible to raise
   // delayed syntax error at correct position).
 
-  function parseExpression(noIn, refShorthandDefaultPos) {
-    var start = storeCurrentPos();
-    var expr = parseMaybeAssign(noIn, refShorthandDefaultPos);
-    if (tokType === _comma) {
-      var node = startNodeAt(start);
+  pp.parseExpression = function(noIn, refShorthandDefaultPos) {
+    var start = this.currentPos();
+    var expr = this.parseMaybeAssign(noIn, refShorthandDefaultPos);
+    if (this.type === _comma) {
+      var node = this.startNodeAt(start);
       node.expressions = [expr];
-      while (eat(_comma)) node.expressions.push(parseMaybeAssign(noIn, refShorthandDefaultPos));
-      return finishNode(node, "SequenceExpression");
+      while (this.eat(_comma)) node.expressions.push(this.parseMaybeAssign(noIn, refShorthandDefaultPos));
+      return this.finishNode(node, "SequenceExpression");
     }
     return expr;
-  }
+  };
 
   // Parse an assignment expression. This includes applications of
   // operators like `+=`.
 
-  function parseMaybeAssign(noIn, refShorthandDefaultPos) {
+  pp.parseMaybeAssign = function(noIn, refShorthandDefaultPos) {
     var failOnShorthandAssign;
     if (!refShorthandDefaultPos) {
       refShorthandDefaultPos = {start: 0};
@@ -2138,48 +2094,48 @@
     } else {
       failOnShorthandAssign = false;
     }
-    var start = storeCurrentPos();
-    var left = parseMaybeConditional(noIn, refShorthandDefaultPos);
-    if (tokType.isAssign) {
-      var node = startNodeAt(start);
-      node.operator = tokVal;
-      node.left = tokType === _eq ? toAssignable(left) : left;
+    var start = this.currentPos();
+    var left = this.parseMaybeConditional(noIn, refShorthandDefaultPos);
+    if (this.type.isAssign) {
+      var node = this.startNodeAt(start);
+      node.operator = this.value;
+      node.left = this.type === _eq ? this.toAssignable(left) : left;
       refShorthandDefaultPos.start = 0; // reset because shorthand default was used correctly
-      checkLVal(left);
-      next();
-      node.right = parseMaybeAssign(noIn);
-      return finishNode(node, "AssignmentExpression");
+      this.checkLVal(left);
+      this.next();
+      node.right = this.parseMaybeAssign(noIn);
+      return this.finishNode(node, "AssignmentExpression");
     } else if (failOnShorthandAssign && refShorthandDefaultPos.start) {
-      unexpected(refShorthandDefaultPos.start);
+      this.unexpected(refShorthandDefaultPos.start);
     }
     return left;
-  }
+  };
 
   // Parse a ternary conditional (`?:`) operator.
 
-  function parseMaybeConditional(noIn, refShorthandDefaultPos) {
-    var start = storeCurrentPos();
-    var expr = parseExprOps(noIn, refShorthandDefaultPos);
+  pp.parseMaybeConditional = function(noIn, refShorthandDefaultPos) {
+    var start = this.currentPos();
+    var expr = this.parseExprOps(noIn, refShorthandDefaultPos);
     if (refShorthandDefaultPos && refShorthandDefaultPos.start) return expr;
-    if (eat(_question)) {
-      var node = startNodeAt(start);
+    if (this.eat(_question)) {
+      var node = this.startNodeAt(start);
       node.test = expr;
-      node.consequent = parseMaybeAssign();
-      expect(_colon);
-      node.alternate = parseMaybeAssign(noIn);
-      return finishNode(node, "ConditionalExpression");
+      node.consequent = this.parseMaybeAssign();
+      this.expect(_colon);
+      node.alternate = this.parseMaybeAssign(noIn);
+      return this.finishNode(node, "ConditionalExpression");
     }
     return expr;
-  }
+  };
 
   // Start the precedence parser.
 
-  function parseExprOps(noIn, refShorthandDefaultPos) {
-    var start = storeCurrentPos();
-    var expr = parseMaybeUnary(refShorthandDefaultPos);
+  pp.parseExprOps = function(noIn, refShorthandDefaultPos) {
+    var start = this.currentPos();
+    var expr = this.parseMaybeUnary(refShorthandDefaultPos);
     if (refShorthandDefaultPos && refShorthandDefaultPos.start) return expr;
-    return parseExprOp(expr, start, -1, noIn);
-  }
+    return this.parseExprOp(expr, start, -1, noIn);
+  };
 
   // Parse binary operators with the operator precedence parsing
   // algorithm. `left` is the left-hand side of the operator.
@@ -2187,465 +2143,465 @@
   // defer further parser to one of its callers when it encounters an
   // operator that has a lower precedence than the set it is parsing.
 
-  function parseExprOp(left, leftStart, minPrec, noIn) {
-    var prec = tokType.binop;
-    if (prec != null && (!noIn || tokType !== _in)) {
+  pp.parseExprOp = function(left, leftStart, minPrec, noIn) {
+    var prec = this.type.binop;
+    if (prec != null && (!noIn || this.type !== _in)) {
       if (prec > minPrec) {
-        var node = startNodeAt(leftStart);
+        var node = this.startNodeAt(leftStart);
         node.left = left;
-        node.operator = tokVal;
-        var op = tokType;
-        next();
-        var start = storeCurrentPos();
-        node.right = parseExprOp(parseMaybeUnary(), start, prec, noIn);
-        finishNode(node, (op === _logicalOR || op === _logicalAND) ? "LogicalExpression" : "BinaryExpression");
-        return parseExprOp(node, leftStart, minPrec, noIn);
+        node.operator = this.value;
+        var op = this.type;
+        this.next();
+        var start = this.currentPos();
+        node.right = this.parseExprOp(this.parseMaybeUnary(), start, prec, noIn);
+        this.finishNode(node, (op === _logicalOR || op === _logicalAND) ? "LogicalExpression" : "BinaryExpression");
+        return this.parseExprOp(node, leftStart, minPrec, noIn);
       }
     }
     return left;
-  }
+  };
 
   // Parse unary operators, both prefix and postfix.
 
-  function parseMaybeUnary(refShorthandDefaultPos) {
-    if (tokType.prefix) {
-      var node = startNode(), update = tokType.isUpdate;
-      node.operator = tokVal;
+  pp.parseMaybeUnary = function(refShorthandDefaultPos) {
+    if (this.type.prefix) {
+      var node = this.startNode(), update = this.type.isUpdate;
+      node.operator = this.value;
       node.prefix = true;
-      next();
-      node.argument = parseMaybeUnary();
-      if (refShorthandDefaultPos && refShorthandDefaultPos.start) unexpected(refShorthandDefaultPos.start);
-      if (update) checkLVal(node.argument);
-      else if (strict && node.operator === "delete" &&
+      this.next();
+      node.argument = this.parseMaybeUnary();
+      if (refShorthandDefaultPos && refShorthandDefaultPos.start) this.unexpected(refShorthandDefaultPos.start);
+      if (update) this.checkLVal(node.argument);
+      else if (this.strict && node.operator === "delete" &&
                node.argument.type === "Identifier")
-        raise(node.start, "Deleting local variable in strict mode");
-      return finishNode(node, update ? "UpdateExpression" : "UnaryExpression");
+        this.raise(node.start, "Deleting local variable in strict mode");
+      return this.finishNode(node, update ? "UpdateExpression" : "UnaryExpression");
     }
-    var start = storeCurrentPos();
-    var expr = parseExprSubscripts(refShorthandDefaultPos);
+    var start = this.currentPos();
+    var expr = this.parseExprSubscripts(refShorthandDefaultPos);
     if (refShorthandDefaultPos && refShorthandDefaultPos.start) return expr;
-    while (tokType.postfix && !canInsertSemicolon()) {
-      var node = startNodeAt(start);
-      node.operator = tokVal;
+    while (this.type.postfix && !this.canInsertSemicolon()) {
+      var node = this.startNodeAt(start);
+      node.operator = this.value;
       node.prefix = false;
       node.argument = expr;
-      checkLVal(expr);
-      next();
-      expr = finishNode(node, "UpdateExpression");
+      this.checkLVal(expr);
+      this.next();
+      expr = this.finishNode(node, "UpdateExpression");
     }
     return expr;
-  }
+  };
 
   // Parse call, dot, and `[]`-subscript expressions.
 
-  function parseExprSubscripts(refShorthandDefaultPos) {
-    var start = storeCurrentPos();
-    var expr = parseExprAtom(refShorthandDefaultPos);
+  pp.parseExprSubscripts = function(refShorthandDefaultPos) {
+    var start = this.currentPos();
+    var expr = this.parseExprAtom(refShorthandDefaultPos);
     if (refShorthandDefaultPos && refShorthandDefaultPos.start) return expr;
-    return parseSubscripts(expr, start);
-  }
+    return this.parseSubscripts(expr, start);
+  };
 
-  function parseSubscripts(base, start, noCalls) {
-    if (eat(_dot)) {
-      var node = startNodeAt(start);
+  pp.parseSubscripts = function(base, start, noCalls) {
+    if (this.eat(_dot)) {
+      var node = this.startNodeAt(start);
       node.object = base;
-      node.property = parseIdent(true);
+      node.property = this.parseIdent(true);
       node.computed = false;
-      return parseSubscripts(finishNode(node, "MemberExpression"), start, noCalls);
-    } else if (eat(_bracketL)) {
-      var node = startNodeAt(start);
+      return this.parseSubscripts(this.finishNode(node, "MemberExpression"), start, noCalls);
+    } else if (this.eat(_bracketL)) {
+      var node = this.startNodeAt(start);
       node.object = base;
-      node.property = parseExpression();
+      node.property = this.parseExpression();
       node.computed = true;
-      expect(_bracketR);
-      return parseSubscripts(finishNode(node, "MemberExpression"), start, noCalls);
-    } else if (!noCalls && eat(_parenL)) {
-      var node = startNodeAt(start);
+      this.expect(_bracketR);
+      return this.parseSubscripts(this.finishNode(node, "MemberExpression"), start, noCalls);
+    } else if (!noCalls && this.eat(_parenL)) {
+      var node = this.startNodeAt(start);
       node.callee = base;
-      node.arguments = parseExprList(_parenR, false);
-      return parseSubscripts(finishNode(node, "CallExpression"), start, noCalls);
-    } else if (tokType === _backQuote) {
-      var node = startNodeAt(start);
+      node.arguments = this.parseExprList(_parenR, false);
+      return this.parseSubscripts(this.finishNode(node, "CallExpression"), start, noCalls);
+    } else if (this.type === _backQuote) {
+      var node = this.startNodeAt(start);
       node.tag = base;
-      node.quasi = parseTemplate();
-      return parseSubscripts(finishNode(node, "TaggedTemplateExpression"), start, noCalls);
+      node.quasi = this.parseTemplate();
+      return this.parseSubscripts(this.finishNode(node, "TaggedTemplateExpression"), start, noCalls);
     } return base;
-  }
+  };
 
   // Parse an atomic expression — either a single token that is an
   // expression, an expression started by a keyword like `function` or
   // `new`, or an expression wrapped in punctuation like `()`, `[]`,
   // or `{}`.
 
-  function parseExprAtom(refShorthandDefaultPos) {
-    switch (tokType) {
+  pp.parseExprAtom = function(refShorthandDefaultPos) {
+    switch (this.type) {
     case _this:
-      var node = startNode();
-      next();
-      return finishNode(node, "ThisExpression");
+      var node = this.startNode();
+      this.next();
+      return this.finishNode(node, "ThisExpression");
 
     case _yield:
-      if (inGenerator) return parseYield();
+      if (this.inGenerator) return this.parseYield();
 
     case _name:
-      var start = storeCurrentPos();
-      var id = parseIdent(tokType !== _name);
-      if (!canInsertSemicolon() && eat(_arrow)) {
-        return parseArrowExpression(startNodeAt(start), [id]);
+      var start = this.currentPos();
+      var id = this.parseIdent(this.type !== _name);
+      if (!this.canInsertSemicolon() && this.eat(_arrow)) {
+        return this.parseArrowExpression(this.startNodeAt(start), [id]);
       }
       return id;
 
     case _regexp:
-      var node = startNode();
-      node.regex = {pattern: tokVal.pattern, flags: tokVal.flags};
-      node.value = tokVal.value;
-      node.raw = input.slice(tokStart, tokEnd);
-      next();
-      return finishNode(node, "Literal");
+      var node = this.startNode();
+      node.regex = {pattern: this.value.pattern, flags: this.value.flags};
+      node.value = this.value.value;
+      node.raw = this.input.slice(this.start, this.end);
+      this.next();
+      return this.finishNode(node, "Literal");
 
     case _num: case _string:
-      var node = startNode();
-      node.value = tokVal;
-      node.raw = input.slice(tokStart, tokEnd);
-      next();
-      return finishNode(node, "Literal");
+      var node = this.startNode();
+      node.value = this.value;
+      node.raw = this.input.slice(this.start, this.end);
+      this.next();
+      return this.finishNode(node, "Literal");
 
     case _null: case _true: case _false:
-      var node = startNode();
-      node.value = tokType.atomValue;
-      node.raw = tokType.keyword;
-      next();
-      return finishNode(node, "Literal");
+      var node = this.startNode();
+      node.value = this.type.atomValue;
+      node.raw = this.type.keyword;
+      this.next();
+      return this.finishNode(node, "Literal");
 
     case _parenL:
-      return parseParenAndDistinguishExpression();
+      return this.parseParenAndDistinguishExpression();
 
     case _bracketL:
-      var node = startNode();
-      next();
+      var node = this.startNode();
+      this.next();
       // check whether this is array comprehension or regular array
-      if (options.ecmaVersion >= 7 && tokType === _for) {
-        return parseComprehension(node, false);
+      if (this.options.ecmaVersion >= 7 && this.type === _for) {
+        return this.parseComprehension(node, false);
       }
-      node.elements = parseExprList(_bracketR, true, true, refShorthandDefaultPos);
-      return finishNode(node, "ArrayExpression");
+      node.elements = this.parseExprList(_bracketR, true, true, refShorthandDefaultPos);
+      return this.finishNode(node, "ArrayExpression");
 
     case _braceL:
-      return parseObj(false, refShorthandDefaultPos);
+      return this.parseObj(false, refShorthandDefaultPos);
 
     case _function:
-      var node = startNode();
-      next();
-      return parseFunction(node, false);
+      var node = this.startNode();
+      this.next();
+      return this.parseFunction(node, false);
 
     case _class:
-      return parseClass(startNode(), false);
+      return this.parseClass(this.startNode(), false);
 
     case _new:
-      return parseNew();
+      return this.parseNew();
 
     case _backQuote:
-      return parseTemplate();
+      return this.parseTemplate();
 
     default:
-      unexpected();
+      this.unexpected();
     }
-  }
+  };
 
-  function parseParenAndDistinguishExpression() {
-    var start = storeCurrentPos(), val;
-    if (options.ecmaVersion >= 6) {
-      next();
+  pp.parseParenAndDistinguishExpression = function() {
+    var start = this.currentPos(), val;
+    if (this.options.ecmaVersion >= 6) {
+      this.next();
 
-      if (options.ecmaVersion >= 7 && tokType === _for) {
-        return parseComprehension(startNodeAt(start), true);
+      if (this.options.ecmaVersion >= 7 && this.type === _for) {
+        return this.parseComprehension(this.startNodeAt(start), true);
       }
 
-      var innerStart = storeCurrentPos(), exprList = [], first = true;
+      var innerStart = this.currentPos(), exprList = [], first = true;
       var refShorthandDefaultPos = {start: 0}, spreadStart, innerParenStart;
-      while (tokType !== _parenR) {
-        first ? first = false : expect(_comma);
-        if (tokType === _ellipsis) {
-          spreadStart = tokStart;
-          exprList.push(parseRest());
+      while (this.type !== _parenR) {
+        first ? first = false : this.expect(_comma);
+        if (this.type === _ellipsis) {
+          spreadStart = this.start;
+          exprList.push(this.parseRest());
           break;
         } else {
-          if (tokType === _parenL && !innerParenStart) {
-            innerParenStart = tokStart;
+          if (this.type === _parenL && !innerParenStart) {
+            innerParenStart = this.start;
           }
-          exprList.push(parseMaybeAssign(false, refShorthandDefaultPos));
+          exprList.push(this.parseMaybeAssign(false, refShorthandDefaultPos));
         }
       }
-      var innerEnd = storeCurrentPos();
-      expect(_parenR);
+      var innerEnd = this.currentPos();
+      this.expect(_parenR);
 
-      if (!canInsertSemicolon() && eat(_arrow)) {
-        if (innerParenStart) unexpected(innerParenStart);
-        return parseArrowExpression(startNodeAt(start), exprList);
+      if (!this.canInsertSemicolon() && this.eat(_arrow)) {
+        if (innerParenStart) this.unexpected(innerParenStart);
+        return this.parseArrowExpression(this.startNodeAt(start), exprList);
       }
 
-      if (!exprList.length) unexpected(lastStart);
-      if (spreadStart) unexpected(spreadStart);
-      if (refShorthandDefaultPos.start) unexpected(refShorthandDefaultPos.start);
+      if (!exprList.length) this.unexpected(this.lastTokStart);
+      if (spreadStart) this.unexpected(spreadStart);
+      if (refShorthandDefaultPos.start) this.unexpected(refShorthandDefaultPos.start);
 
       if (exprList.length > 1) {
-        val = startNodeAt(innerStart);
+        val = this.startNodeAt(innerStart);
         val.expressions = exprList;
-        finishNodeAt(val, "SequenceExpression", innerEnd);
+        this.finishNodeAt(val, "SequenceExpression", innerEnd);
       } else {
         val = exprList[0];
       }
     } else {
-      val = parseParenExpression();
+      val = this.parseParenExpression();
     }
 
-    if (options.preserveParens) {
-      var par = startNodeAt(start);
+    if (this.options.preserveParens) {
+      var par = this.startNodeAt(start);
       par.expression = val;
-      return finishNode(par, "ParenthesizedExpression");
+      return this.finishNode(par, "ParenthesizedExpression");
     } else {
       return val;
     }
-  }
+  };
 
   // New's precedence is slightly tricky. It must allow its argument
   // to be a `[]` or dot subscript expression, but not a call — at
   // least, not without wrapping it in parentheses. Thus, it uses the
 
-  function parseNew() {
-    var node = startNode();
-    next();
-    var start = storeCurrentPos();
-    node.callee = parseSubscripts(parseExprAtom(), start, true);
-    if (eat(_parenL)) node.arguments = parseExprList(_parenR, false);
+  pp.parseNew = function() {
+    var node = this.startNode();
+    this.next();
+    var start = this.currentPos();
+    node.callee = this.parseSubscripts(this.parseExprAtom(), start, true);
+    if (this.eat(_parenL)) node.arguments = this.parseExprList(_parenR, false);
     else node.arguments = empty;
-    return finishNode(node, "NewExpression");
-  }
+    return this.finishNode(node, "NewExpression");
+  };
 
   // Parse template expression.
 
-  function parseTemplateElement() {
-    var elem = startNode();
+  pp.parseTemplateElement = function() {
+    var elem = this.startNode();
     elem.value = {
-      raw: input.slice(tokStart, tokEnd),
-      cooked: tokVal
+      raw: this.input.slice(this.start, this.end),
+      cooked: this.value
     };
-    next();
-    elem.tail = tokType === _backQuote;
-    return finishNode(elem, "TemplateElement");
-  }
+    this.next();
+    elem.tail = this.type === _backQuote;
+    return this.finishNode(elem, "TemplateElement");
+  };
 
-  function parseTemplate() {
-    var node = startNode();
-    next();
+  pp.parseTemplate = function() {
+    var node = this.startNode();
+    this.next();
     node.expressions = [];
-    var curElt = parseTemplateElement();
+    var curElt = this.parseTemplateElement();
     node.quasis = [curElt];
     while (!curElt.tail) {
-      expect(_dollarBraceL);
-      node.expressions.push(parseExpression());
-      expect(_braceR);
-      node.quasis.push(curElt = parseTemplateElement());
+      this.expect(_dollarBraceL);
+      node.expressions.push(this.parseExpression());
+      this.expect(_braceR);
+      node.quasis.push(curElt = this.parseTemplateElement());
     }
-    next();
-    return finishNode(node, "TemplateLiteral");
-  }
+    this.next();
+    return this.finishNode(node, "TemplateLiteral");
+  };
 
   // Parse an object literal or binding pattern.
 
-  function parseObj(isPattern, refShorthandDefaultPos) {
-    var node = startNode(), first = true, propHash = {};
+  pp.parseObj = function(isPattern, refShorthandDefaultPos) {
+    var node = this.startNode(), first = true, propHash = {};
     node.properties = [];
-    next();
-    while (!eat(_braceR)) {
+    this.next();
+    while (!this.eat(_braceR)) {
       if (!first) {
-        expect(_comma);
-        if (options.allowTrailingCommas && eat(_braceR)) break;
+        this.expect(_comma);
+        if (this.options.allowTrailingCommas && this.eat(_braceR)) break;
       } else first = false;
 
-      var prop = startNode(), isGenerator, start;
-      if (options.ecmaVersion >= 6) {
+      var prop = this.startNode(), isGenerator, start;
+      if (this.options.ecmaVersion >= 6) {
         prop.method = false;
         prop.shorthand = false;
         if (isPattern || refShorthandDefaultPos) {
-          start = storeCurrentPos();
+          start = this.currentPos();
         }
         if (!isPattern) {
-          isGenerator = eat(_star);
+          isGenerator = this.eat(_star);
         }
       }
-      parsePropertyName(prop);
-      if (eat(_colon)) {
-        prop.value = isPattern ? parseMaybeDefault() : parseMaybeAssign(false, refShorthandDefaultPos);
+      this.parsePropertyName(prop);
+      if (this.eat(_colon)) {
+        prop.value = isPattern ? this.parseMaybeDefault() : this.parseMaybeAssign(false, refShorthandDefaultPos);
         prop.kind = "init";
-      } else if (options.ecmaVersion >= 6 && tokType === _parenL) {
-        if (isPattern) unexpected();
+      } else if (this.options.ecmaVersion >= 6 && this.type === _parenL) {
+        if (isPattern) this.unexpected();
         prop.kind = "init";
         prop.method = true;
-        prop.value = parseMethod(isGenerator);
-      } else if (options.ecmaVersion >= 5 && !prop.computed && prop.key.type === "Identifier" &&
+        prop.value = this.parseMethod(isGenerator);
+      } else if (this.options.ecmaVersion >= 5 && !prop.computed && prop.key.type === "Identifier" &&
                  (prop.key.name === "get" || prop.key.name === "set") &&
-                 (tokType != _comma && tokType != _braceR)) {
-        if (isGenerator || isPattern) unexpected();
+                 (this.type != _comma && this.type != _braceR)) {
+        if (isGenerator || isPattern) this.unexpected();
         prop.kind = prop.key.name;
-        parsePropertyName(prop);
-        prop.value = parseMethod(false);
-      } else if (options.ecmaVersion >= 6 && !prop.computed && prop.key.type === "Identifier") {
+        this.parsePropertyName(prop);
+        prop.value = this.parseMethod(false);
+      } else if (this.options.ecmaVersion >= 6 && !prop.computed && prop.key.type === "Identifier") {
         prop.kind = "init";
         if (isPattern) {
-          prop.value = parseMaybeDefault(start, prop.key);
-        } else if (tokType === _eq && refShorthandDefaultPos) {
+          prop.value = this.parseMaybeDefault(start, prop.key);
+        } else if (this.type === _eq && refShorthandDefaultPos) {
           if (!refShorthandDefaultPos.start)
-            refShorthandDefaultPos.start = tokStart;
-          prop.value = parseMaybeDefault(start, prop.key);
+            refShorthandDefaultPos.start = this.start;
+          prop.value = this.parseMaybeDefault(start, prop.key);
         } else {
           prop.value = prop.key;
         }
         prop.shorthand = true;
-      } else unexpected();
+      } else this.unexpected();
 
-      checkPropClash(prop, propHash);
-      node.properties.push(finishNode(prop, "Property"));
+      this.checkPropClash(prop, propHash);
+      node.properties.push(this.finishNode(prop, "Property"));
     }
-    return finishNode(node, isPattern ? "ObjectPattern" : "ObjectExpression");
-  }
+    return this.finishNode(node, isPattern ? "ObjectPattern" : "ObjectExpression");
+  };
 
-  function parsePropertyName(prop) {
-    if (options.ecmaVersion >= 6) {
-      if (eat(_bracketL)) {
+  pp.parsePropertyName = function(prop) {
+    if (this.options.ecmaVersion >= 6) {
+      if (this.eat(_bracketL)) {
         prop.computed = true;
-        prop.key = parseExpression();
-        expect(_bracketR);
+        prop.key = this.parseExpression();
+        this.expect(_bracketR);
         return;
       } else {
         prop.computed = false;
       }
     }
-    prop.key = (tokType === _num || tokType === _string) ? parseExprAtom() : parseIdent(true);
-  }
+    prop.key = (this.type === _num || this.type === _string) ? this.parseExprAtom() : this.parseIdent(true);
+  };
 
   // Initialize empty function node.
 
-  function initFunction(node) {
+  pp.initFunction = function(node) {
     node.id = null;
-    if (options.ecmaVersion >= 6) {
+    if (this.options.ecmaVersion >= 6) {
       node.generator = false;
       node.expression = false;
     }
-  }
+  };
 
   // Parse a function declaration or literal (depending on the
   // `isStatement` parameter).
 
-  function parseFunction(node, isStatement, allowExpressionBody) {
-    initFunction(node);
-    if (options.ecmaVersion >= 6) {
-      node.generator = eat(_star);
+  pp.parseFunction = function(node, isStatement, allowExpressionBody) {
+    this.initFunction(node);
+    if (this.options.ecmaVersion >= 6) {
+      node.generator = this.eat(_star);
     }
-    if (isStatement || tokType === _name) {
-      node.id = parseIdent();
+    if (isStatement || this.type === _name) {
+      node.id = this.parseIdent();
     }
-    expect(_parenL);
-    node.params = parseBindingList(_parenR, false);
-    parseFunctionBody(node, allowExpressionBody);
-    return finishNode(node, isStatement ? "FunctionDeclaration" : "FunctionExpression");
-  }
+    this.expect(_parenL);
+    node.params = this.parseBindingList(_parenR, false);
+    this.parseFunctionBody(node, allowExpressionBody);
+    return this.finishNode(node, isStatement ? "FunctionDeclaration" : "FunctionExpression");
+  };
 
   // Parse object or class method.
 
-  function parseMethod(isGenerator) {
-    var node = startNode();
-    initFunction(node);
-    expect(_parenL);
-    node.params = parseBindingList(_parenR, false);
+  pp.parseMethod = function(isGenerator) {
+    var node = this.startNode();
+    this.initFunction(node);
+    this.expect(_parenL);
+    node.params = this.parseBindingList(_parenR, false);
     var allowExpressionBody;
-    if (options.ecmaVersion >= 6) {
+    if (this.options.ecmaVersion >= 6) {
       node.generator = isGenerator;
       allowExpressionBody = true;
     } else {
       allowExpressionBody = false;
     }
-    parseFunctionBody(node, allowExpressionBody);
-    return finishNode(node, "FunctionExpression");
-  }
+    this.parseFunctionBody(node, allowExpressionBody);
+    return this.finishNode(node, "FunctionExpression");
+  };
 
   // Parse arrow function expression with given parameters.
 
-  function parseArrowExpression(node, params) {
-    initFunction(node);
-    node.params = toAssignableList(params, true);
-    parseFunctionBody(node, true);
-    return finishNode(node, "ArrowFunctionExpression");
-  }
+  pp.parseArrowExpression = function(node, params) {
+    this.initFunction(node);
+    node.params = this.toAssignableList(params, true);
+    this.parseFunctionBody(node, true);
+    return this.finishNode(node, "ArrowFunctionExpression");
+  };
 
   // Parse function body and check parameters.
 
-  function parseFunctionBody(node, allowExpression) {
-    var isExpression = allowExpression && tokType !== _braceL;
+  pp.parseFunctionBody = function(node, allowExpression) {
+    var isExpression = allowExpression && this.type !== _braceL;
 
     if (isExpression) {
-      node.body = parseMaybeAssign();
+      node.body = this.parseMaybeAssign();
       node.expression = true;
     } else {
       // Start a new scope with regard to labels and the `inFunction`
       // flag (restore them to their old value afterwards).
-      var oldInFunc = inFunction, oldInGen = inGenerator, oldLabels = labels;
-      inFunction = true; inGenerator = node.generator; labels = [];
-      node.body = parseBlock(true);
+      var oldInFunc = this.inFunction, oldInGen = this.inGenerator, oldLabels = this.labels;
+      this.inFunction = true; this.inGenerator = node.generator; this.labels = [];
+      node.body = this.parseBlock(true);
       node.expression = false;
-      inFunction = oldInFunc; inGenerator = oldInGen; labels = oldLabels;
+      this.inFunction = oldInFunc; this.inGenerator = oldInGen; this.labels = oldLabels;
     }
 
     // If this is a strict mode function, verify that argument names
     // are not repeated, and it does not try to bind the words `eval`
     // or `arguments`.
-    if (strict || !isExpression && node.body.body.length && isUseStrict(node.body.body[0])) {
+    if (this.strict || !isExpression && node.body.body.length && this.isUseStrict(node.body.body[0])) {
       var nameHash = {};
       if (node.id)
-        checkFunctionParam(node.id, {});
+        this.checkFunctionParam(node.id, {});
       for (var i = 0; i < node.params.length; i++)
-        checkFunctionParam(node.params[i], nameHash);
+        this.checkFunctionParam(node.params[i], nameHash);
     }
-  }
+  };
 
   // Parse a class declaration or literal (depending on the
   // `isStatement` parameter).
 
-  function parseClass(node, isStatement) {
-    next();
-    node.id = tokType === _name ? parseIdent() : isStatement ? unexpected() : null;
-    node.superClass = eat(_extends) ? parseExprSubscripts() : null;
-    var classBody = startNode();
+  pp.parseClass = function(node, isStatement) {
+    this.next();
+    node.id = this.type === _name ? this.parseIdent() : isStatement ? this.unexpected() : null;
+    node.superClass = this.eat(_extends) ? this.parseExprSubscripts() : null;
+    var classBody = this.startNode();
     classBody.body = [];
-    expect(_braceL);
-    while (!eat(_braceR)) {
-      if (eat(_semi)) continue;
-      var method = startNode();
-      var isGenerator = eat(_star);
-      parsePropertyName(method);
-      if (tokType !== _parenL && !method.computed && method.key.type === "Identifier" &&
+    this.expect(_braceL);
+    while (!this.eat(_braceR)) {
+      if (this.eat(_semi)) continue;
+      var method = this.startNode();
+      var isGenerator = this.eat(_star);
+      this.parsePropertyName(method);
+      if (this.type !== _parenL && !method.computed && method.key.type === "Identifier" &&
           method.key.name === "static") {
-        if (isGenerator) unexpected();
+        if (isGenerator) this.unexpected();
         method['static'] = true;
-        isGenerator = eat(_star);
-        parsePropertyName(method);
+        isGenerator = this.eat(_star);
+        this.parsePropertyName(method);
       } else {
         method['static'] = false;
       }
-      if (tokType !== _parenL && !method.computed && method.key.type === "Identifier" &&
+      if (this.type !== _parenL && !method.computed && method.key.type === "Identifier" &&
           (method.key.name === "get" || method.key.name === "set")) {
-        if (isGenerator) unexpected();
+        if (isGenerator) this.unexpected();
         method.kind = method.key.name;
-        parsePropertyName(method);
+        this.parsePropertyName(method);
       } else {
         method.kind = "";
       }
-      method.value = parseMethod(isGenerator);
-      classBody.body.push(finishNode(method, "MethodDefinition"));
+      method.value = this.parseMethod(isGenerator);
+      classBody.body.push(this.finishNode(method, "MethodDefinition"));
     }
-    node.body = finishNode(classBody, "ClassBody");
-    return finishNode(node, isStatement ? "ClassDeclaration" : "ClassExpression");
-  }
+    node.body = this.finishNode(classBody, "ClassBody");
+    return this.finishNode(node, isStatement ? "ClassDeclaration" : "ClassExpression");
+  };
 
   // Parses a comma-separated list of expressions, and returns them as
   // an array. `close` is the token type that ends the list, and
@@ -2653,64 +2609,64 @@
   // nothing in between them to be parsed as `null` (which is needed
   // for array literals).
 
-  function parseExprList(close, allowTrailingComma, allowEmpty, refShorthandDefaultPos) {
+  pp.parseExprList = function(close, allowTrailingComma, allowEmpty, refShorthandDefaultPos) {
     var elts = [], first = true;
-    while (!eat(close)) {
+    while (!this.eat(close)) {
       if (!first) {
-        expect(_comma);
-        if (allowTrailingComma && options.allowTrailingCommas && eat(close)) break;
+        this.expect(_comma);
+        if (allowTrailingComma && this.options.allowTrailingCommas && this.eat(close)) break;
       } else first = false;
 
-      if (allowEmpty && tokType === _comma) {
+      if (allowEmpty && this.type === _comma) {
         elts.push(null);
       } else {
-        if (tokType === _ellipsis)
-          elts.push(parseSpread(refShorthandDefaultPos));
+        if (this.type === _ellipsis)
+          elts.push(this.parseSpread(refShorthandDefaultPos));
         else
-          elts.push(parseMaybeAssign(false, refShorthandDefaultPos));
+          elts.push(this.parseMaybeAssign(false, refShorthandDefaultPos));
       }
     }
     return elts;
-  }
+  };
 
   // Parse the next token as an identifier. If `liberal` is true (used
   // when parsing properties), it will also convert keywords into
   // identifiers.
 
-  function parseIdent(liberal) {
-    var node = startNode();
-    if (liberal && options.forbidReserved == "everywhere") liberal = false;
-    if (tokType === _name) {
+  pp.parseIdent = function(liberal) {
+    var node = this.startNode();
+    if (liberal && this.options.forbidReserved == "everywhere") liberal = false;
+    if (this.type === _name) {
       if (!liberal &&
-          (options.forbidReserved &&
-           (options.ecmaVersion === 3 ? isReservedWord3 : isReservedWord5)(tokVal) ||
-           strict && isStrictReservedWord(tokVal)) &&
-          input.slice(tokStart, tokEnd).indexOf("\\") == -1)
-        raise(tokStart, "The keyword '" + tokVal + "' is reserved");
-      node.name = tokVal;
-    } else if (liberal && tokType.keyword) {
-      node.name = tokType.keyword;
+          (this.options.forbidReserved &&
+           (this.options.ecmaVersion === 3 ? isReservedWord3 : isReservedWord5)(this.value) ||
+           this.strict && isStrictReservedWord(this.value)) &&
+          this.input.slice(this.start, this.end).indexOf("\\") == -1)
+        this.raise(this.start, "The keyword '" + this.value + "' is reserved");
+      node.name = this.value;
+    } else if (liberal && this.type.keyword) {
+      node.name = this.type.keyword;
     } else {
-      unexpected();
+      this.unexpected();
     }
-    next();
-    return finishNode(node, "Identifier");
-  }
+    this.next();
+    return this.finishNode(node, "Identifier");
+  };
 
   // Parses module export declaration.
 
-  function parseExport(node) {
-    next();
+  pp.parseExport = function(node) {
+    this.next();
     // export var|const|let|function|class ...;
-    if (tokType === _var || tokType === _const || tokType === _let || tokType === _function || tokType === _class) {
-      node.declaration = parseStatement(true);
+    if (this.type === _var || this.type === _const || this.type === _let || this.type === _function || this.type === _class) {
+      node.declaration = this.parseStatement(true);
       node['default'] = false;
       node.specifiers = null;
       node.source = null;
     } else
     // export default ...;
-    if (eat(_default)) {
-      var expr = parseMaybeAssign();
+    if (this.eat(_default)) {
+      var expr = this.parseMaybeAssign();
       if (expr.id) {
         switch (expr.type) {
           case "FunctionExpression": expr.type = "FunctionDeclaration"; break;
@@ -2721,144 +2677,144 @@
       node['default'] = true;
       node.specifiers = null;
       node.source = null;
-      semicolon();
+      this.semicolon();
     } else {
       // export * from '...';
       // export { x, y as z } [from '...'];
-      var isBatch = tokType === _star;
+      var isBatch = this.type === _star;
       node.declaration = null;
       node['default'] = false;
-      node.specifiers = parseExportSpecifiers();
-      if (eatContextual("from")) {
-        node.source = tokType === _string ? parseExprAtom() : unexpected();
+      node.specifiers = this.parseExportSpecifiers();
+      if (this.eatContextual("from")) {
+        node.source = this.type === _string ? this.parseExprAtom() : this.unexpected();
       } else {
-        if (isBatch) unexpected();
+        if (isBatch) this.unexpected();
         node.source = null;
       }
-      semicolon();
+      this.semicolon();
     }
-    return finishNode(node, "ExportDeclaration");
-  }
+    return this.finishNode(node, "ExportDeclaration");
+  };
 
   // Parses a comma-separated list of module exports.
 
-  function parseExportSpecifiers() {
+  pp.parseExportSpecifiers = function() {
     var nodes = [], first = true;
-    if (tokType === _star) {
+    if (this.type === _star) {
       // export * from '...'
-      var node = startNode();
-      next();
-      nodes.push(finishNode(node, "ExportBatchSpecifier"));
+      var node = this.startNode();
+      this.next();
+      nodes.push(this.finishNode(node, "ExportBatchSpecifier"));
     } else {
       // export { x, y as z } [from '...']
-      expect(_braceL);
-      while (!eat(_braceR)) {
+      this.expect(_braceL);
+      while (!this.eat(_braceR)) {
         if (!first) {
-          expect(_comma);
-          if (options.allowTrailingCommas && eat(_braceR)) break;
+          this.expect(_comma);
+          if (this.options.allowTrailingCommas && this.eat(_braceR)) break;
         } else first = false;
 
-        var node = startNode();
-        node.id = parseIdent(tokType === _default);
-        node.name = eatContextual("as") ? parseIdent(true) : null;
-        nodes.push(finishNode(node, "ExportSpecifier"));
+        var node = this.startNode();
+        node.id = this.parseIdent(this.type === _default);
+        node.name = this.eatContextual("as") ? this.parseIdent(true) : null;
+        nodes.push(this.finishNode(node, "ExportSpecifier"));
       }
     }
     return nodes;
-  }
+  };
 
   // Parses import declaration.
 
-  function parseImport(node) {
-    next();
+  pp.parseImport = function(node) {
+    this.next();
     // import '...';
-    if (tokType === _string) {
+    if (this.type === _string) {
       node.specifiers = [];
-      node.source = parseExprAtom();
+      node.source = this.parseExprAtom();
       node.kind = "";
     } else {
-      node.specifiers = parseImportSpecifiers();
-      expectContextual("from");
-      node.source = tokType === _string ? parseExprAtom() : unexpected();
+      node.specifiers = this.parseImportSpecifiers();
+      this.expectContextual("from");
+      node.source = this.type === _string ? this.parseExprAtom() : this.unexpected();
     }
-    semicolon();
-    return finishNode(node, "ImportDeclaration");
-  }
+    this.semicolon();
+    return this.finishNode(node, "ImportDeclaration");
+  };
 
   // Parses a comma-separated list of module imports.
 
-  function parseImportSpecifiers() {
+  pp.parseImportSpecifiers = function() {
     var nodes = [], first = true;
-    if (tokType === _name) {
+    if (this.type === _name) {
       // import defaultObj, { x, y as z } from '...'
-      var node = startNode();
-      node.id = parseIdent();
-      checkLVal(node.id, true);
+      var node = this.startNode();
+      node.id = this.parseIdent();
+      this.checkLVal(node.id, true);
       node.name = null;
       node['default'] = true;
-      nodes.push(finishNode(node, "ImportSpecifier"));
-      if (!eat(_comma)) return nodes;
+      nodes.push(this.finishNode(node, "ImportSpecifier"));
+      if (!this.eat(_comma)) return nodes;
     }
-    if (tokType === _star) {
-      var node = startNode();
-      next();
-      expectContextual("as");
-      node.name = parseIdent();
-      checkLVal(node.name, true);
-      nodes.push(finishNode(node, "ImportBatchSpecifier"));
+    if (this.type === _star) {
+      var node = this.startNode();
+      this.next();
+      this.expectContextual("as");
+      node.name = this.parseIdent();
+      this.checkLVal(node.name, true);
+      nodes.push(this.finishNode(node, "ImportBatchSpecifier"));
       return nodes;
     }
-    expect(_braceL);
-    while (!eat(_braceR)) {
+    this.expect(_braceL);
+    while (!this.eat(_braceR)) {
       if (!first) {
-        expect(_comma);
-        if (options.allowTrailingCommas && eat(_braceR)) break;
+        this.expect(_comma);
+        if (this.options.allowTrailingCommas && this.eat(_braceR)) break;
       } else first = false;
 
-      var node = startNode();
-      node.id = parseIdent(true);
-      node.name = eatContextual("as") ? parseIdent() : null;
-      checkLVal(node.name || node.id, true);
+      var node = this.startNode();
+      node.id = this.parseIdent(true);
+      node.name = this.eatContextual("as") ? this.parseIdent() : null;
+      this.checkLVal(node.name || node.id, true);
       node['default'] = false;
-      nodes.push(finishNode(node, "ImportSpecifier"));
+      nodes.push(this.finishNode(node, "ImportSpecifier"));
     }
     return nodes;
-  }
+  };
 
   // Parses yield expression inside generator.
 
-  function parseYield() {
-    var node = startNode();
-    next();
-    if (eat(_semi) || canInsertSemicolon()) {
+  pp.parseYield = function() {
+    var node = this.startNode();
+    this.next();
+    if (this.eat(_semi) || this.canInsertSemicolon()) {
       node.delegate = false;
       node.argument = null;
     } else {
-      node.delegate = eat(_star);
-      node.argument = parseMaybeAssign();
+      node.delegate = this.eat(_star);
+      node.argument = this.parseMaybeAssign();
     }
-    return finishNode(node, "YieldExpression");
-  }
+    return this.finishNode(node, "YieldExpression");
+  };
 
   // Parses array and generator comprehensions.
 
-  function parseComprehension(node, isGenerator) {
+  pp.parseComprehension = function(node, isGenerator) {
     node.blocks = [];
-    while (tokType === _for) {
-      var block = startNode();
-      next();
-      expect(_parenL);
-      block.left = parseBindingAtom();
-      checkLVal(block.left, true);
-      expectContextual("of");
-      block.right = parseExpression();
-      expect(_parenR);
-      node.blocks.push(finishNode(block, "ComprehensionBlock"));
+    while (this.type === _for) {
+      var block = this.startNode();
+      this.next();
+      this.expect(_parenL);
+      block.left = this.parseBindingAtom();
+      this.checkLVal(block.left, true);
+      this.expectContextual("of");
+      block.right = this.parseExpression();
+      this.expect(_parenR);
+      node.blocks.push(this.finishNode(block, "ComprehensionBlock"));
     }
-    node.filter = eat(_if) ? parseParenExpression() : null;
-    node.body = parseExpression();
-    expect(isGenerator ? _parenR : _bracketR);
+    node.filter = this.eat(_if) ? this.parseParenExpression() : null;
+    node.body = this.parseExpression();
+    this.expect(isGenerator ? _parenR : _bracketR);
     node.generator = isGenerator;
-    return finishNode(node, "ComprehensionExpression");
-  }
+    return this.finishNode(node, "ComprehensionExpression");
+  };
 });
diff --git a/test/driver.js b/test/driver.js
index 7b7dee853c..6de53dc9e3 100644
--- a/test/driver.js
+++ b/test/driver.js
@@ -33,8 +33,7 @@
           } else {
             callback("fail", test.code, "Expected error message: " + test.error + "\nBut parsing succeeded.");
           }
-        }
-        else if (test.assert) {
+        } else if (test.assert) {
           var error = test.assert(ast);
           if (error) callback("fail", test.code,
                                  "\n  Assertion failed:\n " + error);