src/modules.rs

   1 // Copyright 2015 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 use utils;
  12
  13 use std::path::{Path, PathBuf};
  14 use std::collections::HashMap;
  15
  16 use syntax::ast;
  17 use syntax::codemap;
  18 use syntax::parse::parser;
  19
  20
  21 /// List all the files containing modules of a crate.
  22 /// If a file is used twice in a crate, it appears only once.
  23 pub fn list_files<'a>(krate: &'a ast::Crate,
  24                       codemap: &codemap::CodeMap)
  25                       -> HashMap<PathBuf, &'a ast::Mod> {
  26     let mut result = HashMap::new();
  27     let root_filename: PathBuf = codemap.span_to_filename(krate.span).into();
  28     list_submodules(&krate.module,
  29                     root_filename.parent().unwrap(),
  30                     codemap,
  31                     &mut result);
  32     result.insert(root_filename, &krate.module);
  33     result
  34 }
  35
  36 /// Recursively list all external modules included in a module.
  37 fn list_submodules<'a>(module: &'a ast::Mod,
  38                        search_dir: &Path,
  39                        codemap: &codemap::CodeMap,
  40                        result: &mut HashMap<PathBuf, &'a ast::Mod>) {
  41     debug!("list_submodules: search_dir: {:?}", search_dir);
  42     for item in &module.items {
  43         if let ast::ItemMod(ref sub_mod) = item.node {
  44             if !utils::contains_skip(&item.attrs) {
  45                 let is_internal = codemap.span_to_filename(item.span) ==
  46                                   codemap.span_to_filename(sub_mod.inner);
  47                 let dir_path = if is_internal {
  48                     search_dir.join(&item.ident.to_string())
  49                 } else {
  50                     let mod_path = module_file(item.ident, &item.attrs, search_dir, codemap);
  51                     let dir_path = mod_path.parent().unwrap().to_owned();
  52                     result.insert(mod_path, sub_mod);
  53                     dir_path
  54                 };
  55                 list_submodules(sub_mod, &dir_path, codemap, result);
  56             }
  57         }
  58     }
  59 }
  60
  61 /// Find the file corresponding to an external mod
  62 fn module_file(id: ast::Ident,
  63                attrs: &[ast::Attribute],
  64                dir_path: &Path,
  65                codemap: &codemap::CodeMap)
  66                -> PathBuf {
  67     if let Some(path) = parser::Parser::submod_path_from_attr(attrs, &dir_path) {
  68         return path;
  69     }
  70
  71     match parser::Parser::default_submod_path(id, &dir_path, codemap).result {
  72         Ok(parser::ModulePathSuccess { path, .. }) => path,
  73         Err(_) => panic!("Couldn't find module {}", id),
  74     }
  75 }