Type inference fails when using associated type in traits

[StealthyKamereon]

Hello
I have noticed type inference fails in a case that seem rather obvious to solve.
Here is a link to a minimal reproduction project: https://github.com/StealthyKamereon/repro_bug_try_into/tree/master

The failure occurred when matching on the function TryInto::try_into: the inference is able to resolve the type of the Ok variant but not the Err one.

I tried this code:

fn repro() -> A {
    let b = B;
    // let a: A = match b.try_into() { // Compiles just fine
    let a = match b.try_into() { // Doesn't compile
        Ok(a) => a,
        Err(e) => { // e is unknown
            println!("Error converting: {:?}", e.to_string()); // e.to_string fails
            return A;
        }
    };
    a
}

struct A;

struct B;

#[derive(Debug)]
struct ConversionError;

impl Display for ConversionError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "Error")
    }
}

impl TryFrom<B> for A {
    type Error = ConversionError;
    fn try_from(_value: B) -> Result<Self, Self::Error> {
        Ok(A)
    }
}

I expected to see this happen: The compiler should be able to know that e is ConversionError because a is bound to A by the function signature.

Instead, this happened: The compiler cannot resolve the type of e.

Meta

rustc --version --verbose:

rustc 1.85.0 (4d91de4e4 2025-02-17)
binary: rustc
commit-hash: 4d91de4e48198da2e33413efdcd9cd2cc0c46688
commit-date: 2025-02-17
host: x86_64-pc-windows-msvc
release: 1.85.0
LLVM version: 19.1.7

Backtrace

error[E0282]: type annotations needed
  --> src\main.rs:14:48
   |
14 |             println!("Error converting: {:?}", e.to_string());
   |                                                ^ cannot infer type

For more information about this error, try `rustc --explain E0282`.
error: could not compile `repro_bug_try_into` (bin "repro_bug_try_into") due to 1 previous error

[theemathas]

Minimized to not depend on the TryFrom/TryInto traits from std:

fn main() {
    // Annotating `z: ToType` makes it compile
    let z = match FromType.convert() {
        Ok(y) => y,
        Err(e) => {
            // Commenting this out makes it compile
            e.is_conversion_error();
            unreachable!()
        }
    };
    let _: ToType = z;
}

struct ConversionError;
impl ConversionError {
    fn is_conversion_error(&self) {}
}

struct FromType;
struct ToType;
struct OtherType;

trait Convert<T> {
    type Error;
    fn convert(self) -> Result<T, Self::Error>;
}

impl Convert<ToType> for FromType {
    type Error = ConversionError;
    fn convert(self) -> Result<ToType, Self::Error> {
        Ok(ToType)
    }
}

impl Convert<OtherType> for FromType {
    type Error = i32;
    fn convert(self) -> Result<OtherType, Self::Error> {
        Ok(OtherType)
    }
}

error[E0282]: type annotations needed
 --> src/main.rs:7:13
  |
7 |             e.is_conversion_error();
  |             ^ cannot infer type

For more information about this error, try `rustc --explain E0282`.