#[derive(PartialEq)] fails to compile with an Arc<Trait> field

[sfackler]

use std::sync::Arc;
use std::fmt;
use std::cmp::PartialEq;

trait Foo {}

impl PartialEq for Foo {
    fn eq(&self, other: &Foo) -> bool {
        true
    }
}

type Bar = Arc<Foo>;

#[derive(PartialEq)]
struct Baz {
    bar: Bar,
}

fn main() {}

error[E0507]: cannot move out of borrowed content
  --> foo.rs:17:5
   |
17 |     bar: Bar,
   |     ^^^^^^^^ cannot move out of borrowed content

error[E0507]: cannot move out of borrowed content
  --> foo.rs:17:5
   |
17 |     bar: Bar,
   |     ^^^^^^^^ cannot move out of borrowed content

error: aborting due to 2 previous errors

Expanded:

#![feature(prelude_import)]
#![no_std]
#[prelude_import]
use std::prelude::v1::*;
#[macro_use]
extern crate std as std;
use std::sync::Arc;
use std::fmt;
use std::cmp::PartialEq;

trait Foo { }

impl PartialEq for Foo {
    fn eq(&self, other: &Foo) -> bool { true }
}

type Bar = Arc<Foo>;

struct Baz {
    bar: Bar,
}
#[automatically_derived]
#[allow(unused_qualifications)]
impl ::std::cmp::PartialEq for Baz {
    #[inline]
    fn eq(&self, __arg_0: &Baz) -> bool {
        match *__arg_0 {
            Baz { bar: ref __self_1_0 } =>
            match *self {
                Baz { bar: ref __self_0_0 } =>
                true && (*__self_0_0) == (*__self_1_0),
            },
        }
    }
    #[inline]
    fn ne(&self, __arg_0: &Baz) -> bool {
        match *__arg_0 {
            Baz { bar: ref __self_1_0 } =>
            match *self {
                Baz { bar: ref __self_0_0 } =>
                false || (*__self_0_0) != (*__self_1_0),
            },
        }
    }
}

fn main() { }

[sfackler]

The derefs of the __self_1_0 fields appear to be the issues - we should just be able to remove those from the derived output since references forward equality, right?

[stephaneyfx]

It looks related to #31740.

[dtolnay]

Same thing for Box<Trait> as reported in #47823.

trait Trait {}

impl PartialEq for Box<Trait> {
    fn eq(&self, _: &Box<Trait>) -> bool {
        false
    }
}

#[derive(PartialEq)]
struct S(Box<Trait>);

The generated code looks like:

impl PartialEq for S {
    fn eq(&self, rhs: &S) -> bool {
        match *rhs {
            S(ref rhs) => match *self {
                S(ref lhs) => true && (*lhs) == (*rhs)
            }
        }
    }
}

error[E0507]: cannot move out of borrowed content
  --> src/main.rs:18:49
   |
18 |                 S(ref lhs) => true && (*lhs) == (*rhs)
   |                                                 ^^^^^^ cannot move out of borrowed content

[shepmaster]

This seems like a duplicate of #31740, as @stephaneyfx mentioned. Any reason to not close it as such?

[daboross]

It should be possible to fix this issue without fixing the underlying one though, right?

I'd appreciate it if this was fixed to work in #[derive(PartialEq)] even if regular == still failed.

Ideally it would also be nice to get an error message that this comes from #[derive(PartialEq)] in cases like this - not sure how possible that is, though. It was at least a bit confusing running into this error just on the field itself, and having to do elimination to find out that it was PartialEq doing it.

[Diggsey]

Ugh, just ran into this today 😢

[spease]

I'm also getting this.

[TheNeikos]

I just ran into this problem and solved it (for now) by using a newtype like this:

Where before I had:

#[derive(PartialEq)
struct Foo(Box<dyn Trait>);

I now have:

struct BoxedTrait(Box<dyn Trait>);

impl PartialEq for BoxedTrait {
   fn eq(&self, other: &Self) -> bool {
    <Box<dyn Trait> as PartialEq>::eq(&self.0, &other.0)
  }
}

#[derive(PartialEq)
struct Foo(BoxedTrait);

[ColonelThirtyTwo]

Also ran into this. Though unlike the other examples, I was implementing PartialEq on the dynamic trait object itself rather than Box<Trait>.

[garfieldnate]

I'm also struggling with this; I tried the solution from @TheNeikos, but Rust tells me that the 0 field of Box is private. Can I use something else instead of the 0 field?

[garfieldnate]

I went with this to achieve simple pointer equality:

use std::ptr;
type BoxedMyTrait = Box<dyn MyTrait>;

impl PartialEq for BoxedMyTrait {
	fn eq(&self, other: &Self) -> bool {
		ptr::eq(self as *const _, other as *const _)
	}
}

[daboross]

@garfieldnate @TheNeikos's solution is for a tuple struct with a single field. The .0 here isn't accessing .0 of a box, but .0 of the tuple struct (in other words, the box).

I believe your situation is a different issue.

[Enselic]

Triage: Let's close as duplicate to duplicate of #31740. It seems much to fix the underlying issue rather than special casing a fix for just #[derive(PartialEq)].