call it `hir::VisibilityKind` instead of `hir::Visibility_:*`

It was pointed out in review that the glob-exported
underscore-suffixed convention for `Spanned` HIR nodes is no longer
preferred: see February 2016's #31487 for AST's migration away from
this style towards properly namespaced NodeKind enums.

This concerns #51968.

diff --git a/src/librustc/hir/intravisit.rs b/src/librustc/hir/intravisit.rs
index 7173f670cd55486470937e84d28f8c44662dd583..60e944e5affc3c7ed32bd822f5a14c7304d72620 100644 (file)
--- a/src/librustc/hir/intravisit.rs
+++ b/src/librustc/hir/intravisit.rs
@@ -1104,7 +1104,7 @@ pub fn walk_arm<'v, V: Visitor<'v>>(visitor: &mut V, arm: &'v Arm) {
 }
 
 pub fn walk_vis<'v, V: Visitor<'v>>(visitor: &mut V, vis: &'v Visibility) {
-    if let VisibilityRestricted { ref path, id } = vis.node {
+    if let VisibilityKind::Restricted { ref path, id } = vis.node {
         visitor.visit_id(id);
         visitor.visit_path(path, id)
     }

diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs
index 4db12c95168306b7f3903703582a2643b9bff4c1..7219db278348464ee39df79e6c3b2854784e0923 100644 (file)
--- a/src/librustc/hir/lowering.rs
+++ b/src/librustc/hir/lowering.rs
@@ -1285,7 +1285,7 @@ fn lower_existential_impl_trait(
                 name: keywords::Invalid.name(),
                 attrs: Default::default(),
                 node: exist_ty_item_kind,
-                vis: respan(span.shrink_to_lo(), hir::VisibilityInherited),
+                vis: respan(span.shrink_to_lo(), hir::VisibilityKind::Inherited),
                 span: exist_ty_span,
             };
 
@@ -2771,11 +2771,11 @@ fn lower_use_tree(
                         let path = this.lower_path_extra(def, &path, None, ParamMode::Explicit);
                         let item = hir::ItemUse(P(path), hir::UseKind::Single);
                         let vis_kind = match vis.node {
-                            hir::VisibilityPublic => hir::VisibilityPublic,
-                            hir::VisibilityCrate(sugar) => hir::VisibilityCrate(sugar),
-                            hir::VisibilityInherited => hir::VisibilityInherited,
-                            hir::VisibilityRestricted { ref path, id: _ } => {
-                                hir::VisibilityRestricted {
+                            hir::VisibilityKind::Public => hir::VisibilityKind::Public,
+                            hir::VisibilityKind::Crate(sugar) => hir::VisibilityKind::Crate(sugar),
+                            hir::VisibilityKind::Inherited => hir::VisibilityKind::Inherited,
+                            hir::VisibilityKind::Restricted { ref path, id: _ } => {
+                                hir::VisibilityKind::Restricted {
                                     path: path.clone(),
                                     // We are allocating a new NodeId here
                                     id: this.next_id().node_id,
@@ -2844,11 +2844,11 @@ fn lower_use_tree(
 
                     self.with_hir_id_owner(new_id, |this| {
                         let vis_kind = match vis.node {
-                            hir::VisibilityPublic => hir::VisibilityPublic,
-                            hir::VisibilityCrate(sugar) => hir::VisibilityCrate(sugar),
-                            hir::VisibilityInherited => hir::VisibilityInherited,
-                            hir::VisibilityRestricted { ref path, id: _ } => {
-                                hir::VisibilityRestricted {
+                            hir::VisibilityKind::Public => hir::VisibilityKind::Public,
+                            hir::VisibilityKind::Crate(sugar) => hir::VisibilityKind::Crate(sugar),
+                            hir::VisibilityKind::Inherited => hir::VisibilityKind::Inherited,
+                            hir::VisibilityKind::Restricted { ref path, id: _ } => {
+                                hir::VisibilityKind::Restricted {
                                     path: path.clone(),
                                     // We are allocating a new NodeId here
                                     id: this.next_id().node_id,
@@ -2876,7 +2876,7 @@ fn lower_use_tree(
                 // the stability of `use a::{};`, to avoid it showing up as
                 // a re-export by accident when `pub`, e.g. in documentation.
                 let path = P(self.lower_path(id, &prefix, ParamMode::Explicit));
-                *vis = respan(prefix.span.shrink_to_lo(), hir::VisibilityInherited);
+                *vis = respan(prefix.span.shrink_to_lo(), hir::VisibilityKind::Inherited);
                 hir::ItemUse(path, hir::UseKind::ListStem)
             }
         }
@@ -4277,9 +4277,9 @@ fn lower_visibility(
         explicit_owner: Option<NodeId>,
     ) -> hir::Visibility {
         let node = match v.node {
-            VisibilityKind::Public => hir::VisibilityPublic,
-            VisibilityKind::Crate(sugar) => hir::VisibilityCrate(sugar),
-            VisibilityKind::Restricted { ref path, id } => hir::VisibilityRestricted {
+            VisibilityKind::Public => hir::VisibilityKind::Public,
+            VisibilityKind::Crate(sugar) => hir::VisibilityKind::Crate(sugar),
+            VisibilityKind::Restricted { ref path, id } => hir::VisibilityKind::Restricted {
                 path: P(self.lower_path(id, path, ParamMode::Explicit)),
                 id: if let Some(owner) = explicit_owner {
                     self.lower_node_id_with_owner(id, owner).node_id
@@ -4287,7 +4287,7 @@ fn lower_visibility(
                     self.lower_node_id(id).node_id
                 },
             },
-            VisibilityKind::Inherited => hir::VisibilityInherited,
+            VisibilityKind::Inherited => hir::VisibilityKind::Inherited,
         };
         respan(v.span, node)
     }

diff --git a/src/librustc/hir/map/collector.rs b/src/librustc/hir/map/collector.rs
index 55ad73515c0d3a34444c784a046f978ecdb552c8..3cc25bfd2d4d7c4a4800dfbbde1041c20ddf234d 100644 (file)
--- a/src/librustc/hir/map/collector.rs
+++ b/src/librustc/hir/map/collector.rs
@@ -459,10 +459,10 @@ fn visit_lifetime(&mut self, lifetime: &'hir Lifetime) {
 
     fn visit_vis(&mut self, visibility: &'hir Visibility) {
         match visibility.node {
-            VisibilityPublic |
-            VisibilityCrate(_) |
-            VisibilityInherited => {}
-            VisibilityRestricted { id, .. } => {
+            VisibilityKind::Public |
+            VisibilityKind::Crate(_) |
+            VisibilityKind::Inherited => {}
+            VisibilityKind::Restricted { id, .. } => {
                 self.insert(id, NodeVisibility(visibility));
                 self.with_parent(id, |this| {
                     intravisit::walk_vis(this, visibility);

diff --git a/src/librustc/hir/map/mod.rs b/src/librustc/hir/map/mod.rs
index a5c0a5e33f7053f907b8d85ad7579a4acf8e09d0..08a130f049bf734c322d1961ae87e7eaf3563f02 100644 (file)
--- a/src/librustc/hir/map/mod.rs
+++ b/src/librustc/hir/map/mod.rs
@@ -1050,7 +1050,7 @@ pub fn span(&self, id: NodeId) -> Span {
             Some(EntryLifetime(_, _, lifetime)) => lifetime.span,
             Some(EntryGenericParam(_, _, param)) => param.span,
             Some(EntryVisibility(_, _, &Spanned {
-                node: VisibilityRestricted { ref path, .. }, ..
+                node: VisibilityKind::Restricted { ref path, .. }, ..
             })) => path.span,
             Some(EntryVisibility(_, _, v)) => bug!("unexpected Visibility {:?}", v),
             Some(EntryLocal(_, _, local)) => local.span,

diff --git a/src/librustc/hir/mod.rs b/src/librustc/hir/mod.rs
index 6f8981e1e6cd40c82ad4c58b1fdc748bcc341ecd..b0b81316148ea47c97acd99ca6493df4a9ffcd07 100644 (file)
--- a/src/librustc/hir/mod.rs
+++ b/src/librustc/hir/mod.rs
@@ -24,7 +24,6 @@
 pub use self::Ty_::*;
 pub use self::UnOp::*;
 pub use self::UnsafeSource::*;
-pub use self::Visibility_::*;
 
 use hir::def::Def;
 use hir::def_id::{DefId, DefIndex, LocalDefId, CRATE_DEF_INDEX};
@@ -1929,30 +1928,30 @@ pub struct PolyTraitRef {
     pub span: Span,
 }
 
-pub type Visibility = Spanned<Visibility_>;
+pub type Visibility = Spanned<VisibilityKind>;
 
 #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
-pub enum Visibility_ {
-    VisibilityPublic,
-    VisibilityCrate(CrateSugar),
-    VisibilityRestricted { path: P<Path>, id: NodeId },
-    VisibilityInherited,
+pub enum VisibilityKind {
+    Public,
+    Crate(CrateSugar),
+    Restricted { path: P<Path>, id: NodeId },
+    Inherited,
 }
 
-impl Visibility_ {
+impl VisibilityKind {
     pub fn is_pub(&self) -> bool {
         match *self {
-            VisibilityPublic => true,
+            VisibilityKind::Public => true,
             _ => false
         }
     }
 
     pub fn is_pub_restricted(&self) -> bool {
         match *self {
-            VisibilityPublic |
-            VisibilityInherited => false,
-            VisibilityCrate(..) |
-            VisibilityRestricted { .. } => true,
+            VisibilityKind::Public |
+            VisibilityKind::Inherited => false,
+            VisibilityKind::Crate(..) |
+            VisibilityKind::Restricted { .. } => true,
         }
     }
 }

diff --git a/src/librustc/hir/print.rs b/src/librustc/hir/print.rs
index 5b52764f08d3dbec6cc0cb301171b5cb06230519..255009c94c6abc6e06454302da7445929891a1b2 100644 (file)
--- a/src/librustc/hir/print.rs
+++ b/src/librustc/hir/print.rs
@@ -840,10 +840,10 @@ pub fn print_variants(&mut self,
 
     pub fn print_visibility(&mut self, vis: &hir::Visibility) -> io::Result<()> {
         match vis.node {
-            hir::VisibilityPublic => self.word_nbsp("pub")?,
-            hir::VisibilityCrate(ast::CrateSugar::JustCrate) => self.word_nbsp("crate")?,
-            hir::VisibilityCrate(ast::CrateSugar::PubCrate) => self.word_nbsp("pub(crate)")?,
-            hir::VisibilityRestricted { ref path, .. } => {
+            hir::VisibilityKind::Public => self.word_nbsp("pub")?,
+            hir::VisibilityKind::Crate(ast::CrateSugar::JustCrate) => self.word_nbsp("crate")?,
+            hir::VisibilityKind::Crate(ast::CrateSugar::PubCrate) => self.word_nbsp("pub(crate)")?,
+            hir::VisibilityKind::Restricted { ref path, .. } => {
                 self.s.word("pub(")?;
                 if path.segments.len() == 1 &&
                    path.segments[0].ident.name == keywords::Super.name() {
@@ -856,7 +856,7 @@ pub fn print_visibility(&mut self, vis: &hir::Visibility) -> io::Result<()> {
                 }
                 self.word_nbsp(")")?;
             }
-            hir::VisibilityInherited => ()
+            hir::VisibilityKind::Inherited => ()
         }
 
         Ok(())
@@ -952,16 +952,19 @@ pub fn print_trait_item(&mut self, ti: &hir::TraitItem) -> io::Result<()> {
         self.print_outer_attributes(&ti.attrs)?;
         match ti.node {
             hir::TraitItemKind::Const(ref ty, default) => {
-                let vis = Spanned { span: syntax_pos::DUMMY_SP, node: hir::VisibilityInherited };
+                let vis = Spanned { span: syntax_pos::DUMMY_SP,
+                                    node: hir::VisibilityKind::Inherited };
                 self.print_associated_const(ti.ident, &ty, default, &vis)?;
             }
             hir::TraitItemKind::Method(ref sig, hir::TraitMethod::Required(ref arg_names)) => {
-                let vis = Spanned { span: syntax_pos::DUMMY_SP, node: hir::VisibilityInherited };
+                let vis = Spanned { span: syntax_pos::DUMMY_SP,
+                                    node: hir::VisibilityKind::Inherited };
                 self.print_method_sig(ti.ident, sig, &ti.generics, &vis, arg_names, None)?;
                 self.s.word(";")?;
             }
             hir::TraitItemKind::Method(ref sig, hir::TraitMethod::Provided(body)) => {
-                let vis = Spanned { span: syntax_pos::DUMMY_SP, node: hir::VisibilityInherited };
+                let vis = Spanned { span: syntax_pos::DUMMY_SP,
+                                    node: hir::VisibilityKind::Inherited };
                 self.head("")?;
                 self.print_method_sig(ti.ident, sig, &ti.generics, &vis, &[], Some(body))?;
                 self.nbsp()?;
@@ -2267,7 +2270,8 @@ pub fn print_ty_fn(&mut self,
                       },
                       name,
                       &generics,
-                      &Spanned { span: syntax_pos::DUMMY_SP, node: hir::VisibilityInherited },
+                      &Spanned { span: syntax_pos::DUMMY_SP,
+                                 node: hir::VisibilityKind::Inherited },
                       arg_names,
                       None)?;
         self.end()

diff --git a/src/librustc/ich/impls_hir.rs b/src/librustc/ich/impls_hir.rs
index 3170f9efafb6beac636ef2fdc48c89c14a6ef72a..0c7baea85ad8f63d33ea0589c0eba599e725729a 100644 (file)
--- a/src/librustc/ich/impls_hir.rs
+++ b/src/librustc/ich/impls_hir.rs
@@ -710,20 +710,20 @@ fn hash_stable<W: StableHasherResult>(&self,
     PubCrate,
 });
 
-impl<'a> HashStable<StableHashingContext<'a>> for hir::Visibility_ {
+impl<'a> HashStable<StableHashingContext<'a>> for hir::VisibilityKind {
     fn hash_stable<W: StableHasherResult>(&self,
                                           hcx: &mut StableHashingContext<'a>,
                                           hasher: &mut StableHasher<W>) {
         mem::discriminant(self).hash_stable(hcx, hasher);
         match *self {
-            hir::VisibilityPublic |
-            hir::VisibilityInherited => {
+            hir::VisibilityKind::Public |
+            hir::VisibilityKind::Inherited => {
                 // No fields to hash.
             }
-            hir::VisibilityCrate(sugar) => {
+            hir::VisibilityKind::Crate(sugar) => {
                 sugar.hash_stable(hcx, hasher);
             }
-            hir::VisibilityRestricted { ref path, id } => {
+            hir::VisibilityKind::Restricted { ref path, id } => {
                 hcx.with_node_id_hashing_mode(NodeIdHashingMode::HashDefPath, |hcx| {
                     id.hash_stable(hcx, hasher);
                 });
@@ -733,7 +733,7 @@ fn hash_stable<W: StableHasherResult>(&self,
     }
 }
 
-impl_stable_hash_for_spanned!(hir::Visibility_);
+impl_stable_hash_for_spanned!(hir::VisibilityKind);
 
 impl<'a> HashStable<StableHashingContext<'a>> for hir::Defaultness {
     fn hash_stable<W: StableHasherResult>(&self,

diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs
index aad60c0247d2650737aecff0ebe8b84509b67fc3..54afd795fc0f13de0e2a7cfcb4168200d560b304 100644 (file)
--- a/src/librustc/ty/mod.rs
+++ b/src/librustc/ty/mod.rs
@@ -269,15 +269,15 @@ fn parent(self, id: DefId) -> Option<DefId> {
 impl Visibility {
     pub fn from_hir(visibility: &hir::Visibility, id: NodeId, tcx: TyCtxt) -> Self {
         match visibility.node {
-            hir::VisibilityPublic => Visibility::Public,
-            hir::VisibilityCrate(_) => Visibility::Restricted(DefId::local(CRATE_DEF_INDEX)),
-            hir::VisibilityRestricted { ref path, .. } => match path.def {
+            hir::VisibilityKind::Public => Visibility::Public,
+            hir::VisibilityKind::Crate(_) => Visibility::Restricted(DefId::local(CRATE_DEF_INDEX)),
+            hir::VisibilityKind::Restricted { ref path, .. } => match path.def {
                 // If there is no resolution, `resolve` will have already reported an error, so
                 // assume that the visibility is public to avoid reporting more privacy errors.
                 Def::Err => Visibility::Public,
                 def => Visibility::Restricted(def.def_id()),
             },
-            hir::VisibilityInherited => {
+            hir::VisibilityKind::Inherited => {
                 Visibility::Restricted(tcx.hir.get_module_parent(id))
             }
         }

diff --git a/src/librustc_lint/builtin.rs b/src/librustc_lint/builtin.rs
index 96dcb458303f89c4e6c4f0528e4996b38a2267f5..9ac4872622bf598cb5932964d119dae2ab56adc0 100644 (file)
--- a/src/librustc_lint/builtin.rs
+++ b/src/librustc_lint/builtin.rs
@@ -397,7 +397,7 @@ fn check_item(&mut self, cx: &LateContext, it: &hir::Item) {
             hir::ItemUnion(..) => "a union",
             hir::ItemTrait(.., ref trait_item_refs) => {
                 // Issue #11592, traits are always considered exported, even when private.
-                if it.vis.node == hir::VisibilityInherited {
+                if it.vis.node == hir::VisibilityKind::Inherited {
                     self.private_traits.insert(it.id);
                     for trait_item_ref in trait_item_refs {
                         self.private_traits.insert(trait_item_ref.id.node_id);
@@ -414,7 +414,7 @@ fn check_item(&mut self, cx: &LateContext, it: &hir::Item) {
                 if let Some(node_id) = cx.tcx.hir.as_local_node_id(real_trait) {
                     match cx.tcx.hir.find(node_id) {
                         Some(hir_map::NodeItem(item)) => {
-                            if item.vis.node == hir::VisibilityInherited {
+                            if item.vis.node == hir::VisibilityKind::Inherited {
                                 for impl_item_ref in impl_item_refs {
                                     self.private_traits.insert(impl_item_ref.id.node_id);
                                 }
@@ -1179,15 +1179,15 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for InvalidNoMangleItems {
     fn check_item(&mut self, cx: &LateContext, it: &hir::Item) {
         let suggest_export = |vis: &hir::Visibility, err: &mut DiagnosticBuilder| {
             let suggestion = match vis.node {
-                hir::VisibilityInherited => {
+                hir::VisibilityKind::Inherited => {
                     // inherited visibility is empty span at item start; need an extra space
                     Some("pub ".to_owned())
                 },
-                hir::VisibilityRestricted { .. } |
-                hir::VisibilityCrate(_) => {
+                hir::VisibilityKind::Restricted { .. } |
+                hir::VisibilityKind::Crate(_) => {
                     Some("pub".to_owned())
                 },
-                hir::VisibilityPublic => {
+                hir::VisibilityKind::Public => {
                     err.help("try exporting the item with a `pub use` statement");
                     None
                 }
@@ -1399,7 +1399,7 @@ fn perform_lint(&self, cx: &LateContext, what: &str, id: ast::NodeId,
                     vis: &hir::Visibility, span: Span, exportable: bool) {
         let mut applicability = Applicability::MachineApplicable;
         match vis.node {
-            hir::VisibilityPublic if !cx.access_levels.is_reachable(id) => {
+            hir::VisibilityKind::Public if !cx.access_levels.is_reachable(id) => {
                 if span.ctxt().outer().expn_info().is_some() {
                     applicability = Applicability::MaybeIncorrect;
                 }

diff --git a/src/librustc_metadata/encoder.rs b/src/librustc_metadata/encoder.rs
index 196c53970f6702cd32a473e0522a50b5441aeb06..3cfde7a8297f97c957bf73542124fbeb36bc7df5 100644 (file)
--- a/src/librustc_metadata/encoder.rs
+++ b/src/librustc_metadata/encoder.rs
@@ -320,7 +320,7 @@ pub fn tracked<'x, DATA, R>(&'x mut self,
     fn encode_info_for_items(&mut self) -> Index {
         let krate = self.tcx.hir.krate();
         let mut index = IndexBuilder::new(self);
-        let vis = Spanned { span: syntax_pos::DUMMY_SP, node: hir::VisibilityPublic };
+        let vis = Spanned { span: syntax_pos::DUMMY_SP, node: hir::VisibilityKind::Public };
         index.record(DefId::local(CRATE_DEF_INDEX),
                      IsolatedEncoder::encode_info_for_mod,
                      FromId(CRATE_NODE_ID, (&krate.module, &krate.attrs, &vis)));

diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs
index dafb89be5fdaf1618a2a43a1e2114e68c0bd634b..19f9abc60ddccbcb3e3505d039b0d8026e6a1062 100644 (file)
--- a/src/librustc_privacy/lib.rs
+++ b/src/librustc_privacy/lib.rs
@@ -1469,8 +1469,8 @@ fn visit_ty(&mut self, ty: Ty<'tcx>) -> bool {
                 }
                 if !vis.is_at_least(self.required_visibility, self.tcx) {
                     let vis_adj = match hir_vis.node {
-                        hir::VisibilityCrate(_) => "crate-visible",
-                        hir::VisibilityRestricted { .. } => "restricted",
+                        hir::VisibilityKind::Crate(_) => "crate-visible",
+                        hir::VisibilityKind::Restricted { .. } => "restricted",
                         _ => "private"
                     };
 

diff --git a/src/librustc_save_analysis/lib.rs b/src/librustc_save_analysis/lib.rs
index 414247d22a87a60f87408f0dca97bc18bb04159d..447b5f1fe47e71b94c080c2da4979a701fd316ea 100644 (file)
--- a/src/librustc_save_analysis/lib.rs
+++ b/src/librustc_save_analysis/lib.rs
@@ -633,7 +633,7 @@ pub fn get_path_def(&self, id: NodeId) -> HirDef {
                 ..
             }) |
             Node::NodeVisibility(&Spanned {
-                node: hir::VisibilityRestricted { ref path, .. }, .. }) => path.def,
+                node: hir::VisibilityKind::Restricted { ref path, .. }, .. }) => path.def,
 
             Node::NodeExpr(&hir::Expr {
                 node: hir::ExprStruct(ref qpath, ..),

diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
index 7394b6d580c9f0d7903378ffec54c13a9f948244..b8abb98edec4800945d65bd3036d080bc8b1fa8e 100644 (file)
--- a/src/librustdoc/clean/mod.rs
+++ b/src/librustdoc/clean/mod.rs
@@ -3226,10 +3226,10 @@ pub enum Visibility {
 impl Clean<Option<Visibility>> for hir::Visibility {
     fn clean(&self, cx: &DocContext) -> Option<Visibility> {
         Some(match self.node {
-            hir::VisibilityPublic => Visibility::Public,
-            hir::VisibilityInherited => Visibility::Inherited,
-            hir::VisibilityCrate(_) => Visibility::Crate,
-            hir::VisibilityRestricted { ref path, .. } => {
+            hir::VisibilityKind::Public => Visibility::Public,
+            hir::VisibilityKind::Inherited => Visibility::Inherited,
+            hir::VisibilityKind::Crate(_) => Visibility::Crate,
+            hir::VisibilityKind::Restricted { ref path, .. } => {
                 let path = path.clean(cx);
                 let did = register_def(cx, path.def);
                 Visibility::Restricted(did, path)

diff --git a/src/librustdoc/doctree.rs b/src/librustdoc/doctree.rs
index 76c11a4e7cdd8b86bd22203b1b01c77c68a90c81..6fd9ef234f42317d006a993130b6990d29cf821b 100644 (file)
--- a/src/librustdoc/doctree.rs
+++ b/src/librustdoc/doctree.rs
@@ -54,7 +54,7 @@ pub fn new(name: Option<Name>) -> Module {
         Module {
             name       : name,
             id: ast::CRATE_NODE_ID,
-            vis: Spanned { span: syntax_pos::DUMMY_SP, node: hir::VisibilityInherited },
+            vis: Spanned { span: syntax_pos::DUMMY_SP, node: hir::VisibilityKind::Inherited },
             stab: None,
             depr: None,
             where_outer: syntax_pos::DUMMY_SP,

diff --git a/src/librustdoc/visit_ast.rs b/src/librustdoc/visit_ast.rs
index 3a13f61327e2905cd636d40c25344ebeb1b1f51e..fdeba93990d1c244352befe719f5a5c4ceeec347 100644 (file)
--- a/src/librustdoc/visit_ast.rs
+++ b/src/librustdoc/visit_ast.rs
@@ -96,7 +96,7 @@ pub fn visit(&mut self, krate: &hir::Crate) {
         self.module = self.visit_mod_contents(krate.span,
                                               krate.attrs.clone(),
                                               Spanned { span: syntax_pos::DUMMY_SP,
-                                                        node: hir::VisibilityPublic },
+                                                        node: hir::VisibilityKind::Public },
                                               ast::CRATE_NODE_ID,
                                               &krate.module,
                                               None);