Add m-esr52 at 52.6.0

1 files changed, 2451 insertions, 0 deletions

diff --git a/devtools/shared/Parser.jsm b/devtools/shared/Parser.jsm
new file mode 100644
index 000000000..4bd635383
--- /dev/null
+++ b/devtools/shared/Parser.jsm
@@ -0,0 +1,2451 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 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 Cu = Components.utils;
+
+const { require } = Cu.import("resource://devtools/shared/Loader.jsm", {});
+const { XPCOMUtils } = require("resource://gre/modules/XPCOMUtils.jsm");
+const { console } = require("resource://gre/modules/Console.jsm");
+const DevToolsUtils = require("devtools/shared/DevToolsUtils");
+
+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 = [];
+  this.logExceptions = true;
+};
+
+Parser.prototype = {
+  /**
+   * Gets a collection of parser methods for a specified source.
+   *
+   * @param string source
+   *        The source text content.
+   * @param string url [optional]
+   *        The source url. The AST nodes will be cached, so you can use this
+   *        identifier to avoid parsing the whole source again.
+   */
+  get(source, url = "") {
+    // Try to use the cached AST nodes, to avoid useless parsing operations.
+    if (this._cache.has(url)) {
+      return this._cache.get(url);
+    }
+
+    // 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 (source.match(/^\s*</)) {
+      // First non whitespace character is &lt, so most definitely HTML.
+      while ((scriptMatch = regexp.exec(source))) {
+        // Contents are captured at index 1 or nothing: Self-closing scripts
+        // won't capture code content
+        scriptMatches.push(scriptMatch[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(source);
+        let length = source.length;
+        syntaxTrees.push(new SyntaxTree(nodes, url, length));
+      } catch (e) {
+        this.errors.push(e);
+        if (this.logExceptions) {
+          DevToolsUtils.reportException(url, e);
+        }
+      }
+    } else {
+      // Generate the AST nodes for each script.
+      for (let script of scriptMatches) {
+        // Reflect.parse throws when encounters a syntax error.
+        try {
+          let nodes = Reflect.parse(script);
+          let offset = source.indexOf(script);
+          let length = script.length;
+          syntaxTrees.push(new SyntaxTree(nodes, url, length, offset));
+        } catch (e) {
+          this.errors.push(e);
+          if (this.logExceptions) {
+            DevToolsUtils.reportException(url, e);
+          }
+        }
+      }
+    }
+
+    let pool = new SyntaxTreesPool(syntaxTrees, url);
+
+    // 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 (url) {
+      this._cache.set(url, pool);
+    }
+
+    return pool;
+  },
+
+  /**
+   * Clears all the parsed sources from cache.
+   */
+  clearCache() {
+    this._cache.clear();
+  },
+
+  /**
+   * Clears the AST for a particular source.
+   *
+   * @param String url
+   *        The URL of the source that is being cleared.
+   */
+  clearSource(url) {
+    this._cache.delete(url);
+  },
+
+  _cache: null,
+  errors: null
+};
+
+/**
+ * A pool handling a collection of AST nodes generated by the reflection API.
+ *
+ * @param object syntaxTrees
+ *        A collection of AST nodes generated for a source.
+ * @param string url [optional]
+ *        The source url.
+ */
+function SyntaxTreesPool(syntaxTrees, url = "<unknown>") {
+  this._trees = syntaxTrees;
+  this._url = url;
+  this._cache = new Map();
+}
+
+SyntaxTreesPool.prototype = {
+  /**
+   * @see SyntaxTree.prototype.getIdentifierAt
+   */
+  getIdentifierAt({ line, column, scriptIndex, ignoreLiterals }) {
+    return this._call("getIdentifierAt",
+      scriptIndex, line, column, ignoreLiterals)[0];
+  },
+
+  /**
+   * @see SyntaxTree.prototype.getNamedFunctionDefinitions
+   */
+  getNamedFunctionDefinitions(substring) {
+    return this._call("getNamedFunctionDefinitions", -1, substring);
+  },
+
+  /**
+   * @return SyntaxTree
+   *         The last tree in this._trees
+   */
+  getLastSyntaxTree() {
+    return this._trees[this._trees.length - 1];
+  },
+
+  /**
+   * 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 atOffset
+   *        The offset relative to the parent source.
+   * @return object
+   *         The offset and length relative to the enclosing script.
+   */
+  getScriptInfo(atOffset) {
+    let info = { start: -1, length: -1, index: -1 };
+
+    for (let { offset, length } of this._trees) {
+      info.index++;
+      if (offset <= atOffset && offset + length >= atOffset) {
+        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 functionName
+   *        The function name to call on the SyntaxTree instances.
+   * @param number syntaxTreeIndex
+   *        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 params
+   *        Any kind params to pass to the request function.
+   * @return array
+   *         The results given by all known syntax trees.
+   */
+  _call(functionName, syntaxTreeIndex, ...params) {
+    let results = [];
+    let requestId = [functionName, syntaxTreeIndex, params].toSource();
+
+    if (this._cache.has(requestId)) {
+      return this._cache.get(requestId);
+    }
+
+    let requestedTree = this._trees[syntaxTreeIndex];
+    let targettedTrees = requestedTree ? [requestedTree] : this._trees;
+
+    for (let syntaxTree of targettedTrees) {
+      try {
+        let parseResults = syntaxTree[functionName].apply(syntaxTree, params);
+        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 ${this._url}`, e);
+      }
+    }
+    this._cache.set(requestId, results);
+    return results;
+  },
+
+  _trees: null,
+  _cache: null
+};
+
+/**
+ * A collection of AST nodes generated by the reflection API.
+ *
+ * @param object nodes
+ *        The AST nodes.
+ * @param string url
+ *        The source url.
+ * @param number length
+ *        The total number of chars of the parsed script in the parent source.
+ * @param number offset [optional]
+ *        The char offset of the parsed script in the parent source.
+ */
+function SyntaxTree(nodes, url, length, offset = 0) {
+  this.AST = nodes;
+  this.url = url;
+  this.length = length;
+  this.offset = offset;
+}
+
+SyntaxTree.prototype = {
+  /**
+   * Gets the identifier at the specified location.
+   *
+   * @param number line
+   *        The line in the source.
+   * @param number column
+   *        The column in the source.
+   * @param boolean ignoreLiterals
+   *        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(line, column, ignoreLiterals) {
+    let info = null;
+
+    SyntaxTreeVisitor.walk(this.AST, {
+      /**
+       * Callback invoked for each identifier node.
+       * @param Node node
+       */
+      onIdentifier(node) {
+        if (ParserHelpers.nodeContainsPoint(node, line, column)) {
+          info = {
+            name: node.name,
+            location: ParserHelpers.getNodeLocation(node),
+            evalString: ParserHelpers.getIdentifierEvalString(node)
+          };
+
+          // Abruptly halt walking the syntax tree.
+          SyntaxTreeVisitor.break = true;
+        }
+      },
+
+      /**
+       * Callback invoked for each literal node.
+       * @param Node node
+       */
+      onLiteral(node) {
+        if (!ignoreLiterals) {
+          this.onIdentifier(node);
+        }
+      },
+
+      /**
+       * Callback invoked for each 'this' node.
+       * @param Node node
+       */
+      onThisExpression(node) {
+        this.onIdentifier(node);
+      }
+    });
+
+    return info;
+  },
+
+  /**
+   * Searches for all function definitions (declarations and expressions)
+   * whose names (or inferred names) contain a string.
+   *
+   * @param string substring
+   *        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(substring) {
+    let lowerCaseToken = substring.toLowerCase();
+    let store = [];
+
+    function includesToken(name) {
+      return name && name.toLowerCase().includes(lowerCaseToken);
+    }
+
+    SyntaxTreeVisitor.walk(this.AST, {
+      /**
+       * Callback invoked for each function declaration node.
+       * @param Node node
+       */
+      onFunctionDeclaration(node) {
+        let functionName = node.id.name;
+        if (includesToken(functionName)) {
+          store.push({
+            functionName: functionName,
+            functionLocation: ParserHelpers.getNodeLocation(node)
+          });
+        }
+      },
+
+      /**
+       * Callback invoked for each function expression node.
+       * @param Node node
+       */
+      onFunctionExpression(node) {
+        // Function expressions don't necessarily have a name.
+        let functionName = node.id ? node.id.name : "";
+        let functionLocation = ParserHelpers.getNodeLocation(node);
+
+        // Infer the function's name from an enclosing syntax tree node.
+        let inferredInfo = ParserHelpers.inferFunctionExpressionInfo(node);
+        let inferredName = inferredInfo.name;
+        let inferredChain = inferredInfo.chain;
+        let inferredLocation = inferredInfo.loc;
+
+        // Current node may be part of a larger assignment expression stack.
+        if (node._parent.type == "AssignmentExpression") {
+          this.onFunctionExpression(node._parent);
+        }
+
+        if (includesToken(functionName) || includesToken(inferredName)) {
+          store.push({
+            functionName: functionName,
+            functionLocation: functionLocation,
+            inferredName: inferredName,
+            inferredChain: inferredChain,
+            inferredLocation: inferredLocation
+          });
+        }
+      },
+
+      /**
+       * Callback invoked for each arrow expression node.
+       * @param Node node
+       */
+      onArrowFunctionExpression(node) {
+        // Infer the function's name from an enclosing syntax tree node.
+        let inferredInfo = ParserHelpers.inferFunctionExpressionInfo(node);
+        let inferredName = inferredInfo.name;
+        let inferredChain = inferredInfo.chain;
+        let inferredLocation = inferredInfo.loc;
+
+        // Current node may be part of a larger assignment expression stack.
+        if (node._parent.type == "AssignmentExpression") {
+          this.onFunctionExpression(node._parent);
+        }
+
+        if (includesToken(inferredName)) {
+          store.push({
+            inferredName: inferredName,
+            inferredChain: inferredChain,
+            inferredLocation: inferredLocation
+          });
+        }
+      }
+    });
+
+    return store;
+  },
+
+  AST: null,
+  url: "",
+  length: 0,
+  offset: 0
+};
+
+/**
+ * Parser utility methods.
+ */
+var 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 node
+   *        The node who's location needs to be retrieved.
+   * @return object
+   *         An object containing { line, column } information.
+   */
+  getNodeLocation(node) {
+    if (node.type != "Identifier") {
+      return node.loc;
+    }
+    // Work around the fact that some identifier nodes don't have the
+    // correct location attached.
+    let { loc: parentLocation, type: parentType } = node._parent;
+    let { loc: nodeLocation } = node;
+    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 = Cu.cloneInto(parentLocation, {});
+        loc.end.line = loc.start.line;
+        loc.end.column = loc.start.column + node.name.length;
+        return loc;
+      }
+      if (parentType == "MemberExpression") {
+        // e.g. "foo.bar"
+        // The location is unavailable for the identifier node "bar".
+        let loc = Cu.cloneInto(parentLocation, {});
+        loc.start.line = loc.end.line;
+        loc.start.column = loc.end.column - node.name.length;
+        return loc;
+      }
+      if (parentType == "LabeledStatement") {
+        // e.g. label: ...
+        // The location is unavailable for the identifier node "label".
+        let loc = Cu.cloneInto(parentLocation, {});
+        loc.end.line = loc.start.line;
+        loc.end.column = loc.start.column + node.name.length;
+        return loc;
+      }
+      if (parentType == "ContinueStatement" || parentType == "BreakStatement") {
+        // e.g. continue label; or break label;
+        // The location is unavailable for the identifier node "label".
+        let loc = Cu.cloneInto(parentLocation, {});
+        loc.start.line = loc.end.line;
+        loc.start.column = loc.end.column - node.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 = Cu.cloneInto(nodeLocation, {});
+      loc.end.line = loc.start.line;
+      loc.end.column = loc.start.column + node.name.length;
+      return loc;
+    }
+    return node.loc;
+  },
+
+  /**
+   * Checks if a node's bounds contains a specified line.
+   *
+   * @param Node node
+   *        The node's bounds used as reference.
+   * @param number line
+   *        The line number to check.
+   * @return boolean
+   *         True if the line and column is contained in the node's bounds.
+   */
+  nodeContainsLine(node, line) {
+    let { start: s, end: e } = this.getNodeLocation(node);
+    return s.line <= line && e.line >= line;
+  },
+
+  /**
+   * Checks if a node's bounds contains a specified line and column.
+   *
+   * @param Node node
+   *        The node's bounds used as reference.
+   * @param number line
+   *        The line number to check.
+   * @param number column
+   *        The column number to check.
+   * @return boolean
+   *         True if the line and column is contained in the node's bounds.
+   */
+  nodeContainsPoint(node, line, column) {
+    let { start: s, end: e } = this.getNodeLocation(node);
+    return s.line == line && e.line == line &&
+           s.column <= column && e.column >= column;
+  },
+
+  /**
+   * Try to infer a function expression's name & other details based on the
+   * enclosing VariableDeclarator, AssignmentExpression or ObjectExpression.
+   *
+   * @param Node node
+   *        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(node) {
+    let parent = node._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(node);
+      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 "node" represents the "bar" identifier in a hypothetical
+   * "{ foo: bar }" object expression, the returned node is the "foo"
+   * identifier.
+   *
+   * @param Node node
+   *        The value node in an object expression.
+   * @return object
+   *         The key identifier node in the object expression.
+   */
+  _getObjectExpressionPropertyKeyForValue(node) {
+    let parent = node._parent;
+    if (parent.type != "ObjectExpression") {
+      return null;
+    }
+    for (let property of parent.properties) {
+      if (property.value == node) {
+        return property.key;
+      }
+    }
+    return null;
+  },
+
+  /**
+   * 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 node represents the "baz: {}" object expression in a
+   * hypothetical "foo = { bar: { baz: {} } }" assignment expression, the
+   * returned chain is ["foo", "bar", "baz"].
+   *
+   * @param Node node
+   *        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(node, aStore = []) {
+    switch (node.type) {
+      case "ObjectExpression":
+        this._getObjectExpressionPropertyChain(node._parent, aStore);
+        let propertyKey = this._getObjectExpressionPropertyKeyForValue(node);
+        if (propertyKey) {
+          aStore.push(propertyKey.name);
+        }
+        break;
+      // Handle "var foo = { ... }" variable declarators.
+      case "VariableDeclarator":
+        aStore.push(node.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(node.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(node._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 node 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 node
+   *        The member expression node to begin the scan from.
+   * @param array store [optional]
+   *        The chain to store the nodes into.
+   * @return array
+   *         The full member chain, as strings.
+   */
+  _getMemberExpressionPropertyChain(node, store = []) {
+    switch (node.type) {
+      case "MemberExpression":
+        this._getMemberExpressionPropertyChain(node.object, store);
+        this._getMemberExpressionPropertyChain(node.property, store);
+        break;
+      case "ThisExpression":
+        store.push("this");
+        break;
+      case "Identifier":
+        store.push(node.name);
+        break;
+    }
+    return store;
+  },
+
+  /**
+   * Returns an evaluation string which can be used to obtain the
+   * current value for the respective identifier.
+   *
+   * @param Node node
+   *        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(node) {
+    switch (node._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(node)) {
+          let propertyChain =
+            this._getObjectExpressionPropertyChain(node._parent);
+          let propertyLeaf = node.name;
+          return [...propertyChain, propertyLeaf].join(".");
+        }
+        break;
+      case "MemberExpression":
+        // Make sure this is a property identifier, not the parent object.
+        if (node._parent.property == node) {
+          return this._getMemberExpressionPropertyChain(node._parent).join(".");
+        }
+        break;
+    }
+    switch (node.type) {
+      case "ThisExpression":
+        return "this";
+      case "Identifier":
+        return node.name;
+      case "Literal":
+        return uneval(node.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;
+ * }
+ */
+var SyntaxTreeVisitor = {
+  /**
+   * Walks a syntax tree.
+   *
+   * @param object tree
+   *        The AST nodes generated by the reflection API
+   * @param object callbacks
+   *        A map of all the callbacks to invoke when passing through certain
+   *        types of noes (e.g: onFunctionDeclaration, onBlockStatement etc.).
+   */
+  walk(tree, callbacks) {
+    this.break = false;
+    this[tree.type](tree, callbacks);
+  },
+
+  /**
+   * Filters all the nodes in this syntax tree based on a predicate.
+   *
+   * @param object tree
+   *        The AST nodes generated by the reflection API
+   * @param function predicate
+   *        The predicate ran on each node.
+   * @return array
+   *         An array of nodes validating the predicate.
+   */
+  filter(tree, predicate) {
+    let store = [];
+    this.walk(tree, {
+      onNode: e => {
+        if (predicate(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(node, callbacks) {
+    if (callbacks.onProgram) {
+      callbacks.onProgram(node);
+    }
+    for (let statement of node.body) {
+      this[statement.type](statement, node, callbacks);
+    }
+  },
+
+  /**
+   * Any statement.
+   *
+   * interface Statement <: Node { }
+   */
+  Statement(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onStatement) {
+      callbacks.onStatement(node);
+    }
+  },
+
+  /**
+   * An empty statement, i.e., a solitary semicolon.
+   *
+   * interface EmptyStatement <: Statement {
+   *   type: "EmptyStatement";
+   * }
+   */
+  EmptyStatement(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onEmptyStatement) {
+      callbacks.onEmptyStatement(node);
+    }
+  },
+
+  /**
+   * A block statement, i.e., a sequence of statements surrounded by braces.
+   *
+   * interface BlockStatement <: Statement {
+   *   type: "BlockStatement";
+   *   body: [ Statement ];
+   * }
+   */
+  BlockStatement(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onBlockStatement) {
+      callbacks.onBlockStatement(node);
+    }
+    for (let statement of node.body) {
+      this[statement.type](statement, node, callbacks);
+    }
+  },
+
+  /**
+   * An expression statement, i.e., a statement consisting of a single
+   * expression.
+   *
+   * interface ExpressionStatement <: Statement {
+   *   type: "ExpressionStatement";
+   *   expression: Expression;
+   * }
+   */
+  ExpressionStatement(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onExpressionStatement) {
+      callbacks.onExpressionStatement(node);
+    }
+    this[node.expression.type](node.expression, node, callbacks);
+  },
+
+  /**
+   * An if statement.
+   *
+   * interface IfStatement <: Statement {
+   *   type: "IfStatement";
+   *   test: Expression;
+   *   consequent: Statement;
+   *   alternate: Statement | null;
+   * }
+   */
+  IfStatement(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onIfStatement) {
+      callbacks.onIfStatement(node);
+    }
+    this[node.test.type](node.test, node, callbacks);
+    this[node.consequent.type](node.consequent, node, callbacks);
+    if (node.alternate) {
+      this[node.alternate.type](node.alternate, node, callbacks);
+    }
+  },
+
+  /**
+   * A labeled statement, i.e., a statement prefixed by a break/continue label.
+   *
+   * interface LabeledStatement <: Statement {
+   *   type: "LabeledStatement";
+   *   label: Identifier;
+   *   body: Statement;
+   * }
+   */
+  LabeledStatement(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onLabeledStatement) {
+      callbacks.onLabeledStatement(node);
+    }
+    this[node.label.type](node.label, node, callbacks);
+    this[node.body.type](node.body, node, callbacks);
+  },
+
+  /**
+   * A break statement.
+   *
+   * interface BreakStatement <: Statement {
+   *   type: "BreakStatement";
+   *   label: Identifier | null;
+   * }
+   */
+  BreakStatement(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onBreakStatement) {
+      callbacks.onBreakStatement(node);
+    }
+    if (node.label) {
+      this[node.label.type](node.label, node, callbacks);
+    }
+  },
+
+  /**
+   * A continue statement.
+   *
+   * interface ContinueStatement <: Statement {
+   *   type: "ContinueStatement";
+   *   label: Identifier | null;
+   * }
+   */
+  ContinueStatement(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onContinueStatement) {
+      callbacks.onContinueStatement(node);
+    }
+    if (node.label) {
+      this[node.label.type](node.label, node, callbacks);
+    }
+  },
+
+  /**
+   * A with statement.
+   *
+   * interface WithStatement <: Statement {
+   *   type: "WithStatement";
+   *   object: Expression;
+   *   body: Statement;
+   * }
+   */
+  WithStatement(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onWithStatement) {
+      callbacks.onWithStatement(node);
+    }
+    this[node.object.type](node.object, node, callbacks);
+    this[node.body.type](node.body, node, callbacks);
+  },
+
+  /**
+   * 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(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onSwitchStatement) {
+      callbacks.onSwitchStatement(node);
+    }
+    this[node.discriminant.type](node.discriminant, node, callbacks);
+    for (let _case of node.cases) {
+      this[_case.type](_case, node, callbacks);
+    }
+  },
+
+  /**
+   * A return statement.
+   *
+   * interface ReturnStatement <: Statement {
+   *   type: "ReturnStatement";
+   *   argument: Expression | null;
+   * }
+   */
+  ReturnStatement(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onReturnStatement) {
+      callbacks.onReturnStatement(node);
+    }
+    if (node.argument) {
+      this[node.argument.type](node.argument, node, callbacks);
+    }
+  },
+
+  /**
+   * A throw statement.
+   *
+   * interface ThrowStatement <: Statement {
+   *   type: "ThrowStatement";
+   *   argument: Expression;
+   * }
+   */
+  ThrowStatement(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onThrowStatement) {
+      callbacks.onThrowStatement(node);
+    }
+    this[node.argument.type](node.argument, node, callbacks);
+  },
+
+  /**
+   * A try statement.
+   *
+   * interface TryStatement <: Statement {
+   *   type: "TryStatement";
+   *   block: BlockStatement;
+   *   handler: CatchClause | null;
+   *   guardedHandlers: [ CatchClause ];
+   *   finalizer: BlockStatement | null;
+   * }
+   */
+  TryStatement(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onTryStatement) {
+      callbacks.onTryStatement(node);
+    }
+    this[node.block.type](node.block, node, callbacks);
+    if (node.handler) {
+      this[node.handler.type](node.handler, node, callbacks);
+    }
+    for (let guardedHandler of node.guardedHandlers) {
+      this[guardedHandler.type](guardedHandler, node, callbacks);
+    }
+    if (node.finalizer) {
+      this[node.finalizer.type](node.finalizer, node, callbacks);
+    }
+  },
+
+  /**
+   * A while statement.
+   *
+   * interface WhileStatement <: Statement {
+   *   type: "WhileStatement";
+   *   test: Expression;
+   *   body: Statement;
+   * }
+   */
+  WhileStatement(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onWhileStatement) {
+      callbacks.onWhileStatement(node);
+    }
+    this[node.test.type](node.test, node, callbacks);
+    this[node.body.type](node.body, node, callbacks);
+  },
+
+  /**
+   * A do/while statement.
+   *
+   * interface DoWhileStatement <: Statement {
+   *   type: "DoWhileStatement";
+   *   body: Statement;
+   *   test: Expression;
+   * }
+   */
+  DoWhileStatement(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onDoWhileStatement) {
+      callbacks.onDoWhileStatement(node);
+    }
+    this[node.body.type](node.body, node, callbacks);
+    this[node.test.type](node.test, node, callbacks);
+  },
+
+  /**
+   * A for statement.
+   *
+   * interface ForStatement <: Statement {
+   *   type: "ForStatement";
+   *   init: VariableDeclaration | Expression | null;
+   *   test: Expression | null;
+   *   update: Expression | null;
+   *   body: Statement;
+   * }
+   */
+  ForStatement(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onForStatement) {
+      callbacks.onForStatement(node);
+    }
+    if (node.init) {
+      this[node.init.type](node.init, node, callbacks);
+    }
+    if (node.test) {
+      this[node.test.type](node.test, node, callbacks);
+    }
+    if (node.update) {
+      this[node.update.type](node.update, node, callbacks);
+    }
+    this[node.body.type](node.body, node, callbacks);
+  },
+
+  /**
+   * 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(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onForInStatement) {
+      callbacks.onForInStatement(node);
+    }
+    this[node.left.type](node.left, node, callbacks);
+    this[node.right.type](node.right, node, callbacks);
+    this[node.body.type](node.body, node, callbacks);
+  },
+
+  /**
+   * A for/of statement.
+   *
+   * interface ForOfStatement <: Statement {
+   *   type: "ForOfStatement";
+   *   left: VariableDeclaration | Expression;
+   *   right: Expression;
+   *   body: Statement;
+   * }
+   */
+  ForOfStatement(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onForOfStatement) {
+      callbacks.onForOfStatement(node);
+    }
+    this[node.left.type](node.left, node, callbacks);
+    this[node.right.type](node.right, node, callbacks);
+    this[node.body.type](node.body, node, callbacks);
+  },
+
+  /**
+   * A let statement.
+   *
+   * interface LetStatement <: Statement {
+   *   type: "LetStatement";
+   *   head: [ { id: Pattern, init: Expression | null } ];
+   *   body: Statement;
+   * }
+   */
+  LetStatement(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onLetStatement) {
+      callbacks.onLetStatement(node);
+    }
+    for (let { id, init } of node.head) {
+      this[id.type](id, node, callbacks);
+      if (init) {
+        this[init.type](init, node, callbacks);
+      }
+    }
+    this[node.body.type](node.body, node, callbacks);
+  },
+
+  /**
+   * A debugger statement.
+   *
+   * interface DebuggerStatement <: Statement {
+   *   type: "DebuggerStatement";
+   * }
+   */
+  DebuggerStatement(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onDebuggerStatement) {
+      callbacks.onDebuggerStatement(node);
+    }
+  },
+
+  /**
+   * 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(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onDeclaration) {
+      callbacks.onDeclaration(node);
+    }
+  },
+
+  /**
+   * 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(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onFunctionDeclaration) {
+      callbacks.onFunctionDeclaration(node);
+    }
+    this[node.id.type](node.id, node, callbacks);
+    for (let param of node.params) {
+      this[param.type](param, node, callbacks);
+    }
+    for (let _default of node.defaults) {
+      if (_default) {
+        this[_default.type](_default, node, callbacks);
+      }
+    }
+    if (node.rest) {
+      this[node.rest.type](node.rest, node, callbacks);
+    }
+    this[node.body.type](node.body, node, callbacks);
+  },
+
+  /**
+   * A variable declaration, via one of var, let, or const.
+   *
+   * interface VariableDeclaration <: Declaration {
+   *   type: "VariableDeclaration";
+   *   declarations: [ VariableDeclarator ];
+   *   kind: "var" | "let" | "const";
+   * }
+   */
+  VariableDeclaration(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onVariableDeclaration) {
+      callbacks.onVariableDeclaration(node);
+    }
+    for (let declaration of node.declarations) {
+      this[declaration.type](declaration, node, callbacks);
+    }
+  },
+
+  /**
+   * A variable declarator.
+   *
+   * interface VariableDeclarator <: Node {
+   *   type: "VariableDeclarator";
+   *   id: Pattern;
+   *   init: Expression | null;
+   * }
+   */
+  VariableDeclarator(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onVariableDeclarator) {
+      callbacks.onVariableDeclarator(node);
+    }
+    this[node.id.type](node.id, node, callbacks);
+    if (node.init) {
+      this[node.init.type](node.init, node, callbacks);
+    }
+  },
+
+  /**
+   * 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(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onExpression) {
+      callbacks.onExpression(node);
+    }
+  },
+
+  /**
+   * A this expression.
+   *
+   * interface ThisExpression <: Expression {
+   *   type: "ThisExpression";
+   * }
+   */
+  ThisExpression(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onThisExpression) {
+      callbacks.onThisExpression(node);
+    }
+  },
+
+  /**
+   * An array expression.
+   *
+   * interface ArrayExpression <: Expression {
+   *   type: "ArrayExpression";
+   *   elements: [ Expression | null ];
+   * }
+   */
+  ArrayExpression(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onArrayExpression) {
+      callbacks.onArrayExpression(node);
+    }
+    for (let element of node.elements) {
+      if (element) {
+        this[element.type](element, node, callbacks);
+      }
+    }
+  },
+
+  /**
+   * A spread expression.
+   *
+   * interface SpreadExpression <: Expression {
+   *   type: "SpreadExpression";
+   *   expression: Expression;
+   * }
+   */
+  SpreadExpression(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onSpreadExpression) {
+      callbacks.onSpreadExpression(node);
+    }
+    this[node.expression.type](node.expression, node, callbacks);
+  },
+
+  /**
+   * 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 | ComputedName,
+   *                   value: Expression,
+   *                   kind: "init" | "get" | "set" } ];
+   * }
+   */
+  ObjectExpression(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onObjectExpression) {
+      callbacks.onObjectExpression(node);
+    }
+    for (let { key, value } of node.properties) {
+      this[key.type](key, node, callbacks);
+      this[value.type](value, node, callbacks);
+    }
+  },
+
+  /**
+   * A computed property name in object expression, like in { [a]: b }
+   *
+   * interface ComputedName <: Node {
+   *   type: "ComputedName";
+   *   name: Expression;
+   * }
+   */
+  ComputedName(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onComputedName) {
+      callbacks.onComputedName(node);
+    }
+    this[node.name.type](node.name, node, callbacks);
+  },
+
+  /**
+   * 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(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onFunctionExpression) {
+      callbacks.onFunctionExpression(node);
+    }
+    if (node.id) {
+      this[node.id.type](node.id, node, callbacks);
+    }
+    for (let param of node.params) {
+      this[param.type](param, node, callbacks);
+    }
+    for (let _default of node.defaults) {
+      if (_default) {
+        this[_default.type](_default, node, callbacks);
+      }
+    }
+    if (node.rest) {
+      this[node.rest.type](node.rest, node, callbacks);
+    }
+    this[node.body.type](node.body, node, callbacks);
+  },
+
+  /**
+   * An arrow expression.
+   *
+   * interface ArrowFunctionExpression <: Function, Expression {
+   *   type: "ArrowFunctionExpression";
+   *   params: [ Pattern ];
+   *   defaults: [ Expression ];
+   *   rest: Identifier | null;
+   *   body: BlockStatement | Expression;
+   *   generator: boolean;
+   *   expression: boolean;
+   * }
+   */
+  ArrowFunctionExpression(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onArrowFunctionExpression) {
+      callbacks.onArrowFunctionExpression(node);
+    }
+    for (let param of node.params) {
+      this[param.type](param, node, callbacks);
+    }
+    for (let _default of node.defaults) {
+      if (_default) {
+        this[_default.type](_default, node, callbacks);
+      }
+    }
+    if (node.rest) {
+      this[node.rest.type](node.rest, node, callbacks);
+    }
+    this[node.body.type](node.body, node, callbacks);
+  },
+
+  /**
+   * A sequence expression, i.e., a comma-separated sequence of expressions.
+   *
+   * interface SequenceExpression <: Expression {
+   *   type: "SequenceExpression";
+   *   expressions: [ Expression ];
+   * }
+   */
+  SequenceExpression(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onSequenceExpression) {
+      callbacks.onSequenceExpression(node);
+    }
+    for (let expression of node.expressions) {
+      this[expression.type](expression, node, callbacks);
+    }
+  },
+
+  /**
+   * A unary operator expression.
+   *
+   * interface UnaryExpression <: Expression {
+   *   type: "UnaryExpression";
+   *   operator: UnaryOperator;
+   *   prefix: boolean;
+   *   argument: Expression;
+   * }
+   */
+  UnaryExpression(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onUnaryExpression) {
+      callbacks.onUnaryExpression(node);
+    }
+    this[node.argument.type](node.argument, node, callbacks);
+  },
+
+  /**
+   * A binary operator expression.
+   *
+   * interface BinaryExpression <: Expression {
+   *   type: "BinaryExpression";
+   *   operator: BinaryOperator;
+   *   left: Expression;
+   *   right: Expression;
+   * }
+   */
+  BinaryExpression(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onBinaryExpression) {
+      callbacks.onBinaryExpression(node);
+    }
+    this[node.left.type](node.left, node, callbacks);
+    this[node.right.type](node.right, node, callbacks);
+  },
+
+  /**
+   * An assignment operator expression.
+   *
+   * interface AssignmentExpression <: Expression {
+   *   type: "AssignmentExpression";
+   *   operator: AssignmentOperator;
+   *   left: Expression;
+   *   right: Expression;
+   * }
+   */
+  AssignmentExpression(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onAssignmentExpression) {
+      callbacks.onAssignmentExpression(node);
+    }
+    this[node.left.type](node.left, node, callbacks);
+    this[node.right.type](node.right, node, callbacks);
+  },
+
+  /**
+   * An update (increment or decrement) operator expression.
+   *
+   * interface UpdateExpression <: Expression {
+   *   type: "UpdateExpression";
+   *   operator: UpdateOperator;
+   *   argument: Expression;
+   *   prefix: boolean;
+   * }
+   */
+  UpdateExpression(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onUpdateExpression) {
+      callbacks.onUpdateExpression(node);
+    }
+    this[node.argument.type](node.argument, node, callbacks);
+  },
+
+  /**
+   * A logical operator expression.
+   *
+   * interface LogicalExpression <: Expression {
+   *   type: "LogicalExpression";
+   *   operator: LogicalOperator;
+   *   left: Expression;
+   *   right: Expression;
+   * }
+   */
+  LogicalExpression(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onLogicalExpression) {
+      callbacks.onLogicalExpression(node);
+    }
+    this[node.left.type](node.left, node, callbacks);
+    this[node.right.type](node.right, node, callbacks);
+  },
+
+  /**
+   * A conditional expression, i.e., a ternary ?/: expression.
+   *
+   * interface ConditionalExpression <: Expression {
+   *   type: "ConditionalExpression";
+   *   test: Expression;
+   *   alternate: Expression;
+   *   consequent: Expression;
+   * }
+   */
+  ConditionalExpression(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onConditionalExpression) {
+      callbacks.onConditionalExpression(node);
+    }
+    this[node.test.type](node.test, node, callbacks);
+    this[node.alternate.type](node.alternate, node, callbacks);
+    this[node.consequent.type](node.consequent, node, callbacks);
+  },
+
+  /**
+   * A new expression.
+   *
+   * interface NewExpression <: Expression {
+   *   type: "NewExpression";
+   *   callee: Expression;
+   *   arguments: [ Expression | null ];
+   * }
+   */
+  NewExpression(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onNewExpression) {
+      callbacks.onNewExpression(node);
+    }
+    this[node.callee.type](node.callee, node, callbacks);
+    for (let argument of node.arguments) {
+      if (argument) {
+        this[argument.type](argument, node, callbacks);
+      }
+    }
+  },
+
+  /**
+   * A function or method call expression.
+   *
+   * interface CallExpression <: Expression {
+   *   type: "CallExpression";
+   *   callee: Expression;
+   *   arguments: [ Expression | null ];
+   * }
+   */
+  CallExpression(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onCallExpression) {
+      callbacks.onCallExpression(node);
+    }
+    this[node.callee.type](node.callee, node, callbacks);
+    for (let argument of node.arguments) {
+      if (argument) {
+        if (!this[argument.type]) {
+          console.error("Unknown parser object:", argument.type);
+        }
+        this[argument.type](argument, node, callbacks);
+      }
+    }
+  },
+
+  /**
+   * 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(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onMemberExpression) {
+      callbacks.onMemberExpression(node);
+    }
+    this[node.object.type](node.object, node, callbacks);
+    this[node.property.type](node.property, node, callbacks);
+  },
+
+  /**
+   * A yield expression.
+   *
+   * interface YieldExpression <: Expression {
+   *   argument: Expression | null;
+   * }
+   */
+  YieldExpression(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onYieldExpression) {
+      callbacks.onYieldExpression(node);
+    }
+    if (node.argument) {
+      this[node.argument.type](node.argument, node, callbacks);
+    }
+  },
+
+  /**
+   * 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(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onComprehensionExpression) {
+      callbacks.onComprehensionExpression(node);
+    }
+    this[node.body.type](node.body, node, callbacks);
+    for (let block of node.blocks) {
+      this[block.type](block, node, callbacks);
+    }
+    if (node.filter) {
+      this[node.filter.type](node.filter, node, callbacks);
+    }
+  },
+
+  /**
+   * 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(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onGeneratorExpression) {
+      callbacks.onGeneratorExpression(node);
+    }
+    this[node.body.type](node.body, node, callbacks);
+    for (let block of node.blocks) {
+      this[block.type](block, node, callbacks);
+    }
+    if (node.filter) {
+      this[node.filter.type](node.filter, node, callbacks);
+    }
+  },
+
+  /**
+   * A graph expression, aka "sharp literal," such as #1={ self: #1# }.
+   *
+   * interface GraphExpression <: Expression {
+   *   index: uint32;
+   *   expression: Literal;
+   * }
+   */
+  GraphExpression(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onGraphExpression) {
+      callbacks.onGraphExpression(node);
+    }
+    this[node.expression.type](node.expression, node, callbacks);
+  },
+
+  /**
+   * A graph index expression, aka "sharp variable," such as #1#.
+   *
+   * interface GraphIndexExpression <: Expression {
+   *   index: uint32;
+   * }
+   */
+  GraphIndexExpression(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onGraphIndexExpression) {
+      callbacks.onGraphIndexExpression(node);
+    }
+  },
+
+  /**
+   * A let expression.
+   *
+   * interface LetExpression <: Expression {
+   *   type: "LetExpression";
+   *   head: [ { id: Pattern, init: Expression | null } ];
+   *   body: Expression;
+   * }
+   */
+  LetExpression(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onLetExpression) {
+      callbacks.onLetExpression(node);
+    }
+    for (let { id, init } of node.head) {
+      this[id.type](id, node, callbacks);
+      if (init) {
+        this[init.type](init, node, callbacks);
+      }
+    }
+    this[node.body.type](node.body, node, callbacks);
+  },
+
+  /**
+   * Any pattern.
+   *
+   * interface Pattern <: Node { }
+   */
+  Pattern(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onPattern) {
+      callbacks.onPattern(node);
+    }
+  },
+
+  /**
+   * 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(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onObjectPattern) {
+      callbacks.onObjectPattern(node);
+    }
+    for (let { key, value } of node.properties) {
+      this[key.type](key, node, callbacks);
+      this[value.type](value, node, callbacks);
+    }
+  },
+
+  /**
+   * An array-destructuring pattern.
+   *
+   * interface ArrayPattern <: Pattern {
+   *   type: "ArrayPattern";
+   *   elements: [ Pattern | null ];
+   * }
+   */
+  ArrayPattern(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onArrayPattern) {
+      callbacks.onArrayPattern(node);
+    }
+    for (let element of node.elements) {
+      if (element) {
+        this[element.type](element, node, callbacks);
+      }
+    }
+  },
+
+  /**
+   * 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(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onSwitchCase) {
+      callbacks.onSwitchCase(node);
+    }
+    if (node.test) {
+      this[node.test.type](node.test, node, callbacks);
+    }
+    for (let consequent of node.consequent) {
+      this[consequent.type](consequent, node, callbacks);
+    }
+  },
+
+  /**
+   * 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(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onCatchClause) {
+      callbacks.onCatchClause(node);
+    }
+    this[node.param.type](node.param, node, callbacks);
+    if (node.guard) {
+      this[node.guard.type](node.guard, node, callbacks);
+    }
+    this[node.body.type](node.body, node, callbacks);
+  },
+
+  /**
+   * A for or for each block in an array comprehension or generator expression.
+   *
+   * interface ComprehensionBlock <: Node {
+   *   left: Pattern;
+   *   right: Expression;
+   *   each: boolean;
+   * }
+   */
+  ComprehensionBlock(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onComprehensionBlock) {
+      callbacks.onComprehensionBlock(node);
+    }
+    this[node.left.type](node.left, node, callbacks);
+    this[node.right.type](node.right, node, callbacks);
+  },
+
+  /**
+   * An identifier. Note that an identifier may be an expression or a
+   * destructuring pattern.
+   *
+   * interface Identifier <: Node, Expression, Pattern {
+   *   type: "Identifier";
+   *   name: string;
+   * }
+   */
+  Identifier(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onIdentifier) {
+      callbacks.onIdentifier(node);
+    }
+  },
+
+  /**
+   * A literal token. Note that a literal can be an expression.
+   *
+   * interface Literal <: Node, Expression {
+   *   type: "Literal";
+   *   value: string | boolean | null | number | RegExp;
+   * }
+   */
+  Literal(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onLiteral) {
+      callbacks.onLiteral(node);
+    }
+  },
+
+  /**
+   * A template string literal.
+   *
+   * interface TemplateLiteral <: Node {
+   *   type: "TemplateLiteral";
+   *   elements: [ Expression ];
+   * }
+   */
+  TemplateLiteral(node, parent, callbacks) {
+    node._parent = parent;
+
+    if (this.break) {
+      return;
+    }
+    if (callbacks.onNode) {
+      if (callbacks.onNode(node, parent) === false) {
+        return;
+      }
+    }
+    if (callbacks.onTemplateLiteral) {
+      callbacks.onTemplateLiteral(node);
+    }
+    for (let element of node.elements) {
+      if (element) {
+        this[element.type](element, node, callbacks);
+      }
+    }
+  }
+};
+
+XPCOMUtils.defineLazyGetter(Parser, "reflectionAPI", () => Reflect);