Give WithLineNumber more powers

Author: CAD97

src/span.rs

@@ -29,7 +29,7 @@ pub struct WithLineNumber<T> {
     pub data: T,
 }
 
-impl Span for WithLineNumber<&str> {
+impl Span for &str {
     /// Byte index range into this string.
     type Subspan = Range<usize>;
     /// Byte index into this string.
@@ -40,63 +40,111 @@ impl Span for WithLineNumber<&str> {
     }
 
     fn end(&self) -> Self::Pos {
-        self.data.len()
+        self.len()
     }
 
     fn slice(&self, range: Range<Self::Pos>) -> Range<usize> {
         range
     }
 }
 
-impl SpanFormatter<WithLineNumber<&str>> for () {
-    fn first_line(&self, span: &WithLineNumber<&str>) -> WithLineNumber<Range<usize>> {
+impl SpanFormatter<&str> for () {
+    fn first_line(&self, span: &&str) -> WithLineNumber<Range<usize>> {
         let start = 0;
         let end = span
-            .data
             .as_bytes()
             .iter()
             .enumerate()
             .find(|(_, &b)| b == b'\n')
-            .map_or_else(|| span.data.len(), |(i, _)| i);
+            .map_or_else(|| span.len(), |(i, _)| i);
         WithLineNumber {
             data: start..end,
-            line_num: span.line_num,
+            line_num: 1,
         }
     }
 
     fn next_line(
         &self,
-        span: &WithLineNumber<&str>,
+        span: &&str,
         subspan: &WithLineNumber<Range<usize>>,
     ) -> Option<WithLineNumber<Range<usize>>> {
         let start = subspan.data.end + 1;
         let end = span
-            .data
             .get(start..)?
             .as_bytes()
             .iter()
             .enumerate()
             .find(|(_, &b)| b == b'\n')
-            .map_or_else(|| span.data.len(), |(i, _)| i + start);
+            .map_or_else(|| span.len(), |(i, _)| i + start);
         Some(WithLineNumber {
             data: start..end,
             line_num: subspan.line_num + 1,
         })
     }
 
-    fn count_columns(&self, span: &WithLineNumber<&str>, subspan: &Range<usize>) -> usize {
-        span.data[subspan.start..subspan.end].chars().count()
+    fn count_columns(&self, span: &&str, subspan: &Range<usize>) -> usize {
+        span[subspan.start..subspan.end].chars().count()
     }
 }
 
-impl SpanWriter<WithLineNumber<&str>> for () {
+impl SpanWriter<&str> for () {
     fn write(
         &self,
         w: &mut dyn io::Write,
-        span: &WithLineNumber<&str>,
+        span: &&str,
         subspan: &Range<usize>,
     ) -> io::Result<()> {
-        w.write_all(span.data[subspan.start..subspan.end].as_bytes())
+        w.write_all(span[subspan.start..subspan.end].as_bytes())
+    }
+}
+
+impl<S: Span> Span for WithLineNumber<S> {
+    type Subspan = S::Subspan;
+    type Pos = S::Pos;
+
+    fn start(&self) -> S::Pos {
+        self.data.start()
+    }
+
+    fn end(&self) -> S::Pos {
+        self.data.end()
+    }
+
+    fn slice(&self, range: Range<S::Pos>) -> S::Subspan {
+        self.data.slice(range)
+    }
+}
+
+impl<S: Span, SF: SpanFormatter<S>> SpanFormatter<WithLineNumber<S>> for SF {
+    fn first_line(&self, span: &WithLineNumber<S>) -> WithLineNumber<S::Subspan> {
+        let wln = self.first_line(&span.data);
+        WithLineNumber {
+            data: wln.data,
+            line_num: wln.line_num + span.line_num - 1,
+        }
+    }
+
+    fn next_line(
+        &self,
+        span: &WithLineNumber<S>,
+        subspan: &WithLineNumber<S::Subspan>,
+    ) -> Option<WithLineNumber<S::Subspan>> {
+        self.next_line(&span.data, subspan)
+    }
+
+    fn count_columns(&self, span: &WithLineNumber<S>, subspan: &S::Subspan) -> usize {
+        self.count_columns(&span.data, subspan)
+    }
+}
+
+impl<S: Span, SW: SpanWriter<S>> SpanWriter<WithLineNumber<S>> for SW {
+    fn write(
+        &self,
+        w: &mut dyn io::Write,
+        span: &WithLineNumber<S>,
+        subspan: &S::Subspan,
+    ) -> io::Result<()> {
+        self.write(w, &span.data, subspan)
     }
 }