fix(noInvalidUseBeforeDeclaration): handle class, enum, import-equals (#8113)

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

Author: Conaclos

.changeset/twenty-signs-turn.md

@@ -0,0 +1,13 @@
+---
+"@biomejs/biome": patch
+---
+
+Fixed [`noInvalidUseBeforeDeclaration`](https://biomejs.dev/linter/rules/no-invalid-use-before-declaration/).
+The rule now reports invalid use of classes, enums, and TypeScript's import-equals before their declarations.
+
+The following code is now reported as invalid:
+
+```js
+new C();
+class C {}
+```

crates/biome_configuration/src/analyzer/linter/rules.rs

@@ -11,9 +11,10 @@ use biome_rowan::{AstNode, SyntaxNodeOptionExt, TextRange};
 use biome_rule_options::no_invalid_use_before_declaration::NoInvalidUseBeforeDeclarationOptions;
 
 declare_lint_rule! {
-    /// Disallow the use of variables and function parameters before their declaration
+    /// Disallow the use of variables, function parameters, classes, and enums before their declaration
     ///
-    /// JavaScript doesn't allow the use of block-scoped variables (`let`, `const`) and function parameters before their declaration.
+    /// JavaScript doesn't allow the use of block-scoped variables (`let`, `const`), function parameters, and classes before their declaration.
+    /// Similarly TypeScript doesn't allow the use of enums before their declaration.
     /// A `ReferenceError` will be thrown with any attempt to access the variable or the parameter before its declaration.
     ///
     /// The rule also reports the use of variables declared with `var` before their declarations.
@@ -40,14 +41,16 @@ declare_lint_rule! {
     /// function f(a = b, b = 0) {}
     /// ```
     ///
+    /// ```js,expect_diagnostic
+    /// new C();
+    /// class C {}
+    /// ```
+    ///
     /// ### Valid
     ///
     /// ```js
     /// f();
     /// function f() {}
-    ///
-    /// new C();
-    /// class C {}
     /// ```
     ///
     /// ```js
@@ -60,6 +63,14 @@ declare_lint_rule! {
     /// function f() { return CONSTANT; }
     /// const CONSTANT = 0;
     /// ```
+    ///
+    /// ```ts
+    /// function f() {
+    ///     new C();
+    /// }
+    /// let c: C;
+    /// class C {}
+    /// ```
     pub NoInvalidUseBeforeDeclaration {
         version: "1.5.0",
         name: "noInvalidUseBeforeDeclaration",
@@ -105,20 +116,21 @@ impl Rule for NoInvalidUseBeforeDeclaration {
             let Ok(declaration_kind) = DeclarationKind::try_from(&declaration) else {
                 continue;
             };
-            let declaration_end = declaration.range().end();
-            let declaration_control_flow_root =
-                if let AnyJsBindingDeclaration::JsVariableDeclarator(declarator) = declaration
-                    .parent_binding_pattern_declaration()
-                    .unwrap_or(declaration)
-                {
-                    declarator
-                        .syntax()
-                        .ancestors()
-                        .skip(1)
-                        .find(|ancestor| AnyJsControlFlowRoot::can_cast(ancestor.kind()))
-                } else {
-                    None
-                };
+            let declaration_end = if matches!(
+                declaration_kind,
+                DeclarationKind::Class | DeclarationKind::Enum
+            ) {
+                // A class can be instantiated by its properties.
+                // Enum members can be qualified by the enum name.
+                id.range().end()
+            } else {
+                declaration.range().end()
+            };
+            let declaration_control_flow_root = declaration
+                .syntax()
+                .ancestors()
+                .skip(1)
+                .find(|ancestor| AnyJsControlFlowRoot::can_cast(ancestor.kind()));
             for reference in binding.all_references() {
                 if reference.range_start() < declaration_end {
                     let reference_syntax = reference.syntax();
@@ -177,6 +189,8 @@ impl Rule for NoInvalidUseBeforeDeclaration {
             binding_range: declaration_range,
         } = state;
         let declaration_kind_text = match declaration_kind {
+            DeclarationKind::Class => "class",
+            DeclarationKind::Enum => "enum",
             DeclarationKind::EnumMember => "enum member",
             DeclarationKind::Parameter => "parameter",
             DeclarationKind::Variable => "variable",
@@ -202,8 +216,10 @@ pub struct InvalidUseBeforeDeclaration {
     binding_range: TextRange,
 }
 
-#[derive(Debug, Copy, Clone)]
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
 pub enum DeclarationKind {
+    Class,
+    Enum,
     EnumMember,
     Parameter,
     Variable,
@@ -220,9 +236,8 @@ impl TryFrom<&AnyJsBindingDeclaration> for DeclarationKind {
             | AnyJsBindingDeclaration::JsArrayBindingPatternRestElement(_)
             | AnyJsBindingDeclaration::JsObjectBindingPatternProperty(_)
             | AnyJsBindingDeclaration::JsObjectBindingPatternRest(_)
-            | AnyJsBindingDeclaration::JsObjectBindingPatternShorthandProperty(_) => {
-                Ok(Self::Variable)
-            }
+            | AnyJsBindingDeclaration::JsObjectBindingPatternShorthandProperty(_)
+            | AnyJsBindingDeclaration::TsImportEqualsDeclaration(_) => Ok(Self::Variable),
             AnyJsBindingDeclaration::JsVariableDeclarator(declarator) => {
                 if let Some(var_decl) = declarator.declaration()
                     && let Some(var_decl_clause) = var_decl.parent::<JsVariableDeclarationClause>()
@@ -239,6 +254,21 @@ impl TryFrom<&AnyJsBindingDeclaration> for DeclarationKind {
             AnyJsBindingDeclaration::JsFormalParameter(_)
             | AnyJsBindingDeclaration::JsRestParameter(_)
             | AnyJsBindingDeclaration::TsPropertyParameter(_) => Ok(Self::Parameter),
+            AnyJsBindingDeclaration::JsClassDeclaration(_)
+            | AnyJsBindingDeclaration::JsClassExportDefaultDeclaration(_) => {
+                if value.parent::<TsDeclareStatement>().is_some() {
+                    Err(())
+                } else {
+                    Ok(Self::Class)
+                }
+            }
+            AnyJsBindingDeclaration::TsEnumDeclaration(_) => {
+                if value.parent::<TsDeclareStatement>().is_some() {
+                    Err(())
+                } else {
+                    Ok(Self::Enum)
+                }
+            }
             // Other declarations allow use before definition
             AnyJsBindingDeclaration::JsArrowFunctionExpression(_)
             | AnyJsBindingDeclaration::JsBogusParameter(_)
@@ -249,20 +279,16 @@ impl TryFrom<&AnyJsBindingDeclaration> for DeclarationKind {
             | AnyJsBindingDeclaration::JsFunctionDeclaration(_)
             | AnyJsBindingDeclaration::JsFunctionExpression(_)
             | AnyJsBindingDeclaration::TsDeclareFunctionDeclaration(_)
-            | AnyJsBindingDeclaration::JsClassDeclaration(_)
             | AnyJsBindingDeclaration::JsClassExpression(_)
             | AnyJsBindingDeclaration::TsInterfaceDeclaration(_)
             | AnyJsBindingDeclaration::TsTypeAliasDeclaration(_)
-            | AnyJsBindingDeclaration::TsEnumDeclaration(_)
             | AnyJsBindingDeclaration::TsExternalModuleDeclaration(_)
             | AnyJsBindingDeclaration::TsModuleDeclaration(_)
             | AnyJsBindingDeclaration::JsShorthandNamedImportSpecifier(_)
             | AnyJsBindingDeclaration::JsNamedImportSpecifier(_)
             | AnyJsBindingDeclaration::JsBogusNamedImportSpecifier(_)
             | AnyJsBindingDeclaration::JsDefaultImportSpecifier(_)
             | AnyJsBindingDeclaration::JsNamespaceImportSpecifier(_)
-            | AnyJsBindingDeclaration::TsImportEqualsDeclaration(_)
-            | AnyJsBindingDeclaration::JsClassExportDefaultDeclaration(_)
             | AnyJsBindingDeclaration::JsFunctionExportDefaultDeclaration(_)
             | AnyJsBindingDeclaration::TsDeclareFunctionExportDefaultDeclaration(_)
             | AnyJsBindingDeclaration::JsCatchDeclaration(_) => Err(()),

crates/biome_js_analyze/src/lint/correctness/no_invalid_use_before_declaration.rs

@@ -0,0 +1,5 @@
+
+function f() {
+	const enum1Member = E1.A;
+}
+enum E1 { A }

crates/biome_js_analyze/tests/specs/correctness/noInvalidUseBeforeDeclaration/enum.ts

@@ -0,0 +1,13 @@
+---
+source: crates/biome_js_analyze/tests/spec_tests.rs
+expression: enum.ts
+---
+# Input
+```ts
+
+function f() {
+	const enum1Member = E1.A;
+}
+enum E1 { A }
+
+```

crates/biome_js_analyze/tests/specs/correctness/noInvalidUseBeforeDeclaration/enum.ts.snap

@@ -16,3 +16,9 @@ var f = f;
 function f(a = b, b = 0) {}
 
 function g(a = a) {}
+
+const instance = new Class1();
+class Class1 {}
+
+const instance2 = new Class2();
+export default class Class2 {}

crates/biome_js_analyze/tests/specs/correctness/noInvalidUseBeforeDeclaration/invalid.js

@@ -1,7 +1,6 @@
 ---
 source: crates/biome_js_analyze/tests/spec_tests.rs
 expression: invalid.js
-snapshot_kind: text
 ---
 # Input
 ```js
@@ -24,6 +23,12 @@ function f(a = b, b = 0) {}
 
 function g(a = a) {}
 
+const instance = new Class1();
+class Class1 {}
+
+const instance2 = new Class2();
+export default class Class2 {}
+
 ```
 
 # Diagnostics
@@ -176,6 +181,7 @@ invalid.js:18:16 lint/correctness/noInvalidUseBeforeDeclaration ━━━━━
   > 18 │ function g(a = a) {}
        │                ^
     19 │ 
+    20 │ const instance = new Class1();
   
   i The parameter is declared here:
   
@@ -184,6 +190,52 @@ invalid.js:18:16 lint/correctness/noInvalidUseBeforeDeclaration ━━━━━
   > 18 │ function g(a = a) {}
        │            ^
     19 │ 
+    20 │ const instance = new Class1();
+  
+
+```
+
+```
+invalid.js:20:22 lint/correctness/noInvalidUseBeforeDeclaration ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × This class is used before its declaration.
+  
+    18 │ function g(a = a) {}
+    19 │ 
+  > 20 │ const instance = new Class1();
+       │                      ^^^^^^
+    21 │ class Class1 {}
+    22 │ 
+  
+  i The class is declared here:
+  
+    20 │ const instance = new Class1();
+  > 21 │ class Class1 {}
+       │       ^^^^^^
+    22 │ 
+    23 │ const instance2 = new Class2();
+  
+
+```
+
+```
+invalid.js:23:23 lint/correctness/noInvalidUseBeforeDeclaration ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  × This class is used before its declaration.
+  
+    21 │ class Class1 {}
+    22 │ 
+  > 23 │ const instance2 = new Class2();
+       │                       ^^^^^^
+    24 │ export default class Class2 {}
+    25 │ 
+  
+  i The class is declared here:
+  
+    23 │ const instance2 = new Class2();
+  > 24 │ export default class Class2 {}
+       │                      ^^^^^^
+    25 │ 
   
 
 ```

crates/biome_js_analyze/tests/specs/correctness/noInvalidUseBeforeDeclaration/invalid.js.snap

@@ -2,7 +2,16 @@ class C {
     constructor(readonly a = b, readonly b = 0) {}
 }
 
+const member = E.A;
 enum E {
     A = B,
     B,
 }
+
+namespace Ns {
+	const c = new Class();
+}
+class Class {}
+
+x;
+import x = require("file");