Enum variant and associated function with matching names compiles

speelbarrow · July 3, 2023, 5:46pm

Hey there! I'm posting on here because I've noticed what might be a bug of the compiler but could also just be me misunderstanding something related to how Rust works.

Lets take the example of the following enum:

enum Example {
    Example1,
    Example2,
}

If I then add the following block to the source file, the code will still compile:

impl Example {
    fn Example1() {
        println!("Hello, World!")
    }
}

I do understand that this isn't the recommended case for a function name in Rust, however I would expect that the compiler would catch the name collision regardless.

If I then try to invoke Example::Example1(), I get the following error:

`Example::Example1` is a unit enum variant, and does not take parentheses to be constructed

I can construct the enum variant without issue. So the behaviour is consistent.

However, once again, I don't really understand why the compiler doesn't flag the name collision to begin with. Is there a use case for this behaviour that I'm missing?

I've posted a Gist with two files -- one that compiles, one that doesn't -- to clarify exactly what I'm talking about.

I look forward to any and all responses!

- Noah

steffahn · July 3, 2023, 5:55pm

Seems to be tracked in this issue:

github.com/rust-lang/rust

Enum associated functions can name-clash with variants, but cannot be called.

opened 01:07AM - 19 Feb 17 UTC

tekacs

A-lint T-compiler C-feature-request

### Description It's currently possible to name a function associated to an e…num identically to the name of one of its variants. This function cannot be called (see below), but rather than warning at the point that the function is defined, the compiler only emits an error upon trying to call said function (and in some cases - see the 'Alternate Reproduction' - it doesn't even do that). https://is.gd/EZQ9mL ```rust #[derive(Debug)] enum X { a } impl X { fn a() -> X { X::a } } fn main() { println!("{:?}", X::a()) } ``` yields: ```rust rustc 1.15.1 (021bd294c 2017-02-08) error: `X::a` is being called, but it is not a function --> <anon>:13:22 | 13 | println!("{:?}", X::a()) | ^^^^^^ | = help: did you mean to write `X::a`? note: defined here --> <anon>:3:5 | 3 | a | ^ error: aborting due to previous error ``` ### Expected behaviour: Emit an error at the point (`fn a() -> X`) that the function is defined. ### Alternate reproduction Even more confusing is the code: https://is.gd/S15gOw ```rust #[derive(Debug)] enum X { a(), b, } impl X { fn a() -> X { X::b } } fn main() { println!("{:?}", X::a()) } ``` This compiles and runs. Any guesses whether the variant or the function wins? :smile:

speelbarrow · July 3, 2023, 6:06pm

Got it. Thanks!