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