Tie inner attributes to the correct #[cfg(..)] mod

It's possible that multiple modules could have the same name. E.g.:

    #[cfg(linux)]
    mod foo;
    #[cfg(not(linux))]
    mod foo;

Previously, we would just assign attributes to the first module we found
with the same name as the one we were trying to associate inner
attributes with.This lead to a situation where we assigned all inner sub
module attributes to the first module we found.

Now we also ensure the spans for each item match so that we know we're
associating the inner attributes with the correct mod item.

Author: ytmimi

src/modules.rs

@@ -294,7 +294,12 @@ impl<'ast, 'sess, 'c> ModResolver<'ast, 'sess> {
                     .to_mut()
                     .iter_mut()
                     .filter(|i| matches!(i.kind, ast::ItemKind::Mod(..)))
-                    .find(|i| i.ident == item.ident)
+                    .find(|i| {
+                        // The module names need to be the same, and to account for multiple modules
+                        // with the same name (e.g. those annotated with `#[cfg(..)]` we also check
+                        // the spans to make sure we're adding attributes to the correct item.
+                        i.ident == item.ident && i.span == item.span
+                    })
                 {
                     mod_item.attrs.extend(sub_mod_kind.attrs())
                 }

src/modules/test.rs

@@ -29,10 +29,19 @@ fn validate_file_mod_map<F: Fn(&FileModMap<'_>)>(mod_path: &PathBuf, recursive:
 }
 
 fn get_submodule<'a>(module: &'a Module<'_>, mod_name: &str) -> &'a rustc_ast::ast::Item {
+    get_nth_submodule(module, mod_name, 0)
+}
+
+fn get_nth_submodule<'a>(
+    module: &'a Module<'_>,
+    mod_name: &str,
+    position: usize,
+) -> &'a rustc_ast::ast::Item {
     module
         .items
         .iter()
-        .find(|i| i.ident == Ident::from_str(mod_name))
+        .filter(|i| i.ident == Ident::from_str(mod_name))
+        .nth(position)
         .unwrap()
 }
 
@@ -63,5 +72,15 @@ fn external_sub_module_inner_attrs_are_present_in_mod_item_attrs_list() {
         // mod d is annotated with an inner `#![rustfmt::skip]` attribute.
         let mod_d = get_submodule(module, "d");
         assert!(contains_skip(&mod_d.attrs));
+
+        // mod e is defined in both e1.rs and e2.rs depending on the operating system.
+        // We should ensure that attributes from one path aren't added to the other.
+        let mod_e1 = get_nth_submodule(module, "e", 0);
+        assert!(contains_name(&mod_e1.attrs, sym::no_std));
+        assert!(!contains_name(&mod_e1.attrs, sym::no_implicit_prelude));
+
+        let mod_e2 = get_nth_submodule(module, "e", 1);
+        assert!(contains_name(&mod_e2.attrs, sym::no_implicit_prelude));
+        assert!(!contains_name(&mod_e2.attrs, sym::no_std));
     });
 }

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

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

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

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

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

@@ -3,3 +3,10 @@ mod a;
 #[rustfmt::skip]
 mod c;
 mod d;
+
+#[cfg(linux)]
+#[path ="e1.rs"]
+mod e;
+#[cfg(not(linux))]
+#[path ="e2.rs"]
+mod e;