assert_eq!(a,b) fails to compile for slices while assert!(a == b) works fine

[gnzlbg]

Example (playground):

pub fn foo(xs: &[u32], k: u32) -> (&[u32], u32) { (xs, 0) }
fn main() {
    assert!(foo(&[], 10) == (&[], 0));  // OK
    assert_eq!(foo(&[], 10), (&[], 0));  // FAILS
}

[shepmaster]

&[] isn't a slice, it's a reference to an array:

  = note: expected type `(&[u32], u32)`
             found type `(&[_; 0], {integer})`

[gnzlbg]

Yes, but assert! succeeds because there is a PartialEq implementation for slices and arrays. For some reason assert_eq! is not invoking that one here (and per the docs it says it does).

[shepmaster]

and per the docs it says it does

It does, but it does other things first. Macro expanded and then hand-cleaned:

fn main() {
    if !(foo(&[], 10) == (&[], 0)) {
        panic!();
    };

    match (&foo(&[], 10), &(&[], 0)) {
        (left_val, right_val) => {
            if !(*left_val == *right_val) {
                panic!()
            }
        }
    };
}

[kennytm]

@gnzlbg There is PartialEq implementation between &[T] and &[T; n], but not (&[T], u32) and (&[T; n], u32). The PartialEq impl for tuples are like:

impl<A, B, C, D, E, F, G, H> PartialEq<(A, B, C, D, E, F, G, H)> for (A, B, C, D, E, F, G, H) where
    A: PartialEq<A>,
    B: PartialEq<B>,
    C: PartialEq<C>,
    D: PartialEq<D>,
    E: PartialEq<E>,
    F: PartialEq<F>,
    G: PartialEq<G>,
    H: PartialEq<H> + ?Sized, 

note that the LHS and RHS are equal types.

[gnzlbg]

@kennytm but how come that assert!(foo(&[], 10) == (&[], 0)); works then? I am confused 😕

[kennytm]

@gnzlbg assert_eq expands to

match (&left, &right) {
    (l, r) => {
        if !(*l == *r) {
            panic!("...");
        }
    }
}

Probably the match has changed some inference behavior making &[] not able to coerce from &[_; 0] to an &[u32].

[eddyb]

This isn't a regression, is it? Pretty sure this never worked.

As for why, the macro needs to bind the two expressions to variables (by reference) to be able to not only compare but also print them (in case of a mismatch) - this is why assert_eq is a separate macro, after all - and this means coercion information can't flow through ==.

OTOH, in foo(&[], 10) == (&[], 0), the &[] on the RHS of == gets &[u32] as "expected type".

[eddyb]

We can probably make assert_eq do coercions just like == like so (untested!):

// perma-unstable
pub fn check_assert_eq<'a, A, B>(a: &'a A, b: &'a B) -> Result<(), (&'a A, &'a B)>
    where A: PartialEq<B>
{
    if a == b { Ok(()) } else { Err((a, b)) }
}
macro_rules! assert_eq {
    ($left:expr, $right:expr) => ({
        if let Err((left_val, right_val)) = check_assert_eq(&$left, &$right) {
            panic!(r#"assertion failed: `(left == right)`
  left: `{:?}`,
 right: `{:?}`"#, left_val, right_val);
        }
    });
}

[kennytm]

cc #44838.