Fix nonsensical #[path] attributes being silently allowed

Changes:
- compiler/rustc_hir/src/attrs/data_structures.rs: Extended
  AttributeKind::Path variant to carry AttrStyle alongside
  the Symbol, enabling inner/outer attribute distinction

- compiler/rustc_attr_parsing/src/attributes/path.rs: Updated
  convert in SingleAttributeParser for PathParser to pass
  cx.attr_style into AttributeKind::Path

- compiler/rustc_passes/src/check_attr.rs: Added
  check_path_attribute to validate and emit errors for useless
  #[path] and #![path] attributes on inline modules

- compiler/rustc_passes/src/errors.rs: Added
  UselessPathAttribute and UselessInnerPathAttribute error structs

- 	ests/ui/attributes/path-inline-module.rs: UI tests covering
  all four validation cases

- 	ests/ui/attributes/path-inline-module.stderr: Expected
  diagnostics for the above tests

Author: krishkumarwork3-beep

compiler/rustc_attr_parsing/src/attributes/path.rs

@@ -19,6 +19,6 @@ impl SingleAttributeParser for PathParser {
         let nv = cx.expect_name_value(args, cx.attr_span, None)?;
         let path = cx.expect_string_literal(nv)?;
 
-        Some(AttributeKind::Path(path))
+        Some(AttributeKind::Path(path, cx.attr_style))
     }
 }

compiler/rustc_hir/src/attrs/data_structures.rs

@@ -1210,7 +1210,7 @@ pub enum AttributeKind {
     },
 
     /// Represents `#[path]`
-    Path(Symbol),
+    Path(Symbol, AttrStyle),
 
     /// Represents `#[pattern_complexity_limit]`
     PatternComplexityLimit {

compiler/rustc_passes/src/check_attr.rs

@@ -305,7 +305,9 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             AttributeKind::Optimize(..) => (),
             AttributeKind::PanicRuntime => (),
             AttributeKind::PatchableFunctionEntry { .. } => (),
-            AttributeKind::Path(..) => (),
+            AttributeKind::Path(_, style) => {
+                self.check_path_attribute(*style, hir_id, span)
+            }
             AttributeKind::PatternComplexityLimit { .. } => (),
             AttributeKind::PinV2(..) => (),
             AttributeKind::PreludeImport => (),
@@ -938,7 +940,49 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             }
         }
     }
-
+    fn check_path_attribute(&self, style: AttrStyle, hir_id: HirId, span: Span) {
+    let mod_span = self.tcx.hir_span(hir_id);
+    if mod_span.from_expansion() {
+        return;
+    }
+    let node = self.tcx.hir_node(hir_id);
+    let item_kind = match node {
+        hir::Node::Item(item) => Some(&item.kind),
+        _ => None,
+    };
+    match item_kind {
+        Some(ItemKind::Mod(_, module)) => {
+            let is_outer_attr = matches!(style, ast::AttrStyle::Outer);
+            let is_inner_attr = matches!(style, ast::AttrStyle::Inner);
+
+            let inner_span = module.spans.inner_span;
+            let is_inline_module = self.tcx.sess.source_map()
+                .lookup_char_pos(span.lo()).file.name
+                == self.tcx.sess.source_map()
+                .lookup_char_pos(inner_span.lo()).file.name;
+
+            let has_nested_external_modules = module.item_ids.iter().any(|item_id| {
+                let item = self.tcx.hir_item(*item_id);
+                if let ItemKind::Mod(_, nested_mod) = &item.kind {
+                    let nested_inner = nested_mod.spans.inner_span;
+                    let nested_item_span = self.tcx.hir_span(item.hir_id());
+                    return self.tcx.sess.source_map()
+                        .lookup_char_pos(nested_item_span.lo()).file.name
+                        != self.tcx.sess.source_map()
+                        .lookup_char_pos(nested_inner.lo()).file.name;
+                }
+                false
+            });
+            if is_outer_attr && is_inline_module && !has_nested_external_modules {
+                self.dcx().emit_err(errors::UselessPathAttribute { span });
+            }
+            else if is_inner_attr && !has_nested_external_modules {
+                self.dcx().emit_err(errors::UselessInnerPathAttribute { span });
+            }
+        }
+        _ => {}
+    }
+}
     /// Checks `#[doc(inline)]`/`#[doc(no_inline)]` attributes.
     ///
     /// A doc inlining attribute is invalid if it is applied to a non-`use` item, or

compiler/rustc_passes/src/errors.rs

@@ -13,6 +13,20 @@ use rustc_span::{DUMMY_SP, Ident, Span, Symbol};
 use crate::check_attr::ProcMacroKind;
 use crate::lang_items::Duplicate;
 
+
+#[derive(Diagnostic)]
+#[diag("attribute `#[path]` is useless on inline modules")]
+pub(crate) struct UselessPathAttribute {
+    #[primary_span]
+    pub span: Span,
+}
+#[derive(Diagnostic)]
+#[diag("attribute `#[path]` is useless here as there are no nested external modules")]
+pub(crate) struct UselessInnerPathAttribute {
+    #[primary_span]
+    pub span: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag("`#[loop_match]` should be applied to a loop")]
 pub(crate) struct LoopMatchAttr {

tests/ui/attributes/path-inline-module.rs

@@ -0,0 +1,24 @@
+// ERROR: #[path] on inline module with NO external submodules
+#[path = "foo.rs"]
+mod inline_module {} //~ ERROR attribute `#[path]` is useless on inline modules
+
+// ERROR: #[path] on inline module with only inline submodules
+#[path = "foo.rs"]
+mod inline_with_inline_sub { //~ ERROR attribute `#[path]` is useless on inline modules
+    mod inner {} // inline, not external
+}
+
+// ERROR: #![path] inside module with no external submodules
+mod useless_inner { //~ ERROR attribute `#[path]` is useless here as there are no nested external modules
+    #![path = "some_dir"]
+    // no external submodules
+}
+
+// ERROR: #![path] inside module where submodule is inline (has body)
+mod thread_inline_sub { //~ ERROR attribute `#[path]` is useless here as there are no nested external modules
+    #![path = "thread_files"]
+    #[path = "tls.rs"]
+    mod local_data {} //~ ERROR attribute `#[path]` is useless on inline modules
+}
+
+fn main() {}

tests/ui/attributes/path-inline-module.stderr

@@ -0,0 +1,41 @@
+error: attribute `#[path]` is useless on inline modules
+  --> $DIR/path-inline-module.rs:3:1
+   |
+LL | mod inline_module {}
+   | ^^^^^^^^^^^^^^^^^^^^
+
+error: attribute `#[path]` is useless on inline modules
+  --> $DIR/path-inline-module.rs:7:1
+   |
+LL | / mod inline_with_inline_sub {
+LL | |     mod inner {} // inline, not external
+LL | | }
+   | |_^
+
+error: attribute `#[path]` is useless here as there are no nested external modules
+  --> $DIR/path-inline-module.rs:12:1
+   |
+LL | / mod useless_inner {
+LL | |     #![path = "some_dir"]
+LL | |     // no external submodules
+LL | | }
+   | |_^
+
+error: attribute `#[path]` is useless here as there are no nested external modules
+  --> $DIR/path-inline-module.rs:18:1
+   |
+LL | / mod thread_inline_sub {
+LL | |     #![path = "thread_files"]
+LL | |     #[path = "tls.rs"]
+LL | |     mod local_data {}
+LL | | }
+   | |_^
+
+error: attribute `#[path]` is useless on inline modules
+  --> $DIR/path-inline-module.rs:21:5
+   |
+LL |     mod local_data {}
+   |     ^^^^^^^^^^^^^^^^^
+
+error: aborting due to 5 previous errors
+