Stop tracking whether macros are exported in HIR

inquisitivecrystal · inquisitivecrystal · commit 020a39156f94 · 2021-08-15T14:18:46.000-07:00
diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs
@@ -443,23 +443,15 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 self.lower_param_bounds(bounds, ImplTraitContext::disallowed()),
             ),
             ItemKind::MacroDef(MacroDef { ref body, macro_rules }) => {
-                let is_exported = !macro_rules
-                    || attrs.map_or(false, |a| self.sess.contains_name(a, sym::macro_export));
-
                 let body = P(self.lower_mac_args(body));
 
-                hir::ItemKind::Macro {
-                    // `is_exported` is duplicated, to make matching more convenient.
-                    is_exported,
-                    macro_def: hir::MacroDef {
-                        is_exported,
-                        ident: *ident,
-                        vis: *vis,
-                        def_id: hir_id.expect_owner(),
-                        span,
-                        ast: MacroDef { body, macro_rules },
-                    },
-                }
+                hir::ItemKind::Macro(hir::MacroDef {
+                    ident: *ident,
+                    vis: *vis,
+                    def_id: hir_id.expect_owner(),
+                    span,
+                    ast: MacroDef { body, macro_rules },
+                })
             }
             ItemKind::MacCall(..) => {
                 panic!("`TyMac` should have been expanded by now")
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
@@ -772,7 +772,6 @@ impl Crate<'_> {
 /// Not parsed directly, but created on macro import or `macro_rules!` expansion.
 #[derive(Debug)]
 pub struct MacroDef<'hir> {
-    pub is_exported: bool,
     pub ident: Ident,
     pub vis: Visibility<'hir>,
     pub def_id: LocalDefId,
@@ -2781,7 +2780,7 @@ pub enum ItemKind<'hir> {
     /// An external module, e.g. `extern { .. }`.
     ForeignMod { abi: Abi, items: &'hir [ForeignItemRef<'hir>] },
     /// A MBE macro (`macro_rules!` or `macro`).
-    Macro { is_exported: bool, macro_def: MacroDef<'hir> },
+    Macro(MacroDef<'hir>),
     /// Module-level inline assembly (from `global_asm!`).
     GlobalAsm(&'hir InlineAsm<'hir>),
     /// A type alias, e.g., `type Foo = Bar<u8>`.
diff --git a/compiler/rustc_hir/src/intravisit.rs b/compiler/rustc_hir/src/intravisit.rs
@@ -593,7 +593,7 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item<'v>) {
             visitor.visit_id(item.hir_id());
             walk_list!(visitor, visit_foreign_item_ref, items);
         }
-        ItemKind::Macro { ref macro_def, .. } => {
+        ItemKind::Macro(ref macro_def) => {
             visitor.visit_id(item.hir_id());
             visitor.visit_macro_def(macro_def)
         }
diff --git a/compiler/rustc_hir/src/stable_hash_impls.rs b/compiler/rustc_hir/src/stable_hash_impls.rs
@@ -193,7 +193,7 @@ impl<HirCtx: crate::HashStableContext> HashStable<HirCtx> for Item<'_> {
 
 impl<HirCtx: crate::HashStableContext> HashStable<HirCtx> for MacroDef<'_> {
     fn hash_stable(&self, hcx: &mut HirCtx, hasher: &mut StableHasher) {
-        let MacroDef { is_exported: _, ident, def_id: _, ref ast, ref vis, span } = *self;
+        let MacroDef { ident, def_id: _, ref ast, ref vis, span } = *self;
 
         hcx.hash_hir_item_like(|hcx| {
             ident.name.hash_stable(hcx, hasher);
diff --git a/compiler/rustc_hir_pretty/src/lib.rs b/compiler/rustc_hir_pretty/src/lib.rs
@@ -660,7 +660,7 @@ impl<'a> State<'a> {
                 }
                 self.bclose(item.span);
             }
-            hir::ItemKind::Macro { ref macro_def, .. } => {
+            hir::ItemKind::Macro(ref macro_def) => {
                 let (kw, has_bang) = if macro_def.ast.macro_rules {
                     ("macro_rules", true)
                 } else {
diff --git a/compiler/rustc_lint/src/builtin.rs b/compiler/rustc_lint/src/builtin.rs
@@ -617,7 +617,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingDoc {
                 return;
             }
 
-            hir::ItemKind::Macro { is_exported: true, .. }
+            hir::ItemKind::Macro { .. }
             | hir::ItemKind::TyAlias(..)
             | hir::ItemKind::Fn(..)
             | hir::ItemKind::Mod(..)
diff --git a/compiler/rustc_metadata/src/rmeta/encoder.rs b/compiler/rustc_metadata/src/rmeta/encoder.rs
@@ -1374,12 +1374,8 @@ impl EncodeContext<'a, 'tcx> {
                 return self.encode_info_for_mod(item.def_id, m);
             }
             hir::ItemKind::ForeignMod { .. } => EntryKind::ForeignMod,
-            hir::ItemKind::Macro { is_exported, ref macro_def } => {
-                if is_exported {
-                    EntryKind::MacroDef(self.lazy(macro_def.ast.clone()))
-                } else {
-                    return;
-                }
+            hir::ItemKind::Macro(ref macro_def) => {
+                EntryKind::MacroDef(self.lazy(macro_def.ast.clone()))
             }
             hir::ItemKind::GlobalAsm(..) => EntryKind::GlobalAsm,
             hir::ItemKind::TyAlias(..) => EntryKind::Type,
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
@@ -1512,8 +1512,11 @@ impl Visitor<'tcx> for CheckAttrVisitor<'tcx> {
         // Historically we've run more checks on non-exported than exported macros,
         // so this lets us continue to run them while maintaining backwards compatibility.
         // In the long run, the checks should be harmonized.
-        if let ItemKind::Macro { is_exported: false, .. } = item.kind {
-            check_non_exported_macro_for_invalid_attrs(self.tcx, item);
+        if let ItemKind::Macro(ref macro_def) = item.kind {
+            let def_id = item.def_id.to_def_id();
+            if macro_def.ast.macro_rules && !self.tcx.has_attr(def_id, sym::macro_export) {
+                check_non_exported_macro_for_invalid_attrs(self.tcx, item);
+            }
         }
 
         let target = Target::from_item(item);
diff --git a/compiler/rustc_passes/src/stability.rs b/compiler/rustc_passes/src/stability.rs
@@ -622,7 +622,6 @@ impl<'tcx> Visitor<'tcx> for MissingStabilityAnnotations<'tcx> {
             i.kind,
             hir::ItemKind::Impl(hir::Impl { of_trait: None, .. })
                 | hir::ItemKind::ForeignMod { .. }
-                | hir::ItemKind::Macro { is_exported: false, .. }
         ) {
             self.check_missing_stability(i.def_id, i.span);
         }
diff --git a/compiler/rustc_privacy/src/lib.rs b/compiler/rustc_privacy/src/lib.rs
@@ -25,7 +25,7 @@ use rustc_middle::ty::subst::{InternalSubsts, Subst};
 use rustc_middle::ty::{self, Const, GenericParamDefKind, TraitRef, Ty, TyCtxt, TypeFoldable};
 use rustc_session::lint;
 use rustc_span::hygiene::Transparency;
-use rustc_span::symbol::{kw, Ident};
+use rustc_span::symbol::{kw, sym, Ident};
 use rustc_span::Span;
 use rustc_trait_selection::traits::const_evaluatable::{self, AbstractConst};
 
@@ -507,11 +507,7 @@ impl EmbargoVisitor<'tcx> {
         }
         match def_kind {
             // No type privacy, so can be directly marked as reachable.
-            DefKind::Const
-            | DefKind::Macro(_)
-            | DefKind::Static
-            | DefKind::TraitAlias
-            | DefKind::TyAlias => {
+            DefKind::Const | DefKind::Static | DefKind::TraitAlias | DefKind::TyAlias => {
                 if vis.is_accessible_from(module.to_def_id(), self.tcx) {
                     self.update(def_id, level);
                 }
@@ -566,6 +562,7 @@ impl EmbargoVisitor<'tcx> {
             | DefKind::ExternCrate
             | DefKind::Use
             | DefKind::ForeignMod
+            | DefKind::Macro(_)
             | DefKind::AnonConst
             | DefKind::Field
             | DefKind::GlobalAsm
@@ -642,11 +639,23 @@ impl Visitor<'tcx> for EmbargoVisitor<'tcx> {
             }
             // Foreign modules inherit level from parents.
             hir::ItemKind::ForeignMod { .. } => self.prev_level,
-            // Non-exported macros can't be visible by definition;
-            hir::ItemKind::Macro { is_exported: false, .. } => None,
+            hir::ItemKind::Macro(ref macro_def) => {
+                let def_id = item.def_id.to_def_id();
+                let is_macro_export = self.tcx.has_attr(def_id, sym::macro_export);
+                match (macro_def.ast.macro_rules, is_macro_export) {
+                    (true, true) => Some(AccessLevel::Public),
+                    (true, false) => None,
+                    (false, _) => {
+                        if item.vis.node.is_pub() {
+                            self.prev_level
+                        } else {
+                            None
+                        }
+                    }
+                }
+            }
             // Other `pub` items inherit levels from parents.
-            hir::ItemKind::Macro { is_exported: true, .. }
-            | hir::ItemKind::Const(..)
+            hir::ItemKind::Const(..)
             | hir::ItemKind::Enum(..)
             | hir::ItemKind::ExternCrate(..)
             | hir::ItemKind::GlobalAsm(..)
@@ -714,17 +723,15 @@ impl Visitor<'tcx> for EmbargoVisitor<'tcx> {
                     }
                 }
             }
-            hir::ItemKind::Macro { macro_def: ref md, .. } => {
+            hir::ItemKind::Macro(ref md) => {
+                // We have to make sure that the items that macros might reference
+                // are reachable, since they might be exported transitively.
+
                 // Non-opaque macros cannot make other items more accessible than they already are.
                 let attrs = self.tcx.hir().attrs(md.hir_id());
                 if attr::find_transparency(&self.tcx.sess, &attrs, md.ast.macro_rules).0
                     != Transparency::Opaque
                 {
-                    // `#[macro_export]`-ed `macro_rules!` are `Public` since they
-                    // ignore their containing path to always appear at the crate root.
-                    if md.ast.macro_rules {
-                        self.update(item.def_id, Some(AccessLevel::Public));
-                    }
                     return;
                 }
 

Original file line number	Diff line number	Diff line change
`@@ -593,7 +593,7 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item<'v>) {`
`593`	`593`	`visitor.visit_id(item.hir_id());`
`594`	`594`	`walk_list!(visitor, visit_foreign_item_ref, items);`
`595`	`595`	`}`
`596`		`- ItemKind::Macro { ref macro_def, .. } => {`
	`596`	`+ ItemKind::Macro(ref macro_def) => {`
`597`	`597`	`visitor.visit_id(item.hir_id());`
`598`	`598`	`visitor.visit_macro_def(macro_def)`
`599`	`599`	`}`
Original file line number	Diff line number	Diff line change
`@@ -660,7 +660,7 @@ impl<'a> State<'a> {`
`660`	`660`	`}`
`661`	`661`	`self.bclose(item.span);`
`662`	`662`	`}`
`663`		`- hir::ItemKind::Macro { ref macro_def, .. } => {`
	`663`	`+ hir::ItemKind::Macro(ref macro_def) => {`
`664`	`664`	`let (kw, has_bang) = if macro_def.ast.macro_rules {`
`665`	`665`	`("macro_rules", true)`
`666`	`666`	`} else {`
Original file line number	Diff line number	Diff line change
`@@ -617,7 +617,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingDoc {`
`617`	`617`	`return;`
`618`	`618`	`}`
`619`	`619`
`620`		`- hir::ItemKind::Macro { is_exported: true, .. }`
	`620`	`+ hir::ItemKind::Macro { .. }`
`621`	`621`	`\| hir::ItemKind::TyAlias(..)`
`622`	`622`	`\| hir::ItemKind::Fn(..)`
`623`	`623`	`\| hir::ItemKind::Mod(..)`
Original file line number	Diff line number	Diff line change
`@@ -622,7 +622,6 @@ impl<'tcx> Visitor<'tcx> for MissingStabilityAnnotations<'tcx> {`
`622`	`622`	`i.kind,`
`623`	`623`	`hir::ItemKind::Impl(hir::Impl { of_trait: None, .. })`
`624`	`624`	`\| hir::ItemKind::ForeignMod { .. }`
`625`		`- \| hir::ItemKind::Macro { is_exported: false, .. }`
`626`	`625`	`) {`
`627`	`626`	`self.check_missing_stability(i.def_id, i.span);`
`628`	`627`	`}`