Add internal io::Error::new_const to avoid allocations.

[m-ou-se]

This makes it possible to have a io::Error containing a message with zero allocations, and uses that everywhere to avoid the three allocations involved in io::Error::new(kind, "message").

The function signature isn't perfect, because it needs a reference to the &str. So for now, this is just a pub(crate) function. Later, we'll be able to use fn new_const<MSG: &'static str>(kind: ErrorKind) to make that a bit better. (Then we'll also be able to use some ZST trickery if that would result in more efficient code.)

See #83352

[rust-highfive]

r? @kennytm

(rust-highfive has picked a reviewer for you, use r? to override)

[the8472]

There also is a typo in the PR title.

[jyn514]

This seems like a good use case for specialization.

[m-ou-se]

This seems like a good use case for specialization.

We spent quite a while with several people trying to use specialization here. If you find a way to do this in a nicer way with specialization, let me know. ^^

[mystor]

This seems like a good use case for specialization.

Unfortunately the signature of io::Error::new takes an E: Into<Box<dyn Error + Send + Sync>> with no other bounds, meaning &'a str is a valid argument for any 'a. It's impossible to specialize on lifetimes, so io::Error::new can never be specialized for &'static str.

[nagisa]

@bors r+

[bors]

📌 Commit 6bbcc5b has been approved by nagisa

[Frago9876543210]

Another problem is that some crates still depends on Error::new(). So, this PR reduces only stdlib allocations. The only solution one can think of is a smart-pointer like Cow. I.e. need to be done so that Into<Box<dyn Error + ...>> actually allocates memory in needed cases.

pub enum ThinBox<'a, T> {
    Borrowed(&'a T),
    Owned(Box<T>),
}

fn main() {
    dbg!(std::mem::size_of::<ThinBox<'static, &'static str>>()); //16
}

However, now it is not clear how not to break Error::into_inner().

impl Error {
    pub fn into_inner(self) -> Option<Box<dyn Error + Send + Sync>> { ... }
}

cc @m-ou-se

[m-ou-se]

Another problem is that some crates still depends on Error::new().

@Frago9876543210 We can't fix std::io::Error::new(kind, "some_str") to avoid allocations, since that's the exact same function as in std::io::Error::new(kind, tmp) where tmp is a &'a str that doesn't live for 'static. That works because the entire string is copied onto the heap. There's no way to specialize on lifetimes, so in order to support e.g. std::io::Error::new(kind, &format!("{}", 123)), the version with a string literal will have to keep doing the same.

The only way to provide this to other crates is by adding a new function (or new type), which requires crates to update their code. We could make the new_const introduced here public, or wait until const &str generics are a thing if we want to use that syntax instead.