Rust 带有通配符使用声明的子模块行为

Question

I was trying to understand how (sub)module imports work when using wildcard paths. The simplest demonstration I could come up with is as follows, where two modules, or perhaps two crates, share the same module structure.

pub mod primary {
    pub mod a {
        pub mod b {
            pub struct A(pub i32);
        }
    }
}

pub mod import {
    pub use crate::primary::*;
    // Compiles and executes fine with this commented out, but fails with
    // "error[E0433]: failed to resolve: could not find `b` in `a`"
    // otherwise. The error refers to the usage in the assert_eq macro
    // pub mod a {}
}

fn main() {
    assert_eq!(import::a::b::A(42).0, 42);
}

My general thought, was, since the first case, where the pub mod a {} is commented out works, the wildcard should expand all submodules the wildcard picks up into submodules in the path in which it is expanding. Is this not the case? If so, what's the appropriate way to think about?

TheUse declarations doesn't have a lot of detail on this.

Answer 1

use with a * imports all the names, except for those that would conflict with names that already exist in the current module.

Compare:

pub mod primary {
    pub fn f() {
        println!("p::f");
    }
}

pub mod import {
    pub use crate::primary::*;
}

fn main() {
    import::f();
}

which prints p::f to

pub mod primary {
    pub fn f() {
        println!("p::f");
    }
}

pub mod import {
    pub use crate::primary::*;

    pub fn f() {
        println!("import::f");
    }
}

fn main() {
    import::f();
}

which prints import::f .

---

This might seem obvious for functions and constants (it would otherwise make * very limited, making it impossible for upstream libraries to add any item without risking to break downstream users), but it might seem more confusing for modules. You have to remember though that you can't define a module multiple times (ie. "reopen" a module). The following is illegal:

pub mod primary {
    pub mod a {}
    pub mod a {}
}

and fails with

error[E0428]: the name `a` is defined multiple times
 --> src/lib.rs:3:5
  |
2 |     pub mod a {}
  |     --------- previous definition of the module `a` here
3 |     pub mod a {}
  |     ^^^^^^^^^ `a` redefined here
  |
  = note: `a` must be defined only once in the type namespace of this module

---

You can solve this particular case by adding one more level:

pub mod primary {
    pub mod a {
        pub mod b {
            pub struct A(pub i32);
        }
    }
}

pub mod import {
    pub mod a {
        pub use crate::primary::a::*;
    }
}

fn main() {
    assert_eq!(import::a::b::A(42).0, 42);
}

Answer 2

A wildcard import creates aliases to all items on the top level of the module.

In your example, since primary contains only one item, a , the wildcard import creates an alias import::a , which refers to the module primary::a .

Whenever conflicts arise, explicitly named items are given higher precedence than items that were imported via a wildcard. Effectively, you can shadow a wildcard import by declaring a new item or by importing it by name from another module.

Each mod declaration declares a different module. There is no implicit merging of items in modules that happen to have the same name or alias.