Pattern matching on C-like enums when values are not imported cause unintuitive behaviour

[LeoTestard]

When doing pattern matching on a C-like enum whose values haven't be imported in the current namespace, like :

mod foo {
    enum Bar {
        Baz,
        Qux
    }
}

// ...

match someBar {
    Baz => // ...
    Qux => // ...
}

Rustc doesn't know Baz and Qux are values, since they are not imported.
The first Baz pattern is thus considered as a binding, and all following patterns are seen as "unreachable".

Maybe we should put the enum value names inside the namespace of the enum type (like C++11 enum classes), and, in any case, implement a better error or warning message. Many people apparently ran into this issue, and found it very weird and hard to debug. (cc @cmr )

[sfackler]

enum class style enums are proposed in #10090. There's also #10304 which proposes a warning for upper case match variables which would help in this kind of situation.

[huonw]

This would also be resolved by forcing local variables to be cased_like_this and enum variants LikeThis ala Haskell, but I imagine that might be going a little too far for some people.

[conradkleinespel]

I'm not sure if this is the same issue, but when using a non existent identifier in a pattern match with a enum, all following matches are unreachable.

Here the example code:

enum Greeting {
    Hello,
    ByeBye
}

fn main() {
    let that = Hello;
    match that {
        Hello => (),
        NonExistent => (),
        ByeBye => ()
    }
}

And a pre-populated Rust Playground link:
http://is.gd/acpYw6

[eefriedman]

We now print a message like warning: pattern binding Hellois named the same as one of the variants of the typeGreeting``; that's probably good enough.

[alexcrichton]

Thanks @eefriedman!