1 use crate::base::ModuleData;
3 use rustc_ast::{token, Attribute, Item};
4 use rustc_errors::{struct_span_err, PResult};
5 use rustc_parse::new_parser_from_file;
6 use rustc_session::parse::ParseSess;
7 use rustc_session::Session;
8 use rustc_span::symbol::{sym, Ident};
11 use std::path::{self, Path, PathBuf};
13 #[derive(Copy, Clone)]
14 pub enum DirOwnership {
16 // None if `mod.rs`, `Some("foo")` if we're in `foo.rs`.
17 relative: Option<Ident>,
22 /// Information about the path to a module.
23 // Public for rustfmt usage.
24 pub struct ModulePath<'a> {
27 pub result: PResult<'a, ModulePathSuccess>,
30 // Public for rustfmt usage.
31 pub struct ModulePathSuccess {
32 pub file_path: PathBuf,
33 pub dir_ownership: DirOwnership,
36 crate struct ParsedExternalMod {
37 pub items: Vec<P<Item>>,
39 pub file_path: PathBuf,
40 pub dir_path: PathBuf,
41 pub dir_ownership: DirOwnership,
44 crate fn parse_external_mod(
47 span: Span, // The span to blame on errors.
49 mut dir_ownership: DirOwnership,
50 attrs: &mut Vec<Attribute>,
51 ) -> ParsedExternalMod {
52 // We bail on the first error, but that error does not cause a fatal error... (1)
53 let result: PResult<'_, _> = try {
54 // Extract the file path and the new ownership.
55 let mp = mod_file_path(sess, ident, span, &attrs, &module.dir_path, dir_ownership)?;
56 dir_ownership = mp.dir_ownership;
58 // Ensure file paths are acyclic.
59 error_on_circular_module(&sess.parse_sess, span, &mp.file_path, &module.file_path_stack)?;
61 // Actually parse the external file as a module.
62 let mut parser = new_parser_from_file(&sess.parse_sess, &mp.file_path, Some(span));
63 let (mut inner_attrs, items, inner_span) = parser.parse_mod(&token::Eof)?;
64 attrs.append(&mut inner_attrs);
65 (items, inner_span, mp.file_path)
67 // (1) ...instead, we return a dummy module.
68 let (items, inner_span, file_path) = result.map_err(|mut err| err.emit()).unwrap_or_default();
70 // Extract the directory path for submodules of the module.
71 let dir_path = file_path.parent().unwrap_or(&file_path).to_owned();
73 ParsedExternalMod { items, inner_span, file_path, dir_path, dir_ownership }
76 fn error_on_circular_module<'a>(
80 file_path_stack: &[PathBuf],
81 ) -> PResult<'a, ()> {
82 if let Some(i) = file_path_stack.iter().position(|p| *p == file_path) {
83 let mut err = String::from("circular modules: ");
84 for p in &file_path_stack[i..] {
85 err.push_str(&p.to_string_lossy());
88 err.push_str(&file_path.to_string_lossy());
89 return Err(sess.span_diagnostic.struct_span_err(span, &err[..]));
94 crate fn mod_dir_path(
99 mut dir_ownership: DirOwnership,
100 ) -> (PathBuf, DirOwnership) {
101 if let Some(file_path) = mod_file_path_from_attr(sess, attrs, &module.dir_path) {
102 // For inline modules file path from `#[path]` is actually the directory path
103 // for historical reasons, so we don't pop the last segment here.
104 return (file_path, DirOwnership::Owned { relative: None });
107 // We have to push on the current module name in the case of relative
108 // paths in order to ensure that any additional module paths from inline
109 // `mod x { ... }` come after the relative extension.
111 // For example, a `mod z { ... }` inside `x/y.rs` should set the current
112 // directory path to `/x/y/z`, not `/x/z` with a relative offset of `y`.
113 let mut dir_path = module.dir_path.clone();
114 if let DirOwnership::Owned { relative } = &mut dir_ownership {
115 if let Some(ident) = relative.take() {
116 // Remove the relative offset.
117 dir_path.push(&*ident.as_str());
120 dir_path.push(&*ident.as_str());
122 (dir_path, dir_ownership)
125 fn mod_file_path<'a>(
131 dir_ownership: DirOwnership,
132 ) -> PResult<'a, ModulePathSuccess> {
133 if let Some(file_path) = mod_file_path_from_attr(sess, attrs, dir_path) {
134 // All `#[path]` files are treated as though they are a `mod.rs` file.
135 // This means that `mod foo;` declarations inside `#[path]`-included
136 // files are siblings,
138 // Note that this will produce weirdness when a file named `foo.rs` is
139 // `#[path]` included and contains a `mod foo;` declaration.
140 // If you encounter this, it's your own darn fault :P
141 let dir_ownership = DirOwnership::Owned { relative: None };
142 return Ok(ModulePathSuccess { file_path, dir_ownership });
145 let relative = match dir_ownership {
146 DirOwnership::Owned { relative } => relative,
147 DirOwnership::UnownedViaBlock => None,
149 let ModulePath { path_exists, name, result } =
150 default_submod_path(&sess.parse_sess, ident, span, relative, dir_path);
151 match dir_ownership {
152 DirOwnership::Owned { .. } => Ok(result?),
153 DirOwnership::UnownedViaBlock => {
154 let _ = result.map_err(|mut err| err.cancel());
155 error_decl_mod_in_block(&sess.parse_sess, span, path_exists, &name)
160 fn error_decl_mod_in_block<'a, T>(
165 ) -> PResult<'a, T> {
166 let msg = "Cannot declare a non-inline module inside a block unless it has a path attribute";
167 let mut err = sess.span_diagnostic.struct_span_err(span, msg);
169 let msg = format!("Maybe `use` the module `{}` instead of redeclaring it", name);
170 err.span_note(span, &msg);
175 /// Derive a submodule path from the first found `#[path = "path_string"]`.
176 /// The provided `dir_path` is joined with the `path_string`.
177 fn mod_file_path_from_attr(
181 ) -> Option<PathBuf> {
182 // Extract path string from first `#[path = "path_string"]` attribute.
183 let path_string = sess.first_attr_value_str_by_name(attrs, sym::path)?.as_str();
185 // On windows, the base path might have the form
186 // `\\?\foo\bar` in which case it does not tolerate
187 // mixed `/` and `\` separators, so canonicalize
190 let path_string = path_string.replace("/", "\\");
192 Some(dir_path.join(&*path_string))
195 /// Returns a path to a module.
196 // Public for rustfmt usage.
197 pub fn default_submod_path<'a>(
201 relative: Option<Ident>,
203 ) -> ModulePath<'a> {
204 // If we're in a foo.rs file instead of a mod.rs file,
205 // we need to look for submodules in
206 // `./foo/<ident>.rs` and `./foo/<ident>/mod.rs` rather than
207 // `./<ident>.rs` and `./<ident>/mod.rs`.
208 let relative_prefix_string;
209 let relative_prefix = if let Some(ident) = relative {
210 relative_prefix_string = format!("{}{}", ident.name, path::MAIN_SEPARATOR);
211 &relative_prefix_string
216 let mod_name = ident.name.to_string();
217 let default_path_str = format!("{}{}.rs", relative_prefix, mod_name);
218 let secondary_path_str =
219 format!("{}{}{}mod.rs", relative_prefix, mod_name, path::MAIN_SEPARATOR);
220 let default_path = dir_path.join(&default_path_str);
221 let secondary_path = dir_path.join(&secondary_path_str);
222 let default_exists = sess.source_map().file_exists(&default_path);
223 let secondary_exists = sess.source_map().file_exists(&secondary_path);
225 let result = match (default_exists, secondary_exists) {
226 (true, false) => Ok(ModulePathSuccess {
227 file_path: default_path,
228 dir_ownership: DirOwnership::Owned { relative: Some(ident) },
230 (false, true) => Ok(ModulePathSuccess {
231 file_path: secondary_path,
232 dir_ownership: DirOwnership::Owned { relative: None },
235 let mut err = struct_span_err!(
236 sess.span_diagnostic,
239 "file not found for module `{}`",
243 "to create the module `{}`, create file \"{}\"",
245 default_path.display(),
250 let mut err = struct_span_err!(
251 sess.span_diagnostic,
254 "file for module `{}` found at both {} and {}",
259 err.help("delete or rename one of them to remove the ambiguity");
264 ModulePath { name: mod_name, path_exists: default_exists || secondary_exists, result }