docs(linter): Add config option docs for jsdoc/require-param and jsdoc/require-returns rules (#15857)

Part of #14743.

I also refactored the default definitions a bit to make sure they were simple and matched the usual patterns in the app.

Generated docs:

```md
## Configuration

This rule accepts a configuration object with the following properties:

### checkConstructors

type: `boolean`

default: `false`

Whether to check constructor methods.

### checkDestructured

type: `boolean`

default: `true`

Whether to check destructured parameters.

### checkDestructuredRoots

type: `boolean`

default: `true`

Whether to check destructured parameters when you have code like
`function doSomething({ a, b }) { ... }`. Because there is no named
parameter in this example, when this option is `true` you must
have a `@param` tag that corresponds to `{a, b}`.

### checkGetters

type: `boolean`

default: `true`

Whether to check getter methods.

### checkRestProperty

type: `boolean`

default: `false`

Whether to check rest properties.

### checkSetters

type: `boolean`

default: `true`

Whether to check setter methods.

### checkTypesPattern

type: `string`

default: `"^(?:[oO]bject|[aA]rray|PlainObject|Generic(?:Object|Array))$"`

Regex pattern string to match types that exempt parameters from checking.

### exemptedBy

type: `string[]`

default: `["inheritdoc"]`

List of JSDoc tags that exempt functions from `@param` checking.
```

```md
## Configuration

This rule accepts a configuration object with the following properties:

### checkConstructors

type: `boolean`

default: `false`

Whether to check constructor methods.

### checkGetters

type: `boolean`

default: `true`

Whether to check getter methods.

### exemptedBy

type: `string[]`

default: `["inheritdoc"]`

Tags that exempt functions from requiring `@returns`.

### forceRequireReturn

type: `boolean`

default: `false`

Whether to require a `@returns` tag even if the function doesn't return a value.

### forceReturnsWithAsync

type: `boolean`

default: `false`

Whether to require a `@returns` tag for async functions.
```

Author: connorshea

crates/oxc_linter/src/rules/jsdoc/require_param.rs

@@ -5,6 +5,7 @@ use std::sync::{
 use lazy_regex::Regex;
 use oxc_span::Span;
 use rustc_hash::{FxHashMap, FxHashSet};
+use schemars::JsonSchema;
 use serde::Deserialize;
 
 use oxc_ast::{AstKind, ast::MethodDefinitionKind};
@@ -16,8 +17,8 @@ use crate::{
     context::LintContext,
     rule::Rule,
     utils::{
-        ParamKind, collect_params, default_true, get_function_nearest_jsdoc_node,
-        should_ignore_as_avoid, should_ignore_as_internal, should_ignore_as_private,
+        ParamKind, collect_params, get_function_nearest_jsdoc_node, should_ignore_as_avoid,
+        should_ignore_as_internal, should_ignore_as_private,
     },
 };
 
@@ -30,14 +31,58 @@ fn require_param_diagnostic(violations: Vec<Span>) -> OxcDiagnostic {
 #[derive(Debug, Default, Clone)]
 pub struct RequireParam(Box<RequireParamConfig>);
 
+#[derive(Debug, Clone, Deserialize, JsonSchema)]
+#[serde(rename_all = "camelCase", default)]
+struct RequireParamConfig {
+    /// List of JSDoc tags that exempt functions from `@param` checking.
+    #[serde(default = "default_exempted_by")]
+    exempted_by: Vec<String>,
+    /// Whether to check constructor methods.
+    check_constructors: bool,
+    /// Whether to check getter methods.
+    check_getters: bool,
+    /// Whether to check setter methods.
+    check_setters: bool,
+    /// Whether to check destructured parameters when you have code like
+    /// `function doSomething({ a, b }) { ... }`. Because there is no named
+    /// parameter in this example, when this option is `true` you must
+    /// have a `@param` tag that corresponds to `{a, b}`.
+    check_destructured_roots: bool,
+    /// Whether to check destructured parameters.
+    check_destructured: bool,
+    /// Whether to check rest properties.
+    check_rest_property: bool,
+    /// Regex pattern to match types that exempt parameters from checking.
+    #[serde(default = "default_check_types_pattern")]
+    check_types_pattern: String,
+    // TODO: Support this config
+    // use_default_object_properties: bool,
+}
+
+impl Default for RequireParamConfig {
+    fn default() -> Self {
+        Self {
+            exempted_by: default_exempted_by(),
+            check_constructors: false,
+            check_getters: true,
+            check_setters: true,
+            check_destructured_roots: true,
+            check_destructured: true,
+            check_rest_property: false,
+            check_types_pattern: default_check_types_pattern(),
+        }
+    }
+}
+
 declare_oxc_lint!(
     /// ### What it does
     ///
     /// Requires that all function parameters are documented with JSDoc `@param` tags.
     ///
     /// ### Why is this bad?
     ///
-    /// The rule is aimed at enforcing code quality and maintainability by requiring that all function parameters are documented.
+    /// The rule is aimed at enforcing code quality and maintainability by requiring
+    /// that all function parameters are documented.
     ///
     /// ### Examples
     ///
@@ -55,56 +100,9 @@ declare_oxc_lint!(
     RequireParam,
     jsdoc,
     pedantic,
+    config = RequireParamConfig,
 );
 
-#[derive(Debug, Clone, Deserialize)]
-struct RequireParamConfig {
-    #[serde(default = "default_exempted_by", rename = "exemptedBy")]
-    exempted_by: Vec<String>,
-    #[serde(default = "default_true", rename = "checkConstructors")]
-    check_constructors: bool,
-    #[serde(default, rename = "checkGetters")]
-    check_getters: bool,
-    #[serde(default, rename = "checkSetters")]
-    check_setters: bool,
-    #[serde(default = "default_true", rename = "checkDestructuredRoots")]
-    check_destructured_roots: bool,
-    #[serde(default = "default_true", rename = "checkDestructured")]
-    check_destructured: bool,
-    #[serde(default, rename = "checkRestProperty")]
-    check_rest_property: bool,
-    #[serde(default = "default_check_types_pattern", rename = "checkTypesPattern")]
-    check_types_pattern: String,
-    // TODO: Support this config
-    // #[serde(default, rename = "useDefaultObjectProperties")]
-    // use_default_object_properties: bool,
-}
-impl Default for RequireParamConfig {
-    fn default() -> Self {
-        Self {
-            exempted_by: default_exempted_by(),
-            check_constructors: false,
-            check_getters: default_true(),
-            check_setters: default_true(),
-            check_destructured_roots: default_true(),
-            check_destructured: default_true(),
-            check_rest_property: false,
-            check_types_pattern: default_check_types_pattern(),
-        }
-    }
-}
-fn default_exempted_by() -> Vec<String> {
-    vec!["inheritdoc".to_string()]
-}
-fn default_check_types_pattern() -> String {
-    "^(?:[oO]bject|[aA]rray|PlainObject|Generic(?:Object|Array))$".to_string() // spellchecker:disable-line
-}
-
-fn regex_cache() -> RwLockWriteGuard<'static, FxHashMap<String, Regex>> {
-    static REGEX_CACHE: OnceLock<RwLock<FxHashMap<String, Regex>>> = OnceLock::new();
-    REGEX_CACHE.get_or_init(|| RwLock::new(FxHashMap::default())).write().unwrap()
-}
-
 impl Rule for RequireParam {
     fn from_configuration(value: serde_json::Value) -> Self {
         value
@@ -263,6 +261,19 @@ impl Rule for RequireParam {
     }
 }
 
+fn default_exempted_by() -> Vec<String> {
+    vec!["inheritdoc".to_string()]
+}
+
+fn default_check_types_pattern() -> String {
+    "^(?:[oO]bject|[aA]rray|PlainObject|Generic(?:Object|Array))$".to_string() // spellchecker:disable-line
+}
+
+fn regex_cache() -> RwLockWriteGuard<'static, FxHashMap<String, Regex>> {
+    static REGEX_CACHE: OnceLock<RwLock<FxHashMap<String, Regex>>> = OnceLock::new();
+    REGEX_CACHE.get_or_init(|| RwLock::new(FxHashMap::default())).write().unwrap()
+}
+
 fn collect_tags<'a>(
     jsdocs: &[JSDoc<'a>],
     resolved_param_tag_name: &str,

crates/oxc_linter/src/rules/jsdoc/require_returns.rs

@@ -7,32 +7,61 @@ use oxc_macros::declare_oxc_lint;
 use oxc_semantic::JSDoc;
 use oxc_span::Span;
 use rustc_hash::FxHashMap;
+use schemars::JsonSchema;
 use serde::Deserialize;
 
 use crate::{
     context::LintContext,
     rule::Rule,
     utils::{
-        default_true, get_function_nearest_jsdoc_node, is_duplicated_special_tag,
-        is_missing_special_tag, should_ignore_as_avoid, should_ignore_as_custom_skip,
-        should_ignore_as_internal, should_ignore_as_private,
+        get_function_nearest_jsdoc_node, is_duplicated_special_tag, is_missing_special_tag,
+        should_ignore_as_avoid, should_ignore_as_custom_skip, should_ignore_as_internal,
+        should_ignore_as_private,
     },
 };
 
 fn missing_returns_diagnostic(span: Span) -> OxcDiagnostic {
     OxcDiagnostic::warn("Missing JSDoc `@returns` declaration for function.")
-        .with_help("Add `@returns` tag to the JSDoc comment.")
+        .with_help("Add a `@returns` tag to the JSDoc comment.")
         .with_label(span)
 }
+
 fn duplicate_returns_diagnostic(span: Span) -> OxcDiagnostic {
     OxcDiagnostic::warn("Duplicate `@returns` tags.")
-        .with_help("Remove redundant `@returns` tag.")
+        .with_help("Remove the redundant `@returns` tag.")
         .with_label(span)
 }
 
 #[derive(Debug, Default, Clone)]
 pub struct RequireReturns(Box<RequireReturnsConfig>);
 
+#[derive(Debug, Clone, Deserialize, JsonSchema)]
+#[serde(rename_all = "camelCase", default)]
+struct RequireReturnsConfig {
+    /// Tags that exempt functions from requiring `@returns`.
+    exempted_by: Vec<String>,
+    /// Whether to check constructor methods.
+    check_constructors: bool,
+    /// Whether to check getter methods.
+    check_getters: bool,
+    /// Whether to require a `@returns` tag even if the function doesn't return a value.
+    force_require_return: bool,
+    /// Whether to require a `@returns` tag for async functions.
+    force_returns_with_async: bool,
+}
+
+impl Default for RequireReturnsConfig {
+    fn default() -> Self {
+        Self {
+            exempted_by: default_exempted_by(),
+            check_constructors: false,
+            check_getters: true,
+            force_require_return: false,
+            force_returns_with_async: false,
+        }
+    }
+}
+
 declare_oxc_lint!(
     /// ### What it does
     ///
@@ -65,36 +94,9 @@ declare_oxc_lint!(
     RequireReturns,
     jsdoc,
     pedantic,
+    config = RequireReturnsConfig,
 );
 
-#[derive(Debug, Clone, Deserialize)]
-struct RequireReturnsConfig {
-    #[serde(default = "default_exempted_by", rename = "exemptedBy")]
-    exempted_by: Vec<String>,
-    #[serde(default, rename = "checkConstructors")]
-    check_constructors: bool,
-    #[serde(default = "default_true", rename = "checkGetters")]
-    check_getters: bool,
-    #[serde(default, rename = "forceRequireReturn")]
-    force_require_return: bool,
-    #[serde(default, rename = "forceReturnsWithAsync")]
-    force_returns_with_async: bool,
-}
-impl Default for RequireReturnsConfig {
-    fn default() -> Self {
-        Self {
-            exempted_by: default_exempted_by(),
-            check_constructors: false,
-            check_getters: true,
-            force_require_return: false,
-            force_returns_with_async: false,
-        }
-    }
-}
-fn default_exempted_by() -> Vec<String> {
-    vec!["inheritdoc".to_string()]
-}
-
 impl Rule for RequireReturns {
     fn from_configuration(value: serde_json::Value) -> Self {
         value
@@ -243,6 +245,10 @@ impl Rule for RequireReturns {
     }
 }
 
+fn default_exempted_by() -> Vec<String> {
+    vec!["inheritdoc".to_string()]
+}
+
 /// - Some(true): `Promise` with value
 /// - Some(false): `Promise` without value
 /// - None: Not a `Promise` but some other expression