`use foo::{self, ...}` doesn't import macro `foo!`

[valff]

When there is a macro and a module with the same name, use foo::{self, Bar} syntax imports the module foo, but not the macro foo!. So you are forced to use this:

use crate::foo;
use crate::foo::Bar;

It is especially annoying because rustfmt automatically merges it like this:

use crate::foo::{self, Bar};

And the macro is no longer imported. Both procedural and declarative macros are affected. Here is the full example:

pub mod foo {
    pub struct Bar;
}

mod inner {
    use crate::foo::{self, Bar};
    foo!();
}

#[macro_export]
macro_rules! foo {
    () => {};
}

(Playground)

Errors:

   Compiling playground v0.0.1 (/playground)
error: cannot find macro `foo!` in this scope
 --> src/lib.rs:7:5
  |
7 |     foo!();
  |     ^^^
  |
  = help: have you added the `#[macro_use]` on the module/import?

warning: unused imports: `Bar`, `self`
 --> src/lib.rs:6:22
  |
6 |     use crate::foo::{self, Bar};
  |                      ^^^^  ^^^
  |
  = note: #[warn(unused_imports)] on by default

error: aborting due to previous error

error: Could not compile `playground`.

To learn more, run the command again with --verbose.

[ehuss]

According to #60941 (comment), this is working as intended.

[valff]

Hm. So considering a use statement as a tree, the leaves except self import modules, functions and macros, but a self leaf imports only modules. But what are the benefits of this asymmetry?

[valff]

There is a precedent in stdlib with std::vec! macro and std::vec::Vec struct. If they wouldn't be in the prelude, we wouldn't be able to use the single import statement use std::vec::{self, Vec}.

[jonas-schievink]

Closing as per #60941 (comment). Changes to this would likely require an RFC.

[ehuss]

I'm not sure, @petrochenkov will need to clarify.

There is a sort of consistency. If path segments are processed in sequence, the resolver only needs to track which module has been resolved until the leaf. If it allowed self to import multiple things, then it would also need to track all things found along the path (or backtrack), both of which sound more difficult and complicated. It would also make self in a leaf position a special case, adding an exception to the rules.

It also has a consistency with super and crate which only resolve modules.

I agree it is a bit surprising. My mental model used to be that use foo::{self, Bar}; is syntactic sugar for use foo; use foo::Bar;, but that is not how it works.

[valff]

@ehuss Thanks for the explanation!

What is also confusing, if I want to import both the module and the macro, this doesn't work:

use std::vec::{self, Vec};
use std::vec; // I want just the macro here

It adds too much friction to using imports. I need to maintain two groups of imports: for macros and for other things. And I need to ensure they are not overlapping.

[sinkuu]

use std::{vec, vec::Vec}?

[valff]

Yeah, I had to add that I want to use rust-lang/rustfmt#3362. And there should be a blank line between those two imports, so they are not merged.