Non-inline module is allowed inside other items

[huonw]

These are all legal, and somewhat strange, since they're not really following the file-system analogy that modules are typically explained with. I expect this behaviour is just whatever happens to fall out of the current implementation strategy, so let's make a more explicit decision one way or another.

static X: u8 = { mod foo; 0 };
fn foo() {
    mod foo;
}
fn main() {
    mod foo;
}

As one might expect, each of these is a distinct instance of foo (which can be verified by placing log_syntax(hello) in foo.rs: the compiler will greet you 3 times).

Noticed in https://users.rust-lang.org/t/are-module-declarations-allowed-inside-functions/3583 .

[nikomatsakis]

This seems weird to me. I think the intention is that the out-of-line syntax (mod foo;) should only work at the top-level.

[aturon]

I'd vote for allowing non-inline modules only at the top-level, to retain a clear mapping to the file system.

[nikomatsakis]

(Or nested inside modules.)

[nikomatsakis]

triage: P-medium

Backwards incompatible, but ... kind of a curiousity.

[matklad]

Found one more mod aliasing scenario. It involves several files, and is semi officially allowed by the reference.

The layout

src/
├─ bar.rs
├─ foo.rs
├─ inner
│  └── copy.rs
└─ main.rs

The files

//main.rs
mod foo;
mod bar;
fn main() {}

//foo.rs
mod inner { mod copy; }

//bar.rs
mod inner { mod copy; }

The copy module will be aliased. The problem is that although foo and bar are not directory owners, their inner modules are.