Tidying

Author: Porges

Cargo.lock

@@ -35,15 +35,15 @@ impl<T: ?Sized> Index<T> {
         self.index
     }
 
-    pub fn up_to(&self, ix: Index<T>) -> Span<T> {
+    pub fn up_to(&self, ix: Index<T>) -> Option<Span<T>> {
         debug_assert!(
             *self <= ix,
             "cannot go up_to a lower index: {} > {}",
             self.index,
             ix.index
         );
 
-        Span::from_indices(*self, ix)
+        Span::try_from_indices(*self, ix)
     }
 }
 

complex-indifference/src/index.rs

@@ -1,6 +1,6 @@
 use crate::{Count, Index};
 
-/// A range of [`Index`]es.
+/// A non-empty range of [`Index`]es.
 #[derive(Debug, PartialEq, Eq)]
 pub struct Span<T: ?Sized> {
     start: Index<T>,
@@ -30,10 +30,10 @@ impl<T: ?Sized> From<(Index<T>, Count<T>)> for Span<T> {
     }
 }
 
-// TODO: this is really try-from
-impl<T: ?Sized> From<(Index<T>, Index<T>)> for Span<T> {
-    fn from(value: (Index<T>, Index<T>)) -> Self {
-        Self::from_indices(value.0, value.1)
+impl<T: ?Sized> TryFrom<(Index<T>, Index<T>)> for Span<T> {
+    type Error = ();
+    fn try_from(value: (Index<T>, Index<T>)) -> Result<Self, ()> {
+        Self::try_from_indices(value.0, value.1).ok_or(())
     }
 }
 
@@ -45,8 +45,16 @@ impl<T: ?Sized> Span<T> {
         }
     }
 
-    pub fn from_indices(start: Index<T>, end: Index<T>) -> Self {
-        debug_assert!(
+    pub fn try_from_indices(start: Index<T>, end: Index<T>) -> Option<Self> {
+        if start > end {
+            None
+        } else {
+            Some(Self { start, end })
+        }
+    }
+
+    pub fn unsafe_from_indices(start: Index<T>, end: Index<T>) -> Self {
+        assert!(
             start <= end,
             "indices are in the wrong order: {} > {}",
             start.index(),

complex-indifference/src/span.rs

@@ -9,16 +9,13 @@ edition.workspace = true
 complex-indifference = { path = "../complex-indifference", features = ["unicode-width"] }
 derive_more = { version = "1.0.0", features = ["from", "display", "error"] }
 errful-derive = { path = "../errful-derive" }
-impls = "1.0.3"
-mappable-rc = "0.1.1"
 owo-colors = { version = "4.0.0" }
 ref-cast = "1.0.23"
 snippets = { path = "../snippets" }
 textwrap = { version = "0.16.1", features = ["terminal_size"] }
 unicode-width = "0.2.0"
 url = "2.5.2"
 url-macro = "0.2"
-yoke = "0.7.4"
 
 [dev-dependencies]
 ansi-to-html = "0.2.1"

errful/Cargo.toml

@@ -12,8 +12,6 @@ pub mod result;
 pub use complex_indifference::Span;
 pub use errful_derive::Error;
 pub use formatting::PrettyDisplay;
-#[doc(hidden)]
-pub use impls::impls;
 pub use protocol::{AsErrful, Errful};
 pub use result::MainResult;
 

errful/src/lib.rs

@@ -11,7 +11,7 @@
 //! - Types which are specific to this crate are provided by providing a
 //!   reference to the [`Errful`] trait from this crate. This is used for non-specific
 //!   types such as labels, source code, etc.
-//!   
+//!
 //! The reason for this is that the `provide` method cannot distinguish between
 //! multiple values of the same type, so it would be necessary to define wrapper
 //! types anyway (e.g. `struct Code(str)` – this is how an earlier version of this
@@ -23,6 +23,8 @@
 //! (`T + 'static`) or a reference (`&'self (T + 'static)`), but something like
 //! `Vec<&'self (T + 'static)>` is not possible.
 //!
+//! ## Notes
+//!
 //! An earlier version of this trait returned a `Vec<Box<dyn ErrField>>` where `ErrField`
 //! is implemented by a zero-sized type representing the field. This then allowed reading
 //! the specific field from the error and turn this into a `Vec<&dyn Error>` (for example).

errful/src/protocol.rs

@@ -23,6 +23,24 @@ impl<E> MainResult<E> {
     }
 }
 
+impl<E> From<Result<(), E>> for MainResult<E> {
+    fn from(value: Result<(), E>) -> Self {
+        match value {
+            Ok(()) => MainResult::success(),
+            Err(err) => MainResult::error(err),
+        }
+    }
+}
+
+impl<E> From<Result<std::process::ExitCode, E>> for MainResult<E> {
+    fn from(value: Result<std::process::ExitCode, E>) -> Self {
+        match value {
+            Ok(code) => MainResult::exit_code(code),
+            Err(err) => MainResult::error(err),
+        }
+    }
+}
+
 impl<Err> std::ops::FromResidual<Result<Infallible, Err>> for MainResult<Err> {
     fn from_residual(residual: Result<Infallible, Err>) -> Self {
         match residual {
@@ -54,12 +72,3 @@ impl<E: Error> Termination for MainResult<E> {
         }
     }
 }
-
-impl<E> From<Result<(), E>> for MainResult<E> {
-    fn from(value: Result<(), E>) -> Self {
-        match value {
-            Ok(()) => MainResult::Code(ExitCode::SUCCESS),
-            Err(err) => MainResult::Err(err),
-        }
-    }
-}

errful/src/result.rs

@@ -27,7 +27,8 @@ pub fn render(source_code: &str, mut labels: Vec1<Label>) -> String {
         let span = label.span;
         let start_ix = source_code.floor_char_boundary(span.start().index());
         let end_ix = source_code.ceil_char_boundary(span.end().index());
-        label.span = Span::from_indices(start_ix.into(), end_ix.into());
+        // UNWRAP: since span is already ordered, we know that start_ix <= end_ix
+        label.span = Span::try_from_indices(start_ix.into(), end_ix.into()).unwrap();
     }
 
     Highlighter::new(source_code).render_spans(labels.into())
@@ -108,8 +109,7 @@ impl Highlighter<'_> {
             .unwrap_or(self.source_code.len())
             .into();
 
-        let line_span = Span::from((start_of_line, end_of_line));
-
+        let line_span = Span::try_from((start_of_line, end_of_line)).unwrap();
         debug_assert!(
             line_span.contains_offset(span.start())
                 || (span.len() == Count::ZERO && span.start() == line_span.end())
@@ -421,8 +421,9 @@ impl LineHighlighter<'_> {
                         // |←   offset_to_space   →|
                         //                         [l.start]----
                         // |←  offset_from_start? →|
-                        let offset_from_start =
-                            self.source_code[line_start.up_to(l.start())].width();
+                        let offset_from_start = self.source_code
+                            [line_start.up_to(l.start()).expect("l.start >= line_start")]
+                        .width();
 
                         if offset_from_start == offset_to_space {
                             Some(&l.style)
@@ -452,7 +453,10 @@ impl LineHighlighter<'_> {
         };
 
         debug_assert!(line_start <= label.start());
-        let indent_width = self.source_code[line_start.up_to(label.start())].width();
+        let indent_width = self.source_code[line_start
+            .up_to(label.start())
+            .expect("label.start >= line_start")]
+        .width();
 
         // 2 chars at start of messages: "└╴"
         const MSG_PREFIX_WIDTH: usize = 2;
@@ -484,7 +488,9 @@ impl LineHighlighter<'_> {
             // |← total_width →|← len? →|
             //                          [l.start]-------
             // |←   offset_from_start  →|
-            let offset_from_start = self.source_code[line_start.up_to(l.start())].width();
+            let offset_from_start = self.source_code
+                [line_start.up_to(l.start()).expect("l.start >= line_start")]
+            .width();
             if let Some(len) = offset_from_start.checked_sub(total_width) {
                 if len > 0 {
                     out.push(no_style.style(" ".repeat(len).into()));
@@ -517,7 +523,10 @@ impl LineHighlighter<'_> {
                     let end = min(wanted_end, label.start());
 
                     // emit highlighted portion of line
-                    let value = Span::from_indices(up_to, end).str(self.source_code);
+                    // UNWRAP: since start is > up_to, end must be as well
+                    let value = Span::try_from_indices(up_to, end)
+                        .unwrap()
+                        .str(self.source_code);
                     self.line.push(outer_label.style.style(value.into()));
 
                     // emit indicator line
@@ -543,14 +552,17 @@ impl LineHighlighter<'_> {
                 // if we still didn’t get to the start of the next label
                 // then there is an unhighlighted gap
                 if label.start() > up_to {
-                    // emit unhighlighted characters
-                    let value = &self.source_code[up_to.up_to(label.start())];
-                    self.line.push(no_style.style(value.into()));
-                    // space indicator line wide enough
-                    self.indicator_line
-                        .push(no_style.style(" ".repeat(value.width()).into()));
-
-                    up_to = label.start();
+                    // the first check ensures that start > up_to, .up_to() will allow start >= up_to
+                    if let Some(slice) = up_to.up_to(label.start()) {
+                        // emit unhighlighted characters
+                        let value = &self.source_code[slice];
+                        self.line.push(no_style.style(value.into()));
+                        // space indicator line wide enough
+                        self.indicator_line
+                            .push(no_style.style(" ".repeat(value.width()).into()));
+
+                        up_to = label.start();
+                    }
                 }
             }
 
@@ -560,10 +572,11 @@ impl LineHighlighter<'_> {
 
         while let Some(label) = stack.pop() {
             let end = label.end();
-            if up_to <= end {
+
+            if let Some(slice) = up_to.up_to(end) {
                 // TODO: what are the effects of this check?
                 // it prevents a crash found by fuzzing but might skip a message?
-                let value = &self.source_code[up_to.up_to(end)];
+                let value = &self.source_code[slice];
                 let continuing = label.start() < up_to;
                 self.fill_indicator(continuing, false, value, &label.style);
                 self.line.push(label.style.style(value.into()));
@@ -574,10 +587,13 @@ impl LineHighlighter<'_> {
 
         // if we didn't reach the end, we need to emit the rest
         if up_to < line_span.end() {
-            // emit unhighlighted characters
-            let value = self.source_code[up_to.up_to(line_span.end())].trim_ascii_end();
-            self.line.push(no_style.style(value.into()));
-            // indicator line doesn't need spacing
+            // note that .up_to() would allow <= line_span.end()
+            if let Some(slice) = up_to.up_to(line_span.end()) {
+                // emit unhighlighted characters
+                let value = self.source_code[slice].trim_ascii_end();
+                self.line.push(no_style.style(value.into()));
+                // indicator line doesn't need spacing
+            }
         }
 
         // emit all messages now that we know the full order

snippets/src/lib.rs

@@ -23,7 +23,11 @@ fn main() {
                 .iter()
                 .map(|l| {
                     Label::new(
-                        Span::from_indices(min(l.start, l.end).into(), max(l.start, l.end).into()),
+                        Span::try_from_indices(
+                            min(l.start, l.end).into(),
+                            max(l.start, l.end).into(),
+                        )
+                        .unwrap(),
                         l.label.deref().into(),
                         style,
                     )