// except according to those terms.
use std::collections::BTreeMap;
-use std::path::{Path, PathBuf};
use std::io;
+use std::path::{Path, PathBuf};
use syntax::ast;
use syntax::codemap;
-use syntax::parse::parser;
+use syntax::parse::{parser, DirectoryOwnership};
+use syntax_pos::symbol::Symbol;
+use config::FileName;
use utils::contains_skip;
/// List all the files containing modules of a crate.
pub fn list_files<'a>(
krate: &'a ast::Crate,
codemap: &codemap::CodeMap,
-) -> Result<BTreeMap<PathBuf, &'a ast::Mod>, io::Error> {
+) -> Result<BTreeMap<FileName, &'a ast::Mod>, io::Error> {
let mut result = BTreeMap::new(); // Enforce file order determinism
- let root_filename: PathBuf = codemap.span_to_filename(krate.span).into();
- list_submodules(
- &krate.module,
- root_filename.parent().unwrap(),
- codemap,
- &mut result,
- )?;
- result.insert(root_filename, &krate.module);
+ let root_filename = codemap.span_to_filename(krate.span);
+ {
+ let parent = match root_filename {
+ codemap::FileName::Real(ref path) => path.parent().unwrap(),
+ _ => Path::new(""),
+ };
+ list_submodules(&krate.module, parent, None, codemap, &mut result)?;
+ }
+ result.insert(root_filename.into(), &krate.module);
Ok(result)
}
+fn path_value(attr: &ast::Attribute) -> Option<Symbol> {
+ if attr.name() == "path" {
+ attr.value_str()
+ } else {
+ None
+ }
+}
+
+// N.B. Even when there are multiple `#[path = ...]` attributes, we just need to
+// examine the first one, since rustc ignores the second and the subsequent ones
+// as unused attributes.
+fn find_path_value(attrs: &[ast::Attribute]) -> Option<Symbol> {
+ attrs.iter().flat_map(path_value).next()
+}
+
/// Recursively list all external modules included in a module.
fn list_submodules<'a>(
module: &'a ast::Mod,
search_dir: &Path,
+ relative: Option<ast::Ident>,
codemap: &codemap::CodeMap,
- result: &mut BTreeMap<PathBuf, &'a ast::Mod>,
+ result: &mut BTreeMap<FileName, &'a ast::Mod>,
) -> Result<(), io::Error> {
debug!("list_submodules: search_dir: {:?}", search_dir);
for item in &module.items {
if !contains_skip(&item.attrs) {
let is_internal =
codemap.span_to_filename(item.span) == codemap.span_to_filename(sub_mod.inner);
- let dir_path = if is_internal {
- search_dir.join(&item.ident.to_string())
+ let (dir_path, relative) = if is_internal {
+ if let Some(path) = find_path_value(&item.attrs) {
+ (search_dir.join(&path.as_str()), None)
+ } else {
+ (search_dir.join(&item.ident.to_string()), None)
+ }
} else {
- let mod_path = module_file(item.ident, &item.attrs, search_dir, codemap)?;
+ let (mod_path, relative) =
+ module_file(item.ident, &item.attrs, search_dir, relative, codemap)?;
let dir_path = mod_path.parent().unwrap().to_owned();
- result.insert(mod_path, sub_mod);
- dir_path
+ result.insert(FileName::Real(mod_path), sub_mod);
+ (dir_path, relative)
};
- list_submodules(sub_mod, &dir_path, codemap, result)?;
+ list_submodules(sub_mod, &dir_path, relative, codemap, result)?;
}
}
}
id: ast::Ident,
attrs: &[ast::Attribute],
dir_path: &Path,
+ relative: Option<ast::Ident>,
codemap: &codemap::CodeMap,
-) -> Result<PathBuf, io::Error> {
+) -> Result<(PathBuf, Option<ast::Ident>), io::Error> {
if let Some(path) = parser::Parser::submod_path_from_attr(attrs, dir_path) {
- return Ok(path);
+ return Ok((path, None));
}
- match parser::Parser::default_submod_path(id, dir_path, codemap).result {
- Ok(parser::ModulePathSuccess { path, .. }) => Ok(path),
+ match parser::Parser::default_submod_path(id, relative, dir_path, codemap).result {
+ Ok(parser::ModulePathSuccess {
+ path,
+ directory_ownership,
+ ..
+ }) => {
+ let relative = if let DirectoryOwnership::Owned { relative } = directory_ownership {
+ relative
+ } else {
+ None
+ };
+ Ok((path, relative))
+ }
Err(_) => Err(io::Error::new(
io::ErrorKind::Other,
format!("Couldn't find module {}", id),