Add impl Into<!> for Infallible

[faern]

It's currently possible to convert a never (!) type instance into Infallible (impl From<!> for Infallible). But not the other way around. That means that the (unstable) methods Result::into_ok and Result::into_err (tracking issue: #61695) that use the trait bounds Into<!> will currently not work when you have a Result<Infallible, _> or Result<_, Infallible>.

I tried to implement impl From<Infallible> for ! and ended up with a number of compilation errors like these:

error[E0277]: `?` couldn't convert the error to `!`
   --> compiler/rustc_serialize/src/opaque.rs:151:33
    |
151 |         self.emit_usize(v.len())?;
    |                                 ^ the trait `From<()>` is not implemented for `!`

I found in the git history that this was attempted previously, in commit b2cf9a0 in PR #58302 by @SimonSapin. And the problem is brought up in comment #58302 (comment) but no solution or discussion followed. I also don't understand the error. Is this the same inference problem that is currently preventing the never type from becoming stable? Clearly, custom never tokens can implement conversion into !, just not the standard Infallible one?

I then tried impl Into<!> for Infallible instead. And it seems to work. In the future when ! is (hopefully) stabilized, this impl can just be removed, as it will be covered by by the blanket implementation impl<T> From<T> for T. I know that manually implementing Into is not recommended. But as far as I know it's also not forbidden? This might be a legitimate case where we need it, since the corresponding From does not work?

I'm not sure if this could complicate the stabilization of the never type maybe? If so, we should likely not merge this. As I'm really hoping to get the proper never type on stable sometime. Ping @nikomatsakis, since I think you are still looking into that?

I tagged it as #[stable] directly. My understanding is that trait impls can't be unstable? Please advice on how to proceed here if this is wrong. Is an RFC needed?

Alternative solution (for Result::{into_ok, into_err} specifically)

For the into_ok and into_err methods specifically there is another way to make them work on stable before ! is stabilized. The trait bounds can be changed from Into<!> to Into<Infallible. Since the conversion between the types work that way it will continue to be usable on nightly for the real never type, and it will allow stable to use the methods with Infallible. But unless there are reasons we don't want Infallible to be convertible to the real never type, I think this is cleaner and more useful for Infallible in general.

[rust-highfive]

r? @kennytm

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

[nikomatsakis]

I'm tagging this as T-lang too because of the interaction with the never type fallback story (which btw we plan to try and advance soon...).

[crlf0710]

Triage: It seems further work on never type work will make this PR obsolete. I'll mark this as blocked for now.

[scottmcm]

But unless there are reasons we don't want Infallible to be convertible to the real never type

The goal is that as part of the stabilization, Infallible will become just type Infallible = !; so that all the crates working with Infallible today (such as implementing their traits on it) will just naturally support ! immediately.

[JohnCSimon]

@faern
Ping from triage: I'm closing this due to inactivity, Please reopen when you are ready to continue with this.
Note: if you do please open the PR BEFORE you push to it, else you won't be able to reopen - this is a quirk of github.
Thanks for your contribution.

@rustbot label: +S-inactive