Skip to content

Commit 1910327

Browse files
rust-bors[bot]rust-bors[bot]
authored
Auto merge of #144554 - cjgillot:no-hir-eff-vis, r=<try>
Use less HIR to compute effective visibility.
2 parents f8e355c + 032e102 commit 1910327

File tree

1 file changed

+117
-99
lines changed
  • compiler/rustc_privacy/src

1 file changed

+117
-99
lines changed

‎compiler/rustc_privacy/src/lib.rs

Lines changed: 117 additions & 99 deletions
Original file line numberDiff line numberDiff line change
@@ -24,9 +24,9 @@ use rustc_data_structures::fx::FxHashSet;
2424
use rustc_data_structures::intern::Interned;
2525
use rustc_errors::{MultiSpan, listify};
2626
use rustc_hir::def::{DefKind, Res};
27-
use rustc_hir::def_id::{CRATE_DEF_ID, DefId, LocalDefId, LocalModDefId};
27+
use rustc_hir::def_id::{DefId, LocalDefId, LocalModDefId};
2828
use rustc_hir::intravisit::{self, InferKind, Visitor};
29-
use rustc_hir::{AmbigArg, ForeignItemId, ItemId, PatKind};
29+
use rustc_hir::{AmbigArg, ForeignItemId, ItemId, OwnerId, PatKind};
3030
use rustc_middle::middle::privacy::{EffectiveVisibilities, EffectiveVisibility, Level};
3131
use rustc_middle::query::Providers;
3232
use rustc_middle::ty::print::PrintTraitRefExt as _;
@@ -638,58 +638,62 @@ impl<'tcx> EmbargoVisitor<'tcx> {
638638
}
639639
}
640640

641-
impl<'tcx> Visitor<'tcx> for EmbargoVisitor<'tcx> {
642-
fn visit_item(&mut self, item: &'tcx hir::Item<'tcx>) {
641+
impl<'tcx> EmbargoVisitor<'tcx> {
642+
fn check_def_id(&mut self, owner_id: OwnerId) {
643643
// Update levels of nested things and mark all items
644644
// in interfaces of reachable items as reachable.
645-
let item_ev = self.get(item.owner_id.def_id);
646-
match item.kind {
645+
let item_ev = self.get(owner_id.def_id);
646+
match self.tcx.def_kind(owner_id) {
647647
// The interface is empty, and no nested items.
648-
hir::ItemKind::Use(..)
649-
| hir::ItemKind::ExternCrate(..)
650-
| hir::ItemKind::GlobalAsm { .. } => {}
648+
DefKind::Use | DefKind::ExternCrate | DefKind::GlobalAsm => {}
651649
// The interface is empty, and all nested items are processed by `visit_item`.
652-
hir::ItemKind::Mod(..) => {}
653-
hir::ItemKind::Macro(_, macro_def, _) => {
650+
DefKind::Mod => {}
651+
DefKind::Macro { .. } => {
654652
if let Some(item_ev) = item_ev {
655-
self.update_reachability_from_macro(item.owner_id.def_id, macro_def, item_ev);
653+
let (_, macro_def, _) =
654+
self.tcx.hir_expect_item(owner_id.def_id).expect_macro();
655+
self.update_reachability_from_macro(owner_id.def_id, macro_def, item_ev);
656656
}
657657
}
658-
hir::ItemKind::Const(..)
659-
| hir::ItemKind::Static(..)
660-
| hir::ItemKind::Fn { .. }
661-
| hir::ItemKind::TyAlias(..) => {
658+
DefKind::ForeignTy
659+
| DefKind::Const
660+
| DefKind::Static { .. }
661+
| DefKind::Fn
662+
| DefKind::TyAlias => {
662663
if let Some(item_ev) = item_ev {
663-
self.reach(item.owner_id.def_id, item_ev).generics().predicates().ty();
664+
self.reach(owner_id.def_id, item_ev).generics().predicates().ty();
664665
}
665666
}
666-
hir::ItemKind::Trait(.., trait_item_refs) => {
667+
DefKind::Trait => {
667668
if let Some(item_ev) = item_ev {
668-
self.reach(item.owner_id.def_id, item_ev).generics().predicates();
669+
self.reach(owner_id.def_id, item_ev).generics().predicates();
670+
671+
for assoc_item in self.tcx.associated_items(owner_id).in_definition_order() {
672+
if assoc_item.is_impl_trait_in_trait() {
673+
continue;
674+
}
669675

670-
for trait_item_ref in trait_item_refs {
671-
self.update(trait_item_ref.owner_id.def_id, item_ev, Level::Reachable);
676+
let def_id = assoc_item.def_id.expect_local();
677+
self.update(def_id, item_ev, Level::Reachable);
672678

673679
let tcx = self.tcx;
674-
let mut reach = self.reach(trait_item_ref.owner_id.def_id, item_ev);
680+
let mut reach = self.reach(def_id, item_ev);
675681
reach.generics().predicates();
676682

677-
if let DefKind::AssocTy = tcx.def_kind(trait_item_ref.owner_id)
678-
&& !tcx.defaultness(trait_item_ref.owner_id).has_value()
679-
{
683+
if assoc_item.is_type() && !assoc_item.defaultness(tcx).has_value() {
680684
// No type to visit.
681685
} else {
682686
reach.ty();
683687
}
684688
}
685689
}
686690
}
687-
hir::ItemKind::TraitAlias(..) => {
691+
DefKind::TraitAlias => {
688692
if let Some(item_ev) = item_ev {
689-
self.reach(item.owner_id.def_id, item_ev).generics().predicates();
693+
self.reach(owner_id.def_id, item_ev).generics().predicates();
690694
}
691695
}
692-
hir::ItemKind::Impl(impl_) => {
696+
DefKind::Impl { of_trait } => {
693697
// Type inference is very smart sometimes. It can make an impl reachable even some
694698
// components of its type or trait are unreachable. E.g. methods of
695699
// `impl ReachableTrait<UnreachableTy> for ReachableTy<UnreachableTy> { ... }`
@@ -701,84 +705,99 @@ impl<'tcx> Visitor<'tcx> for EmbargoVisitor<'tcx> {
701705
// without knowing both "shallow" version of its self type and "shallow" version of
702706
// its trait if it exists (which require reaching the `DefId`s in them).
703707
let item_ev = EffectiveVisibility::of_impl::<true>(
704-
item.owner_id.def_id,
708+
owner_id.def_id,
705709
self.tcx,
706710
&self.effective_visibilities,
707711
);
708712

709-
self.update_eff_vis(item.owner_id.def_id, item_ev, None, Level::Direct);
713+
self.update_eff_vis(owner_id.def_id, item_ev, None, Level::Direct);
714+
715+
self.reach(owner_id.def_id, item_ev).generics().predicates().ty().trait_ref();
710716

711-
self.reach(item.owner_id.def_id, item_ev).generics().predicates().ty().trait_ref();
717+
for assoc_item in self.tcx.associated_items(owner_id).in_definition_order() {
718+
if assoc_item.is_impl_trait_in_trait() {
719+
continue;
720+
}
712721

713-
for impl_item_ref in impl_.items {
714-
let def_id = impl_item_ref.owner_id.def_id;
722+
let def_id = assoc_item.def_id.expect_local();
715723
let max_vis =
716-
impl_.of_trait.is_none().then(|| self.tcx.local_visibility(def_id));
724+
if of_trait { None } else { Some(self.tcx.local_visibility(def_id)) };
717725
self.update_eff_vis(def_id, item_ev, max_vis, Level::Direct);
718726

719727
if let Some(impl_item_ev) = self.get(def_id) {
720728
self.reach(def_id, impl_item_ev).generics().predicates().ty();
721729
}
722730
}
723731
}
724-
hir::ItemKind::Enum(_, _, ref def) => {
732+
DefKind::Enum => {
725733
if let Some(item_ev) = item_ev {
726-
self.reach(item.owner_id.def_id, item_ev).generics().predicates();
734+
self.reach(owner_id.def_id, item_ev).generics().predicates();
727735
}
728-
for variant in def.variants {
736+
let def = self.tcx.adt_def(owner_id);
737+
for variant in def.variants() {
729738
if let Some(item_ev) = item_ev {
730-
self.update(variant.def_id, item_ev, Level::Reachable);
739+
self.update(variant.def_id.expect_local(), item_ev, Level::Reachable);
731740
}
732741

733-
if let Some(variant_ev) = self.get(variant.def_id) {
734-
if let Some(ctor_def_id) = variant.data.ctor_def_id() {
735-
self.update(ctor_def_id, variant_ev, Level::Reachable);
742+
if let Some(variant_ev) = self.get(variant.def_id.expect_local()) {
743+
if let Some(ctor_def_id) = variant.ctor_def_id() {
744+
self.update(ctor_def_id.expect_local(), variant_ev, Level::Reachable);
736745
}
737-
for field in variant.data.fields() {
738-
self.update(field.def_id, variant_ev, Level::Reachable);
739-
self.reach(field.def_id, variant_ev).ty();
746+
for field in variant.fields.iter() {
747+
let field = field.did.expect_local();
748+
self.update(field, variant_ev, Level::Reachable);
749+
self.reach(field, variant_ev).ty();
740750
}
741751
// Corner case: if the variant is reachable, but its
742752
// enum is not, make the enum reachable as well.
743-
self.reach(item.owner_id.def_id, variant_ev).ty();
753+
self.reach(owner_id.def_id, variant_ev).ty();
744754
}
745-
if let Some(ctor_def_id) = variant.data.ctor_def_id() {
746-
if let Some(ctor_ev) = self.get(ctor_def_id) {
747-
self.reach(item.owner_id.def_id, ctor_ev).ty();
755+
if let Some(ctor_def_id) = variant.ctor_def_id() {
756+
if let Some(ctor_ev) = self.get(ctor_def_id.expect_local()) {
757+
self.reach(owner_id.def_id, ctor_ev).ty();
748758
}
749759
}
750760
}
751761
}
752-
hir::ItemKind::ForeignMod { items, .. } => {
753-
for foreign_item in items {
754-
if let Some(foreign_item_ev) = self.get(foreign_item.owner_id.def_id) {
755-
self.reach(foreign_item.owner_id.def_id, foreign_item_ev)
756-
.generics()
757-
.predicates()
758-
.ty();
759-
}
760-
}
761-
}
762-
hir::ItemKind::Struct(_, _, ref struct_def)
763-
| hir::ItemKind::Union(_, _, ref struct_def) => {
762+
DefKind::Struct | DefKind::Union => {
763+
let def = self.tcx.adt_def(owner_id).non_enum_variant();
764764
if let Some(item_ev) = item_ev {
765-
self.reach(item.owner_id.def_id, item_ev).generics().predicates();
766-
for field in struct_def.fields() {
767-
self.update(field.def_id, item_ev, Level::Reachable);
768-
if let Some(field_ev) = self.get(field.def_id) {
769-
self.reach(field.def_id, field_ev).ty();
765+
self.reach(owner_id.def_id, item_ev).generics().predicates();
766+
for field in def.fields.iter() {
767+
let field = field.did.expect_local();
768+
self.update(field, item_ev, Level::Reachable);
769+
if let Some(field_ev) = self.get(field) {
770+
self.reach(field, field_ev).ty();
770771
}
771772
}
772773
}
773-
if let Some(ctor_def_id) = struct_def.ctor_def_id() {
774+
if let Some(ctor_def_id) = def.ctor_def_id() {
774775
if let Some(item_ev) = item_ev {
775-
self.update(ctor_def_id, item_ev, Level::Reachable);
776+
self.update(ctor_def_id.expect_local(), item_ev, Level::Reachable);
776777
}
777-
if let Some(ctor_ev) = self.get(ctor_def_id) {
778-
self.reach(item.owner_id.def_id, ctor_ev).ty();
778+
if let Some(ctor_ev) = self.get(ctor_def_id.expect_local()) {
779+
self.reach(owner_id.def_id, ctor_ev).ty();
779780
}
780781
}
781782
}
783+
// Contents are checked directly.
784+
DefKind::ForeignMod => {}
785+
DefKind::Field
786+
| DefKind::Variant
787+
| DefKind::AssocFn
788+
| DefKind::AssocTy
789+
| DefKind::AssocConst
790+
| DefKind::TyParam
791+
| DefKind::AnonConst
792+
| DefKind::InlineConst
793+
| DefKind::OpaqueTy
794+
| DefKind::Closure
795+
| DefKind::SyntheticCoroutineBody
796+
| DefKind::ConstParam
797+
| DefKind::LifetimeParam
798+
| DefKind::Ctor(..) => {
799+
bug!("should be checked while checking parent")
800+
}
782801
}
783802
}
784803
}
@@ -839,7 +858,7 @@ pub struct TestReachabilityVisitor<'a, 'tcx> {
839858
}
840859

841860
impl<'a, 'tcx> TestReachabilityVisitor<'a, 'tcx> {
842-
fn effective_visibility_diagnostic(&mut self, def_id: LocalDefId) {
861+
fn effective_visibility_diagnostic(&self, def_id: LocalDefId) {
843862
if self.tcx.has_attr(def_id, sym::rustc_effective_visibility) {
844863
let mut error_msg = String::new();
845864
let span = self.tcx.def_span(def_id.to_def_id());
@@ -859,43 +878,35 @@ impl<'a, 'tcx> TestReachabilityVisitor<'a, 'tcx> {
859878
}
860879
}
861880

862-
impl<'a, 'tcx> Visitor<'tcx> for TestReachabilityVisitor<'a, 'tcx> {
863-
fn visit_item(&mut self, item: &'tcx hir::Item<'tcx>) {
864-
self.effective_visibility_diagnostic(item.owner_id.def_id);
881+
impl<'a, 'tcx> TestReachabilityVisitor<'a, 'tcx> {
882+
fn check_def_id(&self, owner_id: OwnerId) {
883+
self.effective_visibility_diagnostic(owner_id.def_id);
865884

866-
match item.kind {
867-
hir::ItemKind::Enum(_, _, ref def) => {
868-
for variant in def.variants.iter() {
869-
self.effective_visibility_diagnostic(variant.def_id);
870-
if let Some(ctor_def_id) = variant.data.ctor_def_id() {
871-
self.effective_visibility_diagnostic(ctor_def_id);
885+
match self.tcx.def_kind(owner_id) {
886+
DefKind::Enum => {
887+
let def = self.tcx.adt_def(owner_id.def_id);
888+
for variant in def.variants() {
889+
self.effective_visibility_diagnostic(variant.def_id.expect_local());
890+
if let Some(ctor_def_id) = variant.ctor_def_id() {
891+
self.effective_visibility_diagnostic(ctor_def_id.expect_local());
872892
}
873-
for field in variant.data.fields() {
874-
self.effective_visibility_diagnostic(field.def_id);
893+
for field in variant.fields.iter() {
894+
self.effective_visibility_diagnostic(field.did.expect_local());
875895
}
876896
}
877897
}
878-
hir::ItemKind::Struct(_, _, ref def) | hir::ItemKind::Union(_, _, ref def) => {
898+
DefKind::Struct | DefKind::Union => {
899+
let def = self.tcx.adt_def(owner_id.def_id).non_enum_variant();
879900
if let Some(ctor_def_id) = def.ctor_def_id() {
880-
self.effective_visibility_diagnostic(ctor_def_id);
901+
self.effective_visibility_diagnostic(ctor_def_id.expect_local());
881902
}
882-
for field in def.fields() {
883-
self.effective_visibility_diagnostic(field.def_id);
903+
for field in def.fields.iter() {
904+
self.effective_visibility_diagnostic(field.did.expect_local());
884905
}
885906
}
886907
_ => {}
887908
}
888909
}
889-
890-
fn visit_trait_item(&mut self, item: &'tcx hir::TraitItem<'tcx>) {
891-
self.effective_visibility_diagnostic(item.owner_id.def_id);
892-
}
893-
fn visit_impl_item(&mut self, item: &'tcx hir::ImplItem<'tcx>) {
894-
self.effective_visibility_diagnostic(item.owner_id.def_id);
895-
}
896-
fn visit_foreign_item(&mut self, item: &'tcx hir::ForeignItem<'tcx>) {
897-
self.effective_visibility_diagnostic(item.owner_id.def_id);
898-
}
899910
}
900911

901912
//////////////////////////////////////////////////////////////////////////////////////
@@ -1836,8 +1847,14 @@ fn effective_visibilities(tcx: TyCtxt<'_>, (): ()) -> &EffectiveVisibilities {
18361847
visitor.changed = false;
18371848
}
18381849

1850+
let crate_items = tcx.hir_crate_items(());
18391851
loop {
1840-
tcx.hir_visit_all_item_likes_in_crate(&mut visitor);
1852+
for id in crate_items.free_items() {
1853+
visitor.check_def_id(id.owner_id);
1854+
}
1855+
for id in crate_items.foreign_items() {
1856+
visitor.check_def_id(id.owner_id);
1857+
}
18411858
if visitor.changed {
18421859
visitor.changed = false;
18431860
} else {
@@ -1846,10 +1863,11 @@ fn effective_visibilities(tcx: TyCtxt<'_>, (): ()) -> &EffectiveVisibilities {
18461863
}
18471864
visitor.effective_visibilities.check_invariants(tcx);
18481865

1849-
let mut check_visitor =
1866+
let check_visitor =
18501867
TestReachabilityVisitor { tcx, effective_visibilities: &visitor.effective_visibilities };
1851-
check_visitor.effective_visibility_diagnostic(CRATE_DEF_ID);
1852-
tcx.hir_visit_all_item_likes_in_crate(&mut check_visitor);
1868+
for id in crate_items.owners() {
1869+
check_visitor.check_def_id(id);
1870+
}
18531871

18541872
tcx.arena.alloc(visitor.effective_visibilities)
18551873
}

0 commit comments

Comments
 (0)