Rename ItemEnum -> ItemKind, inner -> kind

diff --git a/src/librustdoc/clean/auto_trait.rs b/src/librustdoc/clean/auto_trait.rs
index f39b53f3c826a60b26fd2682c6ab8ca83c5057c0..a07d6b73f06c1a434ff441312fc93ffa0bea944a 100644 (file)
--- a/src/librustdoc/clean/auto_trait.rs
+++ b/src/librustdoc/clean/auto_trait.rs
@@ -125,7 +125,7 @@ pub fn get_auto_trait_impls(&self, ty: Ty<'tcx>, param_env_def_id: DefId) -> Vec
                     def_id: self.cx.next_def_id(param_env_def_id.krate),
                     stability: None,
                     deprecation: None,
-                    inner: ImplItem(Impl {
+                    kind: ImplItem(Impl {
                         unsafety: hir::Unsafety::Normal,
                         generics: new_generics,
                         provided_trait_methods: Default::default(),

diff --git a/src/librustdoc/clean/blanket_impl.rs b/src/librustdoc/clean/blanket_impl.rs
index de5a9a615557cf82282b51dfddbd1eb3efd84851..ed92361dd23359eed2af88fa046dfeae1b04dba9 100644 (file)
--- a/src/librustdoc/clean/blanket_impl.rs
+++ b/src/librustdoc/clean/blanket_impl.rs
@@ -98,7 +98,7 @@ pub fn get_blanket_impls(&self, ty: Ty<'tcx>, param_env_def_id: DefId) -> Vec<It
                     def_id: self.cx.next_def_id(impl_def_id.krate),
                     stability: None,
                     deprecation: None,
-                    inner: ImplItem(Impl {
+                    kind: ImplItem(Impl {
                         unsafety: hir::Unsafety::Normal,
                         generics: (
                             self.cx.tcx.generics_of(impl_def_id),

diff --git a/src/librustdoc/clean/inline.rs b/src/librustdoc/clean/inline.rs
index b3de70e590574da44660114e83a802559a8d6be6..d6f8870c859f5388cd234b6bcf1cc7bf4e03fb93 100644 (file)
--- a/src/librustdoc/clean/inline.rs
+++ b/src/librustdoc/clean/inline.rs
@@ -54,7 +54,7 @@
     debug!("attrs={:?}", attrs);
     let attrs_clone = attrs;
 
-    let inner = match res {
+    let kind = match res {
         Res::Def(DefKind::Trait, did) => {
             record_extern_fqn(cx, did, clean::TypeKind::Trait);
             ret.extend(build_impls(cx, Some(parent_module), did, attrs));
@@ -128,7 +128,7 @@
         source: cx.tcx.def_span(did).clean(cx),
         name: Some(name.clean(cx)),
         attrs,
-        inner,
+        kind,
         visibility: clean::Public,
         stability: cx.tcx.lookup_stability(did).cloned(),
         deprecation: cx.tcx.lookup_deprecation(did).clean(cx),
@@ -446,7 +446,7 @@ fn merge_attrs(
     debug!("build_impl: impl {:?} for {:?}", trait_.def_id(), for_.def_id());
 
     ret.push(clean::Item {
-        inner: clean::ImplItem(clean::Impl {
+        kind: clean::ImplItem(clean::Impl {
             unsafety: hir::Unsafety::Normal,
             generics,
             provided_trait_methods: provided,
@@ -498,7 +498,7 @@ fn fill_in(
                         visibility: clean::Public,
                         stability: None,
                         deprecation: None,
-                        inner: clean::ImportItem(clean::Import::new_simple(
+                        kind: clean::ImportItem(clean::Import::new_simple(
                             item.ident.to_string(),
                             clean::ImportSource {
                                 path: clean::Path {
@@ -555,7 +555,7 @@ fn build_static(cx: &DocContext<'_>, did: DefId, mutable: bool) -> clean::Static
     }
 }
 
-fn build_macro(cx: &DocContext<'_>, did: DefId, name: Symbol) -> clean::ItemEnum {
+fn build_macro(cx: &DocContext<'_>, did: DefId, name: Symbol) -> clean::ItemKind {
     let imported_from = cx.tcx.original_crate_name(did.krate);
     match cx.enter_resolver(|r| r.cstore().load_macro_untracked(did, cx.sess())) {
         LoadedMacro::MacroDef(def, _) => {

diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
index 366548d5b5fa2c8b0d6342be06fa2df785c9647c..56ce0bae8bb7b969d956455763b32a1760462311 100644 (file)
--- a/src/librustdoc/clean/mod.rs
+++ b/src/librustdoc/clean/mod.rs
@@ -42,7 +42,7 @@
 pub use utils::{get_auto_trait_and_blanket_impls, krate, register_res};
 
 pub use self::types::FnRetTy::*;
-pub use self::types::ItemEnum::*;
+pub use self::types::ItemKind::*;
 pub use self::types::SelfTy::*;
 pub use self::types::Type::*;
 pub use self::types::Visibility::{Inherited, Public};
@@ -276,7 +276,7 @@ fn clean(&self, cx: &DocContext<'_>) -> Item {
             stability: cx.stability(self.id),
             deprecation: cx.deprecation(self.id).clean(cx),
             def_id: cx.tcx.hir().local_def_id(self.id).to_def_id(),
-            inner: ModuleItem(Module { is_crate: self.is_crate, items }),
+            kind: ModuleItem(Module { is_crate: self.is_crate, items }),
         }
     }
 }
@@ -916,7 +916,7 @@ fn clean(&self, cx: &DocContext<'_>) -> Item {
             stability: cx.stability(self.id),
             deprecation: cx.deprecation(self.id).clean(cx),
             def_id: did.to_def_id(),
-            inner: FunctionItem(Function {
+            kind: FunctionItem(Function {
                 decl,
                 generics,
                 header: hir::FnHeader { constness, ..self.header },
@@ -1023,7 +1023,7 @@ fn clean(&self, cx: &DocContext<'_>) -> Item {
             visibility: self.vis.clean(cx),
             stability: cx.stability(self.id),
             deprecation: cx.deprecation(self.id).clean(cx),
-            inner: TraitItem(Trait {
+            kind: TraitItem(Trait {
                 auto: self.is_auto.clean(cx),
                 unsafety: self.unsafety,
                 items: self.items.iter().map(|ti| ti.clean(cx)).collect(),
@@ -1047,7 +1047,7 @@ fn clean(&self, cx: &DocContext<'_>) -> Item {
             visibility: self.vis.clean(cx),
             stability: cx.stability(self.id),
             deprecation: cx.deprecation(self.id).clean(cx),
-            inner: TraitAliasItem(TraitAlias {
+            kind: TraitAliasItem(TraitAlias {
                 generics: self.generics.clean(cx),
                 bounds: self.bounds.clean(cx),
             }),
@@ -1102,7 +1102,7 @@ fn clean(&self, _: &DocContext<'_>) -> TypeKind {
 impl Clean<Item> for hir::TraitItem<'_> {
     fn clean(&self, cx: &DocContext<'_>) -> Item {
         let local_did = cx.tcx.hir().local_def_id(self.hir_id);
-        let inner = match self.kind {
+        let kind = match self.kind {
             hir::TraitItemKind::Const(ref ty, default) => {
                 AssocConstItem(ty.clean(cx), default.map(|e| print_const_expr(cx, e)))
             }
@@ -1140,7 +1140,7 @@ fn clean(&self, cx: &DocContext<'_>) -> Item {
             visibility: Visibility::Inherited,
             stability: get_stability(cx, local_did.to_def_id()),
             deprecation: get_deprecation(cx, local_did.to_def_id()),
-            inner,
+            kind,
         }
     }
 }
@@ -1148,7 +1148,7 @@ fn clean(&self, cx: &DocContext<'_>) -> Item {
 impl Clean<Item> for hir::ImplItem<'_> {
     fn clean(&self, cx: &DocContext<'_>) -> Item {
         let local_did = cx.tcx.hir().local_def_id(self.hir_id);
-        let inner = match self.kind {
+        let kind = match self.kind {
             hir::ImplItemKind::Const(ref ty, expr) => {
                 AssocConstItem(ty.clean(cx), Some(print_const_expr(cx, expr)))
             }
@@ -1175,14 +1175,14 @@ fn clean(&self, cx: &DocContext<'_>) -> Item {
             visibility: self.vis.clean(cx),
             stability: get_stability(cx, local_did.to_def_id()),
             deprecation: get_deprecation(cx, local_did.to_def_id()),
-            inner,
+            kind,
         }
     }
 }
 
 impl Clean<Item> for ty::AssocItem {
     fn clean(&self, cx: &DocContext<'_>) -> Item {
-        let inner = match self.kind {
+        let kind = match self.kind {
             ty::AssocKind::Const => {
                 let ty = cx.tcx.type_of(self.def_id);
                 let default = if self.defaultness.has_value() {
@@ -1343,7 +1343,7 @@ fn clean(&self, cx: &DocContext<'_>) -> Item {
             def_id: self.def_id,
             attrs: inline::load_attrs(cx, self.def_id).clean(cx),
             source: cx.tcx.def_span(self.def_id).clean(cx),
-            inner,
+            kind,
         }
     }
 }
@@ -1784,7 +1784,7 @@ fn clean(&self, cx: &DocContext<'_>) -> Item {
             stability: get_stability(cx, local_did.to_def_id()),
             deprecation: get_deprecation(cx, local_did.to_def_id()),
             def_id: local_did.to_def_id(),
-            inner: StructFieldItem(self.ty.clean(cx)),
+            kind: StructFieldItem(self.ty.clean(cx)),
         }
     }
 }
@@ -1799,7 +1799,7 @@ fn clean(&self, cx: &DocContext<'_>) -> Item {
             stability: get_stability(cx, self.did),
             deprecation: get_deprecation(cx, self.did),
             def_id: self.did,
-            inner: StructFieldItem(cx.tcx.type_of(self.did).clean(cx)),
+            kind: StructFieldItem(cx.tcx.type_of(self.did).clean(cx)),
         }
     }
 }
@@ -1835,7 +1835,7 @@ fn clean(&self, cx: &DocContext<'_>) -> Item {
             visibility: self.vis.clean(cx),
             stability: cx.stability(self.id),
             deprecation: cx.deprecation(self.id).clean(cx),
-            inner: StructItem(Struct {
+            kind: StructItem(Struct {
                 struct_type: self.struct_type,
                 generics: self.generics.clean(cx),
                 fields: self.fields.clean(cx),
@@ -1855,7 +1855,7 @@ fn clean(&self, cx: &DocContext<'_>) -> Item {
             visibility: self.vis.clean(cx),
             stability: cx.stability(self.id),
             deprecation: cx.deprecation(self.id).clean(cx),
-            inner: UnionItem(Union {
+            kind: UnionItem(Union {
                 struct_type: self.struct_type,
                 generics: self.generics.clean(cx),
                 fields: self.fields.clean(cx),
@@ -1885,7 +1885,7 @@ fn clean(&self, cx: &DocContext<'_>) -> Item {
             visibility: self.vis.clean(cx),
             stability: cx.stability(self.id),
             deprecation: cx.deprecation(self.id).clean(cx),
-            inner: EnumItem(Enum {
+            kind: EnumItem(Enum {
                 variants: self.variants.iter().map(|v| v.clean(cx)).collect(),
                 generics: self.generics.clean(cx),
                 variants_stripped: false,
@@ -1904,7 +1904,7 @@ fn clean(&self, cx: &DocContext<'_>) -> Item {
             stability: cx.stability(self.id),
             deprecation: cx.deprecation(self.id).clean(cx),
             def_id: cx.tcx.hir().local_def_id(self.id).to_def_id(),
-            inner: VariantItem(Variant { kind: self.def.clean(cx) }),
+            kind: VariantItem(Variant { kind: self.def.clean(cx) }),
         }
     }
 }
@@ -1930,7 +1930,7 @@ fn clean(&self, cx: &DocContext<'_>) -> Item {
                         def_id: field.did,
                         stability: get_stability(cx, field.did),
                         deprecation: get_deprecation(cx, field.did),
-                        inner: StructFieldItem(cx.tcx.type_of(field.did).clean(cx)),
+                        kind: StructFieldItem(cx.tcx.type_of(field.did).clean(cx)),
                     })
                     .collect(),
             }),
@@ -1941,7 +1941,7 @@ fn clean(&self, cx: &DocContext<'_>) -> Item {
             source: cx.tcx.def_span(self.def_id).clean(cx),
             visibility: Inherited,
             def_id: self.def_id,
-            inner: VariantItem(Variant { kind }),
+            kind: VariantItem(Variant { kind }),
             stability: get_stability(cx, self.def_id),
             deprecation: get_deprecation(cx, self.def_id),
         }
@@ -2057,7 +2057,7 @@ fn clean(&self, cx: &DocContext<'_>) -> Item {
             visibility: self.vis.clean(cx),
             stability: cx.stability(self.id),
             deprecation: cx.deprecation(self.id).clean(cx),
-            inner: TypedefItem(Typedef { type_, generics: self.gen.clean(cx), item_type }, false),
+            kind: TypedefItem(Typedef { type_, generics: self.gen.clean(cx), item_type }, false),
         }
     }
 }
@@ -2072,7 +2072,7 @@ fn clean(&self, cx: &DocContext<'_>) -> Item {
             visibility: self.vis.clean(cx),
             stability: cx.stability(self.id),
             deprecation: cx.deprecation(self.id).clean(cx),
-            inner: OpaqueTyItem(OpaqueTy {
+            kind: OpaqueTyItem(OpaqueTy {
                 bounds: self.opaque_ty.bounds.clean(cx),
                 generics: self.opaque_ty.generics.clean(cx),
             }),
@@ -2100,7 +2100,7 @@ fn clean(&self, cx: &DocContext<'_>) -> Item {
             visibility: self.vis.clean(cx),
             stability: cx.stability(self.id),
             deprecation: cx.deprecation(self.id).clean(cx),
-            inner: StaticItem(Static {
+            kind: StaticItem(Static {
                 type_: self.type_.clean(cx),
                 mutability: self.mutability,
                 expr: print_const_expr(cx, self.expr),
@@ -2121,7 +2121,7 @@ fn clean(&self, cx: &DocContext<'_>) -> Item {
             visibility: self.vis.clean(cx),
             stability: cx.stability(self.id),
             deprecation: cx.deprecation(self.id).clean(cx),
-            inner: ConstantItem(Constant {
+            kind: ConstantItem(Constant {
                 type_: self.type_.clean(cx),
                 expr: print_const_expr(cx, self.expr),
                 value: print_evaluated_const(cx, def_id.to_def_id()),
@@ -2175,7 +2175,7 @@ fn clean(&self, cx: &DocContext<'_>) -> Vec<Item> {
             visibility: self.vis.clean(cx),
             stability: cx.stability(self.id),
             deprecation: cx.deprecation(self.id).clean(cx),
-            inner: ImplItem(Impl {
+            kind: ImplItem(Impl {
                 unsafety: self.unsafety,
                 generics: self.generics.clean(cx),
                 provided_trait_methods: provided.clone(),
@@ -2231,7 +2231,7 @@ fn clean(&self, cx: &DocContext<'_>) -> Vec<Item> {
             visibility: self.vis.clean(cx),
             stability: None,
             deprecation: None,
-            inner: ExternCrateItem(self.name.clean(cx), self.path.clone()),
+            kind: ExternCrateItem(self.name.clean(cx), self.path.clone()),
         }]
     }
 }
@@ -2302,7 +2302,7 @@ fn clean(&self, cx: &DocContext<'_>) -> Vec<Item> {
                         visibility: self.vis.clean(cx),
                         stability: None,
                         deprecation: None,
-                        inner: ImportItem(Import::new_simple(
+                        kind: ImportItem(Import::new_simple(
                             self.name.clean(cx),
                             resolve_use_source(cx, path),
                             false,
@@ -2322,14 +2322,14 @@ fn clean(&self, cx: &DocContext<'_>) -> Vec<Item> {
             visibility: self.vis.clean(cx),
             stability: None,
             deprecation: None,
-            inner: ImportItem(inner),
+            kind: ImportItem(inner),
         }]
     }
 }
 
 impl Clean<Item> for doctree::ForeignItem<'_> {
     fn clean(&self, cx: &DocContext<'_>) -> Item {
-        let inner = match self.kind {
+        let kind = match self.kind {
             hir::ForeignItemKind::Fn(ref decl, ref names, ref generics) => {
                 let abi = cx.tcx.hir().get_foreign_abi(self.id);
                 let (generics, decl) =
@@ -2364,7 +2364,7 @@ fn clean(&self, cx: &DocContext<'_>) -> Item {
             visibility: self.vis.clean(cx),
             stability: cx.stability(self.id),
             deprecation: cx.deprecation(self.id).clean(cx),
-            inner,
+            kind,
         }
     }
 }
@@ -2380,7 +2380,7 @@ fn clean(&self, cx: &DocContext<'_>) -> Item {
             stability: cx.stability(self.hid),
             deprecation: cx.deprecation(self.hid).clean(cx),
             def_id: self.def_id,
-            inner: MacroItem(Macro {
+            kind: MacroItem(Macro {
                 source: format!(
                     "macro_rules! {} {{\n{}}}",
                     name,
@@ -2405,7 +2405,7 @@ fn clean(&self, cx: &DocContext<'_>) -> Item {
             stability: cx.stability(self.id),
             deprecation: cx.deprecation(self.id).clean(cx),
             def_id: cx.tcx.hir().local_def_id(self.id).to_def_id(),
-            inner: ProcMacroItem(ProcMacro { kind: self.kind, helpers: self.helpers.clean(cx) }),
+            kind: ProcMacroItem(ProcMacro { kind: self.kind, helpers: self.helpers.clean(cx) }),
         }
     }
 }

diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs
index 32b3f69ecd4f0d3bc1cc63371ee62516fdfabf99..5b1d38fb05f27ff85e448f71230e129330535606 100644 (file)
--- a/src/librustdoc/clean/types.rs
+++ b/src/librustdoc/clean/types.rs
@@ -41,7 +41,7 @@
 use crate::html::render::cache::ExternalLocation;
 
 use self::FnRetTy::*;
-use self::ItemEnum::*;
+use self::ItemKind::*;
 use self::SelfTy::*;
 use self::Type::*;
 
@@ -81,7 +81,7 @@ pub struct Item {
     /// Not everything has a name. E.g., impls
     pub name: Option<String>,
     pub attrs: Attributes,
-    pub inner: ItemEnum,
+    pub kind: ItemKind,
     pub visibility: Visibility,
     pub def_id: DefId,
     pub stability: Option<Stability>,
@@ -90,14 +90,13 @@ pub struct Item {
 
 impl fmt::Debug for Item {
     fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let fake = self.is_fake();
-        let def_id: &dyn fmt::Debug = if fake { &"**FAKE**" } else { &self.def_id };
+        let def_id: &dyn fmt::Debug = if self.is_fake() { &"**FAKE**" } else { &self.def_id };
 
         fmt.debug_struct("Item")
             .field("source", &self.source)
             .field("name", &self.name)
             .field("attrs", &self.attrs)
-            .field("inner", &self.inner)
+            .field("kind", &self.kind)
             .field("visibility", &self.visibility)
             .field("def_id", def_id)
             .field("stability", &self.stability)
@@ -124,7 +123,7 @@ pub fn links(&self) -> Vec<RenderedLink> {
     }
 
     pub fn is_crate(&self) -> bool {
-        match self.inner {
+        match self.kind {
             StrippedItem(box ModuleItem(Module { is_crate: true, .. }))
             | ModuleItem(Module { is_crate: true, .. }) => true,
             _ => false,
@@ -176,14 +175,14 @@ pub fn is_keyword(&self) -> bool {
         self.type_() == ItemType::Keyword
     }
     pub fn is_stripped(&self) -> bool {
-        match self.inner {
+        match self.kind {
             StrippedItem(..) => true,
             ImportItem(ref i) => !i.should_be_displayed,
             _ => false,
         }
     }
     pub fn has_stripped_fields(&self) -> Option<bool> {
-        match self.inner {
+        match self.kind {
             StructItem(ref _struct) => Some(_struct.fields_stripped),
             UnionItem(ref union) => Some(union.fields_stripped),
             VariantItem(Variant { kind: VariantKind::Struct(ref vstruct) }) => {
@@ -227,8 +226,8 @@ pub fn type_(&self) -> ItemType {
     }
 
     pub fn is_default(&self) -> bool {
-        match self.inner {
-            ItemEnum::MethodItem(ref meth) => {
+        match self.kind {
+            ItemKind::MethodItem(ref meth) => {
                 if let Some(defaultness) = meth.defaultness {
                     defaultness.has_value() && !defaultness.is_final()
                 } else {
@@ -248,7 +247,7 @@ pub fn is_fake(&self) -> bool {
 }
 
 #[derive(Clone, Debug)]
-pub enum ItemEnum {
+pub enum ItemKind {
     ExternCrateItem(String, Option<String>),
     ImportItem(Import),
     StructItem(Struct),
@@ -282,23 +281,23 @@ pub enum ItemEnum {
     AssocConstItem(Type, Option<String>),
     AssocTypeItem(Vec<GenericBound>, Option<Type>),
     /// An item that has been stripped by a rustdoc pass
-    StrippedItem(Box<ItemEnum>),
+    StrippedItem(Box<ItemKind>),
     KeywordItem(String),
 }
 
-impl ItemEnum {
+impl ItemKind {
     pub fn is_type_alias(&self) -> bool {
         match *self {
-            ItemEnum::TypedefItem(_, _) | ItemEnum::AssocTypeItem(_, _) => true,
+            ItemKind::TypedefItem(_, _) | ItemKind::AssocTypeItem(_, _) => true,
             _ => false,
         }
     }
 
     pub fn as_assoc_kind(&self) -> Option<AssocKind> {
         match *self {
-            ItemEnum::AssocConstItem(..) => Some(AssocKind::Const),
-            ItemEnum::AssocTypeItem(..) => Some(AssocKind::Type),
-            ItemEnum::TyMethodItem(..) | ItemEnum::MethodItem(..) => Some(AssocKind::Fn),
+            ItemKind::AssocConstItem(..) => Some(AssocKind::Const),
+            ItemKind::AssocTypeItem(..) => Some(AssocKind::Type),
+            ItemKind::TyMethodItem(..) | ItemKind::MethodItem(..) => Some(AssocKind::Fn),
             _ => None,
         }
     }

diff --git a/src/librustdoc/clean/utils.rs b/src/librustdoc/clean/utils.rs
index f6258221e322d578a4a419a2e64b97010481ba57..e5fb656cbb9167087194ecd9977b590299dd8c3b 100644 (file)
--- a/src/librustdoc/clean/utils.rs
+++ b/src/librustdoc/clean/utils.rs
@@ -2,7 +2,7 @@
 use crate::clean::blanket_impl::BlanketImplFinder;
 use crate::clean::{
     inline, Clean, Crate, Deprecation, ExternalCrate, FnDecl, FnRetTy, Generic, GenericArg,
-    GenericArgs, GenericBound, Generics, GetDefId, ImportSource, Item, ItemEnum, Lifetime,
+    GenericArgs, GenericBound, Generics, GetDefId, ImportSource, Item, ItemKind, Lifetime,
     MacroKind, Path, PathSegment, Primitive, PrimitiveType, ResolvedPath, Span, Type, TypeBinding,
     TypeKind, Visibility, WherePredicate,
 };
@@ -44,8 +44,8 @@ pub fn krate(mut cx: &mut DocContext<'_>) -> Crate {
     let mut module = module.clean(cx);
     let mut masked_crates = FxHashSet::default();
 
-    match module.inner {
-        ItemEnum::ModuleItem(ref module) => {
+    match module.kind {
+        ItemKind::ModuleItem(ref module) => {
             for it in &module.items {
                 // `compiler_builtins` should be masked too, but we can't apply
                 // `#[doc(masked)]` to the injected `extern crate` because it's unstable.
@@ -62,8 +62,8 @@ pub fn krate(mut cx: &mut DocContext<'_>) -> Crate {
 
     let ExternalCrate { name, src, primitives, keywords, .. } = LOCAL_CRATE.clean(cx);
     {
-        let m = match module.inner {
-            ItemEnum::ModuleItem(ref mut m) => m,
+        let m = match module.kind {
+            ItemKind::ModuleItem(ref mut m) => m,
             _ => unreachable!(),
         };
         m.items.extend(primitives.iter().map(|&(def_id, prim, ref attrs)| Item {
@@ -74,7 +74,7 @@ pub fn krate(mut cx: &mut DocContext<'_>) -> Crate {
             stability: get_stability(cx, def_id),
             deprecation: get_deprecation(cx, def_id),
             def_id,
-            inner: ItemEnum::PrimitiveItem(prim),
+            kind: ItemKind::PrimitiveItem(prim),
         }));
         m.items.extend(keywords.into_iter().map(|(def_id, kw, attrs)| Item {
             source: Span::empty(),
@@ -84,7 +84,7 @@ pub fn krate(mut cx: &mut DocContext<'_>) -> Crate {
             stability: get_stability(cx, def_id),
             deprecation: get_deprecation(cx, def_id),
             def_id,
-            inner: ItemEnum::KeywordItem(kw),
+            kind: ItemKind::KeywordItem(kw),
         }));
     }
 
@@ -355,8 +355,8 @@ pub fn build_deref_target_impls(cx: &DocContext<'_>, items: &[Item], ret: &mut V
     let tcx = cx.tcx;
 
     for item in items {
-        let target = match item.inner {
-            ItemEnum::TypedefItem(ref t, true) => &t.type_,
+        let target = match item.kind {
+            ItemKind::TypedefItem(ref t, true) => &t.type_,
             _ => continue,
         };
         let primitive = match *target {

diff --git a/src/librustdoc/fold.rs b/src/librustdoc/fold.rs
index d4ada3278e6a1298901371d33cabfe12dcccec07..694051aa54f4d416bd0504d38257d5b24110f209 100644 (file)
--- a/src/librustdoc/fold.rs
+++ b/src/librustdoc/fold.rs
@@ -5,9 +5,9 @@
 impl StripItem {
     pub fn strip(self) -> Option<Item> {
         match self.0 {
-            Item { inner: StrippedItem(..), .. } => Some(self.0),
+            Item { kind: StrippedItem(..), .. } => Some(self.0),
             mut i => {
-                i.inner = StrippedItem(box i.inner);
+                i.kind = StrippedItem(box i.kind);
                 Some(i)
             }
         }
@@ -20,8 +20,8 @@ fn fold_item(&mut self, item: Item) -> Option<Item> {
     }
 
     /// don't override!
-    fn fold_inner_recur(&mut self, inner: ItemEnum) -> ItemEnum {
-        match inner {
+    fn fold_inner_recur(&mut self, kind: ItemKind) -> ItemKind {
+        match kind {
             StrippedItem(..) => unreachable!(),
             ModuleItem(i) => ModuleItem(self.fold_mod(i)),
             StructItem(mut i) => {
@@ -72,14 +72,14 @@ fn fold_inner_recur(&mut self, inner: ItemEnum) -> ItemEnum {
 
     /// don't override!
     fn fold_item_recur(&mut self, item: Item) -> Option<Item> {
-        let Item { attrs, name, source, visibility, def_id, inner, stability, deprecation } = item;
+        let Item { attrs, name, source, visibility, def_id, kind, stability, deprecation } = item;
 
-        let inner = match inner {
+        let kind = match kind {
             StrippedItem(box i) => StrippedItem(box self.fold_inner_recur(i)),
-            _ => self.fold_inner_recur(inner),
+            _ => self.fold_inner_recur(kind),
         };
 
-        Some(Item { attrs, name, source, inner, visibility, stability, deprecation, def_id })
+        Some(Item { attrs, name, source, kind, visibility, stability, deprecation, def_id })
     }
 
     fn fold_mod(&mut self, m: Module) -> Module {

diff --git a/src/librustdoc/formats/cache.rs b/src/librustdoc/formats/cache.rs
index b99321e8484c97ca224fa036d25efdedc277d60a..277571b11f51b0de385beb0d4706207a9079d255 100644 (file)
--- a/src/librustdoc/formats/cache.rs
+++ b/src/librustdoc/formats/cache.rs
@@ -218,7 +218,7 @@ fn fold_item(&mut self, item: clean::Item) -> Option<clean::Item> {
 
         // If this is a stripped module,
         // we don't want it or its children in the search index.
-        let orig_stripped_mod = match item.inner {
+        let orig_stripped_mod = match item.kind {
             clean::StrippedItem(box clean::ModuleItem(..)) => {
                 mem::replace(&mut self.stripped_mod, true)
             }
@@ -227,7 +227,7 @@ fn fold_item(&mut self, item: clean::Item) -> Option<clean::Item> {
 
         // If the impl is from a masked crate or references something from a
         // masked crate then remove it completely.
-        if let clean::ImplItem(ref i) = item.inner {
+        if let clean::ImplItem(ref i) = item.kind {
             if self.masked_crates.contains(&item.def_id.krate)
                 || i.trait_.def_id().map_or(false, |d| self.masked_crates.contains(&d.krate))
                 || i.for_.def_id().map_or(false, |d| self.masked_crates.contains(&d.krate))
@@ -238,12 +238,12 @@ fn fold_item(&mut self, item: clean::Item) -> Option<clean::Item> {
 
         // Propagate a trait method's documentation to all implementors of the
         // trait.
-        if let clean::TraitItem(ref t) = item.inner {
+        if let clean::TraitItem(ref t) = item.kind {
             self.traits.entry(item.def_id).or_insert_with(|| t.clone());
         }
 
         // Collect all the implementors of traits.
-        if let clean::ImplItem(ref i) = item.inner {
+        if let clean::ImplItem(ref i) = item.kind {
             if let Some(did) = i.trait_.def_id() {
                 if i.blanket_impl.is_none() {
                     self.implementors
@@ -256,7 +256,7 @@ fn fold_item(&mut self, item: clean::Item) -> Option<clean::Item> {
 
         // Index this method for searching later on.
         if let Some(ref s) = item.name {
-            let (parent, is_inherent_impl_item) = match item.inner {
+            let (parent, is_inherent_impl_item) = match item.kind {
                 clean::StrippedItem(..) => ((None, None), false),
                 clean::AssocConstItem(..) | clean::TypedefItem(_, true)
                     if self.parent_is_trait_impl =>
@@ -345,7 +345,7 @@ fn fold_item(&mut self, item: clean::Item) -> Option<clean::Item> {
             _ => false,
         };
 
-        match item.inner {
+        match item.kind {
             clean::StructItem(..)
             | clean::EnumItem(..)
             | clean::TypedefItem(..)
@@ -384,7 +384,7 @@ fn fold_item(&mut self, item: clean::Item) -> Option<clean::Item> {
 
         // Maintain the parent stack
         let orig_parent_is_trait_impl = self.parent_is_trait_impl;
-        let parent_pushed = match item.inner {
+        let parent_pushed = match item.kind {
             clean::TraitItem(..)
             | clean::EnumItem(..)
             | clean::ForeignTypeItem
@@ -422,12 +422,12 @@ fn fold_item(&mut self, item: clean::Item) -> Option<clean::Item> {
         // Once we've recursively found all the generics, hoard off all the
         // implementations elsewhere.
         let ret = self.fold_item_recur(item).and_then(|item| {
-            if let clean::Item { inner: clean::ImplItem(_), .. } = item {
+            if let clean::Item { kind: clean::ImplItem(_), .. } = item {
                 // Figure out the id of this impl. This may map to a
                 // primitive rather than always to a struct/enum.
                 // Note: matching twice to restrict the lifetime of the `i` borrow.
                 let mut dids = FxHashSet::default();
-                if let clean::Item { inner: clean::ImplItem(ref i), .. } = item {
+                if let clean::Item { kind: clean::ImplItem(ref i), .. } = item {
                     match i.for_ {
                         clean::ResolvedPath { did, .. }
                         | clean::BorrowedRef {

diff --git a/src/librustdoc/formats/item_type.rs b/src/librustdoc/formats/item_type.rs
index 696bdae94fc88b89170999b60258b2d196781c04..a0f4502f750f1968389c51fac41f0b20881e0cc1 100644 (file)
--- a/src/librustdoc/formats/item_type.rs
+++ b/src/librustdoc/formats/item_type.rs
@@ -60,12 +60,12 @@ fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 
 impl<'a> From<&'a clean::Item> for ItemType {
     fn from(item: &'a clean::Item) -> ItemType {
-        let inner = match item.inner {
+        let kind = match item.kind {
             clean::StrippedItem(box ref item) => item,
-            ref inner => inner,
+            ref kind => kind,
         };
 
-        match *inner {
+        match *kind {
             clean::ModuleItem(..) => ItemType::Module,
             clean::ExternCrateItem(..) => ItemType::ExternCrate,
             clean::ImportItem(..) => ItemType::Import,

diff --git a/src/librustdoc/formats/mod.rs b/src/librustdoc/formats/mod.rs
index dcb0184c58cd20c95918f6c215e7a4edda050787..b893d6c64ec9446b95db8aaa9675e77710a4bacd 100644 (file)
--- a/src/librustdoc/formats/mod.rs
+++ b/src/librustdoc/formats/mod.rs
@@ -32,7 +32,7 @@ pub struct Impl {
 
 impl Impl {
     pub fn inner_impl(&self) -> &clean::Impl {
-        match self.impl_item.inner {
+        match self.impl_item.kind {
             clean::ImplItem(ref impl_) => impl_,
             _ => panic!("non-impl item found in impl"),
         }

diff --git a/src/librustdoc/formats/renderer.rs b/src/librustdoc/formats/renderer.rs
index 90ace4d44c47dc93e1539dbf1da183df6f641d4b..273e281925742a43fa6cbc5d30d01f1773de867f 100644 (file)
--- a/src/librustdoc/formats/renderer.rs
+++ b/src/librustdoc/formats/renderer.rs
@@ -86,7 +86,7 @@ pub fn run_format<T: FormatRenderer>(
             }
 
             cx.mod_item_in(&item, &name, &cache)?;
-            let module = match item.inner {
+            let module = match item.kind {
                 clean::StrippedItem(box clean::ModuleItem(m)) | clean::ModuleItem(m) => m,
                 _ => unreachable!(),
             };

diff --git a/src/librustdoc/html/render/cache.rs b/src/librustdoc/html/render/cache.rs
index add28de17edef20e1f21d68b364161b041844045..0541bf118e14f2876c1a608c3333720c9d60a88d 100644 (file)
--- a/src/librustdoc/html/render/cache.rs
+++ b/src/librustdoc/html/render/cache.rs
@@ -165,7 +165,7 @@ struct CrateData<'a> {
 }
 
 crate fn get_index_search_type(item: &clean::Item) -> Option<IndexItemFunctionType> {
-    let (all_types, ret_types) = match item.inner {
+    let (all_types, ret_types) = match item.kind {
         clean::FunctionItem(ref f) => (&f.all_types, &f.ret_types),
         clean::MethodItem(ref m) => (&m.all_types, &m.ret_types),
         clean::TyMethodItem(ref m) => (&m.all_types, &m.ret_types),

diff --git a/src/librustdoc/html/render/mod.rs b/src/librustdoc/html/render/mod.rs
index 5ac0ffcfbf1c2d18b50928006dd82d54cd7b0acc..404ba07ddfdb8096359244af39b45696cec8400e 100644 (file)
--- a/src/librustdoc/html/render/mod.rs
+++ b/src/librustdoc/html/render/mod.rs
@@ -618,7 +618,7 @@ fn mod_item_in(
 
         // Render sidebar-items.js used throughout this module.
         if !self.render_redirect_pages {
-            let module = match item.inner {
+            let module = match item.kind {
                 clean::StrippedItem(box clean::ModuleItem(ref m)) | clean::ModuleItem(ref m) => m,
                 _ => unreachable!(),
             };
@@ -1717,7 +1717,7 @@ fn print_item(cx: &Context, item: &clean::Item, buf: &mut Buffer, cache: &Cache)
 
     write!(buf, "</span>"); // out-of-band
     write!(buf, "<span class=\"in-band\">");
-    let name = match item.inner {
+    let name = match item.kind {
         clean::ModuleItem(ref m) => {
             if m.is_crate {
                 "Crate "
@@ -1766,7 +1766,7 @@ fn print_item(cx: &Context, item: &clean::Item, buf: &mut Buffer, cache: &Cache)
 
     write!(buf, "</span></h1>"); // in-band
 
-    match item.inner {
+    match item.kind {
         clean::ModuleItem(ref m) => item_module(buf, cx, item, &m.items),
         clean::FunctionItem(ref f) | clean::ForeignFunctionItem(ref f) => {
             item_function(buf, cx, item, f)
@@ -2133,7 +2133,7 @@ fn cmp(i1: &clean::Item, i2: &clean::Item, idx1: usize, idx2: usize) -> Ordering
             );
         }
 
-        match myitem.inner {
+        match myitem.kind {
             clean::ExternCrateItem(ref name, ref src) => {
                 use crate::html::format::anchor;
 
@@ -2169,7 +2169,7 @@ fn cmp(i1: &clean::Item, i2: &clean::Item, idx1: usize, idx2: usize) -> Ordering
                     continue;
                 }
 
-                let unsafety_flag = match myitem.inner {
+                let unsafety_flag = match myitem.kind {
                     clean::FunctionItem(ref func) | clean::ForeignFunctionItem(ref func)
                         if func.header.unsafety == hir::Unsafety::Unsafe =>
                     {
@@ -2582,7 +2582,7 @@ fn item_trait(w: &mut Buffer, cx: &Context, it: &clean::Item, t: &clean::Trait,
             }
             for (pos, m) in provided.iter().enumerate() {
                 render_assoc_item(w, m, AssocItemLink::Anchor(None), ItemType::Trait);
-                match m.inner {
+                match m.kind {
                     clean::MethodItem(ref inner) if !inner.generics.where_predicates.is_empty() => {
                         write!(w, ",\n    {{ ... }}\n");
                     }
@@ -2958,7 +2958,7 @@ fn method(
             where_clause = WhereClause { gens: g, indent, end_newline }
         )
     }
-    match item.inner {
+    match item.kind {
         clean::StrippedItem(..) => {}
         clean::TyMethodItem(ref m) => method(w, item, m.header, &m.generics, &m.decl, link, parent),
         clean::MethodItem(ref m) => method(w, item, m.header, &m.generics, &m.decl, link, parent),
@@ -2994,7 +2994,7 @@ fn item_struct(w: &mut Buffer, cx: &Context, it: &clean::Item, s: &clean::Struct
     let mut fields = s
         .fields
         .iter()
-        .filter_map(|f| match f.inner {
+        .filter_map(|f| match f.kind {
             clean::StructFieldItem(ref ty) => Some((f, ty)),
             _ => None,
         })
@@ -3044,7 +3044,7 @@ fn item_union(w: &mut Buffer, cx: &Context, it: &clean::Item, s: &clean::Union,
     let mut fields = s
         .fields
         .iter()
-        .filter_map(|f| match f.inner {
+        .filter_map(|f| match f.kind {
             clean::StructFieldItem(ref ty) => Some((f, ty)),
             _ => None,
         })
@@ -3097,7 +3097,7 @@ fn item_enum(w: &mut Buffer, cx: &Context, it: &clean::Item, e: &clean::Enum, ca
             for v in &e.variants {
                 write!(w, "    ");
                 let name = v.name.as_ref().unwrap();
-                match v.inner {
+                match v.kind {
                     clean::VariantItem(ref var) => match var.kind {
                         clean::VariantKind::CLike => write!(w, "{}", name),
                         clean::VariantKind::Tuple(ref tys) => {
@@ -3147,7 +3147,7 @@ fn item_enum(w: &mut Buffer, cx: &Context, it: &clean::Item, e: &clean::Enum, ca
                 id = id,
                 name = variant.name.as_ref().unwrap()
             );
-            if let clean::VariantItem(ref var) = variant.inner {
+            if let clean::VariantItem(ref var) = variant.kind {
                 if let clean::VariantKind::Tuple(ref tys) = var.kind {
                     write!(w, "(");
                     for (i, ty) in tys.iter().enumerate() {
@@ -3164,8 +3164,7 @@ fn item_enum(w: &mut Buffer, cx: &Context, it: &clean::Item, e: &clean::Enum, ca
             document_non_exhaustive(w, variant);
 
             use crate::clean::{Variant, VariantKind};
-            if let clean::VariantItem(Variant { kind: VariantKind::Struct(ref s) }) = variant.inner
-            {
+            if let clean::VariantItem(Variant { kind: VariantKind::Struct(ref s) }) = variant.kind {
                 let variant_id = cx.derive_id(format!(
                     "{}.{}.fields",
                     ItemType::Variant,
@@ -3179,7 +3178,7 @@ fn item_enum(w: &mut Buffer, cx: &Context, it: &clean::Item, e: &clean::Enum, ca
                 );
                 for field in &s.fields {
                     use crate::clean::StructFieldItem;
-                    if let StructFieldItem(ref ty) = field.inner {
+                    if let StructFieldItem(ref ty) = field.kind {
                         let id = cx.derive_id(format!(
                             "variant.{}.field.{}",
                             variant.name.as_ref().unwrap(),
@@ -3275,7 +3274,7 @@ fn render_struct(
             let mut has_visible_fields = false;
             write!(w, " {{");
             for field in fields {
-                if let clean::StructFieldItem(ref ty) = field.inner {
+                if let clean::StructFieldItem(ref ty) = field.kind {
                     write!(
                         w,
                         "\n{}    {}{}: {},",
@@ -3306,7 +3305,7 @@ fn render_struct(
                 if i > 0 {
                     write!(w, ", ");
                 }
-                match field.inner {
+                match field.kind {
                     clean::StrippedItem(box clean::StructFieldItem(..)) => write!(w, "_"),
                     clean::StructFieldItem(ref ty) => {
                         write!(w, "{}{}", field.visibility.print_with_space(), ty.print())
@@ -3352,7 +3351,7 @@ fn render_union(
 
     write!(w, " {{\n{}", tab);
     for field in fields {
-        if let clean::StructFieldItem(ref ty) = field.inner {
+        if let clean::StructFieldItem(ref ty) = field.kind {
             write!(
                 w,
                 "    {}{}: {},\n{}",
@@ -3516,7 +3515,7 @@ fn render_deref_methods(
         .inner_impl()
         .items
         .iter()
-        .find_map(|item| match item.inner {
+        .find_map(|item| match item.kind {
             clean::TypedefItem(ref t, true) => Some(match *t {
                 clean::Typedef { item_type: Some(ref type_), .. } => (type_, &t.type_),
                 _ => (&t.type_, &t.type_),
@@ -3538,7 +3537,7 @@ fn render_deref_methods(
 }
 
 fn should_render_item(item: &clean::Item, deref_mut_: bool) -> bool {
-    let self_type_opt = match item.inner {
+    let self_type_opt = match item.kind {
         clean::MethodItem(ref method) => method.decl.self_type(),
         clean::TyMethodItem(ref method) => method.decl.self_type(),
         _ => None,
@@ -3589,7 +3588,7 @@ fn spotlight_decl(decl: &clean::FnDecl) -> String {
                     ));
                     let t_did = impl_.trait_.def_id().unwrap();
                     for it in &impl_.items {
-                        if let clean::TypedefItem(ref tydef, _) = it.inner {
+                        if let clean::TypedefItem(ref tydef, _) = it.kind {
                             out.push_str("<span class=\"where fmt-newline\">    ");
                             assoc_type(
                                 &mut out,
@@ -3657,7 +3656,7 @@ fn render_impl(
             fmt_impl_for_trait_page(&i.inner_impl(), w, use_absolute);
             if show_def_docs {
                 for it in &i.inner_impl().items {
-                    if let clean::TypedefItem(ref tydef, _) = it.inner {
+                    if let clean::TypedefItem(ref tydef, _) = it.kind {
                         write!(w, "<span class=\"where fmt-newline\">  ");
                         assoc_type(w, it, &[], Some(&tydef.type_), AssocItemLink::Anchor(None), "");
                         write!(w, ";</span>");
@@ -3728,14 +3727,14 @@ fn doc_impl_item(
         };
 
         let (is_hidden, extra_class) =
-            if (trait_.is_none() || item.doc_value().is_some() || item.inner.is_type_alias())
+            if (trait_.is_none() || item.doc_value().is_some() || item.kind.is_type_alias())
                 && !is_default_item
             {
                 (false, "")
             } else {
                 (true, " hidden")
             };
-        match item.inner {
+        match item.kind {
             clean::MethodItem(clean::Method { .. })
             | clean::TyMethodItem(clean::TyMethod { .. }) => {
                 // Only render when the method is not static or we allow static methods
@@ -4000,7 +3999,7 @@ fn print_sidebar(cx: &Context, it: &clean::Item, buffer: &mut Buffer, cache: &Ca
         write!(
             buffer,
             "<p class=\"location\">{}{}</p>",
-            match it.inner {
+            match it.kind {
                 clean::StructItem(..) => "Struct ",
                 clean::TraitItem(..) => "Trait ",
                 clean::PrimitiveItem(..) => "Primitive Type ",
@@ -4040,7 +4039,7 @@ fn print_sidebar(cx: &Context, it: &clean::Item, buffer: &mut Buffer, cache: &Ca
             it.name.as_ref().expect("crates always have a name")
         );
     }
-    match it.inner {
+    match it.kind {
         clean::StructItem(ref s) => sidebar_struct(buffer, it, s),
         clean::TraitItem(ref t) => sidebar_trait(buffer, it, t),
         clean::PrimitiveItem(_) => sidebar_primitive(buffer, it),
@@ -4180,7 +4179,7 @@ fn sidebar_assoc_items(it: &clean::Item) -> String {
                 .find(|i| i.inner_impl().trait_.def_id() == c.deref_trait_did)
             {
                 if let Some((target, real_target)) =
-                    impl_.inner_impl().items.iter().find_map(|item| match item.inner {
+                    impl_.inner_impl().items.iter().find_map(|item| match item.kind {
                         clean::TypedefItem(ref t, true) => Some(match *t {
                             clean::Typedef { item_type: Some(ref type_), .. } => (type_, &t.type_),
                             _ => (&t.type_, &t.type_),
@@ -4319,8 +4318,8 @@ fn get_id_for_impl_on_foreign_type(for_: &clean::Type, trait_: &clean::Type) ->
 }
 
 fn extract_for_impl_name(item: &clean::Item) -> Option<(String, String)> {
-    match item.inner {
-        clean::ItemEnum::ImplItem(ref i) => {
+    match item.kind {
+        clean::ItemKind::ImplItem(ref i) => {
             if let Some(ref trait_) = i.trait_ {
                 Some((
                     format!("{:#}", i.for_.print()),
@@ -4470,7 +4469,7 @@ fn sidebar_typedef(buf: &mut Buffer, it: &clean::Item) {
 fn get_struct_fields_name(fields: &[clean::Item]) -> String {
     let mut fields = fields
         .iter()
-        .filter(|f| if let clean::StructFieldItem(..) = f.inner { true } else { false })
+        .filter(|f| if let clean::StructFieldItem(..) = f.kind { true } else { false })
         .filter_map(|f| match f.name {
             Some(ref name) => {
                 Some(format!("<a href=\"#structfield.{name}\">{name}</a>", name = name))

diff --git a/src/librustdoc/passes/calculate_doc_coverage.rs b/src/librustdoc/passes/calculate_doc_coverage.rs
index ced26fcf5b0e95b33dbf40d09d355fd120bafd23..ef68bae10782db3632dc7f191fd5b9d55979a657 100644 (file)
--- a/src/librustdoc/passes/calculate_doc_coverage.rs
+++ b/src/librustdoc/passes/calculate_doc_coverage.rs
@@ -187,7 +187,7 @@ fn print_table_record(
 
 impl<'a, 'b> fold::DocFolder for CoverageCalculator<'a, 'b> {
     fn fold_item(&mut self, i: clean::Item) -> Option<clean::Item> {
-        match i.inner {
+        match i.kind {
             _ if !i.def_id.is_local() => {
                 // non-local items are skipped because they can be out of the users control,
                 // especially in the case of trait impls, which rustdoc eagerly inlines

diff --git a/src/librustdoc/passes/collect_intra_doc_links.rs b/src/librustdoc/passes/collect_intra_doc_links.rs
index e0cb5bf1a4ee614481a962bbdfff514011f09b6c..fd0dd339abdc22be4fef80cdb5104cef4c776e89 100644 (file)
--- a/src/librustdoc/passes/collect_intra_doc_links.rs
+++ b/src/librustdoc/passes/collect_intra_doc_links.rs
@@ -671,7 +671,7 @@ fn resolve_associated_trait_item(
     let implicit_impls = crate::clean::get_auto_trait_and_blanket_impls(cx, ty, did);
     let mut candidates: Vec<_> = implicit_impls
         .flat_map(|impl_outer| {
-            match impl_outer.inner {
+            match impl_outer.kind {
                 clean::ImplItem(impl_) => {
                     debug!("considering auto or blanket impl for trait {:?}", impl_.trait_);
                     // Give precedence to methods that were overridden
@@ -681,14 +681,14 @@ fn resolve_associated_trait_item(
                                 return None;
                             }
                             let kind = assoc
-                                .inner
+                                .kind
                                 .as_assoc_kind()
                                 .expect("inner items for a trait should be associated items");
                             if kind.namespace() != ns {
                                 return None;
                             }
 
-                            trace!("considering associated item {:?}", assoc.inner);
+                            trace!("considering associated item {:?}", assoc.kind);
                             // We have a slight issue: normal methods come from `clean` types,
                             // but provided methods come directly from `tcx`.
                             // Fortunately, we don't need the whole method, we just need to know
@@ -832,7 +832,7 @@ fn fold_item(&mut self, mut item: Item) -> Option<Item> {
             trace!("got parent node for {:?} {:?}, id {:?}", item.type_(), item.name, item.def_id);
         }
 
-        let current_item = match item.inner {
+        let current_item = match item.kind {
             clean::ModuleItem(..) => {
                 if item.attrs.inner_docs {
                     if item.def_id.is_top_level_module() { item.name.clone() } else { None }

diff --git a/src/librustdoc/passes/collect_trait_impls.rs b/src/librustdoc/passes/collect_trait_impls.rs
index 5eb3f98b12371b0686e3249431b9e995a750e2da..81de07302478b0dce045e5d266be9c04d60ed489 100644 (file)
--- a/src/librustdoc/passes/collect_trait_impls.rs
+++ b/src/librustdoc/passes/collect_trait_impls.rs
@@ -55,11 +55,11 @@ pub fn collect_trait_impls(krate: Crate, cx: &DocContext<'_>) -> Crate {
 
     // scan through included items ahead of time to splice in Deref targets to the "valid" sets
     for it in &new_items {
-        if let ImplItem(Impl { ref for_, ref trait_, ref items, .. }) = it.inner {
+        if let ImplItem(Impl { ref for_, ref trait_, ref items, .. }) = it.kind {
             if cleaner.keep_item(for_) && trait_.def_id() == cx.tcx.lang_items().deref_trait() {
                 let target = items
                     .iter()
-                    .find_map(|item| match item.inner {
+                    .find_map(|item| match item.kind {
                         TypedefItem(ref t, true) => Some(&t.type_),
                         _ => None,
                     })
@@ -75,7 +75,7 @@ pub fn collect_trait_impls(krate: Crate, cx: &DocContext<'_>) -> Crate {
     }
 
     new_items.retain(|it| {
-        if let ImplItem(Impl { ref for_, ref trait_, ref blanket_impl, .. }) = it.inner {
+        if let ImplItem(Impl { ref for_, ref trait_, ref blanket_impl, .. }) = it.kind {
             cleaner.keep_item(for_)
                 || trait_.as_ref().map_or(false, |t| cleaner.keep_item(t))
                 || blanket_impl.is_some()
@@ -96,7 +96,7 @@ pub fn collect_trait_impls(krate: Crate, cx: &DocContext<'_>) -> Crate {
     }
 
     if let Some(ref mut it) = krate.module {
-        if let ModuleItem(Module { ref mut items, .. }) = it.inner {
+        if let ModuleItem(Module { ref mut items, .. }) = it.kind {
             items.extend(synth.impls);
             items.extend(new_items);
         } else {

diff --git a/src/librustdoc/passes/doc_test_lints.rs b/src/librustdoc/passes/doc_test_lints.rs
index 686ec51fb0604025705c86cd49b9c2d4e0cef5a5..432b9bee5ef85c30dd6ea736686333e7a55fb0b3 100644 (file)
--- a/src/librustdoc/passes/doc_test_lints.rs
+++ b/src/librustdoc/passes/doc_test_lints.rs
@@ -58,7 +58,7 @@ fn add_test(&mut self, _: String, config: LangString, _: usize) {
 }
 
 pub fn should_have_doc_example(cx: &DocContext<'_>, item: &clean::Item) -> bool {
-    if matches!(item.inner,
+    if matches!(item.kind,
         clean::StructFieldItem(_)
         | clean::VariantItem(_)
         | clean::AssocConstItem(_, _)

diff --git a/src/librustdoc/passes/strip_hidden.rs b/src/librustdoc/passes/strip_hidden.rs
index f82e72b488bb764b753750a3273a0f3b4570871c..4b9e150eb1e30b43f4a451c485500cc2524d6578 100644 (file)
--- a/src/librustdoc/passes/strip_hidden.rs
+++ b/src/librustdoc/passes/strip_hidden.rs
@@ -41,7 +41,7 @@ fn fold_item(&mut self, i: Item) -> Option<Item> {
         if i.attrs.lists(sym::doc).has_word(sym::hidden) {
             debug!("strip_hidden: stripping {:?} {:?}", i.type_(), i.name);
             // use a dedicated hidden item for given item type if any
-            match i.inner {
+            match i.kind {
                 clean::StructFieldItem(..) | clean::ModuleItem(..) => {
                     // We need to recurse into stripped modules to
                     // strip things like impl methods but when doing so

diff --git a/src/librustdoc/passes/stripper.rs b/src/librustdoc/passes/stripper.rs
index 9b4f62235f5e8c3457e12a31f62f76077409c936..4250c2b48fc5017c7c88d39a857688d1da0abecb 100644 (file)
--- a/src/librustdoc/passes/stripper.rs
+++ b/src/librustdoc/passes/stripper.rs
@@ -13,7 +13,7 @@ pub struct Stripper<'a> {
 
 impl<'a> DocFolder for Stripper<'a> {
     fn fold_item(&mut self, i: Item) -> Option<Item> {
-        match i.inner {
+        match i.kind {
             clean::StrippedItem(..) => {
                 // We need to recurse into stripped modules to strip things
                 // like impl methods but when doing so we must not add any
@@ -86,7 +86,7 @@ fn fold_item(&mut self, i: Item) -> Option<Item> {
             clean::KeywordItem(..) => {}
         }
 
-        let fastreturn = match i.inner {
+        let fastreturn = match i.kind {
             // nothing left to do for traits (don't want to filter their
             // methods out, visibility controlled by the trait)
             clean::TraitItem(..) => true,
@@ -123,7 +123,7 @@ pub struct ImplStripper<'a> {
 
 impl<'a> DocFolder for ImplStripper<'a> {
     fn fold_item(&mut self, i: Item) -> Option<Item> {
-        if let clean::ImplItem(ref imp) = i.inner {
+        if let clean::ImplItem(ref imp) = i.kind {
             // emptied none trait impls can be stripped
             if imp.trait_.is_none() && imp.items.is_empty() {
                 return None;
@@ -162,7 +162,7 @@ fn fold_item(&mut self, i: Item) -> Option<Item> {
 
 impl DocFolder for ImportStripper {
     fn fold_item(&mut self, i: Item) -> Option<Item> {
-        match i.inner {
+        match i.kind {
             clean::ExternCrateItem(..) | clean::ImportItem(..) if i.visibility != clean::Public => {
                 None
             }