assert_eq! of trivially-equal enums with 2 non-empty variants is not optimized out

[ZhonghaoPan-nju]

https://godbolt.org/z/Wrq4EdvrP

This program should be optimized to an empty main, but it isn't:

#[derive(PartialEq)]
enum Foo {
    Bar(u8, u8),
    #[allow(dead_code)]
    Baz(u8),
}

impl std::fmt::Debug for Foo {
    #[inline]
    fn fmt(&self, _f: &mut std::fmt::Formatter) -> std::fmt::Result {
        Ok(())
    }
}

pub fn main() {
    let a = Foo::Bar(1, 2);
    let b = Foo::Bar(1, 2);
    assert_eq!(a, b);
}

Note that if the assert is changed to just a panic that doesn't try to format a and b, the comparison does get optimized out. And also, if the Baz is a unit variant we will get the expected optimization but only with -Cdebuginfo=0.

rustc 1.85.0-nightly (d117b7f21 2024-12-31)
binary: rustc
commit-hash: d117b7f211835282b3b177dc64245fff0327c04c
commit-date: 2024-12-31
host: x86_64-unknown-linux-gnu
release: 1.85.0-nightly
LLVM version: 19.1.6

[saethlin]

@WindFrank Whoa, you found a really interesting and surprising missed optimization, but you explained it in a way that I found quite confusing. I'm going to rewrite the issue description to be more clear.

[nikic]

Works with -Zmir-opt-level=0. For some reason b gets lowered as a memcpy of a instead of being initialized separately.

[saethlin]

GVN (the MIR transform) has realized that b is a copy of a and applied this transformation:

-        _2 = Foo::Bar(const 1_u8, const 2_u8);
+        _2 = copy _1;

Of course that's a transformation that can be done at the source level too; here's a reproducer that works with -Zmir-opt-level=0:
https://godbolt.org/z/nG14z6zhM

#[derive(Clone, Copy, PartialEq)]
enum Foo {
    Bar(u8, u8),
    #[allow(dead_code)]
    Baz(u8),
}

impl std::fmt::Debug for Foo {
    #[inline]
    fn fmt(&self, _f: &mut std::fmt::Formatter) -> std::fmt::Result {
        Ok(())
    }
}

pub fn main() {
    let a = Foo::Bar(1, 2);
    let b = a;
    assert_eq!(a, b);
}

[scottmcm]

This looks like it's an escape analysis problem, like all the cases where printing an accumulator after a loop makes the loop slower.

Change @saethlin 's repro like this https://rust.godbolt.org/z/78h5jdeaj

 pub fn main() {
     let a = Foo::Bar(1, 2);
     let b = a;
-    assert_eq!(a, b);
+    assert_eq!({a}, {b});
 }

And it optimizes down to an empty main:

define void @_ZN7example4main17h0b7eacf4acc29beaE() unnamed_addr #0 {
  ret void
}

[saethlin]

Realizing that it may be unclear to OP that we have actually addressed their original observation.

The optimized reproducer originally shared reduces to this:

#![allow(dead_code)]
#[derive(PartialEq, Debug)]
enum Foo {
    Bar(u8, u8),
    Baz(u8),
}
pub fn main() {
    let a = Foo::Bar(1, 2);
    let b = Foo::Bar(0 + 1, 2);
    assert_eq!(a, b);
}

The closures in the original post are irrelevant. This program optimizes well right now because the extra arithmetic confuses GVN and prevents us from handing LLVM IR that constructs b with a memcpy of a.