docs: Rename 'range' parameter to 'span'

Author: epage

Diff for: src/renderer/mod.rs

@@ -1523,7 +1523,7 @@ impl Renderer {
             }
             if suggestion.origin != primary_origin {
                 if let Some(origin) = suggestion.origin {
-                    let (loc, _) = sm.span_to_locations(parts[0].range.clone());
+                    let (loc, _) = sm.span_to_locations(parts[0].span.clone());
                     // --> file.rs:line:col
                     //  |
                     let arrow = self.file_start();
@@ -1563,8 +1563,8 @@ impl Renderer {
                 row_num += 1;
             }
 
-            let file_lines = sm.span_to_lines(parts[0].range.clone());
-            let (line_start, line_end) = sm.span_to_locations(parts[0].range.clone());
+            let file_lines = sm.span_to_lines(parts[0].span.clone());
+            let (line_start, line_end) = sm.span_to_locations(parts[0].span.clone());
             let mut lines = complete.lines();
             if lines.clone().next().is_none() {
                 // Account for a suggestion to completely remove a line(s) with whitespace (#94192).
@@ -1697,8 +1697,8 @@ impl Renderer {
                 // already existing code, despite the colors and UI elements.
                 // We special case `#[derive(_)]\n` and other attribute suggestions, because those
                 // are the ones where context is most useful.
-                let file_lines = sm.span_to_lines(parts[0].range.end..parts[0].range.end);
-                let (lo, _) = sm.span_to_locations(parts[0].range.clone());
+                let file_lines = sm.span_to_lines(parts[0].span.end..parts[0].span.end);
+                let (lo, _) = sm.span_to_locations(parts[0].span.clone());
                 let line_num = lo.line;
                 if let Some(line) = sm.get_line(line_num) {
                     let line = normalize_whitespace(line);
@@ -1724,7 +1724,7 @@ impl Renderer {
                 show_code_change
             {
                 for part in parts {
-                    let (span_start, span_end) = sm.span_to_locations(part.range.clone());
+                    let (span_start, span_end) = sm.span_to_locations(part.span.clone());
                     let span_start_pos = span_start.display;
                     let span_end_pos = span_end.display;
 
@@ -1764,7 +1764,7 @@ impl Renderer {
                     let padding: usize = max_line_num_len + 3;
                     for p in underline_start..underline_end {
                         if matches!(show_code_change, DisplaySuggestion::Underline)
-                            && is_different(sm, part.replacement, part.range.clone())
+                            && is_different(sm, part.replacement, part.span.clone())
                         {
                             // If this is a replacement, underline with `~`, if this is an addition
                             // underline with `+`.

Diff for: src/renderer/source_map.rs

@@ -129,8 +129,8 @@ impl<'a> SourceMap<'a> {
         let source_len = self.source.len();
         if let Some(bigger) = annotations.iter().find_map(|x| {
             // Allow highlighting one past the last character in the source.
-            if source_len + 1 < x.range.end {
-                Some(&x.range)
+            if source_len + 1 < x.span.end {
+                Some(&x.span)
             } else {
                 None
             }
@@ -150,13 +150,13 @@ impl<'a> SourceMap<'a> {
         let mut multiline_annotations = vec![];
 
         for Annotation {
-            range,
+            span,
             label,
             kind,
             highlight_source,
         } in annotations
         {
-            let (lo, mut hi) = self.span_to_locations(range.clone());
+            let (lo, mut hi) = self.span_to_locations(span.clone());
 
             // Watch out for "empty spans". If we get a span like 6..6, we
             // want to just display a `^` at 6, so convert that to
@@ -374,13 +374,13 @@ impl<'a> SourceMap<'a> {
         }
         // Assumption: all spans are in the same file, and all spans
         // are disjoint. Sort in ascending order.
-        patches.sort_by_key(|p| p.range.start);
+        patches.sort_by_key(|p| p.span.start);
 
         // Find the bounding span.
-        let Some(lo) = patches.iter().map(|p| p.range.start).min() else {
+        let Some(lo) = patches.iter().map(|p| p.span.start).min() else {
             return Vec::new();
         };
-        let Some(hi) = patches.iter().map(|p| p.range.end).max() else {
+        let Some(hi) = patches.iter().map(|p| p.span.end).max() else {
             return Vec::new();
         };
 
@@ -410,7 +410,7 @@ impl<'a> SourceMap<'a> {
             // suggestion and snippet to look as if we just suggested to add
             // `"b"`, which is typically much easier for the user to understand.
             part.trim_trivial_replacements(self);
-            let (cur_lo, cur_hi) = self.span_to_locations(part.range.clone());
+            let (cur_lo, cur_hi) = self.span_to_locations(part.span.clone());
             if prev_hi.line == cur_lo.line {
                 let mut count = push_trailing(&mut buf, prev_line, &prev_hi, Some(&cur_lo));
                 while count > 0 {
@@ -454,7 +454,7 @@ impl<'a> SourceMap<'a> {
                     _ => 1,
                 })
                 .sum();
-            if !is_different(self, part.replacement, part.range.clone()) {
+            if !is_different(self, part.replacement, part.span.clone()) {
                 // Account for cases where we are suggesting the same code that's already
                 // there. This shouldn't happen often, but in some cases for multipart
                 // suggestions it's much easier to handle it here than in the origin.

Diff for: src/snippet.rs

@@ -39,7 +39,7 @@ impl<'a> Message<'a> {
                             let end = cause
                                 .markers
                                 .iter()
-                                .map(|a| a.range.end)
+                                .map(|a| a.span.end)
                                 .max()
                                 .unwrap_or(cause.source.len())
                                 .min(cause.source.len());
@@ -50,7 +50,7 @@ impl<'a> Message<'a> {
                             let end = suggestion
                                 .markers
                                 .iter()
-                                .map(|a| a.range.end)
+                                .map(|a| a.span.end)
                                 .max()
                                 .unwrap_or(suggestion.source.len())
                                 .min(suggestion.source.len());
@@ -222,7 +222,7 @@ impl<'a> Snippet<'a, Patch<'a>> {
 
 #[derive(Clone, Debug)]
 pub struct Annotation<'a> {
-    pub(crate) range: Range<usize>,
+    pub(crate) span: Range<usize>,
     pub(crate) label: Option<&'a str>,
     pub(crate) kind: AnnotationKind,
     pub(crate) highlight_source: bool,
@@ -254,7 +254,7 @@ pub enum AnnotationKind {
 impl AnnotationKind {
     pub fn span<'a>(self, span: Range<usize>) -> Annotation<'a> {
         Annotation {
-            range: span,
+            span: span,
             label: None,
             kind: self,
             highlight_source: false,
@@ -268,16 +268,16 @@ impl AnnotationKind {
 
 #[derive(Clone, Debug)]
 pub struct Patch<'a> {
-    pub(crate) range: Range<usize>,
+    pub(crate) span: Range<usize>,
     pub(crate) replacement: &'a str,
 }
 
 impl<'a> Patch<'a> {
     /// Text passed to this function is considered "untrusted input", as such
     /// all text is passed through a normalization function. Pre-styled text is
     /// not allowed to be passed to this function.
-    pub fn new(range: Range<usize>, replacement: &'a str) -> Self {
-        Self { range, replacement }
+    pub fn new(span: Range<usize>, replacement: &'a str) -> Self {
+        Self { span, replacement }
     }
 
     pub(crate) fn is_addition(&self, sm: &SourceMap<'_>) -> bool {
@@ -299,16 +299,16 @@ impl<'a> Patch<'a> {
     pub(crate) fn is_destructive_replacement(&self, sm: &SourceMap<'_>) -> bool {
         self.is_replacement(sm)
             && !sm
-                .span_to_snippet(self.range.clone())
+                .span_to_snippet(self.span.clone())
                 // This should use `is_some_and` when our MSRV is >= 1.70
                 .map_or(false, |s| {
                     as_substr(s.trim(), self.replacement.trim()).is_some()
                 })
     }
 
     fn replaces_meaningful_content(&self, sm: &SourceMap<'_>) -> bool {
-        sm.span_to_snippet(self.range.clone())
-            .map_or(!self.range.is_empty(), |snippet| !snippet.trim().is_empty())
+        sm.span_to_snippet(self.span.clone())
+            .map_or(!self.span.is_empty(), |snippet| !snippet.trim().is_empty())
     }
 
     /// Try to turn a replacement into an addition when the span that is being
@@ -317,12 +317,12 @@ impl<'a> Patch<'a> {
         if self.replacement.is_empty() {
             return;
         }
-        let Some(snippet) = sm.span_to_snippet(self.range.clone()) else {
+        let Some(snippet) = sm.span_to_snippet(self.span.clone()) else {
             return;
         };
 
         if let Some((prefix, substr, suffix)) = as_substr(snippet, self.replacement) {
-            self.range = self.range.start + prefix..self.range.end.saturating_sub(suffix);
+            self.span = self.span.start + prefix..self.span.end.saturating_sub(suffix);
             self.replacement = substr;
         }
     }