Dec 26, 2024 · Oct 4, 2024 · Oct 4, 2024 · Oct 5, 2024 · Oct 5, 2024 · Oct 5, 2024
diff --git a/packages/eslint-plugin/docs/rules/strict-boolean-expressions.mdx b/packages/eslint-plugin/docs/rules/strict-boolean-expressions.mdx
 - Right-hand side operand is ignored when it's not a descendant of another boolean expression.
    This is to allow usage of boolean operators for their short-circuiting behavior.
 - Asserted argument of an assertion function (`assert(arg)`).
 - Return type of array predicate functions such as`filter()`,`some()`, etc.

 ##Examples

 declarefunction assert(value:unknown):assertsvalue;
 let maybeString=Math.random()>0.5?'':undefined;
 assert(maybeString);

 // array predicates' return types are boolean contexts.
 ['one',null].filter(x=>x);
 ```

 </TabItem>
diff --git a/packages/eslint-plugin/src/rules/strict-boolean-expressions.ts b/packages/eslint-plugin/src/rules/strict-boolean-expressions.ts
  TSESTree,
 } from '@typescript-eslint/utils';

 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import { AST_NODE_TYPES, ASTUtils } from '@typescript-eslint/utils';
 import * as tsutils from 'ts-api-utils';
 import * as ts from 'typescript';

  getConstrainedTypeAtLocation,
  getParserServices,
  getWrappingFixer,
  isArrayMethodCallWithPredicate,
  isParenlessArrowFunction,
  isTypeArrayTypeOrUnionOfArrayTypes,
  nullThrows,
 } from '../util';
 import { findTruthinessAssertedArgument } from '../util/assertionFunctionUtils';

  | 'conditionFixDefaultEmptyString'
  | 'conditionFixDefaultFalse'
  | 'conditionFixDefaultZero'
  | 'noStrictNullCheck';
  | 'explicitBooleanReturnType'
  | 'noStrictNullCheck'
  | 'predicateCannotBeAsync'
  | 'predicateReturnsNonBoolean';

 export default createRule<Options, MessageId>({
  name: 'strict-boolean-expressions',
        'Explicitly treat nullish value the same as false (`value ?? false`)',
      conditionFixDefaultZero:
        'Explicitly treat nullish value the same as 0 (`value ?? 0`)',
      explicitBooleanReturnType:
        'Add an explicit `boolean` return type annotation.',
      noStrictNullCheck:
        'This rule requires the `strictNullChecks` compiler option to be turned on to function correctly.',
      predicateCannotBeAsync:
        "Predicate function should not be 'async'; expected a boolean return type.",
      predicateReturnsNonBoolean: 'Predicate function should return a boolean.',
    },
    schema: [
      {
      if (assertedArgument != null) {
        traverseNode(assertedArgument, true);
      }
      if (isArrayMethodCallWithPredicate(context, services, node)) {
        const predicate = node.arguments.at(0);

        if (predicate) {
          checkArrayMethodCallPredicate(predicate);
        }
      }
    }

    /**
     * Dedicated function to check array method predicate calls. Reports predicate
     * arguments that don't return a boolean value.
     *
     * Ignores the `allow*` options and requires a boolean value.
     */
    function checkArrayMethodCallPredicate(
      predicateNode: TSESTree.CallExpressionArgument,
    ): void {
      const isFunctionExpression = ASTUtils.isFunction(predicateNode);

      // custom message for accidental `async` function expressions
      if (isFunctionExpression && predicateNode.async) {
        return context.report({
          node: predicateNode,
          messageId: 'predicateCannotBeAsync',
        });
      }

      const returnTypes = services
        .getTypeAtLocation(predicateNode)
        .getCallSignatures()
        .map(signature => {
          const type = signature.getReturnType();

          if (tsutils.isTypeParameter(type)) {
            return checker.getBaseConstraintOfType(type) ?? type;
          }

          return type;
        });

      if (returnTypes.every(returnType => isBooleanType(returnType))) {
        return;
      }

      const canFix = isFunctionExpression && !predicateNode.returnType;

      return context.report({
        node: predicateNode,
        messageId: 'predicateReturnsNonBoolean',
        suggest: canFix
          ? [
              {
                messageId: 'explicitBooleanReturnType',
                fix: fixer => {
                  if (
                    predicateNode.type ===
                      AST_NODE_TYPES.ArrowFunctionExpression &&
                    isParenlessArrowFunction(predicateNode, context.sourceCode)
                  ) {
                    return [
                      fixer.insertTextBefore(predicateNode.params[0], '('),
                      fixer.insertTextAfter(
                        predicateNode.params[0],
                        '): boolean',
                      ),
                    ];
                  }

                  if (predicateNode.params.length === 0) {
                    const closingBracket = nullThrows(
                      context.sourceCode.getFirstToken(
                        predicateNode,
                        token => token.value === ')',
                      ),
                      'function expression has to have a closing parenthesis.',
                    );

                    return fixer.insertTextAfter(closingBracket, ': boolean');
                  }

                  const lastClosingParenthesis = nullThrows(
                    context.sourceCode.getTokenAfter(
                      predicateNode.params[predicateNode.params.length - 1],
                      token => token.value === ')',
                    ),
                    'function expression has to have a closing parenthesis.',
                  );

                  return fixer.insertTextAfter(
                    lastClosingParenthesis,
                    ': boolean',
                  );
                },
              },
            ]
          : null,
      });
    }

    /**
 function isBrandedBoolean(type: ts.Type): boolean {
  return (
    type.isIntersection() &&
    type.types.some(childType =>
      tsutils.isTypeFlagSet(
        childType,
        ts.TypeFlags.BooleanLiteral | ts.TypeFlags.Boolean,
      ),
    )
    type.types.some(childType => isBooleanType(childType))
  );
 }

 function isBooleanType(expressionType: ts.Type): boolean {
  return tsutils.isTypeFlagSet(
    expressionType,
    ts.TypeFlags.Boolean | ts.TypeFlags.BooleanLiteral,
  );
 }
diff --git a/packages/eslint-plugin/tests/docs-eslint-output-snapshots/strict-boolean-expressions.shot b/packages/eslint-plugin/tests/docs-eslint-output-snapshots/strict-boolean-expressions.shot
Original file line number	Diff line number	Diff line change
Expand Up		@@ -22,6 +22,7 @@ The following nodes are considered boolean expressions and their type is checked
		- Right-hand side operand is ignored when it's not a descendant of another boolean expression.
		This is to allow usage of boolean operators for their short-circuiting behavior.
		- Asserted argument of an assertion function (`assert(arg)`).
		- Return type of array predicate functions such as`filter()`,`some()`, etc.

		##Examples

Expand DownExpand Up		@@ -61,6 +62,9 @@ while (obj) {
		declarefunction assert(value:unknown):assertsvalue;
		let maybeString=Math.random()>0.5?'':undefined;
		assert(maybeString);

		// array predicates' return types are boolean contexts.
		['one',null].filter(x=>x);
		```

		</TabItem>
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -3,7 +3,7 @@ import type {
		TSESTree,
		} from '@typescript-eslint/utils';

		import { AST_NODE_TYPES } from '@typescript-eslint/utils';
		import { AST_NODE_TYPES, ASTUtils } from '@typescript-eslint/utils';
		import * as tsutils from 'ts-api-utils';
		import * as ts from 'typescript';

Expand All		@@ -12,7 +12,10 @@ import {
		getConstrainedTypeAtLocation,
		getParserServices,
		getWrappingFixer,
		isArrayMethodCallWithPredicate,
		isParenlessArrowFunction,
		isTypeArrayTypeOrUnionOfArrayTypes,
		nullThrows,
		} from '../util';
		import { findTruthinessAssertedArgument } from '../util/assertionFunctionUtils';

Expand DownExpand Up		@@ -53,7 +56,10 @@ export type MessageId =
		\| 'conditionFixDefaultEmptyString'
		\| 'conditionFixDefaultFalse'
		\| 'conditionFixDefaultZero'
		\| 'noStrictNullCheck';
		\| 'explicitBooleanReturnType'
		\| 'noStrictNullCheck'
		\| 'predicateCannotBeAsync'
		\| 'predicateReturnsNonBoolean';

		export default createRule<Options, MessageId>({
		name: 'strict-boolean-expressions',
Expand DownExpand Up		@@ -122,8 +128,13 @@ export default createRule<Options, MessageId>({
		'Explicitly treat nullish value the same as false (`value ?? false`)',
		conditionFixDefaultZero:
		'Explicitly treat nullish value the same as 0 (`value ?? 0`)',
		explicitBooleanReturnType:
		'Add an explicit `boolean` return type annotation.',
		noStrictNullCheck:
		'This rule requires the `strictNullChecks` compiler option to be turned on to function correctly.',
		predicateCannotBeAsync:
		"Predicate function should not be 'async'; expected a boolean return type.",
		predicateReturnsNonBoolean: 'Predicate function should return a boolean.',
		},
		schema: [
		{
Expand DownExpand Up		@@ -275,6 +286,104 @@ export default createRule<Options, MessageId>({
		if (assertedArgument != null) {
		traverseNode(assertedArgument, true);
		}
		if (isArrayMethodCallWithPredicate(context, services, node)) {
		const predicate = node.arguments.at(0);

		if (predicate) {
		checkArrayMethodCallPredicate(predicate);
		}
		}
		}

		/**
		* Dedicated function to check array method predicate calls. Reports predicate
		* arguments that don't return a boolean value.
		*
		* Ignores the `allow*` options and requires a boolean value.
		*/
		function checkArrayMethodCallPredicate(
		predicateNode: TSESTree.CallExpressionArgument,
		): void {
		const isFunctionExpression = ASTUtils.isFunction(predicateNode);

		// custom message for accidental `async` function expressions
		if (isFunctionExpression && predicateNode.async) {
		return context.report({
		node: predicateNode,
		messageId: 'predicateCannotBeAsync',
		});
		}

		const returnTypes = services
		.getTypeAtLocation(predicateNode)
		.getCallSignatures()
		.map(signature => {
		const type = signature.getReturnType();

		if (tsutils.isTypeParameter(type)) {
		return checker.getBaseConstraintOfType(type) ?? type;
		}

		return type;
		});

		if (returnTypes.every(returnType => isBooleanType(returnType))) {
		return;
		}

		const canFix = isFunctionExpression && !predicateNode.returnType;

		return context.report({
		node: predicateNode,
		messageId: 'predicateReturnsNonBoolean',
		suggest: canFix
kirkwaiblinger marked this conversation as resolved. Show resolvedHide resolved
		? [
		{
		messageId: 'explicitBooleanReturnType',
		fix: fixer => {
		if (
		predicateNode.type ===
		AST_NODE_TYPES.ArrowFunctionExpression &&
		isParenlessArrowFunction(predicateNode, context.sourceCode)
		) {
		return [
		fixer.insertTextBefore(predicateNode.params[0], '('),
		fixer.insertTextAfter(
		predicateNode.params[0],
		'): boolean',
		),
		];
		}

		if (predicateNode.params.length === 0) {
		const closingBracket = nullThrows(
		context.sourceCode.getFirstToken(
		predicateNode,
		token => token.value === ')',
		),
		'function expression has to have a closing parenthesis.',
		);

		return fixer.insertTextAfter(closingBracket, ': boolean');
		}

		const lastClosingParenthesis = nullThrows(
		context.sourceCode.getTokenAfter(
		predicateNode.params[predicateNode.params.length - 1],
		token => token.value === ')',
		),
		'function expression has to have a closing parenthesis.',
		);

		return fixer.insertTextAfter(
		lastClosingParenthesis,
		': boolean',
		);
		},
		},
		]
		: null,
		});
		}

		/**
Expand DownExpand Up		@@ -1007,11 +1116,13 @@ function isArrayLengthExpression(
		function isBrandedBoolean(type: ts.Type): boolean {
		return (
		type.isIntersection() &&
		type.types.some(childType =>
		tsutils.isTypeFlagSet(
		childType,
		ts.TypeFlags.BooleanLiteral \| ts.TypeFlags.Boolean,
		),
		)
		type.types.some(childType => isBooleanType(childType))
		);
		}

		function isBooleanType(expressionType: ts.Type): boolean {
		return tsutils.isTypeFlagSet(
		expressionType,
		ts.TypeFlags.Boolean \| ts.TypeFlags.BooleanLiteral,
		);
		}