useConsistentMethodSignatures (JavaScript)

Language JavaScript (and super languages)

Summary

Rule available since: v2.3.14
Diagnostic Category: lint/style/useConsistentMethodSignatures
This rule isn’t recommended, so you need to enable it.
This rule has an unsafe fix.
The default severity of this rule is information.
Sources:
- Same as @typescript-eslint/method-signature-style

How to configure

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

Description

Enforce one syntax for functions declared in interfaces and type aliases.

TypeScript supports method syntax and property syntax:

1
interface Example {
2
  method(arg: string): void;
3
  property: (arg: string) => void;
4
}

The two forms can behave differently when the strictFunctionTypes compiler option is enabled. Function properties receive stricter parameter checks, while methods keep TypeScript’s more permissive compatibility behavior.

In this example, callers of Emitter may pass any Event. Narrowing the property parameter to SpecialEvent is therefore rejected, while TypeScript still accepts the method form:

1
interface Emitter {
2
  method(arg: Event): void;
3
  property: (arg: Event) => void;
4
}
5

6
interface SpecialEvent extends Event {
7
  isBirthday: boolean;
8
}
9

10
interface SpecialEmitter extends Emitter {
11
  method(arg: SpecialEvent): void;
12
  property: (arg: SpecialEvent) => void; // Error with `strictFunctionTypes`
13
}

Type-system terminology

With strictFunctionTypes, function properties check parameters contravariantly: a replacement function must accept every value accepted by the original function. Methods use TypeScript’s more permissive bivariant parameter checking, which allows the narrower SpecialEvent parameter above. See the TypeScript handbook for the formal rationale.

Using one form consistently avoids unexpected differences in type checking.

Without strictFunctionTypes, the two forms have the same parameter-checking behavior, so the choice is only stylistic.

Examples

Invalid

1
interface Example {
2
  methodFunc(arg: string): number;
3
}

code-block.ts:2:3 lint/style/useConsistentMethodSignatures  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ℹ Prefer using property-style over method-style method signatures.
  
    1 │ interface Example {
  > 2 │   methodFunc(arg: string): number;
      │   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    3 │ }
    4 │ 
  
  ℹ Consistently using a single style of method signatures helps improve readability and consistency.
  
  ℹ Property-style function declarations also allow for stricter type checking when the strictFunctionTypes compiler option is enabled.
  
  ℹ If this isn't what you want, consider changing the style option in the rule's settings.
  
  ℹ Unsafe fix: Convert to property-style signature.
  
    1 1 │   interface Example {
    2   │ - ··methodFunc(arg:·string):·number;
      2 │ + ··methodFunc:·(arg:·string)·=>·number;
    3 3 │   }
    4 4 │

1
type Generic<T, U> = {
2
  methodFunc(arg: T): U;
3
}

code-block.ts:2:3 lint/style/useConsistentMethodSignatures  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ℹ Prefer using property-style over method-style method signatures.
  
    1 │ type Generic<T, U> = {
  > 2 │   methodFunc(arg: T): U;
      │   ^^^^^^^^^^^^^^^^^^^^^^
    3 │ }
    4 │ 
  
  ℹ Consistently using a single style of method signatures helps improve readability and consistency.
  
  ℹ Property-style function declarations also allow for stricter type checking when the strictFunctionTypes compiler option is enabled.
  
  ℹ If this isn't what you want, consider changing the style option in the rule's settings.
  
  ℹ Unsafe fix: Convert to property-style signature.
  
    1 1 │   type Generic<T, U> = {
    2   │ - ··methodFunc(arg:·T):·U;
      2 │ + ··methodFunc:·(arg:·T)·=>·U;
    3 3 │   }
    4 4 │

1
type Union =
2
  | {
3
    foo(bar: number): number;
4
  }
5
  | 4;

code-block.ts:3:5 lint/style/useConsistentMethodSignatures  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ℹ Prefer using property-style over method-style method signatures.
  
    1 │ type Union =
    2 │   | {
  > 3 │     foo(bar: number): number;
      │     ^^^^^^^^^^^^^^^^^^^^^^^^^
    4 │   }
    5 │   | 4;
  
  ℹ Consistently using a single style of method signatures helps improve readability and consistency.
  
  ℹ Property-style function declarations also allow for stricter type checking when the strictFunctionTypes compiler option is enabled.
  
  ℹ If this isn't what you want, consider changing the style option in the rule's settings.
  
  ℹ Unsafe fix: Convert to property-style signature.
  
    1 1 │   type Union =
    2 2 │     | {
    3   │ - ····foo(bar:·number):·number;
      3 │ + ····foo:·(bar:·number)·=>·number;
    4 4 │     }
    5 5 │     | 4;

1
type Intersection =
2
  {
3
    qux(quux: number): "quuux";
4
  } & { foo: string };

code-block.ts:3:5 lint/style/useConsistentMethodSignatures  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ℹ Prefer using property-style over method-style method signatures.
  
    1 │ type Intersection =
    2 │   {
  > 3 │     qux(quux: number): "quuux";
      │     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    4 │   } & { foo: string };
    5 │ 
  
  ℹ Consistently using a single style of method signatures helps improve readability and consistency.
  
  ℹ Property-style function declarations also allow for stricter type checking when the strictFunctionTypes compiler option is enabled.
  
  ℹ If this isn't what you want, consider changing the style option in the rule's settings.
  
  ℹ Unsafe fix: Convert to property-style signature.
  
    1 1 │   type Intersection =
    2 2 │     {
    3   │ - ····qux(quux:·number):·"quuux";
      3 │ + ····qux:·(quux:·number)·=>·"quuux";
    4 4 │     } & { foo: string };
    5 5 │

Valid

1
interface Prop {
2
  propFunc: (arg: string) => number;
3
}

1
type Thing<T> = {
2
  genericProp: <U>(arg: U) => T;
3
}

1
type Callback = () => void;

Classes (as well as interfaces lacking function declarations) are always ignored:

1
interface Example {
2
  notAFunc: number;
3
}

1
class Foo {
2
  methodFunc(arg: string): number;
3
}

Options

`style`

The desired method signature style to enforce.
Possible values are either "method" or "property".

Default: "property", which enables stricter parameter checking with strictFunctionTypes.

Examples for `"style": "method"`

1
{
2
  "linter": {
3
    "rules": {
4
      "style": {
5
        "useConsistentMethodSignatures": {
6
          "level": "on",
7
          "options": {
8
            "style": "method"
9
          }
10
        }
11
      }
12
    }
13
  }
14
}

1
interface Blah {
2
  propFunc: (arg: string) => void;
3
}

code-block.ts:2:3 lint/style/useConsistentMethodSignatures  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ℹ Prefer using method-style over property-style method signatures.
  
    1 │ interface Blah {
  > 2 │   propFunc: (arg: string) => void;
      │   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    3 │ }
    4 │ 
  
  ℹ Consistently using a single style of method signatures helps improve readability and consistency.
  
  ℹ If this isn't what you want, consider changing the style option in the rule's settings.
  
  ℹ Unsafe fix: Convert to method-style signature.
  
    1 1 │   interface Blah {
    2   │ - ··propFunc:·(arg:·string)·=>·void;
      2 │ + ··propFunc(arg:·string):·void;
    3 3 │   }
    4 4 │

1
type Generic = {
2
  propFunc: <T, U>(arg: T) => U;
3
}

code-block.ts:2:3 lint/style/useConsistentMethodSignatures  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

  ℹ Prefer using method-style over property-style method signatures.
  
    1 │ type Generic = {
  > 2 │   propFunc: <T, U>(arg: T) => U;
      │   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    3 │ }
    4 │ 
  
  ℹ Consistently using a single style of method signatures helps improve readability and consistency.
  
  ℹ If this isn't what you want, consider changing the style option in the rule's settings.
  
  ℹ Unsafe fix: Convert to method-style signature.
  
    1 1 │   type Generic = {
    2   │ - ··propFunc:·<T,·U>(arg:·T)·=>·U;
      2 │ + ··propFunc<T,·U>(arg:·T):·U;
    3 3 │   }
    4 4 │

1
type OK = {
2
  flubber(arg: number): number;
3
}