Unexpected lifetime issue when comparing Option<&i32>

[CasualX]

I tried this code:

fn check(a: Option<&i32>, b: &i32) -> bool {
    a == Some(b)
}

I expected to see this happen: Code compiles and works as expected.

Switching the equality around like this compiles successfully and works as expected:

fn check(a: Option<&i32>, b: &i32) -> bool {
    Some(b) == a
}

Alternatively explicitly forcing both references to a shared lifetime works too:

fn check<'c>(a: Option<&'c i32>, b: &'c i32) -> bool {
    a == Some(b)
}

Instead, this happened: error[E0495]: cannot infer an appropriate lifetime for automatic coercion due to conflicting requirements

Meta

https://play.rust-lang.org/?gist=9bd7c205c280df1ea37bb49cd3ecca25&version=stable&backtrace=0

[tirr-c]

The compiler says that this code, with explicit lifetime parameters, has a type mismatch between Option<&'a i32> and Option<&'b i32>:

fn check<'a, 'b>(a: Option<&'a i32>, b: &'b i32) -> bool {
    let tmp: Option<&'b i32> = Some(b);
    a == tmp //< mismatched types
}

It says 'b should outlive 'a, and the bound is not needed when we compare two simple references. Kinda confusing; anyway, as said, I added a lifetime bound.

fn check<'a, 'b>(a: Option<&'a i32>, b: &'b i32) -> bool where 'b: 'a {
    let tmp: Option<&'b i32> = Some(b);
    a == tmp
}

And it compiles well.

What's strange is, PartialEq here cannot be symmetric; following code doesn't compile.

fn check<'a, 'b>(a: Option<&'a i32>, b: &'b i32) -> bool where 'b: 'a {
    let tmp: Option<&'b i32> = Some(b);
    let eq1 = a == tmp;
    let eq2 = tmp == a; //< mismatched types
    assert_eq!(eq1, eq2);
    eq1
}

This is definitely wrong.

[tirr-c]

More testcases. This works well:

fn should_equal<'a, 'b>(a: Option<&'a usize>, b: &'b usize) {
    let b = Some(b);
    assert_eq!(a, b);
    assert_eq!(b, a);
}

However, this fails compiling:

fn should_equal<'a, 'b>(a: Option<&'a usize>, b: &'b usize) {
    let b = Some(b);
    assert!(a == b);
    assert!(b == a);
}

[oli-obk]

The PartialEq impl for Option is derived. This sounds like a bug with derive

[fintelia]

This is the code generated by derive:

#[automatically_derived]
#[allow(unused_qualifications)]
#[stable(feature = "rust1", since = "1.0.0")]
impl <T: ::std::cmp::PartialEq> ::std::cmp::PartialEq for Option<T> {
    #[inline]
    fn eq(&self, __arg_0: &Option<T>) -> bool {
        {
            let __self_vi =
                unsafe { ::std::intrinsics::discriminant_value(&*self) } as
                    isize;
            let __arg_1_vi =
                unsafe { ::std::intrinsics::discriminant_value(&*__arg_0) } as
                    isize;
            if true && __self_vi == __arg_1_vi {
                match (&*self, &*__arg_0) {
                    (&Option::Some(ref __self_0),
                     &Option::Some(ref __arg_1_0)) =>
                    true && (*__self_0) == (*__arg_1_0),
                    _ => true,
                }
            } else { false }
        }
    }
    #[inline]
    fn ne(&self, __arg_0: &Option<T>) -> bool {
        {
            let __self_vi =
                unsafe { ::std::intrinsics::discriminant_value(&*self) } as
                    isize;
            let __arg_1_vi =
                unsafe { ::std::intrinsics::discriminant_value(&*__arg_0) } as
                    isize;
            if true && __self_vi == __arg_1_vi {
                match (&*self, &*__arg_0) {
                    (&Option::Some(ref __self_0),
                     &Option::Some(ref __arg_1_0)) =>
                    false || (*__self_0) != (*__arg_1_0),
                    _ => false,
                }
            } else { true }
        }
    }
}

[fintelia]

And a "simpler" case that generates the same error:

pub struct Foo<'a>(&'a usize);

impl<'a> ::std::cmp::PartialEq for Foo<'a> {
    fn eq(&self, _: &Foo<'a>) -> bool { true  }
    fn ne(&self, _: &Foo<'a>) -> bool { false  }
}

fn should_equal<'a, 'b>(a: Foo<'a>, b: &'b usize) {
    assert!(a == Foo(b));
}

[PlasmaPower]

This appears to be a problem with the equal operator, not the PartialEq implementation or trait, as this works fine: https://play.rust-lang.org/?gist=32afb56e08f6d275711698f0a4fc7f61&version=stable&backtrace=0

fn check(a: Option<&i32>, b: &i32) -> bool {
    a.eq(&Some(b))
}

[CasualX]

This issue looks resolved? The error no longer occurs when I try my example in the playground.

However I've no idea when, why or what caused the issue. Can anyone confirm as fixed?

[matthewjasper]

Fix was probably #45435

[CasualX]

that sounds plausible, I'll close this issue then