feat: Add noUselessTypeConstraint

CHANGELOG.md

@@ -8,6 +8,10 @@
 ### Formatter
 ### Linter
 - Fixed an issue where the `noAssignInExpressions` rule replaced the operator with an invalid token, which caused other lint rules to crash. [#4464](https://github.com/rome/tools/issues/4464)
+
+#### New rules
+- [`noUselessTypeConstraint`](https://docs.rome.tools/lint/rules/noUselessTypeConstraint/)
+
 ### Parser
 ### VSCode
 ### JavaScript APIs

crates/rome_diagnostics_categories/src/categories.rs

@@ -42,6 +42,7 @@ define_categories! {
     "lint/complexity/noUselessLabel":"https://docs.rome.tools/lint/rules/noUselessLabel",
     "lint/complexity/noUselessRename": "https://docs.rome.tools/lint/rules/noUselessRename",
     "lint/complexity/noUselessSwitchCase": "https://docs.rome.tools/lint/rules/noUselessSwitchCase",
+    "lint/complexity/noUselessTypeConstraint": "https://docs.rome.tools/lint/rules/noUselessTypeConstraint",
     "lint/complexity/noWith": "https://docs.rome.tools/lint/rules/noWith",
     "lint/complexity/useFlatMap": "https://docs.rome.tools/lint/rules/useFlatMap",
     "lint/complexity/useOptionalChain": "https://docs.rome.tools/lint/rules/useOptionalChain",

crates/rome_js_analyze/src/analyzers/complexity/no_useless_type_constraint.rs

@@ -0,0 +1,90 @@
+use rome_analyze::context::RuleContext;
+use rome_analyze::{declare_rule, ActionCategory, Ast, Rule, RuleDiagnostic};
+use rome_console::markup;
+
+use rome_diagnostics::Applicability;
+use rome_js_syntax::TsTypeConstraintClause;
+use rome_rowan::{AstNode, BatchMutationExt};
+
+use crate::JsRuleAction;
+
+declare_rule! {
+    /// Disallow using `any` or `unknown` as type constraint.
+    ///
+    /// ## Examples
+    ///
+    /// ### Invalid
+    ///
+    /// ```ts,expect_diagnostic
+    ///
+    /// interface FooAny<T extends any> {}
+    ///
+    /// type BarAny<T extends any> = {};
+    ///
+    /// class BazAny<T extends any> {
+    ///   quxAny<U extends any>() {}
+    /// }
+    ///
+    /// const QuuxAny = <T extends any>() => {};
+    ///
+    /// function QuuzAny<T extends any>() {}
+    /// ```
+    ///
+    /// ### Valid
+    ///
+    /// ```ts
+    /// interface Foo<T> {}
+    ///
+    /// type Bar<T> = {};
+    ///```
+    pub(crate) NoUselessTypeConstraint {
+        version: "12.1.0",
+        name: "noUselessTypeConstraint",
+        recommended: true,
+    }
+}
+
+impl Rule for NoUselessTypeConstraint {
+    type Query = Ast<TsTypeConstraintClause>;
+    type State = TsTypeConstraintClause;
+    type Signals = Option<Self::State>;
+    type Options = ();
+
+    fn run(ctx: &RuleContext<Self>) -> Option<Self::State> {
+        let node = ctx.query();
+        let ty = node.ty().ok()?;
+
+        if ty.as_ts_any_type().is_some() || ty.as_ts_unknown_type().is_some() {
+            Some(node.clone())
+        } else {
+            None
+        }
+    }
+
+    fn diagnostic(_ctx: &RuleContext<Self>, state: &Self::State) -> Option<RuleDiagnostic> {
+        state.ty().ok()?;
+
+        Some(
+            RuleDiagnostic::new(
+                rule_category!(),
+                state.syntax().text_trimmed_range(),
+                markup! {
+                    "Useless type constraint."
+                },
+            )
+            .note("Constraining the type to `any` or `unknown` doesn't have any effect."),
+        )
+    }
+
+    fn action(ctx: &RuleContext<Self>, node_replace: &Self::State) -> Option<JsRuleAction> {
+        let mut mutation = ctx.root().begin();
+        mutation.remove_node(node_replace.clone());
+
+        Some(JsRuleAction {
+            category: ActionCategory::QuickFix,
+            applicability: Applicability::MaybeIncorrect,
+            message: markup! { "Remove useless type constraint." }.to_owned(),
+            mutation,
+        })
+    }
+}

crates/rome_js_analyze/tests/specs/complexity/noUselessTypeConstraint/invalid.ts

@@ -0,0 +1,15 @@
+interface FooAny1<T extends any> {
+	field: T;
+}
+
+interface FooAny2<T extends unknown> {
+	field: T;
+}
+
+class BazAny<T extends any> {
+  quxAny<U extends any>() {}
+}
+
+const QuuxAny = <T extends any>() => {};
+
+function QuuzAny<T extends any>() {}

crates/rome_js_analyze/tests/specs/complexity/noUselessTypeConstraint/invalid.ts.snap

@@ -0,0 +1,148 @@
+---
+source: crates/rome_js_analyze/tests/spec_tests.rs
+expression: invalid.ts
+---
+# Input
+```js
+interface FooAny1<T extends any> {
+	field: T;
+}
+
+interface FooAny2<T extends unknown> {
+	field: T;
+}
+
+class BazAny<T extends any> {
+  quxAny<U extends any>() {}
+}
+
+const QuuxAny = <T extends any>() => {};
+
+function QuuzAny<T extends any>() {}
+
+```
+
+# Diagnostics
+```
+invalid.ts:1:21 lint/complexity/noUselessTypeConstraint  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  ! Useless type constraint.
+
+  > 1 │ interface FooAny1<T extends any> {
+      │                     ^^^^^^^^^^^
+    2 │ 	field: T;
+    3 │ }
+
+  i Constraining the type to `any` or `unknown` doesn't have any effect.
+
+  i Suggested fix: Remove useless type constraint.
+
+    1 │ interface·FooAny1<T·extends·any>·{
+      │                     -----------   
+
+```
+
+```
+invalid.ts:5:21 lint/complexity/noUselessTypeConstraint  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  ! Useless type constraint.
+
+    3 │ }
+    4 │ 
+  > 5 │ interface FooAny2<T extends unknown> {
+      │                     ^^^^^^^^^^^^^^^
+    6 │ 	field: T;
+    7 │ }
+
+  i Constraining the type to `any` or `unknown` doesn't have any effect.
+
+  i Suggested fix: Remove useless type constraint.
+
+    5 │ interface·FooAny2<T·extends·unknown>·{
+      │                     ---------------   
+
+```
+
+```
+invalid.ts:9:16 lint/complexity/noUselessTypeConstraint  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  ! Useless type constraint.
+
+     7 │ }
+     8 │ 
+   > 9 │ class BazAny<T extends any> {
+       │                ^^^^^^^^^^^
+    10 │   quxAny<U extends any>() {}
+    11 │ }
+
+  i Constraining the type to `any` or `unknown` doesn't have any effect.
+
+  i Suggested fix: Remove useless type constraint.
+
+    9 │ class·BazAny<T·extends·any>·{
+      │                -----------   
+
+```
+
+```
+invalid.ts:10:12 lint/complexity/noUselessTypeConstraint  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  ! Useless type constraint.
+
+     9 │ class BazAny<T extends any> {
+  > 10 │   quxAny<U extends any>() {}
+       │            ^^^^^^^^^^^
+    11 │ }
+    12 │ 
+
+  i Constraining the type to `any` or `unknown` doesn't have any effect.
+
+  i Suggested fix: Remove useless type constraint.
+
+    10 │ ··quxAny<U·extends·any>()·{}
+       │            -----------      
+
+```
+
+```
+invalid.ts:13:20 lint/complexity/noUselessTypeConstraint  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  ! Useless type constraint.
+
+    11 │ }
+    12 │ 
+  > 13 │ const QuuxAny = <T extends any>() => {};
+       │                    ^^^^^^^^^^^
+    14 │ 
+    15 │ function QuuzAny<T extends any>() {}
+
+  i Constraining the type to `any` or `unknown` doesn't have any effect.
+
+  i Suggested fix: Remove useless type constraint.
+
+    13 │ const·QuuxAny·=·<T·extends·any>()·=>·{};
+       │                    -----------          
+
+```
+
+```
+invalid.ts:15:20 lint/complexity/noUselessTypeConstraint  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  ! Useless type constraint.
+
+    13 │ const QuuxAny = <T extends any>() => {};
+    14 │ 
+  > 15 │ function QuuzAny<T extends any>() {}
+       │                    ^^^^^^^^^^^
+    16 │ 
+
+  i Constraining the type to `any` or `unknown` doesn't have any effect.
+
+  i Suggested fix: Remove useless type constraint.
+
+    15 │ function·QuuzAny<T·extends·any>()·{}
+       │                    -----------      
+
+```
+
+

crates/rome_js_analyze/tests/specs/complexity/noUselessTypeConstraint/valid.ts

@@ -0,0 +1,11 @@
+interface FooAny0<T> {
+	field: T;
+}
+
+interface FooNotAny0<T extends string> {
+	field: T;
+}
+
+type Bar<T> = {};
+
+type Bar2<T extends string> = {};

crates/rome_js_analyze/tests/specs/complexity/noUselessTypeConstraint/valid.ts.snap

@@ -0,0 +1,21 @@
+---
+source: crates/rome_js_analyze/tests/spec_tests.rs
+expression: valid.ts
+---
+# Input
+```js
+interface FooAny0<T> {
+	field: T;
+}
+
+interface FooNotAny0<T extends string> {
+	field: T;
+}
+
+type Bar<T> = {};
+
+type Bar2<T extends string> = {};
+
+```
+
+