diff -r 000000000000 -r 6474c204b198 browser/devtools/shared/Parser.jsm
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/browser/devtools/shared/Parser.jsm	Wed Dec 31 06:09:35 2014 +0100
@@ -0,0 +1,2337 @@
+/* -*- Mode: javascript; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ft=javascript ts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+const Ci = Components.interfaces;
+const Cu = Components.utils;
+
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+const { DevToolsUtils } = Cu.import("resource://gre/modules/devtools/DevToolsUtils.jsm", {});
+
+XPCOMUtils.defineLazyModuleGetter(this,
+  "Reflect", "resource://gre/modules/reflect.jsm");
+
+this.EXPORTED_SYMBOLS = ["Parser", "ParserHelpers", "SyntaxTreeVisitor"];
+
+/**
+ * A JS parser using the reflection API.
+ */
+this.Parser = function Parser() {
+  this._cache = new Map();
+  this.errors = [];
+};
+
+Parser.prototype = {
+  /**
+   * Gets a collection of parser methods for a specified source.
+   *
+   * @param string aSource
+   *        The source text content.
+   * @param string aUrl [optional]
+   *        The source url. The AST nodes will be cached, so you can use this
+   *        identifier to avoid parsing the whole source again.
+   */
+  get: function(aSource, aUrl = "") {
+    // Try to use the cached AST nodes, to avoid useless parsing operations.
+    if (this._cache.has(aUrl)) {
+      return this._cache.get(aUrl);
+    }
+
+    // The source may not necessarily be JS, in which case we need to extract
+    // all the scripts. Fastest/easiest way is with a regular expression.
+    // Don't worry, the rules of using a <script> tag are really strict,
+    // this will work.
+    let regexp = /<script[^>]*>([^]*?)<\/script\s*>/gim;
+    let syntaxTrees = [];
+    let scriptMatches = [];
+    let scriptMatch;
+
+    if (aSource.match(/^\s*</)) {
+      // First non whitespace character is &lt, so most definitely HTML.
+      while (scriptMatch = regexp.exec(aSource)) {
+        scriptMatches.push(scriptMatch[1]); // Contents are captured at index 1.
+      }
+    }
+
+    // If there are no script matches, send the whole source directly to the
+    // reflection API to generate the AST nodes.
+    if (!scriptMatches.length) {
+      // Reflect.parse throws when encounters a syntax error.
+      try {
+        let nodes = Reflect.parse(aSource);
+        let length = aSource.length;
+        syntaxTrees.push(new SyntaxTree(nodes, aUrl, length));
+      } catch (e) {
+        this.errors.push(e);
+        DevToolsUtils.reportException(aUrl, e);
+      }
+    }
+    // Generate the AST nodes for each script.
+    else {
+      for (let script of scriptMatches) {
+        // Reflect.parse throws when encounters a syntax error.
+        try {
+          let nodes = Reflect.parse(script);
+          let offset = aSource.indexOf(script);
+          let length = script.length;
+          syntaxTrees.push(new SyntaxTree(nodes, aUrl, length, offset));
+        } catch (e) {
+          this.errors.push(e);
+          DevToolsUtils.reportException(aUrl, e);
+        }
+      }
+    }
+
+    let pool = new SyntaxTreesPool(syntaxTrees, aUrl);
+
+    // Cache the syntax trees pool by the specified url. This is entirely
+    // optional, but it's strongly encouraged to cache ASTs because
+    // generating them can be costly with big/complex sources.
+    if (aUrl) {
+      this._cache.set(aUrl, pool);
+    }
+
+    return pool;
+  },
+
+  /**
+   * Clears all the parsed sources from cache.
+   */
+  clearCache: function() {
+    this._cache.clear();
+  },
+
+  /**
+   * Clears the AST for a particular source.
+   *
+   * @param String aUrl
+   *        The URL of the source that is being cleared.
+   */
+  clearSource: function(aUrl) {
+    this._cache.delete(aUrl);
+  },
+
+  _cache: null,
+  errors: null
+};
+
+/**
+ * A pool handling a collection of AST nodes generated by the reflection API.
+ *
+ * @param object aSyntaxTrees
+ *        A collection of AST nodes generated for a source.
+ * @param string aUrl [optional]
+ *        The source url.
+ */
+function SyntaxTreesPool(aSyntaxTrees, aUrl = "<unknown>") {
+  this._trees = aSyntaxTrees;
+  this._url = aUrl;
+  this._cache = new Map();
+}
+
+SyntaxTreesPool.prototype = {
+  /**
+   * @see SyntaxTree.prototype.getIdentifierAt
+   */
+  getIdentifierAt: function({ line, column, scriptIndex, ignoreLiterals }) {
+    return this._call("getIdentifierAt", scriptIndex, line, column, ignoreLiterals)[0];
+  },
+
+  /**
+   * @see SyntaxTree.prototype.getNamedFunctionDefinitions
+   */
+  getNamedFunctionDefinitions: function(aSubstring) {
+    return this._call("getNamedFunctionDefinitions", -1, aSubstring);
+  },
+
+  /**
+   * Gets the total number of scripts in the parent source.
+   * @return number
+   */
+  get scriptCount() {
+    return this._trees.length;
+  },
+
+  /**
+   * Finds the start and length of the script containing the specified offset
+   * relative to its parent source.
+   *
+   * @param number aOffset
+   *        The offset relative to the parent source.
+   * @return object
+   *         The offset and length relative to the enclosing script.
+   */
+  getScriptInfo: function(aOffset) {
+    let info = { start: -1, length: -1, index: -1 };
+
+    for (let { offset, length } of this._trees) {
+      info.index++;
+      if (offset <= aOffset && offset + length >= aOffset) {
+        info.start = offset;
+        info.length = length;
+        return info;
+      }
+    }
+
+    info.index = -1;
+    return info;
+  },
+
+  /**
+   * Handles a request for a specific or all known syntax trees.
+   *
+   * @param string aFunction
+   *        The function name to call on the SyntaxTree instances.
+   * @param number aSyntaxTreeIndex
+   *        The syntax tree for which to handle the request. If the tree at
+   *        the specified index isn't found, the accumulated results for all
+   *        syntax trees are returned.
+   * @param any aParams
+   *        Any kind params to pass to the request function.
+   * @return array
+   *         The results given by all known syntax trees.
+   */
+  _call: function(aFunction, aSyntaxTreeIndex, ...aParams) {
+    let results = [];
+    let requestId = [aFunction, aSyntaxTreeIndex, aParams].toSource();
+
+    if (this._cache.has(requestId)) {
+      return this._cache.get(requestId);
+    }
+
+    let requestedTree = this._trees[aSyntaxTreeIndex];
+    let targettedTrees = requestedTree ? [requestedTree] : this._trees;
+
+    for (let syntaxTree of targettedTrees) {
+      try {
+        let parseResults = syntaxTree[aFunction].apply(syntaxTree, aParams);
+        if (parseResults) {
+          parseResults.sourceUrl = syntaxTree.url;
+          parseResults.scriptLength = syntaxTree.length;
+          parseResults.scriptOffset = syntaxTree.offset;
+          results.push(parseResults);
+        }
+      } catch (e) {
+        // Can't guarantee that the tree traversal logic is forever perfect :)
+        // Language features may be added, in which case the recursive methods
+        // need to be updated. If an exception is thrown here, file a bug.
+        DevToolsUtils.reportException("Syntax tree visitor for " + aUrl, e);
+      }
+    }
+    this._cache.set(requestId, results);
+    return results;
+  },
+
+  _trees: null,
+  _cache: null
+};
+
+/**
+ * A collection of AST nodes generated by the reflection API.
+ *
+ * @param object aNodes
+ *        The AST nodes.
+ * @param string aUrl
+ *        The source url.
+ * @param number aLength
+ *        The total number of chars of the parsed script in the parent source.
+ * @param number aOffset [optional]
+ *        The char offset of the parsed script in the parent source.
+ */
+function SyntaxTree(aNodes, aUrl, aLength, aOffset = 0) {
+  this.AST = aNodes;
+  this.url = aUrl;
+  this.length = aLength;
+  this.offset = aOffset;
+};
+
+SyntaxTree.prototype = {
+  /**
+   * Gets the identifier at the specified location.
+   *
+   * @param number aLine
+   *        The line in the source.
+   * @param number aColumn
+   *        The column in the source.
+   * @param boolean aIgnoreLiterals
+   *        Specifies if alone literals should be ignored.
+   * @return object
+   *         An object containing identifier information as { name, location,
+   *         evalString } properties, or null if nothing is found.
+   */
+  getIdentifierAt: function(aLine, aColumn, aIgnoreLiterals) {
+    let info = null;
+
+    SyntaxTreeVisitor.walk(this.AST, {
+      /**
+       * Callback invoked for each identifier node.
+       * @param Node aNode
+       */
+      onIdentifier: function(aNode) {
+        if (ParserHelpers.nodeContainsPoint(aNode, aLine, aColumn)) {
+          info = {
+            name: aNode.name,
+            location: ParserHelpers.getNodeLocation(aNode),
+            evalString: ParserHelpers.getIdentifierEvalString(aNode)
+          };
+
+          // Abruptly halt walking the syntax tree.
+          SyntaxTreeVisitor.break = true;
+        }
+      },
+
+      /**
+       * Callback invoked for each literal node.
+       * @param Node aNode
+       */
+      onLiteral: function(aNode) {
+        if (!aIgnoreLiterals) {
+          this.onIdentifier(aNode);
+        }
+      },
+
+      /**
+       * Callback invoked for each 'this' node.
+       * @param Node aNode
+       */
+      onThisExpression: function(aNode) {
+        this.onIdentifier(aNode);
+      }
+    });
+
+    return info;
+  },
+
+  /**
+   * Searches for all function definitions (declarations and expressions)
+   * whose names (or inferred names) contain a string.
+   *
+   * @param string aSubstring
+   *        The string to be contained in the function name (or inferred name).
+   *        Can be an empty string to match all functions.
+   * @return array
+   *         All the matching function declarations and expressions, as
+   *         { functionName, functionLocation ... } object hashes.
+   */
+  getNamedFunctionDefinitions: function(aSubstring) {
+    let lowerCaseToken = aSubstring.toLowerCase();
+    let store = [];
+
+    SyntaxTreeVisitor.walk(this.AST, {
+      /**
+       * Callback invoked for each function declaration node.
+       * @param Node aNode
+       */
+      onFunctionDeclaration: function(aNode) {
+        let functionName = aNode.id.name;
+        if (functionName.toLowerCase().contains(lowerCaseToken)) {
+          store.push({
+            functionName: functionName,
+            functionLocation: ParserHelpers.getNodeLocation(aNode)
+          });
+        }
+      },
+
+      /**
+       * Callback invoked for each function expression node.
+       * @param Node aNode
+       */
+      onFunctionExpression: function(aNode) {
+        // Function expressions don't necessarily have a name.
+        let functionName = aNode.id ? aNode.id.name : "";
+        let functionLocation = ParserHelpers.getNodeLocation(aNode);
+
+        // Infer the function's name from an enclosing syntax tree node.
+        let inferredInfo = ParserHelpers.inferFunctionExpressionInfo(aNode);
+        let inferredName = inferredInfo.name;
+        let inferredChain = inferredInfo.chain;
+        let inferredLocation = inferredInfo.loc;
+
+        // Current node may be part of a larger assignment expression stack.
+        if (aNode._parent.type == "AssignmentExpression") {
+          this.onFunctionExpression(aNode._parent);
+        }
+
+        if ((functionName && functionName.toLowerCase().contains(lowerCaseToken)) ||
+            (inferredName && inferredName.toLowerCase().contains(lowerCaseToken))) {
+          store.push({
+            functionName: functionName,
+            functionLocation: functionLocation,
+            inferredName: inferredName,
+            inferredChain: inferredChain,
+            inferredLocation: inferredLocation
+          });
+        }
+      },
+
+      /**
+       * Callback invoked for each arrow expression node.
+       * @param Node aNode
+       */
+      onArrowExpression: function(aNode) {
+        // Infer the function's name from an enclosing syntax tree node.
+        let inferredInfo = ParserHelpers.inferFunctionExpressionInfo(aNode);
+        let inferredName = inferredInfo.name;
+        let inferredChain = inferredInfo.chain;
+        let inferredLocation = inferredInfo.loc;
+
+        // Current node may be part of a larger assignment expression stack.
+        if (aNode._parent.type == "AssignmentExpression") {
+          this.onFunctionExpression(aNode._parent);
+        }
+
+        if (inferredName && inferredName.toLowerCase().contains(lowerCaseToken)) {
+          store.push({
+            inferredName: inferredName,
+            inferredChain: inferredChain,
+            inferredLocation: inferredLocation
+          });
+        }
+      }
+    });
+
+    return store;
+  },
+
+  AST: null,
+  url: "",
+  length: 0,
+  offset: 0
+};
+
+/**
+ * Parser utility methods.
+ */
+let ParserHelpers = {
+  /**
+   * Gets the location information for a node. Not all nodes have a
+   * location property directly attached, or the location information
+   * is incorrect, in which cases it's accessible via the parent.
+   *
+   * @param Node aNode
+   *        The node who's location needs to be retrieved.
+   * @return object
+   *         An object containing { line, column } information.
+   */
+  getNodeLocation: function(aNode) {
+    if (aNode.type != "Identifier") {
+      return aNode.loc;
+    }
+    // Work around the fact that some identifier nodes don't have the
+    // correct location attached.
+    let { loc: parentLocation, type: parentType } = aNode._parent;
+    let { loc: nodeLocation } = aNode;
+    if (!nodeLocation) {
+      if (parentType == "FunctionDeclaration" ||
+          parentType == "FunctionExpression") {
+        // e.g. "function foo() {}" or "{ bar: function foo() {} }"
+        // The location is unavailable for the identifier node "foo".
+        let loc = JSON.parse(JSON.stringify(parentLocation));
+        loc.end.line = loc.start.line;
+        loc.end.column = loc.start.column + aNode.name.length;
+        return loc;
+      }
+      if (parentType == "MemberExpression") {
+        // e.g. "foo.bar"
+        // The location is unavailable for the identifier node "bar".
+        let loc = JSON.parse(JSON.stringify(parentLocation));
+        loc.start.line = loc.end.line;
+        loc.start.column = loc.end.column - aNode.name.length;
+        return loc;
+      }
+      if (parentType == "LabeledStatement") {
+        // e.g. label: ...
+        // The location is unavailable for the identifier node "label".
+        let loc = JSON.parse(JSON.stringify(parentLocation));
+        loc.end.line = loc.start.line;
+        loc.end.column = loc.start.column + aNode.name.length;
+        return loc;
+      }
+      if (parentType == "ContinueStatement") {
+        // e.g. continue label
+        // The location is unavailable for the identifier node "label".
+        let loc = JSON.parse(JSON.stringify(parentLocation));
+        loc.start.line = loc.end.line;
+        loc.start.column = loc.end.column - aNode.name.length;
+        return loc;
+      }
+    } else {
+      if (parentType == "VariableDeclarator") {
+        // e.g. "let foo = 42"
+        // The location incorrectly spans across the whole variable declaration,
+        // not just the identifier node "foo".
+        let loc = JSON.parse(JSON.stringify(nodeLocation));
+        loc.end.line = loc.start.line;
+        loc.end.column = loc.start.column + aNode.name.length;
+        return loc;
+      }
+    }
+    return aNode.loc;
+  },
+
+  /**
+   * Checks if a node's bounds contains a specified line.
+   *
+   * @param Node aNode
+   *        The node's bounds used as reference.
+   * @param number aLine
+   *        The line number to check.
+   * @return boolean
+   *         True if the line and column is contained in the node's bounds.
+   */
+  nodeContainsLine: function(aNode, aLine) {
+    let { start: s, end: e } = this.getNodeLocation(aNode);
+    return s.line <= aLine && e.line >= aLine;
+  },
+
+  /**
+   * Checks if a node's bounds contains a specified line and column.
+   *
+   * @param Node aNode
+   *        The node's bounds used as reference.
+   * @param number aLine
+   *        The line number to check.
+   * @param number aColumn
+   *        The column number to check.
+   * @return boolean
+   *         True if the line and column is contained in the node's bounds.
+   */
+  nodeContainsPoint: function(aNode, aLine, aColumn) {
+    let { start: s, end: e } = this.getNodeLocation(aNode);
+    return s.line == aLine && e.line == aLine &&
+           s.column <= aColumn && e.column >= aColumn;
+  },
+
+  /**
+   * Try to infer a function expression's name & other details based on the
+   * enclosing VariableDeclarator, AssignmentExpression or ObjectExpression.
+   *
+   * @param Node aNode
+   *        The function expression node to get the name for.
+   * @return object
+   *         The inferred function name, or empty string can't infer the name,
+   *         along with the chain (a generic "context", like a prototype chain)
+   *         and location if available.
+   */
+  inferFunctionExpressionInfo: function(aNode) {
+    let parent = aNode._parent;
+
+    // A function expression may be defined in a variable declarator,
+    // e.g. var foo = function(){}, in which case it is possible to infer
+    // the variable name.
+    if (parent.type == "VariableDeclarator") {
+      return {
+        name: parent.id.name,
+        chain: null,
+        loc: this.getNodeLocation(parent.id)
+      };
+    }
+
+    // Function expressions can also be defined in assignment expressions,
+    // e.g. foo = function(){} or foo.bar = function(){}, in which case it is
+    // possible to infer the assignee name ("foo" and "bar" respectively).
+    if (parent.type == "AssignmentExpression") {
+      let propertyChain = this._getMemberExpressionPropertyChain(parent.left);
+      let propertyLeaf = propertyChain.pop();
+      return {
+        name: propertyLeaf,
+        chain: propertyChain,
+        loc: this.getNodeLocation(parent.left)
+      };
+    }
+
+    // If a function expression is defined in an object expression,
+    // e.g. { foo: function(){} }, then it is possible to infer the name
+    // from the corresponding property.
+    if (parent.type == "ObjectExpression") {
+      let propertyKey = this._getObjectExpressionPropertyKeyForValue(aNode);
+      let propertyChain = this._getObjectExpressionPropertyChain(parent);
+      let propertyLeaf = propertyKey.name;
+      return {
+        name: propertyLeaf,
+        chain: propertyChain,
+        loc: this.getNodeLocation(propertyKey)
+      };
+    }
+
+    // Can't infer the function expression's name.
+    return {
+      name: "",
+      chain: null,
+      loc: null
+    };
+  },
+
+  /**
+   * Gets the name of an object expression's property to which a specified
+   * value is assigned.
+   *
+   * Used for inferring function expression information and retrieving
+   * an identifier evaluation string.
+   *
+   * For example, if aNode represents the "bar" identifier in a hypothetical
+   * "{ foo: bar }" object expression, the returned node is the "foo" identifier.
+   *
+   * @param Node aNode
+   *        The value node in an object expression.
+   * @return object
+   *         The key identifier node in the object expression.
+   */
+  _getObjectExpressionPropertyKeyForValue: function(aNode) {
+    let parent = aNode._parent;
+    if (parent.type != "ObjectExpression") {
+      return null;
+    }
+    for (let property of parent.properties) {
+      if (property.value == aNode) {
+        return property.key;
+      }
+    }
+  },
+
+  /**
+   * Gets an object expression's property chain to its parent
+   * variable declarator or assignment expression, if available.
+   *
+   * Used for inferring function expression information and retrieving
+   * an identifier evaluation string.
+   *
+   * For example, if aNode represents the "baz: {}" object expression in a
+   * hypothetical "foo = { bar: { baz: {} } }" assignment expression, the
+   * returned chain is ["foo", "bar", "baz"].
+   *
+   * @param Node aNode
+   *        The object expression node to begin the scan from.
+   * @param array aStore [optional]
+   *        The chain to store the nodes into.
+   * @return array
+   *         The chain to the parent variable declarator, as strings.
+   */
+  _getObjectExpressionPropertyChain: function(aNode, aStore = []) {
+    switch (aNode.type) {
+      case "ObjectExpression":
+        this._getObjectExpressionPropertyChain(aNode._parent, aStore);
+        let propertyKey = this._getObjectExpressionPropertyKeyForValue(aNode);
+        if (propertyKey) {
+          aStore.push(propertyKey.name);
+        }
+        break;
+      // Handle "var foo = { ... }" variable declarators.
+      case "VariableDeclarator":
+        aStore.push(aNode.id.name);
+        break;
+      // Handle "foo.bar = { ... }" assignment expressions, since they're
+      // commonly used when defining an object's prototype methods; e.g:
+      // "Foo.prototype = { ... }".
+      case "AssignmentExpression":
+        this._getMemberExpressionPropertyChain(aNode.left, aStore);
+        break;
+      // Additionally handle stuff like "foo = bar.baz({ ... })", because it's
+      // commonly used in prototype-based inheritance in many libraries; e.g:
+      // "Foo = Bar.extend({ ... })".
+      case "NewExpression":
+      case "CallExpression":
+        this._getObjectExpressionPropertyChain(aNode._parent, aStore);
+        break;
+    }
+    return aStore;
+  },
+
+  /**
+   * Gets a member expression's property chain.
+   *
+   * Used for inferring function expression information and retrieving
+   * an identifier evaluation string.
+   *
+   * For example, if aNode represents a hypothetical "foo.bar.baz"
+   * member expression, the returned chain ["foo", "bar", "baz"].
+   *
+   * More complex expressions like foo.bar().baz are intentionally not handled.
+   *
+   * @param Node aNode
+   *        The member expression node to begin the scan from.
+   * @param array aStore [optional]
+   *        The chain to store the nodes into.
+   * @return array
+   *         The full member chain, as strings.
+   */
+  _getMemberExpressionPropertyChain: function(aNode, aStore = []) {
+    switch (aNode.type) {
+      case "MemberExpression":
+        this._getMemberExpressionPropertyChain(aNode.object, aStore);
+        this._getMemberExpressionPropertyChain(aNode.property, aStore);
+        break;
+      case "ThisExpression":
+        aStore.push("this");
+        break;
+      case "Identifier":
+        aStore.push(aNode.name);
+        break;
+    }
+    return aStore;
+  },
+
+  /**
+   * Returns an evaluation string which can be used to obtain the
+   * current value for the respective identifier.
+   *
+   * @param Node aNode
+   *        The leaf node (e.g. Identifier, Literal) to begin the scan from.
+   * @return string
+   *         The corresponding evaluation string, or empty string if
+   *         the specified leaf node can't be used.
+   */
+  getIdentifierEvalString: function(aNode) {
+    switch (aNode._parent.type) {
+      case "ObjectExpression":
+        // If the identifier is the actual property value, it can be used
+        // directly as an evaluation string. Otherwise, construct the property
+        // access chain, since the value might have changed.
+        if (!this._getObjectExpressionPropertyKeyForValue(aNode)) {
+          let propertyChain = this._getObjectExpressionPropertyChain(aNode._parent);
+          let propertyLeaf = aNode.name;
+          return [...propertyChain, propertyLeaf].join(".");
+        }
+        break;
+      case "MemberExpression":
+        // Make sure this is a property identifier, not the parent object.
+        if (aNode._parent.property == aNode) {
+          return this._getMemberExpressionPropertyChain(aNode._parent).join(".");
+        }
+        break;
+    }
+    switch (aNode.type) {
+      case "ThisExpression":
+        return "this";
+      case "Identifier":
+        return aNode.name;
+      case "Literal":
+        return uneval(aNode.value);
+      default:
+        return "";
+    }
+  }
+};
+
+/**
+ * A visitor for a syntax tree generated by the reflection API.
+ * See https://developer.mozilla.org/en-US/docs/SpiderMonkey/Parser_API.
+ *
+ * All node types implement the following interface:
+ * interface Node {
+ *   type: string;
+ *   loc: SourceLocation | null;
+ * }
+ */
+let SyntaxTreeVisitor = {
+  /**
+   * Walks a syntax tree.
+   *
+   * @param object aTree
+   *        The AST nodes generated by the reflection API
+   * @param object aCallbacks
+   *        A map of all the callbacks to invoke when passing through certain
+   *        types of noes (e.g: onFunctionDeclaration, onBlockStatement etc.).
+   */
+  walk: function(aTree, aCallbacks) {
+    this.break = false;
+    this[aTree.type](aTree, aCallbacks);
+  },
+
+  /**
+   * Filters all the nodes in this syntax tree based on a predicate.
+   *
+   * @param object aTree
+   *        The AST nodes generated by the reflection API
+   * @param function aPredicate
+   *        The predicate ran on each node.
+   * @return array
+   *         An array of nodes validating the predicate.
+   */
+  filter: function(aTree, aPredicate) {
+    let store = [];
+    this.walk(aTree, { onNode: e => { if (aPredicate(e)) store.push(e); } });
+    return store;
+  },
+
+  /**
+   * A flag checked on each node in the syntax tree. If true, walking is
+   * abruptly halted.
+   */
+  break: false,
+
+  /**
+   * A complete program source tree.
+   *
+   * interface Program <: Node {
+   *   type: "Program";
+   *   body: [ Statement ];
+   * }
+   */
+  Program: function(aNode, aCallbacks) {
+    if (aCallbacks.onProgram) {
+      aCallbacks.onProgram(aNode);
+    }
+    for (let statement of aNode.body) {
+      this[statement.type](statement, aNode, aCallbacks);
+    }
+  },
+
+  /**
+   * Any statement.
+   *
+   * interface Statement <: Node { }
+   */
+  Statement: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onStatement) {
+      aCallbacks.onStatement(aNode);
+    }
+  },
+
+  /**
+   * An empty statement, i.e., a solitary semicolon.
+   *
+   * interface EmptyStatement <: Statement {
+   *   type: "EmptyStatement";
+   * }
+   */
+  EmptyStatement: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onEmptyStatement) {
+      aCallbacks.onEmptyStatement(aNode);
+    }
+  },
+
+  /**
+   * A block statement, i.e., a sequence of statements surrounded by braces.
+   *
+   * interface BlockStatement <: Statement {
+   *   type: "BlockStatement";
+   *   body: [ Statement ];
+   * }
+   */
+  BlockStatement: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onBlockStatement) {
+      aCallbacks.onBlockStatement(aNode);
+    }
+    for (let statement of aNode.body) {
+      this[statement.type](statement, aNode, aCallbacks);
+    }
+  },
+
+  /**
+   * An expression statement, i.e., a statement consisting of a single expression.
+   *
+   * interface ExpressionStatement <: Statement {
+   *   type: "ExpressionStatement";
+   *   expression: Expression;
+   * }
+   */
+  ExpressionStatement: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onExpressionStatement) {
+      aCallbacks.onExpressionStatement(aNode);
+    }
+    this[aNode.expression.type](aNode.expression, aNode, aCallbacks);
+  },
+
+  /**
+   * An if statement.
+   *
+   * interface IfStatement <: Statement {
+   *   type: "IfStatement";
+   *   test: Expression;
+   *   consequent: Statement;
+   *   alternate: Statement | null;
+   * }
+   */
+  IfStatement: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onIfStatement) {
+      aCallbacks.onIfStatement(aNode);
+    }
+    this[aNode.test.type](aNode.test, aNode, aCallbacks);
+    this[aNode.consequent.type](aNode.consequent, aNode, aCallbacks);
+    if (aNode.alternate) {
+      this[aNode.alternate.type](aNode.alternate, aNode, aCallbacks);
+    }
+  },
+
+  /**
+   * A labeled statement, i.e., a statement prefixed by a break/continue label.
+   *
+   * interface LabeledStatement <: Statement {
+   *   type: "LabeledStatement";
+   *   label: Identifier;
+   *   body: Statement;
+   * }
+   */
+  LabeledStatement: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onLabeledStatement) {
+      aCallbacks.onLabeledStatement(aNode);
+    }
+    this[aNode.label.type](aNode.label, aNode, aCallbacks);
+    this[aNode.body.type](aNode.body, aNode, aCallbacks);
+  },
+
+  /**
+   * A break statement.
+   *
+   * interface BreakStatement <: Statement {
+   *   type: "BreakStatement";
+   *   label: Identifier | null;
+   * }
+   */
+  BreakStatement: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onBreakStatement) {
+      aCallbacks.onBreakStatement(aNode);
+    }
+    if (aNode.label) {
+      this[aNode.label.type](aNode.label, aNode, aCallbacks);
+    }
+  },
+
+  /**
+   * A continue statement.
+   *
+   * interface ContinueStatement <: Statement {
+   *   type: "ContinueStatement";
+   *   label: Identifier | null;
+   * }
+   */
+  ContinueStatement: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onContinueStatement) {
+      aCallbacks.onContinueStatement(aNode);
+    }
+    if (aNode.label) {
+      this[aNode.label.type](aNode.label, aNode, aCallbacks);
+    }
+  },
+
+  /**
+   * A with statement.
+   *
+   * interface WithStatement <: Statement {
+   *   type: "WithStatement";
+   *   object: Expression;
+   *   body: Statement;
+   * }
+   */
+  WithStatement: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onWithStatement) {
+      aCallbacks.onWithStatement(aNode);
+    }
+    this[aNode.object.type](aNode.object, aNode, aCallbacks);
+    this[aNode.body.type](aNode.body, aNode, aCallbacks);
+  },
+
+  /**
+   * A switch statement. The lexical flag is metadata indicating whether the
+   * switch statement contains any unnested let declarations (and therefore
+   * introduces a new lexical scope).
+   *
+   * interface SwitchStatement <: Statement {
+   *   type: "SwitchStatement";
+   *   discriminant: Expression;
+   *   cases: [ SwitchCase ];
+   *   lexical: boolean;
+   * }
+   */
+  SwitchStatement: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onSwitchStatement) {
+      aCallbacks.onSwitchStatement(aNode);
+    }
+    this[aNode.discriminant.type](aNode.discriminant, aNode, aCallbacks);
+    for (let _case of aNode.cases) {
+      this[_case.type](_case, aNode, aCallbacks);
+    }
+  },
+
+  /**
+   * A return statement.
+   *
+   * interface ReturnStatement <: Statement {
+   *   type: "ReturnStatement";
+   *   argument: Expression | null;
+   * }
+   */
+  ReturnStatement: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onReturnStatement) {
+      aCallbacks.onReturnStatement(aNode);
+    }
+    if (aNode.argument) {
+      this[aNode.argument.type](aNode.argument, aNode, aCallbacks);
+    }
+  },
+
+  /**
+   * A throw statement.
+   *
+   * interface ThrowStatement <: Statement {
+   *   type: "ThrowStatement";
+   *   argument: Expression;
+   * }
+   */
+  ThrowStatement: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onThrowStatement) {
+      aCallbacks.onThrowStatement(aNode);
+    }
+    this[aNode.argument.type](aNode.argument, aNode, aCallbacks);
+  },
+
+  /**
+   * A try statement.
+   *
+   * interface TryStatement <: Statement {
+   *   type: "TryStatement";
+   *   block: BlockStatement;
+   *   handler: CatchClause | null;
+   *   guardedHandlers: [ CatchClause ];
+   *   finalizer: BlockStatement | null;
+   * }
+   */
+  TryStatement: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onTryStatement) {
+      aCallbacks.onTryStatement(aNode);
+    }
+    this[aNode.block.type](aNode.block, aNode, aCallbacks);
+    if (aNode.handler) {
+      this[aNode.handler.type](aNode.handler, aNode, aCallbacks);
+    }
+    for (let guardedHandler of aNode.guardedHandlers) {
+      this[guardedHandler.type](guardedHandler, aNode, aCallbacks);
+    }
+    if (aNode.finalizer) {
+      this[aNode.finalizer.type](aNode.finalizer, aNode, aCallbacks);
+    }
+  },
+
+  /**
+   * A while statement.
+   *
+   * interface WhileStatement <: Statement {
+   *   type: "WhileStatement";
+   *   test: Expression;
+   *   body: Statement;
+   * }
+   */
+  WhileStatement: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onWhileStatement) {
+      aCallbacks.onWhileStatement(aNode);
+    }
+    this[aNode.test.type](aNode.test, aNode, aCallbacks);
+    this[aNode.body.type](aNode.body, aNode, aCallbacks);
+  },
+
+  /**
+   * A do/while statement.
+   *
+   * interface DoWhileStatement <: Statement {
+   *   type: "DoWhileStatement";
+   *   body: Statement;
+   *   test: Expression;
+   * }
+   */
+  DoWhileStatement: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onDoWhileStatement) {
+      aCallbacks.onDoWhileStatement(aNode);
+    }
+    this[aNode.body.type](aNode.body, aNode, aCallbacks);
+    this[aNode.test.type](aNode.test, aNode, aCallbacks);
+  },
+
+  /**
+   * A for statement.
+   *
+   * interface ForStatement <: Statement {
+   *   type: "ForStatement";
+   *   init: VariableDeclaration | Expression | null;
+   *   test: Expression | null;
+   *   update: Expression | null;
+   *   body: Statement;
+   * }
+   */
+  ForStatement: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onForStatement) {
+      aCallbacks.onForStatement(aNode);
+    }
+    if (aNode.init) {
+      this[aNode.init.type](aNode.init, aNode, aCallbacks);
+    }
+    if (aNode.test) {
+      this[aNode.test.type](aNode.test, aNode, aCallbacks);
+    }
+    if (aNode.update) {
+      this[aNode.update.type](aNode.update, aNode, aCallbacks);
+    }
+    this[aNode.body.type](aNode.body, aNode, aCallbacks);
+  },
+
+  /**
+   * A for/in statement, or, if each is true, a for each/in statement.
+   *
+   * interface ForInStatement <: Statement {
+   *   type: "ForInStatement";
+   *   left: VariableDeclaration | Expression;
+   *   right: Expression;
+   *   body: Statement;
+   *   each: boolean;
+   * }
+   */
+  ForInStatement: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onForInStatement) {
+      aCallbacks.onForInStatement(aNode);
+    }
+    this[aNode.left.type](aNode.left, aNode, aCallbacks);
+    this[aNode.right.type](aNode.right, aNode, aCallbacks);
+    this[aNode.body.type](aNode.body, aNode, aCallbacks);
+  },
+
+  /**
+   * A for/of statement.
+   *
+   * interface ForOfStatement <: Statement {
+   *   type: "ForOfStatement";
+   *   left: VariableDeclaration | Expression;
+   *   right: Expression;
+   *   body: Statement;
+   * }
+   */
+  ForOfStatement: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onForOfStatement) {
+      aCallbacks.onForOfStatement(aNode);
+    }
+    this[aNode.left.type](aNode.left, aNode, aCallbacks);
+    this[aNode.right.type](aNode.right, aNode, aCallbacks);
+    this[aNode.body.type](aNode.body, aNode, aCallbacks);
+  },
+
+  /**
+   * A let statement.
+   *
+   * interface LetStatement <: Statement {
+   *   type: "LetStatement";
+   *   head: [ { id: Pattern, init: Expression | null } ];
+   *   body: Statement;
+   * }
+   */
+  LetStatement: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onLetStatement) {
+      aCallbacks.onLetStatement(aNode);
+    }
+    for (let { id, init } of aNode.head) {
+      this[id.type](id, aNode, aCallbacks);
+      if (init) {
+        this[init.type](init, aNode, aCallbacks);
+      }
+    }
+    this[aNode.body.type](aNode.body, aNode, aCallbacks);
+  },
+
+  /**
+   * A debugger statement.
+   *
+   * interface DebuggerStatement <: Statement {
+   *   type: "DebuggerStatement";
+   * }
+   */
+  DebuggerStatement: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onDebuggerStatement) {
+      aCallbacks.onDebuggerStatement(aNode);
+    }
+  },
+
+  /**
+   * Any declaration node. Note that declarations are considered statements;
+   * this is because declarations can appear in any statement context in the
+   * language recognized by the SpiderMonkey parser.
+   *
+   * interface Declaration <: Statement { }
+   */
+  Declaration: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onDeclaration) {
+      aCallbacks.onDeclaration(aNode);
+    }
+  },
+
+  /**
+   * A function declaration.
+   *
+   * interface FunctionDeclaration <: Function, Declaration {
+   *   type: "FunctionDeclaration";
+   *   id: Identifier;
+   *   params: [ Pattern ];
+   *   defaults: [ Expression ];
+   *   rest: Identifier | null;
+   *   body: BlockStatement | Expression;
+   *   generator: boolean;
+   *   expression: boolean;
+   * }
+   */
+  FunctionDeclaration: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onFunctionDeclaration) {
+      aCallbacks.onFunctionDeclaration(aNode);
+    }
+    this[aNode.id.type](aNode.id, aNode, aCallbacks);
+    for (let param of aNode.params) {
+      this[param.type](param, aNode, aCallbacks);
+    }
+    for (let _default of aNode.defaults) {
+      this[_default.type](_default, aNode, aCallbacks);
+    }
+    if (aNode.rest) {
+      this[aNode.rest.type](aNode.rest, aNode, aCallbacks);
+    }
+    this[aNode.body.type](aNode.body, aNode, aCallbacks);
+  },
+
+  /**
+   * A variable declaration, via one of var, let, or const.
+   *
+   * interface VariableDeclaration <: Declaration {
+   *   type: "VariableDeclaration";
+   *   declarations: [ VariableDeclarator ];
+   *   kind: "var" | "let" | "const";
+   * }
+   */
+  VariableDeclaration: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onVariableDeclaration) {
+      aCallbacks.onVariableDeclaration(aNode);
+    }
+    for (let declaration of aNode.declarations) {
+      this[declaration.type](declaration, aNode, aCallbacks);
+    }
+  },
+
+  /**
+   * A variable declarator.
+   *
+   * interface VariableDeclarator <: Node {
+   *   type: "VariableDeclarator";
+   *   id: Pattern;
+   *   init: Expression | null;
+   * }
+   */
+  VariableDeclarator: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onVariableDeclarator) {
+      aCallbacks.onVariableDeclarator(aNode);
+    }
+    this[aNode.id.type](aNode.id, aNode, aCallbacks);
+    if (aNode.init) {
+      this[aNode.init.type](aNode.init, aNode, aCallbacks);
+    }
+  },
+
+  /**
+   * Any expression node. Since the left-hand side of an assignment may be any
+   * expression in general, an expression can also be a pattern.
+   *
+   * interface Expression <: Node, Pattern { }
+   */
+  Expression: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onExpression) {
+      aCallbacks.onExpression(aNode);
+    }
+  },
+
+  /**
+   * A this expression.
+   *
+   * interface ThisExpression <: Expression {
+   *   type: "ThisExpression";
+   * }
+   */
+  ThisExpression: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onThisExpression) {
+      aCallbacks.onThisExpression(aNode);
+    }
+  },
+
+  /**
+   * An array expression.
+   *
+   * interface ArrayExpression <: Expression {
+   *   type: "ArrayExpression";
+   *   elements: [ Expression | null ];
+   * }
+   */
+  ArrayExpression: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onArrayExpression) {
+      aCallbacks.onArrayExpression(aNode);
+    }
+    for (let element of aNode.elements) {
+      // TODO: remove the typeof check when support for SpreadExpression is
+      // added (bug 890913).
+      if (element && typeof this[element.type] == "function") {
+        this[element.type](element, aNode, aCallbacks);
+      }
+    }
+  },
+
+  /**
+   * An object expression. A literal property in an object expression can have
+   * either a string or number as its value. Ordinary property initializers
+   * have a kind value "init"; getters and setters have the kind values "get"
+   * and "set", respectively.
+   *
+   * interface ObjectExpression <: Expression {
+   *   type: "ObjectExpression";
+   *   properties: [ { key: Literal | Identifier,
+   *                   value: Expression,
+   *                   kind: "init" | "get" | "set" } ];
+   * }
+   */
+  ObjectExpression: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onObjectExpression) {
+      aCallbacks.onObjectExpression(aNode);
+    }
+    for (let { key, value } of aNode.properties) {
+      this[key.type](key, aNode, aCallbacks);
+      this[value.type](value, aNode, aCallbacks);
+    }
+  },
+
+  /**
+   * A function expression.
+   *
+   * interface FunctionExpression <: Function, Expression {
+   *   type: "FunctionExpression";
+   *   id: Identifier | null;
+   *   params: [ Pattern ];
+   *   defaults: [ Expression ];
+   *   rest: Identifier | null;
+   *   body: BlockStatement | Expression;
+   *   generator: boolean;
+   *   expression: boolean;
+   * }
+   */
+  FunctionExpression: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onFunctionExpression) {
+      aCallbacks.onFunctionExpression(aNode);
+    }
+    if (aNode.id) {
+      this[aNode.id.type](aNode.id, aNode, aCallbacks);
+    }
+    for (let param of aNode.params) {
+      this[param.type](param, aNode, aCallbacks);
+    }
+    for (let _default of aNode.defaults) {
+      this[_default.type](_default, aNode, aCallbacks);
+    }
+    if (aNode.rest) {
+      this[aNode.rest.type](aNode.rest, aNode, aCallbacks);
+    }
+    this[aNode.body.type](aNode.body, aNode, aCallbacks);
+  },
+
+  /**
+   * An arrow expression.
+   *
+   * interface ArrowExpression <: Function, Expression {
+   *   type: "ArrowExpression";
+   *   params: [ Pattern ];
+   *   defaults: [ Expression ];
+   *   rest: Identifier | null;
+   *   body: BlockStatement | Expression;
+   *   generator: boolean;
+   *   expression: boolean;
+   * }
+   */
+  ArrowExpression: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onArrowExpression) {
+      aCallbacks.onArrowExpression(aNode);
+    }
+    for (let param of aNode.params) {
+      this[param.type](param, aNode, aCallbacks);
+    }
+    for (let _default of aNode.defaults) {
+      this[_default.type](_default, aNode, aCallbacks);
+    }
+    if (aNode.rest) {
+      this[aNode.rest.type](aNode.rest, aNode, aCallbacks);
+    }
+    this[aNode.body.type](aNode.body, aNode, aCallbacks);
+  },
+
+  /**
+   * A sequence expression, i.e., a comma-separated sequence of expressions.
+   *
+   * interface SequenceExpression <: Expression {
+   *   type: "SequenceExpression";
+   *   expressions: [ Expression ];
+   * }
+   */
+  SequenceExpression: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onSequenceExpression) {
+      aCallbacks.onSequenceExpression(aNode);
+    }
+    for (let expression of aNode.expressions) {
+      this[expression.type](expression, aNode, aCallbacks);
+    }
+  },
+
+  /**
+   * A unary operator expression.
+   *
+   * interface UnaryExpression <: Expression {
+   *   type: "UnaryExpression";
+   *   operator: UnaryOperator;
+   *   prefix: boolean;
+   *   argument: Expression;
+   * }
+   */
+  UnaryExpression: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onUnaryExpression) {
+      aCallbacks.onUnaryExpression(aNode);
+    }
+    this[aNode.argument.type](aNode.argument, aNode, aCallbacks);
+  },
+
+  /**
+   * A binary operator expression.
+   *
+   * interface BinaryExpression <: Expression {
+   *   type: "BinaryExpression";
+   *   operator: BinaryOperator;
+   *   left: Expression;
+   *   right: Expression;
+   * }
+   */
+  BinaryExpression: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onBinaryExpression) {
+      aCallbacks.onBinaryExpression(aNode);
+    }
+    this[aNode.left.type](aNode.left, aNode, aCallbacks);
+    this[aNode.right.type](aNode.right, aNode, aCallbacks);
+  },
+
+  /**
+   * An assignment operator expression.
+   *
+   * interface AssignmentExpression <: Expression {
+   *   type: "AssignmentExpression";
+   *   operator: AssignmentOperator;
+   *   left: Expression;
+   *   right: Expression;
+   * }
+   */
+  AssignmentExpression: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onAssignmentExpression) {
+      aCallbacks.onAssignmentExpression(aNode);
+    }
+    this[aNode.left.type](aNode.left, aNode, aCallbacks);
+    this[aNode.right.type](aNode.right, aNode, aCallbacks);
+  },
+
+  /**
+   * An update (increment or decrement) operator expression.
+   *
+   * interface UpdateExpression <: Expression {
+   *   type: "UpdateExpression";
+   *   operator: UpdateOperator;
+   *   argument: Expression;
+   *   prefix: boolean;
+   * }
+   */
+  UpdateExpression: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onUpdateExpression) {
+      aCallbacks.onUpdateExpression(aNode);
+    }
+    this[aNode.argument.type](aNode.argument, aNode, aCallbacks);
+  },
+
+  /**
+   * A logical operator expression.
+   *
+   * interface LogicalExpression <: Expression {
+   *   type: "LogicalExpression";
+   *   operator: LogicalOperator;
+   *   left: Expression;
+   *   right: Expression;
+   * }
+   */
+  LogicalExpression: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onLogicalExpression) {
+      aCallbacks.onLogicalExpression(aNode);
+    }
+    this[aNode.left.type](aNode.left, aNode, aCallbacks);
+    this[aNode.right.type](aNode.right, aNode, aCallbacks);
+  },
+
+  /**
+   * A conditional expression, i.e., a ternary ?/: expression.
+   *
+   * interface ConditionalExpression <: Expression {
+   *   type: "ConditionalExpression";
+   *   test: Expression;
+   *   alternate: Expression;
+   *   consequent: Expression;
+   * }
+   */
+  ConditionalExpression: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onConditionalExpression) {
+      aCallbacks.onConditionalExpression(aNode);
+    }
+    this[aNode.test.type](aNode.test, aNode, aCallbacks);
+    this[aNode.alternate.type](aNode.alternate, aNode, aCallbacks);
+    this[aNode.consequent.type](aNode.consequent, aNode, aCallbacks);
+  },
+
+  /**
+   * A new expression.
+   *
+   * interface NewExpression <: Expression {
+   *   type: "NewExpression";
+   *   callee: Expression;
+   *   arguments: [ Expression | null ];
+   * }
+   */
+  NewExpression: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onNewExpression) {
+      aCallbacks.onNewExpression(aNode);
+    }
+    this[aNode.callee.type](aNode.callee, aNode, aCallbacks);
+    for (let argument of aNode.arguments) {
+      if (argument) {
+        this[argument.type](argument, aNode, aCallbacks);
+      }
+    }
+  },
+
+  /**
+   * A function or method call expression.
+   *
+   * interface CallExpression <: Expression {
+   *   type: "CallExpression";
+   *   callee: Expression;
+   *   arguments: [ Expression | null ];
+   * }
+   */
+  CallExpression: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onCallExpression) {
+      aCallbacks.onCallExpression(aNode);
+    }
+    this[aNode.callee.type](aNode.callee, aNode, aCallbacks);
+    for (let argument of aNode.arguments) {
+      if (argument) {
+        this[argument.type](argument, aNode, aCallbacks);
+      }
+    }
+  },
+
+  /**
+   * A member expression. If computed is true, the node corresponds to a
+   * computed e1[e2] expression and property is an Expression. If computed is
+   * false, the node corresponds to a static e1.x expression and property is an
+   * Identifier.
+   *
+   * interface MemberExpression <: Expression {
+   *   type: "MemberExpression";
+   *   object: Expression;
+   *   property: Identifier | Expression;
+   *   computed: boolean;
+   * }
+   */
+  MemberExpression: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onMemberExpression) {
+      aCallbacks.onMemberExpression(aNode);
+    }
+    this[aNode.object.type](aNode.object, aNode, aCallbacks);
+    this[aNode.property.type](aNode.property, aNode, aCallbacks);
+  },
+
+  /**
+   * A yield expression.
+   *
+   * interface YieldExpression <: Expression {
+   *   argument: Expression | null;
+   * }
+   */
+  YieldExpression: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onYieldExpression) {
+      aCallbacks.onYieldExpression(aNode);
+    }
+    if (aNode.argument) {
+      this[aNode.argument.type](aNode.argument, aNode, aCallbacks);
+    }
+  },
+
+  /**
+   * An array comprehension. The blocks array corresponds to the sequence of
+   * for and for each blocks. The optional filter expression corresponds to the
+   * final if clause, if present.
+   *
+   * interface ComprehensionExpression <: Expression {
+   *   body: Expression;
+   *   blocks: [ ComprehensionBlock ];
+   *   filter: Expression | null;
+   * }
+   */
+  ComprehensionExpression: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onComprehensionExpression) {
+      aCallbacks.onComprehensionExpression(aNode);
+    }
+    this[aNode.body.type](aNode.body, aNode, aCallbacks);
+    for (let block of aNode.blocks) {
+      this[block.type](block, aNode, aCallbacks);
+    }
+    if (aNode.filter) {
+      this[aNode.filter.type](aNode.filter, aNode, aCallbacks);
+    }
+  },
+
+  /**
+   * A generator expression. As with array comprehensions, the blocks array
+   * corresponds to the sequence of for and for each blocks, and the optional
+   * filter expression corresponds to the final if clause, if present.
+   *
+   * interface GeneratorExpression <: Expression {
+   *   body: Expression;
+   *   blocks: [ ComprehensionBlock ];
+   *   filter: Expression | null;
+   * }
+   */
+  GeneratorExpression: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onGeneratorExpression) {
+      aCallbacks.onGeneratorExpression(aNode);
+    }
+    this[aNode.body.type](aNode.body, aNode, aCallbacks);
+    for (let block of aNode.blocks) {
+      this[block.type](block, aNode, aCallbacks);
+    }
+    if (aNode.filter) {
+      this[aNode.filter.type](aNode.filter, aNode, aCallbacks);
+    }
+  },
+
+  /**
+   * A graph expression, aka "sharp literal," such as #1={ self: #1# }.
+   *
+   * interface GraphExpression <: Expression {
+   *   index: uint32;
+   *   expression: Literal;
+   * }
+   */
+  GraphExpression: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onGraphExpression) {
+      aCallbacks.onGraphExpression(aNode);
+    }
+    this[aNode.expression.type](aNode.expression, aNode, aCallbacks);
+  },
+
+  /**
+   * A graph index expression, aka "sharp variable," such as #1#.
+   *
+   * interface GraphIndexExpression <: Expression {
+   *   index: uint32;
+   * }
+   */
+  GraphIndexExpression: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onGraphIndexExpression) {
+      aCallbacks.onGraphIndexExpression(aNode);
+    }
+  },
+
+  /**
+   * A let expression.
+   *
+   * interface LetExpression <: Expression {
+   *   type: "LetExpression";
+   *   head: [ { id: Pattern, init: Expression | null } ];
+   *   body: Expression;
+   * }
+   */
+  LetExpression: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onLetExpression) {
+      aCallbacks.onLetExpression(aNode);
+    }
+    for (let { id, init } of aNode.head) {
+      this[id.type](id, aNode, aCallbacks);
+      if (init) {
+        this[init.type](init, aNode, aCallbacks);
+      }
+    }
+    this[aNode.body.type](aNode.body, aNode, aCallbacks);
+  },
+
+  /**
+   * Any pattern.
+   *
+   * interface Pattern <: Node { }
+   */
+  Pattern: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onPattern) {
+      aCallbacks.onPattern(aNode);
+    }
+  },
+
+  /**
+   * An object-destructuring pattern. A literal property in an object pattern
+   * can have either a string or number as its value.
+   *
+   * interface ObjectPattern <: Pattern {
+   *   type: "ObjectPattern";
+   *   properties: [ { key: Literal | Identifier, value: Pattern } ];
+   * }
+   */
+  ObjectPattern: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onObjectPattern) {
+      aCallbacks.onObjectPattern(aNode);
+    }
+    for (let { key, value } of aNode.properties) {
+      this[key.type](key, aNode, aCallbacks);
+      this[value.type](value, aNode, aCallbacks);
+    }
+  },
+
+  /**
+   * An array-destructuring pattern.
+   *
+   * interface ArrayPattern <: Pattern {
+   *   type: "ArrayPattern";
+   *   elements: [ Pattern | null ];
+   * }
+   */
+  ArrayPattern: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onArrayPattern) {
+      aCallbacks.onArrayPattern(aNode);
+    }
+    for (let element of aNode.elements) {
+      if (element) {
+        this[element.type](element, aNode, aCallbacks);
+      }
+    }
+  },
+
+  /**
+   * A case (if test is an Expression) or default (if test is null) clause in
+   * the body of a switch statement.
+   *
+   * interface SwitchCase <: Node {
+   *   type: "SwitchCase";
+   *   test: Expression | null;
+   *   consequent: [ Statement ];
+   * }
+   */
+  SwitchCase: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onSwitchCase) {
+      aCallbacks.onSwitchCase(aNode);
+    }
+    if (aNode.test) {
+      this[aNode.test.type](aNode.test, aNode, aCallbacks);
+    }
+    for (let consequent of aNode.consequent) {
+      this[consequent.type](consequent, aNode, aCallbacks);
+    }
+  },
+
+  /**
+   * A catch clause following a try block. The optional guard property
+   * corresponds to the optional expression guard on the bound variable.
+   *
+   * interface CatchClause <: Node {
+   *   type: "CatchClause";
+   *   param: Pattern;
+   *   guard: Expression | null;
+   *   body: BlockStatement;
+   * }
+   */
+  CatchClause: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onCatchClause) {
+      aCallbacks.onCatchClause(aNode);
+    }
+    this[aNode.param.type](aNode.param, aNode, aCallbacks);
+    if (aNode.guard) {
+      this[aNode.guard.type](aNode.guard, aNode, aCallbacks);
+    }
+    this[aNode.body.type](aNode.body, aNode, aCallbacks);
+  },
+
+  /**
+   * A for or for each block in an array comprehension or generator expression.
+   *
+   * interface ComprehensionBlock <: Node {
+   *   left: Pattern;
+   *   right: Expression;
+   *   each: boolean;
+   * }
+   */
+  ComprehensionBlock: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onComprehensionBlock) {
+      aCallbacks.onComprehensionBlock(aNode);
+    }
+    this[aNode.left.type](aNode.left, aNode, aCallbacks);
+    this[aNode.right.type](aNode.right, aNode, aCallbacks);
+  },
+
+  /**
+   * An identifier. Note that an identifier may be an expression or a
+   * destructuring pattern.
+   *
+   * interface Identifier <: Node, Expression, Pattern {
+   *   type: "Identifier";
+   *   name: string;
+   * }
+   */
+  Identifier: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onIdentifier) {
+      aCallbacks.onIdentifier(aNode);
+    }
+  },
+
+  /**
+   * A literal token. Note that a literal can be an expression.
+   *
+   * interface Literal <: Node, Expression {
+   *   type: "Literal";
+   *   value: string | boolean | null | number | RegExp;
+   * }
+   */
+  Literal: function(aNode, aParent, aCallbacks) {
+    aNode._parent = aParent;
+
+    if (this.break) {
+      return;
+    }
+    if (aCallbacks.onNode) {
+      if (aCallbacks.onNode(aNode, aParent) === false) {
+        return;
+      }
+    }
+    if (aCallbacks.onLiteral) {
+      aCallbacks.onLiteral(aNode);
+    }
+  }
+};
+
+XPCOMUtils.defineLazyGetter(Parser, "reflectionAPI", () => Reflect);