Replace all uses of path.res.def_id() with path.def_id()

Author: camelid

src/librustdoc/clean/auto_trait.rs

@@ -691,7 +691,7 @@ impl<'a, 'tcx> AutoTraitFinder<'a, 'tcx> {
 
     fn is_fn_trait(&self, path: &Path) -> bool {
         let tcx = self.cx.tcx;
-        let did = path.res.def_id();
+        let did = path.def_id();
         did == tcx.require_lang_item(LangItem::Fn, None)
             || did == tcx.require_lang_item(LangItem::FnMut, None)
             || did == tcx.require_lang_item(LangItem::FnOnce, None)

src/librustdoc/clean/inline.rs

@@ -454,7 +454,7 @@ crate fn build_impl(
     // Return if the trait itself or any types of the generic parameters are doc(hidden).
     let mut stack: Vec<&Type> = vec![&for_];
 
-    if let Some(did) = trait_.as_ref().map(|t| t.res.def_id()) {
+    if let Some(did) = trait_.as_ref().map(|t| t.def_id()) {
         if tcx.get_attrs(did).lists(sym::doc).has_word(sym::hidden) {
             return;
         }
@@ -474,7 +474,7 @@ crate fn build_impl(
         }
     }
 
-    if let Some(did) = trait_.as_ref().map(|t| t.res.def_id()) {
+    if let Some(did) = trait_.as_ref().map(|t| t.def_id()) {
         record_extern_trait(cx, did);
     }
 
@@ -628,7 +628,7 @@ fn filter_non_trait_generics(trait_did: DefId, mut g: clean::Generics) -> clean:
             } if *s == kw::SelfUpper => {
                 bounds.retain(|bound| match bound {
                     clean::GenericBound::TraitBound(clean::PolyTrait { trait_, .. }, _) => {
-                        trait_.res.def_id() != trait_did
+                        trait_.def_id() != trait_did
                     }
                     _ => true,
                 });
@@ -642,7 +642,7 @@ fn filter_non_trait_generics(trait_did: DefId, mut g: clean::Generics) -> clean:
             ty: clean::QPath { self_type: box clean::Generic(ref s), trait_, name: _, .. },
             bounds,
             ..
-        } => !(bounds.is_empty() || *s == kw::SelfUpper && trait_.res.def_id() == trait_did),
+        } => !(bounds.is_empty() || *s == kw::SelfUpper && trait_.def_id() == trait_did),
         _ => true,
     });
     g

src/librustdoc/clean/mod.rs

@@ -1100,7 +1100,7 @@ impl Clean<Item> for ty::AssocItem {
                             if *name != my_name {
                                 return None;
                             }
-                            if trait_.res.def_id() != self.container.id() {
+                            if trait_.def_id() != self.container.id() {
                                 return None;
                             }
                             match **self_type {

src/librustdoc/clean/simplify.rs

@@ -102,7 +102,7 @@ crate fn merge_bounds(
         // If this QPath's trait `trait_did` is the same as, or a supertrait
         // of, the bound's trait `did` then we can keep going, otherwise
         // this is just a plain old equality bound.
-        if !trait_is_same_or_supertrait(cx, trait_ref.trait_.res.def_id(), trait_did) {
+        if !trait_is_same_or_supertrait(cx, trait_ref.trait_.def_id(), trait_did) {
             return false;
         }
         let last = trait_ref.trait_.segments.last_mut().expect("segments were empty");

src/librustdoc/clean/types.rs

@@ -1499,13 +1499,13 @@ impl Type {
             QPath { self_type, trait_, name, .. } => (self_type, trait_, name),
             _ => return None,
         };
-        Some((&self_, trait_.res.def_id(), *name))
+        Some((&self_, trait_.def_id(), *name))
     }
 
     fn inner_def_id(&self, cache: Option<&Cache>) -> Option<DefId> {
         let t: PrimitiveType = match *self {
             ResolvedPath { did, .. } => return Some(did),
-            DynTrait(ref bounds, _) => return Some(bounds[0].trait_.res.def_id()),
+            DynTrait(ref bounds, _) => return Some(bounds[0].trait_.def_id()),
             Primitive(p) => return cache.and_then(|c| c.primitive_locations.get(&p).cloned()),
             BorrowedRef { type_: box Generic(..), .. } => PrimitiveType::Reference,
             BorrowedRef { ref type_, .. } => return type_.inner_def_id(cache),

src/librustdoc/html/format.rs

@@ -914,7 +914,7 @@ fn fmt_type<'cx>(
         clean::QPath { ref name, ref self_type, ref trait_, ref self_def_id } => {
             let should_show_cast = !trait_.segments.is_empty()
                 && self_def_id
-                    .zip(Some(trait_.res.def_id()))
+                    .zip(Some(trait_.def_id()))
                     .map_or(!self_type.is_self_type(), |(id, trait_)| id != trait_);
             if f.alternate() {
                 if should_show_cast {
@@ -939,7 +939,7 @@ fn fmt_type<'cx>(
             //        the ugliness comes from inlining across crates where
             //        everything comes in as a fully resolved QPath (hard to
             //        look at).
-            match href(trait_.res.def_id(), cx) {
+            match href(trait_.def_id(), cx) {
                 Ok((ref url, _, ref path)) if !f.alternate() => {
                     write!(
                         f,
@@ -972,7 +972,7 @@ impl clean::Path {
         &'a self,
         cx: &'a Context<'tcx>,
     ) -> impl fmt::Display + 'b + Captures<'tcx> {
-        display_fn(move |f| resolved_path(f, self.res.def_id(), self, false, false, cx))
+        display_fn(move |f| resolved_path(f, self.def_id(), self, false, false, cx))
     }
 }
 

src/librustdoc/html/render/cache.rs

@@ -322,7 +322,7 @@ crate fn get_real_types<'tcx>(
         if let Some(bound) = generics.params.iter().find(|g| g.is_type() && g.name == arg_s) {
             for bound in bound.get_bounds().unwrap_or(&[]) {
                 if let Some(path) = bound.get_trait_path() {
-                    let ty = Type::ResolvedPath { did: path.res.def_id(), path };
+                    let ty = Type::ResolvedPath { did: path.def_id(), path };
                     let adds = get_real_types(generics, &ty, tcx, recurse + 1, res);
                     nb_added += adds;
                     if adds == 0 && !ty.is_full_generic() {

src/librustdoc/html/render/mod.rs

@@ -2389,7 +2389,7 @@ fn collect_paths_for_type(first_ty: clean::Type, cache: &Cache) -> Vec<String> {
             }
             clean::Type::QPath { self_type, trait_, .. } => {
                 work.push_back(*self_type);
-                process_path(trait_.res.def_id());
+                process_path(trait_.def_id());
             }
             _ => {}
         }

src/librustdoc/json/conversions.rs

@@ -365,7 +365,7 @@ impl FromWithTcx<clean::GenericBound> for GenericBound {
             TraitBound(clean::PolyTrait { trait_, generic_params }, modifier) => {
                 // FIXME: should `trait_` be a clean::Path equivalent in JSON?
                 let trait_ =
-                    clean::ResolvedPath { did: trait_.res.def_id(), path: trait_ }.into_tcx(tcx);
+                    clean::ResolvedPath { did: trait_.def_id(), path: trait_ }.into_tcx(tcx);
                 GenericBound::TraitBound {
                     trait_,
                     generic_params: generic_params.into_iter().map(|x| x.into_tcx(tcx)).collect(),
@@ -401,7 +401,7 @@ impl FromWithTcx<clean::Type> for Type {
 
                 Type::ResolvedPath {
                     name: first_trait.whole_name(),
-                    id: from_item_id(first_trait.res.def_id().into()),
+                    id: from_item_id(first_trait.def_id().into()),
                     args: first_trait
                         .segments
                         .last()
@@ -436,7 +436,7 @@ impl FromWithTcx<clean::Type> for Type {
             },
             QPath { name, self_type, trait_, .. } => {
                 // FIXME: should `trait_` be a clean::Path equivalent in JSON?
-                let trait_ = ResolvedPath { did: trait_.res.def_id(), path: trait_ }.into_tcx(tcx);
+                let trait_ = ResolvedPath { did: trait_.def_id(), path: trait_ }.into_tcx(tcx);
                 Type::QualifiedPath {
                     name: name.to_string(),
                     self_type: Box::new((*self_type).into_tcx(tcx)),
@@ -513,7 +513,7 @@ impl FromWithTcx<clean::Impl> for Impl {
         } = impl_;
         // FIXME: should `trait_` be a clean::Path equivalent in JSON?
         let trait_ = trait_.map(|path| {
-            let did = path.res.def_id();
+            let did = path.def_id();
             clean::ResolvedPath { path, did }.into_tcx(tcx)
         });
         Impl {

src/librustdoc/passes/collect_trait_impls.rs

@@ -82,7 +82,7 @@ crate fn collect_trait_impls(krate: Crate, cx: &mut DocContext<'_>) -> Crate {
             cleaner.keep_impl(for_)
                 || trait_
                     .as_ref()
-                    .map_or(false, |t| cleaner.keep_impl_with_def_id(t.res.def_id().into()))
+                    .map_or(false, |t| cleaner.keep_impl_with_def_id(t.def_id().into()))
                 || blanket_impl.is_some()
         } else {
             true