|
|
/** * @fileoverview Rule to control usage of strict mode directives. * @author Brandon Mills */
"use strict";
//------------------------------------------------------------------------------
// Requirements
//------------------------------------------------------------------------------
const astUtils = require("./utils/ast-utils");
//------------------------------------------------------------------------------
// Helpers
//------------------------------------------------------------------------------
/** * Gets all of the Use Strict Directives in the Directive Prologue of a group of * statements. * @param {ASTNode[]} statements Statements in the program or function body. * @returns {ASTNode[]} All of the Use Strict Directives. */ function getUseStrictDirectives(statements) { const directives = [];
for (let i = 0; i < statements.length; i++) { const statement = statements[i];
if ( statement.type === "ExpressionStatement" && statement.expression.type === "Literal" && statement.expression.value === "use strict" ) { directives[i] = statement; } else { break; } }
return directives; }
/** * Checks whether a given parameter is a simple parameter. * @param {ASTNode} node A pattern node to check. * @returns {boolean} `true` if the node is an Identifier node. */ function isSimpleParameter(node) { return node.type === "Identifier"; }
/** * Checks whether a given parameter list is a simple parameter list. * @param {ASTNode[]} params A parameter list to check. * @returns {boolean} `true` if the every parameter is an Identifier node. */ function isSimpleParameterList(params) { return params.every(isSimpleParameter); }
//------------------------------------------------------------------------------
// Rule Definition
//------------------------------------------------------------------------------
module.exports = { meta: { type: "suggestion",
docs: { description: "require or disallow strict mode directives", category: "Strict Mode", recommended: false, url: "https://eslint.org/docs/rules/strict" },
schema: [ { enum: ["never", "global", "function", "safe"] } ],
fixable: "code", messages: { function: "Use the function form of 'use strict'.", global: "Use the global form of 'use strict'.", multiple: "Multiple 'use strict' directives.", never: "Strict mode is not permitted.", unnecessary: "Unnecessary 'use strict' directive.", module: "'use strict' is unnecessary inside of modules.", implied: "'use strict' is unnecessary when implied strict mode is enabled.", unnecessaryInClasses: "'use strict' is unnecessary inside of classes.", nonSimpleParameterList: "'use strict' directive inside a function with non-simple parameter list throws a syntax error since ES2016.", wrap: "Wrap {{name}} in a function with 'use strict' directive." } },
create(context) {
const ecmaFeatures = context.parserOptions.ecmaFeatures || {}, scopes = [], classScopes = []; let mode = context.options[0] || "safe";
if (ecmaFeatures.impliedStrict) { mode = "implied"; } else if (mode === "safe") { mode = ecmaFeatures.globalReturn ? "global" : "function"; }
/** * Determines whether a reported error should be fixed, depending on the error type. * @param {string} errorType The type of error * @returns {boolean} `true` if the reported error should be fixed */ function shouldFix(errorType) { return errorType === "multiple" || errorType === "unnecessary" || errorType === "module" || errorType === "implied" || errorType === "unnecessaryInClasses"; }
/** * Gets a fixer function to remove a given 'use strict' directive. * @param {ASTNode} node The directive that should be removed * @returns {Function} A fixer function */ function getFixFunction(node) { return fixer => fixer.remove(node); }
/** * Report a slice of an array of nodes with a given message. * @param {ASTNode[]} nodes Nodes. * @param {string} start Index to start from. * @param {string} end Index to end before. * @param {string} messageId Message to display. * @param {boolean} fix `true` if the directive should be fixed (i.e. removed) * @returns {void} */ function reportSlice(nodes, start, end, messageId, fix) { nodes.slice(start, end).forEach(node => { context.report({ node, messageId, fix: fix ? getFixFunction(node) : null }); }); }
/** * Report all nodes in an array with a given message. * @param {ASTNode[]} nodes Nodes. * @param {string} messageId Message id to display. * @param {boolean} fix `true` if the directive should be fixed (i.e. removed) * @returns {void} */ function reportAll(nodes, messageId, fix) { reportSlice(nodes, 0, nodes.length, messageId, fix); }
/** * Report all nodes in an array, except the first, with a given message. * @param {ASTNode[]} nodes Nodes. * @param {string} messageId Message id to display. * @param {boolean} fix `true` if the directive should be fixed (i.e. removed) * @returns {void} */ function reportAllExceptFirst(nodes, messageId, fix) { reportSlice(nodes, 1, nodes.length, messageId, fix); }
/** * Entering a function in 'function' mode pushes a new nested scope onto the * stack. The new scope is true if the nested function is strict mode code. * @param {ASTNode} node The function declaration or expression. * @param {ASTNode[]} useStrictDirectives The Use Strict Directives of the node. * @returns {void} */ function enterFunctionInFunctionMode(node, useStrictDirectives) { const isInClass = classScopes.length > 0, isParentGlobal = scopes.length === 0 && classScopes.length === 0, isParentStrict = scopes.length > 0 && scopes[scopes.length - 1], isStrict = useStrictDirectives.length > 0;
if (isStrict) { if (!isSimpleParameterList(node.params)) { context.report({ node: useStrictDirectives[0], messageId: "nonSimpleParameterList" }); } else if (isParentStrict) { context.report({ node: useStrictDirectives[0], messageId: "unnecessary", fix: getFixFunction(useStrictDirectives[0]) }); } else if (isInClass) { context.report({ node: useStrictDirectives[0], messageId: "unnecessaryInClasses", fix: getFixFunction(useStrictDirectives[0]) }); }
reportAllExceptFirst(useStrictDirectives, "multiple", true); } else if (isParentGlobal) { if (isSimpleParameterList(node.params)) { context.report({ node, messageId: "function" }); } else { context.report({ node, messageId: "wrap", data: { name: astUtils.getFunctionNameWithKind(node) } }); } }
scopes.push(isParentStrict || isStrict); }
/** * Exiting a function in 'function' mode pops its scope off the stack. * @returns {void} */ function exitFunctionInFunctionMode() { scopes.pop(); }
/** * Enter a function and either: * - Push a new nested scope onto the stack (in 'function' mode). * - Report all the Use Strict Directives (in the other modes). * @param {ASTNode} node The function declaration or expression. * @returns {void} */ function enterFunction(node) { const isBlock = node.body.type === "BlockStatement", useStrictDirectives = isBlock ? getUseStrictDirectives(node.body.body) : [];
if (mode === "function") { enterFunctionInFunctionMode(node, useStrictDirectives); } else if (useStrictDirectives.length > 0) { if (isSimpleParameterList(node.params)) { reportAll(useStrictDirectives, mode, shouldFix(mode)); } else { context.report({ node: useStrictDirectives[0], messageId: "nonSimpleParameterList" }); reportAllExceptFirst(useStrictDirectives, "multiple", true); } } }
const rule = { Program(node) { const useStrictDirectives = getUseStrictDirectives(node.body);
if (node.sourceType === "module") { mode = "module"; }
if (mode === "global") { if (node.body.length > 0 && useStrictDirectives.length === 0) { context.report({ node, messageId: "global" }); } reportAllExceptFirst(useStrictDirectives, "multiple", true); } else { reportAll(useStrictDirectives, mode, shouldFix(mode)); } }, FunctionDeclaration: enterFunction, FunctionExpression: enterFunction, ArrowFunctionExpression: enterFunction };
if (mode === "function") { Object.assign(rule, {
// Inside of class bodies are always strict mode.
ClassBody() { classScopes.push(true); }, "ClassBody:exit"() { classScopes.pop(); },
"FunctionDeclaration:exit": exitFunctionInFunctionMode, "FunctionExpression:exit": exitFunctionInFunctionMode, "ArrowFunctionExpression:exit": exitFunctionInFunctionMode }); }
return rule; } };
|