noConfusingVoidType

TypeScript and TSX

Summary

Rule available since: v1.2.0
Diagnostic Category: lint/suspicious/noConfusingVoidType
This rule is recommended, which means is enabled by default.
This rule has an unsafe fix.
The default severity of this rule is warning.
Sources:
- Same as @typescript-eslint/no-invalid-void-type

How to configure

1
{
2
  "linter": {
3
    "rules": {
4
      "suspicious": {
5
        "noConfusingVoidType": "error"
6
      }
7
    }
8
  }
9
}

Description

Disallow void type outside of generic or return types.

void in TypeScript refers to a function return that is meant to be ignored. Attempting to use a void type outside of a return type or a type parameter is often a sign of programmer error. void can also be misleading for other developers even if used correctly.

The void type means cannot be mixed with any other types, other than never, which accepts all types. If you think you need this then you probably want the undefined type instead.

The code action suggests using undefined instead of void. It is unsafe because a variable with the void type cannot be assigned to a variable with the undefined type.

Examples

Invalid

1
let foo: void;

code-block.ts:1:10 lint/suspicious/noConfusingVoidType  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ⚠ void is confusing outside a return type or a type parameter.
  
  > 1 │ let foo: void;
      │          ^^^^
    2 │ 
  
  ℹ Unsafe fix: Use undefined instead.
  
    1   │ - let·foo:·void;
      1 │ + let·foo:·undefined;
    2 2 │

1
function logSomething(thing: void) {}

code-block.ts:1:30 lint/suspicious/noConfusingVoidType  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ⚠ void is confusing outside a return type or a type parameter.
  
  > 1 │ function logSomething(thing: void) {}
      │                              ^^^^
    2 │ 
  
  ℹ Unsafe fix: Use undefined instead.
  
    1   │ - function·logSomething(thing:·void)·{}
      1 │ + function·logSomething(thing:·undefined)·{}
    2 2 │

1
interface Interface {
2
    prop: void;
3
}

code-block.ts:2:11 lint/suspicious/noConfusingVoidType  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ⚠ void is confusing outside a return type or a type parameter.
  
    1 │ interface Interface {
  > 2 │     prop: void;
      │           ^^^^
    3 │ }
    4 │ 
  
  ℹ Unsafe fix: Use undefined instead.
  
    1 1 │   interface Interface {
    2   │ - ····prop:·void;
      2 │ + ····prop:·undefined;
    3 3 │   }
    4 4 │

1
type PossibleValues = number | void;

code-block.ts:1:32 lint/suspicious/noConfusingVoidType  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ⚠ void is confusing inside a union type.
  
  > 1 │ type PossibleValues = number | void;
      │                                ^^^^
    2 │ 
  
  ℹ Unsafe fix: Use undefined instead.
  
    1   │ - type·PossibleValues·=·number·|·void;
      1 │ + type·PossibleValues·=·number·|·undefined;
    2 2 │

Valid

1
function foo(): void {};

1
function doSomething(this: void) {}

1
function printArg<T = void>(arg: T) {}