eslint-plugin-unicorn-ts 0.0.1-security → 50.0.1

package/rules/consistent-destructuring.js

@@ -0,0 +1,168 @@
+'use strict';
+const avoidCapture = require('./utils/avoid-capture.js');
+const isLeftHandSide = require('./utils/is-left-hand-side.js');
+const {isCallOrNewExpression} = require('./ast/index.js');
+
+const MESSAGE_ID = 'consistentDestructuring';
+const MESSAGE_ID_SUGGEST = 'consistentDestructuringSuggest';
+
+const isSimpleExpression = expression => {
+	while (expression) {
+		if (expression.computed) {
+			return false;
+		}
+
+		if (expression.type !== 'MemberExpression') {
+			break;
+		}
+
+		expression = expression.object;
+	}
+
+	return expression.type === 'Identifier'
+		|| expression.type === 'ThisExpression';
+};
+
+const isChildInParentScope = (child, parent) => {
+	while (child) {
+		if (child === parent) {
+			return true;
+		}
+
+		child = child.upper;
+	}
+
+	return false;
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const {sourceCode} = context;
+	const declarations = new Map();
+
+	return {
+		VariableDeclarator(node) {
+			if (!(
+				node.id.type === 'ObjectPattern'
+				&& node.init
+				&& node.init.type !== 'Literal'
+				// Ignore any complex expressions (e.g. arrays, functions)
+				&& isSimpleExpression(node.init)
+			)) {
+				return;
+			}
+
+			declarations.set(sourceCode.getText(node.init), {
+				scope: sourceCode.getScope(node),
+				variables: sourceCode.getDeclaredVariables(node),
+				objectPattern: node.id,
+			});
+		},
+		MemberExpression(node) {
+			if (
+				node.computed
+				|| (
+					isCallOrNewExpression(node.parent)
+					&& node.parent.callee === node
+				)
+				|| isLeftHandSide(node)
+			) {
+				return;
+			}
+
+			const declaration = declarations.get(sourceCode.getText(node.object));
+
+			if (!declaration) {
+				return;
+			}
+
+			const {scope, objectPattern} = declaration;
+			const memberScope = sourceCode.getScope(node);
+
+			// Property is destructured outside the current scope
+			if (!isChildInParentScope(memberScope, scope)) {
+				return;
+			}
+
+			const destructurings = objectPattern.properties.filter(property =>
+				property.type === 'Property'
+				&& property.key.type === 'Identifier'
+				&& property.value.type === 'Identifier',
+			);
+			const lastProperty = objectPattern.properties.at(-1);
+
+			const hasRest = lastProperty && lastProperty.type === 'RestElement';
+
+			const expression = sourceCode.getText(node);
+			const member = sourceCode.getText(node.property);
+
+			// Member might already be destructured
+			const destructuredMember = destructurings.find(property =>
+				property.key.name === member,
+			);
+
+			if (!destructuredMember) {
+				// Don't destructure additional members when rest is used
+				if (hasRest) {
+					return;
+				}
+
+				// Destructured member collides with an existing identifier
+				if (avoidCapture(member, [memberScope]) !== member) {
+					return;
+				}
+			}
+
+			// Don't try to fix nested member expressions
+			if (node.parent.type === 'MemberExpression') {
+				return {
+					node,
+					messageId: MESSAGE_ID,
+				};
+			}
+
+			const newMember = destructuredMember ? destructuredMember.value.name : member;
+
+			return {
+				node,
+				messageId: MESSAGE_ID,
+				suggest: [{
+					messageId: MESSAGE_ID_SUGGEST,
+					data: {
+						expression,
+						property: newMember,
+					},
+					* fix(fixer) {
+						const {properties} = objectPattern;
+						const lastProperty = properties.at(-1);
+
+						yield fixer.replaceText(node, newMember);
+
+						if (!destructuredMember) {
+							yield lastProperty
+								? fixer.insertTextAfter(lastProperty, `, ${newMember}`)
+								: fixer.replaceText(objectPattern, `{${newMember}}`);
+						}
+					},
+				}],
+			};
+		},
+	};
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Use destructured variables over properties.',
+		},
+		fixable: 'code',
+		hasSuggestions: true,
+		messages: {
+			[MESSAGE_ID]: 'Use destructured variables over properties.',
+			[MESSAGE_ID_SUGGEST]: 'Replace `{{expression}}` with destructured property `{{property}}`.',
+		},
+	},
+};

package/rules/consistent-function-scoping.js

@@ -0,0 +1,223 @@
+'use strict';
+const {getFunctionHeadLocation, getFunctionNameWithKind} = require('@eslint-community/eslint-utils');
+const {
+	getReferences,
+	isNodeMatches,
+} = require('./utils/index.js');
+const {
+	functionTypes,
+} = require('./ast/index.js');
+
+const MESSAGE_ID = 'consistent-function-scoping';
+const messages = {
+	[MESSAGE_ID]: 'Move {{functionNameWithKind}} to the outer scope.',
+};
+
+const isSameScope = (scope1, scope2) =>
+	scope1 && scope2 && (scope1 === scope2 || scope1.block === scope2.block);
+
+function checkReferences(scope, parent, scopeManager) {
+	const hitReference = references => references.some(reference => {
+		if (isSameScope(parent, reference.from)) {
+			return true;
+		}
+
+		const {resolved} = reference;
+		const [definition] = resolved.defs;
+
+		// Skip recursive function name
+		if (definition?.type === 'FunctionName' && resolved.name === definition.name.name) {
+			return false;
+		}
+
+		return isSameScope(parent, resolved.scope);
+	});
+
+	const hitDefinitions = definitions => definitions.some(definition => {
+		const scope = scopeManager.acquire(definition.node);
+		return isSameScope(parent, scope);
+	});
+
+	// This check looks for neighboring function definitions
+	const hitIdentifier = identifiers => identifiers.some(identifier => {
+		// Only look at identifiers that live in a FunctionDeclaration
+		if (
+			!identifier.parent
+			|| identifier.parent.type !== 'FunctionDeclaration'
+		) {
+			return false;
+		}
+
+		const identifierScope = scopeManager.acquire(identifier);
+
+		// If we have a scope, the earlier checks should have worked so ignore them here
+		/* c8 ignore next 3 */
+		if (identifierScope) {
+			return false;
+		}
+
+		const identifierParentScope = scopeManager.acquire(identifier.parent);
+		/* c8 ignore next 3 */
+		if (!identifierParentScope) {
+			return false;
+		}
+
+		// Ignore identifiers from our own scope
+		if (isSameScope(scope, identifierParentScope)) {
+			return false;
+		}
+
+		// Look at the scope above the function definition to see if lives
+		// next to the reference being checked
+		return isSameScope(parent, identifierParentScope.upper);
+	});
+
+	return getReferences(scope)
+		.map(({resolved}) => resolved)
+		.filter(Boolean)
+		.some(variable =>
+			hitReference(variable.references)
+			|| hitDefinitions(variable.defs)
+			|| hitIdentifier(variable.identifiers),
+		);
+}
+
+// https://reactjs.org/docs/hooks-reference.html
+const reactHooks = [
+	'useState',
+	'useEffect',
+	'useContext',
+	'useReducer',
+	'useCallback',
+	'useMemo',
+	'useRef',
+	'useImperativeHandle',
+	'useLayoutEffect',
+	'useDebugValue',
+].flatMap(hookName => [hookName, `React.${hookName}`]);
+
+const isReactHook = scope =>
+	scope.block?.parent?.callee
+	&& isNodeMatches(scope.block.parent.callee, reactHooks);
+
+const isArrowFunctionWithThis = scope =>
+	scope.type === 'function'
+	&& scope.block?.type === 'ArrowFunctionExpression'
+	&& (scope.thisFound || scope.childScopes.some(scope => isArrowFunctionWithThis(scope)));
+
+const iifeFunctionTypes = new Set([
+	'FunctionExpression',
+	'ArrowFunctionExpression',
+]);
+const isIife = node =>
+	iifeFunctionTypes.has(node.type)
+	&& node.parent.type === 'CallExpression'
+	&& node.parent.callee === node;
+
+function checkNode(node, scopeManager) {
+	const scope = scopeManager.acquire(node);
+
+	if (!scope || isArrowFunctionWithThis(scope)) {
+		return true;
+	}
+
+	let parentNode = node.parent;
+
+	// Skip over junk like the block statement inside of a function declaration
+	// or the various pieces of an arrow function.
+
+	if (parentNode.type === 'VariableDeclarator') {
+		parentNode = parentNode.parent;
+	}
+
+	if (parentNode.type === 'VariableDeclaration') {
+		parentNode = parentNode.parent;
+	}
+
+	if (parentNode.type === 'BlockStatement') {
+		parentNode = parentNode.parent;
+	}
+
+	const parentScope = scopeManager.acquire(parentNode);
+	if (
+		!parentScope
+		|| parentScope.type === 'global'
+		|| isReactHook(parentScope)
+		|| isIife(parentNode)
+	) {
+		return true;
+	}
+
+	return checkReferences(scope, parentScope, scopeManager);
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const {checkArrowFunctions} = {checkArrowFunctions: true, ...context.options[0]};
+	const {sourceCode} = context;
+	const {scopeManager} = sourceCode;
+
+	const functions = [];
+
+	context.on(functionTypes, () => {
+		functions.push(false);
+	});
+
+	context.on('JSXElement', () => {
+		// Turn off this rule if we see a JSX element because scope
+		// references does not include JSXElement nodes.
+		if (functions.length > 0) {
+			functions[functions.length - 1] = true;
+		}
+	});
+
+	context.onExit(functionTypes, node => {
+		const currentFunctionHasJsx = functions.pop();
+		if (currentFunctionHasJsx) {
+			return;
+		}
+
+		if (node.type === 'ArrowFunctionExpression' && !checkArrowFunctions) {
+			return;
+		}
+
+		if (checkNode(node, scopeManager)) {
+			return;
+		}
+
+		return {
+			node,
+			loc: getFunctionHeadLocation(node, sourceCode),
+			messageId: MESSAGE_ID,
+			data: {
+				functionNameWithKind: getFunctionNameWithKind(node, sourceCode),
+			},
+		};
+	});
+};
+
+const schema = [
+	{
+		type: 'object',
+		additionalProperties: false,
+		properties: {
+			checkArrowFunctions: {
+				type: 'boolean',
+				default: true,
+			},
+		},
+	},
+];
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Move function definitions to the highest possible scope.',
+		},
+		schema,
+		messages,
+	},
+};

package/rules/custom-error-definition.js

@@ -0,0 +1,215 @@
+'use strict';
+const {upperFirst} = require('./utils/lodash.js');
+
+const MESSAGE_ID_INVALID_EXPORT = 'invalidExport';
+const messages = {
+	[MESSAGE_ID_INVALID_EXPORT]: 'Exported error name should match error class',
+};
+
+const nameRegexp = /^(?:[A-Z][\da-z]*)*Error$/;
+
+const getClassName = name => upperFirst(name).replace(/(?:error|)$/i, 'Error');
+
+const getConstructorMethod = className => `
+	constructor() {
+		super();
+		this.name = '${className}';
+	}
+`;
+
+const hasValidSuperClass = node => {
+	if (!node.superClass) {
+		return false;
+	}
+
+	let {name, type, property} = node.superClass;
+
+	if (type === 'MemberExpression') {
+		({name} = property);
+	}
+
+	return nameRegexp.test(name);
+};
+
+const isSuperExpression = node =>
+	node.type === 'ExpressionStatement'
+	&& node.expression.type === 'CallExpression'
+	&& node.expression.callee.type === 'Super';
+
+const isAssignmentExpression = (node, name) => {
+	if (
+		node.type !== 'ExpressionStatement'
+		|| node.expression.type !== 'AssignmentExpression'
+	) {
+		return false;
+	}
+
+	const lhs = node.expression.left;
+
+	if (!lhs.object || lhs.object.type !== 'ThisExpression') {
+		return false;
+	}
+
+	return lhs.property.name === name;
+};
+
+const isPropertyDefinition = (node, name) =>
+	node.type === 'PropertyDefinition'
+	&& !node.computed
+	&& node.key.type === 'Identifier'
+	&& node.key.name === name;
+
+function * customErrorDefinition(context, node) {
+	if (!hasValidSuperClass(node)) {
+		return;
+	}
+
+	if (node.id === null) {
+		return;
+	}
+
+	const {name} = node.id;
+	const className = getClassName(name);
+
+	if (name !== className) {
+		yield {
+			node: node.id,
+			message: `Invalid class name, use \`${className}\`.`,
+		};
+	}
+
+	const {body, range} = node.body;
+	const constructor = body.find(x => x.kind === 'constructor');
+
+	if (!constructor) {
+		yield {
+			node,
+			message: 'Add a constructor to your error.',
+			fix: fixer => fixer.insertTextAfterRange([
+				range[0],
+				range[0] + 1,
+			], getConstructorMethod(name)),
+		};
+		return;
+	}
+
+	const constructorBodyNode = constructor.value.body;
+
+	// Verify the constructor has a body (TypeScript)
+	if (!constructorBodyNode) {
+		return;
+	}
+
+	const constructorBody = constructorBodyNode.body;
+
+	const superExpression = constructorBody.find(body => isSuperExpression(body));
+	const messageExpressionIndex = constructorBody.findIndex(x => isAssignmentExpression(x, 'message'));
+
+	if (!superExpression) {
+		yield {
+			node: constructorBodyNode,
+			message: 'Missing call to `super()` in constructor.',
+		};
+	} else if (messageExpressionIndex !== -1) {
+		const expression = constructorBody[messageExpressionIndex];
+
+		yield {
+			node: superExpression,
+			message: 'Pass the error message to `super()` instead of setting `this.message`.',
+			* fix(fixer) {
+				if (superExpression.expression.arguments.length === 0) {
+					const rhs = expression.expression.right;
+					yield fixer.insertTextAfterRange([
+						superExpression.range[0],
+						superExpression.range[0] + 6,
+					], rhs.raw || rhs.name);
+				}
+
+				yield fixer.removeRange([
+					messageExpressionIndex === 0 ? constructorBodyNode.range[0] : constructorBody[messageExpressionIndex - 1].range[1],
+					expression.range[1],
+				]);
+			},
+		};
+	}
+
+	const nameExpression = constructorBody.find(x => isAssignmentExpression(x, 'name'));
+	if (!nameExpression) {
+		const nameProperty = body.find(node => isPropertyDefinition(node, 'name'));
+
+		if (!nameProperty?.value || nameProperty.value.value !== name) {
+			yield {
+				node: nameProperty?.value ?? constructorBodyNode,
+				message: `The \`name\` property should be set to \`${name}\`.`,
+			};
+		}
+	} else if (nameExpression.expression.right.value !== name) {
+		yield {
+			node: nameExpression?.expression.right ?? constructorBodyNode,
+			message: `The \`name\` property should be set to \`${name}\`.`,
+		};
+	}
+}
+
+const customErrorExport = (context, node) => {
+	const exportsName = node.left.property.name;
+
+	const maybeError = node.right;
+
+	if (maybeError.type !== 'ClassExpression') {
+		return;
+	}
+
+	if (!hasValidSuperClass(maybeError)) {
+		return;
+	}
+
+	if (!maybeError.id) {
+		return;
+	}
+
+	// Assume rule has already fixed the error name
+	const errorName = maybeError.id.name;
+
+	if (exportsName === errorName) {
+		return;
+	}
+
+	return {
+		node: node.left.property,
+		messageId: MESSAGE_ID_INVALID_EXPORT,
+		fix: fixer => fixer.replaceText(node.left.property, errorName),
+	};
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	context.on('ClassDeclaration', node => customErrorDefinition(context, node));
+	context.on('AssignmentExpression', node => {
+		if (node.right.type === 'ClassExpression') {
+			return customErrorDefinition(context, node.right);
+		}
+	});
+	context.on('AssignmentExpression', node => {
+		if (
+			node.left.type === 'MemberExpression'
+			&& node.left.object.type === 'Identifier'
+			&& node.left.object.name === 'exports'
+		) {
+			return customErrorExport(context, node);
+		}
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Enforce correct `Error` subclassing.',
+		},
+		fixable: 'code',
+		messages,
+	},
+};

package/rules/empty-brace-spaces.js

@@ -0,0 +1,72 @@
+'use strict';
+const {isOpeningBraceToken} = require('@eslint-community/eslint-utils');
+
+const MESSAGE_ID = 'empty-brace-spaces';
+const messages = {
+	[MESSAGE_ID]: 'Do not add spaces between braces.',
+};
+
+const getProblem = (node, context) => {
+	const {sourceCode} = context;
+	const filter = node.type === 'RecordExpression'
+		? token => token.type === 'Punctuator' && (token.value === '#{' || token.value === '{|')
+		: isOpeningBraceToken;
+	const openingBrace = sourceCode.getFirstToken(node, {filter});
+	const closingBrace = sourceCode.getLastToken(node);
+	const [, start] = openingBrace.range;
+	const [end] = closingBrace.range;
+	const textBetween = sourceCode.text.slice(start, end);
+
+	if (!/^\s+$/.test(textBetween)) {
+		return;
+	}
+
+	return {
+		loc: {
+			start: openingBrace.loc.end,
+			end: closingBrace.loc.start,
+		},
+		messageId: MESSAGE_ID,
+		fix: fixer => fixer.removeRange([start, end]),
+	};
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	context.on([
+		'BlockStatement',
+		'ClassBody',
+		'StaticBlock',
+	], node => {
+		if (node.body.length > 0) {
+			return;
+		}
+
+		return getProblem(node, context);
+	});
+
+	context.on([
+		'ObjectExpression',
+		// Experimental https://github.com/tc39/proposal-record-tuple
+		'RecordExpression',
+	], node => {
+		if (node.properties.length > 0) {
+			return;
+		}
+
+		return getProblem(node, context);
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'layout',
+		docs: {
+			description: 'Enforce no spaces between braces.',
+		},
+		fixable: 'whitespace',
+		messages,
+	},
+};