docs(linter): Improve diagnostic for consistent-type-definitions rule. (#15752)

connorshea · connorshea · commit 65a3520095fa · 2025-11-17T14:32:17.000Z
Fix the grammar of the diagnostic message and improve the docs a bit.

This removes the redundant help message, but that results in the fix message showing up, which can look a bit weird for multi-line fixes? Not sure if I should keep this as-is or add a static help message.

Also adds an extra test case.
diff --git a/crates/oxc_linter/src/rules/typescript/consistent_type_definitions.rs b/crates/oxc_linter/src/rules/typescript/consistent_type_definitions.rs
@@ -17,23 +17,26 @@ use crate::{
 };
 
 fn consistent_type_definitions_diagnostic(
-    preferred_type_kind: &str,
-    bad_type_kind: &str,
+    config: ConsistentTypeDefinitionsConfig,
     span: Span,
 ) -> OxcDiagnostic {
-    OxcDiagnostic::warn(format!("Use an `{preferred_type_kind}` instead of a `{bad_type_kind}`"))
-        .with_help(format!("Use an `{preferred_type_kind}` instead of a `{bad_type_kind}`"))
-        .with_label(span)
+    let message = match config {
+        ConsistentTypeDefinitionsConfig::Interface => "Use `interface` instead of `type`.",
+        ConsistentTypeDefinitionsConfig::Type => "Use `type` instead of `interface`.",
+    };
+
+    OxcDiagnostic::warn(message).with_label(span)
 }
 
 #[derive(Debug, Default, Clone, JsonSchema, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase", default)]
 pub struct ConsistentTypeDefinitions {
-    /// Configuration option to enforce either 'interface' or 'type' for object type definitions.
+    /// Configuration option to enforce either `interface` or `type` for object type definitions.
     ///
     /// Setting to `type` enforces the use of types for object type definitions.
     ///
     /// Examples of **incorrect** code for this option:
+    ///
     /// ```typescript
     /// interface T {
     ///   x: number;
@@ -58,11 +61,11 @@ enum ConsistentTypeDefinitionsConfig {
 declare_oxc_lint!(
     /// ### What it does
     ///
-    /// Enforce type definitions to consistently use either interface or type.
+    /// Enforce type definitions to consistently use either `interface` or `type`.
     ///
     /// ### Why is this bad?
     ///
-    /// TypeScript provides two common ways to define an object type: interface and type.
+    /// TypeScript provides two common ways to define an object type: `interface` and `type`.
     /// The two are generally very similar, and can often be used interchangeably.
     /// Using the same type declaration style consistently helps with code readability.
     ///
@@ -135,8 +138,7 @@ impl Rule for ConsistentTypeDefinitions {
 
                         ctx.diagnostic_with_fix(
                             consistent_type_definitions_diagnostic(
-                                "interface",
-                                "type",
+                                ConsistentTypeDefinitionsConfig::Interface,
                                 Span::new(start, start + 4),
                             ),
                             |fixer| {
@@ -175,8 +177,7 @@ impl Rule for ConsistentTypeDefinitions {
 
                     ctx.diagnostic_with_fix(
                         consistent_type_definitions_diagnostic(
-                            "type",
-                            "interface",
+                            ConsistentTypeDefinitionsConfig::Type,
                             Span::sized(decl.span.start, 9),
                         ),
                         |fixer| {
@@ -221,8 +222,7 @@ impl Rule for ConsistentTypeDefinitions {
 
                 ctx.diagnostic_with_fix(
                     consistent_type_definitions_diagnostic(
-                        "type",
-                        "interface",
+                        ConsistentTypeDefinitionsConfig::Type,
                         Span::sized(start, 9),
                     ),
                     |fixer| {
@@ -259,6 +259,7 @@ fn test() {
         ),
         ("type U = string;", Some(serde_json::json!(["interface"]))),
         ("type V = { x: number } | { y: string };", Some(serde_json::json!(["interface"]))),
+        ("interface T { x: \"interface\" | \"type\"; }", Some(serde_json::json!(["interface"]))),
         (
             "
 			type Record<T, U> = {
@@ -295,6 +296,7 @@ fn test() {
         ("interface T { x: number; }", Some(serde_json::json!(["type"]))),
         ("interface T{ x: number; }", Some(serde_json::json!(["type"]))),
         ("interface T                          { x: number; }", Some(serde_json::json!(["type"]))),
+        ("type T = { x: \"interface\" | \"type\"; };", Some(serde_json::json!(["interface"]))),
         ("interface A extends B, C { x: number; };", Some(serde_json::json!(["type"]))),
         ("interface A extends B<T1>, C<T2> { x: number; };", Some(serde_json::json!(["type"]))),
         (
@@ -406,6 +408,11 @@ fn test() {
           }",
             Some(serde_json::json!(["interface"])),
         ),
+        (
+            "type T = { x: \"interface\" | \"type\"; };",
+            "interface T { x: \"interface\" | \"type\"; }",
+            Some(serde_json::json!(["interface"])),
+        ),
         (
             "interface T { x: number; }",
             "type T = { x: number; }",
diff --git a/crates/oxc_linter/src/snapshots/typescript_consistent_type_definitions.snap b/crates/oxc_linter/src/snapshots/typescript_consistent_type_definitions.snap
@@ -1,190 +1,242 @@
 ---
 source: crates/oxc_linter/src/tester.rs
 ---
-  ⚠ typescript-eslint(consistent-type-definitions): Use an `interface` instead of a `type`
+  ⚠ typescript-eslint(consistent-type-definitions): Use `interface` instead of `type`.
    ╭─[consistent_type_definitions.tsx:1:1]
  1 │ type T = { x: number; };
    · ────
    ╰────
-  help: Use an `interface` instead of a `type`
+  help: Replace `type T = { x: number; };` with `interface T { x: number; }`.
 
-  ⚠ typescript-eslint(consistent-type-definitions): Use an `interface` instead of a `type`
+  ⚠ typescript-eslint(consistent-type-definitions): Use `interface` instead of `type`.
    ╭─[consistent_type_definitions.tsx:1:1]
  1 │ type T={ x: number; };
    · ────
    ╰────
-  help: Use an `interface` instead of a `type`
+  help: Replace `type T={ x: number; };` with `interface T { x: number; }`.
 
-  ⚠ typescript-eslint(consistent-type-definitions): Use an `interface` instead of a `type`
+  ⚠ typescript-eslint(consistent-type-definitions): Use `interface` instead of `type`.
    ╭─[consistent_type_definitions.tsx:1:1]
  1 │ type T=                         { x: number; };
    · ────
    ╰────
-  help: Use an `interface` instead of a `type`
+  help: Replace `type T=                         { x: number; };` with `interface T { x: number; }`.
 
-  ⚠ typescript-eslint(consistent-type-definitions): Use an `interface` instead of a `type`
+  ⚠ typescript-eslint(consistent-type-definitions): Use `interface` instead of `type`.
    ╭─[consistent_type_definitions.tsx:2:11]
  1 │ 
  2 │             export type W<T> = {
    ·                    ────
  3 │               x: T;
    ╰────
-  help: Use an `interface` instead of a `type`
+  help: Replace `type W<T> = {
+        			  x: T;
+        			};` with `interface W<T> {
+        			  x: T;
+        			}`.
 
-  ⚠ typescript-eslint(consistent-type-definitions): Use an `type` instead of a `interface`
+  ⚠ typescript-eslint(consistent-type-definitions): Use `type` instead of `interface`.
    ╭─[consistent_type_definitions.tsx:1:1]
  1 │ interface T { x: number; }
    · ─────────
    ╰────
-  help: Use an `type` instead of a `interface`
+  help: Replace `interface T { x: number; }` with `type T = { x: number; }`.
 
-  ⚠ typescript-eslint(consistent-type-definitions): Use an `type` instead of a `interface`
+  ⚠ typescript-eslint(consistent-type-definitions): Use `type` instead of `interface`.
    ╭─[consistent_type_definitions.tsx:1:1]
  1 │ interface T{ x: number; }
    · ─────────
    ╰────
-  help: Use an `type` instead of a `interface`
+  help: Replace `interface T{ x: number; }` with `type T = { x: number; }`.
 
-  ⚠ typescript-eslint(consistent-type-definitions): Use an `type` instead of a `interface`
+  ⚠ typescript-eslint(consistent-type-definitions): Use `type` instead of `interface`.
    ╭─[consistent_type_definitions.tsx:1:1]
  1 │ interface T                          { x: number; }
    · ─────────
    ╰────
-  help: Use an `type` instead of a `interface`
+  help: Replace `interface T                          { x: number; }` with `type T = { x: number; }`.
 
-  ⚠ typescript-eslint(consistent-type-definitions): Use an `type` instead of a `interface`
+  ⚠ typescript-eslint(consistent-type-definitions): Use `interface` instead of `type`.
+   ╭─[consistent_type_definitions.tsx:1:1]
+ 1 │ type T = { x: "interface" | "type"; };
+   · ────
+   ╰────
+  help: Replace `type T = { x: "interface" | "type"; };` with `interface T { x: "interface" | "type"; }`.
+
+  ⚠ typescript-eslint(consistent-type-definitions): Use `type` instead of `interface`.
    ╭─[consistent_type_definitions.tsx:1:1]
  1 │ interface A extends B, C { x: number; };
    · ─────────
    ╰────
-  help: Use an `type` instead of a `interface`
+  help: Replace `interface A extends B, C { x: number; }` with `type A = { x: number; } & B & C`.
 
-  ⚠ typescript-eslint(consistent-type-definitions): Use an `type` instead of a `interface`
+  ⚠ typescript-eslint(consistent-type-definitions): Use `type` instead of `interface`.
    ╭─[consistent_type_definitions.tsx:1:1]
  1 │ interface A extends B<T1>, C<T2> { x: number; };
    · ─────────
    ╰────
-  help: Use an `type` instead of a `interface`
+  help: Replace `interface A extends B<T1>, C<T2> { x: number; }` with `type A = { x: number; } & B<T1> & C<T2>`.
 
-  ⚠ typescript-eslint(consistent-type-definitions): Use an `type` instead of a `interface`
+  ⚠ typescript-eslint(consistent-type-definitions): Use `type` instead of `interface`.
    ╭─[consistent_type_definitions.tsx:2:11]
  1 │ 
  2 │             export interface W<T> {
    ·                    ─────────
  3 │               x: T;
    ╰────
-  help: Use an `type` instead of a `interface`
+  help: Replace `interface W<T> {
+        			  x: T;
+        			}` with `type W<T> = {
+        			  x: T;
+        			}`.
 
-  ⚠ typescript-eslint(consistent-type-definitions): Use an `type` instead of a `interface`
+  ⚠ typescript-eslint(consistent-type-definitions): Use `type` instead of `interface`.
    ╭─[consistent_type_definitions.tsx:3:6]
  2 │             namespace JSX {
  3 │               interface Array<T> {
    ·               ─────────
  4 │                 foo(x: (x: number) => T): T[];
    ╰────
-  help: Use an `type` instead of a `interface`
+  help: Replace `interface Array<T> {
+        			    foo(x: (x: number) => T): T[];
+        			  }` with `type Array<T> = {
+        			    foo(x: (x: number) => T): T[];
+        			  }`.
 
-  ⚠ typescript-eslint(consistent-type-definitions): Use an `type` instead of a `interface`
+  ⚠ typescript-eslint(consistent-type-definitions): Use `type` instead of `interface`.
    ╭─[consistent_type_definitions.tsx:3:6]
  2 │             global {
  3 │               interface Array<T> {
    ·               ─────────
  4 │                 foo(x: (x: number) => T): T[];
    ╰────
-  help: Use an `type` instead of a `interface`
+  help: Replace `interface Array<T> {
+        			    foo(x: (x: number) => T): T[];
+        			  }` with `type Array<T> = {
+        			    foo(x: (x: number) => T): T[];
+        			  }`.
 
-  ⚠ typescript-eslint(consistent-type-definitions): Use an `type` instead of a `interface`
+  ⚠ typescript-eslint(consistent-type-definitions): Use `type` instead of `interface`.
    ╭─[consistent_type_definitions.tsx:3:6]
  2 │             declare global {
  3 │               interface Array<T> {
    ·               ─────────
  4 │                 foo(x: (x: number) => T): T[];
    ╰────
-  help: Use an `type` instead of a `interface`
+  help: Replace `interface Array<T> {
+        			    foo(x: (x: number) => T): T[];
+        			  }` with `type Array<T> = {
+        			    foo(x: (x: number) => T): T[];
+        			  }`.
 
-  ⚠ typescript-eslint(consistent-type-definitions): Use an `type` instead of a `interface`
+  ⚠ typescript-eslint(consistent-type-definitions): Use `type` instead of `interface`.
    ╭─[consistent_type_definitions.tsx:4:8]
  3 │               namespace Foo {
  4 │                 interface Bar {}
    ·                 ─────────
  5 │               }
    ╰────
-  help: Use an `type` instead of a `interface`
+  help: Replace `interface Bar {}` with `type Bar = {}`.
 
-  ⚠ typescript-eslint(consistent-type-definitions): Use an `type` instead of a `interface`
+  ⚠ typescript-eslint(consistent-type-definitions): Use `type` instead of `interface`.
    ╭─[consistent_type_definitions.tsx:2:19]
  1 │ 
  2 │             export default interface Test {
    ·                            ─────────
  3 │               bar(): string;
    ╰────
-  help: Use an `type` instead of a `interface`
+  help: Replace `export default interface Test {
+        			  bar(): string;
+        			  foo(): number;
+        			}` with `type Test = {
+        			  bar(): string;
+        			  foo(): number;
+        			}
+        export default Test`.
 
-  ⚠ typescript-eslint(consistent-type-definitions): Use an `type` instead of a `interface`
+  ⚠ typescript-eslint(consistent-type-definitions): Use `type` instead of `interface`.
    ╭─[consistent_type_definitions.tsx:2:19]
  1 │ 
  2 │             export default interface Test {
    ·                            ─────────
  3 │               bar(): string;
    ╰────
-  help: Use an `type` instead of a `interface`
+  help: Replace `interface Test {
+        			  bar(): string;
+        			  foo(): number;
+        			}` with `type Test = {
+        			  bar(): string;
+        			  foo(): number;
+        			}`.
 
-  ⚠ typescript-eslint(consistent-type-definitions): Use an `interface` instead of a `type`
+  ⚠ typescript-eslint(consistent-type-definitions): Use `interface` instead of `type`.
    ╭─[consistent_type_definitions.tsx:2:19]
  1 │ 
  2 │             export declare type Test = {
    ·                            ────
  3 │               foo: string;
    ╰────
-  help: Use an `interface` instead of a `type`
+  help: Replace `type Test = {
+        			  foo: string;
+        			  bar: string;
+        			};` with `interface Test {
+        			  foo: string;
+        			  bar: string;
+        			}`.
 
-  ⚠ typescript-eslint(consistent-type-definitions): Use an `type` instead of a `interface`
+  ⚠ typescript-eslint(consistent-type-definitions): Use `type` instead of `interface`.
    ╭─[consistent_type_definitions.tsx:2:19]
  1 │ 
  2 │             export declare interface Test {
    ·                            ─────────
  3 │               foo: string;
    ╰────
-  help: Use an `type` instead of a `interface`
+  help: Replace `interface Test {
+        			  foo: string;
+        			  bar: string;
+        			}` with `type Test = {
+        			  foo: string;
+        			  bar: string;
+        			}`.
 
-  ⚠ typescript-eslint(consistent-type-definitions): Use an `interface` instead of a `type`
+  ⚠ typescript-eslint(consistent-type-definitions): Use `interface` instead of `type`.
    ╭─[consistent_type_definitions.tsx:1:10]
  1 │ declaretype S={}
    ·         ────
    ╰────
-  help: Use an `interface` instead of a `type`
+  help: Replace `type S={}` with `interface S {}`.
 
-  ⚠ typescript-eslint(consistent-type-definitions): Use an `type` instead of a `interface`
+  ⚠ typescript-eslint(consistent-type-definitions): Use `type` instead of `interface`.
    ╭─[consistent_type_definitions.tsx:1:10]
  1 │ declareinterface S {}
    ·         ─────────
    ╰────
-  help: Use an `type` instead of a `interface`
+  help: Replace `interface S {}` with `type S = {}`.
 
-  ⚠ typescript-eslint(consistent-type-definitions): Use an `interface` instead of a `type`
+  ⚠ typescript-eslint(consistent-type-definitions): Use `interface` instead of `type`.
    ╭─[consistent_type_definitions.tsx:1:17]
  1 │ export declaretype S={}
    ·                ────
    ╰────
-  help: Use an `interface` instead of a `type`
+  help: Replace `type S={}` with `interface S {}`.
 
-  ⚠ typescript-eslint(consistent-type-definitions): Use an `type` instead of a `interface`
+  ⚠ typescript-eslint(consistent-type-definitions): Use `type` instead of `interface`.
    ╭─[consistent_type_definitions.tsx:1:17]
  1 │ export declareinterface S {}
    ·                ─────────
    ╰────
-  help: Use an `type` instead of a `interface`
+  help: Replace `interface S {}` with `type S = {}`.
 
-  ⚠ typescript-eslint(consistent-type-definitions): Use an `type` instead of a `interface`
+  ⚠ typescript-eslint(consistent-type-definitions): Use `type` instead of `interface`.
    ╭─[consistent_type_definitions.tsx:1:25]
  1 │ declare /* interface */ interface T { x: number; };
    ·                         ─────────
    ╰────
-  help: Use an `type` instead of a `interface`
+  help: Replace `interface T { x: number; }` with `type T = { x: number; }`.
 
-  ⚠ typescript-eslint(consistent-type-definitions): Use an `interface` instead of a `type`
+  ⚠ typescript-eslint(consistent-type-definitions): Use `interface` instead of `type`.
    ╭─[consistent_type_definitions.tsx:1:20]
  1 │ declare /* type */ type T =  { x: number; };
    ·                    ────
    ╰────
-  help: Use an `interface` instead of a `type`
+  help: Replace `type T =  { x: number; };` with `interface T { x: number; }`.
