revert(linter): revert incorrect perf in rules (#10509)

Author: shulaoda

crates/oxc_linter/src/globals.rs

@@ -190,7 +190,7 @@ pub fn is_valid_aria_property(name: &str) -> bool {
 /// set of valid ARIA role definitions
 /// Reference: <https://www.w3.org/TR/wai-aria/#role_definitions>
 /// Reference: <https://github.com/A11yance/aria-query/blob/v5.3.2/src/rolesMap.js>
-pub const VALID_ARIA_ROLES: [&str; 125] = [
+pub const VALID_ARIA_ROLES: phf::Set<&'static str> = phf::phf_set![
     "alert",
     "alertdialog",
     "application",
@@ -318,7 +318,7 @@ pub const VALID_ARIA_ROLES: [&str; 125] = [
     "treeitem",
 ];
 
-pub const HTML_TAG: [&str; 149] = [
+pub const HTML_TAG: phf::Set<&'static str> = phf::phf_set![
     "a",
     "abbr",
     "acronym",

crates/oxc_linter/src/rules/eslint/array_callback_return/mod.rs

@@ -196,7 +196,7 @@ pub fn get_array_method_name<'a>(node: &AstNode<'a>, ctx: &LintContext<'a>) -> O
                 // "methods",
                 let array_method = callee.static_property_name()?;
 
-                if TARGET_METHODS.binary_search(&array_method).is_ok()
+                if TARGET_METHODS.contains(&array_method)
                     // Check that current node is parent's first argument
                     && call.arguments.len() == 1
                     && is_nth_argument(call, current_node_arg, 0)

crates/oxc_linter/src/rules/eslint/func_names.rs

@@ -388,7 +388,7 @@ const INVALID_NAMES: [&str; 9] =
     ["arguments", "async", "await", "constructor", "default", "eval", "null", "undefined", "yield"];
 
 fn is_valid_identifier_name(name: &str) -> bool {
-    INVALID_NAMES.binary_search(&name).is_err() && is_identifier_name(name)
+    !INVALID_NAMES.contains(&name) && is_identifier_name(name)
 }
 
 #[test]

crates/oxc_linter/src/rules/eslint/use_isnan.rs

@@ -155,21 +155,21 @@ fn is_nan_identifier<'a>(expr: &'a Expression<'a>) -> bool {
 }
 
 /// If callee is calling the `indexOf` or `lastIndexOf` function.
-fn is_target_callee<'a>(callee: &'a Expression<'a>) -> Option<&'static str> {
+fn is_target_callee<'a>(callee: &'a Expression) -> Option<&'a str> {
     const TARGET_METHODS: [&str; 2] = ["indexOf", "lastIndexOf"];
     let callee = callee.get_inner_expression();
 
     if let Some(expr) = callee.as_member_expression() {
-        return expr.static_property_name().and_then(|property| {
-            TARGET_METHODS.iter().find(|method| **method == property).copied()
-        });
+        return expr
+            .static_property_name()
+            .and_then(|property| TARGET_METHODS.contains(&property).then_some(property));
     }
 
     if let Expression::ChainExpression(chain) = callee {
         let expr = chain.expression.as_member_expression()?;
-        return expr.static_property_name().and_then(|property| {
-            TARGET_METHODS.iter().find(|method| **method == property).copied()
-        });
+        return expr
+            .static_property_name()
+            .and_then(|property| TARGET_METHODS.contains(&property).then_some(property));
     }
 
     None

crates/oxc_linter/src/rules/eslint/valid_typeof.rs

@@ -117,18 +117,15 @@ impl Rule for ValidTypeof {
         };
 
         if let Expression::StringLiteral(lit) = sibling {
-            if VALID_TYPES.binary_search(&lit.value.as_str()).is_err() {
+            if !VALID_TYPES.contains(&lit.value.as_str()) {
                 ctx.diagnostic(invalid_value(None, sibling.span()));
             }
             return;
         }
 
         if let Expression::TemplateLiteral(template) = sibling {
             if template.expressions.is_empty() {
-                if template
-                    .quasi()
-                    .is_some_and(|value| VALID_TYPES.binary_search(&value.as_str()).is_err())
-                {
+                if template.quasi().is_some_and(|value| !VALID_TYPES.contains(&value.as_str())) {
                     ctx.diagnostic(invalid_value(None, sibling.span()));
                 }
                 return;

crates/oxc_linter/src/rules/jsdoc/check_tag_names.rs

@@ -58,7 +58,7 @@ struct CheckTagnamesConfig {
     typed: bool,
 }
 
-const VALID_BLOCK_TAGS: [&str; 74] = [
+const VALID_BLOCK_TAGS: phf::Set<&'static str> = phf::phf_set![
     "abstract",
     "access",
     "alias",
@@ -88,12 +88,10 @@ const VALID_BLOCK_TAGS: [&str; 74] = [
     "hideconstructor",
     "ignore",
     "implements",
-    "import",
     "inheritdoc",
     "inner",
     "instance",
     "interface",
-    "internal",
     "kind",
     "lends",
     "license",
@@ -109,7 +107,6 @@ const VALID_BLOCK_TAGS: [&str; 74] = [
     "module",
     "name",
     "namespace",
-    "overload",
     "override",
     "package",
     "param",
@@ -120,12 +117,10 @@ const VALID_BLOCK_TAGS: [&str; 74] = [
     "readonly",
     "requires",
     "returns",
-    "satisfies",
     "see",
     "since",
     "static",
     "summary",
-    "template",
     "this",
     "throws",
     "todo",
@@ -135,6 +130,12 @@ const VALID_BLOCK_TAGS: [&str; 74] = [
     "variation",
     "version",
     "yields",
+    // JSDoc TS specific
+    "import",
+    "internal",
+    "overload",
+    "satisfies",
+    "template",
 ];
 
 const JSX_TAGS: [&str; 4] = ["jsx", "jsxFrag", "jsxImportSource", "jsxRuntime"];
@@ -242,7 +243,7 @@ impl Rule for CheckTagNames {
 
                 // Additional check for `typed` mode
                 if config.typed {
-                    if ALWAYS_INVALID_TAGS_IF_TYPED.binary_search(&tag_name).is_ok() {
+                    if ALWAYS_INVALID_TAGS_IF_TYPED.contains(&tag_name) {
                         ctx.diagnostic(check_tag_names_diagnostic(
                             tag.kind.span,
                             &format!("`@{tag_name}` is redundant when using a type system."),
@@ -255,17 +256,15 @@ impl Rule for CheckTagNames {
                         continue;
                     }
 
-                    if !is_ambient
-                        && OUTSIDE_AMBIENT_INVALID_TAGS_IF_TYPED.binary_search(&tag_name).is_ok()
-                    {
+                    if !is_ambient && OUTSIDE_AMBIENT_INVALID_TAGS_IF_TYPED.contains(&tag_name) {
                         ctx.diagnostic(check_tag_names_diagnostic(tag.kind.span, &format!("`@{tag_name}` is redundant outside of ambient(`declare` or `.d.ts`) contexts when using a type system.")));
                         continue;
                     }
                 }
 
                 // If invalid or unknown, report
                 let is_valid = (config.jsx_tags && JSX_TAGS.contains(&tag_name))
-                    || VALID_BLOCK_TAGS.binary_search(&tag_name).is_ok();
+                    || VALID_BLOCK_TAGS.contains(tag_name);
                 if !is_valid {
                     ctx.diagnostic(check_tag_names_diagnostic(
                         tag.kind.span,

crates/oxc_linter/src/rules/jsdoc/empty_tags.rs

@@ -101,7 +101,7 @@ impl Rule for EmptyTags {
         let settings = &ctx.settings().jsdoc;
 
         let is_empty_tag_kind = |tag_name: &str| {
-            if EMPTY_TAGS.binary_search(&tag_name).is_ok() {
+            if EMPTY_TAGS.contains(&tag_name) {
                 return true;
             }
             if !self.0.tags.is_empty() && self.0.tags.contains(&tag_name.to_string()) {

crates/oxc_linter/src/rules/jsx_a11y/aria_activedescendant_has_tabindex.rs

@@ -67,7 +67,7 @@ impl Rule for AriaActivedescendantHasTabindex {
 
         let element_type = get_element_type(ctx, jsx_opening_el);
 
-        if HTML_TAG.binary_search(&element_type.as_ref()).is_err() {
+        if !HTML_TAG.contains(element_type.as_ref()) {
             return;
         }
 

crates/oxc_linter/src/rules/jsx_a11y/aria_role.rs

@@ -146,7 +146,7 @@ impl Rule for AriaRole {
             if let Some(aria_role) = has_jsx_prop(&jsx_el.opening_element, "role") {
                 let element_type = get_element_type(ctx, &jsx_el.opening_element);
 
-                if self.ignore_non_dom && HTML_TAG.binary_search(&element_type.as_ref()).is_err() {
+                if self.ignore_non_dom && !HTML_TAG.contains(element_type.as_ref()) {
                     return;
                 }
 

crates/oxc_linter/src/rules/jsx_a11y/aria_unsupported_elements.rs

@@ -50,7 +50,7 @@ impl Rule for AriaUnsupportedElements {
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
         if let AstKind::JSXOpeningElement(jsx_el) = node.kind() {
             let el_type = get_element_type(ctx, jsx_el);
-            if RESERVED_HTML_TAG.binary_search(&el_type.as_ref()).is_ok() {
+            if RESERVED_HTML_TAG.contains(&el_type.as_ref()) {
                 for attr in &jsx_el.attributes {
                     let attr = match attr {
                         JSXAttributeItem::Attribute(attr) => attr,