Inline ModItem and preserve P

Author: camsteffen

src/modules.rs

@@ -155,17 +155,13 @@ impl<'ast, 'sess> ModResolver<'ast, 'sess> {
     fn visit_cfg_if(&mut self, item: &ast::Item) -> Result<(), ModuleResolutionError> {
         let mut visitor = visitor::CfgIfVisitor::new(self.parse_sess);
         visitor.visit_item(item);
-        for module_item in visitor.mods() {
-            if let ast::ItemKind::Mod(_, ref sub_mod_kind) = module_item.item.kind {
+        for item in visitor.items {
+            if let ast::ItemKind::Mod(_, ref sub_mod_kind) = item.kind {
                 let items = match sub_mod_kind {
                     ast::ModKind::Loaded(items, ..) => Cow::Borrowed(items),
                     _ => Cow::Owned(ThinVec::new()),
                 };
-                self.visit_sub_mod(
-                    &module_item.item,
-                    Module::new(module_item.item.span, items, &[]),
-                    false,
-                )?;
+                self.visit_sub_mod(&item, Module::new(item.span, items, &[]), false)?;
             }
         }
         Ok(())

src/modules/visitor.rs

@@ -1,32 +1,25 @@
 use rustc_ast::ast;
+use rustc_ast::ptr::P;
 use rustc_ast::visit::Visitor;
 use rustc_span::Symbol;
 
 use crate::attr::MetaVisitor;
 use crate::parse::macros::cfg_if::parse_cfg_if;
 use crate::parse::session::ParseSess;
 
-pub(crate) struct ModItem {
-    pub(crate) item: ast::Item,
-}
-
 /// Traverse `cfg_if!` macro and fetch modules.
 pub(crate) struct CfgIfVisitor<'a> {
     parse_sess: &'a ParseSess,
-    mods: Vec<ModItem>,
+    pub(crate) items: Vec<P<ast::Item>>,
 }
 
 impl<'a> CfgIfVisitor<'a> {
     pub(crate) fn new(parse_sess: &'a ParseSess) -> CfgIfVisitor<'a> {
         CfgIfVisitor {
-            mods: vec![],
             parse_sess,
+            items: Vec::new(),
         }
     }
-
-    pub(crate) fn mods(self) -> Vec<ModItem> {
-        self.mods
-    }
 }
 
 impl<'a, 'ast: 'a> Visitor<'ast> for CfgIfVisitor<'a> {
@@ -63,8 +56,7 @@ impl<'a, 'ast: 'a> CfgIfVisitor<'a> {
         };
 
         let items = parse_cfg_if(self.parse_sess, mac)?;
-        self.mods
-            .append(&mut items.into_iter().map(|item| ModItem { item }).collect());
+        self.items.extend(items);
 
         Ok(())
     }

src/parse/macros/cfg_if.rs

@@ -1,6 +1,7 @@
 use std::panic::{catch_unwind, AssertUnwindSafe};
 
 use rustc_ast::ast;
+use rustc_ast::ptr::P;
 use rustc_ast::token::{Delimiter, TokenKind};
 use rustc_parse::parser::ForceCollect;
 use rustc_span::symbol::kw;
@@ -11,7 +12,7 @@ use crate::parse::session::ParseSess;
 pub(crate) fn parse_cfg_if<'a>(
     sess: &'a ParseSess,
     mac: &'a ast::MacCall,
-) -> Result<Vec<ast::Item>, &'static str> {
+) -> Result<Vec<P<ast::Item>>, &'static str> {
     match catch_unwind(AssertUnwindSafe(|| parse_cfg_if_inner(sess, mac))) {
         Ok(Ok(items)) => Ok(items),
         Ok(err @ Err(_)) => err,
@@ -22,7 +23,7 @@ pub(crate) fn parse_cfg_if<'a>(
 fn parse_cfg_if_inner<'a>(
     sess: &'a ParseSess,
     mac: &'a ast::MacCall,
-) -> Result<Vec<ast::Item>, &'static str> {
+) -> Result<Vec<P<ast::Item>>, &'static str> {
     let ts = mac.args.tokens.clone();
     let mut parser = build_stream_parser(sess.inner(), ts);
 
@@ -63,7 +64,7 @@ fn parse_cfg_if_inner<'a>(
             && parser.token.kind != TokenKind::Eof
         {
             let item = match parser.parse_item(ForceCollect::No) {
-                Ok(Some(item_ptr)) => item_ptr.into_inner(),
+                Ok(Some(item_ptr)) => item_ptr,
                 Ok(None) => continue,
                 Err(err) => {
                     err.cancel();