src/librustdoc/visit_lib.rs

   1 use crate::core::DocContext;
   2 use rustc_hir::def::{DefKind, Res};
   3 use rustc_hir::def_id::{DefId, DefIdSet};
   4 use rustc_middle::ty::TyCtxt;
   5 use rustc_resolve::Resolver;
   6
   7 // FIXME: this may not be exhaustive, but is sufficient for rustdocs current uses
   8
   9 #[derive(Default)]
  10 pub(crate) struct RustdocEffectiveVisibilities {
  11     extern_public: DefIdSet,
  12 }
  13
  14 macro_rules! define_method {
  15     ($method:ident) => {
  16         pub(crate) fn $method(&self, tcx: TyCtxt<'_>, def_id: DefId) -> bool {
  17             match def_id.as_local() {
  18                 Some(def_id) => tcx.effective_visibilities(()).$method(def_id),
  19                 None => self.extern_public.contains(&def_id),
  20             }
  21         }
  22     };
  23 }
  24
  25 impl RustdocEffectiveVisibilities {
  26     define_method!(is_directly_public);
  27     define_method!(is_exported);
  28     define_method!(is_reachable);
  29
  30     pub(crate) fn init(&mut self, extern_public: DefIdSet) {
  31         self.extern_public = extern_public;
  32     }
  33 }
  34
  35 pub(crate) fn lib_embargo_visit_item(cx: &mut DocContext<'_>, def_id: DefId) {
  36     assert!(!def_id.is_local());
  37     LibEmbargoVisitor {
  38         tcx: cx.tcx,
  39         extern_public: &mut cx.cache.effective_visibilities.extern_public,
  40         visited_mods: Default::default(),
  41     }
  42     .visit_item(def_id)
  43 }
  44
  45 pub(crate) fn early_lib_embargo_visit_item(
  46     resolver: &Resolver<'_>,
  47     extern_public: &mut DefIdSet,
  48     def_id: DefId,
  49     is_mod: bool,
  50 ) {
  51     assert!(!def_id.is_local());
  52     EarlyLibEmbargoVisitor { resolver, extern_public, visited_mods: Default::default() }
  53         .visit_item(def_id, is_mod)
  54 }
  55
  56 /// Similar to `librustc_privacy::EmbargoVisitor`, but also takes
  57 /// specific rustdoc annotations into account (i.e., `doc(hidden)`)
  58 struct LibEmbargoVisitor<'a, 'tcx> {
  59     tcx: TyCtxt<'tcx>,
  60     // Effective visibilities for reachable nodes
  61     extern_public: &'a mut DefIdSet,
  62     // Keeps track of already visited modules, in case a module re-exports its parent
  63     visited_mods: DefIdSet,
  64 }
  65
  66 struct EarlyLibEmbargoVisitor<'r, 'ra> {
  67     resolver: &'r Resolver<'ra>,
  68     // Effective visibilities for reachable nodes
  69     extern_public: &'r mut DefIdSet,
  70     // Keeps track of already visited modules, in case a module re-exports its parent
  71     visited_mods: DefIdSet,
  72 }
  73
  74 impl LibEmbargoVisitor<'_, '_> {
  75     fn visit_mod(&mut self, def_id: DefId) {
  76         if !self.visited_mods.insert(def_id) {
  77             return;
  78         }
  79
  80         for item in self.tcx.module_children(def_id).iter() {
  81             if let Some(def_id) = item.res.opt_def_id() {
  82                 if item.vis.is_public() {
  83                     self.visit_item(def_id);
  84                 }
  85             }
  86         }
  87     }
  88
  89     fn visit_item(&mut self, def_id: DefId) {
  90         if !self.tcx.is_doc_hidden(def_id) {
  91             self.extern_public.insert(def_id);
  92             if self.tcx.def_kind(def_id) == DefKind::Mod {
  93                 self.visit_mod(def_id);
  94             }
  95         }
  96     }
  97 }
  98
  99 impl EarlyLibEmbargoVisitor<'_, '_> {
 100     fn visit_mod(&mut self, def_id: DefId) {
 101         if !self.visited_mods.insert(def_id) {
 102             return;
 103         }
 104
 105         for item in self.resolver.cstore().module_children_untracked(def_id, self.resolver.sess()) {
 106             if let Some(def_id) = item.res.opt_def_id() {
 107                 if item.vis.is_public() {
 108                     self.visit_item(def_id, matches!(item.res, Res::Def(DefKind::Mod, _)));
 109                 }
 110             }
 111         }
 112     }
 113
 114     fn visit_item(&mut self, def_id: DefId, is_mod: bool) {
 115         if !self.resolver.cstore().is_doc_hidden_untracked(def_id) {
 116             self.extern_public.insert(def_id);
 117             if is_mod {
 118                 self.visit_mod(def_id);
 119             }
 120         }
 121     }
 122 }