Should modules with path attribute become directory owners automatically?

[matklad]

Consider this layout

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

// foo.rs
mod bar;

// bar.rs
// empty

It generates cannot declare a new module at this location error for mod bar;, which is good.

However, If I explicitly specify #[path = ] for mod foo; it compiles:

// main.rs
#[path = "foo.rs"]
mod foo;
fn main() {}

// foo.rs
mod bar;

// bar.rs
// empty

I don't know if this is expected behavior or not, but it looks suspicious to me .

[pnkfelix]

No matter what we decide here, I think its important that the following variation continue to work:

// main.rs
#[path = "foo.rs"]
mod foo;
fn main() {}

// foo.rs
#[path = "bar.rs"]
mod bar;

// bar.rs
// empty

That is, if the developer cares enough about their existing directory layout that they are willing to add #[path] attributes even for modules that are merely referenced from non-standard places, then we should support that.

---

(I don't have a strong opinion about disallowing the second form in the issue description.)

[pnkfelix]

triage: I-nominated

[KalitaAlexey]

Why #[path] is allowed?
https://github.com/rust-lang/rust/blob/master/src/doc/style/features/modules.md suggests to not use #[path].

[nikomatsakis]

I think the answer is that we should not accept this. If a module has a path attribute, it should be a directory owner if the path is a mod.rs path (e.g. foo/mod.rs), but not otherwise.

[nikomatsakis]

Discussed in @rust-lang/lang. Note that if we stop allowing out-of-line submodules from arbitrary named files, a warning period would be required.

[nikomatsakis]

triage: P-medium

This doesn't feel super urgent. If we end up keeping the current behavior, we can live with it.

[Aatch]

@KalitaAlexey while it should probably be avoided if possible, #[path] is useful and shouldn't be removed (not that we can remove it at this point anyway).

[KalitaAlexey]

@Aatch Could you please describe situation when #[path] is single way?

[matklad]

@KalitaAlexey for example stdlib uses path in conjunction with cfg attributes to select among several implementations: https://github.com/rust-lang/rust/blob/master/src/libstd/lib.rs#L439-L443

[brson]

Help wanted. Just change the parser to disallow the behavior in the OP, add a compile-fail test. We will need to run it through crater to see if anybody depends on this, and maybe have a deprecation period. If people do depend on it, let's just add a test to the test suite and call it expected behavior.

[brson]

@jseyfried nice papercut

[jseyfried]

Fixed in #37602.

[briansmith]

I think the answer is that we should not accept this. If a module has a path attribute, it should be a directory owner if the path is a mod.rs path (e.g. foo/mod.rs), but not otherwise.

Now how do you create a module in a file that isn't named mod.rs that is a directory owner?