Skip to main content

no-invalid-void-type

Disallow void type outside of generic or return types.

🔒

Extending "plugin:@typescript-eslint/strict" in an ESLint configuration enables this rule.

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 generic type argument 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.

.eslintrc.cjs
module.exports = {
"rules": {
"@typescript-eslint/no-invalid-void-type": "error"
}
};
Try this rule in the playground ↗

Examples

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;
}

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.

Resources