seemingly incorrect nontrivial_structural_match warning

[jmhain]

For the following code, I get a compiler warning:

#[derive(PartialEq, Eq)]
pub enum Thing { Foo(bool), Bar(Vec<()>) }

impl Thing {
    pub const FOO: Thing = Self::Foo(true);
}

pub fn foo(thing: Thing) {
    match thing {
        Thing::FOO => {},
        _ => {},
    }
}

Playground link

And the warning:

warning: to use a constant of type `Vec<()>` in a pattern, the constant's initializer must be trivial or `Vec<()>` must be annotated with `#[derive(PartialEq, Eq)]`
  --> src/lib.rs:10:9
   |
10 |         Thing::FOO => {},
   |         ^^^^^^^^^^
   |
   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
   = note: for more information, [see issue #73448 <https://github.com/rust-lang/rust/issues/73448>](https://github.com/rust-lang/rust/issues/73448)
   = note: `#[warn(nontrivial_structural_match)]` on by default

What makes me think this warning is incorrect is that the constant's initializer does not produce the Vec-containing variant like the warning suggests, and changing Self:: to Thing:: in the initializer resolves the error despite those (afaik) being equivalent.

[compiler-errors]

changing Self:: to Thing:: in the initializer resolves the error despite those (afaik) being equivalent.

Strange... Given:

#[derive(PartialEq, Eq)]
pub enum Thing { Foo(bool), Bar(Vec<()>) }

impl Thing {
    pub const FOO: Thing = Thing::Foo(true);
    pub const BAR: Thing = Self::Foo(true);
}

fn main() {}

The MIR we generate for either associated const is quite different...

const <impl at [src/main.rs:4:1: 4:11](https://play.rust-lang.org/?version=stable&mode=debug&edition=2021#)>::FOO: Thing = {
    let mut _0: Thing;                   // return place in scope 0 at [src/main.rs:5:20: 5:25](https://play.rust-lang.org/?version=stable&mode=debug&edition=2021#)

    bb0: {
        Deinit(_0);                      // scope 0 at [src/main.rs:5:28: 5:44](https://play.rust-lang.org/?version=stable&mode=debug&edition=2021#)
        ((_0 as Foo).0: bool) = const true; // scope 0 at [src/main.rs:5:28: 5:44](https://play.rust-lang.org/?version=stable&mode=debug&edition=2021#)
        discriminant(_0) = 0;            // scope 0 at [src/main.rs:5:28: 5:44](https://play.rust-lang.org/?version=stable&mode=debug&edition=2021#)
        return;                          // scope 0 at [src/main.rs:5:5: 5:45](https://play.rust-lang.org/?version=stable&mode=debug&edition=2021#)
    }
}

const <impl at [src/main.rs:4:1: 4:11](https://play.rust-lang.org/?version=stable&mode=debug&edition=2021#)>::BAR: Thing = {
    let mut _0: Thing;                   // return place in scope 0 at [src/main.rs:6:20: 6:25](https://play.rust-lang.org/?version=stable&mode=debug&edition=2021#)

    bb0: {
        _0 = Thing::Foo(const true) -> bb1; // scope 0 at [src/main.rs:6:28: 6:43](https://play.rust-lang.org/?version=stable&mode=debug&edition=2021#)
                                         // mir::Constant
                                         // + span: [src/main.rs:6:28: 6:37](https://play.rust-lang.org/?version=stable&mode=debug&edition=2021#)
                                         // + literal: Const { ty: fn(bool) -> Thing {Thing::Foo}, val: Value(<ZST>) }
    }

    bb1: {
        return;                          // scope 0 at [src/main.rs:6:5: 6:44](https://play.rust-lang.org/?version=stable&mode=debug&edition=2021#)
    }
}

🤔

[ericmarkmartin]

I'd like to take a swing at this

[ericmarkmartin]

@rustbot claim

[ericmarkmartin]

@compiler-errors I looked at the thir generated for your program

#[derive(PartialEq, Eq)]
pub enum Thing { Foo(bool), Bar(Vec<()>) }

impl Thing {
    pub const FOO: Thing = Thing::Foo(true);
    pub const BAR: Thing = Self::Foo(true);
}

fn main() {}

and FOO and BAR are already different. FOO has kind Adt whereas BAR has kind Call.