feat(linter): add support for vitest/valid-title rule (#12085)

I noticed that there's already a fully working implementation of
`jest/valid-title`, and the logic is very similar. However, the vitest
rule has slightly different configuration options, so it's not quite the
same. I made the `vitest/valid-title` rule work with their specific
configuration options and unit tests.

As part of this, I added support for the vitest typecheck option so that
all the vitest-specific test scenarios would pass for this rule. This
meant adding a `VitestPluginSettings` module with `typecheck` available
as a boolean, defaulting to false.

I considered trying to reuse some of the logic from the jest rule
equivalent, but since there are subtle differences I didn't think the
refactor was worth it on a first pass. The only tradeoff is that there's
some duplicate logic between the jest / vitest rules for this.

Future consideration: The only other rule that uses `typecheck` as a
config setting in `eslint-plugin-vitest` is the `expect-expect` rule,
which we currently have listed in the
[VITEST_COMPATIBLE_JEST_RULES](https://github.com/oxc-project/oxc/blob/main/crates/oxc_linter/src/utils/mod.rs#L34).
It might be worth adding support for `typecheck` in that rule for 100%
compatibility.

----
Reference:

Vitest Config Options from `vitest/valid_title.rs`):
```ts
interface Options {
    ignoreTypeOfDescribeName?: boolean;
    allowArguments?: boolean;
    disallowedWords?: string[];
    mustNotMatch?: Partial<Record<'describe' | 'test' | 'it', string>> | string;
    mustMatch?: Partial<Record<'describe' | 'test' | 'it', string>> | string;
}
```

Jest Config Options (from `jest/valid_title.rs`):
```ts
interface Options {
    ignoreSpaces?: boolean;
    ignoreTypeOfTestName?: boolean;
    ignoreTypeOfDescribeName?: boolean;
    disallowedWords?: string[];
    mustNotMatch?: Partial<Record<'describe' | 'test' | 'it', string>> | string;
    mustMatch?: Partial<Record<'describe' | 'test' | 'it', string>> | string;
}
```

[Vitest valid-title Rule
Docs](https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/valid-title.md)
[Jest valid-title Rule
Docs](https://github.com/jest-community/eslint-plugin-jest/blob/main/docs/rules/valid-title.md)

---------

Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
Co-authored-by: Claude <[email protected]>

Author: 3 people

apps/oxlint/src/snapshots/_-c fixtures__print_config__ban_rules__eslintrc.json -A all -D eqeqeq [email protected]

@@ -42,6 +42,9 @@ working directory:
       "implementsReplacesDocs": false,
       "exemptDestructuredRootsFromChecks": false,
       "tagNamePreference": {}
+    },
+    "vitest": {
+      "typecheck": false
     }
   },
   "env": {

apps/oxlint/src/snapshots/fixtures_-A all [email protected]

@@ -35,6 +35,9 @@ working directory: fixtures
       "implementsReplacesDocs": false,
       "exemptDestructuredRootsFromChecks": false,
       "tagNamePreference": {}
+    },
+    "vitest": {
+      "typecheck": false
     }
   },
   "env": {

crates/oxc_linter/src/config/settings/mod.rs

@@ -2,13 +2,14 @@ pub mod jsdoc;
 mod jsx_a11y;
 mod next;
 mod react;
+pub mod vitest;
 
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
 use self::{
     jsdoc::JSDocPluginSettings, jsx_a11y::JSXA11yPluginSettings, next::NextPluginSettings,
-    react::ReactPluginSettings,
+    react::ReactPluginSettings, vitest::VitestPluginSettings,
 };
 
 /// # Oxlint Plugin Settings
@@ -52,6 +53,9 @@ pub struct OxlintSettings {
 
     #[serde(default)]
     pub jsdoc: JSDocPluginSettings,
+
+    #[serde(default)]
+    pub vitest: VitestPluginSettings,
 }
 
 #[cfg(test)]

crates/oxc_linter/src/config/settings/vitest.rs

@@ -0,0 +1,16 @@
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+
+/// Configure Vitest plugin rules.
+///
+/// See [eslint-plugin-vitest](https://github.com/veritem/eslint-plugin-vitest)'s
+/// configuration for a full reference.
+#[derive(Debug, Clone, Deserialize, Serialize, Default, JsonSchema)]
+#[cfg_attr(test, derive(PartialEq, Eq))]
+pub struct VitestPluginSettings {
+    /// Whether to enable typecheck mode for Vitest rules.
+    /// When enabled, some rules will skip certain checks for describe blocks
+    /// to accommodate TypeScript type checking scenarios.
+    #[serde(default)]
+    pub typecheck: bool,
+}

crates/oxc_linter/src/rules.rs

@@ -1260,12 +1260,12 @@ oxc_macros::declare_all_lint_rules! {
     vitest::prefer_to_be_object,
     vitest::prefer_to_be_truthy,
     vitest::require_local_test_context_for_concurrent_snapshots,
-    vue::define_props_destructuring,
     vue::define_emits_declaration,
     vue::define_props_declaration,
+    vue::define_props_destructuring,
     vue::max_props,
-    vue::no_import_compiler_macros,
     vue::no_export_in_script_setup,
+    vue::no_import_compiler_macros,
     vue::no_multiple_slot_args,
     vue::no_required_prop_with_default,
     vue::prefer_import_from_vue,

crates/oxc_linter/src/rules/jest/valid_title.rs

@@ -28,6 +28,7 @@ pub struct ValidTitle(Box<ValidTitleConfig>);
 pub struct ValidTitleConfig {
     ignore_type_of_test_name: bool,
     ignore_type_of_describe_name: bool,
+    allow_arguments: bool,
     disallowed_words: Vec<CompactStr>,
     ignore_space: bool,
     must_not_match_patterns: FxHashMap<MatchKind, CompiledMatcherAndMessage>,
@@ -45,7 +46,7 @@ impl std::ops::Deref for ValidTitle {
 declare_oxc_lint!(
     /// ### What it does
     ///
-    /// Checks that the titles of Jest blocks are valid.
+    /// Checks that the titles of Jest and Vitest blocks are valid.
     ///
     /// Titles must be:
     /// - not empty,
@@ -84,6 +85,7 @@ declare_oxc_lint!(
     ///     ignoreSpaces?: boolean;
     ///     ignoreTypeOfTestName?: boolean;
     ///     ignoreTypeOfDescribeName?: boolean;
+    ///     allowArguments?: boolean;
     ///     disallowedWords?: string[];
     ///     mustNotMatch?: Partial<Record<'describe' | 'test' | 'it', string>> | string;
     ///     mustMatch?: Partial<Record<'describe' | 'test' | 'it', string>> | string;
@@ -108,6 +110,7 @@ impl Rule for ValidTitle {
 
         let ignore_type_of_test_name = get_as_bool("ignoreTypeOfTestName");
         let ignore_type_of_describe_name = get_as_bool("ignoreTypeOfDescribeName");
+        let allow_arguments = get_as_bool("allowArguments");
         let ignore_space = get_as_bool("ignoreSpaces");
         let disallowed_words = config
             .and_then(|v| v.get("disallowedWords"))
@@ -125,6 +128,7 @@ impl Rule for ValidTitle {
         Self(Box::new(ValidTitleConfig {
             ignore_type_of_test_name,
             ignore_type_of_describe_name,
+            allow_arguments,
             disallowed_words,
             ignore_space,
             must_not_match_patterns,
@@ -159,10 +163,29 @@ impl ValidTitle {
             return;
         }
 
+        // Check if extend keyword has been used (vitest feature)
+        if let Some(member) = jest_fn_call.members.first()
+            && member.is_name_equal("extend")
+        {
+            return;
+        }
+
         let Some(arg) = call_expr.arguments.first() else {
             return;
         };
 
+        // Handle typecheck settings - skip for describe when enabled (vitest feature)
+        if ctx.settings().vitest.typecheck
+            && matches!(jest_fn_call.kind, JestFnKind::General(JestGeneralFnKind::Describe))
+        {
+            return;
+        }
+
+        // Handle allowArguments option (vitest feature)
+        if self.allow_arguments && matches!(arg, Argument::Identifier(_)) {
+            return;
+        }
+
         let need_report_name = match jest_fn_call.kind {
             JestFnKind::General(JestGeneralFnKind::Test) => !self.ignore_type_of_test_name,
             JestFnKind::General(JestGeneralFnKind::Describe) => !self.ignore_type_of_describe_name,
@@ -284,15 +307,39 @@ fn compile_matcher_patterns(
 fn compile_matcher_pattern(pattern: MatcherPattern) -> Option<CompiledMatcherAndMessage> {
     match pattern {
         MatcherPattern::String(pattern) => {
-            let reg_str = format!("(?u){}", pattern.as_str()?);
+            let pattern_str = pattern.as_str()?;
+
+            // Check for JS regex literal: /pattern/flags
+            if let Some(stripped) = pattern_str.strip_prefix('/')
+                && let Some(end) = stripped.rfind('/')
+            {
+                let (pat, _flags) = stripped.split_at(end);
+                // For now, ignore flags and just use the pattern
+                let regex = Regex::new(pat).ok()?;
+                return Some((regex, None));
+            }
+
+            // Fallback: treat as a normal Rust regex with Unicode support
+            let reg_str = format!("(?u){pattern_str}");
             let reg = Regex::new(&reg_str).ok()?;
             Some((reg, None))
         }
         MatcherPattern::Vec(pattern) => {
-            let reg_str = pattern.first().and_then(|v| v.as_str()).map(|v| format!("(?u){v}"))?;
-            let reg = Regex::new(&reg_str).ok()?;
+            let pattern_str = pattern.first().and_then(|v| v.as_str())?;
+
+            // Check for JS regex literal: /pattern/flags
+            let regex = if let Some(stripped) = pattern_str.strip_prefix('/')
+                && let Some(end) = stripped.rfind('/')
+            {
+                let (pat, _flags) = stripped.split_at(end);
+                Regex::new(pat).ok()?
+            } else {
+                let reg_str = format!("(?u){pattern_str}");
+                Regex::new(&reg_str).ok()?
+            };
+
             let message = pattern.get(1).and_then(serde_json::Value::as_str).map(CompactStr::from);
-            Some((reg, message))
+            Some((regex, message))
         }
     }
 }
@@ -306,6 +353,7 @@ fn validate_title(
 ) {
     if title.is_empty() {
         Message::EmptyTitle.diagnostic(ctx, span);
+        return;
     }
 
     if !valid_title.disallowed_words.is_empty() {
@@ -585,6 +633,35 @@ fn test() {
             None,
         ),
         ("it(abc, function () {})", Some(serde_json::json!([{ "ignoreTypeOfTestName": true }]))),
+        // Vitest-specific tests with allowArguments option
+        ("it(foo, () => {});", Some(serde_json::json!([{ "allowArguments": true }]))),
+        ("describe(bar, () => {});", Some(serde_json::json!([{ "allowArguments": true }]))),
+        ("test(baz, () => {});", Some(serde_json::json!([{ "allowArguments": true }]))),
+        // Vitest-specific tests with .extend()
+        (
+            "export const myTest = test.extend({
+                archive: []
+            })",
+            None,
+        ),
+        ("const localTest = test.extend({})", None),
+        (
+            "import { it } from 'vitest'
+
+            const test = it.extend({
+                fixture: [
+                    async ({}, use) => {
+                        setup()
+                        await use()
+                        teardown()
+                    },
+                    { auto: true }
+                ],
+            })
+
+            test('', () => {})",
+            None,
+        ),
     ];
 
     let fail = vec![
@@ -927,6 +1004,8 @@ fn test() {
             None,
         ),
         ("it(abc, function () {})", None),
+        // Vitest-specific fail test with allowArguments: false
+        ("test(bar, () => {});", Some(serde_json::json!([{ "allowArguments": false }]))),
     ];
 
     let fix = vec![

crates/oxc_linter/src/snapshots/jest_valid_title.snap

@@ -574,3 +574,10 @@ source: crates/oxc_linter/src/tester.rs
    ·    ───
    ╰────
   help: "Replace your title with a string"
+
+  ⚠ eslint-plugin-jest(valid-title): "Title must be a string"
+   ╭─[valid_title.tsx:1:6]
+ 1 │ test(bar, () => {});
+   ·      ───
+   ╰────
+  help: "Replace your title with a string"

crates/oxc_linter/src/snapshots/schema_json.snap

@@ -113,6 +113,9 @@ expression: json
           "implementsReplacesDocs": false,
           "exemptDestructuredRootsFromChecks": false,
           "tagNamePreference": {}
+        },
+        "vitest": {
+          "typecheck": false
         }
       },
       "allOf": [
@@ -538,6 +541,16 @@ expression: json
               "$ref": "#/definitions/ReactPluginSettings"
             }
           ]
+        },
+        "vitest": {
+          "default": {
+            "typecheck": false
+          },
+          "allOf": [
+            {
+              "$ref": "#/definitions/VitestPluginSettings"
+            }
+          ]
         }
       }
     },
@@ -598,6 +611,17 @@ expression: json
           "type": "boolean"
         }
       ]
+    },
+    "VitestPluginSettings": {
+      "description": "Configure Vitest plugin rules.\n\nSee [eslint-plugin-vitest](https://github.com/veritem/eslint-plugin-vitest)'s\nconfiguration for a full reference.",
+      "type": "object",
+      "properties": {
+        "typecheck": {
+          "description": "Whether to enable typecheck mode for Vitest rules.\nWhen enabled, some rules will skip certain checks for describe blocks\nto accommodate TypeScript type checking scenarios.",
+          "default": false,
+          "type": "boolean"
+        }
+      }
     }
   }
 }

npm/oxlint/configuration_schema.json

@@ -109,6 +109,9 @@
           "implementsReplacesDocs": false,
           "exemptDestructuredRootsFromChecks": false,
           "tagNamePreference": {}
+        },
+        "vitest": {
+          "typecheck": false
         }
       },
       "allOf": [
@@ -534,6 +537,16 @@
               "$ref": "#/definitions/ReactPluginSettings"
             }
           ]
+        },
+        "vitest": {
+          "default": {
+            "typecheck": false
+          },
+          "allOf": [
+            {
+              "$ref": "#/definitions/VitestPluginSettings"
+            }
+          ]
         }
       }
     },
@@ -594,6 +607,17 @@
           "type": "boolean"
         }
       ]
+    },
+    "VitestPluginSettings": {
+      "description": "Configure Vitest plugin rules.\n\nSee [eslint-plugin-vitest](https://github.com/veritem/eslint-plugin-vitest)'s\nconfiguration for a full reference.",
+      "type": "object",
+      "properties": {
+        "typecheck": {
+          "description": "Whether to enable typecheck mode for Vitest rules.\nWhen enabled, some rules will skip certain checks for describe blocks\nto accommodate TypeScript type checking scenarios.",
+          "default": false,
+          "type": "boolean"
+        }
+      }
     }
   }
 }

tasks/website/src/linter/snapshots/schema_markdown.snap

@@ -540,3 +540,29 @@ Example:
 
 
 ##### settings.react.linkComponents[n]
+
+
+
+
+
+
+### settings.vitest
+
+type: `object`
+
+
+Configure Vitest plugin rules.
+
+See [eslint-plugin-vitest](https://github.com/veritem/eslint-plugin-vitest)'s
+configuration for a full reference.
+
+
+#### settings.vitest.typecheck
+
+type: `boolean`
+
+default: `false`
+
+Whether to enable typecheck mode for Vitest rules.
+When enabled, some rules will skip certain checks for describe blocks
+to accommodate TypeScript type checking scenarios.