eslint-plugin-unicorn 70.0.0 → 71.0.0

package/rules/no-unnecessary-array-flat-map.js

@@ -1,10 +1,11 @@
 import {hasSideEffect} from '@eslint-community/eslint-utils';
-import {isMethodCall} from './ast/index.js';
+import {isEmptyArrayExpression, isMethodCall} from './ast/index.js';
 import {
 	getParenthesizedText,
 	isKnownNonArray,
 	isParenthesized,
 	isSameIdentifier,
+	isTypeScriptFile,
 	shouldAddParenthesesToMemberExpressionObject,
 	wouldRemoveComments,
 } from './utils/index.js';
@@ -49,10 +50,6 @@ const isSimpleSingleParameterArrowCallback = node =>
 	&& !node.params[0].optional
 	&& node.body.type !== 'BlockStatement';
 
-const isEmptyArrayExpression = node =>
-	node.type === 'ArrayExpression'
-	&& node.elements.length === 0;
-
 const getSingleArrayElement = node => {
 	if (
 		node.type !== 'ArrayExpression'
@@ -195,6 +192,10 @@ function getProblemForFilterFlatMap(flatMapCallExpression, callbackResult, conte
 }
 
 function getProblemForConditionalFlatMap(flatMapCallExpression, callback, callbackResult, context) {
+	if (isTypeScriptFile(context.physicalFilename)) {
+		return;
+	}
+
 	const method = isSameIdentifier(callbackResult.element, callback.params[0]) ? 'filter' : 'filter().map';
 	const problem = {
 		node: flatMapCallExpression.callee.property,

package/rules/no-unnecessary-global-this.js

@@ -1,9 +1,4 @@
-import {
-	isIdentifierName,
-	isKeyword,
-	isReservedWord,
-	isStrictReservedWord,
-} from '@babel/helper-validator-identifier';
+import reservedIdentifiers from 'reserved-identifiers';
 import {findVariable} from '@eslint-community/eslint-utils';
 import {isStringLiteral} from './ast/index.js';
 import {
@@ -12,6 +7,7 @@ import {
 	isLeftHandSide,
 	isControlFlowTest,
 	isBooleanExpression,
+	isIdentifierName,
 } from './utils/index.js';
 
 const MESSAGE_ID = 'no-unnecessary-global-this';
@@ -53,11 +49,11 @@ function isActiveGlobal(name, node, context) {
 		&& variable.defs.length === 0;
 }
 
+const reserved = reservedIdentifiers();
+
 function canUseBareIdentifier(name) {
 	return isIdentifierName(name)
-		&& !isKeyword(name)
-		&& !isReservedWord(name, true)
-		&& !isStrictReservedWord(name, true);
+		&& (!reserved.has(name) || name === 'eval' || name === 'arguments');
 }
 
 function getStaticPropertyName(node) {

package/rules/no-unused-properties.js

@@ -65,7 +65,6 @@ const getReferenceParent = referenceNode => {
 	return referenceNode.parent;
 };
 
-// eslint-disable-next-line unicorn/name-replacements
 const specialProtoPropertyKey = {
 	type: 'Identifier',
 	name: '__proto__',

package/rules/no-useless-coercion.js

@@ -1,3 +1,4 @@
+import {isEmptyStringLiteral} from './ast/index.js';
 import {
 	isBoolean,
 	isString,
@@ -25,8 +26,6 @@ const coercions = new Map([
 	['Number', {type: 'number', isType: (node, context) => isNumber(node, context.sourceCode.getScope(node))}],
 ]);
 
-const isEmptyStringLiteral = node => node.type === 'Literal' && node.value === '';
-
 /** @param {ESLint.Rule.RuleContext} context */
 const create = context => {
 	const {sourceCode} = context;

package/rules/no-useless-undefined.js

@@ -410,10 +410,10 @@ const create = context => {
 			return;
 		}
 
-		const accessWhenTestPasses = !isConsequentUndefined;
+		const isAccessWhenTestPasses = !isConsequentUndefined;
 		const testValidity = getIndexedAccessTestValidity(node.test, indexedAccess);
 
-		if (testValidity !== accessWhenTestPasses) {
+		if (testValidity !== isAccessWhenTestPasses) {
 			return;
 		}
 

package/rules/prefer-array-find.js

@@ -204,13 +204,10 @@ const create = context => {
 	// `array.filter()[0]`
 	// `array?.filter()[0]`
 	context.on('MemberExpression', node => {
-		if (!(
-			node.computed
+		if (!(node.computed
 			&& node.property.type === 'Literal'
 			&& node.property.raw === '0'
-			&& isArrayFilterCall(node.object, context)
-			&& !isLeftHandSide(node)
-		)) {
+			&& isArrayFilterCall(node.object, context)) || isLeftHandSide(node)) {
 			return;
 		}
 

package/rules/prefer-bigint-literals.js

@@ -75,6 +75,7 @@ function getReplacement(valueNode) {
 	const {value, raw} = valueNode;
 
 	// Intentionally `Number.isInteger`, not `Number.isSafeInteger`: large integers beyond the safe range are exactly what bigint literals are for.
+	// eslint-disable-next-line unicorn/prefer-number-is-safe-integer
 	if (!Number.isInteger(value)) {
 		return;
 	}

package/rules/prefer-boolean-return.js

@@ -3,6 +3,7 @@ import {
 	getLastTrailingCommentOnSameLine,
 	getNextNode,
 	getParenthesizedText,
+	getPreviousNode,
 	isGlobalBooleanCall,
 	shouldAddParenthesesToUnaryExpressionArgument,
 } from './utils/index.js';
@@ -143,11 +144,11 @@ const create = context => {
 		const hasComments = sourceCode.getCommentsInside(node).length > 0
 			|| sourceCode.getCommentsInside(alternate).length > 0
 			|| getLastTrailingCommentOnSameLine(context, alternate);
-		const needsGlobalBoolean = !shouldNegateTest
+		const isNeedsGlobalBoolean = !shouldNegateTest
 			&& !isRuntimeBooleanExpression(node.test, context)
 			&& !canUseGlobalBoolean(node);
 
-		if (hasComments || needsGlobalBoolean) {
+		if (hasComments || isNeedsGlobalBoolean) {
 			return problem;
 		}
 
@@ -160,6 +161,13 @@ const create = context => {
 		};
 	}
 
+	function isPrecededByFlatIfReturningSameBoolean(node, returnValue) {
+		const previousNode = getPreviousNode(node, context);
+		return previousNode?.type === 'IfStatement'
+			&& !previousNode.alternate
+			&& getBooleanReturnValue(getNodeBody(previousNode.consequent)) === returnValue;
+	}
+
 	function getFlatProblem(node) {
 		const alternate = getNextNode(node, context);
 		if (
@@ -169,9 +177,18 @@ const create = context => {
 			return;
 		}
 
+		const consequent = getNodeBody(node.consequent);
+		const consequentValue = getBooleanReturnValue(consequent);
+		if (
+			consequentValue !== undefined
+			&& isPrecededByFlatIfReturningSameBoolean(node, consequentValue)
+		) {
+			return;
+		}
+
 		const problem = getProblem(
 			node,
-			getNodeBody(node.consequent),
+			consequent,
 			alternate,
 			[
 				sourceCode.getRange(node)[0],

package/rules/prefer-default-parameters.js

@@ -108,8 +108,8 @@ const fixDefaultExpression = (fixer, sourceCode, node) => {
 		]);
 	}
 
-	const endsWithWhitespace = lineText[column] === ' ';
-	if (endsWithWhitespace) {
+	const isEndsWithWhitespace = lineText[column] === ' ';
+	if (isEndsWithWhitespace) {
 		const [start, end] = sourceCode.getRange(node);
 		return fixer.removeRange([start, end + 1]);
 	}

package/rules/prefer-else-if.js

@@ -148,13 +148,13 @@ function getEqualityComparisons(node) {
 */
 function getBooleanComparisonInfo(node, context) {
 	node = unwrapExpression(node);
-	let value = true;
+	let isValue = true;
 
 	while (
 		node.type === 'UnaryExpression'
 		&& node.operator === '!'
 	) {
-		value = !value;
+		isValue = !isValue;
 		node = unwrapExpression(node.argument);
 	}
 
@@ -178,7 +178,7 @@ function getBooleanComparisonInfo(node, context) {
 
 	return {
 		discriminant: node,
-		valueKeys: new Set([getStaticEqualityValueKey(value)]),
+		valueKeys: new Set([getStaticEqualityValueKey(isValue)]),
 	};
 }
 
@@ -444,13 +444,9 @@ function getProblem(previousIfStatement, ifStatement, context, branchAlwaysExits
 	const previous = getComparisonInfo(previousIfStatement.test, context);
 	const current = getComparisonInfo(ifStatement.test, context);
 
-	if (!(
-		previous
+	if (!(previous
 		&& current
-		&& isSame(previous.discriminant, current.discriminant)
-		&& !hasOverlappingValues(previous.valueKeys, current.valueKeys)
-		&& !hasDirectDiscriminantMutation(previousIfStatement.consequent, previous.discriminant, context)
-	)) {
+		&& isSame(previous.discriminant, current.discriminant)) || hasOverlappingValues(previous.valueKeys, current.valueKeys) || hasDirectDiscriminantMutation(previousIfStatement.consequent, previous.discriminant, context)) {
 		return;
 	}
 

package/rules/prefer-has-check.js

@@ -1,5 +1,10 @@
 import {findVariable, getStaticValue} from '@eslint-community/eslint-utils';
-import {isMethodCall, isNewExpression, isUndefined} from './ast/index.js';
+import {
+	isMethodCall,
+	isNewExpression,
+	isNullLiteral,
+	isUndefined,
+} from './ast/index.js';
 import {
 	getParenthesizedText,
 	getTypeSymbol,
@@ -823,8 +828,6 @@ const getCallKind = (callExpression, comparison, context) => {
 	}
 };
 
-const isNullLiteral = node => node.type === 'Literal' && node.value === null;
-
 const getComparison = callExpression => {
 	const comparisonTarget = getTransparentExpressionAncestor(callExpression);
 	const {parent} = comparisonTarget;

package/rules/prefer-https.js

@@ -82,14 +82,14 @@ function isWellKnownXmlNamespace(text, matchIndex) {
 
 /** @param {import('eslint').Rule.RuleContext} context */
 const create = context => {
-	let checked = false;
+	let isChecked = false;
 
 	onRoot(context, node => {
-		if (checked) {
+		if (isChecked) {
 			return;
 		}
 
-		checked = true;
+		isChecked = true;
 
 		const {sourceCode} = context;
 		const {text} = sourceCode;

package/rules/prefer-identifier-import-export-specifiers.js

@@ -1,6 +1,4 @@
-import helperValidatorIdentifier from '@babel/helper-validator-identifier';
-
-const {isIdentifierName} = helperValidatorIdentifier;
+import {isIdentifierName} from './utils/index.js';
 
 const MESSAGE_ID = 'prefer-identifier-import-export-specifiers';
 const messages = {

package/rules/prefer-minimal-ternary.js

@@ -166,14 +166,14 @@ function isMinimalBinaryExpression(left, right, context) {
 		return false;
 	}
 
-	const leftSidesAreSame = isSameSourceText(left.left, right.left, context.sourceCode);
-	const rightSidesAreSame = isSameSourceText(left.right, right.right, context.sourceCode);
+	const isLeftSidesAreSame = isSameSourceText(left.left, right.left, context.sourceCode);
+	const isRightSidesAreSame = isSameSourceText(left.right, right.right, context.sourceCode);
 
-	if (leftSidesAreSame === rightSidesAreSame) {
+	if (isLeftSidesAreSame === isRightSidesAreSame) {
 		return false;
 	}
 
-	return rightSidesAreSame || isSafeSharedExpression(left.left);
+	return isRightSidesAreSame || isSafeSharedExpression(left.left);
 }
 
 function hasSameObjectWithDifferentDynamicKey(left, right, context) {

package/rules/prefer-object-define-properties.js

@@ -1,15 +1,13 @@
 import {getStaticValue} from '@eslint-community/eslint-utils';
-import helperValidatorIdentifier from '@babel/helper-validator-identifier';
 import {isMethodCall} from './ast/index.js';
 import {
 	getIndentString,
 	getNextNode,
 	getPreviousNode,
 	isSameReference,
+	isIdentifierName,
 } from './utils/index.js';
 
-const {isIdentifierName} = helperValidatorIdentifier;
-
 const MESSAGE_ID = 'prefer-object-define-properties';
 const messages = {
 	[MESSAGE_ID]: 'Prefer `Object.defineProperties()` over multiple `Object.defineProperty()` calls.',

package/rules/prefer-observer-apis.js

@@ -231,11 +231,8 @@ const isGlobalObject = (node, context) =>
 const isWriteOnlyLeftHandSide = node =>
 	isLeftHandSide(node)
 	&& node.parent.type !== 'UpdateExpression'
-	&& !(
-		node.parent.type === 'AssignmentExpression'
-		&& node.parent.left === node
-		&& node.parent.operator !== '='
-	);
+	&& (!(node.parent.type === 'AssignmentExpression'
+		&& node.parent.left === node) || node.parent.operator === '=');
 
 const isGlobalDocument = (node, context) => {
 	node = unwrapTypeScriptExpression(node);

package/rules/prefer-private-class-fields.js

@@ -1,7 +1,5 @@
-import helperValidatorIdentifier from '@babel/helper-validator-identifier';
 import {getStaticStringValue} from './ast/index.js';
-
-const {isIdentifierName} = helperValidatorIdentifier;
+import {isIdentifierName} from './utils/index.js';
 
 const MESSAGE_ID = 'prefer-private-class-fields';
 const messages = {

package/rules/prefer-simple-sort-comparator.js

@@ -138,14 +138,14 @@ function trueBranchSign(branch) {
 }
 
 function expectedSignForTest(test, minuend, subtrahend) {
-	const greaterThan = test.operator === '>' || test.operator === '>=';
+	const isGreaterThan = test.operator === '>' || test.operator === '>=';
 	const testLeftIsMinuend = isSameReference(test.left, minuend) && isSameReference(test.right, subtrahend);
 
 	if (testLeftIsMinuend) {
-		return greaterThan ? 1 : -1;
+		return isGreaterThan ? 1 : -1;
 	}
 
-	return greaterThan ? -1 : 1;
+	return isGreaterThan ? -1 : 1;
 }
 
 function branchSignsMatchSubtraction(branch, minuend, subtrahend) {
@@ -220,9 +220,9 @@ const create = context => {
 
 		// Orient the subtraction so it matches the comparator's sort direction.
 		const {test} = tree;
-		const greaterThan = test.operator === '>' || test.operator === '>=';
-		const leftIsMinuend = greaterThan ? sign > 0 : sign < 0;
-		const [minuend, subtrahend] = leftIsMinuend ? [test.left, test.right] : [test.right, test.left];
+		const isGreaterThan = test.operator === '>' || test.operator === '>=';
+		const isLeftIsMinuend = isGreaterThan ? sign > 0 : sign < 0;
+		const [minuend, subtrahend] = isLeftIsMinuend ? [test.left, test.right] : [test.right, test.left];
 
 		if (!branchSignsMatchSubtraction(tree, minuend, subtrahend)) {
 			return;

package/rules/prefer-single-object-destructuring.js

@@ -68,15 +68,12 @@ const getProblem = (sourceCode, firstNode, secondNode) => {
 	const first = getSupportedDeclaration(sourceCode, firstNode);
 	const second = getSupportedDeclaration(sourceCode, secondNode);
 
-	if (!(
-		first
+	if (!(first
 		&& second
 		&& first.node.kind === second.node.kind
 		&& first.source === second.source
 		&& sourceCode.getCommentsInside(first.node).length === 0
-		&& sourceCode.getCommentsInside(second.node).length === 0
-		&& !hasCommentsBetween(sourceCode, first.node, second.node)
-	)) {
+		&& sourceCode.getCommentsInside(second.node).length === 0) || hasCommentsBetween(sourceCode, first.node, second.node)) {
 		return;
 	}
 

package/rules/prefer-single-replace.js

@@ -21,8 +21,8 @@ const characterClassEscapes = new Map([
 	['\t', String.raw`\t`],
 	['\f', String.raw`\f`],
 	['\v', String.raw`\v`],
-	['\u2028', String.raw`\u2028`],
-	['\u2029', String.raw`\u2029`],
+	['\u{2028}', String.raw`\u2028`],
+	['\u{2029}', String.raw`\u2029`],
 ]);
 
 // Escapes a single character for use inside a character class. `^` and `-` are only special depending on position, so they are escaped only when necessary (avoids tripping `no-useless-escape` on the output).

package/rules/prefer-spread.js

@@ -18,6 +18,7 @@ import {
 	isTypeParameterType,
 	hasUnparenthesizedOptionalChainElement,
 	isTypeScriptExpressionWrapper,
+	isDefaultLibrarySymbol,
 } from './utils/index.js';
 import {removeMethodCall} from './fix/index.js';
 import {
@@ -155,8 +156,8 @@ function fixConcat(node, context, fixableArguments) {
 	const array = node.callee.object;
 	const concatCallArguments = node.arguments;
 	const arrayParenthesizedRange = getParenthesizedRange(array, context);
-	const arrayIsArrayLiteral = isArrayLiteral(array);
-	const arrayHasTrailingComma = arrayIsArrayLiteral && isArrayLiteralHasTrailingComma(array, sourceCode);
+	const isArrayIsArrayLiteral = isArrayLiteral(array);
+	const arrayHasTrailingComma = isArrayIsArrayLiteral && isArrayLiteralHasTrailingComma(array, sourceCode);
 
 	const getArrayLiteralElementsText = (node, keepTrailingComma) => {
 		if (
@@ -204,7 +205,7 @@ function fixConcat(node, context, fixableArguments) {
 			return '';
 		}
 
-		if (arrayIsArrayLiteral) {
+		if (isArrayIsArrayLiteral) {
 			if (!isEmptyArrayExpression(array)) {
 				text = ` ${text}`;
 
@@ -243,7 +244,7 @@ function fixConcat(node, context, fixableArguments) {
 	return function * (fixer) {
 		// Fixed code always starts with `[`
 		if (
-			!arrayIsArrayLiteral
+			!isArrayIsArrayLiteral
 			&& needsSemicolon(sourceCode.getTokenBefore(node), context, '[')
 		) {
 			yield fixer.insertTextBefore(node, ';');
@@ -257,7 +258,7 @@ function fixConcat(node, context, fixableArguments) {
 
 		const text = getFixedText();
 
-		if (arrayIsArrayLiteral) {
+		if (isArrayIsArrayLiteral) {
 			const closingBracketToken = sourceCode.getLastToken(array);
 			yield fixer.insertTextBefore(closingBracketToken, text);
 		} else {
@@ -389,9 +390,6 @@ function isGlobalMemberExpression(node, objectName, propertyName, context) {
 	return staticValue?.value === propertyName;
 }
 
-const isDefaultLibrarySymbol = (symbol, program) =>
-	symbol?.declarations?.some(declaration => program.isSourceFileDefaultLibrary(declaration.getSourceFile())) ?? false;
-
 function isBufferModuleImport(definition) {
 	return (
 		definition?.type === 'ImportBinding'
@@ -1339,11 +1337,11 @@ const create = context => {
 		};
 
 		const fixableArguments = getConcatFixableArguments(node.arguments, scope, context);
-		const receiverSafeToSpread = !isArrayConstructorWithOneArgument(object, context);
+		const isReceiverSafeToSpread = !isArrayConstructorWithOneArgument(object, context);
 
 		if (fixableArguments.length > 0 || node.arguments.length === 0) {
 			if (
-				receiverSafeToSpread
+				isReceiverSafeToSpread
 				&& !hasCommentsOutsideRanges(node, getConcatPreservedRanges(node, fixableArguments.length))
 			) {
 				problem.fix = fixConcat(node, context, fixableArguments);
@@ -1357,7 +1355,7 @@ const create = context => {
 			return problem;
 		}
 
-		if (!receiverSafeToSpread) {
+		if (!isReceiverSafeToSpread) {
 			return problem;
 		}
 
@@ -1422,17 +1420,13 @@ const create = context => {
 
 	// `array.slice()`
 	context.on('CallExpression', node => {
-		if (!(
-			isMethodCall(node, {
-				method: 'slice',
-				minimumArguments: 0,
-				maximumArguments: 1,
-				optionalCall: false,
-				optionalMember: false,
-			})
-			&& !isArrayLiteral(node.callee.object)
-			&& !hasUnparenthesizedOptionalChainElement(node.callee.object, context)
-		)) {
+		if (!isMethodCall(node, {
+			method: 'slice',
+			minimumArguments: 0,
+			maximumArguments: 1,
+			optionalCall: false,
+			optionalMember: false,
+		}) || isArrayLiteral(node.callee.object) || hasUnparenthesizedOptionalChainElement(node.callee.object, context)) {
 			return;
 		}
 
@@ -1465,16 +1459,12 @@ const create = context => {
 
 	// `array.toSpliced()`
 	context.on('CallExpression', node => {
-		if (!(
-			isMethodCall(node, {
-				method: 'toSpliced',
-				argumentsLength: 0,
-				optionalCall: false,
-				optionalMember: false,
-			})
-			&& node.callee.object.type !== 'ArrayExpression'
-			&& !hasUnparenthesizedOptionalChainElement(node.callee.object, context)
-		)) {
+		if (!isMethodCall(node, {
+			method: 'toSpliced',
+			argumentsLength: 0,
+			optionalCall: false,
+			optionalMember: false,
+		}) || node.callee.object.type === 'ArrayExpression' || hasUnparenthesizedOptionalChainElement(node.callee.object, context)) {
 			return;
 		}
 

package/rules/prefer-string-pad-start-end.js

@@ -1,5 +1,5 @@
 import {findVariable, getStaticValue} from '@eslint-community/eslint-utils';
-import {isMethodCall} from './ast/index.js';
+import {isMethodCall, isNumericLiteral} from './ast/index.js';
 import {
 	getParenthesizedText,
 	isSameReference,
@@ -78,11 +78,6 @@ const hasCommentsInside = (node, context) => context.sourceCode.getCommentsInsid
 
 const isSimpleTarget = node => node.type === 'Identifier';
 
-const isNumericLiteral = node => (
-	node.type === 'Literal'
-	&& typeof node.value === 'number'
-);
-
 const isZeroLiteral = node => (
 	isNumericLiteral(node)
 	&& node.value === 0

package/rules/prefer-string-repeat.js

@@ -1,4 +1,3 @@
-import jsesc from 'jsesc';
 import {isStringLiteral, isDirective} from './ast/index.js';
 import {fixSpaceAroundKeyword} from './fix/index.js';
 import isJestInlineSnapshot from './shared/is-jest-inline-snapshot.js';
@@ -10,15 +9,23 @@ const messages = {
 
 const singleWhitespace = /^\s$/u;
 
+const namedEscapes = new Map([
+	['\t', String.raw`\t`],
+	['\n', String.raw`\n`],
+	['\r', String.raw`\r`],
+	['\f', String.raw`\f`],
+]);
+
+// Escape a single whitespace character into a readable single-quoted string literal.
 function quoteWhitespace(character) {
-	return jsesc(character, {
-		quotes: 'single',
-		wrap: true,
-		es6: true,
-		minimal: false,
-		lowercaseHex: false,
-		json: true,
-	});
+	if (character === ' ') {
+		return '\' \'';
+	}
+
+	const escape = namedEscapes.get(character)
+		?? String.raw`\u{${character.codePointAt(0).toString(16).toUpperCase()}}`;
+
+	return `'${escape}'`;
 }
 
 function getRepeatedWhitespace(value, minimumRepetitions) {

package/rules/prefer-string-replace-all.js

@@ -40,7 +40,7 @@ function hasSafeGlobalStringReplacementFlags(flags) {
 	return true;
 }
 
-const getUnicodeEscape = codePoint => String.raw`\u{${codePoint.toString(16)}}`;
+const getUnicodeEscape = codePoint => String.raw`\u{${codePoint.toString(16).toUpperCase()}}`;
 
 function getValueReplacement(node) {
 	const {kind, codePoint, raw} = node;

package/rules/prefer-ternary.js

@@ -1,4 +1,5 @@
 import {hasSideEffect, findVariable} from '@eslint-community/eslint-utils';
+import {isBooleanLiteral} from './ast/index.js';
 import {
 	needsSemicolon,
 	isSameReference,
@@ -13,7 +14,6 @@ const messageId = 'prefer-ternary';
 const suggestionMessageId = 'prefer-ternary/suggestion';
 
 const isTernary = node => node?.type === 'ConditionalExpression';
-const isBooleanLiteral = node => node?.type === 'Literal' && typeof node.value === 'boolean';
 
 function getNodeBody(node) {
 	/* c8 ignore next 3 */
@@ -57,7 +57,7 @@ const isMergeableAssignmentExpression = (consequent, alternate) =>
 
 /** @param {import('eslint').Rule.RuleContext} context */
 const create = context => {
-	const onlySingleLine = context.options[0] === 'only-single-line';
+	const isOnlySingleLine = context.options[0] === 'only-single-line';
 	const {sourceCode} = context;
 
 	const getText = node => {
@@ -134,7 +134,7 @@ const create = context => {
 		}
 
 		if (
-			onlySingleLine
+			isOnlySingleLine
 			&& [node.test, right].some(n => !isSingleLineNode(n, context))
 		) {
 			return;
@@ -161,7 +161,7 @@ const create = context => {
 		}
 
 		if (
-			onlySingleLine
+			isOnlySingleLine
 			&& !isSingleLineNode(declarator.init, context)
 		) {
 			return;
@@ -245,7 +245,7 @@ const create = context => {
 		const alternate = getNodeBody(node.alternate);
 
 		if (
-			onlySingleLine
+			isOnlySingleLine
 			&& [consequent, alternate, node.test].some(node => !isSingleLineNode(node, context))
 		) {
 			return;