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;
}
Open in Playground

Options​

This rule accepts the following options:

type Options = [
  {
    /** Whether a `this` parameter of a function may be `void`. */
    allowAsThisParameter?: boolean;
    /** Whether `void` can be used as a valid value for generic type parameters. */
    allowInGenericTypeArguments?:
      | [string, ...string[]]
      /** Whether `void` can be used as a valid value for generic type parameters. */
      | boolean;
  },
];

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

allowInGenericTypeArguments​

Whether 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>();
Open in Playground

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>;
Open in Playground

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>;
Open in Playground

allowAsThisParameter​

Whether a this parameter of a function may be void. 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) {}
}
Open in Playground

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​