619b8abaa6
In some places we use `Vec<Attribute>` and some places we use `ThinVec<Attribute>` (a.k.a. `AttrVec`). This results in various points where we have to convert between `Vec` and `ThinVec`. This commit changes the places that use `Vec<Attribute>` to use `AttrVec`. A lot of this is mechanical and boring, but there are some interesting parts: - It adds a few new methods to `ThinVec`. - It implements `MapInPlace` for `ThinVec`, and introduces a macro to avoid the repetition of this trait for `Vec`, `SmallVec`, and `ThinVec`. Overall, it makes the code a little nicer, and has little effect on performance. But it is a precursor to removing `rustc_data_structures::thin_vec::ThinVec` and replacing it with `thin_vec::ThinVec`, which is implemented more efficiently.
299 lines
11 KiB
Rust
299 lines
11 KiB
Rust
use crate::base::ModuleData;
|
|
use rustc_ast::ptr::P;
|
|
use rustc_ast::{token, AttrVec, Attribute, Inline, Item, ModSpans};
|
|
use rustc_errors::{struct_span_err, DiagnosticBuilder, ErrorGuaranteed};
|
|
use rustc_parse::new_parser_from_file;
|
|
use rustc_parse::validate_attr;
|
|
use rustc_session::parse::ParseSess;
|
|
use rustc_session::Session;
|
|
use rustc_span::symbol::{sym, Ident};
|
|
use rustc_span::Span;
|
|
|
|
use std::path::{self, Path, PathBuf};
|
|
|
|
#[derive(Copy, Clone)]
|
|
pub enum DirOwnership {
|
|
Owned {
|
|
// None if `mod.rs`, `Some("foo")` if we're in `foo.rs`.
|
|
relative: Option<Ident>,
|
|
},
|
|
UnownedViaBlock,
|
|
}
|
|
|
|
// Public for rustfmt usage.
|
|
pub struct ModulePathSuccess {
|
|
pub file_path: PathBuf,
|
|
pub dir_ownership: DirOwnership,
|
|
}
|
|
|
|
pub(crate) struct ParsedExternalMod {
|
|
pub items: Vec<P<Item>>,
|
|
pub spans: ModSpans,
|
|
pub file_path: PathBuf,
|
|
pub dir_path: PathBuf,
|
|
pub dir_ownership: DirOwnership,
|
|
}
|
|
|
|
pub enum ModError<'a> {
|
|
CircularInclusion(Vec<PathBuf>),
|
|
ModInBlock(Option<Ident>),
|
|
FileNotFound(Ident, PathBuf, PathBuf),
|
|
MultipleCandidates(Ident, PathBuf, PathBuf),
|
|
ParserError(DiagnosticBuilder<'a, ErrorGuaranteed>),
|
|
}
|
|
|
|
pub(crate) fn parse_external_mod(
|
|
sess: &Session,
|
|
ident: Ident,
|
|
span: Span, // The span to blame on errors.
|
|
module: &ModuleData,
|
|
mut dir_ownership: DirOwnership,
|
|
attrs: &mut AttrVec,
|
|
) -> ParsedExternalMod {
|
|
// We bail on the first error, but that error does not cause a fatal error... (1)
|
|
let result: Result<_, ModError<'_>> = try {
|
|
// Extract the file path and the new ownership.
|
|
let mp = mod_file_path(sess, ident, &attrs, &module.dir_path, dir_ownership)?;
|
|
dir_ownership = mp.dir_ownership;
|
|
|
|
// Ensure file paths are acyclic.
|
|
if let Some(pos) = module.file_path_stack.iter().position(|p| p == &mp.file_path) {
|
|
Err(ModError::CircularInclusion(module.file_path_stack[pos..].to_vec()))?;
|
|
}
|
|
|
|
// Actually parse the external file as a module.
|
|
let mut parser = new_parser_from_file(&sess.parse_sess, &mp.file_path, Some(span));
|
|
let (inner_attrs, items, inner_span) =
|
|
parser.parse_mod(&token::Eof).map_err(|err| ModError::ParserError(err))?;
|
|
attrs.extend(inner_attrs);
|
|
(items, inner_span, mp.file_path)
|
|
};
|
|
// (1) ...instead, we return a dummy module.
|
|
let (items, spans, file_path) =
|
|
result.map_err(|err| err.report(sess, span)).unwrap_or_default();
|
|
|
|
// Extract the directory path for submodules of the module.
|
|
let dir_path = file_path.parent().unwrap_or(&file_path).to_owned();
|
|
|
|
ParsedExternalMod { items, spans, file_path, dir_path, dir_ownership }
|
|
}
|
|
|
|
pub(crate) fn mod_dir_path(
|
|
sess: &Session,
|
|
ident: Ident,
|
|
attrs: &[Attribute],
|
|
module: &ModuleData,
|
|
mut dir_ownership: DirOwnership,
|
|
inline: Inline,
|
|
) -> (PathBuf, DirOwnership) {
|
|
match inline {
|
|
Inline::Yes if let Some(file_path) = mod_file_path_from_attr(sess, attrs, &module.dir_path) => {
|
|
// For inline modules file path from `#[path]` is actually the directory path
|
|
// for historical reasons, so we don't pop the last segment here.
|
|
(file_path, DirOwnership::Owned { relative: None })
|
|
}
|
|
Inline::Yes => {
|
|
// We have to push on the current module name in the case of relative
|
|
// paths in order to ensure that any additional module paths from inline
|
|
// `mod x { ... }` come after the relative extension.
|
|
//
|
|
// For example, a `mod z { ... }` inside `x/y.rs` should set the current
|
|
// directory path to `/x/y/z`, not `/x/z` with a relative offset of `y`.
|
|
let mut dir_path = module.dir_path.clone();
|
|
if let DirOwnership::Owned { relative } = &mut dir_ownership {
|
|
if let Some(ident) = relative.take() {
|
|
// Remove the relative offset.
|
|
dir_path.push(ident.as_str());
|
|
}
|
|
}
|
|
dir_path.push(ident.as_str());
|
|
|
|
(dir_path, dir_ownership)
|
|
}
|
|
Inline::No => {
|
|
// FIXME: This is a subset of `parse_external_mod` without actual parsing,
|
|
// check whether the logic for unloaded, loaded and inline modules can be unified.
|
|
let file_path = mod_file_path(sess, ident, &attrs, &module.dir_path, dir_ownership)
|
|
.map(|mp| {
|
|
dir_ownership = mp.dir_ownership;
|
|
mp.file_path
|
|
})
|
|
.unwrap_or_default();
|
|
|
|
// Extract the directory path for submodules of the module.
|
|
let dir_path = file_path.parent().unwrap_or(&file_path).to_owned();
|
|
|
|
(dir_path, dir_ownership)
|
|
}
|
|
}
|
|
}
|
|
|
|
fn mod_file_path<'a>(
|
|
sess: &'a Session,
|
|
ident: Ident,
|
|
attrs: &[Attribute],
|
|
dir_path: &Path,
|
|
dir_ownership: DirOwnership,
|
|
) -> Result<ModulePathSuccess, ModError<'a>> {
|
|
if let Some(file_path) = mod_file_path_from_attr(sess, attrs, dir_path) {
|
|
// All `#[path]` files are treated as though they are a `mod.rs` file.
|
|
// This means that `mod foo;` declarations inside `#[path]`-included
|
|
// files are siblings,
|
|
//
|
|
// Note that this will produce weirdness when a file named `foo.rs` is
|
|
// `#[path]` included and contains a `mod foo;` declaration.
|
|
// If you encounter this, it's your own darn fault :P
|
|
let dir_ownership = DirOwnership::Owned { relative: None };
|
|
return Ok(ModulePathSuccess { file_path, dir_ownership });
|
|
}
|
|
|
|
let relative = match dir_ownership {
|
|
DirOwnership::Owned { relative } => relative,
|
|
DirOwnership::UnownedViaBlock => None,
|
|
};
|
|
let result = default_submod_path(&sess.parse_sess, ident, relative, dir_path);
|
|
match dir_ownership {
|
|
DirOwnership::Owned { .. } => result,
|
|
DirOwnership::UnownedViaBlock => Err(ModError::ModInBlock(match result {
|
|
Ok(_) | Err(ModError::MultipleCandidates(..)) => Some(ident),
|
|
_ => None,
|
|
})),
|
|
}
|
|
}
|
|
|
|
/// Derive a submodule path from the first found `#[path = "path_string"]`.
|
|
/// The provided `dir_path` is joined with the `path_string`.
|
|
fn mod_file_path_from_attr(
|
|
sess: &Session,
|
|
attrs: &[Attribute],
|
|
dir_path: &Path,
|
|
) -> Option<PathBuf> {
|
|
// Extract path string from first `#[path = "path_string"]` attribute.
|
|
let first_path = attrs.iter().find(|at| at.has_name(sym::path))?;
|
|
let Some(path_sym) = first_path.value_str() else {
|
|
// This check is here mainly to catch attempting to use a macro,
|
|
// such as #[path = concat!(...)]. This isn't currently supported
|
|
// because otherwise the InvocationCollector would need to defer
|
|
// loading a module until the #[path] attribute was expanded, and
|
|
// it doesn't support that (and would likely add a bit of
|
|
// complexity). Usually bad forms are checked in AstValidator (via
|
|
// `check_builtin_attribute`), but by the time that runs the macro
|
|
// is expanded, and it doesn't give an error.
|
|
validate_attr::emit_fatal_malformed_builtin_attribute(
|
|
&sess.parse_sess,
|
|
first_path,
|
|
sym::path,
|
|
);
|
|
};
|
|
|
|
let path_str = path_sym.as_str();
|
|
|
|
// On windows, the base path might have the form
|
|
// `\\?\foo\bar` in which case it does not tolerate
|
|
// mixed `/` and `\` separators, so canonicalize
|
|
// `/` to `\`.
|
|
#[cfg(windows)]
|
|
let path_str = path_str.replace("/", "\\");
|
|
|
|
Some(dir_path.join(path_str))
|
|
}
|
|
|
|
/// Returns a path to a module.
|
|
// Public for rustfmt usage.
|
|
pub fn default_submod_path<'a>(
|
|
sess: &'a ParseSess,
|
|
ident: Ident,
|
|
relative: Option<Ident>,
|
|
dir_path: &Path,
|
|
) -> Result<ModulePathSuccess, ModError<'a>> {
|
|
// If we're in a foo.rs file instead of a mod.rs file,
|
|
// we need to look for submodules in
|
|
// `./foo/<ident>.rs` and `./foo/<ident>/mod.rs` rather than
|
|
// `./<ident>.rs` and `./<ident>/mod.rs`.
|
|
let relative_prefix_string;
|
|
let relative_prefix = if let Some(ident) = relative {
|
|
relative_prefix_string = format!("{}{}", ident.name, path::MAIN_SEPARATOR);
|
|
&relative_prefix_string
|
|
} else {
|
|
""
|
|
};
|
|
|
|
let default_path_str = format!("{}{}.rs", relative_prefix, ident.name);
|
|
let secondary_path_str =
|
|
format!("{}{}{}mod.rs", relative_prefix, ident.name, path::MAIN_SEPARATOR);
|
|
let default_path = dir_path.join(&default_path_str);
|
|
let secondary_path = dir_path.join(&secondary_path_str);
|
|
let default_exists = sess.source_map().file_exists(&default_path);
|
|
let secondary_exists = sess.source_map().file_exists(&secondary_path);
|
|
|
|
match (default_exists, secondary_exists) {
|
|
(true, false) => Ok(ModulePathSuccess {
|
|
file_path: default_path,
|
|
dir_ownership: DirOwnership::Owned { relative: Some(ident) },
|
|
}),
|
|
(false, true) => Ok(ModulePathSuccess {
|
|
file_path: secondary_path,
|
|
dir_ownership: DirOwnership::Owned { relative: None },
|
|
}),
|
|
(false, false) => Err(ModError::FileNotFound(ident, default_path, secondary_path)),
|
|
(true, true) => Err(ModError::MultipleCandidates(ident, default_path, secondary_path)),
|
|
}
|
|
}
|
|
|
|
impl ModError<'_> {
|
|
fn report(self, sess: &Session, span: Span) -> ErrorGuaranteed {
|
|
let diag = &sess.parse_sess.span_diagnostic;
|
|
match self {
|
|
ModError::CircularInclusion(file_paths) => {
|
|
let mut msg = String::from("circular modules: ");
|
|
for file_path in &file_paths {
|
|
msg.push_str(&file_path.display().to_string());
|
|
msg.push_str(" -> ");
|
|
}
|
|
msg.push_str(&file_paths[0].display().to_string());
|
|
diag.struct_span_err(span, &msg)
|
|
}
|
|
ModError::ModInBlock(ident) => {
|
|
let msg = "cannot declare a non-inline module inside a block unless it has a path attribute";
|
|
let mut err = diag.struct_span_err(span, msg);
|
|
if let Some(ident) = ident {
|
|
let note =
|
|
format!("maybe `use` the module `{}` instead of redeclaring it", ident);
|
|
err.span_note(span, ¬e);
|
|
}
|
|
err
|
|
}
|
|
ModError::FileNotFound(ident, default_path, secondary_path) => {
|
|
let mut err = struct_span_err!(
|
|
diag,
|
|
span,
|
|
E0583,
|
|
"file not found for module `{}`",
|
|
ident,
|
|
);
|
|
err.help(&format!(
|
|
"to create the module `{}`, create file \"{}\" or \"{}\"",
|
|
ident,
|
|
default_path.display(),
|
|
secondary_path.display(),
|
|
));
|
|
err
|
|
}
|
|
ModError::MultipleCandidates(ident, default_path, secondary_path) => {
|
|
let mut err = struct_span_err!(
|
|
diag,
|
|
span,
|
|
E0761,
|
|
"file for module `{}` found at both \"{}\" and \"{}\"",
|
|
ident,
|
|
default_path.display(),
|
|
secondary_path.display(),
|
|
);
|
|
err.help("delete or rename one of them to remove the ambiguity");
|
|
err
|
|
}
|
|
ModError::ParserError(err) => err,
|
|
}.emit()
|
|
}
|
|
}
|