Add skipped sub module inner attributes to module item attributes

Extends the sub module attribute association to also include inner
attributes for external sub modules that are skipped by rustfmt.

Author: ytmimi

src/modules.rs

@@ -109,12 +109,17 @@ enum SubModKind<'a, 'ast> {
     MultiExternal(Vec<(PathBuf, DirectoryOwnership, Module<'ast>)>),
     /// `mod foo {}`
     Internal(&'a ast::Item),
+    /// Just like External, but sub modules of this modules are not resolved,
+    /// and this module is not added to the FileModMap
+    SkippedExternal(PathBuf, DirectoryOwnership, Module<'ast>),
 }
 
 impl<'a, 'ast> SubModKind<'a, 'ast> {
     fn attrs(&self) -> Vec<ast::Attribute> {
         match self {
-            Self::External(_, _, module) => module.inner_attr.clone(),
+            Self::External(_, _, module) | Self::SkippedExternal(_, _, module) => {
+                module.inner_attr.clone()
+            }
             Self::MultiExternal(modules) => modules
                 .iter()
                 .map(|(_, _, module)| module.inner_attr.clone().into_iter())
@@ -263,10 +268,8 @@ impl<'ast, 'sess, 'c> ModResolver<'ast, 'sess> {
 
         let sub_mod_kind = self.peek_sub_mod(item, &sub_mod)?;
         if let Some(sub_mod_kind) = sub_mod_kind {
-            if matches!(
-                sub_mod_kind,
-                SubModKind::External(..) | SubModKind::MultiExternal(_)
-            ) {
+            let is_internal_mod = matches!(sub_mod_kind, SubModKind::Internal(_));
+            if !is_internal_mod {
                 self.update_mod_item_with_submod_attrs(item, &sub_mod_kind)
             }
             self.insert_sub_mod(sub_mod_kind.clone())?;
@@ -305,14 +308,12 @@ impl<'ast, 'sess, 'c> ModResolver<'ast, 'sess> {
         item: &'c ast::Item,
         sub_mod: &Module<'ast>,
     ) -> Result<Option<SubModKind<'c, 'ast>>, ModuleResolutionError> {
-        if contains_skip(&item.attrs) {
-            return Ok(None);
-        }
-
         if is_mod_decl(item) {
             // mod foo;
             // Look for an extern file.
             self.find_external_module(item.ident, &item.attrs, sub_mod)
+        } else if contains_skip(&item.attrs) {
+            return Ok(None);
         } else {
             // An internal module (`mod foo { /* ... */ }`);
             Ok(Some(SubModKind::Internal(item)))
@@ -370,6 +371,7 @@ impl<'ast, 'sess, 'c> ModResolver<'ast, 'sess> {
                 }
                 Ok(())
             }
+            SubModKind::SkippedExternal(..) => Ok(()),
         }
     }
 
@@ -408,7 +410,18 @@ impl<'ast, 'sess, 'c> ModResolver<'ast, 'sess> {
                 return Ok(None);
             }
             return match Parser::parse_file_as_module(self.parse_sess, &path, sub_mod.span) {
-                Ok((ref attrs, _, _)) if contains_skip(attrs) => Ok(None),
+                Ok((attrs, items, span)) if contains_skip(&attrs) => {
+                    Ok(Some(SubModKind::SkippedExternal(
+                        path,
+                        DirectoryOwnership::Owned { relative: None },
+                        Module::new(
+                            span,
+                            Some(Cow::Owned(ast::ModKind::Unloaded)),
+                            Cow::Owned(items),
+                            Cow::Owned(attrs),
+                        ),
+                    )))
+                }
                 Ok((attrs, items, span)) => Ok(Some(SubModKind::External(
                     path,
                     DirectoryOwnership::Owned { relative: None },
@@ -457,7 +470,18 @@ impl<'ast, 'sess, 'c> ModResolver<'ast, 'sess> {
                     }
                 }
                 match Parser::parse_file_as_module(self.parse_sess, &file_path, sub_mod.span) {
-                    Ok((ref attrs, _, _)) if contains_skip(attrs) => Ok(None),
+                    Ok((attrs, items, span)) if contains_skip(&attrs) => {
+                        Ok(Some(SubModKind::SkippedExternal(
+                            file_path,
+                            dir_ownership,
+                            Module::new(
+                                span,
+                                Some(Cow::Owned(ast::ModKind::Unloaded)),
+                                Cow::Owned(items),
+                                Cow::Owned(attrs),
+                            ),
+                        )))
+                    }
                     Ok((attrs, items, span)) if outside_mods_empty => {
                         Ok(Some(SubModKind::External(
                             file_path,

src/modules/test.rs

@@ -7,6 +7,7 @@ use crate::attr::contains_name;
 use crate::config::{Config, FileName};
 use crate::parse::parser::{DirectoryOwnership, Parser};
 use crate::parse::session::ParseSess;
+use crate::utils::contains_skip;
 use crate::Input;
 
 fn validate_file_mod_map<F: Fn(&FileModMap<'_>)>(mod_path: &PathBuf, recursive: bool, f: F) {
@@ -52,5 +53,15 @@ fn external_sub_module_inner_attrs_are_present_in_mod_item_attrs_list() {
 
         let mod_b = get_submodule(module, "b");
         assert!(contains_name(&mod_b.attrs, sym::macro_use));
+
+        // mod c is annotated with `#[rustfmt::skip]`, but we should still have access to
+        // the inner attributes
+        let mod_c = get_submodule(module, "c");
+        assert!(contains_name(&mod_c.attrs, sym::macro_use));
+        assert!(contains_skip(&mod_c.attrs));
+
+        // mod d is annotated with an inner `#![rustfmt::skip]` attribute.
+        let mod_d = get_submodule(module, "d");
+        assert!(contains_skip(&mod_d.attrs));
     });
 }

tests/mod-resolver/issue-4959-sub-mod-inner-attr/c.rs

@@ -0,0 +1 @@
+#![macro_use]

tests/mod-resolver/issue-4959-sub-mod-inner-attr/d.rs

@@ -0,0 +1 @@
+#![rustfmt::skip]

tests/mod-resolver/issue-4959-sub-mod-inner-attr/lib.rs

@@ -1,2 +1,5 @@
 mod b;
 mod a;
+#[rustfmt::skip]
+mod c;
+mod d;