1 use crate::base::ModuleData;
3 use rustc_ast::{token, Attribute, Inline, Item, ModSpans};
4 use rustc_errors::{struct_span_err, DiagnosticBuilder, ErrorGuaranteed};
5 use rustc_parse::new_parser_from_file;
6 use rustc_parse::validate_attr;
7 use rustc_session::parse::ParseSess;
8 use rustc_session::Session;
9 use rustc_span::symbol::{sym, Ident};
12 use std::path::{self, Path, PathBuf};
14 #[derive(Copy, Clone)]
15 pub enum DirOwnership {
17 // None if `mod.rs`, `Some("foo")` if we're in `foo.rs`.
18 relative: Option<Ident>,
23 // Public for rustfmt usage.
24 pub struct ModulePathSuccess {
25 pub file_path: PathBuf,
26 pub dir_ownership: DirOwnership,
29 pub(crate) struct ParsedExternalMod {
30 pub items: Vec<P<Item>>,
32 pub file_path: PathBuf,
33 pub dir_path: PathBuf,
34 pub dir_ownership: DirOwnership,
37 pub enum ModError<'a> {
38 CircularInclusion(Vec<PathBuf>),
39 ModInBlock(Option<Ident>),
40 FileNotFound(Ident, PathBuf, PathBuf),
41 MultipleCandidates(Ident, PathBuf, PathBuf),
42 ParserError(DiagnosticBuilder<'a, ErrorGuaranteed>),
45 pub(crate) fn parse_external_mod(
48 span: Span, // The span to blame on errors.
50 mut dir_ownership: DirOwnership,
51 attrs: &mut Vec<Attribute>,
52 ) -> ParsedExternalMod {
53 // We bail on the first error, but that error does not cause a fatal error... (1)
54 let result: Result<_, ModError<'_>> = try {
55 // Extract the file path and the new ownership.
56 let mp = mod_file_path(sess, ident, &attrs, &module.dir_path, dir_ownership)?;
57 dir_ownership = mp.dir_ownership;
59 // Ensure file paths are acyclic.
60 if let Some(pos) = module.file_path_stack.iter().position(|p| p == &mp.file_path) {
61 Err(ModError::CircularInclusion(module.file_path_stack[pos..].to_vec()))?;
64 // Actually parse the external file as a module.
65 let mut parser = new_parser_from_file(&sess.parse_sess, &mp.file_path, Some(span));
66 let (mut inner_attrs, items, inner_span) =
67 parser.parse_mod(&token::Eof).map_err(|err| ModError::ParserError(err))?;
68 attrs.append(&mut inner_attrs);
69 (items, inner_span, mp.file_path)
71 // (1) ...instead, we return a dummy module.
72 let (items, spans, file_path) =
73 result.map_err(|err| err.report(sess, span)).unwrap_or_default();
75 // Extract the directory path for submodules of the module.
76 let dir_path = file_path.parent().unwrap_or(&file_path).to_owned();
78 ParsedExternalMod { items, spans, file_path, dir_path, dir_ownership }
81 pub(crate) fn mod_dir_path(
86 mut dir_ownership: DirOwnership,
88 ) -> (PathBuf, DirOwnership) {
90 Inline::Yes if let Some(file_path) = mod_file_path_from_attr(sess, attrs, &module.dir_path) => {
91 // For inline modules file path from `#[path]` is actually the directory path
92 // for historical reasons, so we don't pop the last segment here.
93 (file_path, DirOwnership::Owned { relative: None })
96 // We have to push on the current module name in the case of relative
97 // paths in order to ensure that any additional module paths from inline
98 // `mod x { ... }` come after the relative extension.
100 // For example, a `mod z { ... }` inside `x/y.rs` should set the current
101 // directory path to `/x/y/z`, not `/x/z` with a relative offset of `y`.
102 let mut dir_path = module.dir_path.clone();
103 if let DirOwnership::Owned { relative } = &mut dir_ownership {
104 if let Some(ident) = relative.take() {
105 // Remove the relative offset.
106 dir_path.push(ident.as_str());
109 dir_path.push(ident.as_str());
111 (dir_path, dir_ownership)
114 // FIXME: This is a subset of `parse_external_mod` without actual parsing,
115 // check whether the logic for unloaded, loaded and inline modules can be unified.
116 let file_path = mod_file_path(sess, ident, &attrs, &module.dir_path, dir_ownership)
118 dir_ownership = mp.dir_ownership;
121 .unwrap_or_default();
123 // Extract the directory path for submodules of the module.
124 let dir_path = file_path.parent().unwrap_or(&file_path).to_owned();
126 (dir_path, dir_ownership)
131 fn mod_file_path<'a>(
136 dir_ownership: DirOwnership,
137 ) -> Result<ModulePathSuccess, ModError<'a>> {
138 if let Some(file_path) = mod_file_path_from_attr(sess, attrs, dir_path) {
139 // All `#[path]` files are treated as though they are a `mod.rs` file.
140 // This means that `mod foo;` declarations inside `#[path]`-included
141 // files are siblings,
143 // Note that this will produce weirdness when a file named `foo.rs` is
144 // `#[path]` included and contains a `mod foo;` declaration.
145 // If you encounter this, it's your own darn fault :P
146 let dir_ownership = DirOwnership::Owned { relative: None };
147 return Ok(ModulePathSuccess { file_path, dir_ownership });
150 let relative = match dir_ownership {
151 DirOwnership::Owned { relative } => relative,
152 DirOwnership::UnownedViaBlock => None,
154 let result = default_submod_path(&sess.parse_sess, ident, relative, dir_path);
155 match dir_ownership {
156 DirOwnership::Owned { .. } => result,
157 DirOwnership::UnownedViaBlock => Err(ModError::ModInBlock(match result {
158 Ok(_) | Err(ModError::MultipleCandidates(..)) => Some(ident),
164 /// Derive a submodule path from the first found `#[path = "path_string"]`.
165 /// The provided `dir_path` is joined with the `path_string`.
166 fn mod_file_path_from_attr(
170 ) -> Option<PathBuf> {
171 // Extract path string from first `#[path = "path_string"]` attribute.
172 let first_path = attrs.iter().find(|at| at.has_name(sym::path))?;
173 let Some(path_sym) = first_path.value_str() else {
174 // This check is here mainly to catch attempting to use a macro,
175 // such as #[path = concat!(...)]. This isn't currently supported
176 // because otherwise the InvocationCollector would need to defer
177 // loading a module until the #[path] attribute was expanded, and
178 // it doesn't support that (and would likely add a bit of
179 // complexity). Usually bad forms are checked in AstValidator (via
180 // `check_builtin_attribute`), but by the time that runs the macro
181 // is expanded, and it doesn't give an error.
182 validate_attr::emit_fatal_malformed_builtin_attribute(
189 let path_str = path_sym.as_str();
191 // On windows, the base path might have the form
192 // `\\?\foo\bar` in which case it does not tolerate
193 // mixed `/` and `\` separators, so canonicalize
196 let path_str = path_str.replace("/", "\\");
198 Some(dir_path.join(path_str))
201 /// Returns a path to a module.
202 // Public for rustfmt usage.
203 pub fn default_submod_path<'a>(
206 relative: Option<Ident>,
208 ) -> Result<ModulePathSuccess, ModError<'a>> {
209 // If we're in a foo.rs file instead of a mod.rs file,
210 // we need to look for submodules in
211 // `./foo/<ident>.rs` and `./foo/<ident>/mod.rs` rather than
212 // `./<ident>.rs` and `./<ident>/mod.rs`.
213 let relative_prefix_string;
214 let relative_prefix = if let Some(ident) = relative {
215 relative_prefix_string = format!("{}{}", ident.name, path::MAIN_SEPARATOR);
216 &relative_prefix_string
221 let mod_name = ident.name.to_string();
222 let default_path_str = format!("{}{}.rs", relative_prefix, mod_name);
223 let secondary_path_str =
224 format!("{}{}{}mod.rs", relative_prefix, mod_name, path::MAIN_SEPARATOR);
225 let default_path = dir_path.join(&default_path_str);
226 let secondary_path = dir_path.join(&secondary_path_str);
227 let default_exists = sess.source_map().file_exists(&default_path);
228 let secondary_exists = sess.source_map().file_exists(&secondary_path);
230 match (default_exists, secondary_exists) {
231 (true, false) => Ok(ModulePathSuccess {
232 file_path: default_path,
233 dir_ownership: DirOwnership::Owned { relative: Some(ident) },
235 (false, true) => Ok(ModulePathSuccess {
236 file_path: secondary_path,
237 dir_ownership: DirOwnership::Owned { relative: None },
239 (false, false) => Err(ModError::FileNotFound(ident, default_path, secondary_path)),
240 (true, true) => Err(ModError::MultipleCandidates(ident, default_path, secondary_path)),
245 fn report(self, sess: &Session, span: Span) -> ErrorGuaranteed {
246 let diag = &sess.parse_sess.span_diagnostic;
248 ModError::CircularInclusion(file_paths) => {
249 let mut msg = String::from("circular modules: ");
250 for file_path in &file_paths {
251 msg.push_str(&file_path.display().to_string());
252 msg.push_str(" -> ");
254 msg.push_str(&file_paths[0].display().to_string());
255 diag.struct_span_err(span, &msg)
257 ModError::ModInBlock(ident) => {
258 let msg = "cannot declare a non-inline module inside a block unless it has a path attribute";
259 let mut err = diag.struct_span_err(span, msg);
260 if let Some(ident) = ident {
262 format!("maybe `use` the module `{}` instead of redeclaring it", ident);
263 err.span_note(span, ¬e);
267 ModError::FileNotFound(ident, default_path, secondary_path) => {
268 let mut err = struct_span_err!(
272 "file not found for module `{}`",
276 "to create the module `{}`, create file \"{}\" or \"{}\"",
278 default_path.display(),
279 secondary_path.display(),
283 ModError::MultipleCandidates(ident, default_path, secondary_path) => {
284 let mut err = struct_span_err!(
288 "file for module `{}` found at both \"{}\" and \"{}\"",
290 default_path.display(),
291 secondary_path.display(),
293 err.help("delete or rename one of them to remove the ambiguity");
296 ModError::ParserError(err) => err,