Regression in Error conversion from Infallible

[alexcrichton]

The following code:

use std::convert::{TryFrom, Infallible};

struct E;

impl From<Infallible> for E {
    fn from(_: Infallible) -> E {
        E
    }
}

fn foo() -> Result<(), E> {
    u32::try_from(1u32)?;
    Ok(())
}

compiles on stable but fails to compile on nightly with:

error[E0277]: `?` couldn't convert the error to `E`
  --> src/lib.rs:13:24
   |
13 |     u32::try_from(1u32)?;
   |                        ^ the trait `std::convert::From<()>` is not implemented for `E`
   |
   = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
   = help: the following implementations were found:
             <E as std::convert::From<!>>
   = note: required by `std::convert::From::from`

This was discovered through bytecodealliance/wasmtime#633

[alexcrichton]

Bisection reveals #66607 as the cause, likely #65355

[SimonSapin]

Reduced:

struct E;

impl From<!> for E {
    fn from(_: !) -> E {
        E
    }
}

#[allow(unreachable_code)]
fn foo(never: !) {
    <E as From<!>>::from(never);  // Ok
    <E as From<_>>::from(never);  // Inference fails here
}

(Playground)

[Centril]

(Adding #![feature(never_type_fallback)] resolves the issue.)

[SimonSapin]

The above went through this doc-comment of the desugaring of foo?, which wasn’t easy to find:

rust/src/librustc/hir/lowering/expr.rs

Lines 1199 to 1209 in 91642e3

	/// Desugar `ExprKind::Try` from: `<expr>?` into:
	/// ```rust
	/// match Try::into_result(<expr>) {
	/// Ok(val) => #[allow(unreachable_code)] val,
	/// Err(err) => #[allow(unreachable_code)]
	/// // If there is an enclosing `try {...}`:
	/// break 'catch_target Try::from_error(From::from(err)),
	/// // Otherwise:
	/// return Try::from_error(From::from(err)),
	/// }
	/// ```

[SimonSapin]

(Adding #![feature(never_type_fallback)] resolves the issue.)

That explains where the () comes from, thanks. But it’s not clear to me why fallback should happen in the first place in this code.

[Centril]

Unclear to me also; cc @nikomatsakis and @arielb1 -- also cc #65992

[acfoltzer]

The same result also occurs when the desired error type is transitively From<!>, which seems to come up pretty commonly in the wild since std errors like TryFromIntError are From<!>:

use std::convert::{TryFrom};

struct E;

impl From<!> for E {
    fn from(_: !) -> E {
        E
    }
}

struct F;

impl From<E> for F {
    fn from(_: E) -> F {
        F
    }
}

fn foo() -> Result<(), F> {
    u32::try_from(1u32)?;
    Ok(())
}

error[E0277]: `?` couldn't convert the error to `F`
  --> src/lib.rs:20:24
   |
20 |     u32::try_from(1u32)?;
   |                        ^ the trait `std::convert::From<()>` is not implemented for `F`
   |
   = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
   = help: the following implementations were found:
             <F as std::convert::From<E>>
   = note: required by `std::convert::From::from`

[SimonSapin]

@acfoltzer Your example legitimately does not compile, although the error message is wrong in Nightly because of this bug. From conversions have never worked transitively. The impl From<!> for E does not affect your example, you get the same results without it. The ! here comes from <u32 as TryFrom<u32>>::Error