Wildcard import fails to resolve if a derive is present

[ennis]

The following snippet fails to compile with the error [E0412]: cannot find type Foo in this scope

https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=d954ef6f84f0d1df4e5c4791c7716da9

struct Foo;          // line 1

mod foo {
    use super::*;    // line 4
    
    // Commenting out the Debug derive makes it work
    #[derive(Debug)] // line 7
    pub struct Foo;
}

mod bar {
    use super::foo::*;
    
    fn bar(_: Foo) {}
}

Expected result: code compiles without issues

I can get it to compile by doing one of those:

• by removing use super::* on line 4
• by commenting #[derive(Debug)] at line 7
• by renaming struct Foo on line 1 to Foo2
• and curiously, by copy-pasting the generated Debug impl obtained with --pretty=expanded instead of using #[derive(Debug)]

The same issue happens with other derives (Clone,Eq,etc.). Seems like #[derive()] is confused when an item with the same name is visible?

[petrochenkov]

Looks like a legitimate bug.
It's also a regression from Rust 1.15 released almost 2 years ago :)

[spastorino]

Assigning P-medium as discussed as part of the Prioritization Working Group process and removing I-prioritize.

[estebank]

From #81887:

Hello. I've noticed a strange behaviour where rust-analyzer and rustc would disagree what was wrong with my code. Turns out neither of them were right, I've had an "ambiguous name" problem however both rustc and rust-analyzer resolved the type anyway and they chose a different type to disambiguate into.

I've managed to make this minimal reproduction.
I can either remove the derives or remove the indirection through the c module and the problem will go away.

I expected to get a "Foo is ambiguous" error, instead i get an error for one of the usages of Foo which doesn't match the resolved type of Foo.

As a side-note, at least for rustc the resolved type seems to be dependent on the lexical order of the module/type definitions (not reexports), if that helps at all.

I get the same result on both nightly and stable, locally and on the playground. I found these issues #56593 and #62769 which sound similar but the problem there seems to be the opposite - "type doesn't resolve when it should" (in the presence of derive) instead of here "type resolves when it shouldn't".

[rich-g]

Bumping this, as it still seems to be an issue. Minimal example:
https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=02595dc261355bf662c11cc605d20e55

[wusticality]

I filed an issue as well and then someone referred me to this issue, I guess it's a dupe. I'm running into this issue as well, any movement on this? Seems like a bug to me, no?

#105235

[cybersoulK]

having the same issue, it's a major bug, 5 years without fix?