src/modules/visitor.rs

   1 use syntax::ast;
   2 use syntax::parse::token::{DelimToken, TokenKind};
   3 use syntax::parse::{stream_to_parser_with_base_dir, Directory, ParseSess};
   4 use syntax::symbol::kw;
   5 use syntax::visit::Visitor;
   6 use syntax_pos::Symbol;
   7
   8 use crate::attr::MetaVisitor;
   9
  10 pub(crate) struct ModItem {
  11     pub(crate) item: ast::Item,
  12 }
  13
  14 /// Traverse `cfg_if!` macro and fetch modules.
  15 pub(crate) struct CfgIfVisitor<'a> {
  16     parse_sess: &'a ParseSess,
  17     mods: Vec<ModItem>,
  18     base_dir: Directory<'a>,
  19 }
  20
  21 impl<'a> CfgIfVisitor<'a> {
  22     pub(crate) fn new(parse_sess: &'a ParseSess, base_dir: Directory<'a>) -> CfgIfVisitor<'a> {
  23         CfgIfVisitor {
  24             mods: vec![],
  25             parse_sess,
  26             base_dir,
  27         }
  28     }
  29
  30     pub(crate) fn mods(self) -> Vec<ModItem> {
  31         self.mods
  32     }
  33 }
  34
  35 impl<'a, 'ast: 'a> Visitor<'ast> for CfgIfVisitor<'a> {
  36     fn visit_mac(&mut self, mac: &'ast ast::Mac) {
  37         match self.visit_mac_inner(mac) {
  38             Ok(()) => (),
  39             Err(e) => debug!("{}", e),
  40         }
  41     }
  42 }
  43
  44 impl<'a, 'ast: 'a> CfgIfVisitor<'a> {
  45     fn visit_mac_inner(&mut self, mac: &'ast ast::Mac) -> Result<(), &'static str> {
  46         // Support both:
  47         // ```
  48         // extern crate cfg_if;
  49         // cfg_if::cfg_if! {..}
  50         // ```
  51         // And:
  52         // ```
  53         // #[macro_use]
  54         // extern crate cfg_if;
  55         // cfg_if! {..}
  56         // ```
  57         match mac.path.segments.first() {
  58             Some(first_segment) => {
  59                 if first_segment.ident.name != Symbol::intern("cfg_if") {
  60                     return Err("Expected cfg_if");
  61                 }
  62             }
  63             None => {
  64                 return Err("Expected cfg_if");
  65             }
  66         };
  67
  68         let mut parser =
  69             stream_to_parser_with_base_dir(self.parse_sess, mac.tts.clone(), self.base_dir.clone());
  70         parser.cfg_mods = false;
  71         let mut process_if_cfg = true;
  72
  73         while parser.token.kind != TokenKind::Eof {
  74             if process_if_cfg {
  75                 if !parser.eat_keyword(kw::If) {
  76                     return Err("Expected `if`");
  77                 }
  78                 parser
  79                     .parse_attribute(false)
  80                     .map_err(|_| "Failed to parse attributes")?;
  81             }
  82
  83             if !parser.eat(&TokenKind::OpenDelim(DelimToken::Brace)) {
  84                 return Err("Expected an opening brace");
  85             }
  86
  87             while parser.token != TokenKind::CloseDelim(DelimToken::Brace)
  88                 && parser.token.kind != TokenKind::Eof
  89             {
  90                 let item = match parser.parse_item() {
  91                     Ok(Some(item_ptr)) => item_ptr.into_inner(),
  92                     Ok(None) => continue,
  93                     Err(mut err) => {
  94                         err.cancel();
  95                         parser.sess.span_diagnostic.reset_err_count();
  96                         return Err(
  97                             "Expected item inside cfg_if block, but failed to parse it as an item",
  98                         );
  99                     }
 100                 };
 101                 if let ast::ItemKind::Mod(..) = item.kind {
 102                     self.mods.push(ModItem { item });
 103                 }
 104             }
 105
 106             if !parser.eat(&TokenKind::CloseDelim(DelimToken::Brace)) {
 107                 return Err("Expected a closing brace");
 108             }
 109
 110             if parser.eat(&TokenKind::Eof) {
 111                 break;
 112             }
 113
 114             if !parser.eat_keyword(kw::Else) {
 115                 return Err("Expected `else`");
 116             }
 117
 118             process_if_cfg = parser.token.is_keyword(kw::If);
 119         }
 120
 121         Ok(())
 122     }
 123 }
 124
 125 /// Extracts `path = "foo.rs"` from attributes.
 126 #[derive(Default)]
 127 pub(crate) struct PathVisitor {
 128     /// A list of path defined in attributes.
 129     paths: Vec<String>,
 130 }
 131
 132 impl PathVisitor {
 133     pub(crate) fn paths(self) -> Vec<String> {
 134         self.paths
 135     }
 136 }
 137
 138 impl<'ast> MetaVisitor<'ast> for PathVisitor {
 139     fn visit_meta_name_value(&mut self, meta_item: &'ast ast::MetaItem, lit: &'ast ast::Lit) {
 140         if meta_item.check_name(Symbol::intern("path")) && lit.kind.is_str() {
 141             self.paths.push(lit_to_str(lit));
 142         }
 143     }
 144 }
 145
 146 #[cfg(not(windows))]
 147 fn lit_to_str(lit: &ast::Lit) -> String {
 148     match lit.kind {
 149         ast::LitKind::Str(symbol, ..) => symbol.to_string(),
 150         _ => unreachable!(),
 151     }
 152 }
 153
 154 #[cfg(windows)]
 155 fn lit_to_str(lit: &ast::Lit) -> String {
 156     match lit.kind {
 157         ast::LitKind::Str(symbol, ..) => symbol.as_str().replace("/", "\\"),
 158         _ => unreachable!(),
 159     }
 160 }