Vendor exn from https://github.com/fast/exn@bb4d8ea4e4df335c46d4fa3f4f260121f9f84305

This is the basis for substantial changes to make it usable for the `gix-*` crates.
The wonderful aspect about this is not only a great reduction in dependencies,
but it also removes most proc-macro invocations.

Author: Byron

gix-error/src/exn/Cargo.toml

@@ -0,0 +1,37 @@
+# Copyright 2025 FastLabs Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+[package]
+name = "exn"
+version = "0.2.1"
+
+description = "A context-aware concrete Error type built on `std::error::Error`."
+
+edition.workspace = true
+homepage.workspace = true
+license.workspace = true
+readme.workspace = true
+repository.workspace = true
+
+[package.metadata.docs.rs]
+all-features = true
+rustdoc-args = ["--cfg", "docsrs"]
+
+[dependencies]
+
+[dev-dependencies]
+insta = { workspace = true }
+
+[lints]
+workspace = true

gix-error/src/exn/src/debug.rs

@@ -0,0 +1,108 @@
+// Copyright 2025 FastLabs Developers
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::fmt;
+use std::fmt::Formatter;
+
+use crate::Error;
+use crate::Exn;
+use crate::Frame;
+
+impl<E: Error> fmt::Debug for Exn<E> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        write_exn(f, self.as_frame(), 0, "")
+    }
+}
+
+impl fmt::Debug for Frame {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        write_exn(f, self, 0, "")
+    }
+}
+
+fn write_exn(f: &mut Formatter<'_>, frame: &Frame, level: usize, prefix: &str) -> fmt::Result {
+    write!(f, "{}", frame.as_error())?;
+    write_location(f, frame)?;
+
+    let children = frame.children();
+    let children_len = children.len();
+
+    for (i, child) in children.iter().enumerate() {
+        write!(f, "\n{}|", prefix)?;
+        write!(f, "\n{}|-> ", prefix)?;
+
+        let child_child_len = child.children().len();
+        if level == 0 && children_len == 1 && child_child_len == 1 {
+            write_exn(f, child, 0, prefix)?;
+        } else if i < children_len - 1 {
+            write_exn(f, child, level + 1, &format!("{}|   ", prefix))?;
+        } else {
+            write_exn(f, child, level + 1, &format!("{}    ", prefix))?;
+        }
+    }
+
+    Ok(())
+}
+
+#[cfg(not(windows_test))]
+fn write_location(f: &mut Formatter<'_>, exn: &Frame) -> fmt::Result {
+    let location = exn.location();
+    write!(
+        f,
+        ", at {}:{}:{}",
+        location.file(),
+        location.line(),
+        location.column()
+    )
+}
+
+#[cfg(windows_test)]
+fn write_location(f: &mut Formatter<'_>, exn: &Frame) -> fmt::Result {
+    let location = exn.location();
+    use std::os::windows::ffi::OsStrExt;
+    use std::path::Component;
+    use std::path::MAIN_SEPARATOR;
+    use std::path::Path;
+
+    let file = location.file();
+    let path = Path::new(file);
+
+    let mut resolved = String::new();
+
+    for c in path.components() {
+        match c {
+            Component::RootDir => {}
+            Component::CurDir => resolved.push('.'),
+            Component::ParentDir => resolved.push_str(".."),
+            Component::Prefix(prefix) => {
+                resolved.push_str(&prefix.as_os_str().to_string_lossy());
+                continue;
+            }
+            Component::Normal(s) => resolved.push_str(&s.to_string_lossy()),
+        }
+        resolved.push('/');
+    }
+
+    if path.as_os_str().encode_wide().last() != Some(MAIN_SEPARATOR as u16)
+        && resolved != "/"
+        && resolved.ends_with('/')
+    {
+        resolved.pop(); // Pop last '/'
+    }
+
+    let line = location.line();
+    let column = location.column();
+
+    write!(f, ", at {resolved}:{line}:{column}")
+}

gix-error/src/exn/src/display.rs

@@ -0,0 +1,24 @@
+// Copyright 2025 FastLabs Developers
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::fmt;
+
+use crate::Error;
+use crate::Exn;
+
+impl<E: Error> fmt::Display for Exn<E> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.as_error())
+    }
+}

gix-error/src/exn/src/impls.rs

@@ -0,0 +1,157 @@
+// Copyright 2025 FastLabs Developers
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use std::fmt;
+use std::marker::PhantomData;
+use std::panic::Location;
+
+use crate::Error;
+
+/// An exception type that can hold an error tree and additional context.
+pub struct Exn<E: Error> {
+    // trade one more indirection for less stack size
+    frame: Box<Frame>,
+    phantom: PhantomData<E>,
+}
+
+impl<E: Error> From<E> for Exn<E> {
+    #[track_caller]
+    fn from(error: E) -> Self {
+        Exn::new(error)
+    }
+}
+
+impl<E: Error> Exn<E> {
+    /// Create a new exception with the given error.
+    ///
+    /// This will automatically walk the [source chain of the error] and add them as children
+    /// frames.
+    ///
+    /// See also [`Error::raise`] for a fluent way to convert an error into an `Exn` instance.
+    ///
+    /// [source chain of the error]: std::error::Error::source
+    #[track_caller]
+    pub fn new(error: E) -> Self {
+        struct SourceError(String);
+
+        impl fmt::Debug for SourceError {
+            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+                fmt::Debug::fmt(&self.0, f)
+            }
+        }
+
+        impl fmt::Display for SourceError {
+            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+                fmt::Display::fmt(&self.0, f)
+            }
+        }
+
+        impl std::error::Error for SourceError {}
+
+        fn walk(error: &dyn std::error::Error, location: &'static Location<'static>) -> Vec<Frame> {
+            if let Some(source) = error.source() {
+                let children = vec![Frame {
+                    error: Box::new(SourceError(source.to_string())),
+                    location,
+                    children: walk(source, location),
+                }];
+                children
+            } else {
+                vec![]
+            }
+        }
+
+        let location = Location::caller();
+        let children = walk(&error, location);
+        let frame = Frame {
+            error: Box::new(error),
+            location,
+            children,
+        };
+
+        Self {
+            frame: Box::new(frame),
+            phantom: PhantomData,
+        }
+    }
+
+    /// Create a new exception with the given error and children.
+    #[track_caller]
+    pub fn from_iter<T, I>(children: I, err: E) -> Self
+    where
+        T: Error,
+        I: IntoIterator,
+        I::Item: Into<Exn<T>>,
+    {
+        let mut new_exn = Exn::new(err);
+        for exn in children {
+            let exn = exn.into();
+            new_exn.frame.children.push(*exn.frame);
+        }
+        new_exn
+    }
+
+    /// Raise a new exception; this will make the current exception a child of the new one.
+    #[track_caller]
+    pub fn raise<T: Error>(self, err: T) -> Exn<T> {
+        let mut new_exn = Exn::new(err);
+        new_exn.frame.children.push(*self.frame);
+        new_exn
+    }
+
+    /// Return the current exception.
+    pub fn as_error(&self) -> &E {
+        self.frame
+            .as_any()
+            .downcast_ref()
+            .expect("error type must match")
+    }
+
+    /// Return the underlying exception frame.
+    pub fn as_frame(&self) -> &Frame {
+        &self.frame
+    }
+}
+
+/// A frame in the exception tree.
+pub struct Frame {
+    /// The error that occurred at this frame.
+    error: Box<dyn Error>,
+    /// The source code location where this exception frame was created.
+    location: &'static Location<'static>,
+    /// Child exception frames that provide additional context or source errors.
+    children: Vec<Frame>,
+}
+
+impl Frame {
+    /// Return the error as a reference to [`std::any::Any`].
+    pub fn as_any(&self) -> &dyn std::any::Any {
+        &*self.error
+    }
+
+    /// Return the error as a reference to [`std::error::Error`].
+    pub fn as_error(&self) -> &dyn std::error::Error {
+        &*self.error
+    }
+
+    /// Return the source code location where this exception frame was created.
+    pub fn location(&self) -> &'static Location<'static> {
+        self.location
+    }
+
+    /// Return a slice of the children of the exception.
+    pub fn children(&self) -> &[Frame] {
+        &self.children
+    }
+}