feat(lint/noRestrictedImports): add rule

crates/biome_diagnostics_categories/src/categories.rs

@@ -112,6 +112,7 @@ define_categories! {
     "lint/nursery/noMisleadingCharacterClass": "https://biomejs.dev/linter/rules/no-misleading-character-class",
     "lint/nursery/noNodejsModules": "https://biomejs.dev/linter/rules/no-nodejs-modules",
     "lint/nursery/noReExportAll": "https://biomejs.dev/linter/rules/no-re-export-all",
+    "lint/nursery/noRestrictedImports": "https://biomejs.dev/linter/rules/no-restricted-imports",
     "lint/nursery/noSkippedTests": "https://biomejs.dev/linter/rules/no-skipped-tests",
     "lint/nursery/noThenProperty": "https://biomejs.dev/linter/rules/no-then-property",
     "lint/nursery/noTypeOnlyImportAttributes": "https://biomejs.dev/linter/rules/no-type-only-import-attributes",

crates/biome_js_analyze/src/analyzers/nursery/no_restricted_imports.rs

@@ -0,0 +1,72 @@
+use biome_analyze::context::RuleContext;
+use biome_analyze::{declare_rule, Ast, Rule, RuleDiagnostic, RuleSource};
+use biome_console::markup;
+use biome_deserialize_macros::Deserializable;
+use biome_js_syntax::inner_string_text;
+use biome_rowan::TextRange;
+use rustc_hash::FxHashMap;
+use serde::{Deserialize, Serialize};
+
+use super::use_nodejs_import_protocol::AnyJsImportLike;
+
+declare_rule! {
+    /// Disallow specified modules when loaded by import or require.
+    ///
+    /// ## Options
+    ///
+    /// ```json
+    /// {
+    ///     "noRestrictedImports": {
+    ///         "options": {
+    ///             "paths": {
+    ///                 "lodash": "Using lodash is not encouraged",
+    ///                 "underscore": "Using underscore is not encouraged"
+    ///             }
+    ///         }
+    ///     }
+    /// }
+    /// ```
+    pub(crate) NoRestrictedImports {
+        version: "next",
+        name: "noRestrictedImports",
+        source: RuleSource::Eslint("no-restricted-imports"),
+        recommended: false,
+    }
+}
+
+/// Options for the rule `noRestrictedImports`.
+#[derive(Clone, Debug, Default, Deserialize, Deserializable, Eq, PartialEq, Serialize)]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+pub struct RestrictedImportsOptions {
+    /// A list of names that should trigger the rule
+    #[serde(skip_serializing_if = "FxHashMap::is_empty")]
+    paths: FxHashMap<String, String>,
+}
+
+impl Rule for NoRestrictedImports {
+    type Query = Ast<AnyJsImportLike>;
+    type State = (TextRange, String);
+    type Signals = Option<Self::State>;
+    type Options = RestrictedImportsOptions;
+
+    fn run(ctx: &RuleContext<Self>) -> Self::Signals {
+        let module_name = ctx.query().module_name_token()?;
+        let inner_text = inner_string_text(&module_name);
+
+        ctx.options()
+            .paths
+            .get(inner_text.text())
+            .map(|message| (module_name.text_trimmed_range(), message.to_string()))
+    }
+
+    fn diagnostic(_ctx: &RuleContext<Self>, (span, text): &Self::State) -> Option<RuleDiagnostic> {
+        Some(RuleDiagnostic::new(
+            rule_category!(),
+            *span,
+            markup! {
+                {text}
+            },
+        ))
+    }
+}

crates/biome_js_analyze/src/options.rs

@@ -1,5 +1,6 @@
 //! This module contains the rules that have options
 
+use crate::analyzers::nursery::no_restricted_imports::RestrictedImportsOptions;
 use crate::analyzers::nursery::use_consistent_array_type::ConsistentArrayTypeOptions;
 use crate::analyzers::nursery::use_filenaming_convention::FilenamingConventionOptions;
 use crate::semantic_analyzers::correctness::use_exhaustive_dependencies::HooksOptions;
@@ -37,6 +38,8 @@ pub enum PossibleOptions {
     NamingConvention(NamingConventionOptions),
     /// Options for `noRestrictedGlobals` rule
     RestrictedGlobals(RestrictedGlobalsOptions),
+    /// Options for `noRestrictedImports` rule
+    RestrictedImports(RestrictedImportsOptions),
     /// Options for `useValidAriaRole` rule
     ValidAriaRole(ValidAriaRoleOptions),
     /// Options for `useSortedClasses` rule
@@ -101,6 +104,13 @@ impl PossibleOptions {
                 };
                 RuleOptions::new(options)
             }
+            "noRestrictedImports" => {
+                let options = match self {
+                    PossibleOptions::RestrictedImports(options) => options.clone(),
+                    _ => RestrictedImportsOptions::default(),
+                };
+                RuleOptions::new(options)
+            }
             "useValidAriaRole" => {
                 let options = match self {
                     PossibleOptions::ValidAriaRole(options) => options.clone(),
@@ -133,6 +143,8 @@ impl Deserializable for PossibleOptions {
             }
             "noRestrictedGlobals" => Deserializable::deserialize(value, "options", diagnostics)
                 .map(Self::RestrictedGlobals),
+            "noRestrictedImports" => Deserializable::deserialize(value, "options", diagnostics)
+                .map(Self::RestrictedImports),
             "useConsistentArrayType" => Deserializable::deserialize(value, "options", diagnostics)
                 .map(Self::ConsistentArrayType),
             "useExhaustiveDependencies" => {

crates/biome_js_analyze/tests/specs/nursery/noRestrictedImports/invalid.js

@@ -0,0 +1,2 @@
+import eslint from 'eslint';
+const l = require('lodash');

crates/biome_js_analyze/tests/specs/nursery/noRestrictedImports/invalid.js.snap

@@ -0,0 +1,39 @@
+---
+source: crates/biome_js_analyze/tests/spec_tests.rs
+expression: invalid.js
+---
+# Input
+```jsx
+import eslint from 'eslint';
+const l = require('lodash');
+
+```
+
+# Diagnostics
+```
+invalid.js:1:20 lint/nursery/noRestrictedImports ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  ! Importing Eslint is forbidden
+
+  > 1 │ import eslint from 'eslint';
+      │                    ^^^^^^^^
+    2 │ const l = require('lodash');
+    3 │ 
+
+
+```
+
+```
+invalid.js:2:19 lint/nursery/noRestrictedImports ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  ! It's not recommended to use lodash
+
+    1 │ import eslint from 'eslint';
+  > 2 │ const l = require('lodash');
+      │                   ^^^^^^^^
+    3 │ 
+
+
+```
+
+

crates/biome_js_analyze/tests/specs/nursery/noRestrictedImports/invalid.options.json

@@ -0,0 +1,19 @@
+{
+	"$schema": "../../../../../../packages/@biomejs/biome/configuration_schema.json",
+	"linter": {
+		"enabled": true,
+		"rules": {
+			"nursery": {
+				"noRestrictedImports": {
+					"level": "error",
+					"options": {
+						"paths": {
+							"eslint": "Importing Eslint is forbidden",
+							"lodash": "It's not recommended to use lodash"
+						}
+					}
+				}
+			}
+		}
+	}
+}

crates/biome_js_analyze/tests/specs/nursery/noRestrictedImports/valid.js

@@ -0,0 +1 @@
+const path = require('lodash');

crates/biome_js_analyze/tests/specs/nursery/noRestrictedImports/valid.js.snap

@@ -0,0 +1,11 @@
+---
+source: crates/biome_js_analyze/tests/spec_tests.rs
+expression: valid.js
+---
+# Input
+```jsx
+const path = require('lodash');
+
+```
+
+

crates/biome_js_analyze/tests/specs/nursery/noRestrictedImports/valid.options.json

@@ -0,0 +1,15 @@
+{
+	"$schema": "../../../../../../packages/@biomejs/biome/configuration_schema.json",
+	"linter": {
+		"rules": {
+			"nursery": {
+				"noRestrictedImports": {
+					"level": "error",
+					"options": {
+						"paths": {}
+					}
+				}
+			}
+		}
+	}
+}