refactor(linter): use one instance of rope per file (#11552)

Sysix · Sysix · commit 9b475ad05b75 · 2025-06-08T12:39:11.000Z
diff --git a/crates/oxc_linter/src/service/offset_to_position.rs b/crates/oxc_linter/src/service/offset_to_position.rs
@@ -46,15 +46,15 @@ impl SpanPosition {
     }
 }
 
-pub fn offset_to_position(offset: u32, source_text: &str) -> SpanPosition {
-    // TODO(perf): share a single instance of `Rope`
-    let rope = Rope::from_str(source_text);
-    let (line, column) = get_line_column(&rope, offset, source_text);
+pub fn offset_to_position(rope: &Rope, offset: u32, source_text: &str) -> SpanPosition {
+    let (line, column) = get_line_column(rope, offset, source_text);
     SpanPosition::new(line, column)
 }
 
 #[cfg(test)]
 mod test {
+    use oxc_data_structures::rope::Rope;
+
     use super::offset_to_position;
 
     #[test]
@@ -89,11 +89,11 @@ mod test {
     #[test]
     #[should_panic(expected = "out of bounds")]
     fn out_of_bounds() {
-        offset_to_position(100, "foo");
+        offset_to_position(&Rope::from_str("foo"), 100, "foo");
     }
 
     fn assert_position(source: &str, offset: u32, expected: (u32, u32)) {
-        let position = offset_to_position(offset, source);
+        let position = offset_to_position(&Rope::from_str(source), offset, source);
         assert_eq!(position.line, expected.0);
         assert_eq!(position.character, expected.1);
     }
diff --git a/crates/oxc_linter/src/service/runtime.rs b/crates/oxc_linter/src/service/runtime.rs
@@ -554,6 +554,7 @@ impl<'l> Runtime<'l> {
         allocator: &'a oxc_allocator::Allocator,
     ) -> Vec<MessageWithPosition<'a>> {
         use oxc_allocator::CloneIn;
+        use oxc_data_structures::rope::Rope;
         use std::sync::Mutex;
 
         use crate::{
@@ -564,11 +565,12 @@ impl<'l> Runtime<'l> {
 
         fn fix_to_fix_with_position<'a>(
             fix: &Fix<'a>,
+            rope: &Rope,
             offset: u32,
             source_text: &str,
         ) -> FixWithPosition<'a> {
-            let start_position = offset_to_position(offset + fix.span.start, source_text);
-            let end_position = offset_to_position(offset + fix.span.end, source_text);
+            let start_position = offset_to_position(rope, offset + fix.span.start, source_text);
+            let end_position = offset_to_position(rope, offset + fix.span.end, source_text);
             FixWithPosition {
                 content: fix.content.clone(),
                 span: SpanPositionMessage::new(start_position, end_position)
@@ -583,6 +585,8 @@ impl<'l> Runtime<'l> {
                 module.content.with_dependent_mut(|owner, dependent| {
                     assert_eq!(module.section_module_records.len(), dependent.len());
 
+                    let rope = &Rope::from_str(&owner.source_text);
+
                     for (record_result, section) in
                         module.section_module_records.into_iter().zip(dependent.drain(..))
                     {
@@ -610,10 +614,12 @@ impl<'l> Runtime<'l> {
                                                 .map(|labeled_span| {
                                                     let offset = labeled_span.offset() as u32;
                                                     let start_position = offset_to_position(
+                                                        rope,
                                                         offset + section.source.start,
                                                         &owner.source_text,
                                                     );
                                                     let end_position = offset_to_position(
+                                                        rope,
                                                         offset
                                                             + section.source.start
                                                             + labeled_span.len() as u32,
@@ -647,6 +653,7 @@ impl<'l> Runtime<'l> {
                                                     PossibleFixesWithPosition::Single(
                                                         fix_to_fix_with_position(
                                                             fix,
+                                                            rope,
                                                             section.source.start,
                                                             &owner.source_text,
                                                         ),
@@ -659,6 +666,7 @@ impl<'l> Runtime<'l> {
                                                             .map(|fix| {
                                                                 fix_to_fix_with_position(
                                                                     fix,
+                                                                    rope,
                                                                     section.source.start,
                                                                     &owner.source_text,
                                                                 )

Original file line number	Diff line number	Diff line change
`@@ -46,15 +46,15 @@ impl SpanPosition {`
`46`	`46`	`}`
`47`	`47`	`}`
`48`	`48`
`49`		`-pub fn offset_to_position(offset: u32, source_text: &str) -> SpanPosition {`
`50`		- // TODO(perf): share a single instance of `Rope`
`51`		`- let rope = Rope::from_str(source_text);`
`52`		`- let (line, column) = get_line_column(&rope, offset, source_text);`
	`49`	`+pub fn offset_to_position(rope: &Rope, offset: u32, source_text: &str) -> SpanPosition {`
	`50`	`+ let (line, column) = get_line_column(rope, offset, source_text);`
`53`	`51`	`SpanPosition::new(line, column)`
`54`	`52`	`}`
`55`	`53`
`56`	`54`	`#[cfg(test)]`
`57`	`55`	`mod test {`
	`56`	`+ use oxc_data_structures::rope::Rope;`
	`57`	`+`
`58`	`58`	`use super::offset_to_position;`
`59`	`59`
`60`	`60`	`#[test]`
`@@ -89,11 +89,11 @@ mod test {`
`89`	`89`	`#[test]`
`90`	`90`	`#[should_panic(expected = "out of bounds")]`
`91`	`91`	`fn out_of_bounds() {`
`92`		`- offset_to_position(100, "foo");`
	`92`	`+ offset_to_position(&Rope::from_str("foo"), 100, "foo");`
`93`	`93`	`}`
`94`	`94`
`95`	`95`	`fn assert_position(source: &str, offset: u32, expected: (u32, u32)) {`
`96`		`- let position = offset_to_position(offset, source);`
	`96`	`+ let position = offset_to_position(&Rope::from_str(source), offset, source);`
`97`	`97`	`assert_eq!(position.line, expected.0);`
`98`	`98`	`assert_eq!(position.character, expected.1);`
`99`	`99`	`}`