Cache span end positions

Author: dtolnay

src/fallback.rs

@@ -375,37 +375,34 @@ impl FileInfo {
     }
 
     fn byte_range(&mut self, span: Span) -> Range<usize> {
-        let lo_char = (span.lo - self.span.lo) as usize;
+        self.byte(span.lo)..self.byte(span.hi)
+    }
+
+    fn byte(&mut self, ch: u32) -> usize {
+        let char_index = (ch - self.span.lo) as usize;
 
         // Look up offset of the largest already-computed char index that is
         // less than or equal to the current requested one. We resume counting
         // chars from that point.
         let (&last_char_index, &last_byte_offset) = self
             .char_index_to_byte_offset
-            .range(..=lo_char)
+            .range(..=char_index)
             .next_back()
             .unwrap_or((&0, &0));
 
-        let lo_byte = if last_char_index == lo_char {
+        if last_char_index == char_index {
             last_byte_offset
         } else {
             let total_byte_offset = match self.source_text[last_byte_offset..]
                 .char_indices()
-                .nth(lo_char - last_char_index)
+                .nth(char_index - last_char_index)
             {
                 Some((additional_offset, _ch)) => last_byte_offset + additional_offset,
                 None => self.source_text.len(),
             };
             self.char_index_to_byte_offset
-                .insert(lo_char, total_byte_offset);
+                .insert(char_index, total_byte_offset);
             total_byte_offset
-        };
-
-        let trunc_lo = &self.source_text[lo_byte..];
-        let char_len = (span.hi - span.lo) as usize;
-        lo_byte..match trunc_lo.char_indices().nth(char_len) {
-            Some((offset, _ch)) => lo_byte + offset,
-            None => self.source_text.len(),
         }
     }