| /** |
| * @fileoverview Main Espree file that converts Acorn into Esprima output. |
| * |
| * This file contains code from the following MIT-licensed projects: |
| * 1. Acorn |
| * 2. Babylon |
| * 3. Babel-ESLint |
| * |
| * This file also contains code from Esprima, which is BSD licensed. |
| * |
| * Acorn is Copyright 2012-2015 Acorn Contributors (https://github.com/marijnh/acorn/blob/master/AUTHORS) |
| * Babylon is Copyright 2014-2015 various contributors (https://github.com/babel/babel/blob/master/packages/babylon/AUTHORS) |
| * Babel-ESLint is Copyright 2014-2015 Sebastian McKenzie <sebmck@gmail.com> |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are met: |
| * |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
| * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| * ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY |
| * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
| * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
| * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| * |
| * Esprima is Copyright (c) jQuery Foundation, Inc. and Contributors, All Rights Reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are met: |
| * |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
| * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| * ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY |
| * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
| * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
| * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| /* eslint no-undefined:0, no-use-before-define: 0 */ |
| |
| "use strict"; |
| |
| var astNodeTypes = require("./lib/ast-node-types"), |
| commentAttachment = require("./lib/comment-attachment"), |
| TokenTranslator = require("./lib/token-translator"), |
| acornJSX = require("acorn-jsx/inject"), |
| rawAcorn = require("acorn"); |
| |
| |
| var acorn = acornJSX(rawAcorn); |
| var DEFAULT_ECMA_VERSION = 5; |
| var lookahead, |
| extra, |
| lastToken; |
| |
| /** |
| * Object.assign polyfill for Node < 4 |
| * @param {Object} target The target object |
| * @param {...Object} sources Sources for the object |
| * @returns {Object} `target` after being mutated |
| */ |
| var assign = Object.assign || function assign(target) { |
| for (var argIndex = 1; argIndex < arguments.length; argIndex++) { |
| if (arguments[argIndex] !== null && typeof arguments[argIndex] === "object") { |
| var keys = Object.keys(arguments[argIndex]); |
| |
| for (var keyIndex = 0; keyIndex < keys.length; keyIndex++) { |
| target[keys[keyIndex]] = arguments[argIndex][keys[keyIndex]]; |
| } |
| } |
| } |
| |
| return target; |
| }; |
| |
| /** |
| * Resets the extra object to its default. |
| * @returns {void} |
| * @private |
| */ |
| function resetExtra() { |
| extra = { |
| tokens: null, |
| range: false, |
| loc: false, |
| comment: false, |
| comments: [], |
| tolerant: false, |
| errors: [], |
| strict: false, |
| ecmaFeatures: {}, |
| ecmaVersion: DEFAULT_ECMA_VERSION, |
| isModule: false |
| }; |
| } |
| |
| |
| |
| var tt = acorn.tokTypes, |
| getLineInfo = acorn.getLineInfo; |
| |
| // custom type for JSX attribute values |
| tt.jsxAttrValueToken = {}; |
| |
| /** |
| * Normalize ECMAScript version from the initial config |
| * @param {number} ecmaVersion ECMAScript version from the initial config |
| * @returns {number} normalized ECMAScript version |
| */ |
| function normalizeEcmaVersion(ecmaVersion) { |
| if (typeof ecmaVersion === "number") { |
| var version = ecmaVersion; |
| |
| // Calculate ECMAScript edition number from official year version starting with |
| // ES2015, which corresponds with ES6 (or a difference of 2009). |
| if (version >= 2015) { |
| version -= 2009; |
| } |
| |
| switch (version) { |
| case 3: |
| case 5: |
| case 6: |
| case 7: |
| case 8: |
| case 9: |
| return version; |
| |
| default: |
| throw new Error("Invalid ecmaVersion."); |
| } |
| } else { |
| return DEFAULT_ECMA_VERSION; |
| } |
| } |
| |
| /** |
| * Determines if a node is valid given the set of ecmaFeatures. |
| * @param {ASTNode} node The node to check. |
| * @returns {boolean} True if the node is allowed, false if not. |
| * @private |
| */ |
| function isValidNode(node) { |
| var ecma = extra.ecmaFeatures; |
| |
| switch (node.type) { |
| case "ExperimentalSpreadProperty": |
| case "ExperimentalRestProperty": |
| return ecma.experimentalObjectRestSpread; |
| |
| case "ImportDeclaration": |
| case "ExportNamedDeclaration": |
| case "ExportDefaultDeclaration": |
| case "ExportAllDeclaration": |
| return extra.isModule; |
| |
| default: |
| return true; |
| } |
| } |
| |
| /** |
| * Performs last-minute Esprima-specific compatibility checks and fixes. |
| * @param {ASTNode} result The node to check. |
| * @returns {ASTNode} The finished node. |
| * @private |
| * @this acorn.Parser |
| */ |
| function esprimaFinishNode(result) { |
| // ensure that parsed node was allowed through ecmaFeatures |
| if (!isValidNode(result)) { |
| this.unexpected(result.start); |
| } |
| |
| // https://github.com/marijnh/acorn/issues/323 |
| if (result.type === "TryStatement") { |
| delete result.guardedHandlers; |
| } else if (result.type === "CatchClause") { |
| delete result.guard; |
| } |
| |
| // Acorn doesn't count the opening and closing backticks as part of templates |
| // so we have to adjust ranges/locations appropriately. |
| if (result.type === "TemplateElement") { |
| |
| // additional adjustment needed if ${ is the last token |
| var terminalDollarBraceL = this.input.slice(result.end, result.end + 2) === "${"; |
| |
| if (result.range) { |
| result.range[0]--; |
| result.range[1] += (terminalDollarBraceL ? 2 : 1); |
| } |
| |
| if (result.loc) { |
| result.loc.start.column--; |
| result.loc.end.column += (terminalDollarBraceL ? 2 : 1); |
| } |
| } |
| |
| // Acorn uses undefined instead of null, which affects serialization |
| if (result.type === "Literal" && result.value === undefined) { |
| result.value = null; |
| } |
| |
| if (extra.attachComment) { |
| commentAttachment.processComment(result); |
| } |
| |
| if (result.type.indexOf("Function") > -1 && !result.generator) { |
| result.generator = false; |
| } |
| |
| return result; |
| } |
| |
| /** |
| * Determines if a token is valid given the set of ecmaFeatures. |
| * @param {acorn.Parser} parser The parser to check. |
| * @returns {boolean} True if the token is allowed, false if not. |
| * @private |
| */ |
| function isValidToken(parser) { |
| var ecma = extra.ecmaFeatures; |
| var type = parser.type; |
| |
| switch (type) { |
| case tt.jsxName: |
| case tt.jsxText: |
| case tt.jsxTagStart: |
| case tt.jsxTagEnd: |
| return ecma.jsx; |
| |
| // https://github.com/ternjs/acorn/issues/363 |
| case tt.regexp: |
| if (extra.ecmaVersion < 6 && parser.value.flags && parser.value.flags.indexOf("y") > -1) { |
| return false; |
| } |
| |
| return true; |
| |
| default: |
| return true; |
| } |
| } |
| |
| /** |
| * Injects esprimaFinishNode into the finishNode process. |
| * @param {Function} finishNode Original finishNode function. |
| * @returns {ASTNode} The finished node. |
| * @private |
| */ |
| function wrapFinishNode(finishNode) { |
| return /** @this acorn.Parser */ function(node, type, pos, loc) { |
| var result = finishNode.call(this, node, type, pos, loc); |
| return esprimaFinishNode.call(this, result); |
| }; |
| } |
| |
| acorn.plugins.espree = function(instance) { |
| |
| instance.extend("finishNode", wrapFinishNode); |
| |
| instance.extend("finishNodeAt", wrapFinishNode); |
| |
| instance.extend("next", function(next) { |
| return /** @this acorn.Parser */ function() { |
| if (!isValidToken(this)) { |
| this.unexpected(); |
| } |
| return next.call(this); |
| }; |
| }); |
| |
| // needed for experimental object rest/spread |
| instance.extend("checkLVal", function(checkLVal) { |
| |
| return /** @this acorn.Parser */ function(expr, isBinding, checkClashes) { |
| |
| if (extra.ecmaFeatures.experimentalObjectRestSpread && expr.type === "ObjectPattern") { |
| for (var i = 0; i < expr.properties.length; i++) { |
| if (expr.properties[i].type.indexOf("Experimental") === -1) { |
| this.checkLVal(expr.properties[i].value, isBinding, checkClashes); |
| } |
| } |
| return undefined; |
| } |
| |
| return checkLVal.call(this, expr, isBinding, checkClashes); |
| }; |
| }); |
| |
| instance.extend("parseTopLevel", function(parseTopLevel) { |
| return /** @this acorn.Parser */ function(node) { |
| if (extra.ecmaFeatures.impliedStrict && this.options.ecmaVersion >= 5) { |
| this.strict = true; |
| } |
| return parseTopLevel.call(this, node); |
| }; |
| }); |
| |
| instance.extend("toAssignable", function(toAssignable) { |
| |
| return /** @this acorn.Parser */ function(node, isBinding, refDestructuringErrors) { |
| |
| if (extra.ecmaFeatures.experimentalObjectRestSpread && |
| node.type === "ObjectExpression" |
| ) { |
| node.type = "ObjectPattern"; |
| |
| for (var i = 0; i < node.properties.length; i++) { |
| var prop = node.properties[i]; |
| |
| if (prop.type === "ExperimentalSpreadProperty") { |
| prop.type = "ExperimentalRestProperty"; |
| } else if (prop.kind !== "init") { |
| this.raise(prop.key.start, "Object pattern can't contain getter or setter"); |
| } else { |
| this.toAssignable(prop.value, isBinding); |
| } |
| } |
| |
| return node; |
| } else { |
| return toAssignable.call(this, node, isBinding, refDestructuringErrors); |
| } |
| }; |
| |
| }); |
| |
| /** |
| * Method to parse an object rest or object spread. |
| * @returns {ASTNode} The node representing object rest or object spread. |
| * @this acorn.Parser |
| */ |
| instance.parseObjectRest = function() { |
| var node = this.startNode(); |
| this.next(); |
| node.argument = this.parseIdent(); |
| |
| if (this.type === tt.comma) { |
| this.raise(this.start, "Unexpected trailing comma after rest property"); |
| } |
| |
| return this.finishNode(node, "ExperimentalRestProperty"); |
| }; |
| |
| instance.extend("parseProperty", function(parseProperty) { |
| /** |
| * Override `parseProperty` method to parse rest/spread properties. |
| * @param {boolean} isPattern True if the object is a destructuring pattern. |
| * @param {Object} refDestructuringErrors ? |
| * @returns {ASTNode} The node representing a rest/spread property. |
| * @this acorn.Parser |
| */ |
| return function(isPattern, refDestructuringErrors) { |
| if (extra.ecmaFeatures.experimentalObjectRestSpread && this.type === tt.ellipsis) { |
| var prop; |
| |
| if (isPattern) { |
| prop = this.parseObjectRest(); |
| } else { |
| prop = this.parseSpread(); |
| prop.type = "ExperimentalSpreadProperty"; |
| } |
| |
| return prop; |
| } |
| |
| return parseProperty.call(this, isPattern, refDestructuringErrors); |
| }; |
| }); |
| |
| instance.extend("checkPropClash", function(checkPropClash) { |
| /** |
| * Override `checkPropClash` method to avoid clash on rest/spread properties. |
| * @param {ASTNode} prop A property node to check. |
| * @param {Object} propHash Names map. |
| * @param {Object} refDestructuringErrors Destructuring error information. |
| * @returns {void} |
| * @this acorn.Parser |
| */ |
| return function(prop, propHash, refDestructuringErrors) { |
| if (prop.type === "ExperimentalRestProperty" || prop.type === "ExperimentalSpreadProperty") { |
| return; |
| } |
| checkPropClash.call(this, prop, propHash, refDestructuringErrors); |
| }; |
| }); |
| |
| /** |
| * Overwrites the default raise method to throw Esprima-style errors. |
| * @param {int} pos The position of the error. |
| * @param {string} message The error message. |
| * @throws {SyntaxError} A syntax error. |
| * @returns {void} |
| */ |
| instance.raise = instance.raiseRecoverable = function(pos, message) { |
| var loc = getLineInfo(this.input, pos); |
| var err = new SyntaxError(message); |
| err.index = pos; |
| err.lineNumber = loc.line; |
| err.column = loc.column + 1; // acorn uses 0-based columns |
| throw err; |
| }; |
| |
| /** |
| * Overwrites the default unexpected method to throw Esprima-style errors. |
| * @param {int} pos The position of the error. |
| * @throws {SyntaxError} A syntax error. |
| * @returns {void} |
| */ |
| instance.unexpected = function(pos) { |
| var message = "Unexpected token"; |
| |
| if (pos !== null && pos !== undefined) { |
| this.pos = pos; |
| |
| if (this.options.locations) { |
| while (this.pos < this.lineStart) { |
| this.lineStart = this.input.lastIndexOf("\n", this.lineStart - 2) + 1; |
| --this.curLine; |
| } |
| } |
| |
| this.nextToken(); |
| } |
| |
| if (this.end > this.start) { |
| message += " " + this.input.slice(this.start, this.end); |
| } |
| |
| this.raise(this.start, message); |
| }; |
| |
| /* |
| * Esprima-FB represents JSX strings as tokens called "JSXText", but Acorn-JSX |
| * uses regular tt.string without any distinction between this and regular JS |
| * strings. As such, we intercept an attempt to read a JSX string and set a flag |
| * on extra so that when tokens are converted, the next token will be switched |
| * to JSXText via onToken. |
| */ |
| instance.extend("jsx_readString", function(jsxReadString) { |
| return /** @this acorn.Parser */ function(quote) { |
| var result = jsxReadString.call(this, quote); |
| if (this.type === tt.string) { |
| extra.jsxAttrValueToken = true; |
| } |
| |
| return result; |
| }; |
| }); |
| }; |
| |
| //------------------------------------------------------------------------------ |
| // Tokenizer |
| //------------------------------------------------------------------------------ |
| |
| /** |
| * Tokenizes the given code. |
| * @param {string} code The code to tokenize. |
| * @param {Object} options Options defining how to tokenize. |
| * @returns {Token[]} An array of tokens. |
| * @throws {SyntaxError} If the input code is invalid. |
| * @private |
| */ |
| function tokenize(code, options) { |
| var toString, |
| tokens, |
| impliedStrict, |
| translator = new TokenTranslator(tt, code); |
| |
| toString = String; |
| if (typeof code !== "string" && !(code instanceof String)) { |
| code = toString(code); |
| } |
| |
| lookahead = null; |
| |
| // Options matching. |
| options = assign({}, options); |
| |
| var acornOptions = { |
| ecmaVersion: DEFAULT_ECMA_VERSION, |
| plugins: { |
| espree: true |
| } |
| }; |
| |
| resetExtra(); |
| |
| // Of course we collect tokens here. |
| options.tokens = true; |
| extra.tokens = []; |
| |
| extra.range = (typeof options.range === "boolean") && options.range; |
| acornOptions.ranges = extra.range; |
| |
| extra.loc = (typeof options.loc === "boolean") && options.loc; |
| acornOptions.locations = extra.loc; |
| |
| extra.comment = typeof options.comment === "boolean" && options.comment; |
| |
| if (extra.comment) { |
| acornOptions.onComment = function() { |
| var comment = convertAcornCommentToEsprimaComment.apply(this, arguments); |
| extra.comments.push(comment); |
| }; |
| } |
| |
| extra.tolerant = typeof options.tolerant === "boolean" && options.tolerant; |
| |
| acornOptions.ecmaVersion = extra.ecmaVersion = normalizeEcmaVersion(options.ecmaVersion); |
| |
| // apply parsing flags |
| if (options.ecmaFeatures && typeof options.ecmaFeatures === "object") { |
| extra.ecmaFeatures = assign({}, options.ecmaFeatures); |
| impliedStrict = extra.ecmaFeatures.impliedStrict; |
| extra.ecmaFeatures.impliedStrict = typeof impliedStrict === "boolean" && impliedStrict; |
| } |
| |
| try { |
| var tokenizer = acorn.tokenizer(code, acornOptions); |
| while ((lookahead = tokenizer.getToken()).type !== tt.eof) { |
| translator.onToken(lookahead, extra); |
| } |
| |
| // filterTokenLocation(); |
| tokens = extra.tokens; |
| |
| if (extra.comment) { |
| tokens.comments = extra.comments; |
| } |
| if (extra.tolerant) { |
| tokens.errors = extra.errors; |
| } |
| } catch (e) { |
| throw e; |
| } |
| return tokens; |
| } |
| |
| //------------------------------------------------------------------------------ |
| // Parser |
| //------------------------------------------------------------------------------ |
| |
| |
| |
| /** |
| * Converts an Acorn comment to a Esprima comment. |
| * @param {boolean} block True if it's a block comment, false if not. |
| * @param {string} text The text of the comment. |
| * @param {int} start The index at which the comment starts. |
| * @param {int} end The index at which the comment ends. |
| * @param {Location} startLoc The location at which the comment starts. |
| * @param {Location} endLoc The location at which the comment ends. |
| * @returns {Object} The comment object. |
| * @private |
| */ |
| function convertAcornCommentToEsprimaComment(block, text, start, end, startLoc, endLoc) { |
| var comment = { |
| type: block ? "Block" : "Line", |
| value: text |
| }; |
| |
| if (typeof start === "number") { |
| comment.start = start; |
| comment.end = end; |
| comment.range = [start, end]; |
| } |
| |
| if (typeof startLoc === "object") { |
| comment.loc = { |
| start: startLoc, |
| end: endLoc |
| }; |
| } |
| |
| return comment; |
| } |
| |
| /** |
| * Parses the given code. |
| * @param {string} code The code to tokenize. |
| * @param {Object} options Options defining how to tokenize. |
| * @returns {ASTNode} The "Program" AST node. |
| * @throws {SyntaxError} If the input code is invalid. |
| * @private |
| */ |
| function parse(code, options) { |
| var program, |
| toString = String, |
| translator, |
| impliedStrict, |
| acornOptions = { |
| ecmaVersion: DEFAULT_ECMA_VERSION, |
| plugins: { |
| espree: true |
| } |
| }; |
| |
| lastToken = null; |
| |
| if (typeof code !== "string" && !(code instanceof String)) { |
| code = toString(code); |
| } |
| |
| resetExtra(); |
| commentAttachment.reset(); |
| |
| if (typeof options !== "undefined") { |
| extra.range = (typeof options.range === "boolean") && options.range; |
| extra.loc = (typeof options.loc === "boolean") && options.loc; |
| extra.attachComment = (typeof options.attachComment === "boolean") && options.attachComment; |
| |
| if (extra.loc && options.source !== null && options.source !== undefined) { |
| extra.source = toString(options.source); |
| } |
| |
| if (typeof options.tokens === "boolean" && options.tokens) { |
| extra.tokens = []; |
| translator = new TokenTranslator(tt, code); |
| } |
| if (typeof options.comment === "boolean" && options.comment) { |
| extra.comment = true; |
| extra.comments = []; |
| } |
| if (typeof options.tolerant === "boolean" && options.tolerant) { |
| extra.errors = []; |
| } |
| if (extra.attachComment) { |
| extra.range = true; |
| extra.comments = []; |
| commentAttachment.reset(); |
| } |
| |
| acornOptions.ecmaVersion = extra.ecmaVersion = normalizeEcmaVersion(options.ecmaVersion); |
| |
| if (options.sourceType === "module") { |
| extra.isModule = true; |
| |
| // modules must be in 6 at least |
| if (acornOptions.ecmaVersion < 6) { |
| acornOptions.ecmaVersion = 6; |
| extra.ecmaVersion = 6; |
| } |
| |
| acornOptions.sourceType = "module"; |
| } |
| |
| // apply parsing flags after sourceType to allow overriding |
| if (options.ecmaFeatures && typeof options.ecmaFeatures === "object") { |
| extra.ecmaFeatures = assign({}, options.ecmaFeatures); |
| impliedStrict = extra.ecmaFeatures.impliedStrict; |
| extra.ecmaFeatures.impliedStrict = typeof impliedStrict === "boolean" && impliedStrict; |
| if (options.ecmaFeatures.globalReturn) { |
| acornOptions.allowReturnOutsideFunction = true; |
| } |
| } |
| |
| |
| acornOptions.onToken = function(token) { |
| if (extra.tokens) { |
| translator.onToken(token, extra); |
| } |
| if (token.type !== tt.eof) { |
| lastToken = token; |
| } |
| }; |
| |
| if (extra.attachComment || extra.comment) { |
| acornOptions.onComment = function() { |
| var comment = convertAcornCommentToEsprimaComment.apply(this, arguments); |
| extra.comments.push(comment); |
| |
| if (extra.attachComment) { |
| commentAttachment.addComment(comment); |
| } |
| }; |
| } |
| |
| if (extra.range) { |
| acornOptions.ranges = true; |
| } |
| |
| if (extra.loc) { |
| acornOptions.locations = true; |
| } |
| |
| if (extra.ecmaFeatures.jsx) { |
| // Should process jsx plugin before espree plugin. |
| acornOptions.plugins = { |
| jsx: true, |
| espree: true |
| }; |
| } |
| } |
| |
| program = acorn.parse(code, acornOptions); |
| program.sourceType = extra.isModule ? "module" : "script"; |
| |
| if (extra.comment || extra.attachComment) { |
| program.comments = extra.comments; |
| } |
| |
| if (extra.tokens) { |
| program.tokens = extra.tokens; |
| } |
| |
| /* |
| * Adjust opening and closing position of program to match Esprima. |
| * Acorn always starts programs at range 0 whereas Esprima starts at the |
| * first AST node's start (the only real difference is when there's leading |
| * whitespace or leading comments). Acorn also counts trailing whitespace |
| * as part of the program whereas Esprima only counts up to the last token. |
| */ |
| if (program.range) { |
| program.range[0] = program.body.length ? program.body[0].range[0] : program.range[0]; |
| program.range[1] = lastToken ? lastToken.range[1] : program.range[1]; |
| } |
| |
| if (program.loc) { |
| program.loc.start = program.body.length ? program.body[0].loc.start : program.loc.start; |
| program.loc.end = lastToken ? lastToken.loc.end : program.loc.end; |
| } |
| |
| return program; |
| } |
| |
| //------------------------------------------------------------------------------ |
| // Public |
| //------------------------------------------------------------------------------ |
| |
| exports.version = require("./package.json").version; |
| |
| exports.tokenize = tokenize; |
| |
| exports.parse = parse; |
| |
| // Deep copy. |
| /* istanbul ignore next */ |
| exports.Syntax = (function() { |
| var name, types = {}; |
| |
| if (typeof Object.create === "function") { |
| types = Object.create(null); |
| } |
| |
| for (name in astNodeTypes) { |
| if (astNodeTypes.hasOwnProperty(name)) { |
| types[name] = astNodeTypes[name]; |
| } |
| } |
| |
| if (typeof Object.freeze === "function") { |
| Object.freeze(types); |
| } |
| |
| return types; |
| }()); |
| |
| /* istanbul ignore next */ |
| exports.VisitorKeys = (function() { |
| var visitorKeys = require("./lib/visitor-keys"); |
| var name, |
| keys = {}; |
| |
| if (typeof Object.create === "function") { |
| keys = Object.create(null); |
| } |
| |
| for (name in visitorKeys) { |
| if (visitorKeys.hasOwnProperty(name)) { |
| keys[name] = visitorKeys[name]; |
| } |
| } |
| |
| if (typeof Object.freeze === "function") { |
| Object.freeze(keys); |
| } |
| |
| return keys; |
| }()); |
