Skip to main content

adjacent-overload-signatures

Require that function overload signatures be consecutive.

🎨

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

Function overload signatures represent multiple ways a function can be called, potentially with different return types. It's typical for an interface or type alias describing a function to place all overload signatures next to each other. If Signatures placed elsewhere in the type are easier to be missed by future developers reading the code.

.eslintrc.cjs
module.exports = {
  "rules": {
    "@typescript-eslint/adjacent-overload-signatures": "error"
  }
};

Try this rule in the playground ↗

Examples​

declare namespace Foo {
  export function foo(s: string): void;
  export function foo(n: number): void;
  export function bar(): void;
  export function foo(sn: string | number): void;
}

type Foo = {
  foo(s: string): void;
  foo(n: number): void;
  bar(): void;
  foo(sn: string | number): void;
};

interface Foo {
  foo(s: string): void;
  foo(n: number): void;
  bar(): void;
  foo(sn: string | number): void;
}

class Foo {
  foo(s: string): void;
  foo(n: number): void;
  bar(): void {}
  foo(sn: string | number): void {}
}

export function foo(s: string): void;
export function foo(n: number): void;
export function bar(): void;
export function foo(sn: string | number): void;
Open in Playground

Options​

This rule is not configurable.

When Not To Use It​

It can sometimes be useful to place overload signatures alongside other meaningful parts of a type. For example, if each of a function's overloads corresponds to a different property, you might wish to put each overloads next to its corresponding property. You might consider using ESLint disable comments for those specific situations instead of completely disabling this rule.

Resources​