Mar 9, 2024 · Mar 9, 2024 · Mar 9, 2024 · Mar 9, 2024 · Mar 9, 2024 · Mar 10, 2024
diff --git a/packages/eslint-plugin/docs/rules/no-confusing-void-expression.mdx b/packages/eslint-plugin/docs/rules/no-confusing-void-expression.mdx
 console.log(void alert('Hello, world!'));
 ```

 ### `ignoreVoidInVoid`

 Allow using `void` type expressions in return value of a function that specified as `void`

 Examples of additional **correct** code with this option enabled:

 ```ts option='{ "ignoreVoidInVoid": true }' showPlaygroundButton
 function test1(value: string): void {
  return window.postMessage(value);
 }

 const test2 = (value: string): void => window.postMessage(value);

 const test3 = (value: string): void => {
  return window.postMessage(value);
 };
 ```

 ## When Not To Use It

 The return type of a function can be inspected by going to its definition or hovering over it in an IDE.
diff --git a/packages/eslint-plugin/src/rules/no-confusing-void-expression.ts b/packages/eslint-plugin/src/rules/no-confusing-void-expression.ts
  nullThrows,
  NullThrowsReasons,
 } from '../util';
 import {
  ancestorHasReturnType,
  isValidFunctionExpressionReturnType,
 } from '../util/explicitReturnTypeUtils';

 export type Options = [
  {
    ignoreArrowShorthand?: boolean;
    ignoreVoidOperator?: boolean;
    ignoreVoidInVoid?: boolean;
  },
 ];

  | 'invalidVoidExprWrapVoid'
  | 'voidExprWrapVoid';

 function findFunction(
  node: TSESTree.Node | undefined,
 ):
  | TSESTree.FunctionExpression
  | TSESTree.ArrowFunctionExpression
  | TSESTree.FunctionDeclaration
  | null {
  if (!node) {
    return null;
  }
  if (
    node.type === AST_NODE_TYPES.FunctionExpression ||
    node.type === AST_NODE_TYPES.ArrowFunctionExpression ||
    node.type === AST_NODE_TYPES.FunctionDeclaration
  ) {
    return node;
  }
  return findFunction(node.parent);
 }

 export default createRule<Options, MessageId>({
  name: 'no-confusing-void-expression',
  meta: {
        properties: {
          ignoreArrowShorthand: { type: 'boolean' },
          ignoreVoidOperator: { type: 'boolean' },
          ignoreVoidInVoid: { type: 'boolean' },
        },
        additionalProperties: false,
      },
    fixable: 'code',
    hasSuggestions: true,
  },
  defaultOptions: [{ ignoreArrowShorthand: false, ignoreVoidOperator: false }],

  defaultOptions: [
    {
      ignoreArrowShorthand: false,
      ignoreVoidOperator: false,
      ignoreVoidInVoid: false,
    },
  ],
  create(context, [options]) {
    return {
      'AwaitExpression, CallExpression, TaggedTemplateExpression'(
        }

        const invalidAncestor = findInvalidAncestor(node);

        if (invalidAncestor == null) {
          // void expression is in valid position
          return;
        if (invalidAncestor.type === AST_NODE_TYPES.ArrowFunctionExpression) {
          // handle arrow function shorthand

          if (options.ignoreVoidInVoid) {
            if (hasValidReturnType(invalidAncestor)) {
              return;
            }
          }

          if (options.ignoreVoidOperator) {
            // handle wrapping with `void`
            return context.report({
        if (invalidAncestor.type === AST_NODE_TYPES.ReturnStatement) {
          // handle return statement

          if (options.ignoreVoidInVoid) {
            const functionNode = findFunction(invalidAncestor);

            if (hasValidReturnType(functionNode)) {
              return;
            }
          }

          if (options.ignoreVoidOperator) {
            // handle wrapping with `void`
            return context.report({
      const type = getConstrainedTypeAtLocation(services, targetNode);
      return tsutils.isTypeFlagSet(type, ts.TypeFlags.VoidLike);
    }

    function hasValidReturnType(
      node:
        | TSESTree.FunctionExpression
        | TSESTree.ArrowFunctionExpression
        | TSESTree.FunctionDeclaration
        | null,
    ): boolean {
      const services = getParserServices(context);

      if (node != null) {
        const functionTSNode = services.esTreeNodeToTSNodeMap.get(node);
        const functionType = services.getTypeAtLocation(node);

        if (functionTSNode.type) {
          const signatures = tsutils.getCallSignaturesOfType(functionType);

          return !signatures.every(signature =>
            tsutils.isTypeFlagSet(
              signature.getReturnType(),
              ts.TypeFlags.Any | ts.TypeFlags.Unknown,
            ),
          );
        }

        if (
          ((node.type === AST_NODE_TYPES.FunctionExpression ||
            node.type === AST_NODE_TYPES.ArrowFunctionExpression) &&
            isValidFunctionExpressionReturnType(node, {
              allowTypedFunctionExpressions: true,
            })) ||
          ancestorHasReturnType(node)
        ) {
          return true;
        }
      }

      return false;
    }
  },
 });
diff --git a/packages/eslint-plugin/tests/docs-eslint-output-snapshots/no-confusing-void-expression.shot b/packages/eslint-plugin/tests/docs-eslint-output-snapshots/no-confusing-void-expression.shot
Original file line number	Diff line number	Diff line change
Expand Up		@@ -115,6 +115,24 @@ function doSomething() {
		console.log(void alert('Hello, world!'));
		```

		### `ignoreVoidInVoid`

		Allow using `void` type expressions in return value of a function that specified as `void`

		Examples of additional correct code with this option enabled:

		```ts option='{ "ignoreVoidInVoid": true }' showPlaygroundButton
		function test1(value: string): void {
		return window.postMessage(value);
		}

		const test2 = (value: string): void => window.postMessage(value);

		const test3 = (value: string): void => {
		return window.postMessage(value);
		};
		```

		## When Not To Use It

		The return type of a function can be inspected by going to its definition or hovering over it in an IDE.
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -14,11 +14,16 @@ import {
		nullThrows,
		NullThrowsReasons,
		} from '../util';
		import {
		ancestorHasReturnType,
		isValidFunctionExpressionReturnType,
		} from '../util/explicitReturnTypeUtils';

		export type Options = [
		{
		ignoreArrowShorthand?: boolean;
		ignoreVoidOperator?: boolean;
		ignoreVoidInVoid?: boolean;
		},
		];

Expand All		@@ -32,6 +37,26 @@ export type MessageId =
		\| 'invalidVoidExprWrapVoid'
		\| 'voidExprWrapVoid';

		function findFunction(
		node: TSESTree.Node \| undefined,
		):
		\| TSESTree.FunctionExpression
		\| TSESTree.ArrowFunctionExpression
		\| TSESTree.FunctionDeclaration
		\| null {
		if (!node) {
		return null;
		}
		if (
		node.type === AST_NODE_TYPES.FunctionExpression \|\|
		node.type === AST_NODE_TYPES.ArrowFunctionExpression \|\|
		node.type === AST_NODE_TYPES.FunctionDeclaration
		) {
		return node;
		}
		return findFunction(node.parent);
		}

		export default createRule<Options, MessageId>({
		name: 'no-confusing-void-expression',
		meta: {
Expand DownExpand Up		@@ -72,6 +97,7 @@ export default createRule<Options, MessageId>({
		properties: {
		ignoreArrowShorthand: { type: 'boolean' },
		ignoreVoidOperator: { type: 'boolean' },
		ignoreVoidInVoid: { type: 'boolean' },
		},
		additionalProperties: false,
		},
Expand All		@@ -80,8 +106,13 @@ export default createRule<Options, MessageId>({
		fixable: 'code',
		hasSuggestions: true,
		},
		defaultOptions: [{ ignoreArrowShorthand: false, ignoreVoidOperator: false }],

		defaultOptions: [
		{
		ignoreArrowShorthand: false,
		ignoreVoidOperator: false,
		ignoreVoidInVoid: false,
		},
		],
		create(context, [options]) {
		return {
		'AwaitExpression, CallExpression, TaggedTemplateExpression'(
Expand All		@@ -98,6 +129,7 @@ export default createRule<Options, MessageId>({
		}

		const invalidAncestor = findInvalidAncestor(node);

		if (invalidAncestor == null) {
		// void expression is in valid position
		return;
Expand All		@@ -112,6 +144,12 @@ export default createRule<Options, MessageId>({
		if (invalidAncestor.type === AST_NODE_TYPES.ArrowFunctionExpression) {
		// handle arrow function shorthand

		if (options.ignoreVoidInVoid) {
		if (hasValidReturnType(invalidAncestor)) {
		return;
		}
		}

		if (options.ignoreVoidOperator) {
		// handle wrapping with `void`
		return context.report({
Expand DownExpand Up		@@ -167,6 +205,14 @@ export default createRule<Options, MessageId>({
		if (invalidAncestor.type === AST_NODE_TYPES.ReturnStatement) {
		// handle return statement

		if (options.ignoreVoidInVoid) {
		const functionNode = findFunction(invalidAncestor);
Copy link Member auvredMar 24, 2024 Choose a reason for hiding this comment The reason will be displayed to describe this comment to others.Learn more. [Bug] The following code won't be reported, because`findFunction` doesn't stop on function declarations: typeFoo=()=>void;consttest1:Foo=function(){functiontesttt(){returnconsole.log();// not reported - bug}};consttest2=function(){functiontesttt(){returnconsole.log();// reported - nice}}; playground developer-bandi reacted with thumbs up emoji

		if (hasValidReturnType(functionNode)) {
		return;
		}
		}

		if (options.ignoreVoidOperator) {
		// handle wrapping with `void`
		return context.report({
Expand DownExpand Up		@@ -376,5 +422,44 @@ export default createRule<Options, MessageId>({
		const type = getConstrainedTypeAtLocation(services, targetNode);
		return tsutils.isTypeFlagSet(type, ts.TypeFlags.VoidLike);
		}

		function hasValidReturnType(
		node:
		\| TSESTree.FunctionExpression
		\| TSESTree.ArrowFunctionExpression
		\| TSESTree.FunctionDeclaration
		\| null,
		): boolean {
		const services = getParserServices(context);

		if (node != null) {
		const functionTSNode = services.esTreeNodeToTSNodeMap.get(node);
		const functionType = services.getTypeAtLocation(node);

		if (functionTSNode.type) {
		const signatures = tsutils.getCallSignaturesOfType(functionType);

		return !signatures.every(signature =>
		tsutils.isTypeFlagSet(
		signature.getReturnType(),
		ts.TypeFlags.Any \| ts.TypeFlags.Unknown,
		),
		);
		}

		if (
		((node.type === AST_NODE_TYPES.FunctionExpression \|\|
		node.type === AST_NODE_TYPES.ArrowFunctionExpression) &&
		isValidFunctionExpressionReturnType(node, {
		allowTypedFunctionExpressions: true,
		})) \|\|
		ancestorHasReturnType(node)
		) {
		return true;
		}
Comment on lines +450 to +459 Copy link Member auvredMay 11, 2024 Choose a reason for hiding this comment The reason will be displayed to describe this comment to others.Learn more. If we check that function signature don't contain`any` and`unknown` in the return type, we should do the same for typed functions/variable declarations. The following cases are not reported: typeHigherOrderType=()=>any;():HigherOrderType=>()=>console.log();constx:HigherOrderType=()=>console.log(); playground
		}

		return false;
		}
		},
		});