+++ /dev/null
-/**
- * @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;
- }
-};
projects / dotfiles / .git / blobdiff