src/third_party/devtools/node_modules/espree/lib/espree.js - cobalt - Git at Google

 "use strict";

 /* eslint-disable no-param-reassign*/
 const TokenTranslator = require("./token-translator");

 const DEFAULT_ECMA_VERSION = 5;
 const STATE = Symbol("espree's internal state");
 const ESPRIMA_FINISH_NODE = Symbol("espree's esprimaFinishNode");

 /**
  * Normalize ECMAScript version from the initial config
  * @param {number} ecmaVersion ECMAScript version from the initial config
  * @throws {Error} throws an error if the ecmaVersion is invalid.
  * @returns {number} normalized ECMAScript version
  */
 function normalizeEcmaVersion(ecmaVersion = DEFAULT_ECMA_VERSION) {
     if (typeof ecmaVersion !== "number") {
         throw new Error(`ecmaVersion must be a number. Received value of type ${typeof ecmaVersion} instead.`);
     }

     let 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:
         case 10:
         case 11:
             return version;

         // no default
     }

     throw new Error("Invalid ecmaVersion.");
 }

 /**
  * Normalize sourceType from the initial config
  * @param {string} sourceType to normalize
  * @throws {Error} throw an error if sourceType is invalid
  * @returns {string} normalized sourceType
  */
 function normalizeSourceType(sourceType = "script") {
     if (sourceType === "script" || sourceType === "module") {
         return sourceType;
     }
     throw new Error("Invalid sourceType.");
 }

 /**
  * Normalize parserOptions
  * @param {Object} options the parser options to normalize
  * @throws {Error} throw an error if found invalid option.
  * @returns {Object} normalized options
  */
 function normalizeOptions(options) {
     const ecmaVersion = normalizeEcmaVersion(options.ecmaVersion);
     const sourceType = normalizeSourceType(options.sourceType);
     const ranges = options.range === true;
     const locations = options.loc === true;

     if (sourceType === "module" && ecmaVersion < 6) {
         throw new Error("sourceType 'module' is not supported when ecmaVersion < 2015. Consider adding `{ ecmaVersion: 2015 }` to the parser options.");
     }
     return Object.assign({}, options, { ecmaVersion, sourceType, ranges, locations });
 }

 /**
  * 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) {
     const 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;
 }

 module.exports = () => Parser => {
     const tokTypes = Object.assign({}, Parser.acorn.tokTypes);

     if (Parser.acornJsx) {
         Object.assign(tokTypes, Parser.acornJsx.tokTypes);
     }

     return class Espree extends Parser {
         constructor(opts, code) {
             if (typeof opts !== "object" || opts === null) {
                 opts = {};
             }
             if (typeof code !== "string" && !(code instanceof String)) {
                 code = String(code);
             }

             const options = normalizeOptions(opts);
             const ecmaFeatures = options.ecmaFeatures || {};
             const tokenTranslator =
                 options.tokens === true
                     ? new TokenTranslator(tokTypes, code)
                     : null;

             // Initialize acorn parser.
             super({

                 // TODO: use {...options} when spread is supported(Node.js >= 8.3.0).
                 ecmaVersion: options.ecmaVersion,
                 sourceType: options.sourceType,
                 ranges: options.ranges,
                 locations: options.locations,

                 // Truthy value is true for backward compatibility.
                 allowReturnOutsideFunction: Boolean(ecmaFeatures.globalReturn),

                 // Collect tokens
                 onToken: token => {
                     if (tokenTranslator) {

                         // Use `tokens`, `ecmaVersion`, and `jsxAttrValueToken` in the state.
                         tokenTranslator.onToken(token, this[STATE]);
                     }
                     if (token.type !== tokTypes.eof) {
                         this[STATE].lastToken = token;
                     }
                 },

                 // Collect comments
                 onComment: (block, text, start, end, startLoc, endLoc) => {
                     if (this[STATE].comments) {
                         const comment = convertAcornCommentToEsprimaComment(block, text, start, end, startLoc, endLoc);

                         this[STATE].comments.push(comment);
                     }
                 }
             }, code);

             // Initialize internal state.
             this[STATE] = {
                 tokens: tokenTranslator ? [] : null,
                 comments: options.comment === true ? [] : null,
                 impliedStrict: ecmaFeatures.impliedStrict === true && this.options.ecmaVersion >= 5,
                 ecmaVersion: this.options.ecmaVersion,
                 jsxAttrValueToken: false,
                 lastToken: null
             };
         }

         tokenize() {
             do {
                 this.next();
             } while (this.type !== tokTypes.eof);

             // Consume the final eof token
             this.next();

             const extra = this[STATE];
             const tokens = extra.tokens;

             if (extra.comments) {
                 tokens.comments = extra.comments;
             }

             return tokens;
         }

         finishNode(...args) {
             const result = super.finishNode(...args);

             return this[ESPRIMA_FINISH_NODE](result);
         }

         finishNodeAt(...args) {
             const result = super.finishNodeAt(...args);

             return this[ESPRIMA_FINISH_NODE](result);
         }

         parse() {
             const extra = this[STATE];
             const program = super.parse();

             program.sourceType = this.options.sourceType;

             if (extra.comments) {
                 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] = extra.lastToken ? extra.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 = extra.lastToken ? extra.lastToken.loc.end : program.loc.end;
             }

             return program;
         }

         parseTopLevel(node) {
             if (this[STATE].impliedStrict) {
                 this.strict = true;
             }
             return super.parseTopLevel(node);
         }

         /**
          * 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}
          */
         raise(pos, message) {
             const loc = Parser.acorn.getLineInfo(this.input, pos);
             const 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 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}
          */
         raiseRecoverable(pos, message) {
             this.raise(pos, message);
         }

         /**
          * 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}
          */
         unexpected(pos) {
             let message = "Unexpected token";

             if (pos !== null && pos !== void 0) {
                 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.
         */
         jsx_readString(quote) { // eslint-disable-line camelcase
             const result = super.jsx_readString(quote);

             if (this.type === tokTypes.string) {
                 this[STATE].jsxAttrValueToken = true;
             }
             return result;
         }

         /**
          * Performs last-minute Esprima-specific compatibility checks and fixes.
          * @param {ASTNode} result The node to check.
          * @returns {ASTNode} The finished node.
          */
         [ESPRIMA_FINISH_NODE](result) {

             // 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
                 const 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);
                 }
             }

             if (result.type.indexOf("Function") > -1 && !result.generator) {
                 result.generator = false;
             }

             return result;
         }
     };
 };
	"use strict";

	/* eslint-disable no-param-reassign*/
	const TokenTranslator = require("./token-translator");

	const DEFAULT_ECMA_VERSION = 5;
	const STATE = Symbol("espree's internal state");
	const ESPRIMA_FINISH_NODE = Symbol("espree's esprimaFinishNode");

	/**
	* Normalize ECMAScript version from the initial config
	* @param {number} ecmaVersion ECMAScript version from the initial config
	* @throws {Error} throws an error if the ecmaVersion is invalid.
	* @returns {number} normalized ECMAScript version
	*/
	function normalizeEcmaVersion(ecmaVersion = DEFAULT_ECMA_VERSION) {
	if (typeof ecmaVersion !== "number") {
	throw new Error(`ecmaVersion must be a number. Received value of type ${typeof ecmaVersion} instead.`);
	}

	let 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:
	case 10:
	case 11:
	return version;

	// no default
	}

	throw new Error("Invalid ecmaVersion.");
	}

	/**
	* Normalize sourceType from the initial config
	* @param {string} sourceType to normalize
	* @throws {Error} throw an error if sourceType is invalid
	* @returns {string} normalized sourceType
	*/
	function normalizeSourceType(sourceType = "script") {
	if (sourceType === "script" \|\| sourceType === "module") {
	return sourceType;
	}
	throw new Error("Invalid sourceType.");
	}

	/**
	* Normalize parserOptions
	* @param {Object} options the parser options to normalize
	* @throws {Error} throw an error if found invalid option.
	* @returns {Object} normalized options
	*/
	function normalizeOptions(options) {
	const ecmaVersion = normalizeEcmaVersion(options.ecmaVersion);
	const sourceType = normalizeSourceType(options.sourceType);
	const ranges = options.range === true;
	const locations = options.loc === true;

	if (sourceType === "module" && ecmaVersion < 6) {
	throw new Error("sourceType 'module' is not supported when ecmaVersion < 2015. Consider adding `{ ecmaVersion: 2015 }` to the parser options.");
	}
	return Object.assign({}, options, { ecmaVersion, sourceType, ranges, locations });
	}

	/**
	* 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) {
	const 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;
	}

	module.exports = () => Parser => {
	const tokTypes = Object.assign({}, Parser.acorn.tokTypes);

	if (Parser.acornJsx) {
	Object.assign(tokTypes, Parser.acornJsx.tokTypes);
	}

	return class Espree extends Parser {
	constructor(opts, code) {
	if (typeof opts !== "object" \|\| opts === null) {
	opts = {};
	}
	if (typeof code !== "string" && !(code instanceof String)) {
	code = String(code);
	}

	const options = normalizeOptions(opts);
	const ecmaFeatures = options.ecmaFeatures \|\| {};
	const tokenTranslator =
	options.tokens === true
	? new TokenTranslator(tokTypes, code)
	: null;

	// Initialize acorn parser.
	super({

	// TODO: use {...options} when spread is supported(Node.js >= 8.3.0).
	ecmaVersion: options.ecmaVersion,
	sourceType: options.sourceType,
	ranges: options.ranges,
	locations: options.locations,

	// Truthy value is true for backward compatibility.
	allowReturnOutsideFunction: Boolean(ecmaFeatures.globalReturn),

	// Collect tokens
	onToken: token => {
	if (tokenTranslator) {

	// Use `tokens`, `ecmaVersion`, and `jsxAttrValueToken` in the state.
	tokenTranslator.onToken(token, this[STATE]);
	}
	if (token.type !== tokTypes.eof) {
	this[STATE].lastToken = token;
	}
	},

	// Collect comments
	onComment: (block, text, start, end, startLoc, endLoc) => {
	if (this[STATE].comments) {
	const comment = convertAcornCommentToEsprimaComment(block, text, start, end, startLoc, endLoc);

	this[STATE].comments.push(comment);
	}
	}
	}, code);

	// Initialize internal state.
	this[STATE] = {
	tokens: tokenTranslator ? [] : null,
	comments: options.comment === true ? [] : null,
	impliedStrict: ecmaFeatures.impliedStrict === true && this.options.ecmaVersion >= 5,
	ecmaVersion: this.options.ecmaVersion,
	jsxAttrValueToken: false,
	lastToken: null
	};
	}

	tokenize() {
	do {
	this.next();
	} while (this.type !== tokTypes.eof);

	// Consume the final eof token
	this.next();

	const extra = this[STATE];
	const tokens = extra.tokens;

	if (extra.comments) {
	tokens.comments = extra.comments;
	}

	return tokens;
	}

	finishNode(...args) {
	const result = super.finishNode(...args);

	return this[ESPRIMA_FINISH_NODE](result);
	}

	finishNodeAt(...args) {
	const result = super.finishNodeAt(...args);

	return this[ESPRIMA_FINISH_NODE](result);
	}

	parse() {
	const extra = this[STATE];
	const program = super.parse();

	program.sourceType = this.options.sourceType;

	if (extra.comments) {
	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] = extra.lastToken ? extra.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 = extra.lastToken ? extra.lastToken.loc.end : program.loc.end;
	}

	return program;
	}

	parseTopLevel(node) {
	if (this[STATE].impliedStrict) {
	this.strict = true;
	}
	return super.parseTopLevel(node);
	}

	/**
	* 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}
	*/
	raise(pos, message) {
	const loc = Parser.acorn.getLineInfo(this.input, pos);
	const 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 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}
	*/
	raiseRecoverable(pos, message) {
	this.raise(pos, message);
	}

	/**
	* 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}
	*/
	unexpected(pos) {
	let message = "Unexpected token";

	if (pos !== null && pos !== void 0) {
	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.
	*/
	jsx_readString(quote) { // eslint-disable-line camelcase
	const result = super.jsx_readString(quote);

	if (this.type === tokTypes.string) {
	this[STATE].jsxAttrValueToken = true;
	}
	return result;
	}

	/**
	* Performs last-minute Esprima-specific compatibility checks and fixes.
	* @param {ASTNode} result The node to check.
	* @returns {ASTNode} The finished node.
	*/
	[ESPRIMA_FINISH_NODE](result) {

	// 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
	const 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);
	}
	}

	if (result.type.indexOf("Function") > -1 && !result.generator) {
	result.generator = false;
	}

	return result;
	}
	};
	};