perf(js_analyze): use Box<str>/Box<[_]> to reduce memory usage

crates/biome_analyze/src/lib.rs

@@ -424,7 +424,7 @@ where
                     suppression
                         .suppressed_instances
                         .iter()
-                        .any(|(filter, v)| *filter == entry.rule && v == value)
+                        .any(|(filter, v)| *filter == entry.rule && v == value.as_ref())
                 })
             });
 

crates/biome_analyze/src/matcher.rs

@@ -138,7 +138,7 @@ pub struct SignalEntry<'phase, L: Language> {
     /// Unique identifier for the rule that emitted this signal
     pub rule: RuleKey,
     /// Optional rule instances being suppressed
-    pub instances: Vec<String>,
+    pub instances: Box<[Box<str>]>,
     /// Text range in the document this signal covers
     pub text_range: TextRange,
 }

crates/biome_analyze/src/rule.rs

@@ -800,8 +800,8 @@ pub trait Rule: RuleMeta + Sized {
     /// *Note: For `noUnusedVariables` the above may not seem very useful (and
     /// indeed it's not implemented), but for rules such as
     /// `useExhaustiveDependencies` this is actually desirable.*
-    fn instances_for_signal(_signal: &Self::State) -> Vec<String> {
-        Vec::new()
+    fn instances_for_signal(_signal: &Self::State) -> Box<[Box<str>]> {
+        Vec::new().into_boxed_slice()
     }
 
     /// Used by the analyzer to associate a range of source text to a signal in

crates/biome_cli/src/execute/migrate/eslint_eslint.rs

@@ -537,7 +537,7 @@ impl Deserializable for Rules {
 #[derive(Debug, Default, Deserializable)]
 pub struct NoConsoleOptions {
     /// Allowed calls on the console object.
-    pub allow: Vec<String>,
+    pub allow: Box<[Box<str>]>,
 }
 impl From<NoConsoleOptions> for biome_js_analyze::lint::suspicious::no_console::NoConsoleOptions {
     fn from(val: NoConsoleOptions) -> Self {

crates/biome_cli/src/execute/migrate/eslint_jsxa11y.rs

@@ -7,7 +7,7 @@ use biome_js_analyze::lint::a11y::use_valid_aria_role;
 
 #[derive(Debug, Default, Deserializable)]
 pub(crate) struct AriaRoleOptions {
-    allowed_invalid_roles: Vec<String>,
+    allowed_invalid_roles: Box<[Box<str>]>,
     #[deserializable(rename = "ignoreNonDOM")]
     ignore_non_dom: bool,
 }

crates/biome_cli/src/execute/migrate/eslint_to_biome.rs

@@ -224,13 +224,16 @@ fn migrate_eslint_rule(
         eslint_eslint::Rule::NoRestrictedGlobals(conf) => {
             if migrate_eslint_any_rule(rules, &name, conf.severity(), opts, results) {
                 let severity = conf.severity();
-                let globals = conf.into_vec().into_iter().map(|g| g.into_name());
+                let globals = conf
+                    .into_vec()
+                    .into_iter()
+                    .map(|g| g.into_name().into_boxed_str());
                 let group = rules.style.get_or_insert_with(Default::default);
                 group.no_restricted_globals = Some(biome_config::RuleConfiguration::WithOptions(
                     biome_config::RuleWithOptions {
                         level: severity.into(),
                         options: Box::new(no_restricted_globals::RestrictedGlobalsOptions {
-                            denied_globals: globals.collect(),
+                            denied_globals: globals.collect::<Vec<_>>().into_boxed_slice(),
                         }),
                     },
                 ));

crates/biome_cli/src/execute/migrate/eslint_typescript.rs

@@ -160,7 +160,7 @@ impl From<NamingConventionOptions> for use_naming_convention::NamingConventionOp
         use_naming_convention::NamingConventionOptions {
             strict_case: false,
             require_ascii: false,
-            conventions,
+            conventions: conventions.into_boxed_slice(),
             enum_member_case: use_naming_convention::Format::default(),
         }
     }

crates/biome_css_analyze/src/lint/correctness/no_invalid_position_at_import_rule.rs

@@ -38,10 +38,10 @@ declare_lint_rule! {
 impl Rule for NoInvalidPositionAtImportRule {
     type Query = Ast<CssRuleList>;
     type State = TextRange;
-    type Signals = Vec<Self::State>;
+    type Signals = Box<[Self::State]>;
     type Options = ();
 
-    fn run(ctx: &RuleContext<Self>) -> Vec<Self::State> {
+    fn run(ctx: &RuleContext<Self>) -> Self::Signals {
         let node = ctx.query();
         let mut is_invalid_position = false;
         let mut invalid_import_list = Vec::new();
@@ -73,7 +73,7 @@ impl Rule for NoInvalidPositionAtImportRule {
                 is_invalid_position = true;
             }
         }
-        invalid_import_list
+        invalid_import_list.into_boxed_slice()
     }
 
     fn diagnostic(_: &RuleContext<Self>, state: &Self::State) -> Option<RuleDiagnostic> {

crates/biome_css_analyze/src/lint/nursery/no_descending_specificity.rs

@@ -163,7 +163,7 @@ fn find_descending_selector(
 impl Rule for NoDescendingSpecificity {
     type Query = Semantic<CssRoot>;
     type State = DescendingSelector;
-    type Signals = Vec<Self::State>;
+    type Signals = Box<[Self::State]>;
     type Options = ();
 
     fn run(ctx: &RuleContext<Self>) -> Self::Signals {
@@ -180,8 +180,7 @@ impl Rule for NoDescendingSpecificity {
                 &mut descending_selectors,
             );
         }
-
-        descending_selectors
+        descending_selectors.into_boxed_slice()
     }
 
     fn diagnostic(_: &RuleContext<Self>, node: &Self::State) -> Option<RuleDiagnostic> {

crates/biome_css_analyze/src/lint/nursery/no_irregular_whitespace.rs

@@ -51,12 +51,12 @@ declare_lint_rule! {
 impl Rule for NoIrregularWhitespace {
     type Query = Ast<AnyCssRule>;
     type State = TextRange;
-    type Signals = Vec<Self::State>;
+    type Signals = Box<[Self::State]>;
     type Options = ();
 
     fn run(ctx: &RuleContext<Self>) -> Self::Signals {
         let node = ctx.query();
-        get_irregular_whitespace(node)
+        get_irregular_whitespace(node).into_boxed_slice()
     }
 
     fn diagnostic(_: &RuleContext<Self>, range: &Self::State) -> Option<RuleDiagnostic> {

crates/biome_deserialize/src/impls.rs

@@ -498,6 +498,16 @@ impl Deserializable for String {
     }
 }
 
+impl Deserializable for Box<str> {
+    fn deserialize(
+        value: &impl DeserializableValue,
+        name: &str,
+        diagnostics: &mut Vec<DeserializationDiagnostic>,
+    ) -> Option<Self> {
+        String::deserialize(value, name, diagnostics).map(|s| s.into_boxed_str())
+    }
+}
+
 impl Deserializable for PathBuf {
     fn deserialize(
         value: &impl DeserializableValue,
@@ -556,6 +566,16 @@ impl<T: Deserializable> Deserializable for Vec<T> {
     }
 }
 
+impl<T: Deserializable> Deserializable for Box<[T]> {
+    fn deserialize(
+        value: &impl DeserializableValue,
+        name: &str,
+        diagnostics: &mut Vec<DeserializationDiagnostic>,
+    ) -> Option<Self> {
+        Deserializable::deserialize(value, name, diagnostics).map(Vec::into_boxed_slice)
+    }
+}
+
 #[cfg(feature = "smallvec")]
 impl<T: Deserializable, const L: usize> Deserializable for smallvec::SmallVec<[T; L]> {
     fn deserialize(

crates/biome_deserialize/src/validator.rs

@@ -50,8 +50,20 @@ impl IsEmpty for String {
     }
 }
 
+impl IsEmpty for Box<str> {
+    fn is_empty(&self) -> bool {
+        str::is_empty(self)
+    }
+}
+
 impl<T> IsEmpty for Vec<T> {
     fn is_empty(&self) -> bool {
         Vec::is_empty(self)
     }
 }
+
+impl<T> IsEmpty for Box<[T]> {
+    fn is_empty(&self) -> bool {
+        <[_]>::is_empty(self)
+    }
+}

crates/biome_graphql_analyze/src/lint/nursery/no_duplicated_fields.rs

@@ -49,10 +49,10 @@ declare_lint_rule! {
 impl Rule for NoDuplicatedFields {
     type Query = Ast<AnyGraphqlOperationDefinition>;
     type State = DuplicatedField;
-    type Signals = Vec<Self::State>;
+    type Signals = Box<[Self::State]>;
     type Options = ();
 
-    fn run(ctx: &RuleContext<Self>) -> Vec<Self::State> {
+    fn run(ctx: &RuleContext<Self>) -> Self::Signals {
         let operation = ctx.query();
         let mut duplicated_fields = vec![];
         match operation {
@@ -68,8 +68,7 @@ impl Rule for NoDuplicatedFields {
                 duplicated_fields.extend(check_duplicated_selection_fields(selection_set))
             }
         };
-
-        duplicated_fields
+        duplicated_fields.into_boxed_slice()
     }
 
     fn diagnostic(_ctx: &RuleContext<Self>, state: &Self::State) -> Option<RuleDiagnostic> {

crates/biome_js_analyze/src/assists/source/sort_jsx_props.rs

@@ -52,7 +52,7 @@ declare_source_rule! {
 impl Rule for SortJsxProps {
     type Query = Ast<JsxAttributeList>;
     type State = PropGroup;
-    type Signals = Vec<Self::State>;
+    type Signals = Box<[Self::State]>;
     type Options = ();
 
     fn run(ctx: &RuleContext<Self>) -> Self::Signals {
@@ -72,7 +72,7 @@ impl Rule for SortJsxProps {
             }
         }
         prop_groups.push(current_prop_group);
-        prop_groups
+        prop_groups.into_boxed_slice()
     }
 
     fn action(ctx: &RuleContext<Self>, state: &Self::State) -> Option<JsRuleAction> {

crates/biome_js_analyze/src/lint/a11y/no_label_without_control.rs

@@ -155,11 +155,11 @@ impl Rule for NoLabelWithoutControl {
 #[serde(rename_all = "camelCase", deny_unknown_fields, default)]
 pub struct NoLabelWithoutControlOptions {
     /// Array of component names that should be considered the same as an `input` element.
-    pub input_components: Vec<String>,
+    pub input_components: Box<[Box<str>]>,
     /// Array of attributes that should be treated as the `label` accessible text content.
-    pub label_attributes: Vec<String>,
+    pub label_attributes: Box<[Box<str>]>,
     /// Array of component names that should be considered the same as a `label` element.
-    pub label_components: Vec<String>,
+    pub label_components: Box<[Box<str>]>,
 }
 
 impl NoLabelWithoutControlOptions {
@@ -175,7 +175,7 @@ impl NoLabelWithoutControlOptions {
             && !self
                 .label_attributes
                 .iter()
-                .any(|name| name == attribute_name)
+                .any(|name| name.as_ref() == attribute_name)
         {
             return false;
         }
@@ -245,7 +245,7 @@ impl NoLabelWithoutControlOptions {
                             || self
                                 .input_components
                                 .iter()
-                                .any(|name| name == element_name)
+                                .any(|name| name.as_ref() == element_name)
                         {
                             return true;
                         }
@@ -260,7 +260,7 @@ impl NoLabelWithoutControlOptions {
     fn has_element_name(&self, element_name: &str) -> bool {
         self.label_components
             .iter()
-            .any(|label_component_name| label_component_name == element_name)
+            .any(|label_component_name| label_component_name.as_ref() == element_name)
     }
 }
 

crates/biome_js_analyze/src/lint/a11y/use_aria_props_for_role.rs

@@ -49,7 +49,7 @@ declare_lint_rule! {
 
 #[derive(Default, Debug)]
 pub struct UseAriaPropsForRoleState {
-    missing_aria_props: Vec<String>,
+    missing_aria_props: Box<[String]>,
     attribute: Option<(JsxAttribute, String)>,
 }
 
@@ -121,7 +121,7 @@ impl Rule for UseAriaPropsForRole {
             if !missing_aria_props.is_empty() {
                 return Some(UseAriaPropsForRoleState {
                     attribute: Some((role_attribute, name.text().to_string())),
-                    missing_aria_props,
+                    missing_aria_props: missing_aria_props.into_boxed_slice(),
                 });
             }
         }

crates/biome_js_analyze/src/lint/a11y/use_valid_aria_props.rs

@@ -37,7 +37,7 @@ declare_lint_rule! {
 impl Rule for UseValidAriaProps {
     type Query = Aria<AnyJsxElement>;
     type State = JsxAttribute;
-    type Signals = Vec<Self::State>;
+    type Signals = Box<[Self::State]>;
     type Options = ();
 
     fn run(ctx: &RuleContext<Self>) -> Self::Signals {
@@ -64,11 +64,11 @@ impl Rule for UseValidAriaProps {
                     }
                 })
                 .collect();
-
             attributes
         } else {
-            vec![]
+            Vec::new()
         }
+        .into_boxed_slice()
     }
 
     fn diagnostic(ctx: &RuleContext<Self>, attribute: &Self::State) -> Option<RuleDiagnostic> {

crates/biome_js_analyze/src/lint/a11y/use_valid_aria_role.rs

@@ -78,7 +78,7 @@ declare_lint_rule! {
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
 #[serde(rename_all = "camelCase", deny_unknown_fields, default)]
 pub struct ValidAriaRoleOptions {
-    pub allow_invalid_roles: Vec<String>,
+    pub allow_invalid_roles: Box<[Box<str>]>,
     pub ignore_non_dom: bool,
 }
 
@@ -107,7 +107,10 @@ impl Rule for UseValidAriaRole {
 
         let is_valid = role_attribute_value.all(|val| {
             let role_data = aria_roles.get_role(val);
-            allowed_invalid_roles.contains(&val.to_string()) || role_data.is_some()
+            allowed_invalid_roles
+                .iter()
+                .any(|role| role.as_ref() == val)
+                || role_data.is_some()
         });
 
         if is_valid {

crates/biome_js_analyze/src/lint/complexity/no_useless_fragments.rs

@@ -13,9 +13,7 @@ use biome_js_syntax::{
     JsParenthesizedExpression, JsSyntaxKind, JsxChildList, JsxElement, JsxExpressionAttributeValue,
     JsxExpressionChild, JsxFragment, JsxTagExpression, JsxText, T,
 };
-use biome_rowan::{
-    declare_node_union, AstNode, AstNodeList, BatchMutation, BatchMutationExt, SyntaxNodeText,
-};
+use biome_rowan::{declare_node_union, AstNode, AstNodeList, BatchMutation, BatchMutationExt};
 
 declare_lint_rule! {
     /// Disallow unnecessary fragments

crates/biome_js_analyze/src/lint/complexity/no_useless_switch_case.rs

@@ -71,7 +71,7 @@ declare_lint_rule! {
 impl Rule for NoUselessSwitchCase {
     type Query = Ast<JsDefaultClause>;
     type State = JsCaseClause;
-    type Signals = Vec<Self::State>;
+    type Signals = Box<[Self::State]>;
     type Options = ();
 
     fn run(ctx: &RuleContext<Self>) -> Self::Signals {
@@ -107,10 +107,11 @@ impl Rule for NoUselessSwitchCase {
                     .filter_map(JsCaseClause::cast)
                     .find(|case| !case.consequent().is_empty()),
             )
-            .collect()
+            .collect::<Vec<_>>()
         } else {
-            it.collect()
+            it.collect::<Vec<_>>()
         }
+        .into_boxed_slice()
     }
 
     fn diagnostic(ctx: &RuleContext<Self>, useless_case: &Self::State) -> Option<RuleDiagnostic> {