Merge pull request #2374 from GitoxideLabs/gix-error

Turn `Exn::into_box()` to `Exn::into_inner()`.

Author: Byron

gix-error/src/exn/impls.rs

@@ -140,17 +140,26 @@ impl<E: Error + Send + Sync + 'static> Exn<E> {
             .expect("the owned frame always matches the compile-time error type")
     }
 
-    /// Discard all error context and return the underlying error.
+    /// Discard all error context and return the underlying error in a Box.
     ///
-    /// This may be needed to obtain something that once again implements `Error`.
+    /// This is useful to retain the allocation, as internally it's also stored in a box,
+    /// when comparing it to [`Self::into_inner()`].
     pub fn into_box(self) -> Box<E> {
         match self.frame.error.downcast() {
             Ok(err) => err,
             Err(_) => unreachable!("The type in the frame is always the type of this instance"),
         }
     }
 
-    /// Turn ourselves into a type that implements [`Error`].
+    /// Discard all error context and return the underlying error.
+    ///
+    /// This may be needed to obtain something that once again implements `Error`.
+    /// Note that this destroys the internal Box and moves the value back onto the stack.
+    pub fn into_inner(self) -> E {
+        *self.into_box()
+    }
+
+    /// Turn ourselves into a top-level [Error] that implements [`std::error::Error`].
     pub fn into_error(self) -> crate::Error {
         self.into()
     }

gix-refspec/src/parse.rs

@@ -25,7 +25,7 @@ pub enum Error {
     #[error(transparent)]
     ReferenceName(#[from] gix_validate::reference::name::Error),
     #[error(transparent)]
-    RevSpec(#[from] Box<gix_revision::spec::parse::Error>),
+    RevSpec(#[from] gix_revision::spec::parse::Error),
 }
 
 /// Define how the parsed refspec should be used.
@@ -181,7 +181,7 @@ pub(crate) mod function {
                         .map_err(Error::from)
                         .or_else(|err| {
                             if allow_revspecs {
-                                gix_revision::spec::parse(spec, &mut super::revparse::Noop).map_err(Exn::into_box)?;
+                                gix_revision::spec::parse(spec, &mut super::revparse::Noop).map_err(Exn::into_inner)?;
                                 Ok(spec)
                             } else {
                                 Err(err)

gix-revision/tests/revision/spec/parse/kind.rs

@@ -3,7 +3,7 @@ use crate::spec::parse::{try_parse, try_parse_opts, Options};
 #[test]
 fn cannot_declare_ranges_multiple_times() {
     for invalid_spec in ["^HEAD..", "^HEAD..."] {
-        let err = try_parse(invalid_spec).unwrap_err().into_box();
+        let err = try_parse(invalid_spec).unwrap_err().into_inner();
         assert!(err.message.contains("cannot set spec kind more than once"));
     }
 }
@@ -18,7 +18,7 @@ fn delegate_can_refuse_spec_kinds() {
         },
     )
     .unwrap_err()
-    .into_box();
+    .into_inner();
     // Delegates can refuse spec kind changes to abort parsing early in case they want single-specs only
     insta::assert_snapshot!(err, @"delegate.kind(ExcludeReachable) failed");
 }
@@ -53,7 +53,7 @@ mod include_parents {
 
     #[test]
     fn trailing_caret_exclamation_mark_must_end_the_input() {
-        let err = try_parse("r1^@~1").unwrap_err().into_box();
+        let err = try_parse("r1^@~1").unwrap_err().into_inner();
         assert!(err.message.contains("unconsumed input"));
     }
 }
@@ -98,7 +98,7 @@ mod exclude_parents {
 
     #[test]
     fn trailing_caret_exclamation_mark_must_end_the_input() {
-        let err = try_parse("r1^!~1").unwrap_err().into_box();
+        let err = try_parse("r1^!~1").unwrap_err().into_inner();
         assert!(err.message.contains("unconsumed input"));
     }
 }
@@ -227,25 +227,25 @@ mod range {
 
     #[test]
     fn minus_with_n_omitted_has_to_end_there() {
-        let err = try_parse("r1^-^").unwrap_err().into_box();
+        let err = try_parse("r1^-^").unwrap_err().into_inner();
         assert!(err.message.contains("unconsumed input"));
     }
 
     #[test]
     fn minus_with_n_has_to_end_there() {
-        let err = try_parse("r1^-42^").unwrap_err().into_box();
+        let err = try_parse("r1^-42^").unwrap_err().into_inner();
         assert!(err.message.contains("unconsumed input"));
     }
 
     #[test]
     fn minus_with_n_has_to_end_there_and_handle_range_suffix() {
-        let err = try_parse("r1^-42..").unwrap_err().into_box();
+        let err = try_parse("r1^-42..").unwrap_err().into_inner();
         assert!(err.message.contains("unconsumed input"));
     }
 
     #[test]
     fn minus_with_n_omitted_has_to_end_there_and_handle_range_suffix() {
-        let err = try_parse("r1^-..").unwrap_err().into_box();
+        let err = try_parse("r1^-..").unwrap_err().into_inner();
         assert!(err.message.contains("unconsumed input"));
     }
 

gix-revision/tests/revision/spec/parse/navigate/caret_symbol.rs

@@ -57,7 +57,7 @@ fn followed_by_zero_is_peeling_to_commit() {
 
 #[test]
 fn explicitly_positive_numbers_are_invalid() {
-    let err = try_parse("@^+1").unwrap_err().into_box();
+    let err = try_parse("@^+1").unwrap_err().into_inner();
     assert_eq!(err.input.as_ref().map(AsRef::as_ref), Some(b"+1".as_ref()));
     assert!(err.message.contains("positive numbers are invalid"));
 }
@@ -181,11 +181,11 @@ fn empty_braces_deref_a_tag() {
 
 #[test]
 fn invalid_object_type() {
-    let err = try_parse("@^{invalid}").unwrap_err().into_box();
+    let err = try_parse("@^{invalid}").unwrap_err().into_inner();
     assert_eq!(err.input.as_ref().map(AsRef::as_ref), Some(b"invalid".as_ref()));
     assert!(err.message.contains("cannot peel"));
 
-    let err = try_parse("@^{Commit}").unwrap_err().into_box();
+    let err = try_parse("@^{Commit}").unwrap_err().into_inner();
     assert!(
         err.input.as_ref().map(AsRef::as_ref) == Some(b"Commit".as_ref()) && err.message.contains("cannot peel"),
         "these types are case sensitive"
@@ -204,37 +204,37 @@ fn invalid_caret_without_previous_refname() {
     );
 
     for revspec in ["^^^HEAD", "^^HEAD"] {
-        let err = try_parse(revspec).unwrap_err().into_box();
+        let err = try_parse(revspec).unwrap_err().into_inner();
         assert_eq!(err.input.as_ref().map(AsRef::as_ref), Some(b"HEAD".as_ref()));
         assert!(err.message.contains("unconsumed input"));
     }
 }
 
 #[test]
 fn incomplete_escaped_braces_in_regex_are_invalid() {
-    let err = try_parse(r"@^{/a\{1}}").unwrap_err().into_box();
+    let err = try_parse(r"@^{/a\{1}}").unwrap_err().into_inner();
     assert_eq!(err.input.as_ref().map(AsRef::as_ref), Some(b"}".as_ref()));
     assert!(err.message.contains("unconsumed input"));
 
-    let err = try_parse(r"@^{/a{1\}}").unwrap_err().into_box();
+    let err = try_parse(r"@^{/a{1\}}").unwrap_err().into_inner();
     assert!(
         err.input.as_ref().map(AsRef::as_ref) == Some(br"{/a{1\}}".as_ref()) && err.message.contains("unclosed brace")
     );
 }
 
 #[test]
 fn regex_with_empty_exclamation_mark_prefix_is_invalid() {
-    let err = try_parse(r#"@^{/!hello}"#).unwrap_err().into_box();
+    let err = try_parse(r#"@^{/!hello}"#).unwrap_err().into_inner();
     assert_eq!(err.input.as_ref().map(AsRef::as_ref), Some(b"!hello".as_ref()));
     assert!(err.message.contains("need one character after"));
 }
 
 #[test]
 fn bad_escapes_can_cause_brace_mismatch() {
-    let err = try_parse(r"@^{\}").unwrap_err().into_box();
+    let err = try_parse(r"@^{\}").unwrap_err().into_inner();
     assert!(err.input.as_ref().map(AsRef::as_ref) == Some(br"{\}".as_ref()) && err.message.contains("unclosed brace"));
 
-    let err = try_parse(r"@^{{\}}").unwrap_err().into_box();
+    let err = try_parse(r"@^{{\}}").unwrap_err().into_inner();
     // The raw string r"{{\}}" contains actual backslashes, so the input would be r"{{\}}"
     assert!(
         err.input.as_ref().map(AsRef::as_ref) == Some(br"{{\}}".as_ref()) && err.message.contains("unclosed brace")

gix-revision/tests/revision/spec/parse/navigate/tilde_symbol.rs

@@ -4,7 +4,7 @@ use crate::spec::parse::{parse, try_parse};
 
 #[test]
 fn without_anchor_is_invalid() {
-    let err = try_parse("~").unwrap_err().into_box();
+    let err = try_parse("~").unwrap_err().into_inner();
     assert!(err.message.contains("tilde needs to follow an anchor"));
 }
 

gix/src/commit.rs

@@ -84,7 +84,7 @@ pub mod describe {
         #[error(transparent)]
         OpenCache(#[from] crate::repository::commit_graph_if_enabled::Error),
         #[error(transparent)]
-        Describe(#[from] Box<gix_revision::describe::Error>),
+        Describe(#[from] gix_revision::describe::Error),
         #[error("Could not produce an unambiguous shortened id for formatting.")]
         ShortId(#[from] crate::id::shorten::Error),
         #[error(transparent)]
@@ -245,7 +245,7 @@ pub mod describe {
                     max_candidates: self.max_candidates,
                 },
             )
-            .map_err(Exn::into_box)?;
+            .map_err(Exn::into_inner)?;
 
             Ok(outcome.map(|outcome| Resolution {
                 outcome,

gix/src/config/tree/keys.rs

@@ -527,7 +527,8 @@ pub mod validate {
 
     impl Validate for Time {
         fn validate(&self, value: &BStr) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
-            gix_date::parse(value.to_str()?, std::time::SystemTime::now().into()).map_err(gix_error::Exn::into_box)?;
+            gix_date::parse(value.to_str()?, std::time::SystemTime::now().into())
+                .map_err(gix_error::Exn::into_inner)?;
             Ok(())
         }
     }

src/shared.rs

@@ -391,7 +391,7 @@ mod clap {
 
         fn parse_ref(&self, cmd: &Command, arg: Option<&Arg>, value: &OsStr) -> Result<Self::Value, Error> {
             StringValueParser::new()
-                .try_map(|arg| gix::date::parse(&arg, Some(std::time::SystemTime::now())).map_err(gix::Exn::into_box))
+                .try_map(|arg| gix::date::parse(&arg, Some(std::time::SystemTime::now())).map_err(gix::Exn::into_inner))
                 .parse_ref(cmd, arg, value)
         }
     }