refactor(span): all methods take owned Span

overlookmotel · overlookmotel · commit fc19033286a7 · 2025-01-06T16:11:42.000Z
diff --git a/crates/oxc_linter/src/fixer/fix.rs b/crates/oxc_linter/src/fixer/fix.rs
@@ -350,7 +350,7 @@ impl GetSpan for CompositeFix<'_> {
         match self {
             CompositeFix::Single(fix) => fix.span,
             CompositeFix::Multiple(fixes) => {
-                fixes.iter().map(|fix| fix.span).reduce(|a, b| a.merge(&b)).unwrap_or(SPAN)
+                fixes.iter().map(|fix| fix.span).reduce(Span::merge).unwrap_or(SPAN)
             }
             CompositeFix::None => SPAN,
         }
diff --git a/crates/oxc_linter/src/rules/eslint/no_console.rs b/crates/oxc_linter/src/rules/eslint/no_console.rs
@@ -88,7 +88,7 @@ impl Rule for NoConsole {
             && !self.allow.iter().any(|s| mem.static_property_name().is_some_and(|f| f == s))
         {
             if let Some((mem_span, _)) = mem.static_property_info() {
-                let diagnostic_span = ident.span().merge(&mem_span);
+                let diagnostic_span = ident.span().merge(mem_span);
                 ctx.diagnostic_with_suggestion(no_console_diagnostic(diagnostic_span), |fixer| {
                     remove_console(fixer, ctx, node)
                 });
diff --git a/crates/oxc_linter/src/rules/eslint/sort_imports.rs b/crates/oxc_linter/src/rules/eslint/sort_imports.rs
@@ -306,7 +306,7 @@ impl SortImports {
 
         if is_fixable {
             // Safe to index because we know that `specifiers` is at least 2 element long
-            let specifiers_span = specifiers[0].span.merge(&specifiers[specifiers.len() - 1].span);
+            let specifiers_span = specifiers[0].span.merge(specifiers[specifiers.len() - 1].span);
             ctx.diagnostic_with_fix(
                 sort_members_alphabetically_diagnostic(unsorted_name, unsorted_span),
                 |fixer| {
diff --git a/crates/oxc_linter/src/rules/jsdoc/require_property.rs b/crates/oxc_linter/src/rules/jsdoc/require_property.rs
@@ -91,7 +91,7 @@ impl Rule for RequireProperty {
 
                     let r#type = type_part.parsed();
                     if r#type == "Object" || r#type == "object" || r#type == "PlainObject" {
-                        should_report = Some(tag.kind.span.merge(&type_part.span));
+                        should_report = Some(tag.kind.span.merge(type_part.span));
                     }
                 }
 
diff --git a/crates/oxc_linter/src/rules/react/no_render_return_value.rs b/crates/oxc_linter/src/rules/react/no_render_return_value.rs
@@ -68,7 +68,7 @@ impl Rule for NoRenderReturnValue {
                                 | AstKind::AssignmentExpression(_)
                         ) {
                             ctx.diagnostic(no_render_return_value_diagnostic(
-                                ident.span.merge(&property_span),
+                                ident.span.merge(property_span),
                             ));
                         }
 
@@ -79,7 +79,7 @@ impl Rule for NoRenderReturnValue {
                             {
                                 if e.expression {
                                     ctx.diagnostic(no_render_return_value_diagnostic(
-                                        ident.span.merge(&property_span),
+                                        ident.span.merge(property_span),
                                     ));
                                 }
                             }
diff --git a/crates/oxc_linter/src/rules/typescript/prefer_for_of.rs b/crates/oxc_linter/src/rules/typescript/prefer_for_of.rs
@@ -227,7 +227,7 @@ impl Rule for PreferForOf {
             return;
         }
 
-        let span = for_stmt_init.span.merge(&test_expr.span).merge(&update_expr.span());
+        let span = for_stmt_init.span.merge(test_expr.span).merge(update_expr.span());
         ctx.diagnostic(prefer_for_of_diagnostic(span));
     }
 }
diff --git a/crates/oxc_linter/src/rules/unicorn/prefer_query_selector.rs b/crates/oxc_linter/src/rules/unicorn/prefer_query_selector.rs
@@ -135,7 +135,7 @@ impl Rule for PreferQuerySelector {
                         }
                         _ => literal_value.to_string(),
                     };
-                    let span = property_span.merge(&argument_expr.span());
+                    let span = property_span.merge(argument_expr.span());
                     fixer.replace(
                         span,
                         format!("{preferred_selector}({quotes_symbol}{argument}{quotes_symbol}"),
diff --git a/crates/oxc_parser/src/modifiers.rs b/crates/oxc_parser/src/modifiers.rs
@@ -215,8 +215,7 @@ impl GetSpan for Modifiers<'_> {
         debug_assert!(!modifiers.is_empty());
         // SAFETY: One of Modifier's invariants is that Some(modifiers) always
         // contains a non-empty Vec; otherwise it must be `None`.
-
-        unsafe { modifiers.iter().map(|m| m.span).reduce(|a, b| a.merge(&b)).unwrap_unchecked() }
+        unsafe { modifiers.iter().map(|m| m.span).reduce(Span::merge).unwrap_unchecked() }
     }
 }
 
diff --git a/crates/oxc_regular_expression/src/parser/pattern_parser/pattern_parser_impl.rs b/crates/oxc_regular_expression/src/parser/pattern_parser/pattern_parser_impl.rs
@@ -882,7 +882,7 @@ impl<'a> PatternParser<'a> {
 
                 body.push(ast::CharacterClassContents::CharacterClassRange(Box::new_in(
                     ast::CharacterClassRange {
-                        span: from.span.merge(&to.span),
+                        span: from.span.merge(to.span),
                         min: **from,
                         max: **to,
                     },
@@ -1236,15 +1236,15 @@ impl<'a> PatternParser<'a> {
                     // It is a Syntax Error if the CharacterValue of the first ClassSetCharacter is strictly greater than the CharacterValue of the second ClassSetCharacter.
                     if class_set_character_to.value < class_set_character.value {
                         return Err(diagnostics::character_class_range_out_of_order(
-                            class_set_character.span.merge(&class_set_character_to.span),
+                            class_set_character.span.merge(class_set_character_to.span),
                             "class set",
                         ));
                     }
 
                     return Ok(Some(ast::CharacterClassContents::CharacterClassRange(
                         Box::new_in(
                             ast::CharacterClassRange {
-                                span: class_set_character.span.merge(&class_set_character_to.span),
+                                span: class_set_character.span.merge(class_set_character_to.span),
                                 min: class_set_character,
                                 max: class_set_character_to,
                             },
diff --git a/crates/oxc_semantic/src/jsdoc/parser/jsdoc_tag.rs b/crates/oxc_semantic/src/jsdoc/parser/jsdoc_tag.rs
@@ -40,7 +40,7 @@ pub struct JSDocTag<'a> {
 
 impl<'a> JSDocTag<'a> {
     pub fn new(kind: JSDocTagKindPart<'a>, body_content: &'a str, body_span: Span) -> JSDocTag<'a> {
-        Self { span: kind.span.merge(&body_span), kind, body_raw: body_content, body_span }
+        Self { span: kind.span.merge(body_span), kind, body_raw: body_content, body_span }
     }
 
     /// Use for various simple tags like `@access`, `@deprecated`, ...etc.
diff --git a/crates/oxc_span/src/span/mod.rs b/crates/oxc_span/src/span/mod.rs
@@ -77,7 +77,7 @@ impl Span {
     /// assert_eq!(Span::new(0, 5).size(), 5);
     /// assert_eq!(Span::new(5, 10).size(), 5);
     /// ```
-    pub const fn size(&self) -> u32 {
+    pub const fn size(self) -> u32 {
         debug_assert!(self.start <= self.end);
         self.end - self.start
     }
@@ -92,7 +92,7 @@ impl Span {
     /// assert!(Span::new(5, 5).is_empty());
     /// assert!(!Span::new(0, 5).is_empty());
     /// ```
-    pub const fn is_empty(&self) -> bool {
+    pub const fn is_empty(self) -> bool {
         debug_assert!(self.start <= self.end);
         self.start == self.end
     }
@@ -108,7 +108,7 @@ impl Span {
     /// assert!(!Span::new(0, 5).is_unspanned());
     /// assert!(!Span::new(5, 5).is_unspanned());
     /// ```
-    pub const fn is_unspanned(&self) -> bool {
+    pub const fn is_unspanned(self) -> bool {
         self.start == SPAN.start && self.end == SPAN.end
     }
 
@@ -148,7 +148,7 @@ impl Span {
     /// assert_eq!(merged_span, Span::new(0, 8));
     /// ```
     #[must_use]
-    pub fn merge(&self, other: &Self) -> Self {
+    pub fn merge(self, other: Self) -> Self {
         Self::new(self.start.min(other.start), self.end.max(other.end))
     }
 
@@ -324,7 +324,7 @@ impl Span {
     /// let name = name_span.source_text(source);
     /// assert_eq!(name_span.size(), name.len() as u32);
     /// ```
-    pub fn source_text<'a>(&self, source_text: &'a str) -> &'a str {
+    pub fn source_text(self, source_text: &str) -> &str {
         &source_text[self.start as usize..self.end as usize]
     }
 

Original file line number	Diff line number	Diff line change
`@@ -350,7 +350,7 @@ impl GetSpan for CompositeFix<'_> {`
`350`	`350`	`match self {`
`351`	`351`	`CompositeFix::Single(fix) => fix.span,`
`352`	`352`	`CompositeFix::Multiple(fixes) => {`
`353`		`- fixes.iter().map(\|fix\| fix.span).reduce(\|a, b\| a.merge(&b)).unwrap_or(SPAN)`
	`353`	`+ fixes.iter().map(\|fix\| fix.span).reduce(Span::merge).unwrap_or(SPAN)`
`354`	`354`	`}`
`355`	`355`	`CompositeFix::None => SPAN,`
`356`	`356`	`}`
Original file line number	Diff line number	Diff line change
`@@ -88,7 +88,7 @@ impl Rule for NoConsole {`
`88`	`88`	`&& !self.allow.iter().any(\|s\| mem.static_property_name().is_some_and(\|f\| f == s))`
`89`	`89`	`{`
`90`	`90`	`if let Some((mem_span, _)) = mem.static_property_info() {`
`91`		`- let diagnostic_span = ident.span().merge(&mem_span);`
	`91`	`+ let diagnostic_span = ident.span().merge(mem_span);`
`92`	`92`	`ctx.diagnostic_with_suggestion(no_console_diagnostic(diagnostic_span), \|fixer\| {`
`93`	`93`	`remove_console(fixer, ctx, node)`
`94`	`94`	`});`
Original file line number	Diff line number	Diff line change
`@@ -91,7 +91,7 @@ impl Rule for RequireProperty {`
`91`	`91`
`92`	`92`	`let r#type = type_part.parsed();`
`93`	`93`	`if r#type == "Object" \|\| r#type == "object" \|\| r#type == "PlainObject" {`
`94`		`- should_report = Some(tag.kind.span.merge(&type_part.span));`
	`94`	`+ should_report = Some(tag.kind.span.merge(type_part.span));`
`95`	`95`	`}`
`96`	`96`	`}`
`97`	`97`
Original file line number	Diff line number	Diff line change
`@@ -68,7 +68,7 @@ impl Rule for NoRenderReturnValue {`
`68`	`68`	`\| AstKind::AssignmentExpression(_)`
`69`	`69`	`) {`
`70`	`70`	`ctx.diagnostic(no_render_return_value_diagnostic(`
`71`		`- ident.span.merge(&property_span),`
	`71`	`+ ident.span.merge(property_span),`
`72`	`72`	`));`
`73`	`73`	`}`
`74`	`74`
`@@ -79,7 +79,7 @@ impl Rule for NoRenderReturnValue {`
`79`	`79`	`{`
`80`	`80`	`if e.expression {`
`81`	`81`	`ctx.diagnostic(no_render_return_value_diagnostic(`
`82`		`- ident.span.merge(&property_span),`
	`82`	`+ ident.span.merge(property_span),`
`83`	`83`	`));`
`84`	`84`	`}`
`85`	`85`	`}`
Original file line number	Diff line number	Diff line change
`@@ -227,7 +227,7 @@ impl Rule for PreferForOf {`
`227`	`227`	`return;`
`228`	`228`	`}`
`229`	`229`
`230`		`- let span = for_stmt_init.span.merge(&test_expr.span).merge(&update_expr.span());`
	`230`	`+ let span = for_stmt_init.span.merge(test_expr.span).merge(update_expr.span());`
`231`	`231`	`ctx.diagnostic(prefer_for_of_diagnostic(span));`
`232`	`232`	`}`
`233`	`233`	`}`
Original file line number	Diff line number	Diff line change
`@@ -135,7 +135,7 @@ impl Rule for PreferQuerySelector {`
`135`	`135`	`}`
`136`	`136`	`_ => literal_value.to_string(),`
`137`	`137`	`};`
`138`		`- let span = property_span.merge(&argument_expr.span());`
	`138`	`+ let span = property_span.merge(argument_expr.span());`
`139`	`139`	`fixer.replace(`
`140`	`140`	`span,`
`141`	`141`	`format!("{preferred_selector}({quotes_symbol}{argument}{quotes_symbol}"),`
Original file line number	Diff line number	Diff line change
`@@ -215,8 +215,7 @@ impl GetSpan for Modifiers<'_> {`
`215`	`215`	`debug_assert!(!modifiers.is_empty());`
`216`	`216`	`// SAFETY: One of Modifier's invariants is that Some(modifiers) always`
`217`	`217`	// contains a non-empty Vec; otherwise it must be `None`.
`218`		`-`
`219`		`- unsafe { modifiers.iter().map(\|m\| m.span).reduce(\|a, b\| a.merge(&b)).unwrap_unchecked() }`
	`218`	`+ unsafe { modifiers.iter().map(\|m\| m.span).reduce(Span::merge).unwrap_unchecked() }`
`220`	`219`	`}`
`221`	`220`	`}`
`222`	`221`
Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,7 @@ pub struct JSDocTag<'a> {`
`40`	`40`
`41`	`41`	`impl<'a> JSDocTag<'a> {`
`42`	`42`	`pub fn new(kind: JSDocTagKindPart<'a>, body_content: &'a str, body_span: Span) -> JSDocTag<'a> {`
`43`		`- Self { span: kind.span.merge(&body_span), kind, body_raw: body_content, body_span }`
	`43`	`+ Self { span: kind.span.merge(body_span), kind, body_raw: body_content, body_span }`
`44`	`44`	`}`
`45`	`45`
`46`	`46`	/// Use for various simple tags like `@access`, `@deprecated`, ...etc.