Avoid unnecessary allocations

Author: Flix

src/error.rs

@@ -1,21 +1,21 @@
 //! Error type implementation.
 
-use ::alloc::{string::ToString, vec};
+use ::alloc::{borrow::Cow, boxed::Box, vec, vec::Vec};
 use ::core::{
 	any::Any,
 	error::Error,
 	fmt::{Debug, Display, Formatter, Result as FmtResult},
 	panic::Location,
 };
 
-use crate::features::{AnyDebugSendSync, Box, ErrorSendSync, String, Vec};
+use crate::features::{AnyDebugSendSync, ErrorSendSync};
 
 /// Error information for humans.
 /// Error message with location information.
 #[derive(Debug)]
 pub(crate) struct HumanInfo {
 	/// Message text.
-	pub(crate) message: String,
+	pub(crate) message: Cow<'static, str>,
 	/// Location of occurrence.
 	pub(crate) location: &'static Location<'static>,
 }
@@ -37,9 +37,9 @@ pub(crate) enum Info {
 	/// Contextual information for machines.
 	Machine(MachineInfo),
 }
-// Ensure size of Context is as expected. Can be adjusted though.
+// Ensure niche-optimization is active.
 const _: () = {
-	assert!(size_of::<Info>() == 32);
+	assert!(size_of::<Info>() == size_of::<HumanInfo>());
 };
 
 /// Generic rich error type for use within `Result`s, for libraries and applications.
@@ -138,27 +138,26 @@ impl CtxError {
 	#[track_caller]
 	#[must_use]
 	#[inline]
-	pub fn new<T: ToString>(message: T) -> Self {
-		let infos = vec![Info::Human(HumanInfo {
-			message: message.to_string(),
-			location: Location::caller(),
-		})];
+	pub fn new<C>(context: C) -> Self
+	where
+		C: Into<Cow<'static, str>>,
+	{
+		let infos =
+			vec![Info::Human(HumanInfo { message: context.into(), location: Location::caller() })];
 		Self(CtxErrorImpl { infos, ..Default::default() })
 	}
 
 	/// Create new error from source error.
 	#[track_caller]
 	#[must_use]
 	#[inline]
-	pub fn new_with_source<T, E>(message: T, source: E) -> Self
+	pub fn new_with_source<C, E>(context: C, source: E) -> Self
 	where
-		T: ToString,
+		C: Into<Cow<'static, str>>,
 		E: ErrorSendSync + 'static,
 	{
-		let infos = vec![Info::Human(HumanInfo {
-			message: message.to_string(),
-			location: Location::caller(),
-		})];
+		let infos =
+			vec![Info::Human(HumanInfo { message: context.into(), location: Location::caller() })];
 		Self(CtxErrorImpl { infos, source: Some(Box::new(source)) })
 	}
 
@@ -178,7 +177,7 @@ impl CtxError {
 	#[inline]
 	pub fn context<C>(self, context: C) -> Self
 	where
-		C: ToString,
+		C: Into<Cow<'static, str>>,
 	{
 		Self(self.0.context(context))
 	}
@@ -265,9 +264,9 @@ impl CtxErrorImpl {
 	#[inline]
 	pub fn context<C>(mut self, context: C) -> Self
 	where
-		C: ToString,
+		C: Into<Cow<'static, str>>,
 	{
-		let context = HumanInfo { message: context.to_string(), location: Location::caller() };
+		let context = HumanInfo { message: context.into(), location: Location::caller() };
 		self.infos.push(Info::Human(context));
 		self
 	}
@@ -292,20 +291,34 @@ impl CtxErrorImpl {
 	/// This will override existing attachments of the same type. If you want to add attachments of
 	/// the same type, use `attach` instead.
 	#[must_use]
-	pub fn attach_override<C>(mut self, context: C) -> Self
+	pub fn attach_override<C>(mut self, mut context: C) -> Self
 	where
 		C: AnyDebugSendSync + 'static,
 	{
-		let context = MachineInfo { attachment: Box::new(context) };
-		self.infos.retain(|info| match info {
-			Info::Human(_) => true,
+		let mut inserted = false;
+		#[expect(trivial_casts, reason = "Not that trivial as it seems? False positive")]
+		self.infos.retain_mut(|info| match info {
 			Info::Machine(ctx) => {
-				#[expect(trivial_casts, reason = "Not that trivial as it seems? False positive")]
-				let any = (ctx.attachment.as_ref()) as &(dyn Any + 'static);
-				!any.is::<C>()
+				if let Some(content) =
+					(ctx.attachment.as_mut() as &mut (dyn Any + 'static)).downcast_mut::<C>()
+				{
+					if !inserted {
+						core::mem::swap(content, &mut context);
+						inserted = true;
+						true // First attachment of same type, was replaced with new value, so keep it.
+					} else {
+						false // Another attachment of the same type, remove duplicate.
+					}
+				} else {
+					true // Attachment of different type.
+				}
 			}
+			_ => true,
 		});
-		self.infos.push(Info::Machine(context));
+		if !inserted {
+			// No existing attachment of the same type was found to be replaced, so add a new one.
+			self.infos.push(Info::Machine(MachineInfo { attachment: Box::new(context) }));
+		}
 		self
 	}
 

src/features.rs

@@ -42,11 +42,3 @@ impl<T: Any + Debug + SendSync> AnyDebugSendSync for T {}
 /// Error trait with send/sync.
 pub trait ErrorSendSync: Error + SendSync {}
 impl<T: Error + SendSync> ErrorSendSync for T {}
-
-
-/// Box type.
-pub type Box<T> = alloc::boxed::Box<T>;
-/// Vec type for stacks.
-pub type Vec<T> = alloc::vec::Vec<T>;
-/// String type.
-pub type String = alloc::string::String;

src/results.rs

@@ -1,6 +1,6 @@
 //! Helpers on `Result` types for conversion and context addition.
 
-use ::alloc::string::ToString;
+use ::alloc::borrow::Cow;
 
 use crate::{
 	CtxError,
@@ -14,15 +14,15 @@ pub trait CtxResultExt: Sized {
 	#[must_use]
 	fn context<C>(self, context: C) -> Self
 	where
-		C: ToString;
+		C: Into<Cow<'static, str>>;
 
 	/// Add human context to the error via a closure.
 	#[track_caller]
 	#[must_use]
 	fn context_with<F, C>(self, context_fn: F) -> Self
 	where
 		F: FnOnce() -> C,
-		C: ToString;
+		C: Into<Cow<'static, str>>;
 
 	/// Add machine context to the error.
 	///
@@ -68,7 +68,7 @@ impl<T> CtxResultExt for Result<T, CtxError> {
 	#[inline]
 	fn context<C>(self, context: C) -> Self
 	where
-		C: ToString,
+		C: Into<Cow<'static, str>>,
 	{
 		// Cannot use `map_err` because closures cannot have `#[track_caller]` yet.
 		match self {
@@ -82,7 +82,7 @@ impl<T> CtxResultExt for Result<T, CtxError> {
 	fn context_with<F, C>(self, context_fn: F) -> Self
 	where
 		F: FnOnce() -> C,
-		C: ToString,
+		C: Into<Cow<'static, str>>,
 	{
 		// Cannot use `map_err` because closures cannot have `#[track_caller]` yet.
 		match self {
@@ -133,14 +133,14 @@ pub trait ConvertResult<T, E>: Sized {
 	#[track_caller]
 	fn context<C>(self, context: C) -> Result<T, CtxError>
 	where
-		C: ToString;
+		C: Into<Cow<'static, str>>;
 
 	/// Add human context to the error via a closure.
 	#[track_caller]
 	fn context_with<F, C>(self, context_fn: F) -> Result<T, CtxError>
 	where
 		F: FnOnce(&E) -> C,
-		C: ToString;
+		C: Into<Cow<'static, str>>;
 
 	/// Add machine context to the error.
 	///
@@ -185,7 +185,7 @@ where
 	#[inline]
 	fn context<C>(self, context: C) -> Result<T, CtxError>
 	where
-		C: ToString,
+		C: Into<Cow<'static, str>>,
 	{
 		// Cannot use `map_err` because closures cannot have `#[track_caller]` yet.
 		match self {
@@ -199,7 +199,7 @@ where
 	fn context_with<F, C>(self, context_fn: F) -> Result<T, CtxError>
 	where
 		F: FnOnce(&E) -> C,
-		C: ToString,
+		C: Into<Cow<'static, str>>,
 	{
 		// Cannot use `map_err` because closures cannot have `#[track_caller]` yet.
 		match self {
@@ -259,14 +259,14 @@ pub trait ConvertOption<T>: Sized {
 	#[track_caller]
 	fn context<C>(self, context: C) -> Result<T, CtxError>
 	where
-		C: ToString;
+		C: Into<Cow<'static, str>>;
 
 	/// Convert `None` to an error and add human context to the error via a closure.
 	#[track_caller]
 	fn context_with<F, C>(self, context_fn: F) -> Result<T, CtxError>
 	where
 		F: FnOnce() -> C,
-		C: ToString;
+		C: Into<Cow<'static, str>>;
 
 	/// Convert `None` to an error and add machine context to the error.
 	///
@@ -308,7 +308,7 @@ impl<T> ConvertOption<T> for Option<T> {
 	#[inline]
 	fn context<C>(self, context: C) -> Result<T, CtxError>
 	where
-		C: ToString,
+		C: Into<Cow<'static, str>>,
 	{
 		// Cannot use `ok_or_else` because closures cannot have `#[track_caller]` yet.
 		match self {
@@ -322,7 +322,7 @@ impl<T> ConvertOption<T> for Option<T> {
 	fn context_with<F, C>(self, context_fn: F) -> Result<T, CtxError>
 	where
 		F: FnOnce() -> C,
-		C: ToString,
+		C: Into<Cow<'static, str>>,
 	{
 		// Cannot use `ok_or_else` because closures cannot have `#[track_caller]` yet.
 		match self {

src/tests.rs

@@ -1,6 +1,6 @@
 //! Crate tests.
 
-use ::alloc::{format, vec::Vec};
+use ::alloc::{borrow::ToOwned, format, vec::Vec};
 use ::core::{
 	error::Error,
 	fmt::{Display, Formatter, Result as FmtResult},
@@ -95,9 +95,10 @@ fn error_wrapper() {
 	assert!(error.source().is_some());
 }
 
+/// Make sure all the usual types work as context messages.
 #[test]
 fn context() {
-	let error = CtxError::new("0").context("1").context("2");
+	let error = CtxError::new("0").context("1".to_owned()).context("2");
 	let mut numbers = error.contexts().map(|ctx| ctx.message.parse::<u8>().unwrap());
 	assert_eq!(numbers.next(), Some(2));
 	assert_eq!(numbers.next(), Some(1));