chore: apply rustc mod parsing changes

Author: calebcartwright

src/formatting.rs

@@ -178,7 +178,7 @@ fn format_file(
     original_snippet: Option<String>,
     is_macro_def: bool,
 ) -> Result<(), OperationError> {
-    let snippet_provider = parse_session.snippet_provider(module.as_ref().inner);
+    let snippet_provider = parse_session.snippet_provider(module.span);
     let mut visitor = FmtVisitor::from_parse_sess(
         &parse_session,
         config,

src/formatting/items.rs

@@ -3404,8 +3404,8 @@ pub(crate) fn rewrite_extern_crate(
 /// Returns `true` for `mod foo;`, false for `mod foo { .. }`.
 pub(crate) fn is_mod_decl(item: &ast::Item) -> bool {
     match item.kind {
-        ast::ItemKind::Mod(ref m) => m.inner.hi() != item.span.hi(),
-        _ => false,
+        ast::ItemKind::Mod(_, ast::ModKind::Loaded(_, ast::Inline::Yes, _)) => false,
+        _ => true,
     }
 }
 

src/formatting/modules.rs

@@ -6,6 +6,7 @@ use rustc_ast::ast;
 use rustc_ast::attr::HasAttrs;
 use rustc_ast::visit::Visitor;
 use rustc_span::symbol::{self, sym, Symbol};
+use rustc_span::Span;
 use thiserror::Error;
 
 use crate::config::FileName;
@@ -39,9 +40,12 @@ pub(crate) fn get_mod_inner_attrs<'a>(
 /// Represents module with its inner attributes.
 #[derive(Debug, Clone)]
 pub(crate) struct Module<'a> {
-    ast_mod: Cow<'a, ast::Mod>,
+    ast_mod_kind: Option<Cow<'a, ast::ModKind>>,
+    pub(crate) items: Cow<'a, Vec<rustc_ast::ptr::P<ast::Item>>>,
+    attrs: Cow<'a, Vec<ast::Attribute>>,
     ast_item: Option<Cow<'a, ast::Item>>,
     inner_attr: Vec<ast::Attribute>,
+    pub(crate) span: Span,
 }
 
 impl<'a> Module<'a> {
@@ -67,21 +71,30 @@ impl<'a> Module<'a> {
     }
 
     pub(crate) fn new(
-        ast_mod: Cow<'a, ast::Mod>,
+        mod_span: Span,
+        ast_mod_kind: Option<Cow<'a, ast::ModKind>>,
         ast_item: Option<Cow<'a, ast::Item>>,
-        attrs: &[ast::Attribute],
+        mod_items: Cow<'a, Vec<rustc_ast::ptr::P<ast::Item>>>,
+        mod_attrs: Cow<'a, Vec<ast::Attribute>>,
     ) -> Self {
-        let inner_attr = attrs
+        let inner_attr = mod_attrs
             .iter()
             .filter(|attr| attr.style == ast::AttrStyle::Inner)
             .cloned()
             .collect();
         Module {
+            ast_mod_kind,
             ast_item,
-            ast_mod,
+            items: mod_items,
+            attrs: mod_attrs,
             inner_attr,
+            span: mod_span,
         }
     }
+
+    pub(crate) fn outside_ast_mod_span(&self) -> Option<Span> {
+        self.ast_item.as_ref().map(|item| item.span)
+    }
 }
 
 impl<'a> HasAttrs for Module<'a> {
@@ -93,12 +106,6 @@ impl<'a> HasAttrs for Module<'a> {
     }
 }
 
-impl<'a> AsRef<ast::Mod> for Module<'a> {
-    fn as_ref(&self) -> &ast::Mod {
-        &self.ast_mod
-    }
-}
-
 /// Maps each module to the corresponding file.
 pub(crate) struct ModResolver<'ast, 'sess> {
     parse_sess: &'sess ParseSess,
@@ -164,11 +171,17 @@ impl<'ast, 'sess> ModResolver<'ast, 'sess> {
             _ => PathBuf::new(),
         };
 
-        self.visit_mod_from_ast(&krate.module)?;
+        self.visit_mod_from_ast(&krate.items)?;
 
         self.file_map.insert(
             root_filename,
-            Module::new(Cow::Borrowed(&krate.module), None, &krate.attrs),
+            Module::new(
+                krate.span,
+                None,
+                None,
+                Cow::Borrowed(&krate.items),
+                Cow::Borrowed(&krate.attrs),
+            ),
         );
         Ok(self.file_map)
     }
@@ -178,51 +191,63 @@ impl<'ast, 'sess> ModResolver<'ast, 'sess> {
         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) = module_item.item.kind {
+            if let ast::ItemKind::Mod(_, ref sub_mod_kind) = module_item.item.kind {
                 self.visit_sub_mod(Module::new(
-                    Cow::Owned(sub_mod.clone()),
+                    module_item.item.span,
+                    Some(Cow::Owned(sub_mod_kind.clone())),
                     Some(Cow::Owned(module_item.item)),
-                    &[],
+                    Cow::Owned(vec![]),
+                    Cow::Owned(vec![]),
                 ))?;
             }
         }
         Ok(())
     }
 
     /// Visit modules defined inside macro calls.
-    fn visit_mod_outside_ast(&mut self, module: ast::Mod) -> Result<(), ModuleResolutionError> {
-        for item in module.items {
+    fn visit_mod_outside_ast(
+        &mut self,
+        items: Vec<rustc_ast::ptr::P<ast::Item>>,
+    ) -> Result<(), ModuleResolutionError> {
+        for item in items {
             if is_cfg_if(&item) {
                 self.visit_cfg_if(Cow::Owned(item.into_inner()))?;
                 continue;
             }
 
-            if let ast::ItemKind::Mod(ref sub_mod) = item.kind {
+            if let ast::ItemKind::Mod(_, ref sub_mod_kind) = item.kind {
                 self.visit_sub_mod(Module::new(
-                    Cow::Owned(sub_mod.clone()),
+                    item.span,
+                    Some(Cow::Owned(sub_mod_kind.clone())),
                     Some(Cow::Owned(item.into_inner())),
-                    &[],
+                    Cow::Owned(vec![]),
+                    Cow::Owned(vec![]),
                 ))?;
             }
         }
         Ok(())
     }
 
     /// Visit modules from AST.
-    fn visit_mod_from_ast(&mut self, module: &'ast ast::Mod) -> Result<(), ModuleResolutionError> {
-        for item in &module.items {
+    fn visit_mod_from_ast(
+        &mut self,
+        items: &'ast Vec<rustc_ast::ptr::P<ast::Item>>,
+    ) -> Result<(), ModuleResolutionError> {
+        for item in items {
             if is_cfg_if(item) {
                 let result = self.visit_cfg_if(Cow::Borrowed(item));
                 if result.is_err() && self.recursive {
                     return result;
                 }
             }
 
-            if let ast::ItemKind::Mod(ref sub_mod) = item.kind {
+            if let ast::ItemKind::Mod(_, ref sub_mod_kind) = item.kind {
                 let result = self.visit_sub_mod(Module::new(
-                    Cow::Borrowed(sub_mod),
+                    item.span,
+                    Some(Cow::Borrowed(sub_mod_kind)),
                     Some(Cow::Borrowed(item)),
-                    &item.attrs,
+                    Cow::Owned(vec![]),
+                    Cow::Borrowed(&item.attrs),
                 ));
                 if result.is_err() && self.recursive {
                     return result;
@@ -330,9 +355,12 @@ impl<'ast, 'sess> ModResolver<'ast, 'sess> {
         if let Some(directory) = directory {
             self.directory = directory;
         }
-        match sub_mod.ast_mod {
-            Cow::Borrowed(sub_mod) => self.visit_mod_from_ast(sub_mod),
-            Cow::Owned(sub_mod) => self.visit_mod_outside_ast(sub_mod),
+        match (sub_mod.ast_mod_kind, sub_mod.items) {
+            (Some(Cow::Borrowed(ast::ModKind::Loaded(items, ast::Inline::No, _))), _) => {
+                self.visit_mod_from_ast(&items)
+            }
+            (Some(Cow::Owned(..)), Cow::Owned(items)) => self.visit_mod_outside_ast(items),
+            (_, _) => Ok(()),
         }
     }
 
@@ -351,12 +379,21 @@ impl<'ast, 'sess> ModResolver<'ast, 'sess> {
             if self.parse_sess.is_file_parsed(&path) {
                 return Ok(None);
             }
-            return match Parser::parse_file_as_module(self.parse_sess, &path, sub_mod.ast_mod.inner)
-            {
-                Ok(m) => Ok(Some(SubModKind::External(
+            return match Parser::parse_file_as_module(
+                self.parse_sess,
+                &path,
+                sub_mod.outside_ast_mod_span(),
+            ) {
+                Ok((attrs, items, span)) => Ok(Some(SubModKind::External(
                     path,
                     DirectoryOwnership::Owned { relative: None },
-                    Module::new(Cow::Owned(m.0), sub_mod.ast_item.clone(), &m.1),
+                    Module::new(
+                        span,
+                        Some(Cow::Owned(ast::ModKind::Unloaded)),
+                        sub_mod.ast_item.clone(),
+                        Cow::Owned(items),
+                        Cow::Owned(attrs),
+                    ),
                 ))),
                 Err(ParserError::ParseError) => Err(ModuleResolutionError {
                     module: sub_mod.name(),
@@ -394,17 +431,35 @@ impl<'ast, 'sess> ModResolver<'ast, 'sess> {
                         return Ok(Some(SubModKind::MultiExternal(mods_outside_ast)));
                     }
                 }
-                match Parser::parse_file_as_module(self.parse_sess, &path, sub_mod.ast_mod.inner) {
-                    Ok(m) if outside_mods_empty => Ok(Some(SubModKind::External(
-                        path,
-                        ownership,
-                        Module::new(Cow::Owned(m.0), sub_mod.ast_item.clone(), &m.1),
-                    ))),
-                    Ok(m) => {
+                match Parser::parse_file_as_module(
+                    self.parse_sess,
+                    &path,
+                    sub_mod.outside_ast_mod_span(),
+                ) {
+                    Ok((attrs, items, span)) if outside_mods_empty => {
+                        Ok(Some(SubModKind::External(
+                            path,
+                            ownership,
+                            Module::new(
+                                span,
+                                Some(Cow::Owned(ast::ModKind::Unloaded)),
+                                sub_mod.ast_item.clone(),
+                                Cow::Owned(items),
+                                Cow::Owned(attrs),
+                            ),
+                        )))
+                    }
+                    Ok((attrs, items, span)) => {
                         mods_outside_ast.push((
                             path.clone(),
                             ownership,
-                            Module::new(Cow::Owned(m.0), sub_mod.ast_item.clone(), &m.1),
+                            Module::new(
+                                span,
+                                Some(Cow::Owned(ast::ModKind::Unloaded)),
+                                sub_mod.ast_item.clone(),
+                                Cow::Owned(items),
+                                Cow::Owned(attrs),
+                            ),
                         ));
                         if should_insert {
                             mods_outside_ast.push((path, ownership, sub_mod.clone()));
@@ -494,10 +549,10 @@ impl<'ast, 'sess> ModResolver<'ast, 'sess> {
                 continue;
             }
 
-            let m = match Parser::parse_file_as_module(
+            let (attrs, items, span) = match Parser::parse_file_as_module(
                 self.parse_sess,
                 &actual_path,
-                sub_mod.ast_mod.inner,
+                sub_mod.outside_ast_mod_span(),
             ) {
                 Ok(m) => m,
                 Err(..) => continue,
@@ -506,7 +561,13 @@ impl<'ast, 'sess> ModResolver<'ast, 'sess> {
             result.push((
                 actual_path,
                 DirectoryOwnership::Owned { relative: None },
-                Module::new(Cow::Owned(m.0), sub_mod.ast_item.clone(), &m.1),
+                Module::new(
+                    span,
+                    Some(Cow::Owned(ast::ModKind::Unloaded)),
+                    sub_mod.ast_item.clone(),
+                    Cow::Owned(items),
+                    Cow::Owned(attrs),
+                ),
             ))
         }
         result

src/formatting/syntux/parser.rs

@@ -1,8 +1,8 @@
 use std::panic::{catch_unwind, AssertUnwindSafe};
 use std::path::{Path, PathBuf};
 
-use rustc_ast::ast;
 use rustc_ast::token::{DelimToken, TokenKind};
+use rustc_ast::{ast, ptr};
 use rustc_errors::Diagnostic;
 use rustc_parse::{
     new_parser_from_file,
@@ -123,11 +123,11 @@ impl<'a> Parser<'a> {
     pub(crate) fn parse_file_as_module(
         sess: &'a ParseSess,
         path: &Path,
-        span: Span,
-    ) -> Result<(ast::Mod, Vec<ast::Attribute>), ParserError> {
+        span: Option<Span>,
+    ) -> Result<(Vec<ast::Attribute>, Vec<ptr::P<ast::Item>>, Span), ParserError> {
         let result = catch_unwind(AssertUnwindSafe(|| {
-            let mut parser = new_parser_from_file(sess.inner(), &path, Some(span));
-            match parser.parse_mod(&TokenKind::Eof, ast::Unsafe::No) {
+            let mut parser = new_parser_from_file(sess.inner(), &path, span);
+            match parser.parse_mod(&TokenKind::Eof) {
                 Ok(result) => Some(result),
                 Err(mut e) => {
                     sess.emit_or_cancel_diagnostic(&mut e);