diff --git a/src/librustdoc/clean/auto_trait.rs b/src/librustdoc/clean/auto_trait.rs
index f375af4837f75910ad3d12a0d33b24aa9b2f4ff6..e771714ed61191c3072ca42e953afd7c2e760b2d 100644
--- a/src/librustdoc/clean/auto_trait.rs
+++ b/src/librustdoc/clean/auto_trait.rs
@@ -691,7 +691,7 @@ fn unstable_debug_sort<T: Debug>(&self, vec: &mut Vec<T>) {
 
     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)
diff --git a/src/librustdoc/clean/inline.rs b/src/librustdoc/clean/inline.rs
index 5fb3a98ca5b87c9127e6fdeaa0a87c728d958606..ebf61fd104843992e273e2de529790d3f7f5e916 100644
--- a/src/librustdoc/clean/inline.rs
+++ b/src/librustdoc/clean/inline.rs
@@ -454,7 +454,7 @@ fn merge_attrs(
     // 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 @@ fn merge_attrs(
         }
     }
 
-    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
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
index c52953573ac6517ed7dc5cc73130af6570d42d12..9451664674b59958e7784be126d95d81fe8701ac 100644
--- a/src/librustdoc/clean/mod.rs
+++ b/src/librustdoc/clean/mod.rs
@@ -1100,7 +1100,7 @@ fn clean(&self, cx: &mut DocContext<'_>) -> Item {
                             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 {
diff --git a/src/librustdoc/clean/simplify.rs b/src/librustdoc/clean/simplify.rs
index 101fdd465b70d26adc7ba4fbe73d40c9b98d493b..4c81e75e8d6304b49b8055d90f75fcb0a7c98c4a 100644
--- a/src/librustdoc/clean/simplify.rs
+++ b/src/librustdoc/clean/simplify.rs
@@ -102,7 +102,7 @@
         // 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");
diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs
index 9b74d130941d84fd87af86245eb08511b08ebd08..d259ed3cdfa7e788dbf5820e0830eef64754a110 100644
--- a/src/librustdoc/clean/types.rs
+++ b/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),
diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs
index 7093bcf6adf1cec4e9cf81d934e25bd676038718..9cd10481ef03d5c58349646ad41eaed2532bd625 100644
--- a/src/librustdoc/html/format.rs
+++ b/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))
     }
 }
 
diff --git a/src/librustdoc/html/render/cache.rs b/src/librustdoc/html/render/cache.rs
index 7336b8b41ac161d4c3232374b9fa194756f767cb..9c05c80d55dfea35a5b8c820657ec6950d6a1394 100644
--- a/src/librustdoc/html/render/cache.rs
+++ b/src/librustdoc/html/render/cache.rs
@@ -322,7 +322,7 @@ fn insert(res: &mut FxHashSet<(Type, ItemType)>, tcx: TyCtxt<'_>, ty: Type) -> u
         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() {
diff --git a/src/librustdoc/html/render/mod.rs b/src/librustdoc/html/render/mod.rs
index e936750c6d37f1fdf511abc133af9e01b496234d..6b213da50a79c510522f45ae83b923dbc8c4b598 100644
--- a/src/librustdoc/html/render/mod.rs
+++ b/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());
             }
             _ => {}
         }
diff --git a/src/librustdoc/json/conversions.rs b/src/librustdoc/json/conversions.rs
index fda540aa186b08924974fd9a4d383aae4e4a7ffe..1f2479a302f958a2e1d1ae10f42352b05382e1e8 100644
--- a/src/librustdoc/json/conversions.rs
+++ b/src/librustdoc/json/conversions.rs
@@ -365,7 +365,7 @@ fn from_tcx(bound: clean::GenericBound, tcx: TyCtxt<'_>) -> Self {
             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 @@ fn from_tcx(ty: clean::Type, tcx: TyCtxt<'_>) -> Self {
 
                 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 @@ fn from_tcx(ty: clean::Type, tcx: TyCtxt<'_>) -> Self {
             },
             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 @@ fn from_tcx(impl_: clean::Impl, tcx: TyCtxt<'_>) -> Self {
         } = 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 {
diff --git a/src/librustdoc/passes/collect_trait_impls.rs b/src/librustdoc/passes/collect_trait_impls.rs
index 72e631df89a59c81bf9799812f131bba0dedbe4f..319dd7b42b0ee69cb4d2d23d656f79188977aa82 100644
--- a/src/librustdoc/passes/collect_trait_impls.rs
+++ b/src/librustdoc/passes/collect_trait_impls.rs
@@ -82,7 +82,7 @@
             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