perf(analyzer): reduce use of owned strings

ematipico · ematipico · commit d84b0ff75658 · 2025-05-13T10:14:58.000+01:00
diff --git a/crates/biome_analyze/src/signals.rs b/crates/biome_analyze/src/signals.rs
@@ -143,7 +143,7 @@ impl<L: Language> Default for AnalyzerActionIter<L> {
 
 impl<L: Language> From<AnalyzerAction<L>> for CodeSuggestionAdvice<MarkupBuf> {
     fn from(action: AnalyzerAction<L>) -> Self {
-        let (_, suggestion) = action.mutation.as_text_range_and_edit().unwrap_or_default();
+        let (_, suggestion) = action.mutation.to_text_range_and_edit().unwrap_or_default();
         Self {
             applicability: action.applicability,
             msg: action.message,
@@ -154,7 +154,7 @@ impl<L: Language> From<AnalyzerAction<L>> for CodeSuggestionAdvice<MarkupBuf> {
 
 impl<L: Language> From<AnalyzerAction<L>> for CodeSuggestionItem {
     fn from(action: AnalyzerAction<L>) -> Self {
-        let (range, suggestion) = action.mutation.as_text_range_and_edit().unwrap_or_default();
+        let (range, suggestion) = action.mutation.to_text_range_and_edit().unwrap_or_default();
 
         Self {
             rule_name: action.rule_name,
diff --git a/crates/biome_analyze/src/suppression_action.rs b/crates/biome_analyze/src/suppression_action.rs
@@ -16,7 +16,7 @@ pub trait SuppressionAction {
             suppression_reason,
         } = payload;
 
-        // retrieve the most suited, most left token where the diagnostics was emitted
+        // retrieve the most suited, leftest token where the diagnostics was emitted
         let original_token = self.get_token_from_offset(token_offset, diagnostic_text_range);
 
         // considering that our suppression system works via lines, we need to look for the first newline,
diff --git a/crates/biome_css_analyze/src/utils.rs b/crates/biome_css_analyze/src/utils.rs
@@ -48,8 +48,8 @@ pub fn is_css_variable(value: &str) -> bool {
 pub fn find_font_family(value: CssGenericComponentValueList) -> Vec<AnyCssValue> {
     let mut font_families: Vec<AnyCssValue> = Vec::new();
     for v in value {
-        let value = v.to_trimmed_string();
-        let lower_case_value = value.to_ascii_lowercase_cow();
+        let value = v.to_trimmed_text();
+        let lower_case_value = value.text().to_ascii_lowercase_cow();
 
         // Ignore CSS variables
         if is_css_variable(&lower_case_value) {
diff --git a/crates/biome_js_analyze/src/lint/a11y/no_positive_tabindex.rs b/crates/biome_js_analyze/src/lint/a11y/no_positive_tabindex.rs
@@ -96,29 +96,6 @@ impl NoPositiveTabindexQuery {
     }
 }
 
-impl AnyNumberLikeExpression {
-    /// Returns the value of a number-like expression; it returns the expression
-    /// text for literal expressions. However, for unary expressions, it only
-    /// returns the value for signed numeric expressions.
-    pub(crate) fn value(&self) -> Option<String> {
-        match self {
-            Self::JsStringLiteralExpression(string_literal) => {
-                return Some(string_literal.inner_string_text().ok()?.to_string());
-            }
-            Self::JsNumberLiteralExpression(number_literal) => {
-                return Some(number_literal.value_token().ok()?.to_string());
-            }
-            Self::JsUnaryExpression(unary_expression) => {
-                if unary_expression.is_signed_numeric_literal().ok()? {
-                    return Some(unary_expression.to_trimmed_string());
-                }
-            }
-        }
-
-        None
-    }
-}
-
 impl Rule for NoPositiveTabindex {
     type Query = Semantic<NoPositiveTabindexQuery>;
     type State = TextRange;
@@ -141,9 +118,24 @@ impl Rule for NoPositiveTabindex {
             TabindexProp::JsPropertyObjectMember(js_object_member) => {
                 let expression = js_object_member.value().ok()?;
                 let range = expression.range();
-                let expression_value =
-                    AnyNumberLikeExpression::cast(expression.into_syntax())?.value()?;
-                if !is_tabindex_valid(&expression_value) {
+                let expression_value = AnyNumberLikeExpression::cast(expression.into_syntax())?;
+                let is_tabindex_valid = match expression_value {
+                    AnyNumberLikeExpression::JsStringLiteralExpression(string_literal) => {
+                        is_tabindex_valid(string_literal.inner_string_text().ok()?.text())
+                    }
+                    AnyNumberLikeExpression::JsNumberLiteralExpression(number_literal) => {
+                        is_tabindex_valid(number_literal.value_token().ok()?.text())
+                    }
+                    AnyNumberLikeExpression::JsUnaryExpression(unary_expression) => {
+                        if unary_expression.is_signed_numeric_literal().ok()? {
+                            let text = unary_expression.to_trimmed_text();
+                            is_tabindex_valid(text.text())
+                        } else {
+                            return None;
+                        }
+                    }
+                };
+                if !is_tabindex_valid {
                     return Some(range);
                 }
             }
@@ -214,10 +206,24 @@ fn attribute_has_valid_tabindex(jsx_any_attribute_value: &AnyJsxAttributeValue)
         }
         AnyJsxAttributeValue::JsxExpressionAttributeValue(value) => {
             let expression = value.expression().ok()?;
-            let expression_value =
-                AnyNumberLikeExpression::cast(expression.into_syntax())?.value()?;
+            let expression_value = AnyNumberLikeExpression::cast(expression.into_syntax())?;
 
-            Some(is_tabindex_valid(&expression_value))
+            Some(match expression_value {
+                AnyNumberLikeExpression::JsStringLiteralExpression(string_literal) => {
+                    is_tabindex_valid(string_literal.inner_string_text().ok()?.text())
+                }
+                AnyNumberLikeExpression::JsNumberLiteralExpression(number_literal) => {
+                    is_tabindex_valid(number_literal.value_token().ok()?.text())
+                }
+                AnyNumberLikeExpression::JsUnaryExpression(unary_expression) => {
+                    if unary_expression.is_signed_numeric_literal().ok()? {
+                        let text = unary_expression.to_trimmed_text();
+                        is_tabindex_valid(text.text())
+                    } else {
+                        return None;
+                    }
+                }
+            })
         }
         _ => None,
     }
diff --git a/crates/biome_js_analyze/src/lint/complexity/no_useless_catch.rs b/crates/biome_js_analyze/src/lint/complexity/no_useless_catch.rs
@@ -108,9 +108,9 @@ impl Rule for NoUselessCatch {
             .argument()
             .ok()?
             .as_js_identifier_expression()?
-            .to_trimmed_string();
+            .to_trimmed_text();
 
-        if throw_ident.eq(catch_err_name) {
+        if throw_ident.text().eq(catch_err_name) {
             Some(js_throw_statement.syntax().text_trimmed_range())
         } else {
             None
diff --git a/crates/biome_js_analyze/src/lint/complexity/no_useless_fragments.rs b/crates/biome_js_analyze/src/lint/complexity/no_useless_fragments.rs
@@ -217,8 +217,8 @@ impl Rule for NoUselessFragments {
                             JsSyntaxKind::JSX_TEXT => {
                                 // We need to whitespaces and newlines from the original string.
                                 // Since in the JSX newlines aren't trivia, we require to allocate a string to trim from those characters.
-                                let original_text = child.to_trimmed_string();
-                                let child_text = original_text.trim();
+                                let original_text = child.to_trimmed_text();
+                                let child_text = original_text.text().trim();
 
                                 if (in_jsx_expr || in_js_logical_expr)
                                     && contains_html_character_references(child_text)
diff --git a/crates/biome_js_analyze/src/lint/complexity/no_useless_undefined_initialization.rs b/crates/biome_js_analyze/src/lint/complexity/no_useless_undefined_initialization.rs
@@ -96,10 +96,10 @@ impl Rule for NoUselessUndefinedInitialization {
 
             if keyword.is_undefined() {
                 let decl_range = initializer.range();
-                let Some(binding_name) = decl.id().ok().map(|id| id.to_trimmed_string()) else {
+                let Some(binding_name) = decl.id().ok().map(|id| id.to_trimmed_text()) else {
                     continue;
                 };
-                signals.push((binding_name.into(), decl_range));
+                signals.push((binding_name.text().into(), decl_range));
             }
         }
 
diff --git a/crates/biome_js_analyze/src/lint/correctness/no_constant_math_min_max_clamp.rs b/crates/biome_js_analyze/src/lint/correctness/no_constant_math_min_max_clamp.rs
@@ -96,7 +96,7 @@ impl Rule for NoConstantMathMinMaxClamp {
             ).detail(
                 state.0.range(),
                 markup! {
-                    "It always evaluates to "<Emphasis>{state.0.to_trimmed_string()}</Emphasis>"."
+                    "It always evaluates to "<Emphasis>{state.0.to_trimmed_text().text()}</Emphasis>"."
                 }
             )
         )
@@ -111,7 +111,7 @@ impl Rule for NoConstantMathMinMaxClamp {
         Some(JsRuleAction::new(
             ctx.metadata().action_category(ctx.category(), ctx.group()),
             ctx.metadata().applicability(),
-            markup! {"Swap "<Emphasis>{state.0.to_trimmed_string()}</Emphasis>" with "<Emphasis>{state.1.to_trimmed_string()}</Emphasis>"."}
+            markup! {"Swap "<Emphasis>{state.0.to_trimmed_text().text()}</Emphasis>" with "<Emphasis>{state.1.to_trimmed_text().text()}</Emphasis>"."}
             .to_owned(),
             mutation,
         ))
diff --git a/crates/biome_js_analyze/src/lint/correctness/use_hook_at_top_level.rs b/crates/biome_js_analyze/src/lint/correctness/use_hook_at_top_level.rs
@@ -91,22 +91,22 @@ impl AnyJsFunctionOrMethod {
         false
     }
 
-    fn name(&self) -> Option<String> {
+    fn name(&self) -> Option<Text> {
         match self {
             Self::AnyJsFunction(function) => function
                 .binding()
                 .as_ref()
-                .map(AnyJsBinding::to_trimmed_string),
+                .map(AnyJsBinding::to_trimmed_text),
             Self::JsMethodClassMember(method) => method
                 .name()
                 .ok()
                 .as_ref()
-                .map(AnyJsClassMemberName::to_trimmed_string),
+                .map(AnyJsClassMemberName::to_trimmed_text),
             Self::JsMethodObjectMember(method) => method
                 .name()
                 .ok()
                 .as_ref()
-                .map(AnyJsObjectMemberName::to_trimmed_string),
+                .map(AnyJsObjectMemberName::to_trimmed_text),
         }
     }
 }
diff --git a/crates/biome_js_analyze/src/lint/correctness/use_is_nan.rs b/crates/biome_js_analyze/src/lint/correctness/use_is_nan.rs
@@ -237,7 +237,10 @@ fn create_is_nan_expression(nan: AnyJsExpression) -> Option<AnyJsExpression> {
                 .object()
                 .ok()?
                 .as_js_static_member_expression()
-                .is_some_and(|y| y.member().is_ok_and(|z| z.to_trimmed_string() == "Number"));
+                .is_some_and(|y| {
+                    y.member()
+                        .is_ok_and(|z| z.to_trimmed_text().text() == "Number")
+                });
 
             if !reference.is_global_this() && !reference.has_name("window")
                 || number_identifier_exists
diff --git a/crates/biome_js_analyze/src/lint/nursery/use_explicit_type.rs b/crates/biome_js_analyze/src/lint/nursery/use_explicit_type.rs
@@ -572,7 +572,7 @@ fn is_direct_const_assertion_in_arrow_functions(func: &AnyJsFunction) -> bool {
         return false;
     };
 
-    ts_ref.to_trimmed_string() == "const"
+    ts_ref.to_trimmed_text().text() == "const"
 }
 
 /// Checks if a function is allowed within specific expression contexts.
diff --git a/crates/biome_js_analyze/src/lint/performance/no_delete.rs b/crates/biome_js_analyze/src/lint/performance/no_delete.rs
@@ -94,7 +94,7 @@ impl Rule for NoDelete {
                 {
                     let name = static_expression.member().ok()?;
                     let name = name.as_js_name()?;
-                    if name.to_trimmed_string() == "dataset" {
+                    if name.to_trimmed_text().text() == "dataset" {
                         return None;
                     }
                 }
diff --git a/crates/biome_js_analyze/src/lint/style/use_component_export_only_modules.rs b/crates/biome_js_analyze/src/lint/style/use_component_export_only_modules.rs
@@ -210,7 +210,7 @@ impl Rule for UseComponentExportOnlyModules {
         }
 
         let local_component_ids = local_declaration_ids.iter().filter_map(|id| {
-            if Case::identify(&id.to_trimmed_string(), false) == Case::Pascal {
+            if Case::identify(&id.to_trimmed_text().text(), false) == Case::Pascal {
                 Some(id.range())
             } else {
                 None
@@ -294,7 +294,7 @@ fn is_exported_react_component(any_exported_item: &ExportedItem) -> bool {
         any_exported_item.exported.clone()
     {
         if let Ok(AnyJsExpression::JsIdentifierExpression(fn_name)) = f.callee() {
-            if !REACT_HOOKS.contains(&fn_name.to_trimmed_string().as_str()) {
+            if !REACT_HOOKS.contains(&fn_name.to_trimmed_text().text()) {
                 return false;
             }
             let Ok(args) = f.arguments() else {
@@ -316,13 +316,13 @@ fn is_exported_react_component(any_exported_item: &ExportedItem) -> bool {
             let Ok(arg_name) = arg.name() else {
                 return false;
             };
-            return Case::identify(&arg_name.to_trimmed_string(), false) == Case::Pascal;
+            return Case::identify(&arg_name.to_trimmed_text().text(), false) == Case::Pascal;
         }
     }
     let Some(exported_item_id) = any_exported_item.identifier.clone() else {
         return false;
     };
-    Case::identify(&exported_item_id.to_trimmed_string(), false) == Case::Pascal
+    Case::identify(&exported_item_id.to_trimmed_text().text(), false) == Case::Pascal
         && match any_exported_item.exported.clone() {
             Some(exported) => !matches!(exported, AnyJsExported::TsEnumDeclaration(_)),
             None => true,
diff --git a/crates/biome_js_analyze/src/lint/style/use_number_namespace.rs b/crates/biome_js_analyze/src/lint/style/use_number_namespace.rs
@@ -168,12 +168,12 @@ impl Rule for UseNumberNamespace {
                 )
             }
             AnyJsExpression::JsStaticMemberExpression(expression) => {
-                let name = expression.member().ok()?.to_trimmed_string();
+                let name = expression.member().ok()?.to_trimmed_text();
 
-                if !GLOBAL_NUMBER_PROPERTIES.contains(&name.as_str()) {
+                if !GLOBAL_NUMBER_PROPERTIES.contains(&name.text()) {
                     return None;
                 }
-                let (old_node, replacement) = match name.as_str() {
+                let (old_node, replacement) = match name.text() {
                     "Infinity" => {
                         if let Some(parent) = node.parent::<JsUnaryExpression>() {
                             match parent.operator().ok()? {
@@ -191,7 +191,7 @@ impl Rule for UseNumberNamespace {
                             (node.clone(), "POSITIVE_INFINITY")
                         }
                     }
-                    _ => (node.clone(), name.as_str()),
+                    _ => (node.clone(), name.text()),
                 };
                 (
                     old_node,
diff --git a/crates/biome_js_analyze/src/lint/style/use_shorthand_assign.rs b/crates/biome_js_analyze/src/lint/style/use_shorthand_assign.rs
@@ -82,11 +82,9 @@ impl Rule for UseShorthandAssign {
         let right = node.right().ok()?;
 
         let left_var_name = match left.as_any_js_assignment()? {
-            AnyJsAssignment::JsComputedMemberAssignment(assignment) => {
-                assignment.to_trimmed_string()
-            }
-            AnyJsAssignment::JsIdentifierAssignment(assignment) => assignment.to_trimmed_string(),
-            AnyJsAssignment::JsStaticMemberAssignment(assignment) => assignment.to_trimmed_string(),
+            AnyJsAssignment::JsComputedMemberAssignment(assignment) => assignment.to_trimmed_text(),
+            AnyJsAssignment::JsIdentifierAssignment(assignment) => assignment.to_trimmed_text(),
+            AnyJsAssignment::JsStaticMemberAssignment(assignment) => assignment.to_trimmed_text(),
             _ => return None,
         };
 
diff --git a/crates/biome_js_analyze/src/lint/suspicious/no_document_cookie.rs b/crates/biome_js_analyze/src/lint/suspicious/no_document_cookie.rs
@@ -101,7 +101,7 @@ fn is_cookie(assignment: &AnyJsAssignment) -> Option<()> {
         AnyJsAssignment::JsStaticMemberAssignment(static_assignment) => {
             let property = static_assignment.member().ok()?;
 
-            if property.to_trimmed_string() != COOKIE {
+            if property.to_trimmed_text().text() != COOKIE {
                 return None;
             };
         }
diff --git a/crates/biome_js_analyze/src/lint/suspicious/no_duplicate_test_hooks.rs b/crates/biome_js_analyze/src/lint/suspicious/no_duplicate_test_hooks.rs
@@ -130,7 +130,7 @@ impl Visitor for DuplicateHooksVisitor {
                     else if let AnyJsExpression::JsCallExpression(call_expression) = callee {
                         if let Ok(callee) = call_expression.callee() {
                             if matches!(
-                                callee.to_trimmed_string().as_str(),
+                                callee.to_trimmed_text().text(),
                                 "describe.each" | "describe.only.each" | "fdescribe.each"
                             ) {
                                 self.stack.push(HooksContext::default());
diff --git a/crates/biome_js_analyze/src/lint/suspicious/no_exports_in_test.rs b/crates/biome_js_analyze/src/lint/suspicious/no_exports_in_test.rs
@@ -67,25 +67,25 @@ impl MaybeExport {
                                 AnyJsMemberAssignment::JsComputedMemberAssignment(_) => false,
                                 AnyJsMemberAssignment::JsStaticMemberAssignment(static_member) => {
                                     // module.exports = {}
-                                    let indent_text = ident.to_trimmed_string();
+                                    let indent_text = ident.to_trimmed_text();
                                     let member_text = static_member
                                         .member()
-                                        .map(|member| member.to_trimmed_string());
-                                    indent_text == "module"
-                                        && member_text
-                                            .is_ok_and(|member_text| member_text == "exports")
+                                        .map(|member| member.to_trimmed_text());
+                                    indent_text.text() == "module"
+                                        && member_text.is_ok_and(|member_text| {
+                                            member_text.text() == "exports"
+                                        })
                                 }
                             },
                             AnyJsExpression::JsStaticMemberExpression(member_expr) => {
                                 // modules.exports.foo = {}, module.exports[foo] = {}
-                                let object_text = member_expr
-                                    .object()
-                                    .map(|object| object.to_trimmed_string());
-                                let member_text = member_expr
-                                    .member()
-                                    .map(|member| member.to_trimmed_string());
-                                object_text.is_ok_and(|text| text == "module")
-                                    && member_text.is_ok_and(|member_text| member_text == "exports")
+                                let object_text =
+                                    member_expr.object().map(|object| object.to_trimmed_text());
+                                let member_text =
+                                    member_expr.member().map(|member| member.to_trimmed_text());
+                                object_text.is_ok_and(|text| text.text() == "module")
+                                    && member_text
+                                        .is_ok_and(|member_text| member_text.text() == "exports")
                             }
                             _ => false,
                         })
diff --git a/crates/biome_js_analyze/src/lint/suspicious/no_misrefactored_shorthand_assign.rs b/crates/biome_js_analyze/src/lint/suspicious/no_misrefactored_shorthand_assign.rs
@@ -96,7 +96,7 @@ impl Rule for NoMisrefactoredShorthandAssign {
 
         let left = node.left().ok()?;
         let left = left.as_any_js_assignment()?;
-        let left_text = left.to_trimmed_string();
+        let left_text = left.to_trimmed_text();
 
         let variable_position_in_expression =
             find_variable_position(&binary_expression, &left_text)?;
diff --git a/crates/biome_js_analyze/src/lint/suspicious/no_react_specific_props.rs b/crates/biome_js_analyze/src/lint/suspicious/no_react_specific_props.rs
@@ -60,9 +60,9 @@ impl Rule for NoReactSpecificProps {
         let attribute = ctx.query();
         let name = attribute.name().ok()?;
         let range = name.range();
-        let name = name.to_trimmed_string();
+        let name = name.to_trimmed_text();
 
-        if REACT_SPECIFIC_JSX_PROPS.contains(&name.as_str()) {
+        if REACT_SPECIFIC_JSX_PROPS.contains(&name.text()) {
             let replacement = get_replacement_for_react_prop(&name)?;
             Some((range, replacement))
         } else {
diff --git a/crates/biome_js_analyze/src/lint/suspicious/no_then_property.rs b/crates/biome_js_analyze/src/lint/suspicious/no_then_property.rs
diff --git a/crates/biome_rowan/src/ast/batch.rs b/crates/biome_rowan/src/ast/batch.rs
diff --git a/crates/biome_service/src/file_handlers/javascript.rs b/crates/biome_service/src/file_handlers/javascript.rs
diff --git a/crates/biome_test_utils/src/lib.rs b/crates/biome_test_utils/src/lib.rs

Original file line number	Diff line number	Diff line change
`@@ -96,10 +96,10 @@ impl Rule for NoUselessUndefinedInitialization {`
`96`	`96`
`97`	`97`	`if keyword.is_undefined() {`
`98`	`98`	`let decl_range = initializer.range();`
`99`		`- let Some(binding_name) = decl.id().ok().map(\|id\| id.to_trimmed_string()) else {`
	`99`	`+ let Some(binding_name) = decl.id().ok().map(\|id\| id.to_trimmed_text()) else {`
`100`	`100`	`continue;`
`101`	`101`	`};`
`102`		`- signals.push((binding_name.into(), decl_range));`
	`102`	`+ signals.push((binding_name.text().into(), decl_range));`
`103`	`103`	`}`
`104`	`104`	`}`
`105`	`105`
Original file line number	Diff line number	Diff line change
`@@ -96,7 +96,7 @@ impl Rule for NoConstantMathMinMaxClamp {`
`96`	`96`	`).detail(`
`97`	`97`	`state.0.range(),`
`98`	`98`	`markup! {`
`99`		`- "It always evaluates to "<Emphasis>{state.0.to_trimmed_string()}</Emphasis>"."`
	`99`	`+ "It always evaluates to "<Emphasis>{state.0.to_trimmed_text().text()}</Emphasis>"."`
`100`	`100`	`}`
`101`	`101`	`)`
`102`	`102`	`)`
`@@ -111,7 +111,7 @@ impl Rule for NoConstantMathMinMaxClamp {`
`111`	`111`	`Some(JsRuleAction::new(`
`112`	`112`	`ctx.metadata().action_category(ctx.category(), ctx.group()),`
`113`	`113`	`ctx.metadata().applicability(),`
`114`		`- markup! {"Swap "<Emphasis>{state.0.to_trimmed_string()}</Emphasis>" with "<Emphasis>{state.1.to_trimmed_string()}</Emphasis>"."}`
	`114`	`+ markup! {"Swap "<Emphasis>{state.0.to_trimmed_text().text()}</Emphasis>" with "<Emphasis>{state.1.to_trimmed_text().text()}</Emphasis>"."}`
`115`	`115`	`.to_owned(),`
`116`	`116`	`mutation,`
`117`	`117`	`))`