bahlint 28.58.6934

package/lib/rules/no-invalid-regexp.js

@@ -0,0 +1,244 @@
+/**
+ * @fileoverview Validate strings passed to the RegExp constructor
+ * @author Michael Ficarra
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const RegExpValidator = require("@eslint-community/regexpp").RegExpValidator;
+const validator = new RegExpValidator();
+const validFlags = "dgimsuvy";
+const undefined1 = void 0;
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "problem",
+
+		defaultOptions: [{}],
+
+		docs: {
+			description:
+				"Disallow invalid regular expression strings in `RegExp` constructors",
+			recommended: true,
+			url: "https://eslint.org/docs/latest/rules/no-invalid-regexp",
+		},
+
+		schema: [
+			{
+				type: "object",
+				properties: {
+					allowConstructorFlags: {
+						type: "array",
+						items: {
+							type: "string",
+						},
+						uniqueItems: true,
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+
+		messages: {
+			regexMessage: "{{message}}.",
+		},
+	},
+
+	create(context) {
+		const [{ allowConstructorFlags }] = context.options;
+		let allowedFlags = [];
+
+		if (allowConstructorFlags) {
+			const temp = allowConstructorFlags
+				.join("")
+				.replace(new RegExp(`[${validFlags}]`, "gu"), "");
+
+			if (temp) {
+				allowedFlags = [...new Set(temp)];
+			}
+		}
+
+		/**
+		 * Reports error with the provided message.
+		 * @param {ASTNode} node The node holding the invalid RegExp
+		 * @param {string} message The message to report.
+		 * @returns {void}
+		 */
+		function report(node, message) {
+			context.report({
+				node,
+				messageId: "regexMessage",
+				data: { message },
+			});
+		}
+
+		/**
+		 * Check if node is a string
+		 * @param {ASTNode} node node to evaluate
+		 * @returns {boolean} True if its a string
+		 * @private
+		 */
+		function isString(node) {
+			return (
+				node &&
+				node.type === "Literal" &&
+				typeof node.value === "string"
+			);
+		}
+
+		/**
+		 * Gets flags of a regular expression created by the given `RegExp()` or `new RegExp()` call
+		 * Examples:
+		 *     new RegExp(".")         // => ""
+		 *     new RegExp(".", "gu")   // => "gu"
+		 *     new RegExp(".", flags)  // => null
+		 * @param {ASTNode} node `CallExpression` or `NewExpression` node
+		 * @returns {string|null} flags if they can be determined, `null` otherwise
+		 * @private
+		 */
+		function getFlags(node) {
+			if (node.arguments.length < 2) {
+				return "";
+			}
+
+			if (isString(node.arguments[1])) {
+				return node.arguments[1].value;
+			}
+
+			return null;
+		}
+
+		/**
+		 * Check syntax error in a given pattern.
+		 * @param {string} pattern The RegExp pattern to validate.
+		 * @param {Object} flags The RegExp flags to validate.
+		 * @param {boolean} [flags.unicode] The Unicode flag.
+		 * @param {boolean} [flags.unicodeSets] The UnicodeSets flag.
+		 * @returns {string|null} The syntax error.
+		 */
+		function validateRegExpPattern(pattern, flags) {
+			try {
+				validator.validatePattern(
+					pattern,
+					undefined1,
+					undefined1,
+					flags,
+				);
+				return null;
+			} catch (err) {
+				return err.message;
+			}
+		}
+
+		/**
+		 * Check syntax error in a given flags.
+		 * @param {string|null} flags The RegExp flags to validate.
+		 * @param {string|null} flagsToCheck The RegExp invalid flags.
+		 * @param {string} allFlags all valid and allowed flags.
+		 * @returns {string|null} The syntax error.
+		 */
+		function validateRegExpFlags(flags, flagsToCheck, allFlags) {
+			const duplicateFlags = [];
+
+			if (typeof flagsToCheck === "string") {
+				for (const flag of flagsToCheck) {
+					if (allFlags.includes(flag)) {
+						duplicateFlags.push(flag);
+					}
+				}
+			}
+
+			/*
+			 * `regexpp` checks the combination of `u` and `v` flags when parsing `Pattern` according to `ecma262`,
+			 * but this rule may check only the flag when the pattern is unidentifiable, so check it here.
+			 * https://tc39.es/ecma262/multipage/text-processing.html#sec-parsepattern
+			 */
+			if (flags && flags.includes("u") && flags.includes("v")) {
+				return "Regex 'u' and 'v' flags cannot be used together";
+			}
+
+			if (duplicateFlags.length > 0) {
+				return `Duplicate flags ('${duplicateFlags.join("")}') supplied to RegExp constructor`;
+			}
+
+			if (!flagsToCheck) {
+				return null;
+			}
+
+			return `Invalid flags supplied to RegExp constructor '${flagsToCheck}'`;
+		}
+
+		return {
+			"CallExpression, NewExpression"(node) {
+				if (
+					node.callee.type !== "Identifier" ||
+					node.callee.name !== "RegExp"
+				) {
+					return;
+				}
+
+				const flags = getFlags(node);
+				let flagsToCheck = flags;
+				const allFlags =
+					allowedFlags.length > 0
+						? validFlags.split("").concat(allowedFlags)
+						: validFlags.split("");
+
+				if (flags) {
+					allFlags.forEach(flag => {
+						flagsToCheck = flagsToCheck.replace(flag, "");
+					});
+				}
+
+				let message = validateRegExpFlags(
+					flags,
+					flagsToCheck,
+					allFlags,
+				);
+
+				if (message) {
+					report(node, message);
+					return;
+				}
+
+				if (!isString(node.arguments[0])) {
+					return;
+				}
+
+				const pattern = node.arguments[0].value;
+
+				message =
+					// If flags are unknown, report the regex only if its pattern is invalid both with and without the "u" flag
+					flags === null
+						? validateRegExpPattern(pattern, {
+								unicode: true,
+								unicodeSets: false,
+							}) &&
+							validateRegExpPattern(pattern, {
+								unicode: false,
+								unicodeSets: true,
+							}) &&
+							validateRegExpPattern(pattern, {
+								unicode: false,
+								unicodeSets: false,
+							})
+						: validateRegExpPattern(pattern, {
+								unicode: flags.includes("u"),
+								unicodeSets: flags.includes("v"),
+							});
+
+				if (message) {
+					report(node, message);
+				}
+			},
+		};
+	},
+};

package/lib/rules/no-invalid-this.js

@@ -0,0 +1,178 @@
+/**
+ * @fileoverview A rule to disallow `this` keywords in contexts where the value of `this` is `undefined`.
+ * @author Toru Nagashima
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Determines if the given code path is a code path with lexical `this` binding.
+ * That is, if `this` within the code path refers to `this` of surrounding code path.
+ * @param {CodePath} codePath Code path.
+ * @param {ASTNode} node Node that started the code path.
+ * @returns {boolean} `true` if it is a code path with lexical `this` binding.
+ */
+function isCodePathWithLexicalThis(codePath, node) {
+	return (
+		codePath.origin === "function" &&
+		node.type === "ArrowFunctionExpression"
+	);
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		dialects: ["javascript", "typescript"],
+		language: "javascript",
+		type: "suggestion",
+
+		defaultOptions: [{ capIsConstructor: true }],
+
+		docs: {
+			description:
+				"Disallow use of `this` in contexts where the value of `this` is `undefined`",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/no-invalid-this",
+		},
+
+		schema: [
+			{
+				type: "object",
+				properties: {
+					capIsConstructor: {
+						type: "boolean",
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+
+		messages: {
+			unexpectedThis: "Unexpected 'this'.",
+		},
+	},
+
+	create(context) {
+		const [{ capIsConstructor }] = context.options;
+		const stack = [],
+			sourceCode = context.sourceCode;
+
+		/**
+		 * Gets the current checking context.
+		 *
+		 * The return value has a flag that whether or not `this` keyword is valid.
+		 * The flag is initialized when got at the first time.
+		 * @returns {{valid: boolean}}
+		 *   an object which has a flag that whether or not `this` keyword is valid.
+		 */
+		stack.getCurrent = function () {
+			const current = this.at(-1);
+
+			if (!current.init) {
+				current.init = true;
+				current.valid = !astUtils.isDefaultThisBinding(
+					current.node,
+					sourceCode,
+					{ capIsConstructor },
+				);
+			}
+			return current;
+		};
+
+		return {
+			onCodePathStart(codePath, node) {
+				if (isCodePathWithLexicalThis(codePath, node)) {
+					return;
+				}
+
+				if (codePath.origin === "program") {
+					const scope = sourceCode.getScope(node);
+					const features =
+						context.languageOptions.parserOptions.ecmaFeatures ||
+						{};
+
+					// `this` at the top level of scripts always refers to the global object
+					stack.push({
+						init: true,
+						node,
+						valid: !(
+							node.sourceType === "module" ||
+							(features.globalReturn &&
+								scope.childScopes[0].isStrict)
+						),
+					});
+
+					return;
+				}
+
+				/*
+				 * `init: false` means that `valid` isn't determined yet.
+				 * Most functions don't use `this`, and the calculation for `valid`
+				 * is relatively costly, so we'll calculate it lazily when the first
+				 * `this` within the function is traversed. A special case are non-strict
+				 * functions, because `this` refers to the global object and therefore is
+				 * always valid, so we can set `init: true` right away.
+				 */
+				stack.push({
+					init: !sourceCode.getScope(node).isStrict,
+					node,
+					valid: true,
+				});
+			},
+
+			onCodePathEnd(codePath, node) {
+				if (isCodePathWithLexicalThis(codePath, node)) {
+					return;
+				}
+
+				stack.pop();
+			},
+
+			"AccessorProperty > *.value"(node) {
+				stack.push({
+					init: true,
+					node,
+					valid: true,
+				});
+			},
+
+			"AccessorProperty:exit"() {
+				stack.pop();
+			},
+
+			// Reports if `this` of the current context is invalid.
+			ThisExpression(node) {
+				// Special case: skip `this` if it's the value of an AccessorProperty
+				if (
+					node.parent.type === "AccessorProperty" &&
+					node.parent.value === node
+				) {
+					return;
+				}
+
+				const current = stack.getCurrent();
+
+				if (current && !current.valid) {
+					context.report({
+						node,
+						messageId: "unexpectedThis",
+					});
+				}
+			},
+		};
+	},
+};

package/lib/rules/no-irregular-whitespace.js

@@ -0,0 +1,292 @@
+/**
+ * @fileoverview Rule to disallow whitespace that is not a tab or space, whitespace inside strings and comments are allowed
+ * @author Jonathan Kingston
+ * @author Christophe Porteneuve
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Constants
+//------------------------------------------------------------------------------
+
+const ALL_IRREGULARS =
+	/[\f\v\u0085\ufeff\u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u202f\u205f\u3000\u2028\u2029]/u;
+const IRREGULAR_WHITESPACE =
+	/[\f\v\u0085\ufeff\u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u202f\u205f\u3000]+/gu;
+const IRREGULAR_LINE_TERMINATORS = /[\u2028\u2029]/gu;
+const LINE_BREAK = astUtils.createGlobalLinebreakMatcher();
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "problem",
+
+		defaultOptions: [
+			{
+				skipComments: false,
+				skipJSXText: false,
+				skipRegExps: false,
+				skipStrings: true,
+				skipTemplates: false,
+			},
+		],
+
+		docs: {
+			description: "Disallow irregular whitespace",
+			recommended: true,
+			url: "https://eslint.org/docs/latest/rules/no-irregular-whitespace",
+		},
+
+		schema: [
+			{
+				type: "object",
+				properties: {
+					skipComments: {
+						type: "boolean",
+					},
+					skipStrings: {
+						type: "boolean",
+					},
+					skipTemplates: {
+						type: "boolean",
+					},
+					skipRegExps: {
+						type: "boolean",
+					},
+					skipJSXText: {
+						type: "boolean",
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+
+		messages: {
+			noIrregularWhitespace: "Irregular whitespace not allowed.",
+		},
+	},
+
+	create(context) {
+		const [
+			{
+				skipComments,
+				skipStrings,
+				skipRegExps,
+				skipTemplates,
+				skipJSXText,
+			},
+		] = context.options;
+
+		const sourceCode = context.sourceCode;
+		const commentNodes = sourceCode.getAllComments();
+
+		// Module store of errors that we have found
+		let errors = [];
+
+		/**
+		 * Removes errors that occur inside the given node
+		 * @param {ASTNode} node to check for matching errors.
+		 * @returns {void}
+		 * @private
+		 */
+		function removeWhitespaceError(node) {
+			const locStart = node.loc.start;
+			const locEnd = node.loc.end;
+
+			errors = errors.filter(
+				({ loc: { start: errorLocStart } }) =>
+					errorLocStart.line < locStart.line ||
+					(errorLocStart.line === locStart.line &&
+						errorLocStart.column < locStart.column) ||
+					(errorLocStart.line === locEnd.line &&
+						errorLocStart.column >= locEnd.column) ||
+					errorLocStart.line > locEnd.line,
+			);
+		}
+
+		/**
+		 * Checks literal nodes for errors that we are choosing to ignore and calls the relevant methods to remove the errors
+		 * @param {ASTNode} node to check for matching errors.
+		 * @returns {void}
+		 * @private
+		 */
+		function removeInvalidNodeErrorsInLiteral(node) {
+			const shouldCheckStrings =
+				skipStrings && typeof node.value === "string";
+			const shouldCheckRegExps = skipRegExps && Boolean(node.regex);
+
+			if (shouldCheckStrings || shouldCheckRegExps) {
+				// If we have irregular characters remove them from the errors list
+				if (ALL_IRREGULARS.test(node.raw)) {
+					removeWhitespaceError(node);
+				}
+			}
+		}
+
+		/**
+		 * Checks template string literal nodes for errors that we are choosing to ignore and calls the relevant methods to remove the errors
+		 * @param {ASTNode} node to check for matching errors.
+		 * @returns {void}
+		 * @private
+		 */
+		function removeInvalidNodeErrorsInTemplateLiteral(node) {
+			if (typeof node.value.raw === "string") {
+				if (ALL_IRREGULARS.test(node.value.raw)) {
+					removeWhitespaceError(node);
+				}
+			}
+		}
+
+		/**
+		 * Checks comment nodes for errors that we are choosing to ignore and calls the relevant methods to remove the errors
+		 * @param {ASTNode} node to check for matching errors.
+		 * @returns {void}
+		 * @private
+		 */
+		function removeInvalidNodeErrorsInComment(node) {
+			if (ALL_IRREGULARS.test(node.value)) {
+				removeWhitespaceError(node);
+			}
+		}
+
+		/**
+		 * Checks JSX nodes for errors that we are choosing to ignore and calls the relevant methods to remove the errors
+		 * @param {ASTNode} node to check for matching errors.
+		 * @returns {void}
+		 * @private
+		 */
+		function removeInvalidNodeErrorsInJSXText(node) {
+			if (ALL_IRREGULARS.test(node.raw)) {
+				removeWhitespaceError(node);
+			}
+		}
+
+		/**
+		 * Checks the program source for irregular whitespace
+		 * @param {ASTNode} node The program node
+		 * @returns {void}
+		 * @private
+		 */
+		function checkForIrregularWhitespace(node) {
+			const sourceLines = sourceCode.lines;
+
+			sourceLines.forEach((sourceLine, lineIndex) => {
+				const lineNumber = lineIndex + 1;
+				let match;
+
+				while (
+					(match = IRREGULAR_WHITESPACE.exec(sourceLine)) !== null
+				) {
+					errors.push({
+						node,
+						messageId: "noIrregularWhitespace",
+						loc: {
+							start: {
+								line: lineNumber,
+								column: match.index,
+							},
+							end: {
+								line: lineNumber,
+								column: match.index + match[0].length,
+							},
+						},
+					});
+				}
+			});
+		}
+
+		/**
+		 * Checks the program source for irregular line terminators
+		 * @param {ASTNode} node The program node
+		 * @returns {void}
+		 * @private
+		 */
+		function checkForIrregularLineTerminators(node) {
+			const source = sourceCode.getText(),
+				sourceLines = sourceCode.lines,
+				linebreaks = source.match(LINE_BREAK);
+			let lastLineIndex = -1,
+				match;
+
+			while ((match = IRREGULAR_LINE_TERMINATORS.exec(source)) !== null) {
+				const lineIndex =
+					linebreaks.indexOf(match[0], lastLineIndex + 1) || 0;
+
+				errors.push({
+					node,
+					messageId: "noIrregularWhitespace",
+					loc: {
+						start: {
+							line: lineIndex + 1,
+							column: sourceLines[lineIndex].length,
+						},
+						end: {
+							line: lineIndex + 2,
+							column: 0,
+						},
+					},
+				});
+
+				lastLineIndex = lineIndex;
+			}
+		}
+
+		/**
+		 * A no-op function to act as placeholder for comment accumulation when the `skipComments` option is `false`.
+		 * @returns {void}
+		 * @private
+		 */
+		function noop() {}
+
+		const nodes = {};
+
+		if (ALL_IRREGULARS.test(sourceCode.getText())) {
+			nodes.Program = function (node) {
+				/*
+				 * As we can easily fire warnings for all white space issues with
+				 * all the source its simpler to fire them here.
+				 * This means we can check all the application code without having
+				 * to worry about issues caused in the parser tokens.
+				 * When writing this code also evaluating per node was missing out
+				 * connecting tokens in some cases.
+				 * We can later filter the errors when they are found to be not an
+				 * issue in nodes we don't care about.
+				 */
+				checkForIrregularWhitespace(node);
+				checkForIrregularLineTerminators(node);
+			};
+
+			nodes.Literal = removeInvalidNodeErrorsInLiteral;
+			nodes.TemplateElement = skipTemplates
+				? removeInvalidNodeErrorsInTemplateLiteral
+				: noop;
+			nodes.JSXText = skipJSXText
+				? removeInvalidNodeErrorsInJSXText
+				: noop;
+			nodes["Program:exit"] = function () {
+				if (skipComments) {
+					// First strip errors occurring in comment nodes.
+					commentNodes.forEach(removeInvalidNodeErrorsInComment);
+				}
+
+				// If we have any errors remaining report on them
+				errors.forEach(error => context.report(error));
+			};
+		} else {
+			nodes.Program = noop;
+		}
+
+		return nodes;
+	},
+};