mirror of
https://github.com/hanzoai/eslint.git
synced 2026-10-30 19:38:10 +00:00
2704 lines
65 KiB
JavaScript
2704 lines
65 KiB
JavaScript
/**
|
|
* @fileoverview Tests for ast utils.
|
|
* @author Gyandeep Singh
|
|
*/
|
|
|
|
"use strict";
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Requirements
|
|
//------------------------------------------------------------------------------
|
|
|
|
const assert = require("chai").assert,
|
|
util = require("node:util"),
|
|
espree = require("espree"),
|
|
astUtils = require("../../../../lib/rules/utils/ast-utils"),
|
|
{ Linter } = require("../../../../lib/linter"),
|
|
{ SourceCode } = require("../../../../lib/languages/js/source-code");
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Tests
|
|
//------------------------------------------------------------------------------
|
|
|
|
const ESPREE_CONFIG = {
|
|
ecmaVersion: 6,
|
|
comment: true,
|
|
tokens: true,
|
|
range: true,
|
|
loc: true,
|
|
};
|
|
const linter = new Linter();
|
|
|
|
describe("ast-utils", () => {
|
|
let callCounts;
|
|
|
|
beforeEach(() => {
|
|
callCounts = new Map();
|
|
});
|
|
|
|
/**
|
|
* Asserts that a given function is called at least once during a test
|
|
* @param {Function} func The function that must be called at least once
|
|
* @returns {Function} A wrapper around the same function
|
|
*/
|
|
function mustCall(func) {
|
|
callCounts.set(func, 0);
|
|
return function Wrapper(...args) {
|
|
callCounts.set(func, callCounts.get(func) + 1);
|
|
|
|
return func.call(this, ...args);
|
|
};
|
|
}
|
|
|
|
afterEach(() => {
|
|
callCounts.forEach((callCount, func) => {
|
|
assert(
|
|
callCount > 0,
|
|
`Expected ${func.toString()} to be called at least once but it was not called`,
|
|
);
|
|
});
|
|
});
|
|
|
|
describe("ECMASCRIPT_GLOBALS", () => {
|
|
it("should contain es3 globals", () => {
|
|
assert.ownInclude(astUtils.ECMASCRIPT_GLOBALS, { Object: false });
|
|
});
|
|
|
|
it("should contain es5 globals", () => {
|
|
assert.ownInclude(astUtils.ECMASCRIPT_GLOBALS, { JSON: false });
|
|
});
|
|
|
|
it("should contain es2015 globals", () => {
|
|
assert.ownInclude(astUtils.ECMASCRIPT_GLOBALS, { Promise: false });
|
|
});
|
|
|
|
it("should contain es2017 globals", () => {
|
|
assert.ownInclude(astUtils.ECMASCRIPT_GLOBALS, {
|
|
SharedArrayBuffer: false,
|
|
});
|
|
});
|
|
|
|
it("should contain es2020 globals", () => {
|
|
assert.ownInclude(astUtils.ECMASCRIPT_GLOBALS, { BigInt: false });
|
|
});
|
|
|
|
it("should contain es2021 globals", () => {
|
|
assert.ownInclude(astUtils.ECMASCRIPT_GLOBALS, { WeakRef: false });
|
|
});
|
|
|
|
it("should contain es2026 globals", () => {
|
|
assert.ownInclude(astUtils.ECMASCRIPT_GLOBALS, { Temporal: false });
|
|
});
|
|
});
|
|
|
|
describe("isTokenOnSameLine", () => {
|
|
it("should return false if the tokens are not on the same line", () => {
|
|
linter.verify("if(a)\n{}", {
|
|
plugins: {
|
|
test: {
|
|
rules: {
|
|
checker: {
|
|
create: mustCall(context => ({
|
|
BlockStatement: mustCall(node => {
|
|
assert.isFalse(
|
|
astUtils.isTokenOnSameLine(
|
|
context.sourceCode.getTokenBefore(
|
|
node,
|
|
),
|
|
node,
|
|
),
|
|
);
|
|
}),
|
|
})),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
rules: { "test/checker": "error" },
|
|
});
|
|
});
|
|
|
|
it("should return true if the tokens are on the same line", () => {
|
|
linter.verify("if(a){}", {
|
|
plugins: {
|
|
test: {
|
|
rules: {
|
|
checker: {
|
|
create: mustCall(context => ({
|
|
BlockStatement: mustCall(node => {
|
|
assert.isTrue(
|
|
astUtils.isTokenOnSameLine(
|
|
context.sourceCode.getTokenBefore(
|
|
node,
|
|
),
|
|
node,
|
|
),
|
|
);
|
|
}),
|
|
})),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
rules: { "test/checker": "error" },
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("isNullOrUndefined", () => {
|
|
it("should return true if the argument is null", () => {
|
|
assert.isTrue(
|
|
astUtils.isNullOrUndefined(
|
|
espree.parse("null").body[0].expression,
|
|
),
|
|
);
|
|
});
|
|
|
|
it("should return true if the argument is undefined", () => {
|
|
assert.isTrue(
|
|
astUtils.isNullOrUndefined(
|
|
espree.parse("undefined").body[0].expression,
|
|
),
|
|
);
|
|
});
|
|
|
|
it("should return false if the argument is a number", () => {
|
|
assert.isFalse(
|
|
astUtils.isNullOrUndefined(
|
|
espree.parse("1").body[0].expression,
|
|
),
|
|
);
|
|
});
|
|
|
|
it("should return false if the argument is a string", () => {
|
|
assert.isFalse(
|
|
astUtils.isNullOrUndefined(
|
|
espree.parse("'test'").body[0].expression,
|
|
),
|
|
);
|
|
});
|
|
|
|
it("should return false if the argument is a boolean", () => {
|
|
assert.isFalse(
|
|
astUtils.isNullOrUndefined(
|
|
espree.parse("true").body[0].expression,
|
|
),
|
|
);
|
|
});
|
|
|
|
it("should return false if the argument is an object", () => {
|
|
assert.isFalse(
|
|
astUtils.isNullOrUndefined(
|
|
espree.parse("({})").body[0].expression,
|
|
),
|
|
);
|
|
});
|
|
|
|
it("should return false if the argument is a unicode regex", () => {
|
|
assert.isFalse(
|
|
astUtils.isNullOrUndefined(
|
|
espree.parse("/abc/u", { ecmaVersion: 6 }).body[0]
|
|
.expression,
|
|
),
|
|
);
|
|
});
|
|
});
|
|
|
|
describe("checkReference", () => {
|
|
// catch
|
|
it("should return true if reference is assigned for catch", () => {
|
|
linter.verify("try { } catch (e) { e = 10; }", {
|
|
plugins: {
|
|
test: {
|
|
rules: {
|
|
checker: {
|
|
create: mustCall(context => ({
|
|
CatchClause: mustCall(node => {
|
|
const variables =
|
|
context.sourceCode.getDeclaredVariables(
|
|
node,
|
|
);
|
|
|
|
assert.lengthOf(
|
|
astUtils.getModifyingReferences(
|
|
variables[0].references,
|
|
),
|
|
1,
|
|
);
|
|
}),
|
|
})),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
rules: { "test/checker": "error" },
|
|
});
|
|
});
|
|
|
|
// const
|
|
it("should return true if reference is assigned for const", () => {
|
|
linter.verify("const a = 1; a = 2;", {
|
|
plugins: {
|
|
test: {
|
|
rules: {
|
|
checker: {
|
|
create: mustCall(context => ({
|
|
VariableDeclaration: mustCall(node => {
|
|
const variables =
|
|
context.sourceCode.getDeclaredVariables(
|
|
node,
|
|
);
|
|
|
|
assert.lengthOf(
|
|
astUtils.getModifyingReferences(
|
|
variables[0].references,
|
|
),
|
|
1,
|
|
);
|
|
}),
|
|
})),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
rules: { "test/checker": "error" },
|
|
});
|
|
});
|
|
|
|
it("should return false if reference is not assigned for const", () => {
|
|
linter.verify("const a = 1; c = 2;", {
|
|
plugins: {
|
|
test: {
|
|
rules: {
|
|
checker: {
|
|
create: mustCall(context => ({
|
|
VariableDeclaration: mustCall(node => {
|
|
const variables =
|
|
context.sourceCode.getDeclaredVariables(
|
|
node,
|
|
);
|
|
|
|
assert.lengthOf(
|
|
astUtils.getModifyingReferences(
|
|
variables[0].references,
|
|
),
|
|
0,
|
|
);
|
|
}),
|
|
})),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
rules: { "test/checker": "error" },
|
|
});
|
|
});
|
|
|
|
// class
|
|
it("should return true if reference is assigned for class", () => {
|
|
linter.verify("class A { }\n A = 1;", {
|
|
plugins: {
|
|
test: {
|
|
rules: {
|
|
checker: {
|
|
create: mustCall(context => ({
|
|
ClassDeclaration: mustCall(node => {
|
|
const variables =
|
|
context.sourceCode.getDeclaredVariables(
|
|
node,
|
|
);
|
|
|
|
assert.lengthOf(
|
|
astUtils.getModifyingReferences(
|
|
variables[0].references,
|
|
),
|
|
1,
|
|
);
|
|
assert.lengthOf(
|
|
astUtils.getModifyingReferences(
|
|
variables[1].references,
|
|
),
|
|
0,
|
|
);
|
|
}),
|
|
})),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
rules: { "test/checker": "error" },
|
|
});
|
|
});
|
|
|
|
it("should return false if reference is not assigned for class", () => {
|
|
linter.verify("class A { } foo(A);", {
|
|
plugins: {
|
|
test: {
|
|
rules: {
|
|
checker: {
|
|
create: mustCall(context => ({
|
|
ClassDeclaration: mustCall(node => {
|
|
const variables =
|
|
context.sourceCode.getDeclaredVariables(
|
|
node,
|
|
);
|
|
|
|
assert.lengthOf(
|
|
astUtils.getModifyingReferences(
|
|
variables[0].references,
|
|
),
|
|
0,
|
|
);
|
|
}),
|
|
})),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
rules: { "test/checker": "error" },
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("isDirectiveComment", () => {
|
|
/**
|
|
* Asserts the node is NOT a directive comment
|
|
* @param {ASTNode} node node to assert
|
|
* @returns {void}
|
|
*/
|
|
function assertFalse(node) {
|
|
assert.isFalse(astUtils.isDirectiveComment(node));
|
|
}
|
|
|
|
/**
|
|
* Asserts the node is a directive comment
|
|
* @param {ASTNode} node node to assert
|
|
* @returns {void}
|
|
*/
|
|
function assertTrue(node) {
|
|
assert.isTrue(astUtils.isDirectiveComment(node));
|
|
}
|
|
|
|
it("should return false if it is not a directive line comment", () => {
|
|
const code = [
|
|
"// lalala I'm a normal comment",
|
|
"// trying to confuse eslint ",
|
|
"//trying to confuse eslint-directive-detection",
|
|
"//eslint is awesome",
|
|
"//global line comment is not a directive",
|
|
"//globals line comment is not a directive",
|
|
"//exported line comment is not a directive",
|
|
].join("\n");
|
|
const ast = espree.parse(code, ESPREE_CONFIG);
|
|
const sourceCode = new SourceCode(code, ast);
|
|
const comments = sourceCode.getAllComments();
|
|
|
|
comments.forEach(assertFalse);
|
|
});
|
|
|
|
it("should return false if it is not a directive block comment", () => {
|
|
const code = [
|
|
"/* lalala I'm a normal comment */",
|
|
"/* trying to confuse eslint */",
|
|
"/* trying to confuse eslint-directive-detection */",
|
|
"/*eSlInT is awesome*/",
|
|
].join("\n");
|
|
const ast = espree.parse(code, ESPREE_CONFIG);
|
|
const sourceCode = new SourceCode(code, ast);
|
|
const comments = sourceCode.getAllComments();
|
|
|
|
comments.forEach(assertFalse);
|
|
});
|
|
|
|
it("should return true if it is a directive line comment", () => {
|
|
const code = [
|
|
"// eslint-disable-line no-undef",
|
|
"// eslint-secret-directive 4 8 15 16 23 42 ",
|
|
"// eslint-directive-without-argument",
|
|
"//eslint-directive-without-padding",
|
|
].join("\n");
|
|
const ast = espree.parse(code, ESPREE_CONFIG);
|
|
const sourceCode = new SourceCode(code, ast);
|
|
const comments = sourceCode.getAllComments();
|
|
|
|
comments.forEach(assertTrue);
|
|
});
|
|
|
|
it("should return true if it is a directive block comment", () => {
|
|
const code = [
|
|
"/* eslint-disable no-undef */",
|
|
"/*eslint-enable no-undef*/",
|
|
'/* eslint-env {"es6": true} */',
|
|
"/* eslint foo */",
|
|
"/*eslint bar*/",
|
|
"/*global foo*/",
|
|
"/*globals foo*/",
|
|
"/*exported foo*/",
|
|
].join("\n");
|
|
const ast = espree.parse(code, ESPREE_CONFIG);
|
|
const sourceCode = new SourceCode(code, ast);
|
|
const comments = sourceCode.getAllComments();
|
|
|
|
comments.forEach(assertTrue);
|
|
});
|
|
});
|
|
|
|
describe("isParenthesised", () => {
|
|
it("should return false for not parenthesised nodes", () => {
|
|
const code = "condition ? 1 : 2";
|
|
const ast = espree.parse(code, ESPREE_CONFIG);
|
|
const sourceCode = new SourceCode(code, ast);
|
|
|
|
assert.isFalse(
|
|
astUtils.isParenthesised(sourceCode, ast.body[0].expression),
|
|
);
|
|
});
|
|
|
|
it("should return true for not parenthesised nodes", () => {
|
|
const code = "(condition ? 1 : 2)";
|
|
const ast = espree.parse(code, ESPREE_CONFIG);
|
|
const sourceCode = new SourceCode(code, ast);
|
|
|
|
assert.isTrue(
|
|
astUtils.isParenthesised(sourceCode, ast.body[0].expression),
|
|
);
|
|
});
|
|
});
|
|
|
|
describe("isFunction", () => {
|
|
it("should return true for FunctionDeclaration", () => {
|
|
const ast = espree.parse("function a() {}");
|
|
const node = ast.body[0];
|
|
|
|
assert(astUtils.isFunction(node));
|
|
});
|
|
|
|
it("should return true for FunctionExpression", () => {
|
|
const ast = espree.parse("(function a() {})");
|
|
const node = ast.body[0].expression;
|
|
|
|
assert(astUtils.isFunction(node));
|
|
});
|
|
|
|
it("should return true for AllowFunctionExpression", () => {
|
|
const ast = espree.parse("(() => {})", { ecmaVersion: 6 });
|
|
const node = ast.body[0].expression;
|
|
|
|
assert(astUtils.isFunction(node));
|
|
});
|
|
|
|
it("should return false for Program, VariableDeclaration, BlockStatement", () => {
|
|
const ast = espree.parse("var a; { }");
|
|
|
|
assert(!astUtils.isFunction(ast));
|
|
assert(!astUtils.isFunction(ast.body[0]));
|
|
assert(!astUtils.isFunction(ast.body[1]));
|
|
});
|
|
});
|
|
|
|
describe("isLoop", () => {
|
|
it("should return true for DoWhileStatement", () => {
|
|
const ast = espree.parse("do {} while (a)");
|
|
const node = ast.body[0];
|
|
|
|
assert(astUtils.isLoop(node));
|
|
});
|
|
|
|
it("should return true for ForInStatement", () => {
|
|
const ast = espree.parse("for (var k in obj) {}");
|
|
const node = ast.body[0];
|
|
|
|
assert(astUtils.isLoop(node));
|
|
});
|
|
|
|
it("should return true for ForOfStatement", () => {
|
|
const ast = espree.parse("for (var x of list) {}", {
|
|
ecmaVersion: 6,
|
|
});
|
|
const node = ast.body[0];
|
|
|
|
assert(astUtils.isLoop(node));
|
|
});
|
|
|
|
it("should return true for ForStatement", () => {
|
|
const ast = espree.parse("for (var i = 0; i < 10; ++i) {}");
|
|
const node = ast.body[0];
|
|
|
|
assert(astUtils.isLoop(node));
|
|
});
|
|
|
|
it("should return true for WhileStatement", () => {
|
|
const ast = espree.parse("while (a) {}");
|
|
const node = ast.body[0];
|
|
|
|
assert(astUtils.isLoop(node));
|
|
});
|
|
|
|
it("should return false for Program, VariableDeclaration, BlockStatement", () => {
|
|
const ast = espree.parse("var a; { }");
|
|
|
|
assert(!astUtils.isLoop(ast));
|
|
assert(!astUtils.isLoop(ast.body[0]));
|
|
assert(!astUtils.isLoop(ast.body[1]));
|
|
});
|
|
});
|
|
|
|
describe("isInLoop", () => {
|
|
/**
|
|
* Asserts that the unique node of the given type in the code is either
|
|
* in a loop or not in a loop.
|
|
* @param {string} code the code to check.
|
|
* @param {string} nodeType the type of the node to consider. The code
|
|
* must have exactly one node of this type.
|
|
* @param {boolean} expectedInLoop the expected result for whether the
|
|
* node is in a loop.
|
|
* @returns {void}
|
|
*/
|
|
function assertNodeTypeInLoop(code, nodeType, expectedInLoop) {
|
|
const results = [];
|
|
|
|
linter.verify(code, {
|
|
plugins: {
|
|
test: {
|
|
rules: {
|
|
checker: {
|
|
create: mustCall(() => ({
|
|
[nodeType]: mustCall(node => {
|
|
results.push(astUtils.isInLoop(node));
|
|
}),
|
|
})),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
rules: { "test/checker": "error" },
|
|
});
|
|
|
|
assert.lengthOf(results, 1);
|
|
assert.strictEqual(results[0], expectedInLoop);
|
|
}
|
|
|
|
it("should return true for a loop itself", () => {
|
|
assertNodeTypeInLoop("while (a) {}", "WhileStatement", true);
|
|
});
|
|
|
|
it("should return true for a loop condition", () => {
|
|
assertNodeTypeInLoop("while (a) {}", "Identifier", true);
|
|
});
|
|
|
|
it("should return true for a loop assignee", () => {
|
|
assertNodeTypeInLoop(
|
|
"for (var a in b) {}",
|
|
"VariableDeclaration",
|
|
true,
|
|
);
|
|
});
|
|
|
|
it("should return true for a node within a loop body", () => {
|
|
assertNodeTypeInLoop(
|
|
"for (var a of b) { console.log('Hello'); }",
|
|
"Literal",
|
|
true,
|
|
);
|
|
});
|
|
|
|
it("should return false for a node outside a loop body", () => {
|
|
assertNodeTypeInLoop(
|
|
"while (true) {} a(b);",
|
|
"CallExpression",
|
|
false,
|
|
);
|
|
});
|
|
|
|
it("should return false when the loop is not in the current function", () => {
|
|
assertNodeTypeInLoop(
|
|
"while (true) { funcs.push(() => { var a; }); }",
|
|
"VariableDeclaration",
|
|
false,
|
|
);
|
|
});
|
|
});
|
|
|
|
describe("getStaticStringValue", () => {
|
|
const expectedResults = {
|
|
// string literals
|
|
"''": "",
|
|
"'foo'": "foo",
|
|
|
|
// boolean literals
|
|
false: "false",
|
|
true: "true",
|
|
|
|
// null literal
|
|
null: "null",
|
|
|
|
// number literals
|
|
0: "0",
|
|
"0.": "0",
|
|
".0": "0",
|
|
1: "1",
|
|
"1.": "1",
|
|
".1": "0.1",
|
|
12: "12",
|
|
".12": "0.12",
|
|
0.12: "0.12",
|
|
12.34: "12.34",
|
|
"12e3": "12000",
|
|
"12e-3": "0.012",
|
|
"12.34e5": "1234000",
|
|
"12.34e-5": "0.0001234",
|
|
"011": "9",
|
|
"081": "81",
|
|
"0b11": "3",
|
|
"0b011": "3",
|
|
"0o11": "9",
|
|
"0o011": "9",
|
|
"0x11": "17",
|
|
"0x011": "17",
|
|
|
|
// regexp literals
|
|
"/a/": "/a/",
|
|
"/a/i": "/a/i",
|
|
"/[0-9]/": "/[0-9]/",
|
|
"/(?<zero>0)/": "/(?<zero>0)/",
|
|
"/(?<zero>0)/s": "/(?<zero>0)/s",
|
|
"/(?<=a)b/s": "/(?<=a)b/s",
|
|
|
|
// simple template literals
|
|
"``": "",
|
|
"`foo`": "foo",
|
|
|
|
// unsupported
|
|
"`${''}`": null,
|
|
"`${0}`": null,
|
|
"tag``": null,
|
|
"-0": null,
|
|
"-1": null,
|
|
"1 + 2": null,
|
|
"[]": null,
|
|
"({})": null,
|
|
foo: null,
|
|
undefined: null,
|
|
this: null,
|
|
"(function () {})": null,
|
|
};
|
|
|
|
Object.keys(expectedResults).forEach(key => {
|
|
it(`should return ${expectedResults[key]} for ${key}`, () => {
|
|
const ast = espree.parse(key, { ecmaVersion: 2018 });
|
|
|
|
assert.strictEqual(
|
|
astUtils.getStaticStringValue(ast.body[0].expression),
|
|
expectedResults[key],
|
|
);
|
|
});
|
|
});
|
|
|
|
it("should return text of regex literal even if it's not supported natively.", () => {
|
|
const node = {
|
|
type: "Literal",
|
|
value: null,
|
|
regex: { pattern: "(?:)", flags: "u" },
|
|
};
|
|
const expectedText = "/(?:)/u";
|
|
|
|
assert.strictEqual(
|
|
astUtils.getStaticStringValue(node),
|
|
expectedText,
|
|
);
|
|
});
|
|
|
|
it("should return text of bigint literal even if it's not supported natively.", () => {
|
|
const node = {
|
|
type: "Literal",
|
|
value: null,
|
|
bigint: "100n",
|
|
};
|
|
const expectedText = "100n";
|
|
|
|
assert.strictEqual(
|
|
astUtils.getStaticStringValue(node),
|
|
expectedText,
|
|
);
|
|
});
|
|
});
|
|
|
|
describe("getStaticPropertyName", () => {
|
|
it("should return 'b' for `a.b`", () => {
|
|
const ast = espree.parse("a.b");
|
|
const node = ast.body[0].expression;
|
|
|
|
assert.strictEqual(astUtils.getStaticPropertyName(node), "b");
|
|
});
|
|
|
|
it("should return 'b' for `a['b']`", () => {
|
|
const ast = espree.parse("a['b']");
|
|
const node = ast.body[0].expression;
|
|
|
|
assert.strictEqual(astUtils.getStaticPropertyName(node), "b");
|
|
});
|
|
|
|
it("should return 'b' for `a[`b`]`", () => {
|
|
const ast = espree.parse("a[`b`]", { ecmaVersion: 6 });
|
|
const node = ast.body[0].expression;
|
|
|
|
assert.strictEqual(astUtils.getStaticPropertyName(node), "b");
|
|
});
|
|
|
|
it("should return '100' for `a[100]`", () => {
|
|
const ast = espree.parse("a[100]");
|
|
const node = ast.body[0].expression;
|
|
|
|
assert.strictEqual(astUtils.getStaticPropertyName(node), "100");
|
|
});
|
|
|
|
it("should return null for `a[b]`", () => {
|
|
const ast = espree.parse("a[b]");
|
|
const node = ast.body[0].expression;
|
|
|
|
assert.strictEqual(astUtils.getStaticPropertyName(node), null);
|
|
});
|
|
|
|
it("should return null for `a['a' + 'b']`", () => {
|
|
const ast = espree.parse("a['a' + 'b']");
|
|
const node = ast.body[0].expression;
|
|
|
|
assert.strictEqual(astUtils.getStaticPropertyName(node), null);
|
|
});
|
|
|
|
it("should return null for `a[tag`b`]`", () => {
|
|
const ast = espree.parse("a[tag`b`]", { ecmaVersion: 6 });
|
|
const node = ast.body[0].expression;
|
|
|
|
assert.strictEqual(astUtils.getStaticPropertyName(node), null);
|
|
});
|
|
|
|
it("should return null for `a[`${b}`]`", () => {
|
|
const ast = espree.parse("a[`${b}`]", { ecmaVersion: 6 });
|
|
const node = ast.body[0].expression;
|
|
|
|
assert.strictEqual(astUtils.getStaticPropertyName(node), null);
|
|
});
|
|
|
|
it("should return 'b' for `b: 1`", () => {
|
|
const ast = espree.parse("({b: 1})");
|
|
const node = ast.body[0].expression.properties[0];
|
|
|
|
assert.strictEqual(astUtils.getStaticPropertyName(node), "b");
|
|
});
|
|
|
|
it("should return 'b' for `b() {}`", () => {
|
|
const ast = espree.parse("({b() {}})", { ecmaVersion: 6 });
|
|
const node = ast.body[0].expression.properties[0];
|
|
|
|
assert.strictEqual(astUtils.getStaticPropertyName(node), "b");
|
|
});
|
|
|
|
it("should return 'b' for `get b() {}`", () => {
|
|
const ast = espree.parse("({get b() {}})", { ecmaVersion: 6 });
|
|
const node = ast.body[0].expression.properties[0];
|
|
|
|
assert.strictEqual(astUtils.getStaticPropertyName(node), "b");
|
|
});
|
|
|
|
it("should return 'b' for `['b']: 1`", () => {
|
|
const ast = espree.parse("({['b']: 1})", { ecmaVersion: 6 });
|
|
const node = ast.body[0].expression.properties[0];
|
|
|
|
assert.strictEqual(astUtils.getStaticPropertyName(node), "b");
|
|
});
|
|
|
|
it("should return 'b' for `['b']() {}`", () => {
|
|
const ast = espree.parse("({['b']() {}})", { ecmaVersion: 6 });
|
|
const node = ast.body[0].expression.properties[0];
|
|
|
|
assert.strictEqual(astUtils.getStaticPropertyName(node), "b");
|
|
});
|
|
|
|
it("should return 'b' for `[`b`]: 1`", () => {
|
|
const ast = espree.parse("({[`b`]: 1})", { ecmaVersion: 6 });
|
|
const node = ast.body[0].expression.properties[0];
|
|
|
|
assert.strictEqual(astUtils.getStaticPropertyName(node), "b");
|
|
});
|
|
|
|
it("should return '100' for` [100]: 1`", () => {
|
|
const ast = espree.parse("({[100]: 1})", { ecmaVersion: 6 });
|
|
const node = ast.body[0].expression.properties[0];
|
|
|
|
assert.strictEqual(astUtils.getStaticPropertyName(node), "100");
|
|
});
|
|
|
|
it("should return '/(?<zero>0)/' for `[/(?<zero>0)/]: 1`", () => {
|
|
const ast = espree.parse("({[/(?<zero>0)/]: 1})", {
|
|
ecmaVersion: 2018,
|
|
});
|
|
const node = ast.body[0].expression.properties[0];
|
|
|
|
assert.strictEqual(
|
|
astUtils.getStaticPropertyName(node),
|
|
"/(?<zero>0)/",
|
|
);
|
|
});
|
|
|
|
it("should return null for `[b]: 1`", () => {
|
|
const ast = espree.parse("({[b]: 1})", { ecmaVersion: 6 });
|
|
const node = ast.body[0].expression.properties[0];
|
|
|
|
assert.strictEqual(astUtils.getStaticPropertyName(node), null);
|
|
});
|
|
|
|
it("should return null for `['a' + 'b']: 1`", () => {
|
|
const ast = espree.parse("({['a' + 'b']: 1})", { ecmaVersion: 6 });
|
|
const node = ast.body[0].expression.properties[0];
|
|
|
|
assert.strictEqual(astUtils.getStaticPropertyName(node), null);
|
|
});
|
|
|
|
it("should return null for `[tag`b`]: 1`", () => {
|
|
const ast = espree.parse("({[tag`b`]: 1})", { ecmaVersion: 6 });
|
|
const node = ast.body[0].expression.properties[0];
|
|
|
|
assert.strictEqual(astUtils.getStaticPropertyName(node), null);
|
|
});
|
|
|
|
it("should return null for `[`${b}`]: 1`", () => {
|
|
const ast = espree.parse("({[`${b}`]: 1})", { ecmaVersion: 6 });
|
|
const node = ast.body[0].expression.properties[0];
|
|
|
|
assert.strictEqual(astUtils.getStaticPropertyName(node), null);
|
|
});
|
|
|
|
it("should return null for non member expressions", () => {
|
|
const ast = espree.parse("foo()");
|
|
|
|
assert.strictEqual(
|
|
astUtils.getStaticPropertyName(ast.body[0].expression),
|
|
null,
|
|
);
|
|
assert.strictEqual(
|
|
astUtils.getStaticPropertyName(ast.body[0]),
|
|
null,
|
|
);
|
|
assert.strictEqual(astUtils.getStaticPropertyName(ast.body), null);
|
|
assert.strictEqual(astUtils.getStaticPropertyName(ast), null);
|
|
assert.strictEqual(astUtils.getStaticPropertyName(null), null);
|
|
});
|
|
});
|
|
|
|
describe("getDirectivePrologue", () => {
|
|
it("should return empty array if node is not a Program, FunctionDeclaration, FunctionExpression, or ArrowFunctionExpression", () => {
|
|
const ast = espree.parse("if (a) { b(); }");
|
|
const node = ast.body[0];
|
|
|
|
assert.deepStrictEqual(astUtils.getDirectivePrologue(node), []);
|
|
});
|
|
|
|
it("should return empty array if node is a braceless ArrowFunctionExpression node", () => {
|
|
const ast = espree.parse("var foo = () => 'use strict';", {
|
|
ecmaVersion: 6,
|
|
});
|
|
const node = ast.body[0].declarations[0].init;
|
|
|
|
assert.deepStrictEqual(astUtils.getDirectivePrologue(node), []);
|
|
});
|
|
|
|
it("should return empty array if there are no directives in Program body", () => {
|
|
const ast = espree.parse("var foo;");
|
|
const node = ast;
|
|
|
|
assert.deepStrictEqual(astUtils.getDirectivePrologue(node), []);
|
|
});
|
|
|
|
it("should return empty array if there are no directives in FunctionDeclaration body", () => {
|
|
const ast = espree.parse("function foo() { return bar; }");
|
|
const node = ast.body[0];
|
|
|
|
assert.deepStrictEqual(astUtils.getDirectivePrologue(node), []);
|
|
});
|
|
|
|
it("should return empty array if there are no directives in FunctionExpression body", () => {
|
|
const ast = espree.parse("var foo = function() { return bar; }");
|
|
const node = ast.body[0].declarations[0].init;
|
|
|
|
assert.deepStrictEqual(astUtils.getDirectivePrologue(node), []);
|
|
});
|
|
|
|
it("should return empty array if there are no directives in ArrowFunctionExpression body", () => {
|
|
const ast = espree.parse("var foo = () => { return bar; };", {
|
|
ecmaVersion: 6,
|
|
});
|
|
const node = ast.body[0].declarations[0].init;
|
|
|
|
assert.deepStrictEqual(astUtils.getDirectivePrologue(node), []);
|
|
});
|
|
|
|
it("should return directives in Program body", () => {
|
|
const ast = espree.parse("'use strict'; 'use asm'; var foo;");
|
|
const result = astUtils.getDirectivePrologue(ast);
|
|
|
|
assert.strictEqual(result.length, 2);
|
|
assert.strictEqual(result[0].expression.value, "use strict");
|
|
assert.strictEqual(result[1].expression.value, "use asm");
|
|
});
|
|
|
|
it("should return directives in FunctionDeclaration body", () => {
|
|
const ast = espree.parse(
|
|
"function foo() { 'use strict'; 'use asm'; return bar; }",
|
|
);
|
|
const result = astUtils.getDirectivePrologue(ast.body[0]);
|
|
|
|
assert.strictEqual(result.length, 2);
|
|
assert.strictEqual(result[0].expression.value, "use strict");
|
|
assert.strictEqual(result[1].expression.value, "use asm");
|
|
});
|
|
|
|
it("should return directives in FunctionExpression body", () => {
|
|
const ast = espree.parse(
|
|
"var foo = function() { 'use strict'; 'use asm'; return bar; }",
|
|
);
|
|
const result = astUtils.getDirectivePrologue(
|
|
ast.body[0].declarations[0].init,
|
|
);
|
|
|
|
assert.strictEqual(result.length, 2);
|
|
assert.strictEqual(result[0].expression.value, "use strict");
|
|
assert.strictEqual(result[1].expression.value, "use asm");
|
|
});
|
|
|
|
it("should return directives in ArrowFunctionExpression body", () => {
|
|
const ast = espree.parse(
|
|
"var foo = () => { 'use strict'; 'use asm'; return bar; };",
|
|
{ ecmaVersion: 6 },
|
|
);
|
|
const result = astUtils.getDirectivePrologue(
|
|
ast.body[0].declarations[0].init,
|
|
);
|
|
|
|
assert.strictEqual(result.length, 2);
|
|
assert.strictEqual(result[0].expression.value, "use strict");
|
|
assert.strictEqual(result[1].expression.value, "use asm");
|
|
});
|
|
});
|
|
|
|
{
|
|
const expectedResults = {
|
|
0: true,
|
|
5: true,
|
|
8: true,
|
|
9: true,
|
|
50: true,
|
|
123: true,
|
|
"1_0": true,
|
|
"1_0_1": true,
|
|
"12_3": true,
|
|
"5_000": true,
|
|
"500_0": true,
|
|
"500_00": true,
|
|
"5_000_00": true,
|
|
"1_234_56": true,
|
|
"1_2_3_4": true,
|
|
"11_22_33_44": true,
|
|
"1_23_4_56_7_89": true,
|
|
"08": true,
|
|
"09": true,
|
|
"008": true,
|
|
"0192": true,
|
|
"0180": true,
|
|
"090": true,
|
|
"088": true,
|
|
"099": true,
|
|
"089": true,
|
|
"0098": true,
|
|
"01892": true,
|
|
"08192": true,
|
|
"01829": true,
|
|
"018290": true,
|
|
"0.": false,
|
|
"5.": false,
|
|
".0": false,
|
|
".5": false,
|
|
"5.0": false,
|
|
"5.00_00": false,
|
|
"5.0_1": false,
|
|
"0.1_0": false,
|
|
"5.1_2": false,
|
|
"1.23_45": false,
|
|
".0_1": false,
|
|
".12_34": false,
|
|
"05": false,
|
|
"0123": false,
|
|
"076543210": false,
|
|
"08.": false,
|
|
"0x5": false,
|
|
"0b11_01": false,
|
|
"0o0_1": false,
|
|
"0x56_78": false,
|
|
"5e0": false,
|
|
"0.e1": false,
|
|
".0e1": false,
|
|
"5e0_1": false,
|
|
"5e1_000": false,
|
|
"5e12_34": false,
|
|
"5e-0": false,
|
|
"5e-0_1": false,
|
|
"5e-1_2": false,
|
|
"1_2.3_4e5_6": false,
|
|
"1n": false,
|
|
"1_2n": false,
|
|
"1_000n": false,
|
|
"'5'": false,
|
|
};
|
|
|
|
const ecmaVersion = espree.latestEcmaVersion;
|
|
|
|
describe("isDecimalInteger", () => {
|
|
Object.keys(expectedResults).forEach(key => {
|
|
it(`should return ${expectedResults[key]} for ${key}`, () => {
|
|
assert.strictEqual(
|
|
astUtils.isDecimalInteger(
|
|
espree.parse(key, { ecmaVersion }).body[0]
|
|
.expression,
|
|
),
|
|
expectedResults[key],
|
|
);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("isDecimalIntegerNumericToken", () => {
|
|
Object.keys(expectedResults).forEach(key => {
|
|
it(`should return ${expectedResults[key]} for ${key}`, () => {
|
|
assert.strictEqual(
|
|
astUtils.isDecimalIntegerNumericToken(
|
|
espree.tokenize(key, { ecmaVersion })[0],
|
|
),
|
|
expectedResults[key],
|
|
);
|
|
});
|
|
});
|
|
});
|
|
}
|
|
|
|
describe("getFunctionNameWithKind", () => {
|
|
const expectedResults = {
|
|
"function foo() {}": "function 'foo'",
|
|
"(function foo() {})": "function 'foo'",
|
|
"(function() {})": "function",
|
|
"function* foo() {}": "generator function 'foo'",
|
|
"(function* foo() {})": "generator function 'foo'",
|
|
"(function*() {})": "generator function",
|
|
"() => {}": "arrow function",
|
|
"async () => {}": "async arrow function",
|
|
"({ foo: function foo() {} })": "method 'foo'",
|
|
"({ foo: function() {} })": "method 'foo'",
|
|
"({ '': function() {} })": "method ''",
|
|
"({ ['foo']: function() {} })": "method 'foo'",
|
|
"({ ['']: function() {} })": "method ''",
|
|
"({ [foo]: function() {} })": "method",
|
|
"({ foo() {} })": "method 'foo'",
|
|
"({ foo: function* foo() {} })": "generator method 'foo'",
|
|
"({ foo: function*() {} })": "generator method 'foo'",
|
|
"({ ['foo']: function*() {} })": "generator method 'foo'",
|
|
"({ [foo]: function*() {} })": "generator method",
|
|
"({ *foo() {} })": "generator method 'foo'",
|
|
"({ foo: async function foo() {} })": "async method 'foo'",
|
|
"({ foo: async function() {} })": "async method 'foo'",
|
|
"({ ['foo']: async function() {} })": "async method 'foo'",
|
|
"({ [foo]: async function() {} })": "async method",
|
|
"({ async foo() {} })": "async method 'foo'",
|
|
"({ get foo() {} })": "getter 'foo'",
|
|
"({ set foo(a) {} })": "setter 'foo'",
|
|
"class A { constructor() {} }": "constructor",
|
|
"class A { foo() {} }": "method 'foo'",
|
|
"class A { *foo() {} }": "generator method 'foo'",
|
|
"class A { async foo() {} }": "async method 'foo'",
|
|
"class A { ['foo']() {} }": "method 'foo'",
|
|
"class A { *['foo']() {} }": "generator method 'foo'",
|
|
"class A { async ['foo']() {} }": "async method 'foo'",
|
|
"class A { [foo]() {} }": "method",
|
|
"class A { *[foo]() {} }": "generator method",
|
|
"class A { async [foo]() {} }": "async method",
|
|
"class A { get foo() {} }": "getter 'foo'",
|
|
"class A { set foo(a) {} }": "setter 'foo'",
|
|
"class A { static foo() {} }": "static method 'foo'",
|
|
"class A { static *foo() {} }": "static generator method 'foo'",
|
|
"class A { static async foo() {} }": "static async method 'foo'",
|
|
"class A { static get foo() {} }": "static getter 'foo'",
|
|
"class A { static set foo(a) {} }": "static setter 'foo'",
|
|
"class A { foo = () => {}; }": "method 'foo'",
|
|
"class A { foo = function() {}; }": "method 'foo'",
|
|
"class A { foo = function bar() {}; }": "method 'foo'",
|
|
"class A { static foo = () => {}; }": "static method 'foo'",
|
|
"class A { '#foo' = () => {}; }": "method '#foo'",
|
|
"class A { #foo = () => {}; }": "private method #foo",
|
|
"class A { static #foo = () => {}; }": "static private method #foo",
|
|
"class A { '#foo'() {} }": "method '#foo'",
|
|
"class A { #foo() {} }": "private method #foo",
|
|
"class A { static #foo() {} }": "static private method #foo",
|
|
};
|
|
|
|
Object.keys(expectedResults).forEach(key => {
|
|
it(`should return "${expectedResults[key]}" for "${key}".`, () => {
|
|
linter.verify(key, {
|
|
plugins: {
|
|
test: {
|
|
rules: {
|
|
checker: {
|
|
create: mustCall(() => ({
|
|
":function": mustCall(node => {
|
|
assert.strictEqual(
|
|
astUtils.getFunctionNameWithKind(
|
|
node,
|
|
),
|
|
expectedResults[key],
|
|
);
|
|
}),
|
|
})),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
rules: { "test/checker": "error" },
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("getFunctionHeadLoc", () => {
|
|
const expectedResults = {
|
|
"function foo() {}": [0, 12],
|
|
"(function foo() {})": [1, 13],
|
|
"(function() {})": [1, 9],
|
|
"function* foo() {}": [0, 13],
|
|
"(function* foo() {})": [1, 14],
|
|
"(function*() {})": [1, 10],
|
|
"() => {}": [3, 5],
|
|
"async () => {}": [9, 11],
|
|
"({ foo: function foo() {} })": [3, 20],
|
|
"({ foo: function() {} })": [3, 16],
|
|
"({ ['foo']: function() {} })": [3, 20],
|
|
"({ [foo]: function() {} })": [3, 18],
|
|
"({ foo() {} })": [3, 6],
|
|
"({ foo: function* foo() {} })": [3, 21],
|
|
"({ foo: function*() {} })": [3, 17],
|
|
"({ ['foo']: function*() {} })": [3, 21],
|
|
"({ [foo]: function*() {} })": [3, 19],
|
|
"({ *foo() {} })": [3, 7],
|
|
"({ foo: async function foo() {} })": [3, 26],
|
|
"({ foo: async function() {} })": [3, 22],
|
|
"({ ['foo']: async function() {} })": [3, 26],
|
|
"({ [foo]: async function() {} })": [3, 24],
|
|
"({ async foo() {} })": [3, 12],
|
|
"({ get foo() {} })": [3, 10],
|
|
"({ set foo(a) {} })": [3, 10],
|
|
"class A { constructor() {} }": [10, 21],
|
|
"class A { foo() {} }": [10, 13],
|
|
"class A { *foo() {} }": [10, 14],
|
|
"class A { async foo() {} }": [10, 19],
|
|
"class A { ['foo']() {} }": [10, 17],
|
|
"class A { *['foo']() {} }": [10, 18],
|
|
"class A { async ['foo']() {} }": [10, 23],
|
|
"class A { [foo]() {} }": [10, 15],
|
|
"class A { *[foo]() {} }": [10, 16],
|
|
"class A { async [foo]() {} }": [10, 21],
|
|
"class A { get foo() {} }": [10, 17],
|
|
"class A { set foo(a) {} }": [10, 17],
|
|
"class A { static foo() {} }": [10, 20],
|
|
"class A { static *foo() {} }": [10, 21],
|
|
"class A { static async foo() {} }": [10, 26],
|
|
"class A { static get foo() {} }": [10, 24],
|
|
"class A { static set foo(a) {} }": [10, 24],
|
|
"class A { foo = function() {}; }": [10, 24],
|
|
"class A { foo = function bar() {}; }": [10, 28],
|
|
"class A { static foo = function() {}; }": [10, 31],
|
|
"class A { foo = () => {}; }": [10, 16],
|
|
"class A { foo = arg => {}; }": [10, 16],
|
|
};
|
|
|
|
Object.keys(expectedResults).forEach(key => {
|
|
const expectedLoc = {
|
|
start: {
|
|
line: 1,
|
|
column: expectedResults[key][0],
|
|
},
|
|
end: {
|
|
line: 1,
|
|
column: expectedResults[key][1],
|
|
},
|
|
};
|
|
|
|
it(`should return "${JSON.stringify(expectedLoc)}" for "${key}".`, () => {
|
|
linter.verify(
|
|
key,
|
|
{
|
|
plugins: {
|
|
test: {
|
|
rules: {
|
|
checker: {
|
|
create: mustCall(() => ({
|
|
":function": mustCall(node => {
|
|
assert.deepStrictEqual(
|
|
astUtils.getFunctionHeadLoc(
|
|
node,
|
|
linter.getSourceCode(),
|
|
),
|
|
expectedLoc,
|
|
);
|
|
}),
|
|
})),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
rules: { "test/checker": "error" },
|
|
},
|
|
"test.js",
|
|
);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("isEmptyBlock", () => {
|
|
const expectedResults = {
|
|
"{}": true,
|
|
"{ a }": false,
|
|
a: false,
|
|
};
|
|
|
|
Object.keys(expectedResults).forEach(key => {
|
|
it(`should return ${expectedResults[key]} for ${key}`, () => {
|
|
const ast = espree.parse(key);
|
|
|
|
assert.strictEqual(
|
|
astUtils.isEmptyBlock(ast.body[0]),
|
|
expectedResults[key],
|
|
);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("isEmptyFunction", () => {
|
|
const expectedResults = {
|
|
"(function foo() {})": true,
|
|
"(function foo() { a })": false,
|
|
"(a) => {}": true,
|
|
"(a) => { a }": false,
|
|
"(a) => a": false,
|
|
};
|
|
|
|
Object.keys(expectedResults).forEach(key => {
|
|
it(`should return ${expectedResults[key]} for ${key}`, () => {
|
|
const ast = espree.parse(key, { ecmaVersion: 6 });
|
|
|
|
assert.strictEqual(
|
|
astUtils.isEmptyFunction(ast.body[0].expression),
|
|
expectedResults[key],
|
|
);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("getNextLocation", () => {
|
|
const expectedResults = {
|
|
"": [[1, 0], null],
|
|
"\n": [[1, 0], [2, 0], null],
|
|
"\r\n": [[1, 0], [2, 0], null],
|
|
foo: [[1, 0], [1, 1], [1, 2], [1, 3], null],
|
|
"foo\n": [[1, 0], [1, 1], [1, 2], [1, 3], [2, 0], null],
|
|
"foo\r\n": [[1, 0], [1, 1], [1, 2], [1, 3], [2, 0], null],
|
|
"foo;\n": [[1, 0], [1, 1], [1, 2], [1, 3], [1, 4], [2, 0], null],
|
|
"a\nb": [[1, 0], [1, 1], [2, 0], [2, 1], null],
|
|
"a\nb\n": [[1, 0], [1, 1], [2, 0], [2, 1], [3, 0], null],
|
|
"a\r\nb\r\n": [[1, 0], [1, 1], [2, 0], [2, 1], [3, 0], null],
|
|
"a\nb\r\n": [[1, 0], [1, 1], [2, 0], [2, 1], [3, 0], null],
|
|
"a\n\n": [[1, 0], [1, 1], [2, 0], [3, 0], null],
|
|
"a\r\n\r\n": [[1, 0], [1, 1], [2, 0], [3, 0], null],
|
|
"\n\r\n\n\r\n": [[1, 0], [2, 0], [3, 0], [4, 0], [5, 0], null],
|
|
"ab\u2029c": [[1, 0], [1, 1], [1, 2], [2, 0], [2, 1], null],
|
|
"ab\ncde\n": [
|
|
[1, 0],
|
|
[1, 1],
|
|
[1, 2],
|
|
[2, 0],
|
|
[2, 1],
|
|
[2, 2],
|
|
[2, 3],
|
|
[3, 0],
|
|
null,
|
|
],
|
|
"a ": [[1, 0], [1, 1], [1, 2], null],
|
|
"a\t": [[1, 0], [1, 1], [1, 2], null],
|
|
"a \n": [[1, 0], [1, 1], [1, 2], [2, 0], null],
|
|
};
|
|
|
|
Object.keys(expectedResults).forEach(code => {
|
|
it(`should return expected locations for "${code}".`, () => {
|
|
const ast = espree.parse(code, ESPREE_CONFIG);
|
|
const sourceCode = new SourceCode(code, ast);
|
|
const locations = expectedResults[code];
|
|
|
|
for (let i = 0; i < locations.length - 1; i++) {
|
|
const location = {
|
|
line: locations[i][0],
|
|
column: locations[i][1],
|
|
};
|
|
const expectedNextLocation = locations[i + 1]
|
|
? {
|
|
line: locations[i + 1][0],
|
|
column: locations[i + 1][1],
|
|
}
|
|
: null;
|
|
|
|
assert.deepStrictEqual(
|
|
astUtils.getNextLocation(sourceCode, location),
|
|
expectedNextLocation,
|
|
);
|
|
}
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("getParenthesisedText", () => {
|
|
const expectedResults = {
|
|
"(((foo))); bar;": "(((foo)))",
|
|
"(/* comment */(((foo.bar())))); baz();":
|
|
"(/* comment */(((foo.bar()))))",
|
|
"(foo, bar)": "(foo, bar)",
|
|
};
|
|
|
|
Object.keys(expectedResults).forEach(key => {
|
|
it(`should return ${expectedResults[key]} for ${key}`, () => {
|
|
const ast = espree.parse(key, {
|
|
tokens: true,
|
|
comment: true,
|
|
range: true,
|
|
loc: true,
|
|
});
|
|
const sourceCode = new SourceCode(key, ast);
|
|
|
|
assert.strictEqual(
|
|
astUtils.getParenthesisedText(
|
|
sourceCode,
|
|
ast.body[0].expression,
|
|
),
|
|
expectedResults[key],
|
|
);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("couldBeError", () => {
|
|
const EXPECTED_RESULTS = {
|
|
5: false,
|
|
null: false,
|
|
true: false,
|
|
"'foo'": false,
|
|
"`foo`": false,
|
|
foo: true,
|
|
"new Foo": true,
|
|
"Foo()": true,
|
|
"foo`bar`": true,
|
|
"foo.bar": true,
|
|
"(foo = bar)": true,
|
|
"(foo = 1)": false,
|
|
"(foo += bar)": false,
|
|
"(foo -= bar)": false,
|
|
"(foo *= bar)": false,
|
|
"(foo /= bar)": false,
|
|
"(foo %= bar)": false,
|
|
"(foo **= bar)": false,
|
|
"(foo <<= bar)": false,
|
|
"(foo >>= bar)": false,
|
|
"(foo >>>= bar)": false,
|
|
"(foo &= bar)": false,
|
|
"(foo |= bar)": false,
|
|
"(foo ^= bar)": false,
|
|
"(1, 2, 3)": false,
|
|
"(foo, 2, 3)": false,
|
|
"(1, 2, foo)": true,
|
|
"1 && 2": false,
|
|
"1 && foo": true,
|
|
"foo && 2": false,
|
|
|
|
// A future improvement could detect the left side as statically falsy, making this false.
|
|
"false && foo": true,
|
|
"foo &&= 2": false,
|
|
"foo.bar ??= 2": true,
|
|
"foo[bar] ||= 2": true,
|
|
"foo ? 1 : 2": false,
|
|
"foo ? bar : 2": true,
|
|
"foo ? 1 : bar": true,
|
|
"[1, 2, 3]": false,
|
|
"({ foo: 1 })": false,
|
|
};
|
|
|
|
Object.keys(EXPECTED_RESULTS).forEach(key => {
|
|
it(`returns ${EXPECTED_RESULTS[key]} for ${key}`, () => {
|
|
const ast = espree.parse(key, { ecmaVersion: 2021 });
|
|
|
|
assert.strictEqual(
|
|
astUtils.couldBeError(ast.body[0].expression),
|
|
EXPECTED_RESULTS[key],
|
|
);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("isArrowToken", () => {
|
|
const code = "() => 5";
|
|
const tokens = espree.parse(code, {
|
|
ecmaVersion: 6,
|
|
tokens: true,
|
|
}).tokens;
|
|
const expected = [false, false, true, false];
|
|
|
|
tokens.forEach((token, index) => {
|
|
it(`should return ${expected[index]} for '${token.value}'.`, () => {
|
|
assert.strictEqual(
|
|
astUtils.isArrowToken(token),
|
|
expected[index],
|
|
);
|
|
});
|
|
});
|
|
});
|
|
|
|
{
|
|
const code = "if (obj && foo) { obj[foo](); }";
|
|
const tokens = espree.parse(code, {
|
|
ecmaVersion: 6,
|
|
tokens: true,
|
|
}).tokens;
|
|
const expected = [
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
true,
|
|
];
|
|
|
|
describe("isClosingBraceToken", () => {
|
|
tokens.forEach((token, index) => {
|
|
it(`should return ${expected[index]} for '${token.value}'.`, () => {
|
|
assert.strictEqual(
|
|
astUtils.isClosingBraceToken(token),
|
|
expected[index],
|
|
);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("isNotClosingBraceToken", () => {
|
|
tokens.forEach((token, index) => {
|
|
it(`should return ${expected[index]} for '${token.value}'.`, () => {
|
|
assert.strictEqual(
|
|
astUtils.isNotClosingBraceToken(token),
|
|
!expected[index],
|
|
);
|
|
});
|
|
});
|
|
});
|
|
}
|
|
|
|
{
|
|
const code = "if (obj && foo) { obj[foo](); }";
|
|
const tokens = espree.parse(code, {
|
|
ecmaVersion: 6,
|
|
tokens: true,
|
|
}).tokens;
|
|
const expected = [
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
true,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
];
|
|
|
|
describe("isClosingBracketToken", () => {
|
|
tokens.forEach((token, index) => {
|
|
it(`should return ${expected[index]} for '${token.value}'.`, () => {
|
|
assert.strictEqual(
|
|
astUtils.isClosingBracketToken(token),
|
|
expected[index],
|
|
);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("isNotClosingBracketToken", () => {
|
|
tokens.forEach((token, index) => {
|
|
it(`should return ${expected[index]} for '${token.value}'.`, () => {
|
|
assert.strictEqual(
|
|
astUtils.isNotClosingBracketToken(token),
|
|
!expected[index],
|
|
);
|
|
});
|
|
});
|
|
});
|
|
}
|
|
|
|
{
|
|
const code = "if (obj && foo) { obj[foo](); }";
|
|
const tokens = espree.parse(code, {
|
|
ecmaVersion: 6,
|
|
tokens: true,
|
|
}).tokens;
|
|
const expected = [
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
true,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
true,
|
|
false,
|
|
false,
|
|
];
|
|
|
|
describe("isClosingParenToken", () => {
|
|
tokens.forEach((token, index) => {
|
|
it(`should return ${expected[index]} for '${token.value}'.`, () => {
|
|
assert.strictEqual(
|
|
astUtils.isClosingParenToken(token),
|
|
expected[index],
|
|
);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("isNotClosingParenToken", () => {
|
|
tokens.forEach((token, index) => {
|
|
it(`should return ${expected[index]} for '${token.value}'.`, () => {
|
|
assert.strictEqual(
|
|
astUtils.isNotClosingParenToken(token),
|
|
!expected[index],
|
|
);
|
|
});
|
|
});
|
|
});
|
|
}
|
|
|
|
{
|
|
const code = "const obj = {foo: 1, bar: 2};";
|
|
const tokens = espree.parse(code, {
|
|
ecmaVersion: 6,
|
|
tokens: true,
|
|
}).tokens;
|
|
const expected = [
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
true,
|
|
false,
|
|
false,
|
|
false,
|
|
true,
|
|
false,
|
|
false,
|
|
false,
|
|
];
|
|
|
|
describe("isColonToken", () => {
|
|
tokens.forEach((token, index) => {
|
|
it(`should return ${expected[index]} for '${token.value}'.`, () => {
|
|
assert.strictEqual(
|
|
astUtils.isColonToken(token),
|
|
expected[index],
|
|
);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("isNotColonToken", () => {
|
|
tokens.forEach((token, index) => {
|
|
it(`should return ${expected[index]} for '${token.value}'.`, () => {
|
|
assert.strictEqual(
|
|
astUtils.isNotColonToken(token),
|
|
!expected[index],
|
|
);
|
|
});
|
|
});
|
|
});
|
|
}
|
|
|
|
{
|
|
const code = "const obj = {foo: 1, bar: 2};";
|
|
const tokens = espree.parse(code, {
|
|
ecmaVersion: 6,
|
|
tokens: true,
|
|
}).tokens;
|
|
const expected = [
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
true,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
];
|
|
|
|
describe("isCommaToken", () => {
|
|
tokens.forEach((token, index) => {
|
|
it(`should return ${expected[index]} for '${token.value}'.`, () => {
|
|
assert.strictEqual(
|
|
astUtils.isCommaToken(token),
|
|
expected[index],
|
|
);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("isNotCommaToken", () => {
|
|
tokens.forEach((token, index) => {
|
|
it(`should return ${expected[index]} for '${token.value}'.`, () => {
|
|
assert.strictEqual(
|
|
astUtils.isNotCommaToken(token),
|
|
!expected[index],
|
|
);
|
|
});
|
|
});
|
|
});
|
|
}
|
|
|
|
{
|
|
const code = "const obj = {foo: 1.5, bar: a.b};";
|
|
const tokens = espree.parse(code, {
|
|
ecmaVersion: 6,
|
|
tokens: true,
|
|
}).tokens;
|
|
const expected = [
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
true,
|
|
false,
|
|
false,
|
|
false,
|
|
];
|
|
|
|
describe("isDotToken", () => {
|
|
tokens.forEach((token, index) => {
|
|
it(`should return ${expected[index]} for '${token.value}'.`, () => {
|
|
assert.strictEqual(
|
|
astUtils.isDotToken(token),
|
|
expected[index],
|
|
);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("isNotDotToken", () => {
|
|
tokens.forEach((token, index) => {
|
|
it(`should return ${!expected[index]} for '${token.value}'.`, () => {
|
|
assert.strictEqual(
|
|
astUtils.isNotDotToken(token),
|
|
!expected[index],
|
|
);
|
|
});
|
|
});
|
|
});
|
|
}
|
|
|
|
describe("isCommentToken", () => {
|
|
const code = "const obj = /*block*/ {foo: 1, bar: 2}; //line";
|
|
const ast = espree.parse(code, {
|
|
ecmaVersion: 6,
|
|
tokens: true,
|
|
comment: true,
|
|
});
|
|
|
|
ast.tokens.forEach(token => {
|
|
it(`should return false for '${token.value}'.`, () => {
|
|
assert.strictEqual(astUtils.isCommentToken(token), false);
|
|
});
|
|
});
|
|
ast.comments.forEach(comment => {
|
|
it(`should return true for '${comment.value}'.`, () => {
|
|
assert.strictEqual(astUtils.isCommentToken(comment), true);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("isKeywordToken", () => {
|
|
const code = "const obj = {foo: 1, bar: 2};";
|
|
const tokens = espree.parse(code, {
|
|
ecmaVersion: 6,
|
|
tokens: true,
|
|
}).tokens;
|
|
const expected = [
|
|
true,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
];
|
|
|
|
tokens.forEach((token, index) => {
|
|
it(`should return ${expected[index]} for '${token.value}'.`, () => {
|
|
assert.strictEqual(
|
|
astUtils.isKeywordToken(token),
|
|
expected[index],
|
|
);
|
|
});
|
|
});
|
|
});
|
|
|
|
{
|
|
const code = "if (obj && foo) { obj[foo](); }";
|
|
const tokens = espree.parse(code, {
|
|
ecmaVersion: 6,
|
|
tokens: true,
|
|
}).tokens;
|
|
const expected = [
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
true,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
];
|
|
|
|
describe("isOpeningBraceToken", () => {
|
|
tokens.forEach((token, index) => {
|
|
it(`should return ${expected[index]} for '${token.value}'.`, () => {
|
|
assert.strictEqual(
|
|
astUtils.isOpeningBraceToken(token),
|
|
expected[index],
|
|
);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("isNotOpeningBraceToken", () => {
|
|
tokens.forEach((token, index) => {
|
|
it(`should return ${expected[index]} for '${token.value}'.`, () => {
|
|
assert.strictEqual(
|
|
astUtils.isNotOpeningBraceToken(token),
|
|
!expected[index],
|
|
);
|
|
});
|
|
});
|
|
});
|
|
}
|
|
|
|
{
|
|
const code = "if (obj && foo) { obj[foo](); }";
|
|
const tokens = espree.parse(code, {
|
|
ecmaVersion: 6,
|
|
tokens: true,
|
|
}).tokens;
|
|
const expected = [
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
true,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
];
|
|
|
|
describe("isOpeningBracketToken", () => {
|
|
tokens.forEach((token, index) => {
|
|
it(`should return ${expected[index]} for '${token.value}'.`, () => {
|
|
assert.strictEqual(
|
|
astUtils.isOpeningBracketToken(token),
|
|
expected[index],
|
|
);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("isNotOpeningBracketToken", () => {
|
|
tokens.forEach((token, index) => {
|
|
it(`should return ${expected[index]} for '${token.value}'.`, () => {
|
|
assert.strictEqual(
|
|
astUtils.isNotOpeningBracketToken(token),
|
|
!expected[index],
|
|
);
|
|
});
|
|
});
|
|
});
|
|
}
|
|
|
|
{
|
|
const code = "if (obj && foo) { obj[foo](); }";
|
|
const tokens = espree.parse(code, {
|
|
ecmaVersion: 6,
|
|
tokens: true,
|
|
}).tokens;
|
|
const expected = [
|
|
false,
|
|
true,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
true,
|
|
false,
|
|
false,
|
|
false,
|
|
];
|
|
|
|
describe("isOpeningParenToken", () => {
|
|
tokens.forEach((token, index) => {
|
|
it(`should return ${expected[index]} for '${token.value}'.`, () => {
|
|
assert.strictEqual(
|
|
astUtils.isOpeningParenToken(token),
|
|
expected[index],
|
|
);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("isNotOpeningParenToken", () => {
|
|
tokens.forEach((token, index) => {
|
|
it(`should return ${expected[index]} for '${token.value}'.`, () => {
|
|
assert.strictEqual(
|
|
astUtils.isNotOpeningParenToken(token),
|
|
!expected[index],
|
|
);
|
|
});
|
|
});
|
|
});
|
|
}
|
|
|
|
{
|
|
const code = "if (obj && foo) { obj[foo](); }";
|
|
const tokens = espree.parse(code, {
|
|
ecmaVersion: 6,
|
|
tokens: true,
|
|
}).tokens;
|
|
const expected = [
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
false,
|
|
true,
|
|
false,
|
|
];
|
|
|
|
describe("isSemicolonToken", () => {
|
|
tokens.forEach((token, index) => {
|
|
it(`should return ${expected[index]} for '${token.value}'.`, () => {
|
|
assert.strictEqual(
|
|
astUtils.isSemicolonToken(token),
|
|
expected[index],
|
|
);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("isNotSemicolonToken", () => {
|
|
tokens.forEach((token, index) => {
|
|
it(`should return ${expected[index]} for '${token.value}'.`, () => {
|
|
assert.strictEqual(
|
|
astUtils.isNotSemicolonToken(token),
|
|
!expected[index],
|
|
);
|
|
});
|
|
});
|
|
});
|
|
}
|
|
|
|
describe("isNullLiteral", () => {
|
|
const EXPECTED_RESULTS = {
|
|
null: true,
|
|
"/abc/u": false,
|
|
5: false,
|
|
true: false,
|
|
"'null'": false,
|
|
foo: false,
|
|
};
|
|
|
|
Object.keys(EXPECTED_RESULTS).forEach(key => {
|
|
it(`returns ${EXPECTED_RESULTS[key]} for ${key}`, () => {
|
|
const ast = espree.parse(key, { ecmaVersion: 6 });
|
|
|
|
assert.strictEqual(
|
|
astUtils.isNullLiteral(ast.body[0].expression),
|
|
EXPECTED_RESULTS[key],
|
|
);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("createGlobalLinebreakMatcher", () => {
|
|
it("returns a regular expression with the g flag", () => {
|
|
assert.instanceOf(astUtils.createGlobalLinebreakMatcher(), RegExp);
|
|
assert(
|
|
astUtils
|
|
.createGlobalLinebreakMatcher()
|
|
.toString()
|
|
.endsWith("/gu"),
|
|
);
|
|
});
|
|
it("returns unique objects on each call", () => {
|
|
const firstObject = astUtils.createGlobalLinebreakMatcher();
|
|
const secondObject = astUtils.createGlobalLinebreakMatcher();
|
|
|
|
assert.notStrictEqual(firstObject, secondObject);
|
|
});
|
|
describe("correctly matches linebreaks", () => {
|
|
const LINE_COUNTS = {
|
|
foo: 1,
|
|
"foo\rbar": 2,
|
|
"foo\n": 2,
|
|
"foo\nbar": 2,
|
|
"foo\r\nbar": 2,
|
|
"foo\r\u2028bar": 3,
|
|
"foo\u2029bar": 2,
|
|
};
|
|
|
|
Object.keys(LINE_COUNTS).forEach(text => {
|
|
it(text, () => {
|
|
assert.strictEqual(
|
|
text.split(astUtils.createGlobalLinebreakMatcher())
|
|
.length,
|
|
LINE_COUNTS[text],
|
|
);
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("canTokensBeAdjacent", () => {
|
|
const CASES = new Map([
|
|
[["foo", "bar"], false],
|
|
[[";foo", "bar"], false],
|
|
[[";", "bar"], true],
|
|
[[")", "bar"], true],
|
|
[["foo0", "bar"], false],
|
|
[["foo;", "bar"], true],
|
|
[["foo", "0"], false],
|
|
[["of", ".2"], true],
|
|
[["2", ".2"], false],
|
|
[["of", "'foo'"], true],
|
|
[["foo", "`bar`"], true],
|
|
[["`foo`", "in"], true],
|
|
[["of", "0.2"], false],
|
|
[["of", "0."], false],
|
|
[[".2", "foo"], false],
|
|
[["2.", "foo"], false],
|
|
[["+", "-"], true],
|
|
[["++", "-"], true],
|
|
[["+", "--"], true],
|
|
[["++", "--"], true],
|
|
[["-", "+"], true],
|
|
[["--", "+"], true],
|
|
[["-", "++"], true],
|
|
[["--", "++"], true],
|
|
[["+", "+"], false],
|
|
[["-", "-"], false],
|
|
[["++", "+"], false],
|
|
[["--", "-"], false],
|
|
[["+", "++"], false],
|
|
[["-", "--"], false],
|
|
[["a/", "b"], true],
|
|
[["a/", "+b"], true],
|
|
[["a+", "/^regex$/"], true],
|
|
[["a/", "/^regex$/"], false],
|
|
[["a+", "/**/"], true],
|
|
[["a+", "/**/b"], true],
|
|
[["//", "a"], false],
|
|
[["a/", "/**/b"], false],
|
|
[["a+", "//"], true],
|
|
[["a+", "//\nb"], true],
|
|
[["a/", "//\nb"], false],
|
|
[["/**/", "b"], true],
|
|
[["a/**/", "b"], true],
|
|
[["/**/a", "b"], false],
|
|
[["a", "/**/b"], true],
|
|
[["a", "b/**/"], false],
|
|
[["a", "//\nb"], true],
|
|
[["a", "b//"], false],
|
|
[["#!/usr/bin/env node", "("], false],
|
|
[["123invalidtoken", "("], false],
|
|
[["(", "123invalidtoken"], false],
|
|
[["(", "1n"], true],
|
|
[["1n", "+"], true],
|
|
[["1n", "in"], false],
|
|
[["return", "#x"], true],
|
|
[["yield", "#x"], true],
|
|
[["get", "#x"], true],
|
|
]);
|
|
|
|
CASES.forEach((expectedResult, tokenStrings) => {
|
|
it(tokenStrings.join(", "), () => {
|
|
assert.strictEqual(
|
|
astUtils.canTokensBeAdjacent(
|
|
tokenStrings[0],
|
|
tokenStrings[1],
|
|
),
|
|
expectedResult,
|
|
);
|
|
});
|
|
});
|
|
|
|
it("#!/usr/bin/env node, (", () => {
|
|
assert.strictEqual(
|
|
astUtils.canTokensBeAdjacent(
|
|
{ type: "Shebang", value: "#!/usr/bin/env node" },
|
|
{ type: "Punctuator", value: "(" },
|
|
),
|
|
false,
|
|
);
|
|
});
|
|
});
|
|
|
|
describe("equalTokens", () => {
|
|
it("should return true if tokens are equal", () => {
|
|
const code = "a=0;a=0;";
|
|
const ast = espree.parse(code, ESPREE_CONFIG);
|
|
const sourceCode = new SourceCode(code, ast);
|
|
|
|
assert.strictEqual(
|
|
astUtils.equalTokens(ast.body[0], ast.body[1], sourceCode),
|
|
true,
|
|
);
|
|
});
|
|
|
|
it("should return false if tokens are not equal", () => {
|
|
const code = "a=0;a=1;";
|
|
const ast = espree.parse(code, ESPREE_CONFIG);
|
|
const sourceCode = new SourceCode(code, ast);
|
|
|
|
assert.strictEqual(
|
|
astUtils.equalTokens(ast.body[0], ast.body[1], sourceCode),
|
|
false,
|
|
);
|
|
});
|
|
});
|
|
|
|
describe("equalLiteralValue", () => {
|
|
describe("should return true if two regex values are same, even if it's not supported natively.", () => {
|
|
const patterns = [
|
|
{
|
|
nodeA: {
|
|
type: "Literal",
|
|
value: /(?:)/u, // eslint-disable-line regexp/no-empty-group -- Test data for regex comparison
|
|
regex: { pattern: "(?:)", flags: "u" },
|
|
},
|
|
nodeB: {
|
|
type: "Literal",
|
|
value: /(?:)/u, // eslint-disable-line regexp/no-empty-group -- Test data for regex comparison
|
|
regex: { pattern: "(?:)", flags: "u" },
|
|
},
|
|
expected: true,
|
|
},
|
|
{
|
|
nodeA: {
|
|
type: "Literal",
|
|
value: null,
|
|
regex: { pattern: "(?:)", flags: "u" },
|
|
},
|
|
nodeB: {
|
|
type: "Literal",
|
|
value: null,
|
|
regex: { pattern: "(?:)", flags: "u" },
|
|
},
|
|
expected: true,
|
|
},
|
|
{
|
|
nodeA: {
|
|
type: "Literal",
|
|
value: null,
|
|
regex: { pattern: "(?:)", flags: "u" },
|
|
},
|
|
nodeB: {
|
|
type: "Literal",
|
|
value: /(?:)/, // eslint-disable-line require-unicode-regexp, regexp/no-empty-group -- Checking non-Unicode regex
|
|
regex: { pattern: "(?:)", flags: "" },
|
|
},
|
|
expected: false,
|
|
},
|
|
{
|
|
nodeA: {
|
|
type: "Literal",
|
|
value: null,
|
|
regex: { pattern: "(?:a)", flags: "u" },
|
|
},
|
|
nodeB: {
|
|
type: "Literal",
|
|
value: null,
|
|
regex: { pattern: "(?:b)", flags: "u" },
|
|
},
|
|
expected: false,
|
|
},
|
|
];
|
|
|
|
for (const { nodeA, nodeB, expected } of patterns) {
|
|
it(`should return ${expected} if it compared ${util.format("%o", nodeA)} and ${util.format("%o", nodeB)}`, () => {
|
|
assert.strictEqual(
|
|
astUtils.equalLiteralValue(nodeA, nodeB),
|
|
expected,
|
|
);
|
|
});
|
|
}
|
|
});
|
|
|
|
describe("should return true if two bigint values are same, even if it's not supported natively.", () => {
|
|
const patterns = [
|
|
{
|
|
nodeA: {
|
|
type: "Literal",
|
|
value: null,
|
|
bigint: "1",
|
|
},
|
|
nodeB: {
|
|
type: "Literal",
|
|
value: null,
|
|
bigint: "1",
|
|
},
|
|
expected: true,
|
|
},
|
|
{
|
|
nodeA: {
|
|
type: "Literal",
|
|
value: null,
|
|
bigint: "1",
|
|
},
|
|
nodeB: {
|
|
type: "Literal",
|
|
value: null,
|
|
bigint: "2",
|
|
},
|
|
expected: false,
|
|
},
|
|
{
|
|
nodeA: {
|
|
type: "Literal",
|
|
value: 1n,
|
|
bigint: "1",
|
|
},
|
|
nodeB: {
|
|
type: "Literal",
|
|
value: 1n,
|
|
bigint: "1",
|
|
},
|
|
expected: true,
|
|
},
|
|
{
|
|
nodeA: {
|
|
type: "Literal",
|
|
value: 1n,
|
|
bigint: "1",
|
|
},
|
|
nodeB: {
|
|
type: "Literal",
|
|
value: 2n,
|
|
bigint: "2",
|
|
},
|
|
expected: false,
|
|
},
|
|
];
|
|
|
|
for (const { nodeA, nodeB, expected } of patterns) {
|
|
it(`should return ${expected} if it compared ${util.format("%o", nodeA)} and ${util.format("%o", nodeB)}`, () => {
|
|
assert.strictEqual(
|
|
astUtils.equalLiteralValue(nodeA, nodeB),
|
|
expected,
|
|
);
|
|
});
|
|
}
|
|
});
|
|
});
|
|
|
|
describe("hasOctalOrNonOctalDecimalEscapeSequence", () => {
|
|
const expectedResults = {
|
|
"\\1": true,
|
|
"\\2": true,
|
|
"\\7": true,
|
|
"\\00": true,
|
|
"\\01": true,
|
|
"\\02": true,
|
|
"\\07": true,
|
|
"\\08": true,
|
|
"\\09": true,
|
|
"\\10": true,
|
|
"\\12": true,
|
|
" \\1": true,
|
|
"\\1 ": true,
|
|
"a\\1": true,
|
|
"\\1a": true,
|
|
"a\\1a": true,
|
|
" \\01": true,
|
|
"\\01 ": true,
|
|
"a\\01": true,
|
|
"\\01a": true,
|
|
"a\\01a": true,
|
|
"a\\08a": true,
|
|
"\\0\\1": true,
|
|
"\\0\\01": true,
|
|
"\\0\\08": true,
|
|
"\\n\\1": true,
|
|
"\\n\\01": true,
|
|
"\\n\\08": true,
|
|
"\\\\\\1": true,
|
|
"\\\\\\01": true,
|
|
"\\\\\\08": true,
|
|
"\\8": true,
|
|
"\\9": true,
|
|
"a\\8a": true,
|
|
"\\0\\8": true,
|
|
"\\8\\0": true,
|
|
"\\80": true,
|
|
"\\81": true,
|
|
"\\\\\\8": true,
|
|
"\\\n\\1": true,
|
|
"foo\\\nbar\\2baz": true,
|
|
"\\\n\\8": true,
|
|
"foo\\\nbar\\9baz": true,
|
|
|
|
"\\0": false,
|
|
" \\0": false,
|
|
"\\0 ": false,
|
|
"a\\0": false,
|
|
"\\0a": false,
|
|
"\\\\": false,
|
|
"\\\\0": false,
|
|
"\\\\01": false,
|
|
"\\\\08": false,
|
|
"\\\\1": false,
|
|
"\\\\12": false,
|
|
"\\\\\\0": false,
|
|
"\\0\\\\": false,
|
|
0: false,
|
|
1: false,
|
|
8: false,
|
|
"01": false,
|
|
"08": false,
|
|
80: false,
|
|
12: false,
|
|
"\\a": false,
|
|
"\\n": false,
|
|
"\\\n": false,
|
|
"foo\\\nbar": false,
|
|
"128\\\n349": false,
|
|
};
|
|
|
|
Object.keys(expectedResults).forEach(key => {
|
|
it(`should return ${expectedResults[key]} for ${key}`, () => {
|
|
const ast = espree.parse(`"${key}"`);
|
|
|
|
assert.strictEqual(
|
|
astUtils.hasOctalOrNonOctalDecimalEscapeSequence(
|
|
ast.body[0].expression.raw,
|
|
),
|
|
expectedResults[key],
|
|
);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("isLogicalAssignmentOperator", () => {
|
|
const expectedResults = {
|
|
"&&=": true,
|
|
"||=": true,
|
|
"??=": true,
|
|
"&&": false,
|
|
"||": false,
|
|
"??": false,
|
|
"=": false,
|
|
"&=": false,
|
|
"|=": false,
|
|
"+=": false,
|
|
"**=": false,
|
|
"==": false,
|
|
"===": false,
|
|
};
|
|
|
|
Object.entries(expectedResults).forEach(([key, value]) => {
|
|
it(`should return ${value} for ${key}`, () => {
|
|
assert.strictEqual(
|
|
astUtils.isLogicalAssignmentOperator(key),
|
|
value,
|
|
);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("isTopLevelExpressionStatement", () => {
|
|
it("should return false for a Program node", () => {
|
|
const node = { type: "Program", parent: null };
|
|
|
|
assert.strictEqual(
|
|
astUtils.isTopLevelExpressionStatement(node),
|
|
false,
|
|
);
|
|
});
|
|
|
|
it("should return false if the node is not an ExpressionStatement", () => {
|
|
linter.verify('var foo = () => "use strict";', {
|
|
plugins: {
|
|
test: {
|
|
rules: {
|
|
checker: {
|
|
create: mustCall(() => ({
|
|
":expression": mustCall(node => {
|
|
assert.strictEqual(
|
|
astUtils.isTopLevelExpressionStatement(
|
|
node,
|
|
),
|
|
false,
|
|
);
|
|
}),
|
|
})),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
rules: { "test/checker": "error" },
|
|
});
|
|
});
|
|
|
|
const expectedResults = [
|
|
['if (foo) { "use strict"; }', '"use strict";', false],
|
|
['{ "use strict"; }', '"use strict";', false],
|
|
[
|
|
'switch (foo) { case bar: "use strict"; }',
|
|
'"use strict";',
|
|
false,
|
|
],
|
|
["foo; bar;", "foo;", true],
|
|
["foo; bar;", "bar;", true],
|
|
["function foo() { bar; }", "bar;", true],
|
|
["var foo = function () { foo(); };", "foo();", true],
|
|
["var foo = () => { 'bar'; }", "'bar';", true],
|
|
['"use strict"', '"use strict"', true],
|
|
["(`use strict`)", "(`use strict`)", true],
|
|
];
|
|
|
|
expectedResults.forEach(([code, nodeText, expectedRetVal]) => {
|
|
it(`should return ${expectedRetVal} for \`${nodeText}\` in \`${code}\``, () => {
|
|
linter.verify(code, {
|
|
plugins: {
|
|
test: {
|
|
rules: {
|
|
checker: {
|
|
create: mustCall(context => {
|
|
const assertForNode = mustCall(node =>
|
|
assert.strictEqual(
|
|
astUtils.isTopLevelExpressionStatement(
|
|
node,
|
|
),
|
|
expectedRetVal,
|
|
),
|
|
);
|
|
|
|
return {
|
|
ExpressionStatement(node) {
|
|
if (
|
|
context.sourceCode.getText(
|
|
node,
|
|
) === nodeText
|
|
) {
|
|
assertForNode(node);
|
|
}
|
|
},
|
|
};
|
|
}),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
rules: { "test/checker": "error" },
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("isStaticTemplateLiteral", () => {
|
|
const expectedResults = {
|
|
"``": true,
|
|
"`foo`": true,
|
|
"`foo${bar}`": false,
|
|
'"foo"': false,
|
|
"foo`bar`": false,
|
|
};
|
|
|
|
Object.entries(expectedResults).forEach(([code, expectedResult]) => {
|
|
it(`returns ${expectedResult} for ${code}`, () => {
|
|
const ast = espree.parse(code, { ecmaVersion: 6 });
|
|
|
|
assert.strictEqual(
|
|
astUtils.isStaticTemplateLiteral(ast.body[0].expression),
|
|
expectedResult,
|
|
);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("isDirective", () => {
|
|
const expectedResults = [
|
|
{ code: '"use strict";', expectedRetVal: true },
|
|
{
|
|
code: '"use strict"; "use asm";',
|
|
nodeText: '"use asm";',
|
|
expectedRetVal: true,
|
|
},
|
|
{
|
|
code: 'const a = () => { "foo"; }',
|
|
nodeText: '"foo";',
|
|
expectedRetVal: true,
|
|
},
|
|
{ code: '"";', expectedRetVal: true },
|
|
{ code: '{ "foo"; }', nodeText: '"foo";', expectedRetVal: false },
|
|
{ code: "foo();", expectedRetVal: false },
|
|
{ code: '"foo" + "bar";', expectedRetVal: false },
|
|
{ code: "12345;", expectedRetVal: false },
|
|
{ code: "`foo`;", expectedRetVal: false },
|
|
{ code: "('foo');", expectedRetVal: false },
|
|
{
|
|
code: 'foo(); "use strict";',
|
|
nodeText: '"use strict";',
|
|
expectedRetVal: false,
|
|
},
|
|
];
|
|
|
|
expectedResults.forEach(({ code, nodeText = code, expectedRetVal }) => {
|
|
it(`should return ${expectedRetVal} for \`${nodeText}\` in \`${code}\``, () => {
|
|
linter.verify(code, {
|
|
plugins: {
|
|
test: {
|
|
rules: {
|
|
checker: {
|
|
create: mustCall(({ sourceCode }) => {
|
|
const assertForNode = mustCall(node =>
|
|
assert.strictEqual(
|
|
astUtils.isDirective(node),
|
|
expectedRetVal,
|
|
),
|
|
);
|
|
|
|
return {
|
|
ExpressionStatement(node) {
|
|
if (
|
|
sourceCode.getText(node) ===
|
|
nodeText
|
|
) {
|
|
assertForNode(node);
|
|
|
|
if (!expectedRetVal) {
|
|
// The flow parser sets `directive` to null on non-directive ExpressionStatement nodes.
|
|
node.directive = null;
|
|
assertForNode(node);
|
|
}
|
|
}
|
|
},
|
|
};
|
|
}),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
rules: { "test/checker": "error" },
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("isPropertyDescriptor", () => {
|
|
/**
|
|
* Asserts that `isPropertyDescriptor` reports whether each `ObjectExpression`
|
|
* node in the given code is used as a property descriptor.
|
|
* @param {string} code the code to check.
|
|
* @param {boolean[]} expected the expected result for each `ObjectExpression` node, in traversal order.
|
|
* @param {Object} [languageOptions] the language options to use.
|
|
* @returns {void}
|
|
*/
|
|
function assertResult(code, expected, languageOptions = {}) {
|
|
const results = [];
|
|
linter.verify(code, {
|
|
languageOptions,
|
|
plugins: {
|
|
test: {
|
|
rules: {
|
|
checker: {
|
|
create: mustCall(context => ({
|
|
ObjectExpression: mustCall(node => {
|
|
results.push(
|
|
astUtils.isPropertyDescriptor(
|
|
node,
|
|
context.sourceCode,
|
|
),
|
|
);
|
|
}),
|
|
})),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
rules: { "test/checker": "error" },
|
|
});
|
|
|
|
assert.deepStrictEqual(results, expected);
|
|
}
|
|
|
|
it("should return true for a descriptor of Object.defineProperty", () => {
|
|
assertResult("Object.defineProperty(foo, 'bar', { value: 1 })", [
|
|
true,
|
|
]);
|
|
});
|
|
|
|
it("should return true for the third argument of Reflect.defineProperty", () => {
|
|
assertResult("Reflect.defineProperty(foo, 'bar', { value: 1 })", [
|
|
true,
|
|
]);
|
|
});
|
|
|
|
it("should return true for descriptors nested in Object.defineProperties", () => {
|
|
assertResult(
|
|
"Object.defineProperties(foo, { bar: { value: 1 } })",
|
|
[false, true],
|
|
);
|
|
});
|
|
|
|
it("should return true for descriptors nested in Object.create", () => {
|
|
assertResult("Object.create(proto, { bar: { value: 1 } })", [
|
|
false,
|
|
true,
|
|
]);
|
|
});
|
|
|
|
it("should return true for a call with optional chaining", () => {
|
|
assertResult("Object?.defineProperty(foo, 'bar', { value: 1 })", [
|
|
true,
|
|
]);
|
|
});
|
|
|
|
it("should return false for a standalone object literal", () => {
|
|
assertResult("const d = { value: 1 };", [false]);
|
|
});
|
|
|
|
it("should return false for a descriptor-like object at another position", () => {
|
|
assertResult(
|
|
"Object.defineProperty({ value: 1 }, 'bar', { value: 1 })",
|
|
[false, true],
|
|
);
|
|
});
|
|
|
|
it("should return false when the descriptor map is not the second argument", () => {
|
|
assertResult("Object.create({ bar: { value: 1 } }, foo)", [
|
|
false,
|
|
false,
|
|
]);
|
|
});
|
|
|
|
it("should return false when the object is not the global `Object`", () => {
|
|
assertResult("object.defineProperty(foo, 'bar', { value: 1 })", [
|
|
false,
|
|
]);
|
|
});
|
|
|
|
it("should return false for Reflect.defineProperties", () => {
|
|
assertResult(
|
|
"Reflect.defineProperties(foo, { bar: { value: 1 } })",
|
|
[false, false],
|
|
);
|
|
});
|
|
|
|
it("should return false when `Object` is shadowed", () => {
|
|
assertResult(
|
|
"let Object; Object.defineProperty(foo, 'bar', { value: 1 })",
|
|
[false],
|
|
);
|
|
});
|
|
|
|
it("should return false when the global `Object` is disabled", () => {
|
|
assertResult(
|
|
"Object.defineProperty(foo, 'bar', { value: 1 })",
|
|
[false],
|
|
{ globals: { Object: "off" } },
|
|
);
|
|
});
|
|
|
|
it("should return false for a computed key in the second argument of Object.defineProperties", () => {
|
|
assertResult(
|
|
"Object.defineProperties(foo, { [{ value: 1 }]: 1 })",
|
|
[false, false],
|
|
);
|
|
});
|
|
});
|
|
});
|