espree - npm Package Compare versions

Comparing version 6.1.1 to 6.1.2

CHANGELOG.md

@@ -0,1 +1,5 @@
+v6.1.2 - October 20, 2019
+
+* [`70c4970`](https://github.com/eslint/espree/commit/70c4970e5eba6f060e1e32a22d231647f2d0e0f8) Fix: misuse token types (fixes #393, refs eslint/eslint#11018) (#426) (Toru Nagashima)
+
 v6.1.1 - August 23, 2019
@@ -2,0 +6,0 @@

lib/espree.js

 "use strict";
 
 /* eslint-disable no-param-reassign*/
-const acorn = require("acorn");
-const jsx = require("acorn-jsx");
 const TokenTranslator = require("./token-translator");
@@ -11,5 +9,3 @@
 const ESPRIMA_FINISH_NODE = Symbol("espree's esprimaFinishNode");
-const tokTypes = Object.assign({}, acorn.tokTypes, jsx.tokTypes);
 
-
 /**
@@ -115,236 +111,244 @@ * Normalize ECMAScript version from the initial config
 
-module.exports = () => Parser => class Espree extends Parser {
-    constructor(opts, code) {
-        if (typeof opts !== "object" || opts === null) {
-            opts = {};
-        }
-        if (typeof code !== "string" && !(code instanceof String)) {
-            code = String(code);
-        }
+module.exports = () => Parser => {
+    const tokTypes = Object.assign({}, Parser.acorn.tokTypes);
 
-        const options = normalizeOptions(opts);
-        const ecmaFeatures = options.ecmaFeatures || {};
-        const tokenTranslator =
-            options.tokens === true
-                ? new TokenTranslator(tokTypes, code)
-                : null;
+    if (Parser.acornJsx) {
+        Object.assign(tokTypes, Parser.acornJsx.tokTypes);
+    }
 
-        // Initialize acorn parser.
-        super({
+    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);
+            }
 
-            // TODO: use {...options} when spread is supported(Node.js >= 8.3.0).
-            ecmaVersion: options.ecmaVersion,
-            sourceType: options.sourceType,
-            ranges: options.ranges,
-            locations: options.locations,
+            const options = normalizeOptions(opts);
+            const ecmaFeatures = options.ecmaFeatures || {};
+            const tokenTranslator =
+                options.tokens === true
+                    ? new TokenTranslator(tokTypes, code)
+                    : null;
 
-            // Truthy value is true for backward compatibility.
-            allowReturnOutsideFunction: Boolean(ecmaFeatures.globalReturn),
+            // Initialize acorn parser.
+            super({
 
-            // Collect tokens
-            onToken: token => {
-                if (tokenTranslator) {
+                // TODO: use {...options} when spread is supported(Node.js >= 8.3.0).
+                ecmaVersion: options.ecmaVersion,
+                sourceType: options.sourceType,
+                ranges: options.ranges,
+                locations: options.locations,
 
-                    // Use `tokens`, `ecmaVersion`, and `jsxAttrValueToken` in the state.
-                    tokenTranslator.onToken(token, this[STATE]);
-                }
-                if (token.type !== tokTypes.eof) {
-                    this[STATE].lastToken = token;
-                }
-            },
+                // Truthy value is true for backward compatibility.
+                allowReturnOutsideFunction: Boolean(ecmaFeatures.globalReturn),
 
-            // Collect comments
-            onComment: (block, text, start, end, startLoc, endLoc) => {
-                if (this[STATE].comments) {
-                    const comment = convertAcornCommentToEsprimaComment(block, text, start, end, startLoc, endLoc);
+                // Collect tokens
+                onToken: token => {
+                    if (tokenTranslator) {
 
-                    this[STATE].comments.push(comment);
+                        // 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);
+            }, 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
-        };
-    }
+            // 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 {
+        tokenize() {
+            do {
+                this.next();
+            } while (this.type !== tokTypes.eof);
+
+            // Consume the final eof token
             this.next();
-        } while (this.type !== tokTypes.eof);
 
-        // Consume the final eof token
-        this.next();
+            const extra = this[STATE];
+            const tokens = extra.tokens;
 
-        const extra = this[STATE];
-        const tokens = extra.tokens;
+            if (extra.comments) {
+                tokens.comments = extra.comments;
+            }
 
-        if (extra.comments) {
-            tokens.comments = extra.comments;
+            return tokens;
         }
 
-        return tokens;
-    }
+        finishNode(...args) {
+            const result = super.finishNode(...args);
 
-    finishNode(...args) {
-        const result = super.finishNode(...args);
+            return this[ESPRIMA_FINISH_NODE](result);
+        }
 
-        return this[ESPRIMA_FINISH_NODE](result);
-    }
+        finishNodeAt(...args) {
+            const result = super.finishNodeAt(...args);
 
-    finishNodeAt(...args) {
-        const result = super.finishNodeAt(...args);
+            return this[ESPRIMA_FINISH_NODE](result);
+        }
 
-        return this[ESPRIMA_FINISH_NODE](result);
-    }
+        parse() {
+            const extra = this[STATE];
+            const program = super.parse();
 
-    parse() {
-        const extra = this[STATE];
-        const program = super.parse();
+            program.sourceType = this.options.sourceType;
 
-        program.sourceType = this.options.sourceType;
+            if (extra.comments) {
+                program.comments = extra.comments;
+            }
+            if (extra.tokens) {
+                program.tokens = extra.tokens;
+            }
 
-        if (extra.comments) {
-            program.comments = extra.comments;
+            /*
+             * 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;
         }
-        if (extra.tokens) {
-            program.tokens = extra.tokens;
+
+        parseTopLevel(node) {
+            if (this[STATE].impliedStrict) {
+                this.strict = true;
+            }
+            return super.parseTopLevel(node);
         }
 
-        /*
-         * 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.
+        /**
+         * 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}
          */
-        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];
+        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;
         }
-        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;
+        /**
+         * 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);
         }
-        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 = acorn.getLineInfo(this.input, pos);
-        const err = new SyntaxError(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";
 
-        err.index = pos;
-        err.lineNumber = loc.line;
-        err.column = loc.column + 1; // acorn uses 0-based columns
-        throw err;
-    }
+            if (pos !== null && pos !== void 0) {
+                this.pos = pos;
 
-    /**
-     * 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);
-    }
+                if (this.options.locations) {
+                    while (this.pos < this.lineStart) {
+                        this.lineStart = this.input.lastIndexOf("\n", this.lineStart - 2) + 1;
+                        --this.curLine;
+                    }
+                }
 
-    /**
-     * 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";
+                this.nextToken();
+            }
 
-        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;
-                }
+            if (this.end > this.start) {
+                message += ` ${this.input.slice(this.start, this.end)}`;
             }
 
-            this.nextToken();
+            this.raise(this.start, message);
         }
 
-        if (this.end > this.start) {
-            message += ` ${this.input.slice(this.start, this.end)}`;
+        /*
+        * 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;
         }
 
-        this.raise(this.start, message);
-    }
+        /**
+         * 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) {
 
-    /*
-     * 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);
+            // 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") {
 
-        if (this.type === tokTypes.string) {
-            this[STATE].jsxAttrValueToken = true;
-        }
-        return result;
-    }
+                // additional adjustment needed if ${ is the last token
+                const terminalDollarBraceL = this.input.slice(result.end, result.end + 2) === "${";
 
-    /**
-     * 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) {
+                if (result.range) {
+                    result.range[0]--;
+                    result.range[1] += (terminalDollarBraceL ? 2 : 1);
+                }
 
-        // 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.loc) {
-                result.loc.start.column--;
-                result.loc.end.column += (terminalDollarBraceL ? 2 : 1);
+            if (result.type.indexOf("Function") > -1 && !result.generator) {
+                result.generator = false;
             }
-        }
 
-        if (result.type.indexOf("Function") > -1 && !result.generator) {
-            result.generator = false;
+            return result;
         }
-
-        return result;
-    }
+    };
 };

package.json

@@ -7,3 +7,3 @@ {
   "main": "espree.js",
-  "version": "6.1.1",
+  "version": "6.1.2",
   "files": [
@@ -22,4 +22,4 @@ "lib",
   "dependencies": {
-    "acorn": "^7.0.0",
-    "acorn-jsx": "^5.0.2",
+    "acorn": "^7.1.0",
+    "acorn-jsx": "^5.1.0",
     "eslint-visitor-keys": "^1.1.0"
@@ -26,0 +26,0 @@ },

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

New author

Supply chain risk

A new npm collaborator published a version of the package for the first time. New collaborators are usually benign additions to a project, but do indicate a change to the security surface area of a package.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

67027

increased by1.55%

Lines of code

883

increased by0.34%

Worsened metrics

Number of medium supply chain risk alerts

1

increased byInfinity%

Dependency changes

• Updatedacorn@^7.1.0

• Updatedacorn-jsx@^5.1.0