fix(linter): can't disable no-nested-ternary rule anymore

apps/oxlint/fixtures/typescript_eslint/eslintrc.json

@@ -3,7 +3,6 @@
   "plugins": ["@typescript-eslint"],
   "rules": {
     "no-loss-of-precision": "off",
-    "@typescript-eslint/no-loss-of-precision": "error",
     "@typescript-eslint/no-namespace": "warn"
   }
 }

apps/oxlint/src/lint.rs

@@ -599,7 +599,7 @@ mod test {
         ];
         let result = test(args);
         assert_eq!(result.number_of_files, 1);
-        assert_eq!(result.number_of_warnings, 3);
+        assert_eq!(result.number_of_warnings, 2);
         assert_eq!(result.number_of_errors, 0);
     }
 

crates/oxc_linter/src/config/rules.rs

@@ -110,28 +110,32 @@ impl OxlintRules {
                     }
                 }
                 _ => {
-                    // For overlapping rule names, use the "error" one
-                    // "no-loss-of-precision": "off",
-                    // "@typescript-eslint/no-loss-of-precision": "error"
-                    if let Some(rule_config) =
-                        rule_configs.iter().find(|r| r.severity.is_warn_deny())
-                    {
-                        let config = rule_config.config.clone().unwrap_or_default();
-
-                        if let Some(rule) = rules_for_override.iter().find(|r| r.name() == *name) {
-                            rules_to_replace
-                                .push(RuleWithSeverity::new(rule.read_json(config), rule.severity));
-                        }
-                        // If the given rule is not found in the rule list (for example, if all rules are disabled),
-                        // then look it up in the entire rules list and add it.
-                        else if let Some(rule) = all_rules.iter().find(|r| r.name() == *name) {
-                            rules_to_replace.push(RuleWithSeverity::new(
-                                rule.read_json(config),
-                                rule_config.severity,
-                            ));
-                        }
-                    } else if rule_configs.iter().all(|r| r.severity.is_allow()) {
-                        if let Some(rule) = rules_for_override.iter().find(|r| r.name() == *name) {
+                    let rules = rules_for_override
+                        .iter()
+                        .filter(|r| r.name() == *name)
+                        .map(|r| (r.plugin_name(), r))
+                        .collect::<FxHashMap<_, _>>();
+
+                    for rule_config in rule_configs {
+                        if rule_config.severity.is_warn_deny() {
+                            let config = rule_config.config.clone().unwrap_or_default();
+                            if let Some(rule) = rules.get(&rule_config.plugin_name.as_str()) {
+                                rules_to_replace.push(RuleWithSeverity::new(
+                                    rule.read_json(config),
+                                    rule.severity,
+                                ));
+                            }
+                            // If the given rule is not found in the rule list (for example, if all rules are disabled),
+                            // then look it up in the entire rules list and add it.
+                            else if let Some(rule) = all_rules.iter().find(|r| {
+                                r.name() == *name && r.plugin_name() == rule_config.plugin_name
+                            }) {
+                                rules_to_replace.push(RuleWithSeverity::new(
+                                    rule.read_json(config),
+                                    rule_config.severity,
+                                ));
+                            }
+                        } else if let Some(&rule) = rules.get(&rule_config.plugin_name.as_str()) {
                             rules_to_remove.push(rule.clone());
                         }
                     }
@@ -465,9 +469,8 @@ mod test {
     fn test_override_plugin_prefix_duplicates() {
         let configs = [
             // FIXME: this should be valid
-            // json!({ "@typescript-eslint/no-unused-vars": "error" }),
-            json!({ "no-unused-vars": "off", "typescript/no-unused-vars": "error" }),
-            json!({ "no-unused-vars": "off", "@typescript-eslint/no-unused-vars": "error" }),
+            // json!({ "@unicorn-eslint/no-nested-ternary": "error" }),
+            json!({ "no-nested-ternary": "off", "unicorn/no-nested-ternary": "error" }),
         ];
 
         for config in &configs {
@@ -476,21 +479,21 @@ mod test {
 
             assert_eq!(rules.len(), 1, "{config:?}");
             let rule = rules.iter().next().unwrap();
-            assert_eq!(rule.name(), "no-unused-vars", "{config:?}");
+            assert_eq!(rule.name(), "no-nested-ternary", "{config:?}");
             assert_eq!(rule.severity, AllowWarnDeny::Deny, "{config:?}");
         }
 
         for config in &configs {
             let mut rules = RuleSet::default();
             rules.insert(RuleWithSeverity {
-                rule: RuleEnum::EslintNoUnusedVars(Default::default()),
+                rule: RuleEnum::UnicornNoNestedTernary(Default::default()),
                 severity: AllowWarnDeny::Warn,
             });
             r#override(&mut rules, config);
 
             assert_eq!(rules.len(), 1, "{config:?}");
             let rule = rules.iter().next().unwrap();
-            assert_eq!(rule.name(), "no-unused-vars", "{config:?}");
+            assert_eq!(rule.name(), "no-nested-ternary", "{config:?}");
             assert_eq!(rule.severity, AllowWarnDeny::Warn, "{config:?}");
         }
     }