From 80266d85c9e192ebf91ef0e2c687b6f769d0b8b2 Mon Sep 17 00:00:00 2001
From: DonIsaac <22823424+DonIsaac@users.noreply.github.com>
Date: Thu, 10 Oct 2024 19:21:50 +0000
Subject: [PATCH] feat(linter)!: support plugins in oxlint config files (#6088)
> Closes #5046
This PR migrates the linter crate and oxlint app to use the new `LinterBuilder` API. This PR has the following effects:
1. `plugins` in oxlint config files are now supported
2. irons out weirdness when using CLI args and config files together. CLI args are now always applied on top of config file settings, overriding them.
# Breaking Changes
Before, config files would override rules set in CLI arguments. For example, running this command:
```sh
oxlint -A correctness -c oxlintrc.json
```
With this config file
```jsonc
// oxlintrc.json
{
"rules": {
"no-const-assign": "error"
}
}
```
Would result in a single rule, `no-const-assign` being turned on at an error level with all other rules disabled (i.e. set to "allow").
Now, **CLI arguments will override config files**. That same command with the same config file will result with **all rules being disabled**.
## Details
For a more in-depth explanation, assume we are running the below command using the `oxlintrc.json` file above:
```sh
oxlint -A all -W correctness -A all -W suspicious -c oxlintrc.json
```
### Before
> Note: GitHub doesn't seem to like deeply nested lists. Apologies for the formatting.
Here was the config resolution process _before_ this PR:
Before Steps
1. Start with a default set of filters (["correctness", "warn"]) if no filters were passed to the CLI. Since some were, the filter list starts out empty.
2. Apply each filter taken from the CLI from left to right. When a filter allows a rule or category, it clears the configured set of rules. So applying those filters looks like this
a. start with an empty list `[]`
b. `("all", "allow")` -> `[]`
c. `("correctness", "warn")` -> `[ ]`
d. `("all", "allow")` -> `[]`
e. `("suspicious", "warn")` -> `[ ]`. This is the final rule set for this step
3. Apply overrides from `oxlintrc.json`. This is where things get a little funky, as mentioned in point 2 of what this PR does. At this point, all rules in the rules list are only from the CLI.
a. If a rule is only set in the CLI and is not present in the config file, there's no effect
b. If a rule is in the config file but not the CLI, it gets inserted into the list.
c. If a rule is already in the list and in the config file
i. If the rule is only present once (e.g. `"no-loss-of-precision": "error"`), unconditionally override whatever was in the CLI with what was set in the config file
ii. If the rule is present twice (e.g. `"no-loss-of-precision": "off", "@typescript-eslint/no-loss-of-precision": "error"`),
a. if all rules in the config file are set to `allow`, then turn the rule off
b. If one of them is `warn` or `deny`, then update the currently-set rule's config object, but _leave its severity alone_.
So, for our example, the final rule set would be `[, no-const-assign: "error"]`
After Steps
1. Start with the default rule set, which is all correctness rules for all enabled plugins (`[]`)
2. Apply configuration from `oxlintrc.json` _first_.
a. If the rule is warn/deny exists in the list already, update its severity and config object. If it's not in the list, add it.
b. If the rule is set to allow, remove it from the list.
The list is now `[, no-const-assign: "error"]`.
3. Apply each filter taken from the CLI from left to right. This works the same way as before. So, after they're applied, the list is now `[]`
for LintPlugins {
impl<'de> Deserialize<'de> for LintPlugins {
fn deserialize>(deserializer: D) -> Result {
- Vec::<&str>::deserialize(deserializer).map(|vec| vec.into_iter().collect())
+ struct LintPluginsVisitor;
+ impl<'de> de::Visitor<'de> for LintPluginsVisitor {
+ type Value = LintPlugins;
+
+ fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+ write!(formatter, "a list of plugin names")
+ }
+
+ fn visit_str(self, value: &str) -> Result {
+ Ok(LintPlugins::from(value))
+ }
+
+ fn visit_string(self, v: String) -> Result
+ where
+ E: de::Error,
+ {
+ Ok(LintPlugins::from(v.as_str()))
+ }
+
+ fn visit_seq(self, mut seq: A) -> Result
+ where
+ A: de::SeqAccess<'de>,
+ {
+ let mut plugins = LintPlugins::default();
+ while let Some(plugin) = seq.next_element::<&str>()? {
+ plugins |= plugin.into();
+ }
+ Ok(plugins)
+ }
+ }
+
+ deserializer.deserialize_any(LintPluginsVisitor)
}
}
diff --git a/tasks/benchmark/benches/linter.rs b/tasks/benchmark/benches/linter.rs
index 8cb9709474e74..19089074e7aa1 100644
--- a/tasks/benchmark/benches/linter.rs
+++ b/tasks/benchmark/benches/linter.rs
@@ -2,7 +2,7 @@ use std::{env, path::Path, rc::Rc};
use oxc_allocator::Allocator;
use oxc_benchmark::{criterion_group, criterion_main, BenchmarkId, Criterion};
-use oxc_linter::{AllowWarnDeny, FixKind, LintFilter, Linter, OxlintOptions};
+use oxc_linter::{FixKind, LinterBuilder};
use oxc_parser::Parser;
use oxc_semantic::SemanticBuilder;
use oxc_span::SourceType;
@@ -34,22 +34,7 @@ fn bench_linter(criterion: &mut Criterion) {
.with_cfg(true)
.build_module_record(Path::new(""), program)
.build(program);
- let filter = vec![
- LintFilter::new(AllowWarnDeny::Deny, "all").unwrap(),
- LintFilter::new(AllowWarnDeny::Deny, "nursery").unwrap(),
- ];
- let lint_options = OxlintOptions::default()
- .with_filter(filter)
- .with_fix(FixKind::All)
- .with_import_plugin(true)
- .with_jsdoc_plugin(true)
- .with_jest_plugin(true)
- .with_jsx_a11y_plugin(true)
- .with_nextjs_plugin(true)
- .with_react_perf_plugin(true)
- .with_vitest_plugin(true)
- .with_node_plugin(true);
- let linter = Linter::from_options(lint_options).unwrap();
+ let linter = LinterBuilder::all().with_fix(FixKind::All).build();
let semantic = Rc::new(semantic_ret.semantic);
b.iter(|| linter.run(Path::new(std::ffi::OsStr::new("")), Rc::clone(&semantic)));
},