fix(linter): Fix docs for consistent-type-specifier-style and consistent-type-definitions rules. (#16253)

connorshea · connorshea · commit 42e9dcc7d3dd · 2025-11-28T22:44:12.000Z
Both of these take a string config, and the docs were set up as a configuration object.

Also refactor a few more rules to use the DefaultRuleConfig pattern.
diff --git a/crates/oxc_linter/src/rules/eslint/getter_return.rs b/crates/oxc_linter/src/rules/eslint/getter_return.rs
@@ -16,11 +16,13 @@ use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::Span;
 use schemars::JsonSchema;
+use serde::Deserialize;
+use serde_json::Value;
 
 use crate::{
     AstNode,
     context::{ContextHost, LintContext},
-    rule::Rule,
+    rule::{DefaultRuleConfig, Rule},
 };
 
 fn getter_return_diagnostic(span: Span) -> OxcDiagnostic {
@@ -29,7 +31,7 @@ fn getter_return_diagnostic(span: Span) -> OxcDiagnostic {
         .with_label(span)
 }
 
-#[derive(Debug, Default, Clone, JsonSchema)]
+#[derive(Debug, Default, Clone, JsonSchema, Deserialize)]
 #[serde(rename_all = "camelCase", default)]
 pub struct GetterReturn {
     /// When set to `true`, allows getters to implicitly return `undefined` with a `return` statement containing no expression.
@@ -87,6 +89,12 @@ declare_oxc_lint!(
 );
 
 impl Rule for GetterReturn {
+    fn from_configuration(value: Value) -> Self {
+        serde_json::from_value::<DefaultRuleConfig<GetterReturn>>(value)
+            .unwrap_or_default()
+            .into_inner()
+    }
+
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
         match node.kind() {
             AstKind::Function(func) if !func.is_typescript_syntax() => {
@@ -99,16 +107,6 @@ impl Rule for GetterReturn {
         }
     }
 
-    fn from_configuration(value: serde_json::Value) -> Self {
-        let allow_implicit = value
-            .get(0)
-            .and_then(|config| config.get("allowImplicit"))
-            .and_then(serde_json::Value::as_bool)
-            .unwrap_or(false);
-
-        Self { allow_implicit }
-    }
-
     fn should_run(&self, ctx: &ContextHost) -> bool {
         // https://eslint.org/docs/latest/rules/getter-return#handled_by_typescript
         !ctx.source_type().is_typescript()
diff --git a/crates/oxc_linter/src/rules/eslint/use_isnan.rs b/crates/oxc_linter/src/rules/eslint/use_isnan.rs
@@ -7,8 +7,13 @@ use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 use oxc_syntax::operator::BinaryOperator;
 use schemars::JsonSchema;
+use serde::Deserialize;
 
-use crate::{AstNode, context::LintContext, rule::Rule};
+use crate::{
+    AstNode,
+    context::LintContext,
+    rule::{DefaultRuleConfig, Rule},
+};
 
 fn comparison_with_na_n(span: Span) -> OxcDiagnostic {
     OxcDiagnostic::warn("Requires calls to `isNaN()` when checking for NaN")
@@ -36,7 +41,7 @@ fn index_of_na_n(method_name: &str, span: Span) -> OxcDiagnostic {
         .with_label(span)
 }
 
-#[derive(Debug, Clone, JsonSchema)]
+#[derive(Debug, Clone, JsonSchema, Deserialize)]
 #[serde(rename_all = "camelCase", default)]
 pub struct UseIsnan {
     /// Whether to disallow NaN in switch cases and discriminants
@@ -139,21 +144,9 @@ impl Rule for UseIsnan {
     }
 
     fn from_configuration(value: serde_json::Value) -> Self {
-        let (enforce_for_switch_case, enforce_for_index_of) =
-            value.get(0).map_or((true, false), |config| {
-                (
-                    config
-                        .get("enforceForSwitchCase")
-                        .and_then(serde_json::Value::as_bool)
-                        .unwrap_or(true),
-                    config
-                        .get("enforceForIndexOf")
-                        .and_then(serde_json::Value::as_bool)
-                        .unwrap_or_default(),
-                )
-            });
-
-        Self { enforce_for_switch_case, enforce_for_index_of }
+        serde_json::from_value::<DefaultRuleConfig<UseIsnan>>(value)
+            .unwrap_or_default()
+            .into_inner()
     }
 }
 
diff --git a/crates/oxc_linter/src/rules/eslint/valid_typeof.rs b/crates/oxc_linter/src/rules/eslint/valid_typeof.rs
@@ -4,8 +4,13 @@ use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 use oxc_syntax::operator::UnaryOperator;
 use schemars::JsonSchema;
+use serde::Deserialize;
 
-use crate::{AstNode, context::LintContext, rule::Rule};
+use crate::{
+    AstNode,
+    context::LintContext,
+    rule::{DefaultRuleConfig, Rule},
+};
 
 fn not_string(help: Option<&'static str>, span: Span) -> OxcDiagnostic {
     let mut d =
@@ -24,7 +29,7 @@ fn invalid_value(help: Option<&'static str>, span: Span) -> OxcDiagnostic {
     d
 }
 
-#[derive(Debug, Clone, Default, JsonSchema)]
+#[derive(Debug, Clone, Default, JsonSchema, Deserialize)]
 #[serde(rename_all = "camelCase", default)]
 pub struct ValidTypeof {
     /// The `requireStringLiterals` option when set to `true`, allows the comparison of `typeof`
@@ -154,14 +159,9 @@ impl Rule for ValidTypeof {
     }
 
     fn from_configuration(value: serde_json::Value) -> Self {
-        let require_string_literals = value.get(0).is_some_and(|config| {
-            config
-                .get("requireStringLiterals")
-                .and_then(serde_json::Value::as_bool)
-                .unwrap_or(false)
-        });
-
-        Self { require_string_literals }
+        serde_json::from_value::<DefaultRuleConfig<ValidTypeof>>(value)
+            .unwrap_or_default()
+            .into_inner()
     }
 }
 
diff --git a/crates/oxc_linter/src/rules/import/consistent_type_specifier_style.rs b/crates/oxc_linter/src/rules/import/consistent_type_specifier_style.rs
@@ -11,7 +11,12 @@ use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 
-use crate::{AstNode, context::LintContext, fixer::RuleFixer, rule::Rule};
+use crate::{
+    AstNode,
+    context::LintContext,
+    fixer::RuleFixer,
+    rule::{DefaultRuleConfig, Rule},
+};
 
 fn consistent_type_specifier_style_diagnostic(span: Span, mode: &Mode) -> OxcDiagnostic {
     let (warn_msg, help_msg) = if *mode == Mode::PreferInline {
@@ -31,25 +36,15 @@ fn consistent_type_specifier_style_diagnostic(span: Span, mode: &Mode) -> OxcDia
 #[derive(Debug, Default, PartialEq, Clone, Serialize, Deserialize, JsonSchema)]
 #[serde(rename_all = "kebab-case")]
 enum Mode {
+    /// Prefer `import type { Foo } from 'foo'` for type imports.
     #[default]
     PreferTopLevel,
+    /// Prefer `import { type Foo } from 'foo'` for type imports.
     PreferInline,
 }
 
-impl Mode {
-    pub fn from(raw: &str) -> Self {
-        if raw == "prefer-inline" { Self::PreferInline } else { Self::PreferTopLevel }
-    }
-}
-
-#[derive(Debug, Default, Clone, Serialize, Deserialize, JsonSchema)]
-#[serde(rename_all = "camelCase", default)]
-pub struct ConsistentTypeSpecifierStyle {
-    /// Specify whether to prefer top-level type-only imports or inline type specifiers.
-    /// - `"prefer-top-level"`: `import type { Foo } from 'foo'`
-    /// - `"prefer-inline"`: `import { type Foo } from 'foo'`
-    mode: Mode,
-}
+#[derive(Debug, Default, Clone, Serialize, Deserialize)]
+pub struct ConsistentTypeSpecifierStyle(Mode);
 
 declare_oxc_lint!(
     /// ### What it does
@@ -91,12 +86,14 @@ declare_oxc_lint!(
     import,
     style,
     conditional_fix,
-    config = ConsistentTypeSpecifierStyle,
+    config = Mode,
 );
 
 impl Rule for ConsistentTypeSpecifierStyle {
     fn from_configuration(value: Value) -> Self {
-        Self { mode: value.get(0).and_then(Value::as_str).map(Mode::from).unwrap_or_default() }
+        serde_json::from_value::<DefaultRuleConfig<ConsistentTypeSpecifierStyle>>(value)
+            .unwrap_or_default()
+            .into_inner()
     }
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
         let AstKind::ImportDeclaration(import_decl) = node.kind() else {
@@ -112,15 +109,15 @@ impl Rule for ConsistentTypeSpecifierStyle {
         {
             return;
         }
-        if self.mode == Mode::PreferTopLevel && import_decl.import_kind.is_value() {
+        if self.0 == Mode::PreferTopLevel && import_decl.import_kind.is_value() {
             let (value_specifiers, type_specifiers) = split_import_specifiers_by_kind(specifiers);
             if type_specifiers.is_empty() {
                 return;
             }
 
             for item in &type_specifiers {
                 ctx.diagnostic_with_fix(
-                    consistent_type_specifier_style_diagnostic(item.span(), &self.mode),
+                    consistent_type_specifier_style_diagnostic(item.span(), &self.0),
                     |fixer| {
                         let mut import_source = String::new();
 
@@ -141,9 +138,9 @@ impl Rule for ConsistentTypeSpecifierStyle {
                 );
             }
         }
-        if self.mode == Mode::PreferInline && import_decl.import_kind.is_type() {
+        if self.0 == Mode::PreferInline && import_decl.import_kind.is_type() {
             ctx.diagnostic_with_fix(
-                consistent_type_specifier_style_diagnostic(import_decl.span, &self.mode),
+                consistent_type_specifier_style_diagnostic(import_decl.span, &self.0),
                 |fixer| {
                     let fixer = fixer.for_multifix();
                     let mut rule_fixes = fixer.new_fix_with_capacity(len);
diff --git a/crates/oxc_linter/src/rules/typescript/consistent_type_definitions.rs b/crates/oxc_linter/src/rules/typescript/consistent_type_definitions.rs
@@ -13,7 +13,7 @@ use serde::{Deserialize, Serialize};
 use crate::{
     AstNode,
     context::{ContextHost, LintContext},
-    rule::Rule,
+    rule::{DefaultRuleConfig, Rule},
 };
 
 fn consistent_type_definitions_diagnostic(
@@ -28,33 +28,26 @@ fn consistent_type_definitions_diagnostic(
     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.
-    ///
-    /// Setting to `type` enforces the use of types for object type definitions.
-    ///
-    /// Examples of **incorrect** code for this option:
+#[derive(Debug, Default, Clone, Deserialize, Serialize)]
+pub struct ConsistentTypeDefinitions(ConsistentTypeDefinitionsConfig);
+
+#[derive(Debug, Default, Clone, Copy, Eq, PartialEq, JsonSchema, Deserialize, Serialize)]
+#[serde(rename_all = "kebab-case")]
+enum ConsistentTypeDefinitionsConfig {
+    /// Prefer `interface` over `type` for object type definitions:
     ///
     /// ```typescript
     /// interface T {
     ///   x: number;
     /// }
     /// ```
+    #[default]
+    Interface,
+    /// Prefer `type` over `interface` for object type definitions:
     ///
-    /// Examples of **correct** code for this option:
     /// ```typescript
     /// type T = { x: number };
     /// ```
-    config: ConsistentTypeDefinitionsConfig,
-}
-
-#[derive(Debug, Default, Clone, Copy, Eq, PartialEq, JsonSchema, Deserialize, Serialize)]
-#[serde(rename_all = "kebab-case")]
-enum ConsistentTypeDefinitionsConfig {
-    #[default]
-    Interface,
     Type,
 }
 
@@ -71,7 +64,7 @@ declare_oxc_lint!(
     ///
     /// ### Examples
     ///
-    /// By default this rule enforces the use of interfaces for object types.
+    /// By default this rule enforces the use of `interface` for defining object types.
     ///
     /// Examples of **incorrect** code for this rule:
     /// ```typescript
@@ -91,26 +84,21 @@ declare_oxc_lint!(
     typescript,
     style,
     fix,
-    config = ConsistentTypeDefinitions,
+    config = ConsistentTypeDefinitionsConfig,
 );
 
 impl Rule for ConsistentTypeDefinitions {
     fn from_configuration(value: serde_json::Value) -> Self {
-        let config = value.get(0).and_then(serde_json::Value::as_str).map_or_else(
-            ConsistentTypeDefinitionsConfig::default,
-            |value| match value {
-                "type" => ConsistentTypeDefinitionsConfig::Type,
-                _ => ConsistentTypeDefinitionsConfig::Interface,
-            },
-        );
-        Self { config }
+        serde_json::from_value::<DefaultRuleConfig<ConsistentTypeDefinitions>>(value)
+            .unwrap_or_default()
+            .into_inner()
     }
 
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
         match node.kind() {
             AstKind::TSTypeAliasDeclaration(decl) => match &decl.type_annotation {
                 TSType::TSTypeLiteral(_)
-                    if self.config == ConsistentTypeDefinitionsConfig::Interface =>
+                    if self.0 == ConsistentTypeDefinitionsConfig::Interface =>
                 {
                     let start = if decl.declare {
                         let base_start = decl.span.start + 7;
@@ -155,7 +143,7 @@ impl Rule for ConsistentTypeDefinitions {
 
             AstKind::ExportDefaultDeclaration(exp) => match &exp.declaration {
                 ExportDefaultDeclarationKind::TSInterfaceDeclaration(decl)
-                    if self.config == ConsistentTypeDefinitionsConfig::Type =>
+                    if self.0 == ConsistentTypeDefinitionsConfig::Type =>
                 {
                     let name_span_start = &decl.id.span.start;
                     let mut name_span_end = &decl.id.span.end;
@@ -192,7 +180,7 @@ impl Rule for ConsistentTypeDefinitions {
             },
 
             AstKind::TSInterfaceDeclaration(decl)
-                if self.config == ConsistentTypeDefinitionsConfig::Type =>
+                if self.0 == ConsistentTypeDefinitionsConfig::Type =>
             {
                 let start = if decl.declare {
                     let base_start = decl.span.start + 7;
