feat(lint/noEvolvingAny): add rule (#2112)

CHANGELOG.md

@@ -47,6 +47,12 @@ our [guidelines for writing a good changelog entry](https:/biomejs/b
 
 ### Linter
 
+#### New features
+
+- Add rule [noEvolvingAny](https://biomejs.dev/linter/rules/no-evolving-any) to disallow variables from evolving into `any` type through reassignments.
+
+Contributed by @fujiyamaorange
+
 #### Bug fixes
 
 - Rule `noUndeclaredDependencies` now also validates `peerDependencies` and `optionalDependencies` ([#2122](https:/biomejs/biome/issues/2122)). Contributed by @Sec-ant

crates/biome_diagnostics_categories/src/categories.rs

@@ -115,6 +115,7 @@ define_categories! {
  "lint/nursery/noDuplicateElseIf": "https://biomejs.dev/linter/rules/no-duplicate-else-if",
  "lint/nursery/noDuplicateJsonKeys": "https://biomejs.dev/linter/rules/no-duplicate-json-keys",
  "lint/nursery/noDuplicateTestHooks": "https://biomejs.dev/linter/rules/no-duplicate-test-hooks",
+ "lint/nursery/noEvolvingAny": "https://biomejs.dev/linter/rules/no-evolving-any",
  "lint/nursery/noExcessiveNestedTestSuites": "https://biomejs.dev/linter/rules/no-excessive-nested-test-suites",
  "lint/nursery/noExportsInTest": "https://biomejs.dev/linter/rules/no-exports-in-test",
  "lint/nursery/noFocusedTests": "https://biomejs.dev/linter/rules/no-focused-tests",

crates/biome_js_analyze/src/lint/nursery.rs

@@ -7,6 +7,7 @@ pub mod no_console;
 pub mod no_done_callback;
 pub mod no_duplicate_else_if;
 pub mod no_duplicate_test_hooks;
+pub mod no_evolving_any;
 pub mod no_excessive_nested_test_suites;
 pub mod no_exports_in_test;
 pub mod no_focused_tests;
@@ -32,6 +33,7 @@ declare_group! {
  self :: no_done_callback :: NoDoneCallback ,
  self :: no_duplicate_else_if :: NoDuplicateElseIf ,
  self :: no_duplicate_test_hooks :: NoDuplicateTestHooks ,
+ self :: no_evolving_any :: NoEvolvingAny ,
  self :: no_excessive_nested_test_suites :: NoExcessiveNestedTestSuites ,
  self :: no_exports_in_test :: NoExportsInTest ,
  self :: no_focused_tests :: NoFocusedTests ,

crates/biome_js_analyze/src/lint/nursery/no_evolving_any.rs

@@ -0,0 +1,123 @@
+use biome_analyze::{context::RuleContext, declare_rule, Ast, Rule, RuleDiagnostic};
+use biome_console::markup;
+use biome_js_syntax::{AnyJsExpression, JsFileSource, JsVariableDeclaration, JsVariableDeclarator};
+
+declare_rule! {
+ /// Disallow variables from evolving into `any` type through reassignments.
+ ///
+ /// In TypeScript, variables without explicit type annotations can evolve their types based on subsequent assignments.
+ /// This behaviour can accidentally lead to variables with an `any` type, weakening type safety.
+ /// Just like the `any` type, evolved `any` types disable many type-checking rules and should be avoided to maintain strong type safety.
+ /// This rule prevents such cases by ensuring variables do not evolve into `any` type, encouraging explicit type annotations and controlled type evolutions.
+ ///
+ /// ## Examples
+ ///
+ /// ### Invalid
+ ///
+ /// ```ts,expect_diagnostic
+ /// let a;
+ /// ````
+ ///
+ /// ```ts,expect_diagnostic
+ /// const b = [];
+ /// ````
+ ///
+ /// ```ts,expect_diagnostic
+ /// let c = null;
+ /// ````
+ ///
+ ///
+ /// ### Valid
+ ///
+ /// ```ts
+ /// let a: number;
+ /// let b = 1;
+ /// var c : string;
+ /// var d = "abn";
+ /// const e: never[] = [];
+ /// const f = [null];
+ /// const g = ['1'];
+ /// const h = [1];
+ /// let workspace: Workspace | null = null;
+ /// ```
+ ///
+ pub NoEvolvingAny {
+ version: "next",
+ name: "noEvolvingAny",
+ recommended: true,
+ }
+}
+
+impl Rule for NoEvolvingAny {
+ type Query = Ast<JsVariableDeclaration>;
+ type State = JsVariableDeclarator;
+ type Signals = Option<Self::State>;
+ type Options = ();
+
+ fn run(ctx: &RuleContext<Self>) -> Self::Signals {
+ let source_type = ctx.source_type::<JsFileSource>().language();
+ let is_ts_source = source_type.is_typescript();
+ let node = ctx.query();
+ let is_declaration = source_type.is_definition_file();
+
+ if is_declaration || !is_ts_source {
+ return None;
+ }
+
+ for declarator in node.declarators() {
+ let variable = declarator.ok()?;
+
+ let is_initialized = variable.initializer().is_some();
+ let is_type_annotated = variable.variable_annotation().is_some();
+
+ if !is_initialized && !is_type_annotated {
+ return Some(variable);
+ }
+
+ if is_initialized {
+ let initializer = variable.initializer()?;
+ let expression = initializer.expression().ok()?;
+ match expression {
+ AnyJsExpression::AnyJsLiteralExpression(literal_expr) => {
+ if literal_expr.as_js_null_literal_expression().is_some()
+ && !is_type_annotated
+ {
+ return Some(variable);
+ }
+ }
+ AnyJsExpression::JsArrayExpression(array_expr) => {
+ if array_expr.elements().into_iter().next().is_none() && !is_type_annotated
+ {
+ return Some(variable);
+ }
+ }
+ _ => continue,
+ };
+ }
+ }
+
+ None
+ }
+
+ fn diagnostic(_: &RuleContext<Self>, node: &Self::State) -> Option<RuleDiagnostic> {
+ let variable = node
+ .id()
+ .ok()?
+ .as_any_js_binding()?
+ .as_js_identifier_binding()?
+ .name_token()
+ .ok()?;
+ Some(
+ RuleDiagnostic::new(
+ rule_category!(),
+ variable.text_trimmed_range(),
+ markup! {
+ "This variable's type is not allowed to evolve implicitly, leading to potential "<Emphasis>"any"</Emphasis>" types."
+ },
+ )
+ .note(markup! {
+ "The variable's type may evolve, leading to "<Emphasis>"any"</Emphasis>". Use explicit type or initialization. Specifying an explicit type or initial value to avoid implicit type evolution."
+ }),
+ )
+ }
+}

crates/biome_js_analyze/src/options.rs

@@ -77,6 +77,8 @@ pub type NoEmptyInterface =
 pub type NoEmptyPattern =
  <lint::correctness::no_empty_pattern::NoEmptyPattern as biome_analyze::Rule>::Options;
 pub type NoEmptyTypeParameters = < lint :: complexity :: no_empty_type_parameters :: NoEmptyTypeParameters as biome_analyze :: Rule > :: Options ;
+pub type NoEvolvingAny =
+ <lint::nursery::no_evolving_any::NoEvolvingAny as biome_analyze::Rule>::Options;
 pub type NoExcessiveCognitiveComplexity = < lint :: complexity :: no_excessive_cognitive_complexity :: NoExcessiveCognitiveComplexity as biome_analyze :: Rule > :: Options ;
 pub type NoExcessiveNestedTestSuites = < lint :: nursery :: no_excessive_nested_test_suites :: NoExcessiveNestedTestSuites as biome_analyze :: Rule > :: Options ;
 pub type NoExplicitAny =

crates/biome_js_analyze/tests/specs/nursery/noEvolvingAny/invalid.ts

@@ -0,0 +1,19 @@
+let a;
+const b = [];
+let c = null;
+
+let someVar1;
+someVar1 = '123';
+someVar1 = 123;
+
+var someVar1;
+someVar1 = '123';
+someVar1 = 123;
+
+let x = 0, y, z = 0;
+var x = 0, y, z = 0;
+for(let a = 0, b; a < 5; a++) {}
+
+function ex() {
+ let b;
+}

crates/biome_js_analyze/tests/specs/nursery/noEvolvingAny/invalid.ts.snap

@@ -0,0 +1,176 @@
+---
+source: crates/biome_js_analyze/tests/spec_tests.rs
+expression: invalid.ts
+---
+# Input
+```ts
+let a;
+const b = [];
+let c = null;
+
+let someVar1;
+someVar1 = '123';
+someVar1 = 123;
+
+var someVar1;
+someVar1 = '123';
+someVar1 = 123;
+
+let x = 0, y, z = 0;
+var x = 0, y, z = 0;
+for(let a = 0, b; a < 5; a++) {}
+
+function ex() {
+ let b;
+}
+
+```
+
+# Diagnostics
+```
+invalid.ts:1:5 lint/nursery/noEvolvingAny ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+ ! This variable's type is not allowed to evolve implicitly, leading to potential any types.
+ 
+ > 1 │ let a;
+ │ ^
+ 2 │ const b = [];
+ 3 │ let c = null;
+ 
+ i The variable's type may evolve, leading to any. Use explicit type or initialization. Specifying an explicit type or initial value to avoid implicit type evolution.
+ 
+
+```
+
+```
+invalid.ts:2:7 lint/nursery/noEvolvingAny ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+ ! This variable's type is not allowed to evolve implicitly, leading to potential any types.
+ 
+ 1 │ let a;
+ > 2 │ const b = [];
+ │ ^
+ 3 │ let c = null;
+ 4 │ 
+ 
+ i The variable's type may evolve, leading to any. Use explicit type or initialization. Specifying an explicit type or initial value to avoid implicit type evolution.
+ 
+
+```
+
+```
+invalid.ts:3:5 lint/nursery/noEvolvingAny ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+ ! This variable's type is not allowed to evolve implicitly, leading to potential any types.
+ 
+ 1 │ let a;
+ 2 │ const b = [];
+ > 3 │ let c = null;
+ │ ^
+ 4 │ 
+ 5 │ let someVar1;
+ 
+ i The variable's type may evolve, leading to any. Use explicit type or initialization. Specifying an explicit type or initial value to avoid implicit type evolution.
+ 
+
+```
+
+```
+invalid.ts:5:5 lint/nursery/noEvolvingAny ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+ ! This variable's type is not allowed to evolve implicitly, leading to potential any types.
+ 
+ 3 │ let c = null;
+ 4 │ 
+ > 5 │ let someVar1;
+ │ ^^^^^^^^
+ 6 │ someVar1 = '123';
+ 7 │ someVar1 = 123;
+ 
+ i The variable's type may evolve, leading to any. Use explicit type or initialization. Specifying an explicit type or initial value to avoid implicit type evolution.
+ 
+
+```
+
+```
+invalid.ts:9:5 lint/nursery/noEvolvingAny ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+ ! This variable's type is not allowed to evolve implicitly, leading to potential any types.
+ 
+ 7 │ someVar1 = 123;
+ 8 │ 
+ > 9 │ var someVar1;
+ │ ^^^^^^^^
+ 10 │ someVar1 = '123';
+ 11 │ someVar1 = 123;
+ 
+ i The variable's type may evolve, leading to any. Use explicit type or initialization. Specifying an explicit type or initial value to avoid implicit type evolution.
+ 
+
+```
+
+```
+invalid.ts:13:12 lint/nursery/noEvolvingAny ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+ ! This variable's type is not allowed to evolve implicitly, leading to potential any types.
+ 
+ 11 │ someVar1 = 123;
+ 12 │ 
+ > 13 │ let x = 0, y, z = 0;
+ │ ^
+ 14 │ var x = 0, y, z = 0;
+ 15 │ for(let a = 0, b; a < 5; a++) {}
+ 
+ i The variable's type may evolve, leading to any. Use explicit type or initialization. Specifying an explicit type or initial value to avoid implicit type evolution.
+ 
+
+```
+
+```
+invalid.ts:14:12 lint/nursery/noEvolvingAny ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+ ! This variable's type is not allowed to evolve implicitly, leading to potential any types.
+ 
+ 13 │ let x = 0, y, z = 0;
+ > 14 │ var x = 0, y, z = 0;
+ │ ^
+ 15 │ for(let a = 0, b; a < 5; a++) {}
+ 16 │ 
+ 
+ i The variable's type may evolve, leading to any. Use explicit type or initialization. Specifying an explicit type or initial value to avoid implicit type evolution.
+ 
+
+```
+
+```
+invalid.ts:15:16 lint/nursery/noEvolvingAny ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+ ! This variable's type is not allowed to evolve implicitly, leading to potential any types.
+ 
+ 13 │ let x = 0, y, z = 0;
+ 14 │ var x = 0, y, z = 0;
+ > 15 │ for(let a = 0, b; a < 5; a++) {}
+ │ ^
+ 16 │ 
+ 17 │ function ex() {
+ 
+ i The variable's type may evolve, leading to any. Use explicit type or initialization. Specifying an explicit type or initial value to avoid implicit type evolution.
+ 
+
+```
+
+```
+invalid.ts:18:9 lint/nursery/noEvolvingAny ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+ ! This variable's type is not allowed to evolve implicitly, leading to potential any types.
+ 
+ 17 │ function ex() {
+ > 18 │ let b;
+ │ ^
+ 19 │ }
+ 20 │ 
+ 
+ i The variable's type may evolve, leading to any. Use explicit type or initialization. Specifying an explicit type or initial value to avoid implicit type evolution.
+ 
+
+```

crates/biome_js_analyze/tests/specs/nursery/noEvolvingAny/valid.ts

@@ -0,0 +1,15 @@
+/* should not generate diagnostics */
+
+let a: number;
+let b = 1
+var c : string;
+var d = "abn"
+const e: never[] = [];
+const f = [null];
+const g = ['1'];
+const h = [1];
+let workspace: Workspace | null = null;
+
+const x = 0;
+for(let y of xs) {}
+using z = f();