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.

Sebastian Thiel committed 10 months ago

Commit 0eaab701 parent 5ab19a716 files · +846 −0Browse files

Unified · Split

16 files

gix-error/src/exn/Cargo.toml +37 −0
gix-error/src/exn/src/debug.rs +108 −0
gix-error/src/exn/src/display.rs +24 −0
gix-error/src/exn/src/impls.rs +157 −0
gix-error/src/exn/src/lib.rs +124 −0
gix-error/src/exn/src/macros.rs +90 −0
gix-error/src/exn/src/option.rs +45 −0
gix-error/src/exn/src/result.rs +76 −0
gix-error/src/exn/tests/simple.rs +118 −0
gix-error/src/exn/tests/snapshots/simple__bail.snap +5 −0
gix-error/src/exn/tests/snapshots/simple__ensure_fail.snap +5 −0
gix-error/src/exn/tests/snapshots/simple__error_straightforward.snap +13 −0
gix-error/src/exn/tests/snapshots/simple__error_tree.snap +27 −0
gix-error/src/exn/tests/snapshots/simple__from_error.snap +5 −0
gix-error/src/exn/tests/snapshots/simple__option_ext.snap +5 −0
gix-error/src/exn/tests/snapshots/simple__result_ext.snap +7 −0

gix-error/src/exn/Cargo.toml+37−0

@@ -0,0 +1,37 @@
	1	# Copyright 2025 FastLabs Developers
	2	#
	3	# Licensed under the Apache License, Version 2.0 (the "License");
	4	# you may not use this file except in compliance with the License.
	5	# You may obtain a copy of the License at
	6	#
	7	# http://www.apache.org/licenses/LICENSE-2.0
	8	#
	9	# Unless required by applicable law or agreed to in writing, software
	10	# distributed under the License is distributed on an "AS IS" BASIS,
	11	# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	12	# See the License for the specific language governing permissions and
	13	# limitations under the License.
	14
	15	[package]
	16	name = "exn"
	17	version = "0.2.1"
	18
	19	description = "A context-aware concrete Error type built on `std::error::Error`."
	20
	21	edition.workspace = true
	22	homepage.workspace = true
	23	license.workspace = true
	24	readme.workspace = true
	25	repository.workspace = true
	26
	27	[package.metadata.docs.rs]
	28	all-features = true
	29	rustdoc-args = ["--cfg", "docsrs"]
	30
	31	[dependencies]
	32
	33	[dev-dependencies]
	34	insta = { workspace = true }
	35
	36	[lints]
	37	workspace = true

gix-error/src/exn/src/debug.rs+108−0

@@ -0,0 +1,108 @@
	1	// Copyright 2025 FastLabs Developers
	2	//
	3	// Licensed under the Apache License, Version 2.0 (the "License");
	4	// you may not use this file except in compliance with the License.
	5	// You may obtain a copy of the License at
	6	//
	7	// http://www.apache.org/licenses/LICENSE-2.0
	8	//
	9	// Unless required by applicable law or agreed to in writing, software
	10	// distributed under the License is distributed on an "AS IS" BASIS,
	11	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	12	// See the License for the specific language governing permissions and
	13	// limitations under the License.
	14
	15	use std::fmt;
	16	use std::fmt::Formatter;
	17
	18	use crate::Error;
	19	use crate::Exn;
	20	use crate::Frame;
	21
	22	impl<E: Error> fmt::Debug for Exn<E> {
	23	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
	24	write_exn(f, self.as_frame(), 0, "")
	25	}
	26	}
	27
	28	impl fmt::Debug for Frame {
	29	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
	30	write_exn(f, self, 0, "")
	31	}
	32	}
	33
	34	fn write_exn(f: &mut Formatter<'_>, frame: &Frame, level: usize, prefix: &str) -> fmt::Result {
	35	write!(f, "{}", frame.as_error())?;
	36	write_location(f, frame)?;
	37
	38	let children = frame.children();
	39	let children_len = children.len();
	40
	41	for (i, child) in children.iter().enumerate() {
	42	write!(f, "\n{}\|", prefix)?;
	43	write!(f, "\n{}\|-> ", prefix)?;
	44
	45	let child_child_len = child.children().len();
	46	if level == 0 && children_len == 1 && child_child_len == 1 {
	47	write_exn(f, child, 0, prefix)?;
	48	} else if i < children_len - 1 {
	49	write_exn(f, child, level + 1, &format!("{}\| ", prefix))?;
	50	} else {
	51	write_exn(f, child, level + 1, &format!("{} ", prefix))?;
	52	}
	53	}
	54
	55	Ok(())
	56	}
	57
	58	#[cfg(not(windows_test))]
	59	fn write_location(f: &mut Formatter<'_>, exn: &Frame) -> fmt::Result {
	60	let location = exn.location();
	61	write!(
	62	f,
	63	", at {}:{}:{}",
	64	location.file(),
	65	location.line(),
	66	location.column()
	67	)
	68	}
	69
	70	#[cfg(windows_test)]
	71	fn write_location(f: &mut Formatter<'_>, exn: &Frame) -> fmt::Result {
	72	let location = exn.location();
	73	use std::os::windows::ffi::OsStrExt;
	74	use std::path::Component;
	75	use std::path::MAIN_SEPARATOR;
	76	use std::path::Path;
	77
	78	let file = location.file();
	79	let path = Path::new(file);
	80
	81	let mut resolved = String::new();
	82
	83	for c in path.components() {
	84	match c {
	85	Component::RootDir => {}
	86	Component::CurDir => resolved.push('.'),
	87	Component::ParentDir => resolved.push_str(".."),
	88	Component::Prefix(prefix) => {
	89	resolved.push_str(&prefix.as_os_str().to_string_lossy());
	90	continue;
	91	}
	92	Component::Normal(s) => resolved.push_str(&s.to_string_lossy()),
	93	}
	94	resolved.push('/');
	95	}
	96
	97	if path.as_os_str().encode_wide().last() != Some(MAIN_SEPARATOR as u16)
	98	&& resolved != "/"
	99	&& resolved.ends_with('/')
	100	{
	101	resolved.pop(); // Pop last '/'
	102	}
	103
	104	let line = location.line();
	105	let column = location.column();
	106
	107	write!(f, ", at {resolved}:{line}:{column}")
	108	}

gix-error/src/exn/src/display.rs+24−0

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

gix-error/src/exn/src/impls.rs+157−0

@@ -0,0 +1,157 @@
	1	// Copyright 2025 FastLabs Developers
	2	//
	3	// Licensed under the Apache License, Version 2.0 (the "License");
	4	// you may not use this file except in compliance with the License.
	5	// You may obtain a copy of the License at
	6	//
	7	// http://www.apache.org/licenses/LICENSE-2.0
	8	//
	9	// Unless required by applicable law or agreed to in writing, software
	10	// distributed under the License is distributed on an "AS IS" BASIS,
	11	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	12	// See the License for the specific language governing permissions and
	13	// limitations under the License.
	14
	15	use std::fmt;
	16	use std::marker::PhantomData;
	17	use std::panic::Location;
	18
	19	use crate::Error;
	20
	21	/// An exception type that can hold an error tree and additional context.
	22	pub struct Exn<E: Error> {
	23	// trade one more indirection for less stack size
	24	frame: Box<Frame>,
	25	phantom: PhantomData<E>,
	26	}
	27
	28	impl<E: Error> From<E> for Exn<E> {
	29	#[track_caller]
	30	fn from(error: E) -> Self {
	31	Exn::new(error)
	32	}
	33	}
	34
	35	impl<E: Error> Exn<E> {
	36	/// Create a new exception with the given error.
	37	///
	38	/// This will automatically walk the [source chain of the error] and add them as children
	39	/// frames.
	40	///
	41	/// See also [`Error::raise`] for a fluent way to convert an error into an `Exn` instance.
	42	///
	43	/// [source chain of the error]: std::error::Error::source
	44	#[track_caller]
	45	pub fn new(error: E) -> Self {
	46	struct SourceError(String);
	47
	48	impl fmt::Debug for SourceError {
	49	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
	50	fmt::Debug::fmt(&self.0, f)
	51	}
	52	}
	53
	54	impl fmt::Display for SourceError {
	55	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
	56	fmt::Display::fmt(&self.0, f)
	57	}
	58	}
	59
	60	impl std::error::Error for SourceError {}
	61
	62	fn walk(error: &dyn std::error::Error, location: &'static Location<'static>) -> Vec<Frame> {
	63	if let Some(source) = error.source() {
	64	let children = vec![Frame {
	65	error: Box::new(SourceError(source.to_string())),
	66	location,
	67	children: walk(source, location),
	68	}];
	69	children
	70	} else {
	71	vec![]
	72	}
	73	}
	74
	75	let location = Location::caller();
	76	let children = walk(&error, location);
	77	let frame = Frame {
	78	error: Box::new(error),
	79	location,
	80	children,
	81	};
	82
	83	Self {
	84	frame: Box::new(frame),
	85	phantom: PhantomData,
	86	}
	87	}
	88
	89	/// Create a new exception with the given error and children.
	90	#[track_caller]
	91	pub fn from_iter<T, I>(children: I, err: E) -> Self
	92	where
	93	T: Error,
	94	I: IntoIterator,
	95	I::Item: Into<Exn<T>>,
	96	{
	97	let mut new_exn = Exn::new(err);
	98	for exn in children {
	99	let exn = exn.into();
	100	new_exn.frame.children.push(*exn.frame);
	101	}
	102	new_exn
	103	}
	104
	105	/// Raise a new exception; this will make the current exception a child of the new one.
	106	#[track_caller]
	107	pub fn raise<T: Error>(self, err: T) -> Exn<T> {
	108	let mut new_exn = Exn::new(err);
	109	new_exn.frame.children.push(*self.frame);
	110	new_exn
	111	}
	112
	113	/// Return the current exception.
	114	pub fn as_error(&self) -> &E {
	115	self.frame
	116	.as_any()
	117	.downcast_ref()
	118	.expect("error type must match")
	119	}
	120
	121	/// Return the underlying exception frame.
	122	pub fn as_frame(&self) -> &Frame {
	123	&self.frame
	124	}
	125	}
	126
	127	/// A frame in the exception tree.
	128	pub struct Frame {
	129	/// The error that occurred at this frame.
	130	error: Box<dyn Error>,
	131	/// The source code location where this exception frame was created.
	132	location: &'static Location<'static>,
	133	/// Child exception frames that provide additional context or source errors.
	134	children: Vec<Frame>,
	135	}
	136
	137	impl Frame {
	138	/// Return the error as a reference to [`std::any::Any`].
	139	pub fn as_any(&self) -> &dyn std::any::Any {
	140	&*self.error
	141	}
	142
	143	/// Return the error as a reference to [`std::error::Error`].
	144	pub fn as_error(&self) -> &dyn std::error::Error {
	145	&*self.error
	146	}
	147
	148	/// Return the source code location where this exception frame was created.
	149	pub fn location(&self) -> &'static Location<'static> {
	150	self.location
	151	}
	152
	153	/// Return a slice of the children of the exception.
	154	pub fn children(&self) -> &[Frame] {
	155	&self.children
	156	}
	157	}

gix-error/src/exn/src/lib.rs+124−0

@@ -0,0 +1,124 @@
	1	// Copyright 2025 FastLabs Developers
	2	//
	3	// Licensed under the Apache License, Version 2.0 (the "License");
	4	// you may not use this file except in compliance with the License.
	5	// You may obtain a copy of the License at
	6	//
	7	// http://www.apache.org/licenses/LICENSE-2.0
	8	//
	9	// Unless required by applicable law or agreed to in writing, software
	10	// distributed under the License is distributed on an "AS IS" BASIS,
	11	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	12	// See the License for the specific language governing permissions and
	13	// limitations under the License.
	14
	15	//! A context-aware concrete Error type built on `std::error::Error`
	16	//!
	17	//! # Examples
	18	//!
	19	//! ```
	20	//! use exn::Result;
	21	//! use exn::ResultExt;
	22	//! use exn::bail;
	23	//!
	24	//! // It's recommended to define errors as structs. Exn will maintain the error tree automatically.
	25	//! #[derive(Debug)]
	26	//! struct LogicError(String);
	27	//!
	28	//! impl std::fmt::Display for LogicError {
	29	//! fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
	30	//! write!(f, "logic error: {}", self.0)
	31	//! }
	32	//! }
	33	//!
	34	//! impl std::error::Error for LogicError {}
	35	//!
	36	//! fn do_logic() -> Result<(), LogicError> {
	37	//! bail!(LogicError("0 == 1".to_string()));
	38	//! }
	39	//!
	40	//! // Errors can be enum but notably don't need to chain source error.
	41	//! #[derive(Debug)]
	42	//! enum AppError {
	43	//! Fatal { consequences: &'static str },
	44	//! Trivial,
	45	//! }
	46	//!
	47	//! impl std::fmt::Display for AppError {
	48	//! fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
	49	//! match self {
	50	//! AppError::Fatal { consequences } => write!(f, "fatal error: {consequences}"),
	51	//! AppError::Trivial => write!(f, "trivial error"),
	52	//! }
	53	//! }
	54	//! }
	55	//!
	56	//! impl std::error::Error for AppError {}
	57	//!
	58	//! fn main() {
	59	//! if let Err(err) = do_logic().or_raise(\|\| AppError::Fatal {
	60	//! consequences: "math no longer works",
	61	//! }) {
	62	//! eprintln!("{err:?}");
	63	//! }
	64	//! }
	65	//! ```
	66	//!
	67	//! The above program will print an error message like:
	68	//!
	69	//! ```text
	70	//! fatal error: math no longer works, at exn/src/lib.rs:44:16
	71	//! \|
	72	//! \|-> logic error: 0 == 1, at exn/src/lib.rs:40:5
	73	//! ```
	74
	75	#![cfg_attr(docsrs, feature(doc_cfg))]
	76	#![deny(missing_docs)]
	77
	78	mod debug;
	79	mod display;
	80	mod impls;
	81	mod macros;
	82	mod option;
	83	mod result;
	84
	85	pub use self::impls::Exn;
	86	pub use self::impls::Frame;
	87	pub use self::option::OptionExt;
	88	pub use self::result::Result;
	89	pub use self::result::ResultExt;
	90
	91	/// A trait bound of the supported error type of [`Exn`].
	92	pub trait Error: std::error::Error + std::any::Any + Send + Sync + 'static {
	93	/// Raise this error as a new exception.
	94	#[track_caller]
	95	fn raise(self) -> Exn<Self>
	96	where
	97	Self: Sized,
	98	{
	99	Exn::new(self)
	100	}
	101	}
	102
	103	impl<T> Error for T where T: std::error::Error + std::any::Any + Send + Sync + 'static {}
	104
	105	/// Equivalent to `Ok::<_, Exn<E>>(value)`.
	106	///
	107	/// This simplifies creation of an `exn::Result` in places where type inference cannot deduce the
	108	/// `E` type of the result — without needing to write `Ok::<_, Exn<E>>(value)`.
	109	///
	110	/// One might think that `exn::Result::Ok(value)` would work in such cases, but it does not.
	111	///
	112	/// ```console
	113	/// error[E0282]: type annotations needed for `std::result::Result<i32, E>`
	114	/// --> src/main.rs:11:13
	115	/// \|
	116	/// 11 \| let _ = exn::Result::Ok(1);
	117	/// \| - ^^^^^^^^^^^^^^^ cannot infer type for type parameter `E` declared on the enum `Result`
	118	/// \| \|
	119	/// \| consider giving this pattern the explicit type `std::result::Result<i32, E>`, where the type parameter `E` is specified
	120	/// ```
	121	#[expect(non_snake_case)]
	122	pub fn Ok<T, E: Error>(value: T) -> Result<T, E> {
	123	Result::Ok(value)
	124	}

gix-error/src/exn/src/macros.rs+90−0

@@ -0,0 +1,90 @@
	1	// Copyright 2025 FastLabs Developers
	2	//
	3	// Licensed under the Apache License, Version 2.0 (the "License");
	4	// you may not use this file except in compliance with the License.
	5	// You may obtain a copy of the License at
	6	//
	7	// http://www.apache.org/licenses/LICENSE-2.0
	8	//
	9	// Unless required by applicable law or agreed to in writing, software
	10	// distributed under the License is distributed on an "AS IS" BASIS,
	11	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	12	// See the License for the specific language governing permissions and
	13	// limitations under the License.
	14
	15	/// Creates an [`Exn`] and returns it as [`Result`].
	16	///
	17	/// Shorthand for `return Err(Exn::from(err))`.
	18	///
	19	/// # Examples
	20	///
	21	/// Create an [`Exn`] from [`Error`]:
	22	///
	23	/// [`Exn`]: crate::Exn
	24	/// [`Error`]: std::error::Error
	25	///
	26	/// ```
	27	/// use std::fs;
	28	///
	29	/// use exn::bail;
	30	/// # fn wrapper() -> exn::Result<(), impl exn::Error> {
	31	/// match fs::read_to_string("/path/to/file") {
	32	/// Ok(content) => println!("file contents: {content}"),
	33	/// Err(err) => bail!(err),
	34	/// }
	35	/// # Ok(()) }
	36	/// ```
	37	#[macro_export]
	38	macro_rules! bail {
	39	($err:expr) => {{
	40	return ::std::result::Result::Err($crate::Exn::from($err));
	41	}};
	42	}
	43
	44	/// Ensures `$cond` is met; otherwise return an error.
	45	///
	46	/// Shorthand for `if !$cond { bail!(...); }`.
	47	///
	48	/// # Examples
	49	///
	50	/// Create an [`Exn`] from an [`Error`]:
	51	///
	52	/// [`Exn`]: crate::Exn
	53	/// [`Error`]: std::error::Error
	54	///
	55	/// ```
	56	/// # fn has_permission(_: &u32, _: &u32) -> bool { true }
	57	/// # type User = u32;
	58	/// # let user = 0;
	59	/// # type Resource = u32;
	60	/// # let resource = 0;
	61	/// use std::error::Error;
	62	/// use std::fmt;
	63	///
	64	/// use exn::ensure;
	65	///
	66	/// #[derive(Debug)]
	67	/// struct PermissionDenied(User, Resource);
	68	///
	69	/// impl fmt::Display for PermissionDenied {
	70	/// fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
	71	/// write!(fmt, "permission denied")
	72	/// }
	73	/// }
	74	///
	75	/// impl Error for PermissionDenied {}
	76	///
	77	/// ensure!(
	78	/// has_permission(&user, &resource),
	79	/// PermissionDenied(user, resource),
	80	/// );
	81	/// # Ok(())
	82	/// ```
	83	#[macro_export]
	84	macro_rules! ensure {
	85	($cond:expr, $err:expr $(,)?) => {{
	86	if !bool::from($cond) {
	87	$crate::bail!($err)
	88	}
	89	}};
	90	}

gix-error/src/exn/src/option.rs+45−0

@@ -0,0 +1,45 @@
	1	// Copyright 2025 FastLabs Developers
	2	//
	3	// Licensed under the Apache License, Version 2.0 (the "License");
	4	// you may not use this file except in compliance with the License.
	5	// You may obtain a copy of the License at
	6	//
	7	// http://www.apache.org/licenses/LICENSE-2.0
	8	//
	9	// Unless required by applicable law or agreed to in writing, software
	10	// distributed under the License is distributed on an "AS IS" BASIS,
	11	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	12	// See the License for the specific language governing permissions and
	13	// limitations under the License.
	14
	15	use crate::Error;
	16	use crate::Exn;
	17	use crate::Result;
	18
	19	/// An extension trait for [`Option`] to provide raising new exceptions on `None`.
	20	pub trait OptionExt {
	21	/// The `Some` type.
	22	type Some;
	23
	24	/// Construct a new [`Exn`] on the `None` variant.
	25	fn ok_or_raise<A, F>(self, err: F) -> Result<Self::Some, A>
	26	where
	27	A: Error,
	28	F: FnOnce() -> A;
	29	}
	30
	31	impl<T> OptionExt for Option<T> {
	32	type Some = T;
	33
	34	#[track_caller]
	35	fn ok_or_raise<A, F>(self, err: F) -> Result<T, A>
	36	where
	37	A: Error,
	38	F: FnOnce() -> A,
	39	{
	40	match self {
	41	Some(v) => Ok(v),
	42	None => Err(Exn::new(err())),
	43	}
	44	}
	45	}

gix-error/src/exn/src/result.rs+76−0

@@ -0,0 +1,76 @@
	1	// Copyright 2025 FastLabs Developers
	2	//
	3	// Licensed under the Apache License, Version 2.0 (the "License");
	4	// you may not use this file except in compliance with the License.
	5	// You may obtain a copy of the License at
	6	//
	7	// http://www.apache.org/licenses/LICENSE-2.0
	8	//
	9	// Unless required by applicable law or agreed to in writing, software
	10	// distributed under the License is distributed on an "AS IS" BASIS,
	11	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	12	// See the License for the specific language governing permissions and
	13	// limitations under the License.
	14
	15	use crate::Error;
	16	use crate::Exn;
	17
	18	/// A reasonable return type to use throughout an application.
	19	pub type Result<T, E> = std::result::Result<T, Exn<E>>;
	20
	21	/// An extension trait for [`Result`] to provide context information on [`Exn`]s.
	22	pub trait ResultExt {
	23	/// The `Ok` type.
	24	type Success;
	25
	26	/// The `Err` type that would be wrapped in an [`Exn`].
	27	type Error: Error;
	28
	29	/// Raise a new exception on the [`Exn`] inside the [`Result`].
	30	///
	31	/// Apply [`Exn::raise`] on the `Err` variant, refer to it for more information.
	32	fn or_raise<A, F>(self, err: F) -> Result<Self::Success, A>
	33	where
	34	A: Error,
	35	F: FnOnce() -> A;
	36	}
	37
	38	impl<T, E> ResultExt for std::result::Result<T, E>
	39	where
	40	E: Error,
	41	{
	42	type Success = T;
	43	type Error = E;
	44
	45	#[track_caller]
	46	fn or_raise<A, F>(self, err: F) -> Result<Self::Success, A>
	47	where
	48	A: Error,
	49	F: FnOnce() -> A,
	50	{
	51	match self {
	52	Ok(v) => Ok(v),
	53	Err(e) => Err(Exn::new(e).raise(err())),
	54	}
	55	}
	56	}
	57
	58	impl<T, E> ResultExt for std::result::Result<T, Exn<E>>
	59	where
	60	E: Error,
	61	{
	62	type Success = T;
	63	type Error = E;
	64
	65	#[track_caller]
	66	fn or_raise<A, F>(self, err: F) -> Result<Self::Success, A>
	67	where
	68	A: Error,
	69	F: FnOnce() -> A,
	70	{
	71	match self {
	72	Ok(v) => Ok(v),
	73	Err(e) => Err(e.raise(err())),
	74	}
	75	}
	76	}

gix-error/src/exn/tests/simple.rs+118−0

@@ -0,0 +1,118 @@
	1	// Copyright 2025 FastLabs Developers
	2	//
	3	// Licensed under the Apache License, Version 2.0 (the "License");
	4	// you may not use this file except in compliance with the License.
	5	// You may obtain a copy of the License at
	6	//
	7	// http://www.apache.org/licenses/LICENSE-2.0
	8	//
	9	// Unless required by applicable law or agreed to in writing, software
	10	// distributed under the License is distributed on an "AS IS" BASIS,
	11	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	12	// See the License for the specific language governing permissions and
	13	// limitations under the License.
	14
	15	use exn::Error;
	16	use exn::Exn;
	17	use exn::OptionExt;
	18	use exn::ResultExt;
	19
	20	#[derive(Debug)]
	21	struct SimpleError(&'static str);
	22
	23	impl std::fmt::Display for SimpleError {
	24	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
	25	write!(f, "{}", self.0)
	26	}
	27	}
	28
	29	impl std::error::Error for SimpleError {}
	30
	31	#[test]
	32	fn test_error_straightforward() {
	33	let e1 = SimpleError("E1").raise();
	34	let e2 = e1.raise(SimpleError("E2"));
	35	let e3 = e2.raise(SimpleError("E3"));
	36	let e4 = e3.raise(SimpleError("E4"));
	37	let e5 = e4.raise(SimpleError("E5"));
	38	insta::assert_debug_snapshot!(e5);
	39	}
	40
	41	#[test]
	42	fn test_error_tree() {
	43	let e1 = SimpleError("E1").raise();
	44	let e3 = e1.raise(SimpleError("E3"));
	45
	46	let e9 = SimpleError("E9").raise();
	47	let e10 = e9.raise(SimpleError("E10"));
	48
	49	let e11 = SimpleError("E11").raise();
	50	let e12 = e11.raise(SimpleError("E12"));
	51
	52	let e5 = Exn::from_iter([e3, e10, e12], SimpleError("E5"));
	53
	54	let e2 = SimpleError("E2").raise();
	55	let e4 = e2.raise(SimpleError("E4"));
	56
	57	let e7 = SimpleError("E7").raise();
	58	let e8 = e7.raise(SimpleError("E8"));
	59
	60	let e6 = Exn::from_iter([e5, e4, e8], SimpleError("E6"));
	61	insta::assert_debug_snapshot!(e6);
	62	}
	63
	64	#[test]
	65	fn test_result_ext() {
	66	let result: Result<(), SimpleError> = Err(SimpleError("An error"));
	67	let result = result.or_raise(\|\| SimpleError("Another error"));
	68	insta::assert_debug_snapshot!(result.unwrap_err());
	69	}
	70
	71	#[test]
	72	fn test_option_ext() {
	73	let result: Option<()> = None;
	74	let result = result.ok_or_raise(\|\| SimpleError("An error"));
	75	insta::assert_debug_snapshot!(result.unwrap_err());
	76	}
	77
	78	#[test]
	79	fn test_from_error() {
	80	fn foo() -> exn::Result<(), SimpleError> {
	81	Err(SimpleError("An error"))?;
	82	Ok(())
	83	}
	84
	85	let result = foo();
	86	insta::assert_debug_snapshot!(result.unwrap_err());
	87	}
	88
	89	#[test]
	90	fn test_bail() {
	91	fn foo() -> exn::Result<(), SimpleError> {
	92	exn::bail!(SimpleError("An error"));
	93	}
	94
	95	let result = foo();
	96	insta::assert_debug_snapshot!(result.unwrap_err());
	97	}
	98
	99	#[test]
	100	fn test_ensure_ok() {
	101	fn foo() -> exn::Result<(), SimpleError> {
	102	exn::ensure!(true, SimpleError("An error"));
	103	Ok(())
	104	}
	105
	106	foo().unwrap();
	107	}
	108
	109	#[test]
	110	fn test_ensure_fail() {
	111	fn foo() -> exn::Result<(), SimpleError> {
	112	exn::ensure!(false, SimpleError("An error"));
	113	Ok(())
	114	}
	115
	116	let result = foo();
	117	insta::assert_debug_snapshot!(result.unwrap_err());
	118	}

gix-error/src/exn/tests/snapshots/simple__bail.snap+5−0

@@ -0,0 +1,5 @@
	1	---
	2	source: exn/tests/simple.rs
	3	expression: result.unwrap_err()
	4	---
	5	An error, at exn/tests/simple.rs:92:9

gix-error/src/exn/tests/snapshots/simple__ensure_fail.snap+5−0

@@ -0,0 +1,5 @@
	1	---
	2	source: exn/tests/simple.rs
	3	expression: result.unwrap_err()
	4	---
	5	An error, at exn/tests/simple.rs:112:9

gix-error/src/exn/tests/snapshots/simple__error_straightforward.snap+13−0

@@ -0,0 +1,13 @@
	1	---
	2	source: exn/tests/simple.rs
	3	expression: e5
	4	---
	5	E5, at exn/tests/simple.rs:37:17
	6	\|
	7	\|-> E4, at exn/tests/simple.rs:36:17
	8	\|
	9	\|-> E3, at exn/tests/simple.rs:35:17
	10	\|
	11	\|-> E2, at exn/tests/simple.rs:34:17
	12	\|
	13	\|-> E1, at exn/tests/simple.rs:33:32

gix-error/src/exn/tests/snapshots/simple__error_tree.snap+27−0

@@ -0,0 +1,27 @@
	1	---
	2	source: exn/tests/simple.rs
	3	expression: e6
	4	---
	5	E6, at exn/tests/simple.rs:60:14
	6	\|
	7	\|-> E5, at exn/tests/simple.rs:52:14
	8	\| \|
	9	\| \|-> E3, at exn/tests/simple.rs:44:17
	10	\| \| \|
	11	\| \| \|-> E1, at exn/tests/simple.rs:43:32
	12	\| \|
	13	\| \|-> E10, at exn/tests/simple.rs:47:18
	14	\| \| \|
	15	\| \| \|-> E9, at exn/tests/simple.rs:46:32
	16	\| \|
	17	\| \|-> E12, at exn/tests/simple.rs:50:19
	18	\| \|
	19	\| \|-> E11, at exn/tests/simple.rs:49:34
	20	\|
	21	\|-> E4, at exn/tests/simple.rs:55:17
	22	\| \|
	23	\| \|-> E2, at exn/tests/simple.rs:54:32
	24	\|
	25	\|-> E8, at exn/tests/simple.rs:58:17
	26	\|
	27	\|-> E7, at exn/tests/simple.rs:57:32

gix-error/src/exn/tests/snapshots/simple__from_error.snap+5−0

@@ -0,0 +1,5 @@
	1	---
	2	source: exn/tests/simple.rs
	3	expression: result.unwrap_err()
	4	---
	5	An error, at exn/tests/simple.rs:81:9

gix-error/src/exn/tests/snapshots/simple__option_ext.snap+5−0

@@ -0,0 +1,5 @@
	1	---
	2	source: exn/tests/simple.rs
	3	expression: result.unwrap_err()
	4	---
	5	An error, at exn/tests/simple.rs:74:25

gix-error/src/exn/tests/snapshots/simple__result_ext.snap+7−0

@@ -0,0 +1,7 @@
	1	---
	2	source: exn/tests/simple.rs
	3	expression: result.unwrap_err()
	4	---
	5	Another error, at exn/tests/simple.rs:67:25
	6	\|
	7	\|-> An error, at exn/tests/simple.rs:67:25

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

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code