no-invalid-void-type

Disallow void type outside of generic or return types.

Disallows usage of void type outside of return types or generic type arguments. If void is used as return type, it shouldn’t be a part of intersection/union type with most other types.

Attributes

Rationale

The void type means “nothing” or that a function does not return any value, in contrast with implicit undefined type which means that a function returns a value undefined. So “nothing” cannot be mixed with any other types, other than never, which accepts all types. If you need this - use the undefined type instead.

Rule Details

This rule aims to ensure that the void type is only used in valid places.

Examples of code for this rule:

❌ Incorrect
✅ Correct

type PossibleValues = string | number | void;
type MorePossibleValues = string | ((number & any) | (string | void));

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

logAndReturn<void>(undefined);

interface Interface {
  lambda: () => void;
  prop: void;
}

class MyClass {
  private readonly propName: void;
}

type NoOp = () => void;

function noop(): void {}

let trulyUndefined = void 0;

async function promiseMeSomething(): Promise<void> {}

type stillVoid = void | never;

.eslintrc.cjs
module.exports = {
  "rules": {
    "@typescript-eslint/no-invalid-void-type": "warn"
  }
};

Options

This rule accepts an options object with the following properties:

interface Options {
  allowInGenericTypeArguments?: boolean | string[];
  allowAsThisParameter?: boolean;
}

const defaultOptions: Options = [
  { allowInGenericTypeArguments: true, allowAsThisParameter: false },
];

`allowInGenericTypeArguments`

This option lets you control if void can be used as a valid value for generic type parameters.

Alternatively, you can provide an array of strings which whitelist which types may accept void as a generic type parameter.

Any types considered valid by this option will be considered valid as part of a union type with void.

This option is true by default.

The following patterns are considered warnings with { allowInGenericTypeArguments: false }:

logAndReturn<void>(undefined);

let voidPromise: Promise<void> = new Promise<void>(() => {});
let voidMap: Map<string, void> = new Map<string, void>();

The following patterns are considered warnings with { allowInGenericTypeArguments: ['Ex.Mx.Tx'] }:

logAndReturn<void>(undefined);

type NotAllowedVoid1 = Mx.Tx<void>;
type NotAllowedVoid2 = Tx<void>;
type NotAllowedVoid3 = Promise<void>;

The following patterns are not considered warnings with { allowInGenericTypeArguments: ['Ex.Mx.Tx'] }:

type AllowedVoid = Ex.Mx.Tx<void>;
type AllowedVoidUnion = void | Ex.Mx.Tx<void>;

`allowAsThisParameter`

This option allows specifying a this parameter of a function to be void when set to true. This pattern can be useful to explicitly label function types that do not use a this argument. See the TypeScript docs for more information.

This option is false by default.

The following patterns are considered warnings with { allowAsThisParameter: false } but valid with { allowAsThisParameter: true }:

function doThing(this: void) {}
class Example {
  static helper(this: void) {}
  callback(this: void) {}
}

When Not To Use It

If you don't care about if void is used with other types, or in invalid places, then you don't need this rule.

Attributes

Rationale​

Rule Details​

Options​

allowInGenericTypeArguments​

allowAsThisParameter​

When Not To Use It​

Resources​