rustdoc: Rename expect_real to expect_def_id, remove Item::is_fake

Stupremee · Stupremee · commit acd4dc2d0ca8 · 2021-07-05T19:49:48.000+02:00
diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs
@@ -66,20 +66,22 @@ impl ItemId {
     #[inline]
     crate fn is_local(self) -> bool {
         match self {
-            ItemId::DefId(id) => id.is_local(),
-            _ => false,
+            ItemId::Auto { for_: id, .. }
+            | ItemId::Blanket { for_: id, .. }
+            | ItemId::DefId(id) => id.is_local(),
+            ItemId::Primitive(krate) => krate == LOCAL_CRATE,
         }
     }
 
     #[inline]
     #[track_caller]
-    crate fn expect_real(self) -> rustc_hir::def_id::DefId {
-        self.as_real()
-            .unwrap_or_else(|| panic!("ItemId::expect_real: `{:?}` isn't a real ItemId", self))
+    crate fn expect_def_id(self) -> DefId {
+        self.as_def_id()
+            .unwrap_or_else(|| panic!("ItemId::expect_def_id: `{:?}` isn't a DefId", self))
     }
 
     #[inline]
-    crate fn as_real(self) -> Option<DefId> {
+    crate fn as_def_id(self) -> Option<DefId> {
         match self {
             ItemId::DefId(id) => Some(id),
             _ => None,
@@ -89,9 +91,9 @@ impl ItemId {
     #[inline]
     crate fn krate(self) -> CrateNum {
         match self {
-            ItemId::DefId(id) => id.krate,
-            ItemId::Auto { trait_, .. } => trait_.krate,
-            ItemId::Blanket { trait_, .. } => trait_.krate,
+            ItemId::Auto { for_: id, .. }
+            | ItemId::Blanket { for_: id, .. }
+            | ItemId::DefId(id) => id.krate,
             ItemId::Primitive(krate) => krate,
         }
     }
@@ -100,9 +102,7 @@ impl ItemId {
     crate fn index(self) -> Option<DefIndex> {
         match self {
             ItemId::DefId(id) => Some(id.index),
-            ItemId::Auto { trait_, .. } => Some(trait_.index),
-            ItemId::Blanket { trait_, .. } => Some(trait_.index),
-            ItemId::Primitive(..) => None,
+            _ => None,
         }
     }
 }
@@ -354,19 +354,19 @@ crate fn rustc_span(def_id: DefId, tcx: TyCtxt<'_>) -> Span {
 
 impl Item {
     crate fn stability<'tcx>(&self, tcx: TyCtxt<'tcx>) -> Option<&'tcx Stability> {
-        if self.is_fake() { None } else { tcx.lookup_stability(self.def_id.expect_real()) }
+        self.def_id.as_def_id().and_then(|did| tcx.lookup_stability(did))
     }
 
     crate fn const_stability<'tcx>(&self, tcx: TyCtxt<'tcx>) -> Option<&'tcx ConstStability> {
-        if self.is_fake() { None } else { tcx.lookup_const_stability(self.def_id.expect_real()) }
+        self.def_id.as_def_id().and_then(|did| tcx.lookup_const_stability(did))
     }
 
     crate fn deprecation(&self, tcx: TyCtxt<'_>) -> Option<Deprecation> {
-        if self.is_fake() { None } else { tcx.lookup_deprecation(self.def_id.expect_real()) }
+        self.def_id.as_def_id().and_then(|did| tcx.lookup_deprecation(did))
     }
 
     crate fn inner_docs(&self, tcx: TyCtxt<'_>) -> bool {
-        if self.is_fake() { false } else { tcx.get_attrs(self.def_id.expect_real()).inner_docs() }
+        self.def_id.as_def_id().map(|did| tcx.get_attrs(did).inner_docs()).unwrap_or(false)
     }
 
     crate fn span(&self, tcx: TyCtxt<'_>) -> Span {
@@ -378,10 +378,8 @@ impl Item {
             kind
         {
             *span
-        } else if self.is_fake() {
-            Span::dummy()
         } else {
-            rustc_span(self.def_id.expect_real(), tcx)
+            self.def_id.as_def_id().map(|did| rustc_span(did, tcx)).unwrap_or_else(|| Span::dummy())
         }
     }
 
@@ -546,7 +544,7 @@ impl Item {
     }
 
     crate fn is_crate(&self) -> bool {
-        self.is_mod() && self.def_id.as_real().map_or(false, |did| did.index == CRATE_DEF_INDEX)
+        self.is_mod() && self.def_id.as_def_id().map_or(false, |did| did.index == CRATE_DEF_INDEX)
     }
     crate fn is_mod(&self) -> bool {
         self.type_() == ItemType::Module
@@ -657,11 +655,6 @@ impl Item {
             _ => false,
         }
     }
-
-    crate fn is_fake(&self) -> bool {
-        // FIXME: Find a better way to handle this
-        !matches!(self.def_id, ItemId::DefId(..))
-    }
 }
 
 #[derive(Clone, Debug)]
diff --git a/src/librustdoc/formats/cache.rs b/src/librustdoc/formats/cache.rs
@@ -215,7 +215,7 @@ impl<'a, 'tcx> DocFolder for CacheBuilder<'a, 'tcx> {
         // Propagate a trait method's documentation to all implementors of the
         // trait.
         if let clean::TraitItem(ref t) = *item.kind {
-            self.cache.traits.entry(item.def_id.expect_real()).or_insert_with(|| {
+            self.cache.traits.entry(item.def_id.expect_def_id()).or_insert_with(|| {
                 clean::TraitWithExtraInfo {
                     trait_: t.clone(),
                     is_notable: item.attrs.has_doc_flag(sym::notable_trait),
@@ -348,11 +348,11 @@ impl<'a, 'tcx> DocFolder for CacheBuilder<'a, 'tcx> {
                     // `public_items` map, so we can skip inserting into the
                     // paths map if there was already an entry present and we're
                     // not a public item.
-                    if !self.cache.paths.contains_key(&item.def_id.expect_real())
-                        || self.cache.access_levels.is_public(item.def_id.expect_real())
+                    if !self.cache.paths.contains_key(&item.def_id.expect_def_id())
+                        || self.cache.access_levels.is_public(item.def_id.expect_def_id())
                     {
                         self.cache.paths.insert(
-                            item.def_id.expect_real(),
+                            item.def_id.expect_def_id(),
                             (self.cache.stack.clone(), item.type_()),
                         );
                     }
@@ -361,7 +361,7 @@ impl<'a, 'tcx> DocFolder for CacheBuilder<'a, 'tcx> {
             clean::PrimitiveItem(..) => {
                 self.cache
                     .paths
-                    .insert(item.def_id.expect_real(), (self.cache.stack.clone(), item.type_()));
+                    .insert(item.def_id.expect_def_id(), (self.cache.stack.clone(), item.type_()));
             }
 
             clean::ExternCrateItem { .. }
@@ -391,7 +391,7 @@ impl<'a, 'tcx> DocFolder for CacheBuilder<'a, 'tcx> {
             | clean::StructItem(..)
             | clean::UnionItem(..)
             | clean::VariantItem(..) => {
-                self.cache.parent_stack.push(item.def_id.expect_real());
+                self.cache.parent_stack.push(item.def_id.expect_def_id());
                 self.cache.parent_is_trait_impl = false;
                 true
             }
diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs
@@ -1191,7 +1191,7 @@ impl clean::Visibility {
                 // FIXME(camelid): This may not work correctly if `item_did` is a module.
                 //                 However, rustdoc currently never displays a module's
                 //                 visibility, so it shouldn't matter.
-                let parent_module = find_nearest_parent_module(cx.tcx(), item_did.expect_real());
+                let parent_module = find_nearest_parent_module(cx.tcx(), item_did.expect_def_id());
 
                 if vis_did.index == CRATE_DEF_INDEX {
                     "pub(crate) ".to_owned()
diff --git a/src/librustdoc/html/render/context.rs b/src/librustdoc/html/render/context.rs
@@ -230,7 +230,7 @@ impl<'tcx> Context<'tcx> {
                 &self.shared.style_files,
             )
         } else {
-            if let Some(&(ref names, ty)) = self.cache.paths.get(&it.def_id.expect_real()) {
+            if let Some(&(ref names, ty)) = self.cache.paths.get(&it.def_id.expect_def_id()) {
                 let mut path = String::new();
                 for name in &names[..names.len() - 1] {
                     path.push_str(name);
diff --git a/src/librustdoc/html/render/mod.rs b/src/librustdoc/html/render/mod.rs
@@ -735,7 +735,7 @@ fn naive_assoc_href(it: &clean::Item, link: AssocItemLink<'_>, cx: &Context<'_>)
         AssocItemLink::Anchor(Some(ref id)) => format!("#{}", id),
         AssocItemLink::Anchor(None) => anchor,
         AssocItemLink::GotoSource(did, _) => {
-            href(did.expect_real(), cx).map(|p| format!("{}{}", p.0, anchor)).unwrap_or(anchor)
+            href(did.expect_def_id(), cx).map(|p| format!("{}{}", p.0, anchor)).unwrap_or(anchor)
         }
     }
 }
@@ -867,7 +867,7 @@ fn render_assoc_item(
                     ItemType::TyMethod
                 };
 
-                href(did.expect_real(), cx)
+                href(did.expect_def_id(), cx)
                     .map(|p| format!("{}#{}.{}", p.0, ty, name))
                     .unwrap_or_else(|| format!("#{}.{}", ty, name))
             }
@@ -1819,7 +1819,7 @@ fn small_url_encode(s: String) -> String {
 }
 
 fn sidebar_assoc_items(cx: &Context<'_>, out: &mut Buffer, it: &clean::Item) {
-    let did = it.def_id.expect_real();
+    let did = it.def_id.expect_def_id();
     if let Some(v) = cx.cache.impls.get(&did) {
         let mut used_links = FxHashSet::default();
         let cache = cx.cache();
@@ -2109,7 +2109,7 @@ fn sidebar_trait(cx: &Context<'_>, buf: &mut Buffer, it: &clean::Item, t: &clean
         "</div>",
     );
 
-    if let Some(implementors) = cx.cache.implementors.get(&it.def_id.expect_real()) {
+    if let Some(implementors) = cx.cache.implementors.get(&it.def_id.expect_def_id()) {
         let cache = cx.cache();
         let mut res = implementors
             .iter()
diff --git a/src/librustdoc/html/render/print_item.rs b/src/librustdoc/html/render/print_item.rs
@@ -289,15 +289,15 @@ fn item_module(w: &mut Buffer, cx: &Context<'_>, item: &clean::Item, items: &[cl
                         w,
                         "<div class=\"item-left\"><code>{}extern crate {} as {};",
                         myitem.visibility.print_with_space(myitem.def_id, cx),
-                        anchor(myitem.def_id.expect_real(), &*src.as_str(), cx),
+                        anchor(myitem.def_id.expect_def_id(), &*src.as_str(), cx),
                         myitem.name.as_ref().unwrap(),
                     ),
                     None => write!(
                         w,
                         "<div class=\"item-left\"><code>{}extern crate {};",
                         myitem.visibility.print_with_space(myitem.def_id, cx),
                         anchor(
-                            myitem.def_id.expect_real(),
+                            myitem.def_id.expect_def_id(),
                             &*myitem.name.as_ref().unwrap().as_str(),
                             cx
                         ),
@@ -669,9 +669,9 @@ fn item_trait(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, t: &clean::Tra
     }
 
     // If there are methods directly on this trait object, render them here.
-    render_assoc_items(w, cx, it, it.def_id.expect_real(), AssocItemRender::All);
+    render_assoc_items(w, cx, it, it.def_id.expect_def_id(), AssocItemRender::All);
 
-    if let Some(implementors) = cx.cache.implementors.get(&it.def_id.expect_real()) {
+    if let Some(implementors) = cx.cache.implementors.get(&it.def_id.expect_def_id()) {
         // The DefId is for the first Type found with that name. The bool is
         // if any Types with the same name but different DefId have been found.
         let mut implementor_dups: FxHashMap<Symbol, (DefId, bool)> = FxHashMap::default();
@@ -787,7 +787,7 @@ fn item_trait(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, t: &clean::Tra
         path = if it.def_id.is_local() {
             cx.current.join("/")
         } else {
-            let (ref path, _) = cx.cache.external_paths[&it.def_id.expect_real()];
+            let (ref path, _) = cx.cache.external_paths[&it.def_id.expect_def_id()];
             path[..path.len() - 1].join("/")
         },
         ty = it.type_(),
@@ -813,7 +813,7 @@ fn item_trait_alias(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, t: &clea
     // won't be visible anywhere in the docs. It would be nice to also show
     // associated items from the aliased type (see discussion in #32077), but
     // we need #14072 to make sense of the generics.
-    render_assoc_items(w, cx, it, it.def_id.expect_real(), AssocItemRender::All)
+    render_assoc_items(w, cx, it, it.def_id.expect_def_id(), AssocItemRender::All)
 }
 
 fn item_opaque_ty(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, t: &clean::OpaqueTy) {
@@ -834,7 +834,7 @@ fn item_opaque_ty(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, t: &clean:
     // won't be visible anywhere in the docs. It would be nice to also show
     // associated items from the aliased type (see discussion in #32077), but
     // we need #14072 to make sense of the generics.
-    render_assoc_items(w, cx, it, it.def_id.expect_real(), AssocItemRender::All)
+    render_assoc_items(w, cx, it, it.def_id.expect_def_id(), AssocItemRender::All)
 }
 
 fn item_typedef(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, t: &clean::Typedef) {
@@ -851,7 +851,7 @@ fn item_typedef(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, t: &clean::T
 
     document(w, cx, it, None);
 
-    let def_id = it.def_id.expect_real();
+    let def_id = it.def_id.expect_def_id();
     // Render any items associated directly to this alias, as otherwise they
     // won't be visible anywhere in the docs. It would be nice to also show
     // associated items from the aliased type (see discussion in #32077), but
@@ -903,7 +903,7 @@ fn item_union(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, s: &clean::Uni
             document(w, cx, field, Some(it));
         }
     }
-    let def_id = it.def_id.expect_real();
+    let def_id = it.def_id.expect_def_id();
     render_assoc_items(w, cx, it, def_id, AssocItemRender::All);
     document_type_layout(w, cx, def_id);
 }
@@ -1041,7 +1041,7 @@ fn item_enum(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, e: &clean::Enum
             }
         }
     }
-    let def_id = it.def_id.expect_real();
+    let def_id = it.def_id.expect_def_id();
     render_assoc_items(w, cx, it, def_id, AssocItemRender::All);
     document_type_layout(w, cx, def_id);
 }
@@ -1093,7 +1093,7 @@ fn item_proc_macro(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, m: &clean
 
 fn item_primitive(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item) {
     document(w, cx, it, None);
-    render_assoc_items(w, cx, it, it.def_id.expect_real(), AssocItemRender::All)
+    render_assoc_items(w, cx, it, it.def_id.expect_def_id(), AssocItemRender::All)
 }
 
 fn item_constant(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, c: &clean::Constant) {
@@ -1182,7 +1182,7 @@ fn item_struct(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, s: &clean::St
             }
         }
     }
-    let def_id = it.def_id.expect_real();
+    let def_id = it.def_id.expect_def_id();
     render_assoc_items(w, cx, it, def_id, AssocItemRender::All);
     document_type_layout(w, cx, def_id);
 }
@@ -1213,7 +1213,7 @@ fn item_foreign_type(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item) {
 
     document(w, cx, it, None);
 
-    render_assoc_items(w, cx, it, it.def_id.expect_real(), AssocItemRender::All)
+    render_assoc_items(w, cx, it, it.def_id.expect_def_id(), AssocItemRender::All)
 }
 
 fn item_keyword(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item) {
diff --git a/src/librustdoc/json/mod.rs b/src/librustdoc/json/mod.rs
@@ -164,11 +164,11 @@ impl<'tcx> FormatRenderer<'tcx> for JsonRenderer<'tcx> {
         let id = item.def_id;
         if let Some(mut new_item) = self.convert_item(item) {
             if let types::ItemEnum::Trait(ref mut t) = new_item.inner {
-                t.implementors = self.get_trait_implementors(id.expect_real())
+                t.implementors = self.get_trait_implementors(id.expect_def_id())
             } else if let types::ItemEnum::Struct(ref mut s) = new_item.inner {
-                s.impls = self.get_impls(id.expect_real())
+                s.impls = self.get_impls(id.expect_def_id())
             } else if let types::ItemEnum::Enum(ref mut e) = new_item.inner {
-                e.impls = self.get_impls(id.expect_real())
+                e.impls = self.get_impls(id.expect_def_id())
             }
             let removed = self.index.borrow_mut().insert(from_item_id(id), new_item.clone());
 
diff --git a/src/librustdoc/passes/calculate_doc_coverage.rs b/src/librustdoc/passes/calculate_doc_coverage.rs
@@ -213,13 +213,13 @@ impl<'a, 'b> fold::DocFolder for CoverageCalculator<'a, 'b> {
 
                 let filename = i.span(self.ctx.tcx).filename(self.ctx.sess());
                 let has_doc_example = tests.found_tests != 0;
-                // The `expect_real()` should be okay because `local_def_id_to_hir_id`
+                // The `expect_def_id()` should be okay because `local_def_id_to_hir_id`
                 // would presumably panic if a fake `DefIndex` were passed.
                 let hir_id = self
                     .ctx
                     .tcx
                     .hir()
-                    .local_def_id_to_hir_id(i.def_id.expect_real().expect_local());
+                    .local_def_id_to_hir_id(i.def_id.expect_def_id().expect_local());
                 let (level, source) = self.ctx.tcx.lint_level_at_node(MISSING_DOCS, hir_id);
                 // `missing_docs` is allow-by-default, so don't treat this as ignoring the item
                 // unless the user had an explicit `allow`
diff --git a/src/librustdoc/passes/check_code_block_syntax.rs b/src/librustdoc/passes/check_code_block_syntax.rs
@@ -53,7 +53,7 @@ impl<'a, 'tcx> SyntaxChecker<'a, 'tcx> {
             return;
         }
 
-        let local_id = match item.def_id.as_real().and_then(|x| x.as_local()) {
+        let local_id = match item.def_id.as_def_id().and_then(|x| x.as_local()) {
             Some(id) => id,
             // We don't need to check the syntax for other crates so returning
             // without doing anything should not be a problem.
@@ -137,7 +137,7 @@ impl<'a, 'tcx> DocFolder for SyntaxChecker<'a, 'tcx> {
             let sp = item.attr_span(self.cx.tcx);
             let extra = crate::html::markdown::ExtraInfo::new_did(
                 self.cx.tcx,
-                item.def_id.expect_real(),
+                item.def_id.expect_def_id(),
                 sp,
             );
             for code_block in markdown::rust_code_blocks(&dox, &extra) {
diff --git a/src/librustdoc/passes/collect_intra_doc_links.rs b/src/librustdoc/passes/collect_intra_doc_links.rs
diff --git a/src/librustdoc/passes/collect_trait_impls.rs b/src/librustdoc/passes/collect_trait_impls.rs
diff --git a/src/librustdoc/passes/doc_test_lints.rs b/src/librustdoc/passes/doc_test_lints.rs
diff --git a/src/librustdoc/passes/stripper.rs b/src/librustdoc/passes/stripper.rs

Original file line number	Diff line number	Diff line change
`@@ -66,20 +66,22 @@ impl ItemId {`
`66`	`66`	`#[inline]`
`67`	`67`	`crate fn is_local(self) -> bool {`
`68`	`68`	`match self {`
`69`		`- ItemId::DefId(id) => id.is_local(),`
`70`		`- _ => false,`
	`69`	`+ ItemId::Auto { for_: id, .. }`
	`70`	`+ \| ItemId::Blanket { for_: id, .. }`
	`71`	`+ \| ItemId::DefId(id) => id.is_local(),`
	`72`	`+ ItemId::Primitive(krate) => krate == LOCAL_CRATE,`
`71`	`73`	`}`
`72`	`74`	`}`
`73`	`75`
`74`	`76`	`#[inline]`
`75`	`77`	`#[track_caller]`
`76`		`- crate fn expect_real(self) -> rustc_hir::def_id::DefId {`
`77`		`- self.as_real()`
`78`		- .unwrap_or_else(\|\| panic!("ItemId::expect_real: `{:?}` isn't a real ItemId", self))
	`78`	`+ crate fn expect_def_id(self) -> DefId {`
	`79`	`+ self.as_def_id()`
	`80`	+ .unwrap_or_else(\|\| panic!("ItemId::expect_def_id: `{:?}` isn't a DefId", self))
`79`	`81`	`}`
`80`	`82`
`81`	`83`	`#[inline]`
`82`		`- crate fn as_real(self) -> Option<DefId> {`
	`84`	`+ crate fn as_def_id(self) -> Option<DefId> {`
`83`	`85`	`match self {`
`84`	`86`	`ItemId::DefId(id) => Some(id),`
`85`	`87`	`_ => None,`
`@@ -89,9 +91,9 @@ impl ItemId {`
`89`	`91`	`#[inline]`
`90`	`92`	`crate fn krate(self) -> CrateNum {`
`91`	`93`	`match self {`
`92`		`- ItemId::DefId(id) => id.krate,`
`93`		`- ItemId::Auto { trait_, .. } => trait_.krate,`
`94`		`- ItemId::Blanket { trait_, .. } => trait_.krate,`
	`94`	`+ ItemId::Auto { for_: id, .. }`
	`95`	`+ \| ItemId::Blanket { for_: id, .. }`
	`96`	`+ \| ItemId::DefId(id) => id.krate,`
`95`	`97`	`ItemId::Primitive(krate) => krate,`
`96`	`98`	`}`
`97`	`99`	`}`
`@@ -100,9 +102,7 @@ impl ItemId {`
`100`	`102`	`crate fn index(self) -> Option<DefIndex> {`
`101`	`103`	`match self {`
`102`	`104`	`ItemId::DefId(id) => Some(id.index),`
`103`		`- ItemId::Auto { trait_, .. } => Some(trait_.index),`
`104`		`- ItemId::Blanket { trait_, .. } => Some(trait_.index),`
`105`		`- ItemId::Primitive(..) => None,`
	`105`	`+ _ => None,`
`106`	`106`	`}`
`107`	`107`	`}`
`108`	`108`	`}`
`@@ -354,19 +354,19 @@ crate fn rustc_span(def_id: DefId, tcx: TyCtxt<'_>) -> Span {`
`354`	`354`
`355`	`355`	`impl Item {`
`356`	`356`	`crate fn stability<'tcx>(&self, tcx: TyCtxt<'tcx>) -> Option<&'tcx Stability> {`
`357`		`- if self.is_fake() { None } else { tcx.lookup_stability(self.def_id.expect_real()) }`
	`357`	`+ self.def_id.as_def_id().and_then(\|did\| tcx.lookup_stability(did))`
`358`	`358`	`}`
`359`	`359`
`360`	`360`	`crate fn const_stability<'tcx>(&self, tcx: TyCtxt<'tcx>) -> Option<&'tcx ConstStability> {`
`361`		`- if self.is_fake() { None } else { tcx.lookup_const_stability(self.def_id.expect_real()) }`
	`361`	`+ self.def_id.as_def_id().and_then(\|did\| tcx.lookup_const_stability(did))`
`362`	`362`	`}`
`363`	`363`
`364`	`364`	`crate fn deprecation(&self, tcx: TyCtxt<'_>) -> Option<Deprecation> {`
`365`		`- if self.is_fake() { None } else { tcx.lookup_deprecation(self.def_id.expect_real()) }`
	`365`	`+ self.def_id.as_def_id().and_then(\|did\| tcx.lookup_deprecation(did))`
`366`	`366`	`}`
`367`	`367`
`368`	`368`	`crate fn inner_docs(&self, tcx: TyCtxt<'_>) -> bool {`
`369`		`- if self.is_fake() { false } else { tcx.get_attrs(self.def_id.expect_real()).inner_docs() }`
	`369`	`+ self.def_id.as_def_id().map(\|did\| tcx.get_attrs(did).inner_docs()).unwrap_or(false)`
`370`	`370`	`}`
`371`	`371`
`372`	`372`	`crate fn span(&self, tcx: TyCtxt<'_>) -> Span {`
`@@ -378,10 +378,8 @@ impl Item {`
`378`	`378`	`kind`
`379`	`379`	`{`
`380`	`380`	`*span`
`381`		`- } else if self.is_fake() {`
`382`		`- Span::dummy()`
`383`	`381`	`} else {`
`384`		`- rustc_span(self.def_id.expect_real(), tcx)`
	`382`	`+ self.def_id.as_def_id().map(\|did\| rustc_span(did, tcx)).unwrap_or_else(\|\| Span::dummy())`
`385`	`383`	`}`
`386`	`384`	`}`
`387`	`385`
`@@ -546,7 +544,7 @@ impl Item {`
`546`	`544`	`}`
`547`	`545`
`548`	`546`	`crate fn is_crate(&self) -> bool {`
`549`		`- self.is_mod() && self.def_id.as_real().map_or(false, \|did\| did.index == CRATE_DEF_INDEX)`
	`547`	`+ self.is_mod() && self.def_id.as_def_id().map_or(false, \|did\| did.index == CRATE_DEF_INDEX)`
`550`	`548`	`}`
`551`	`549`	`crate fn is_mod(&self) -> bool {`
`552`	`550`	`self.type_() == ItemType::Module`
`@@ -657,11 +655,6 @@ impl Item {`
`657`	`655`	`_ => false,`
`658`	`656`	`}`
`659`	`657`	`}`
`660`		`-`
`661`		`- crate fn is_fake(&self) -> bool {`
`662`		`- // FIXME: Find a better way to handle this`
`663`		`- !matches!(self.def_id, ItemId::DefId(..))`
`664`		`- }`
`665`	`658`	`}`
`666`	`659`
`667`	`660`	`#[derive(Clone, Debug)]`
Original file line number	Diff line number	Diff line change
`@@ -230,7 +230,7 @@ impl<'tcx> Context<'tcx> {`
`230`	`230`	`&self.shared.style_files,`
`231`	`231`	`)`
`232`	`232`	`} else {`
`233`		`- if let Some(&(ref names, ty)) = self.cache.paths.get(&it.def_id.expect_real()) {`
	`233`	`+ if let Some(&(ref names, ty)) = self.cache.paths.get(&it.def_id.expect_def_id()) {`
`234`	`234`	`let mut path = String::new();`
`235`	`235`	`for name in &names[..names.len() - 1] {`
`236`	`236`	`path.push_str(name);`