feat(linter/no_restricted_imports): add the no_restricted_imports rules

[Spoutnik97]

add first test cases related to the 'paths' config

Note that the test cases and configuration format is not the same as the original ESLint rule.
What is the oxc team strategy to develop such a rule? Is it ok to adapt the config format ?

---

I started a discussion here : #7534 (comment)
I copy/paste the content here. Maybe it is more relevant?

I am working to implement this no-restricted-imports rule.
I have several problems:

How to handle multiple format configuration in rust?
The eslint config can be: "fs", ["fs"], or {paths: [{name: "fs"}]}. But Rust needs only one type. I don't know how to do this in rust.

Is it ok to cover only the {paths: [{name: "fs"}]} case ?

How to parse this config with the from_configuration method?
Here is what I have done:

   fn from_configuration(value: serde_json::Value) -> Self {
        let mut paths = Vec::new();
        let mut patterns = Vec::new();

        if let Some(obj) = value.as_object() {
            // Handle paths array
            if let Some(paths_value) = obj.get("paths") {
                if let Some(paths_array) = paths_value.as_array() {
                    for path_value in paths_array {
                        if let Ok(path) = serde_json::from_value(path_value.clone()) {
                            paths.push(path);
                        }
                    }
                }
            }

            // Handle patterns array
            if let Some(patterns_value) = obj.get("patterns") {
                if let Some(patterns_array) = patterns_value.as_array() {
                    for pattern_value in patterns_array {
                        if let Ok(pattern) = serde_json::from_value(pattern_value.clone()) {
                            patterns.push(pattern);
                        }
                    }
                }
            }
        }

        Self { paths, patterns }
    }

But here is my result:

[RestrictedPath { name: "foo", import_names: None, message: None }]

-------- rule config --------
{
  "paths": [
    {
      "name": "foo",
      "importNames": [
        "AllowedObject"
      ]
    }
  ]
}

Note the "None" values

[graphite-app]

Your org has enabled the Graphite merge queue for merging into main

Add the label “0-merge” to the PR and Graphite will automatically add it to the merge queue when it’s ready to merge. Or use the label “hotfix” to add to the merge queue as a hot fix.

You must have a Graphite account and log in to Graphite in order to use the merge queue. Sign up using this link.

[codspeed-hq]

CodSpeed Performance Report

Merging #7629 will not alter performance

_{Comparing Spoutnik97:linter/no_restricted_imports (c9a1134) with main (8883968)}

Summary

✅ 29 untouched benchmarks

[camc314]

The eslint config can be: "fs", ["fs"], or {paths: [{name: "fs"}]}. But Rust needs only one type. I don't know how to do this in rust.

probably want to normalize them?

e.g. match on the json value type

match value { 
Value::Array => { ... } 
Value::String => { ... } 

and normalize it into what you want it to be

[Spoutnik97]

@camc314 thanks, I'll try it to accept other configs.

I am still fighting with the test which failed :

---- size_asserts stdout ----
thread 'size_asserts' panicked at crates/oxc_linter/src/lib.rs:60:5:
assertion failed: std::mem::size_of::<RuleEnum>() == 16


failures:
    size_asserts

Whereas I tried to improve performances by replacing Vec to a Box in the struct, I still have the error, and I don't know how to improve it. Could you give me some help about it please?

[Spoutnik97]

Ok I found a solution. Tell me if it looks correct