eslint-plugin-unicorn 70.0.0 → 71.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "eslint-plugin-unicorn",
-	"version": "70.0.0",
+	"version": "71.1.0",
 	"description": "More than 300 powerful ESLint rules",
 	"license": "MIT",
 	"repository": {
@@ -62,58 +62,59 @@
 		"xo"
 	],
 	"dependencies": {
-		"@babel/helper-validator-identifier": "^7.29.7",
 		"@eslint-community/eslint-utils": "^4.9.1",
-		"browserslist": "^4.28.2",
+		"browserslist": "^4.28.4",
 		"change-case": "^5.4.4",
 		"ci-info": "^4.4.0",
 		"core-js-compat": "^3.49.0",
 		"detect-indent": "^7.0.2",
 		"find-up-simple": "^1.0.1",
-		"globals": "^17.6.0",
+		"globals": "^17.7.0",
 		"indent-string": "^5.0.0",
 		"is-builtin-module": "^5.0.0",
-		"jsesc": "^3.1.0",
+		"is-identifier": "^1.1.0",
 		"pluralize": "^8.0.0",
-		"regjsparser": "^0.13.1",
-		"semver": "^7.8.4",
+		"quote-js-string": "^0.1.0",
+		"regjsparser": "^0.13.2",
+		"reserved-identifiers": "^1.2.0",
+		"semver": "^7.8.5",
 		"strip-indent": "^4.1.1"
 	},
 	"devDependencies": {
-		"@babel/code-frame": "^8.0.0-rc.6",
-		"@eslint/css": "^1.3.0",
+		"@babel/code-frame": "^8.0.0",
+		"@eslint/css": "^1.4.0",
 		"@eslint/eslintrc": "^3.3.5",
-		"@eslint/json": "^2.0.0",
-		"@eslint/markdown": "^8.0.2",
-		"@html-eslint/eslint-plugin": "^0.62.0",
-		"@html-eslint/parser": "^0.62.0",
+		"@eslint/json": "^2.0.1",
+		"@eslint/markdown": "^8.0.3",
+		"@html-eslint/eslint-plugin": "^0.63.0",
+		"@html-eslint/parser": "^0.63.0",
 		"@lubien/fixture-beta-package": "^1.0.0-beta.1",
-		"@typescript-eslint/parser": "^8.61.0",
-		"@typescript-eslint/types": "^8.61.0",
+		"@typescript-eslint/parser": "^8.62.1",
+		"@typescript-eslint/types": "^8.62.1",
 		"ava": "^8.0.1",
 		"c8": "^11.0.0",
 		"enquirer": "^2.4.1",
-		"eslint": "^10.4.1",
+		"eslint": "^10.6.0",
 		"eslint-ava-rule-tester": "^5.0.1",
-		"eslint-config-xo": "^0.52.0",
+		"eslint-config-xo": "^0.56.0",
 		"eslint-doc-generator": "^3.6.0",
-		"eslint-plugin-eslint-plugin": "^7.4.0",
-		"eslint-plugin-jsdoc": "^63.0.2",
-		"eslint-plugin-unicorn": "^65.0.1",
+		"eslint-plugin-eslint-plugin": "^7.4.1",
+		"eslint-plugin-jsdoc": "^63.0.11",
+		"eslint-plugin-unicorn": "^70.0.0",
 		"eslint-remote-tester": "^4.0.4",
 		"eslint-remote-tester-repositories": "^2.0.2",
 		"eslint-scope": "^9.1.2",
 		"espree": "^11.2.0",
-		"listr2": "^10.2.1",
-		"markdownlint-cli": "^0.48.0",
+		"listr2": "^10.2.2",
+		"markdownlint-cli": "^0.49.0",
 		"nano-spawn": "^2.1.0",
 		"node-style-text": "^2.1.2",
-		"npm-package-json-lint": "^10.4.0",
-		"npm-run-all2": "^9.0.1",
+		"npm-package-json-lint": "^10.4.1",
+		"npm-run-all2": "^9.0.2",
 		"open-editor": "^6.0.0",
 		"outdent": "^0.8.0",
 		"pretty-ms": "^9.3.0",
-		"svelte": "^5.56.3",
+		"svelte": "^5.56.4",
 		"svelte-eslint-parser": "^1.8.0",
 		"typescript": "^6.0.3",
 		"vue-eslint-parser": "^10.4.1",

package/readme.md

@@ -391,7 +391,7 @@ export default defineConfig([
 | [prefer-top-level-await](docs/rules/prefer-top-level-await.md)                                             | Prefer top-level await over top-level promises and async function calls.                                                       | ✅ ☑️ |    | 💡 |    |
 | [prefer-type-error](docs/rules/prefer-type-error.md)                                                       | Enforce throwing `TypeError` in type checking conditions.                                                                      | ✅ ☑️ | 🔧 |    |    |
 | [prefer-type-literal-last](docs/rules/prefer-type-literal-last.md)                                         | Require type literals to be last in union types.                                                                               | ✅    | 🔧 |    |    |
-| [prefer-uint8array-base64](docs/rules/prefer-uint8array-base64.md)                                         | Prefer `Uint8Array#toBase64()` and `Uint8Array.fromBase64()` over `atob()`, `btoa()`, and `Buffer` base64 conversions.         | ✅ ☑️ |    | 💡 |    |
+| [prefer-uint8array-base64](docs/rules/prefer-uint8array-base64.md)                                         | Prefer `Uint8Array#toBase64()` and `Uint8Array.fromBase64()` over `atob()`, `btoa()`, and `Buffer` base64 conversions.         |      |    | 💡 |    |
 | [prefer-unary-minus](docs/rules/prefer-unary-minus.md)                                                     | Prefer the unary minus operator over multiplying or dividing by `-1`.                                                          | ✅ ☑️ | 🔧 |    |    |
 | [prefer-unicode-code-point-escapes](docs/rules/prefer-unicode-code-point-escapes.md)                       | Prefer Unicode code point escapes over legacy escape sequences.                                                                | ✅ ☑️ | 🔧 | 💡 |    |
 | [prefer-url-can-parse](docs/rules/prefer-url-can-parse.md)                                                 | Prefer `URL.canParse()` over constructing a `URL` in a try/catch for validation.                                               | ✅ ☑️ | 🔧 |    |    |
@@ -566,3 +566,7 @@ export default defineConfig([
 
 - [Sindre Sorhus](https://github.com/sindresorhus)
 - [Fisker Cheung](https://github.com/fisker)
+
+## Related
+
+- [eslint-node-test](https://github.com/sindresorhus/eslint-node-test) — ESLint rules for the Node.js built-in test runner.

package/rules/ast/call-or-new-expression.js

@@ -79,18 +79,12 @@ function create(node, options, types) {
 		}
 	}
 
-	if (
-		Array.isArray(names)
+	return !(Array.isArray(names)
 		&& names.length > 0
 		&& (
 			node.callee.type !== 'Identifier'
 			|| !names.includes(node.callee.name)
-		)
-	) {
-		return false;
-	}
-
-	return true;
+		));
 }
 
 /**

package/rules/ast/is-member-expression.js

@@ -83,16 +83,10 @@ export default function isMemberExpression(node, options) {
 		return false;
 	}
 
-	if (
-		Array.isArray(objects)
+	return !(Array.isArray(objects)
 		&& objects.length > 0
 		&& (
 			node.object.type !== 'Identifier'
 			|| !objects.includes(node.object.name)
-		)
-	) {
-		return false;
-	}
-
-	return true;
+		));
 }

package/rules/comment-content.js

@@ -346,7 +346,7 @@ const pathTerminatorCharacters = '"\'`<>';
 const packageSpecifierTerminatorCharacters = '"\'`()[]{}<>,';
 const domainLeadingPunctuation = '([{<';
 const domainTrailingPunctuation = '.,;:!?)]}>';
-const maskCharacter = '\uFFFF';
+const maskCharacter = '\u{FFFF}';
 const openBrackets = '([{';
 const closeBrackets = ')]}';
 const quoteCharacters = '"\'`';
@@ -1062,14 +1062,14 @@ const create = context => {
 		return;
 	}
 
-	let checked = false;
+	let isChecked = false;
 
 	onRoot(context, function * (node) {
-		if (checked) {
+		if (isChecked) {
 			return;
 		}
 
-		checked = true;
+		isChecked = true;
 
 		const {sourceCode} = context;
 		const comments = getRuleComments(context);

package/rules/consistent-boolean-name.js

@@ -6,9 +6,11 @@ import {
 	getAvailableVariableName,
 	getScopes,
 	getVariableIdentifiers,
+	isReactHookName,
 	isNullishType,
 	isTypeParameterType,
 	isUnknownType,
+	lowerFirst,
 	upperFirst,
 } from './utils/index.js';
 import {
@@ -17,6 +19,7 @@ import {
 	isBooleanFunctionReference,
 	isBooleanFunctionTypeAnnotation,
 	isBooleanTypeAnnotation,
+	isFunctionTypeAnnotation,
 } from './utils/is-boolean.js';
 
 const MESSAGE_ID = 'consistent-boolean-name';
@@ -78,6 +81,7 @@ const unknownTypeAnnotationTypes = new Set([
 	'TSNeverKeyword',
 	'TSUnknownKeyword',
 ]);
+const promiseValueTypeNames = new Set(['Promise', 'PromiseLike']);
 const nonBooleanExpressionTypes = new Set([
 	'ArrayExpression',
 	'ObjectExpression',
@@ -98,6 +102,8 @@ const typeScriptExpressionWrapperTypes = new Set([
 ]);
 const isUpperCase = string => string === string.toUpperCase();
 const stripLeadingUnderscores = name => name.replace(/^_+/, '');
+const isScreamingCase = name => /^[A-Z][\dA-Z_]*$/.test(stripLeadingUnderscores(name));
+const hasReactReferenceSuffix = name => /(?:Ref|Reference)$/.test(stripLeadingUnderscores(name));
 
 const isFunction = node => [
 	'ArrowFunctionExpression',
@@ -180,6 +186,18 @@ function getReplacementName(name, prefix) {
 		: `${leadingUnderscores}${prefix}${upperFirst(nameWithoutLeadingUnderscores)}`;
 }
 
+function getReactHookReplacementName({name, nameForPrefixCheck}, prefix) {
+	if (name === nameForPrefixCheck) {
+		return getReplacementName(name, prefix);
+	}
+
+	const hookName = isScreamingCase(nameForPrefixCheck)
+		? getReplacementName(nameForPrefixCheck, prefix)
+		: `${prefix}${upperFirst(nameForPrefixCheck)}`;
+
+	return `use${upperFirst(hookName)}`;
+}
+
 const isExportedIdentifier = identifier => {
 	if (
 		identifier.parent.type === 'VariableDeclarator'
@@ -223,6 +241,26 @@ const shouldSuggestRename = variable => getVariableIdentifiers(variable)
 		&& identifier.type !== 'JSXIdentifier',
 	);
 
+function isDestructuredDefinition(definition) {
+	for (let node = definition.name; node && node !== definition.node; node = node.parent) {
+		if (
+			node.type === 'ObjectPattern'
+			|| node.type === 'ArrayPattern'
+		) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+const isDestructuredVariable = variable =>
+	variable.defs.length > 0
+	&& variable.defs.every(definition => isDestructuredDefinition(definition));
+
+const hasWriteAfterInitialization = variable =>
+	variable.references.some(reference => !reference.init && reference.isWrite());
+
 const isBooleanFunctionDefinition = (definition, context) =>
 	definition.type === 'FunctionName'
 	&& isFunction(definition.node)
@@ -264,6 +302,78 @@ function getFunctionDefinitions(variable) {
 	return overloadDefinitions.length > 0 ? overloadDefinitions : variable.defs;
 }
 
+function hasAsyncFunctionImplementation(definitions) {
+	return definitions.some(definition => isFunction(definition.node) && definition.node.async);
+}
+
+function hasGeneratorFunctionImplementation(definitions) {
+	return definitions.some(definition => isFunction(definition.node) && definition.node.generator);
+}
+
+function isReactHookFunctionBinding(variable, context) {
+	if (
+		variable.name === 'use'
+		|| !isReactHookName(variable.name)
+	) {
+		return false;
+	}
+
+	if (getFunctionDefinitions(variable)) {
+		return true;
+	}
+
+	const definition = getSupportedVariableDefinition(variable);
+
+	if (definition?.type === 'FunctionName') {
+		return isFunction(definition.node);
+	}
+
+	return definition?.type === 'Variable'
+		&& (
+			isFunction(definition.node.init)
+			|| isFunctionTypeAnnotation(definition.name.typeAnnotation, context, context.sourceCode.getScope(definition.name))
+		);
+}
+
+function getNameForPrefixCheck(variable, context) {
+	if (!isReactHookFunctionBinding(variable, context)) {
+		return variable.name;
+	}
+
+	const hookName = variable.name.slice(3);
+
+	return isScreamingCase(hookName) ? hookName : lowerFirst(hookName);
+}
+
+function isReactUseReferenceCall(node) {
+	if (node?.type !== 'CallExpression') {
+		return false;
+	}
+
+	const {callee} = node;
+	if (callee.type === 'Identifier') {
+		return callee.name === 'useRef';
+	}
+
+	return callee.type === 'MemberExpression'
+		&& !callee.computed
+		&& !callee.optional
+		&& callee.object.type === 'Identifier'
+		&& callee.object.name === 'React'
+		&& callee.property.type === 'Identifier'
+		&& callee.property.name === 'useRef';
+}
+
+function isBooleanReactReferenceVariable(variable, context) {
+	const definition = getSupportedVariableDefinition(variable);
+
+	return definition?.type === 'Variable'
+		&& !hasWriteAfterInitialization(variable)
+		&& hasReactReferenceSuffix(variable.name)
+		&& isReactUseReferenceCall(definition.node.init)
+		&& getExpressionBooleanState(definition.node.init.arguments[0], context) === boolean;
+}
+
 function combineBooleanStates(states) {
 	if (
 		states.length === 0
@@ -376,6 +486,8 @@ function getTypeReferenceName(typeName) {
 	}
 }
 
+const getTypeArguments = node => node?.typeArguments?.params ?? node?.typeParameters?.params;
+
 const getTypeState = typeState => ({
 	visitedTypeReferenceNames: new Set(),
 	functionTypesAreBoolean: true,
@@ -412,7 +524,7 @@ function getTypeReferenceBooleanState(node, context, scope, typeState) {
 		const definitionScope = context.sourceCode.getScope(definition.node);
 
 		if (definition.node.type === 'TSTypeAliasDeclaration') {
-			result = getTypeAnnotationBooleanState(definition.node.typeAnnotation, context, definitionScope, normalizedTypeState);
+			result = getDirectTypeAnnotationBooleanState(definition.node.typeAnnotation, context, definitionScope, normalizedTypeState);
 		} else if (definition.node.type === 'TSInterfaceDeclaration') {
 			result = getTypeMembersBooleanState(definition.node.body.body, context, definitionScope, normalizedTypeState);
 		}
@@ -492,22 +604,119 @@ function getTypeAnnotationBooleanState(node, context, scope, typeState) {
 	return getSimpleTypeAnnotationBooleanState(node);
 }
 
-function getFunctionBooleanState(node, context, visitedVariables = new Set()) {
-	if (node.async || node.generator) {
-		return nonBoolean;
+function getPromisedTypeAnnotationBooleanState(node, context, scope, typeState) {
+	const normalizedTypeState = getTypeState(typeState);
+
+	if (
+		node?.type === 'TSTypeAnnotation'
+		|| node?.type === 'TSParenthesizedType'
+	) {
+		return getPromisedTypeAnnotationBooleanState(node.typeAnnotation, context, scope, normalizedTypeState);
 	}
 
-	const stateFromTypeInformation = getTypeInformationBooleanState(node, context);
-	if (stateFromTypeInformation !== unknown) {
-		return stateFromTypeInformation;
+	if (node?.type !== 'TSTypeReference') {
+		return unknown;
+	}
+
+	const name = getTypeReferenceName(node.typeName);
+	const typeArguments = getTypeArguments(node);
+	if (
+		name === 'Promise'
+		&& typeArguments?.length === 1
+		&& isGlobalTypeReferenceName(name, scope)
+	) {
+		return getTypeAnnotationBooleanState(typeArguments[0], context, scope, normalizedTypeState);
+	}
+
+	return unknown;
+}
+
+function isGlobalTypeReferenceName(name, scope) {
+	return (resolveVariableName(name, scope)?.defs ?? []).every(definition => definition.type !== 'Type');
+}
+
+function isGlobalPromiseTypeReference(node, scope) {
+	if (node?.type !== 'TSTypeReference') {
+		return false;
+	}
+
+	const typeName = getTypeReferenceName(node.typeName);
+	return promiseValueTypeNames.has(typeName)
+		&& getTypeArguments(node)?.length === 1
+		&& isGlobalTypeReferenceName(typeName, scope);
+}
+
+function isGlobalPromiseTypeAnnotation(node, scope) {
+	if (
+		node?.type === 'TSTypeAnnotation'
+		|| node?.type === 'TSParenthesizedType'
+	) {
+		return isGlobalPromiseTypeAnnotation(node.typeAnnotation, scope);
+	}
+
+	if (node?.type === 'TSUnionType') {
+		const types = node.types.filter(type => !nullishTypeAnnotationTypes.has(type.type));
+		return types.length > 0 && types.every(type => isGlobalPromiseTypeAnnotation(type, scope));
+	}
+
+	return isGlobalPromiseTypeReference(node, scope);
+}
+
+function getPromisedTypeBooleanState(type, checker) {
+	const promisedType = checker.getPromisedTypeOfPromise(type);
+	return promisedType ? getTypeBooleanState(promisedType, checker, new Set(), false) : unknown;
+}
+
+function getAsyncFunctionTypeInformationBooleanState(node, context) {
+	const {parserServices} = context.sourceCode;
+	if (!parserServices?.program) {
+		return unknown;
+	}
+
+	try {
+		const checker = parserServices.program.getTypeChecker();
+		const typeScriptNode = parserServices.esTreeNodeToTSNodeMap.get(node);
+		const signature = checker.getSignatureFromDeclaration(typeScriptNode);
+		if (signature) {
+			return getPromisedTypeBooleanState(checker.getReturnTypeOfSignature(signature), checker);
+		}
+
+		return combineBooleanStates(
+			parserServices.getTypeAtLocation(node)
+				.getCallSignatures()
+				.map(signature => getPromisedTypeBooleanState(checker.getReturnTypeOfSignature(signature), checker)),
+		);
+	} catch {
+		return unknown;
+	}
+}
+
+function getFunctionBooleanState(node, context, visitedVariables = new Set(), isAsync = node.async) {
+	if (node.generator) {
+		return nonBoolean;
 	}
 
 	const scope = context.sourceCode.getScope(node);
-	const stateFromReturnType = getTypeAnnotationBooleanState(node.returnType, context, scope, {functionTypesAreBoolean: false});
+	// Only actual async function implementations and their overload signatures get `Promise<T>` unwrapped as a predicate return. Promise-valued variables and unrelated type-only callable signatures stay outside this boundary.
+	const stateFromPromisedReturnType = isAsync
+		? getPromisedTypeAnnotationBooleanState(node.returnType, context, scope, {functionTypesAreBoolean: false})
+		: unknown;
+	if (stateFromPromisedReturnType !== unknown) {
+		return stateFromPromisedReturnType;
+	}
+
+	const stateFromReturnType = isAsync ? unknown : getTypeAnnotationBooleanState(node.returnType, context, scope, {functionTypesAreBoolean: false});
 	if (stateFromReturnType !== unknown) {
 		return stateFromReturnType;
 	}
 
+	const stateFromTypeInformation = isAsync
+		? getAsyncFunctionTypeInformationBooleanState(node, context)
+		: getTypeInformationBooleanState(node, context);
+	if (stateFromTypeInformation !== unknown) {
+		return stateFromTypeInformation;
+	}
+
 	if (!node.body) {
 		return unknown;
 	}
@@ -624,7 +833,7 @@ function getExpressionBooleanState(node, context, visitedVariables = new Set(),
 	}
 
 	const scope = context.sourceCode.getScope(node);
-	const stateFromTypeAnnotation = getTypeAnnotationBooleanState(node.typeAnnotation, context, scope, {functionTypesAreBoolean: functionValuesAreBoolean});
+	const stateFromTypeAnnotation = getDirectTypeAnnotationBooleanState(node.typeAnnotation, context, scope, {functionTypesAreBoolean: functionValuesAreBoolean});
 	if (stateFromTypeAnnotation !== unknown) {
 		return stateFromTypeAnnotation;
 	}
@@ -703,9 +912,17 @@ function getParameterBooleanState(definition, context, visitedVariables, functio
 		: unknown;
 }
 
+function getDirectTypeAnnotationBooleanState(node, context, scope, typeState) {
+	if (isGlobalPromiseTypeAnnotation(node, scope)) {
+		return nonBoolean;
+	}
+
+	return getTypeAnnotationBooleanState(node, context, scope, typeState);
+}
+
 function getDefinitionBooleanState(definition, context, visitedVariables, functionValuesAreBoolean) {
 	const scope = context.sourceCode.getScope(definition.name);
-	const stateFromTypeAnnotation = getTypeAnnotationBooleanState(definition.name.typeAnnotation, context, scope, {functionTypesAreBoolean: functionValuesAreBoolean});
+	const stateFromTypeAnnotation = getDirectTypeAnnotationBooleanState(definition.name.typeAnnotation, context, scope, {functionTypesAreBoolean: functionValuesAreBoolean});
 	if (stateFromTypeAnnotation !== unknown) {
 		return stateFromTypeAnnotation;
 	}
@@ -748,7 +965,14 @@ function getVariableBooleanState(variable, context, visitedVariables = new Set()
 	if (functionDefinitions && !functionValuesAreBoolean) {
 		result = nonBoolean;
 	} else if (functionDefinitions) {
-		result = combineBooleanStates(functionDefinitions.map(definition => getFunctionBooleanState(definition.node, context, visitedVariables)));
+		if (hasGeneratorFunctionImplementation(variable.defs)) {
+			result = nonBoolean;
+		} else {
+			const hasAsyncImplementation = hasAsyncFunctionImplementation(variable.defs);
+			result = combineBooleanStates(functionDefinitions.map(definition =>
+				getFunctionBooleanState(definition.node, context, visitedVariables, hasAsyncImplementation || definition.node.async),
+			));
+		}
 	} else {
 		result = getDefinitionBooleanState(definition, context, visitedVariables, functionValuesAreBoolean);
 	}
@@ -865,15 +1089,16 @@ function getExplicitPropertyBooleanState(node, context) {
 
 	if (propertyDefinitionTypes.has(node.type)) {
 		const scope = sourceCode.getScope(node);
-		const stateFromTypeAnnotation = getTypeAnnotationBooleanState(node.typeAnnotation, context, scope);
+		const stateFromTypeAnnotation = getDirectTypeAnnotationBooleanState(node.typeAnnotation, context, scope);
+		if (stateFromTypeAnnotation !== unknown) {
+			return stateFromTypeAnnotation;
+		}
 
-		return stateFromTypeAnnotation === unknown
-			? getExpressionBooleanState(node.value, context)
-			: stateFromTypeAnnotation;
+		return getExpressionBooleanState(node.value, context);
 	}
 
 	if (node.type === 'TSPropertySignature') {
-		return getTypeAnnotationBooleanState(node.typeAnnotation, context, sourceCode.getScope(node));
+		return getDirectTypeAnnotationBooleanState(node.typeAnnotation, context, sourceCode.getScope(node));
 	}
 
 	if (node.type === 'TSMethodSignature') {
@@ -888,7 +1113,7 @@ function getPropertyBooleanState(node, context) {
 	return state === unknown && isBooleanProperty(node, context) ? boolean : state;
 }
 
-function getSuggestions(variable, prefixes, context) {
+function getSuggestions(variable, prefixes, context, nameForPrefixCheck) {
 	if (
 		!shouldSuggestRename(variable)
 		|| variable.references.some(reference => reference.vueUsedInTemplate)
@@ -904,7 +1129,7 @@ function getSuggestions(variable, prefixes, context) {
 	const suggestions = [];
 
 	for (const prefix of prefixes) {
-		const replacement = getAvailableVariableName(getReplacementName(variable.name, prefix), scopes);
+		const replacement = getAvailableVariableName(getReactHookReplacementName({name: variable.name, nameForPrefixCheck}, prefix), scopes);
 
 		if (!replacement || usedReplacements.has(replacement)) {
 			continue;
@@ -954,7 +1179,13 @@ function isInDeclareContext(node) {
 	return false;
 }
 
-function getAutofix(variable, prefixes, context, suggestions) {
+function getAutofix({
+	variable,
+	prefixes,
+	context,
+	suggestions,
+	nameForPrefixCheck,
+}) {
 	if (
 		!suggestions
 		|| !isAutofixableVariable(variable, context)
@@ -963,7 +1194,7 @@ function getAutofix(variable, prefixes, context, suggestions) {
 	}
 
 	const [prefix] = prefixes;
-	const replacement = getReplacementName(variable.name, prefix);
+	const replacement = getReactHookReplacementName({name: variable.name, nameForPrefixCheck}, prefix);
 	const suggestion = suggestions.find(suggestion => suggestion.data.replacement === replacement);
 
 	return suggestion?.fix;
@@ -978,20 +1209,28 @@ const create = context => {
 	}
 
 	const checkVariable = variable => {
-		if (isIgnoredName(variable.name, ignore)) {
+		if (
+			isIgnoredName(variable.name, ignore)
+			|| isDestructuredVariable(variable)
+		) {
 			return;
 		}
 
-		const booleanPrefix = getBooleanPrefix(variable.name, prefixes);
+		const nameForPrefixCheck = getNameForPrefixCheck(variable, context);
+		const booleanPrefix = getBooleanPrefix(nameForPrefixCheck, prefixes);
+		const booleanState = getVariableBooleanState(variable, context);
 		if (booleanPrefix) {
-			if (getVariableBooleanState(variable, context) === nonBoolean) {
+			if (
+				booleanState === nonBoolean
+				&& !isBooleanReactReferenceVariable(variable, context)
+			) {
 				const [definition] = variable.defs;
 
 				context.report({
 					node: definition.name,
 					messageId: MESSAGE_ID_NON_BOOLEAN_PREFIX,
 					data: {
-						name: variable.name,
+						name: nameForPrefixCheck,
 						prefix: booleanPrefix,
 					},
 				});
@@ -1001,23 +1240,29 @@ const create = context => {
 		}
 
 		if (
-			getVariableBooleanState(variable, context) === nonBoolean
+			booleanState === nonBoolean
 			|| !isBooleanVariable(variable, context)
 		) {
 			return;
 		}
 
 		const [definition] = variable.defs;
-		const suggest = getSuggestions(variable, prefixes, context);
+		const suggest = getSuggestions(variable, prefixes, context, nameForPrefixCheck);
 
 		context.report({
 			node: definition.name,
 			messageId: MESSAGE_ID,
 			data: {
-				name: variable.name,
+				name: nameForPrefixCheck,
 				prefixes: formatPrefixes(prefixes),
 			},
-			fix: getAutofix(variable, prefixes, context, suggest),
+			fix: getAutofix({
+				variable,
+				prefixes,
+				context,
+				suggestions: suggest,
+				nameForPrefixCheck,
+			}),
 			suggest,
 		});
 	};
@@ -1045,8 +1290,9 @@ const create = context => {
 		}
 
 		const booleanPrefix = getBooleanPrefix(name, prefixes);
+		const booleanState = getPropertyBooleanState(node, context);
 		if (booleanPrefix) {
-			if (getPropertyBooleanState(node, context) === nonBoolean) {
+			if (booleanState === nonBoolean) {
 				context.report({
 					node: node.key,
 					messageId: MESSAGE_ID_NON_BOOLEAN_PREFIX,

package/rules/consistent-compound-words.js

@@ -1,10 +1,10 @@
-import helperValidatorIdentifier from '@babel/helper-validator-identifier';
 import {
 	getAvailableVariableName,
 	getScopes,
 	isShorthandPropertyValue,
 	lowerFirst,
 	upperFirst,
+	isIdentifierName,
 } from './utils/index.js';
 import {
 	isClassVariable,
@@ -17,7 +17,6 @@ import {renameVariable} from './fix/index.js';
 
 const MESSAGE_ID_ERROR = 'consistent-compound-words/error';
 const MESSAGE_ID_RENAME = 'consistent-compound-words/rename';
-const {isIdentifierName} = helperValidatorIdentifier;
 
 const messages = {
 	[MESSAGE_ID_ERROR]: 'Prefer `{{replacement}}` over `{{name}}`.',