eslint-plugin-unicorn 70.0.0 → 71.0.0

package/rules/utils/is-boolean.js

@@ -16,6 +16,10 @@ const booleanBinaryOperators = new Set([
 
 const booleanTypeStrings = new Set(['boolean', 'true', 'false']);
 const booleanGlobalFunctions = new Set(['isFinite', 'isNaN']);
+const nullishTypeAnnotationTypes = new Set([
+	'TSNullKeyword',
+	'TSUndefinedKeyword',
+]);
 
 const booleanStaticMethods = new Map([
 	['Array', new Set(['isArray'])],
@@ -90,28 +94,16 @@ function isBooleanCallSignatureMembers(members, context, scope, visitedTypeRefer
 		&& callSignatures.every(member => isBooleanTypeAnnotation(member.returnType, context, scope, visitedTypeReferenceNames));
 }
 
-function isBooleanTypeReference(node, context, scope, visitedTypeReferenceNames) {
-	const name = getTypeReferenceName(node.typeName);
-	if (!name || visitedTypeReferenceNames.has(name)) {
-		return false;
-	}
-
-	visitedTypeReferenceNames.add(name);
-
-	const variable = resolveVariableName(name, scope);
-	const [definition] = variable?.defs ?? [];
-	const definitionScope = definition?.type === 'Type'
-		? context.sourceCode.getScope(definition.node)
-		: scope;
-	const result = definition?.type === 'Type'
-		&& definition.node.type === 'TSTypeAliasDeclaration'
-		&& isBooleanTypeAnnotation(definition.node.typeAnnotation, context, definitionScope, visitedTypeReferenceNames);
-
-	visitedTypeReferenceNames.delete(name);
-	return result;
-}
+const hasCallSignatureMembers = members =>
+	members.some(member => member.type === 'TSCallSignatureDeclaration');
 
-function isBooleanFunctionTypeReference(node, context, scope, visitedTypeReferenceNames) {
+function isTypeReference({
+	node,
+	context,
+	scope,
+	visitedTypeReferenceNames,
+	predicate,
+}) {
 	const name = getTypeReferenceName(node.typeName);
 	if (!name || visitedTypeReferenceNames.has(name)) {
 		return false;
@@ -124,22 +116,55 @@ function isBooleanFunctionTypeReference(node, context, scope, visitedTypeReferen
 	const definitionScope = definition?.type === 'Type'
 		? context.sourceCode.getScope(definition.node)
 		: scope;
-	const result = definition?.type === 'Type'
-		&& (
-			(
-				definition.node.type === 'TSTypeAliasDeclaration'
-				&& isBooleanFunctionTypeAnnotation(definition.node.typeAnnotation, context, definitionScope, visitedTypeReferenceNames)
-			)
-			|| (
-				definition.node.type === 'TSInterfaceDeclaration'
-				&& isBooleanCallSignatureMembers(definition.node.body.body, context, definitionScope, visitedTypeReferenceNames)
-			)
-		);
+	const result = definition?.type === 'Type' && predicate(definition.node, definitionScope);
 
 	visitedTypeReferenceNames.delete(name);
 	return result;
 }
 
+const isBooleanTypeReference = (node, context, scope, visitedTypeReferenceNames) => isTypeReference(
+	{
+		node,
+		context,
+		scope,
+		visitedTypeReferenceNames,
+		predicate: (definitionNode, definitionScope) => definitionNode.type === 'TSTypeAliasDeclaration'
+			&& isBooleanTypeAnnotation(definitionNode.typeAnnotation, context, definitionScope, visitedTypeReferenceNames),
+	},
+);
+
+const isBooleanFunctionTypeReference = (node, context, scope, visitedTypeReferenceNames) => isTypeReference(
+	{
+		node,
+		context,
+		scope,
+		visitedTypeReferenceNames,
+		predicate: (definitionNode, definitionScope) => (
+			definitionNode.type === 'TSTypeAliasDeclaration'
+			&& isBooleanFunctionTypeAnnotation(definitionNode.typeAnnotation, context, definitionScope, visitedTypeReferenceNames)
+		) || (
+			definitionNode.type === 'TSInterfaceDeclaration'
+			&& isBooleanCallSignatureMembers(definitionNode.body.body, context, definitionScope, visitedTypeReferenceNames)
+		),
+	},
+);
+
+const isFunctionTypeReference = (node, context, scope, visitedTypeReferenceNames) => isTypeReference(
+	{
+		node,
+		context,
+		scope,
+		visitedTypeReferenceNames,
+		predicate: (definitionNode, definitionScope) => (
+			definitionNode.type === 'TSTypeAliasDeclaration'
+			&& isFunctionTypeAnnotation(definitionNode.typeAnnotation, context, definitionScope, visitedTypeReferenceNames)
+		) || (
+			definitionNode.type === 'TSInterfaceDeclaration'
+			&& hasCallSignatureMembers(definitionNode.body.body)
+		),
+	},
+);
+
 function isBooleanTypeAnnotation(node, context, scope, visitedTypeReferenceNames = new Set()) {
 	switch (node?.type) {
 		case 'TSTypeAnnotation':
@@ -177,6 +202,38 @@ function isBooleanTypeAnnotation(node, context, scope, visitedTypeReferenceNames
 	}
 }
 
+function isFunctionTypeAnnotation(node, context, scope, visitedTypeReferenceNames = new Set()) {
+	switch (node?.type) {
+		case 'TSTypeAnnotation':
+		case 'TSParenthesizedType': {
+			return isFunctionTypeAnnotation(node.typeAnnotation, context, scope, visitedTypeReferenceNames);
+		}
+
+		case 'TSFunctionType': {
+			return true;
+		}
+
+		case 'TSTypeLiteral': {
+			return hasCallSignatureMembers(node.members);
+		}
+
+		case 'TSTypeReference': {
+			return isFunctionTypeReference(node, context, scope, visitedTypeReferenceNames);
+		}
+
+		case 'TSUnionType': {
+			const types = node.types.filter(type => !nullishTypeAnnotationTypes.has(type.type));
+
+			return types.length > 0
+				&& types.every(type => isFunctionTypeAnnotation(type, context, scope, visitedTypeReferenceNames));
+		}
+
+		default: {
+			return false;
+		}
+	}
+}
+
 function isBooleanFunctionTypeAnnotation(node, context, scope, visitedTypeReferenceNames = new Set()) {
 	switch (node?.type) {
 		case 'TSTypeAnnotation':
@@ -599,6 +656,7 @@ export {
 	isBooleanFunctionTypeAnnotation,
 	isKnownBooleanFunctionReference,
 	isBooleanTypeAnnotation,
+	isFunctionTypeAnnotation,
 };
 
 export default isBooleanExpression;

package/rules/utils/is-identifier-name.js

@@ -0,0 +1,5 @@
+import isIdentifier from 'is-identifier';
+
+export default function isIdentifierName(name) {
+	return isIdentifier(name, {checkReserved: false});
+}

package/rules/utils/is-promise-type.js

@@ -1,7 +1,7 @@
 import {isUnknownType} from './types.js';
 
 // Best-effort check whether a TypeScript type is a promise. Returns `true`/`false` when known, `undefined` when indeterminate.
-function isPromiseType(type, checker) {
+export default function isPromiseType(type, checker) {
 	type = checker.getNonNullableType(type);
 
 	if (isUnknownType(type)) {
@@ -24,5 +24,3 @@ function isPromiseType(type, checker) {
 
 	return checker.getPromisedTypeOfPromise(type) !== undefined;
 }
-
-export default isPromiseType;

package/rules/utils/is-react-hook-name.js

@@ -0,0 +1,5 @@
+// https://github.com/facebook/react/blob/main/packages/eslint-plugin-react-hooks/src/rules/RulesOfHooks.ts
+const isReactHookName = name =>
+	name === 'use' || /^use[\dA-Z]/.test(name);
+
+export default isReactHookName;

package/rules/utils/parentheses/get-parent-syntax-opening-parenthesis.js

@@ -15,7 +15,7 @@ E.g., `if (a) {}` then the `(`.
 @param {ESLint.Rule.RuleContext} context - The ESLint rule context object.
 @returns {OpeningParenthesisToken | void} The left parenthesis of the parent node syntax
 */
-function getParentSyntaxOpeningParenthesis(node, context) {
+export default function getParentSyntaxOpeningParenthesis(node, context) {
 	const {parent} = node;
 
 	switch (parent.type) {
@@ -76,5 +76,3 @@ function getParentSyntaxOpeningParenthesis(node, context) {
 		// No default
 	}
 }
-
-export default getParentSyntaxOpeningParenthesis;

package/rules/utils/parentheses/iterate-surrounding-parentheses.js

@@ -35,7 +35,7 @@ function getSurroundingParentheses([head, tail], context) {
 
 	const tokenAfter = context.sourceCode.getTokenAfter(tail);
 
-	if (!tokenBefore || !isClosingParenthesisToken(tokenAfter)) {
+	if (!tokenAfter || !isClosingParenthesisToken(tokenAfter)) {
 		return;
 	}
 

package/rules/utils/should-add-parentheses-to-await-expression-argument.js

@@ -1,3 +1,5 @@
+import getPrecedence, {PRECEDENCE_UNARY} from './get-precedence.js';
+
 /**
 Check if parentheses should be added to a `node` when it's used as `argument` of `AwaitExpression`.
 
@@ -5,13 +7,6 @@ Check if parentheses should be added to a `node` when it's used as `argument` of
 @returns {boolean}
 */
 export default function shouldAddParenthesesToAwaitExpressionArgument(node) {
-	return [
-		'SequenceExpression',
-		'YieldExpression',
-		'ArrowFunctionExpression',
-		'ConditionalExpression',
-		'AssignmentExpression',
-		'LogicalExpression',
-		'BinaryExpression',
-	].includes(node.type);
+	// `await` has the same precedence as other unary operators.
+	return getPrecedence(node) < PRECEDENCE_UNARY;
 }

package/rules/utils/should-add-parentheses-to-call-expression-callee.js

@@ -1,3 +1,5 @@
+import getPrecedence, {PRECEDENCE_CALL} from './get-precedence.js';
+
 /**
 Check if parentheses should be added to a `node` when it's used as `callee` of `CallExpression`.
 
@@ -5,16 +7,8 @@ Check if parentheses should be added to a `node` when it's used as `callee` of `
 @returns {boolean}
 */
 export default function shouldAddParenthesesToCallExpressionCallee(node) {
-	return [
-		'SequenceExpression',
-		'YieldExpression',
-		'ArrowFunctionExpression',
-		'ConditionalExpression',
-		'AssignmentExpression',
-		'LogicalExpression',
-		'BinaryExpression',
-		'UnaryExpression',
-		'UpdateExpression',
-		'NewExpression',
-	].includes(node.type);
+	// `new Foo` (without its own call parentheses) would absorb the call's `()` into its own
+	// argument list (`new Foo()` instead of `(new Foo)()`), so it always needs parentheses
+	// regardless of its precedence.
+	return getPrecedence(node) < PRECEDENCE_CALL || node.type === 'NewExpression';
 }

package/rules/utils/should-add-parentheses-to-unary-expression.js

@@ -1,3 +1,5 @@
+import getPrecedence, {PRECEDENCE_UNARY} from './get-precedence.js';
+
 /**
 Check if parentheses should be added to a `node` when it's used as `argument` of `UnaryExpression`.
 
@@ -8,23 +10,14 @@ Check if parentheses should be added to a `node` when it's used as `argument` of
 // Prefix unary operators all share the same precedence, so the same parenthesization rules apply.
 const supportedOperators = new Set(['!', 'typeof', 'void', 'delete', '~', '+', '-']);
 
+// These are same or higher precedence than `UnaryExpression`, but still look ambiguous as its
+// argument without parentheses (`!x++`, `typeof x!`, `!<Foo>x`), so they get parenthesized too.
+const alwaysParenthesizedTypes = new Set(['UpdateExpression', 'TSNonNullExpression', 'TSTypeAssertion']);
+
 export default function shouldAddParenthesesToUnaryExpressionArgument(node, operator) {
 	if (!supportedOperators.has(operator)) {
 		throw new Error('Unexpected operator');
 	}
 
-	return [
-		'UpdateExpression',
-		'BinaryExpression',
-		'LogicalExpression',
-		'ConditionalExpression',
-		'AssignmentExpression',
-		'ArrowFunctionExpression',
-		'YieldExpression',
-		'SequenceExpression',
-		'TSAsExpression',
-		'TSSatisfiesExpression',
-		'TSNonNullExpression',
-		'TSTypeAssertion',
-	].includes(node.type);
+	return getPrecedence(node) < PRECEDENCE_UNARY || alwaysParenthesizedTypes.has(node.type);
 }

package/rules/utils/to-location.js

@@ -12,7 +12,7 @@ Get location info for the given node or range.
 @param {int} [endOffset] - End position offset.
 @returns {ESTree.SourceLocation}
 */
-function toLocation(nodeOrRange, context, startOffset = 0, endOffset = 0) {
+export default function toLocation(nodeOrRange, context, startOffset = 0, endOffset = 0) {
 	const {sourceCode} = context;
 	const [start, end] = Array.isArray(nodeOrRange) ? nodeOrRange : sourceCode.getRange(nodeOrRange);
 
@@ -21,5 +21,3 @@ function toLocation(nodeOrRange, context, startOffset = 0, endOffset = 0) {
 		end: sourceCode.getLocFromIndex(end + endOffset),
 	};
 }
-
-export default toLocation;