diff --git a/src/librustdoc/clean/auto_trait.rs b/src/librustdoc/clean/auto_trait.rs
index fb178cbd95e7b..d2d74e7e6c264 100644
--- a/src/librustdoc/clean/auto_trait.rs
+++ b/src/librustdoc/clean/auto_trait.rs
@@ -332,10 +332,9 @@ impl<'a, 'tcx> AutoTraitFinder<'a, 'tcx> {
                 match br {
                     // We only care about named late bound regions, as we need to add them
                     // to the 'for<>' section
-                    ty::BrNamed(_, name) => Some(GenericParamDef {
-                        name,
-                        kind: GenericParamDefKind::Lifetime { outlives: vec![] },
-                    }),
+                    ty::BrNamed(_, name) => {
+                        Some(GenericParamDef { name, kind: GenericParamDefKind::Lifetime })
+                    }
                     _ => None,
                 }
             })
@@ -610,18 +609,15 @@ impl<'a, 'tcx> AutoTraitFinder<'a, 'tcx> {
             };
         }
 
-        let final_bounds = self.make_final_bounds(ty_to_bounds, ty_to_fn, lifetime_to_bounds);
-
-        existing_predicates.extend(final_bounds);
-
         for param in generic_params.iter_mut() {
             match param.kind {
-                GenericParamDefKind::Type { ref mut default, ref mut bounds, .. } => {
+                GenericParamDefKind::Type { ref mut default, .. } => {
                     // We never want something like `impl<T=Foo>`.
                     default.take();
                     let generic_ty = Type::Generic(param.name);
                     if !has_sized.contains(&generic_ty) {
-                        bounds.insert(0, GenericBound::maybe_sized(self.cx));
+                        let b = GenericBound::maybe_sized(self.cx);
+                        ty_to_bounds.entry(generic_ty).or_default().insert(b);
                     }
                 }
                 GenericParamDefKind::Lifetime { .. } => {}
@@ -632,6 +628,10 @@ impl<'a, 'tcx> AutoTraitFinder<'a, 'tcx> {
             }
         }
 
+        let final_bounds = self.make_final_bounds(ty_to_bounds, ty_to_fn, lifetime_to_bounds);
+
+        existing_predicates.extend(final_bounds);
+
         self.sort_where_predicates(&mut existing_predicates);
 
         Generics { params: generic_params, where_predicates: existing_predicates }
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
index fd30691c32489..40e9fc7bb80e7 100644
--- a/src/librustdoc/clean/mod.rs
+++ b/src/librustdoc/clean/mod.rs
@@ -16,7 +16,6 @@ use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_hir as hir;
 use rustc_hir::def::{CtorKind, DefKind, Res};
 use rustc_hir::def_id::{DefId, LOCAL_CRATE};
-use rustc_hir::PredicateOrigin;
 use rustc_infer::infer::region_constraints::{Constraint, RegionConstraintData};
 use rustc_middle::middle::resolve_lifetime as rl;
 use rustc_middle::ty::fold::TypeFolder;
@@ -33,7 +32,7 @@ use std::collections::hash_map::Entry;
 use std::collections::BTreeMap;
 use std::default::Default;
 use std::hash::Hash;
-use std::{mem, vec};
+use std::vec;
 
 use crate::core::{self, DocContext, ImplTraitParam};
 use crate::formats::item_type::ItemType;
@@ -167,10 +166,9 @@ fn clean_poly_trait_ref_with_bindings<'tcx>(
         .collect_referenced_late_bound_regions(&poly_trait_ref)
         .into_iter()
         .filter_map(|br| match br {
-            ty::BrNamed(_, name) => Some(GenericParamDef {
-                name,
-                kind: GenericParamDefKind::Lifetime { outlives: vec![] },
-            }),
+            ty::BrNamed(_, name) => {
+                Some(GenericParamDef { name, kind: GenericParamDefKind::Lifetime })
+            }
             _ => None,
         })
         .collect();
@@ -239,12 +237,9 @@ impl<'tcx> Clean<'tcx, Option<Lifetime>> for ty::Region<'tcx> {
     }
 }
 
-impl<'tcx> Clean<'tcx, Option<WherePredicate>> for hir::WherePredicate<'tcx> {
-    fn clean(&self, cx: &mut DocContext<'tcx>) -> Option<WherePredicate> {
-        if !self.in_where_clause() {
-            return None;
-        }
-        Some(match *self {
+impl<'tcx> Clean<'tcx, WherePredicate> for hir::WherePredicate<'tcx> {
+    fn clean(&self, cx: &mut DocContext<'tcx>) -> WherePredicate {
+        match *self {
             hir::WherePredicate::BoundPredicate(ref wbp) => {
                 let bound_params = wbp
                     .bound_generic_params
@@ -275,7 +270,7 @@ impl<'tcx> Clean<'tcx, Option<WherePredicate>> for hir::WherePredicate<'tcx> {
                 lhs: wrp.lhs_ty.clean(cx),
                 rhs: wrp.rhs_ty.clean(cx).into(),
             },
-        })
+        }
     }
 }
 
@@ -434,9 +429,7 @@ fn projection_to_path_segment<'tcx>(
 impl<'tcx> Clean<'tcx, GenericParamDef> for ty::GenericParamDef {
     fn clean(&self, cx: &mut DocContext<'tcx>) -> GenericParamDef {
         let (name, kind) = match self.kind {
-            ty::GenericParamDefKind::Lifetime => {
-                (self.name, GenericParamDefKind::Lifetime { outlives: vec![] })
-            }
+            ty::GenericParamDefKind::Lifetime => (self.name, GenericParamDefKind::Lifetime),
             ty::GenericParamDefKind::Type { has_default, synthetic, .. } => {
                 let default = if has_default {
                     Some(clean_ty(cx.tcx.type_of(self.def_id), cx, Some(self.def_id)))
@@ -447,7 +440,6 @@ impl<'tcx> Clean<'tcx, GenericParamDef> for ty::GenericParamDef {
                     self.name,
                     GenericParamDefKind::Type {
                         did: self.def_id,
-                        bounds: vec![], // These are filled in from the where-clauses.
                         default: default.map(Box::new),
                         synthetic,
                     },
@@ -472,59 +464,25 @@ impl<'tcx> Clean<'tcx, GenericParamDef> for ty::GenericParamDef {
 
 fn clean_generic_param<'tcx>(
     cx: &mut DocContext<'tcx>,
-    generics: Option<&hir::Generics<'tcx>>,
     param: &hir::GenericParam<'tcx>,
 ) -> GenericParamDef {
     let did = cx.tcx.hir().local_def_id(param.hir_id);
-    let (name, kind) = match param.kind {
-        hir::GenericParamKind::Lifetime { .. } => {
-            let outlives = if let Some(generics) = generics {
-                generics
-                    .outlives_for_param(did)
-                    .filter(|bp| !bp.in_where_clause)
-                    .flat_map(|bp| bp.bounds)
-                    .map(|bound| match bound {
-                        hir::GenericBound::Outlives(lt) => lt.clean(cx),
-                        _ => panic!(),
-                    })
-                    .collect()
-            } else {
-                Vec::new()
-            };
-            (param.name.ident().name, GenericParamDefKind::Lifetime { outlives })
-        }
-        hir::GenericParamKind::Type { ref default, synthetic } => {
-            let bounds = if let Some(generics) = generics {
-                generics
-                    .bounds_for_param(did)
-                    .filter(|bp| bp.origin != PredicateOrigin::WhereClause)
-                    .flat_map(|bp| bp.bounds)
-                    .filter_map(|x| x.clean(cx))
-                    .collect()
-            } else {
-                Vec::new()
-            };
-            (
-                param.name.ident().name,
-                GenericParamDefKind::Type {
-                    did: did.to_def_id(),
-                    bounds,
-                    default: default.map(|t| t.clean(cx)).map(Box::new),
-                    synthetic,
-                },
-            )
-        }
-        hir::GenericParamKind::Const { ty, default } => (
-            param.name.ident().name,
-            GenericParamDefKind::Const {
-                did: did.to_def_id(),
-                ty: Box::new(ty.clean(cx)),
-                default: default.map(|ct| {
-                    let def_id = cx.tcx.hir().local_def_id(ct.hir_id);
-                    Box::new(ty::Const::from_anon_const(cx.tcx, def_id).to_string())
-                }),
-            },
-        ),
+    let name = param.name.ident().name;
+    let kind = match param.kind {
+        hir::GenericParamKind::Lifetime { .. } => GenericParamDefKind::Lifetime,
+        hir::GenericParamKind::Type { ref default, synthetic } => GenericParamDefKind::Type {
+            did: cx.tcx.hir().local_def_id(param.hir_id).to_def_id(),
+            default: default.map(|t| t.clean(cx)).map(Box::new),
+            synthetic,
+        },
+        hir::GenericParamKind::Const { ty, default } => GenericParamDefKind::Const {
+            did: did.to_def_id(),
+            ty: Box::new(ty.clean(cx)),
+            default: default.map(|ct| {
+                let def_id = cx.tcx.hir().local_def_id(ct.hir_id);
+                Box::new(ty::Const::from_anon_const(cx.tcx, def_id).to_string())
+            }),
+        },
     };
 
     GenericParamDef { name, kind }
@@ -532,83 +490,35 @@ fn clean_generic_param<'tcx>(
 
 impl<'tcx> Clean<'tcx, Generics> for hir::Generics<'tcx> {
     fn clean(&self, cx: &mut DocContext<'tcx>) -> Generics {
-        // Synthetic type-parameters are inserted after normal ones.
-        // In order for normal parameters to be able to refer to synthetic ones,
-        // scans them first.
-        fn is_impl_trait(param: &hir::GenericParam<'_>) -> bool {
-            match param.kind {
-                hir::GenericParamKind::Type { synthetic, .. } => synthetic,
-                _ => false,
-            }
-        }
-        /// This can happen for `async fn`, e.g. `async fn f<'_>(&'_ self)`.
-        ///
-        /// See [`lifetime_to_generic_param`] in [`rustc_ast_lowering`] for more information.
-        ///
-        /// [`lifetime_to_generic_param`]: rustc_ast_lowering::LoweringContext::lifetime_to_generic_param
-        fn is_elided_lifetime(param: &hir::GenericParam<'_>) -> bool {
-            matches!(
-                param.kind,
-                hir::GenericParamKind::Lifetime { kind: hir::LifetimeParamKind::Elided }
-            )
-        }
-
-        let impl_trait_params = self
-            .params
-            .iter()
-            .filter(|param| is_impl_trait(param))
-            .map(|param| {
-                let param = clean_generic_param(cx, Some(self), param);
-                match param.kind {
-                    GenericParamDefKind::Lifetime { .. } => unreachable!(),
-                    GenericParamDefKind::Type { did, ref bounds, .. } => {
-                        cx.impl_trait_bounds.insert(did.into(), bounds.clone());
+        let mut impl_trait = FxHashSet::default();
+        for (i, p) in self.predicates.iter().enumerate() {
+            if let hir::WherePredicate::BoundPredicate(bp) = p {
+                if let Some((def_id, ident)) = bp.bounded_ty.as_generic_param() {
+                    // Do not include predicates on `impl Trait` desugaring.
+                    if ident.as_str().starts_with("impl ") {
+                        let bounds = bp.bounds.iter().filter_map(|b| b.clean(cx)).collect();
+                        cx.impl_trait_bounds.insert(def_id.into(), bounds);
+                        impl_trait.insert(i);
                     }
-                    GenericParamDefKind::Const { .. } => unreachable!(),
                 }
-                param
-            })
-            .collect::<Vec<_>>();
+            }
+        }
 
         let mut params = Vec::with_capacity(self.params.len());
-        for p in self.params.iter().filter(|p| !is_impl_trait(p) && !is_elided_lifetime(p)) {
-            let p = clean_generic_param(cx, Some(self), p);
-            params.push(p);
+        for p in self.params {
+            if !p.is_elided_lifetime() {
+                params.push(clean_generic_param(cx, p));
+            }
         }
-        params.extend(impl_trait_params);
-
-        let mut generics = Generics {
-            params,
-            where_predicates: self.predicates.iter().filter_map(|x| x.clean(cx)).collect(),
-        };
 
-        // Some duplicates are generated for ?Sized bounds between type params and where
-        // predicates. The point in here is to move the bounds definitions from type params
-        // to where predicates when such cases occur.
-        for where_pred in &mut generics.where_predicates {
-            match *where_pred {
-                WherePredicate::BoundPredicate {
-                    ty: Generic(ref name), ref mut bounds, ..
-                } => {
-                    if bounds.is_empty() {
-                        for param in &mut generics.params {
-                            match param.kind {
-                                GenericParamDefKind::Lifetime { .. } => {}
-                                GenericParamDefKind::Type { bounds: ref mut ty_bounds, .. } => {
-                                    if &param.name == name {
-                                        mem::swap(bounds, ty_bounds);
-                                        break;
-                                    }
-                                }
-                                GenericParamDefKind::Const { .. } => {}
-                            }
-                        }
-                    }
-                }
-                _ => continue,
+        let mut where_predicates = Vec::with_capacity(self.predicates.len());
+        for (i, p) in self.predicates.iter().enumerate() {
+            if impl_trait.contains(&i) {
+                continue;
             }
+            where_predicates.push(p.clean(cx));
         }
-        generics
+        Generics { params, where_predicates }
     }
 }
 
@@ -991,7 +901,7 @@ impl<'tcx> Clean<'tcx, PolyTrait> for hir::PolyTraitRef<'tcx> {
             generic_params: self
                 .bound_generic_params
                 .iter()
-                .map(|x| clean_generic_param(cx, None, x))
+                .map(|x| clean_generic_param(cx, x))
                 .collect(),
         }
     }
@@ -1866,7 +1776,7 @@ impl<'tcx> Clean<'tcx, BareFunctionDecl> for hir::BareFnTy<'tcx> {
         let (generic_params, decl) = enter_impl_trait(cx, |cx| {
             // NOTE: generics must be cleaned before args
             let generic_params =
-                self.generic_params.iter().map(|x| clean_generic_param(cx, None, x)).collect();
+                self.generic_params.iter().map(|x| clean_generic_param(cx, x)).collect();
             let args = clean_args_from_types_and_names(cx, self.decl.inputs, self.param_names);
             let decl = clean_fn_decl_with_args(cx, self.decl, args);
             (generic_params, decl)
diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs
index 83ab9acd3005a..317fe32cc1ad8 100644
--- a/src/librustdoc/clean/types.rs
+++ b/src/librustdoc/clean/types.rs
@@ -1362,17 +1362,11 @@ impl WherePredicate {
 
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub(crate) enum GenericParamDefKind {
-    Lifetime { outlives: Vec<Lifetime> },
-    Type { did: DefId, bounds: Vec<GenericBound>, default: Option<Box<Type>>, synthetic: bool },
+    Lifetime,
+    Type { did: DefId, default: Option<Box<Type>>, synthetic: bool },
     Const { did: DefId, ty: Box<Type>, default: Option<Box<String>> },
 }
 
-impl GenericParamDefKind {
-    pub(crate) fn is_type(&self) -> bool {
-        matches!(self, GenericParamDefKind::Type { .. })
-    }
-}
-
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub(crate) struct GenericParamDef {
     pub(crate) name: Symbol,
@@ -1381,26 +1375,15 @@ pub(crate) struct GenericParamDef {
 
 // `GenericParamDef` is used in many places. Make sure it doesn't unintentionally get bigger.
 #[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))]
-rustc_data_structures::static_assert_size!(GenericParamDef, 56);
+rustc_data_structures::static_assert_size!(GenericParamDef, 40);
 
 impl GenericParamDef {
     pub(crate) fn is_synthetic_type_param(&self) -> bool {
         match self.kind {
-            GenericParamDefKind::Lifetime { .. } | GenericParamDefKind::Const { .. } => false,
+            GenericParamDefKind::Lifetime | GenericParamDefKind::Const { .. } => false,
             GenericParamDefKind::Type { synthetic, .. } => synthetic,
         }
     }
-
-    pub(crate) fn is_type(&self) -> bool {
-        self.kind.is_type()
-    }
-
-    pub(crate) fn get_bounds(&self) -> Option<&[GenericBound]> {
-        match self.kind {
-            GenericParamDefKind::Type { ref bounds, .. } => Some(bounds),
-            _ => None,
-        }
-    }
 }
 
 // maybe use a Generic enum and use Vec<Generic>?
diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs
index 0c0920ae63e4e..263298a83a563 100644
--- a/src/librustdoc/html/format.rs
+++ b/src/librustdoc/html/format.rs
@@ -182,32 +182,10 @@ impl clean::GenericParamDef {
         cx: &'a Context<'tcx>,
     ) -> impl fmt::Display + 'a + Captures<'tcx> {
         display_fn(move |f| match &self.kind {
-            clean::GenericParamDefKind::Lifetime { outlives } => {
-                write!(f, "{}", self.name)?;
-
-                if !outlives.is_empty() {
-                    f.write_str(": ")?;
-                    for (i, lt) in outlives.iter().enumerate() {
-                        if i != 0 {
-                            f.write_str(" + ")?;
-                        }
-                        write!(f, "{}", lt.print())?;
-                    }
-                }
-
-                Ok(())
-            }
-            clean::GenericParamDefKind::Type { bounds, default, .. } => {
+            clean::GenericParamDefKind::Lifetime => write!(f, "{}", self.name),
+            clean::GenericParamDefKind::Type { default, .. } => {
                 f.write_str(self.name.as_str())?;
 
-                if !bounds.is_empty() {
-                    if f.alternate() {
-                        write!(f, ": {:#}", print_generic_bounds(bounds, cx))?;
-                    } else {
-                        write!(f, ":&nbsp;{}", print_generic_bounds(bounds, cx))?;
-                    }
-                }
-
                 if let Some(ref ty) = default {
                     if f.alternate() {
                         write!(f, " = {:#}", ty.print(cx))?;
diff --git a/src/librustdoc/html/render/search_index.rs b/src/librustdoc/html/render/search_index.rs
index 9f302cc256659..0d42f0d9c7a3c 100644
--- a/src/librustdoc/html/render/search_index.rs
+++ b/src/librustdoc/html/render/search_index.rs
@@ -351,7 +351,7 @@ fn add_generics_and_bounds_as_types<'tcx, 'a>(
 
     // If this argument is a type parameter and not a trait bound or a type, we need to look
     // for its bounds.
-    if let Type::Generic(arg_s) = *arg {
+    if let Type::Generic(_) = *arg {
         // First we check if the bounds are in a `where` predicate...
         if let Some(where_pred) = generics.where_predicates.iter().find(|g| match g {
             WherePredicate::BoundPredicate { ty, .. } => ty.def_id(cache) == arg.def_id(cache),
@@ -381,25 +381,6 @@ fn add_generics_and_bounds_as_types<'tcx, 'a>(
             }
             insert_ty(res, tcx, arg.clone(), ty_generics, cache);
         }
-        // Otherwise we check if the trait bounds are "inlined" like `T: Option<u32>`...
-        if let Some(bound) = generics.params.iter().find(|g| g.is_type() && g.name == arg_s) {
-            let mut ty_generics = Vec::new();
-            for bound in bound.get_bounds().unwrap_or(&[]) {
-                if let Some(path) = bound.get_trait_path() {
-                    let ty = Type::Path { path };
-                    add_generics_and_bounds_as_types(
-                        self_,
-                        generics,
-                        &ty,
-                        tcx,
-                        recurse + 1,
-                        &mut ty_generics,
-                        cache,
-                    );
-                }
-            }
-            insert_ty(res, tcx, arg.clone(), ty_generics, cache);
-        }
     } else if let Type::ImplTrait(ref bounds) = *arg {
         let mut ty_generics = Vec::new();
         for bound in bounds {
diff --git a/src/librustdoc/json/conversions.rs b/src/librustdoc/json/conversions.rs
index 4fde63c99d4b9..c26582e58e8f5 100644
--- a/src/librustdoc/json/conversions.rs
+++ b/src/librustdoc/json/conversions.rs
@@ -351,11 +351,8 @@ impl FromWithTcx<clean::GenericParamDefKind> for GenericParamDefKind {
     fn from_tcx(kind: clean::GenericParamDefKind, tcx: TyCtxt<'_>) -> Self {
         use clean::GenericParamDefKind::*;
         match kind {
-            Lifetime { outlives } => GenericParamDefKind::Lifetime {
-                outlives: outlives.into_iter().map(|lt| lt.0.to_string()).collect(),
-            },
-            Type { did: _, bounds, default, synthetic } => GenericParamDefKind::Type {
-                bounds: bounds.into_iter().map(|x| x.into_tcx(tcx)).collect(),
+            Lifetime => GenericParamDefKind::Lifetime,
+            Type { did: _, default, synthetic } => GenericParamDefKind::Type {
                 default: default.map(|x| (*x).into_tcx(tcx)),
                 synthetic,
             },
@@ -378,7 +375,7 @@ impl FromWithTcx<clean::WherePredicate> for WherePredicate {
                     .into_iter()
                     .map(|x| GenericParamDef {
                         name: x.0.to_string(),
-                        kind: GenericParamDefKind::Lifetime { outlives: vec![] },
+                        kind: GenericParamDefKind::Lifetime,
                     })
                     .collect(),
             },
diff --git a/src/rustdoc-json-types/lib.rs b/src/rustdoc-json-types/lib.rs
index eb2c8e5bae1c4..ecba90f1dc45e 100644
--- a/src/rustdoc-json-types/lib.rs
+++ b/src/rustdoc-json-types/lib.rs
@@ -9,7 +9,7 @@ use std::path::PathBuf;
 use serde::{Deserialize, Serialize};
 
 /// rustdoc format-version.
-pub const FORMAT_VERSION: u32 = 15;
+pub const FORMAT_VERSION: u32 = 16;
 
 /// A `Crate` is the root of the emitted JSON blob. It contains all type/documentation information
 /// about the language items in the local crate, as well as info about external items to allow
@@ -346,11 +346,8 @@ pub struct GenericParamDef {
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
 #[serde(rename_all = "snake_case")]
 pub enum GenericParamDefKind {
-    Lifetime {
-        outlives: Vec<String>,
-    },
+    Lifetime,
     Type {
-        bounds: Vec<GenericBound>,
         default: Option<Type>,
         /// This is normally `false`, which means that this generic parameter is
         /// declared in the Rust source text.
diff --git a/src/test/rustdoc-js/generics-multi-trait.js b/src/test/rustdoc-js/generics-multi-trait.js
index e7fcea876c85c..d6d19f3956972 100644
--- a/src/test/rustdoc-js/generics-multi-trait.js
+++ b/src/test/rustdoc-js/generics-multi-trait.js
@@ -9,20 +9,12 @@ const QUERY = [
 const EXPECTED = [
     // check one of the generic items
     {
-        'in_args': [
-            { 'path': 'generics_multi_trait', 'name': 'beta' },
-        ],
-        'returned': [
-            { 'path': 'generics_multi_trait', 'name': 'bet' },
-        ],
+        'in_args': [],
+        'returned': [],
     },
     {
-        'in_args': [
-            { 'path': 'generics_multi_trait', 'name': 'beta' },
-        ],
-        'returned': [
-            { 'path': 'generics_multi_trait', 'name': 'bet' },
-        ],
+        'in_args': [],
+        'returned': [],
     },
     // ignore the name of the generic itself
     {
diff --git a/src/test/rustdoc-js/generics-trait.js b/src/test/rustdoc-js/generics-trait.js
index 7876622435b60..ce168df1cb9c7 100644
--- a/src/test/rustdoc-js/generics-trait.js
+++ b/src/test/rustdoc-js/generics-trait.js
@@ -5,19 +5,11 @@ const QUERY = [
 
 const EXPECTED = [
     {
-        'in_args': [
-            { 'path': 'generics_trait', 'name': 'beta' },
-        ],
-        'returned': [
-            { 'path': 'generics_trait', 'name': 'bet' },
-        ],
+        'in_args': [],
+        'returned': [],
     },
     {
-        'in_args': [
-            { 'path': 'generics_trait', 'name': 'alpha' },
-        ],
-        'returned': [
-            { 'path': 'generics_trait', 'name': 'alef' },
-        ],
+        'in_args': [],
+        'returned': [],
     },
 ];
diff --git a/src/test/rustdoc-js/generics.js b/src/test/rustdoc-js/generics.js
index 5e5ba7cd9ac8f..ad5a6807c3bb0 100644
--- a/src/test/rustdoc-js/generics.js
+++ b/src/test/rustdoc-js/generics.js
@@ -50,15 +50,11 @@ const EXPECTED = [
     },
     {
         // TraitCat
-        'in_args': [
-            { 'path': 'generics', 'name': 'gamma' },
-        ],
+        'in_args': [],
     },
     {
         // TraitDog
-        'in_args': [
-            { 'path': 'generics', 'name': 'gamma' },
-        ],
+        'in_args': [],
     },
     {
         // Result<String>
diff --git a/src/test/rustdoc-json/fn_pointer/generics.rs b/src/test/rustdoc-json/fn_pointer/generics.rs
index 646f720e66396..091c45bf5b968 100644
--- a/src/test/rustdoc-json/fn_pointer/generics.rs
+++ b/src/test/rustdoc-json/fn_pointer/generics.rs
@@ -10,5 +10,5 @@
 // @is - "$.index[*][?(@.name=='WithHigherRankTraitBounds')].inner.type.inner.decl.output" '{ "kind": "primitive", "inner": "i32" }'
 // @count - "$.index[*][?(@.name=='WithHigherRankTraitBounds')].inner.type.inner.generic_params[*]" 1
 // @is - "$.index[*][?(@.name=='WithHigherRankTraitBounds')].inner.type.inner.generic_params[0].name" \"\'c\"
-// @is - "$.index[*][?(@.name=='WithHigherRankTraitBounds')].inner.type.inner.generic_params[0].kind" '{ "lifetime": { "outlives": [] } }'
+// @is - "$.index[*][?(@.name=='WithHigherRankTraitBounds')].inner.type.inner.generic_params[0].kind" '"lifetime"'
 pub type WithHigherRankTraitBounds = for<'c> fn(val: &'c i32) -> i32;
diff --git a/src/test/rustdoc-json/fns/generic_args.rs b/src/test/rustdoc-json/fns/generic_args.rs
index 69150443c29dc..502e400a6ec0c 100644
--- a/src/test/rustdoc-json/fns/generic_args.rs
+++ b/src/test/rustdoc-json/fns/generic_args.rs
@@ -9,32 +9,32 @@ pub trait Foo {}
 // @set generic_foo = generic_args.json "$.index[*][?(@.name=='GenericFoo')].id"
 pub trait GenericFoo<'a> {}
 
-// @is - "$.index[*][?(@.name=='generics')].inner.generics.where_predicates" "[]"
 // @count - "$.index[*][?(@.name=='generics')].inner.generics.params[*]" 1
 // @is - "$.index[*][?(@.name=='generics')].inner.generics.params[0].name" '"F"'
 // @is - "$.index[*][?(@.name=='generics')].inner.generics.params[0].kind.type.default" 'null'
-// @count - "$.index[*][?(@.name=='generics')].inner.generics.params[0].kind.type.bounds[*]" 1
-// @is - "$.index[*][?(@.name=='generics')].inner.generics.params[0].kind.type.bounds[0].trait_bound.trait.inner.id" '$foo'
 // @count - "$.index[*][?(@.name=='generics')].inner.decl.inputs[*]" 1
 // @is - "$.index[*][?(@.name=='generics')].inner.decl.inputs[0][0]" '"f"'
 // @is - "$.index[*][?(@.name=='generics')].inner.decl.inputs[0][1].kind" '"generic"'
 // @is - "$.index[*][?(@.name=='generics')].inner.decl.inputs[0][1].inner" '"F"'
+// @count - "$.index[*][?(@.name=='generics')].inner.generics.where_predicates" 1
+// @is - "$.index[*][?(@.name=='generics')].inner.generics.where_predicates[0].bound_predicate.type" '{"inner": "F", "kind": "generic"}'
+// @count - "$.index[*][?(@.name=='generics')].inner.generics.where_predicates[0].bound_predicate.bounds[*]" 1
+// @is - "$.index[*][?(@.name=='generics')].inner.generics.where_predicates[0].bound_predicate.bounds[0].trait_bound.trait.inner.id" '$foo'
 pub fn generics<F: Foo>(f: F) {}
 
-// @is - "$.index[*][?(@.name=='impl_trait')].inner.generics.where_predicates" "[]"
 // @count - "$.index[*][?(@.name=='impl_trait')].inner.generics.params[*]" 1
 // @is - "$.index[*][?(@.name=='impl_trait')].inner.generics.params[0].name" '"impl Foo"'
-// @is - "$.index[*][?(@.name=='impl_trait')].inner.generics.params[0].kind.type.bounds[0].trait_bound.trait.inner.id" $foo
 // @count - "$.index[*][?(@.name=='impl_trait')].inner.decl.inputs[*]" 1
 // @is - "$.index[*][?(@.name=='impl_trait')].inner.decl.inputs[0][0]" '"f"'
 // @is - "$.index[*][?(@.name=='impl_trait')].inner.decl.inputs[0][1].kind" '"impl_trait"'
 // @count - "$.index[*][?(@.name=='impl_trait')].inner.decl.inputs[0][1].inner[*]" 1
 // @is - "$.index[*][?(@.name=='impl_trait')].inner.decl.inputs[0][1].inner[0].trait_bound.trait.inner.id" $foo
+// @is - "$.index[*][?(@.name=='impl_trait')].inner.generics.where_predicates" '[]'
 pub fn impl_trait(f: impl Foo) {}
 
 // @count - "$.index[*][?(@.name=='where_clase')].inner.generics.params[*]" 3
 // @is - "$.index[*][?(@.name=='where_clase')].inner.generics.params[0].name" '"F"'
-// @is - "$.index[*][?(@.name=='where_clase')].inner.generics.params[0].kind" '{"type": {"bounds": [], "default": null, "synthetic": false}}'
+// @is - "$.index[*][?(@.name=='where_clase')].inner.generics.params[0].kind" '{"type": {"default": null, "synthetic": false}}'
 // @count - "$.index[*][?(@.name=='where_clase')].inner.decl.inputs[*]" 3
 // @is - "$.index[*][?(@.name=='where_clase')].inner.decl.inputs[0][0]" '"f"'
 // @is - "$.index[*][?(@.name=='where_clase')].inner.decl.inputs[0][1].kind" '"generic"'
@@ -50,7 +50,7 @@ pub fn impl_trait(f: impl Foo) {}
 // @is - "$.index[*][?(@.name=='where_clase')].inner.generics.where_predicates[1].bound_predicate.bounds[0].trait_bound.trait.inner.id" $generic_foo
 // @count - "$.index[*][?(@.name=='where_clase')].inner.generics.where_predicates[1].bound_predicate.bounds[0].trait_bound.generic_params[*]" 1
 // @is - "$.index[*][?(@.name=='where_clase')].inner.generics.where_predicates[1].bound_predicate.bounds[0].trait_bound.generic_params[0].name" \"\'a\"
-// @is - "$.index[*][?(@.name=='where_clase')].inner.generics.where_predicates[1].bound_predicate.bounds[0].trait_bound.generic_params[0].kind" '{ "lifetime": { "outlives": [] } }'
+// @is - "$.index[*][?(@.name=='where_clase')].inner.generics.where_predicates[1].bound_predicate.bounds[0].trait_bound.generic_params[0].kind" '"lifetime"'
 // @is - "$.index[*][?(@.name=='where_clase')].inner.generics.where_predicates[1].bound_predicate.generic_params" "[]"
 
 // @is - "$.index[*][?(@.name=='where_clase')].inner.generics.where_predicates[2].bound_predicate.type.kind" '"borrowed_ref"'
@@ -61,7 +61,7 @@ pub fn impl_trait(f: impl Foo) {}
 // @is - "$.index[*][?(@.name=='where_clase')].inner.generics.where_predicates[2].bound_predicate.bounds[0].trait_bound.generic_params" "[]"
 // @count - "$.index[*][?(@.name=='where_clase')].inner.generics.where_predicates[2].bound_predicate.generic_params[*]" 1
 // @is - "$.index[*][?(@.name=='where_clase')].inner.generics.where_predicates[2].bound_predicate.generic_params[0].name" \"\'b\"
-// @is - "$.index[*][?(@.name=='where_clase')].inner.generics.where_predicates[2].bound_predicate.generic_params[0].kind" '{ "lifetime": { "outlives": [] } }'
+// @is - "$.index[*][?(@.name=='where_clase')].inner.generics.where_predicates[2].bound_predicate.generic_params[0].kind" '"lifetime"'
 pub fn where_clase<F, G, H>(f: F, g: G, h: H)
 where
     F: Foo,
diff --git a/src/test/rustdoc-json/fns/generics.rs b/src/test/rustdoc-json/fns/generics.rs
index e777fabaa52a7..fd60bb0eec31d 100644
--- a/src/test/rustdoc-json/fns/generics.rs
+++ b/src/test/rustdoc-json/fns/generics.rs
@@ -6,11 +6,11 @@
 // @set wham_id = generics.json "$.index[*][?(@.name=='Wham')].id"
 pub trait Wham {}
 
-// @is    - "$.index[*][?(@.name=='one_generic_param_fn')].inner.generics.where_predicates" []
 // @count - "$.index[*][?(@.name=='one_generic_param_fn')].inner.generics.params[*]" 1
 // @is    - "$.index[*][?(@.name=='one_generic_param_fn')].inner.generics.params[0].name" '"T"'
 // @has   - "$.index[*][?(@.name=='one_generic_param_fn')].inner.generics.params[0].kind.type.synthetic" false
-// @has   - "$.index[*][?(@.name=='one_generic_param_fn')].inner.generics.params[0].kind.type.bounds[0].trait_bound.trait.inner.id" $wham_id
+// @is    - "$.index[*][?(@.name=='one_generic_param_fn')].inner.generics.where_predicates[0].bound_predicate.type" '{"kind": "generic", "inner": "T"}'
+// @has   - "$.index[*][?(@.name=='one_generic_param_fn')].inner.generics.where_predicates[0].bound_predicate.bounds[0].trait_bound.trait.inner.id" $wham_id
 // @is    - "$.index[*][?(@.name=='one_generic_param_fn')].inner.decl.inputs" '[["w", {"inner": "T", "kind": "generic"}]]'
 pub fn one_generic_param_fn<T: Wham>(w: T) {}
 
@@ -18,7 +18,6 @@ pub fn one_generic_param_fn<T: Wham>(w: T) {}
 // @count - "$.index[*][?(@.name=='one_synthetic_generic_param_fn')].inner.generics.params[*]" 1
 // @is    - "$.index[*][?(@.name=='one_synthetic_generic_param_fn')].inner.generics.params[0].name" '"impl Wham"'
 // @has   - "$.index[*][?(@.name=='one_synthetic_generic_param_fn')].inner.generics.params[0].kind.type.synthetic" true
-// @has   - "$.index[*][?(@.name=='one_synthetic_generic_param_fn')].inner.generics.params[0].kind.type.bounds[0].trait_bound.trait.inner.id" $wham_id
 // @count - "$.index[*][?(@.name=='one_synthetic_generic_param_fn')].inner.decl.inputs[*]" 1
 // @is    - "$.index[*][?(@.name=='one_synthetic_generic_param_fn')].inner.decl.inputs[0][0]" '"w"'
 // @is    - "$.index[*][?(@.name=='one_synthetic_generic_param_fn')].inner.decl.inputs[0][1].kind" '"impl_trait"'
diff --git a/src/test/rustdoc-json/lifetime/longest.rs b/src/test/rustdoc-json/lifetime/longest.rs
index 95b99599e737d..a94a25be7393d 100644
--- a/src/test/rustdoc-json/lifetime/longest.rs
+++ b/src/test/rustdoc-json/lifetime/longest.rs
@@ -4,8 +4,8 @@
 #![no_core]
 
 // @is longest.json "$.index[*][?(@.name=='longest')].inner.generics.params[0].name"  \"\'a\"
-// @is - "$.index[*][?(@.name=='longest')].inner.generics.params[0].kind"  '{"lifetime": {"outlives": []}}'
-// @is - "$.index[*][?(@.name=='longest')].inner.generics.params[0].kind"  '{"lifetime": {"outlives": []}}'
+// @is - "$.index[*][?(@.name=='longest')].inner.generics.params[0].kind"  '"lifetime"'
+// @is - "$.index[*][?(@.name=='longest')].inner.generics.params[0].kind"  '"lifetime"'
 // @count - "$.index[*][?(@.name=='longest')].inner.generics.params[*]" 1
 // @is - "$.index[*][?(@.name=='longest')].inner.generics.where_predicates" []
 
diff --git a/src/test/rustdoc-json/lifetime/outlives.rs b/src/test/rustdoc-json/lifetime/outlives.rs
index 096dd7f7a6918..a685f96adcf86 100644
--- a/src/test/rustdoc-json/lifetime/outlives.rs
+++ b/src/test/rustdoc-json/lifetime/outlives.rs
@@ -4,15 +4,10 @@
 #![no_core]
 
 // @count outlives.json "$.index[*][?(@.name=='foo')].inner.generics.params[*]" 3
-// @is - "$.index[*][?(@.name=='foo')].inner.generics.where_predicates" []
 // @is - "$.index[*][?(@.name=='foo')].inner.generics.params[0].name" \"\'a\"
 // @is - "$.index[*][?(@.name=='foo')].inner.generics.params[1].name" \"\'b\"
 // @is - "$.index[*][?(@.name=='foo')].inner.generics.params[2].name" '"T"'
-// @is - "$.index[*][?(@.name=='foo')].inner.generics.params[0].kind.lifetime.outlives" []
-// @is - "$.index[*][?(@.name=='foo')].inner.generics.params[1].kind.lifetime.outlives" [\"\'a\"]
 // @is - "$.index[*][?(@.name=='foo')].inner.generics.params[2].kind.type.default" null
-// @count - "$.index[*][?(@.name=='foo')].inner.generics.params[2].kind.type.bounds[*]" 1
-// @is - "$.index[*][?(@.name=='foo')].inner.generics.params[2].kind.type.bounds[0].outlives" \"\'b\"
 // @is - "$.index[*][?(@.name=='foo')].inner.decl.inputs[0][1].kind" '"borrowed_ref"'
 // @is - "$.index[*][?(@.name=='foo')].inner.decl.inputs[0][1].inner.lifetime" \"\'a\"
 // @is - "$.index[*][?(@.name=='foo')].inner.decl.inputs[0][1].inner.mutable" false
@@ -20,4 +15,10 @@
 // @is - "$.index[*][?(@.name=='foo')].inner.decl.inputs[0][1].inner.type.inner.lifetime" \"\'b\"
 // @is - "$.index[*][?(@.name=='foo')].inner.decl.inputs[0][1].inner.type.inner.mutable" false
 // @is - "$.index[*][?(@.name=='foo')].inner.decl.inputs[0][1].inner.type.inner.type" '{"inner": "T", "kind": "generic"}'
+// @count - "$.index[*][?(@.name=='foo')].inner.generics.where_predicates[*]" 2
+// @is - "$.index[*][?(@.name=='foo')].inner.generics.where_predicates[0].region_predicate.lifetime" \"\'b\"
+// @count - "$.index[*][?(@.name=='foo')].inner.generics.where_predicates[0].region_predicate.bounds[*]" 1
+// @is - "$.index[*][?(@.name=='foo')].inner.generics.where_predicates[0].region_predicate.bounds[0].outlives" \"\'a\"
+// @is - "$.index[*][?(@.name=='foo')].inner.generics.where_predicates[1].bound_predicate.type.inner" '"T"'
+// @is - "$.index[*][?(@.name=='foo')].inner.generics.where_predicates[1].bound_predicate.bounds[0].outlives" \"\'b\"
 pub fn foo<'a, 'b: 'a, T: 'b>(_: &'a &'b T) {}
diff --git a/src/test/rustdoc-json/structs/with_primitives.rs b/src/test/rustdoc-json/structs/with_primitives.rs
index 9e64317ec203f..0ae83bf847ea0 100644
--- a/src/test/rustdoc-json/structs/with_primitives.rs
+++ b/src/test/rustdoc-json/structs/with_primitives.rs
@@ -1,7 +1,6 @@
 // @has with_primitives.json "$.index[*][?(@.name=='WithPrimitives')].visibility" \"public\"
 // @has - "$.index[*][?(@.name=='WithPrimitives')].kind" \"struct\"
 // @has - "$.index[*][?(@.name=='WithPrimitives')].inner.generics.params[0].name" \"\'a\"
-// @has - "$.index[*][?(@.name=='WithPrimitives')].inner.generics.params[0].kind.lifetime.outlives" []
 // @has - "$.index[*][?(@.name=='WithPrimitives')].inner.struct_type" \"plain\"
 // @has - "$.index[*][?(@.name=='WithPrimitives')].inner.fields_stripped" true
 pub struct WithPrimitives<'a> {
diff --git a/src/test/rustdoc-json/type/fn_lifetime.rs b/src/test/rustdoc-json/type/fn_lifetime.rs
index e0d1e9649a0aa..3ed7a92841282 100644
--- a/src/test/rustdoc-json/type/fn_lifetime.rs
+++ b/src/test/rustdoc-json/type/fn_lifetime.rs
@@ -4,8 +4,7 @@
 
 // @count - "$.index[*][?(@.name=='GenericFn')].inner.generics.params[*]" 1
 // @is    - "$.index[*][?(@.name=='GenericFn')].inner.generics.params[*].name" \"\'a\"
-// @has   - "$.index[*][?(@.name=='GenericFn')].inner.generics.params[*].kind.lifetime"
-// @count - "$.index[*][?(@.name=='GenericFn')].inner.generics.params[*].kind.lifetime.outlives[*]" 0
+// @is    - "$.index[*][?(@.name=='GenericFn')].inner.generics.params[*].kind" \"lifetime\"
 // @count - "$.index[*][?(@.name=='GenericFn')].inner.generics.where_predicates[*]" 0
 // @is    - "$.index[*][?(@.name=='GenericFn')].inner.type.kind" \"function_pointer\"
 // @count - "$.index[*][?(@.name=='GenericFn')].inner.type.inner.generic_params[*]" 0
@@ -20,8 +19,7 @@ pub type GenericFn<'a> = fn(&'a i32) -> &'a i32;
 // @count - "$.index[*][?(@.name=='ForAll')].inner.generics.where_predicates[*]" 0
 // @count - "$.index[*][?(@.name=='ForAll')].inner.type.inner.generic_params[*]" 1
 // @is    - "$.index[*][?(@.name=='ForAll')].inner.type.inner.generic_params[*].name" \"\'a\"
-// @has   - "$.index[*][?(@.name=='ForAll')].inner.type.inner.generic_params[*].kind.lifetime"
-// @count - "$.index[*][?(@.name=='ForAll')].inner.type.inner.generic_params[*].kind.lifetime.outlives[*]" 0
+// @is    - "$.index[*][?(@.name=='ForAll')].inner.type.inner.generic_params[*].kind" \"lifetime\"
 // @count - "$.index[*][?(@.name=='ForAll')].inner.type.inner.decl.inputs[*]" 1
 // @is    - "$.index[*][?(@.name=='ForAll')].inner.type.inner.decl.inputs[*][1].inner.lifetime" \"\'a\"
 // @is    - "$.index[*][?(@.name=='ForAll')].inner.type.inner.decl.output.inner.lifetime" \"\'a\"
diff --git a/src/test/rustdoc/anonymous-lifetime.rs b/src/test/rustdoc/anonymous-lifetime.rs
index f5a7d225847c4..bc4f6b23f43a1 100644
--- a/src/test/rustdoc/anonymous-lifetime.rs
+++ b/src/test/rustdoc/anonymous-lifetime.rs
@@ -12,7 +12,8 @@ pub trait Stream {
 }
 
 // @has 'foo/trait.Stream.html'
-// @has - '//*[@class="code-header in-band"]' 'impl<S: ?Sized + Stream + Unpin> Stream for &mut S'
+// @has - '//*[@class="code-header in-band"]' 'impl<S> Stream for &mut S'
+// @has - '//*[@class="where fmt-newline"]' 'where S: ?Sized + Stream + Unpin'
 impl<S: ?Sized + Stream + Unpin> Stream for &mut S {
     type Item = S::Item;
 
diff --git a/src/test/rustdoc/assoc-types.rs b/src/test/rustdoc/assoc-types.rs
index d9e4ffab1c7d5..1ed035cdcd402 100644
--- a/src/test/rustdoc/assoc-types.rs
+++ b/src/test/rustdoc/assoc-types.rs
@@ -1,8 +1,8 @@
-#![crate_type="lib"]
+#![crate_type = "lib"]
 
 // @has assoc_types/trait.Index.html
 pub trait Index<I: ?Sized> {
-        // @has - '//*[@id="associatedtype.Output"]//h4[@class="code-header"]' 'type Output: ?Sized'
+    // @has - '//*[@id="associatedtype.Output"]//h4[@class="code-header"]' 'type Output: ?Sized'
     type Output: ?Sized;
     // @has - '//*[@id="tymethod.index"]//h4[@class="code-header"]' \
     //      "fn index<'a>(&'a self, index: I) -> &'a Self::Output"
@@ -25,13 +25,16 @@ pub trait Feed {
 // @has assoc_types/fn.use_input.html
 // @has - '//*[@class="rust fn"]' 'T::Input'
 // @has - '//*[@class="rust fn"]//a[@href="trait.Feed.html#associatedtype.Input"]' 'Input'
-pub fn use_input<T: Feed>(_feed: &T, _element: T::Input) { }
+pub fn use_input<T: Feed>(_feed: &T, _element: T::Input) {}
 
 // @has assoc_types/fn.cmp_input.html
-// @has - '//*[@class="rust fn"]' 'where T::Input: PartialEq<U::Input>'
+// @has - '//*[@class="rust fn"]' 'where T: Feed,'
+// @has - '//*[@class="rust fn"]' 'U: Feed,'
+// @has - '//*[@class="rust fn"]' 'T::Input: PartialEq<U::Input>'
 // @has - '//*[@class="rust fn"]//a[@href="trait.Feed.html#associatedtype.Input"]' 'Input'
 pub fn cmp_input<T: Feed, U: Feed>(a: &T::Input, b: &U::Input) -> bool
-    where T::Input: PartialEq<U::Input>
+where
+    T::Input: PartialEq<U::Input>,
 {
     a == b
 }
diff --git a/src/test/rustdoc/doc-assoc-item.rs b/src/test/rustdoc/doc-assoc-item.rs
index 4f15418650c2d..eaaed35360c32 100644
--- a/src/test/rustdoc/doc-assoc-item.rs
+++ b/src/test/rustdoc/doc-assoc-item.rs
@@ -8,11 +8,11 @@ pub trait Bar {
     fn foo(foo: Self::Fuu);
 }
 
-// @has doc_assoc_item/struct.Foo.html '//*[@class="impl has-srclink"]' 'impl<T: Bar<Fuu = u32>> Foo<T>'
+// @has doc_assoc_item/struct.Foo.html
+// @has - '//*[@class="impl has-srclink"]' 'impl<T> Foo<T>'
+// @has - '//*[@class="impl has-srclink"]' 'where T: Bar<Fuu = u32>'
 impl<T: Bar<Fuu = u32>> Foo<T> {
     pub fn new(t: T) -> Foo<T> {
-        Foo {
-            x: t,
-        }
+        Foo { x: t }
     }
 }
diff --git a/src/test/rustdoc/doc-notable_trait.rs b/src/test/rustdoc/doc-notable_trait.rs
index 58a24b855d6e2..a426841a8f284 100644
--- a/src/test/rustdoc/doc-notable_trait.rs
+++ b/src/test/rustdoc/doc-notable_trait.rs
@@ -9,11 +9,12 @@ impl<T: SomeTrait> SomeTrait for Wrapper<T> {}
 #[doc(notable_trait)]
 pub trait SomeTrait {
     // @has doc_notable_trait/trait.SomeTrait.html
-    // @has - '//code[@class="content"]' 'impl<T: SomeTrait> SomeTrait for Wrapper<T>'
-    fn wrap_me(self) -> Wrapper<Self> where Self: Sized {
-        Wrapper {
-            inner: self,
-        }
+    // @has - '//code[@class="content"]' 'impl<T> SomeTrait for Wrapper<T>'
+    fn wrap_me(self) -> Wrapper<Self>
+    where
+        Self: Sized,
+    {
+        Wrapper { inner: self }
     }
 }
 
@@ -23,7 +24,7 @@ impl SomeTrait for SomeStruct {}
 impl SomeStruct {
     // @has doc_notable_trait/struct.SomeStruct.html
     // @has - '//code[@class="content"]' 'impl SomeTrait for SomeStruct'
-    // @has - '//code[@class="content"]' 'impl<T: SomeTrait> SomeTrait for Wrapper<T>'
+    // @has - '//code[@class="content"]' 'impl<T> SomeTrait for Wrapper<T>'
     pub fn new() -> SomeStruct {
         SomeStruct
     }
diff --git a/src/test/rustdoc/impl-parts.rs b/src/test/rustdoc/impl-parts.rs
index 249158c1a1f89..b4799271fad9d 100644
--- a/src/test/rustdoc/impl-parts.rs
+++ b/src/test/rustdoc/impl-parts.rs
@@ -3,10 +3,12 @@
 
 pub auto trait AnAutoTrait {}
 
-pub struct Foo<T> { field: T }
+pub struct Foo<T> {
+    field: T,
+}
 
 // @has impl_parts/struct.Foo.html '//*[@class="impl has-srclink"]//h3[@class="code-header in-band"]' \
-//     "impl<T: Clone> !AnAutoTrait for Foo<T> where T: Sync,"
+//     "impl<T> !AnAutoTrait for Foo<T> where T: Clone, T: Sync,"
 // @has impl_parts/trait.AnAutoTrait.html '//*[@class="item-list"]//h3[@class="code-header in-band"]' \
-//     "impl<T: Clone> !AnAutoTrait for Foo<T> where T: Sync,"
+//     "impl<T> !AnAutoTrait for Foo<T> where T: Clone, T: Sync,"
 impl<T: Clone> !AnAutoTrait for Foo<T> where T: Sync {}
diff --git a/src/test/rustdoc/issue-20727-4.rs b/src/test/rustdoc/issue-20727-4.rs
index 84fc6f94a265a..87fe5705d84e3 100644
--- a/src/test/rustdoc/issue-20727-4.rs
+++ b/src/test/rustdoc/issue-20727-4.rs
@@ -5,7 +5,7 @@ extern crate issue_20727;
 
 // @has issue_20727_4/trait.Index.html
 pub trait Index<Idx: ?Sized> {
-    // @has - '//*[@class="rust trait"]' 'trait Index<Idx: ?Sized> {'
+    // @has - '//*[@class="rust trait"]' 'trait Index<Idx> where Idx: ?Sized, {'
     // @has - '//*[@class="rust trait"]' 'type Output: ?Sized'
     type Output: ?Sized;
 
@@ -17,7 +17,7 @@ pub trait Index<Idx: ?Sized> {
 // @has issue_20727_4/trait.IndexMut.html
 pub trait IndexMut<Idx: ?Sized>: Index<Idx> {
     // @has - '//*[@class="rust trait"]' \
-    //        'trait IndexMut<Idx: ?Sized>: Index<Idx> {'
+    //        'trait IndexMut<Idx>: Index<Idx> where Idx: ?Sized, {'
     // @has - '//*[@class="rust trait"]' \
     //        'fn index_mut(&mut self, index: Idx) -> &mut Self::Output;'
     fn index_mut(&mut self, index: Idx) -> &mut Self::Output;
diff --git a/src/test/rustdoc/normalize-assoc-item.rs b/src/test/rustdoc/normalize-assoc-item.rs
index ad1a868ee32b8..cd020739c1847 100644
--- a/src/test/rustdoc/normalize-assoc-item.rs
+++ b/src/test/rustdoc/normalize-assoc-item.rs
@@ -36,10 +36,10 @@ impl<Inner: Trait> Trait for Generic<Inner> {
 // These can't be normalized because they depend on a generic parameter.
 // However the user can choose whether the text should be displayed as `Inner::X` or `<Inner as Trait>::X`.
 
-// @has 'normalize_assoc_item/struct.Unknown.html' '//pre[@class="rust struct"]' 'pub struct Unknown<Inner: Trait>(pub <Inner as Trait>::X);'
+// @has 'normalize_assoc_item/struct.Unknown.html' '//pre[@class="rust struct"]' 'pub struct Unknown<Inner>(pub <Inner as Trait>::X) where Inner: Trait;'
 pub struct Unknown<Inner: Trait>(pub <Inner as Trait>::X);
 
-// @has 'normalize_assoc_item/struct.Unknown2.html' '//pre[@class="rust struct"]' 'pub struct Unknown2<Inner: Trait>(pub Inner::X);'
+// @has 'normalize_assoc_item/struct.Unknown2.html' '//pre[@class="rust struct"]' 'pub struct Unknown2<Inner>(pub Inner::X) where Inner: Trait;'
 pub struct Unknown2<Inner: Trait>(pub Inner::X);
 
 trait Lifetimes<'a> {
diff --git a/src/test/rustdoc/primitive-tuple-variadic.rs b/src/test/rustdoc/primitive-tuple-variadic.rs
index 4fd6254f6740d..62af89ce350e0 100644
--- a/src/test/rustdoc/primitive-tuple-variadic.rs
+++ b/src/test/rustdoc/primitive-tuple-variadic.rs
@@ -13,6 +13,7 @@ impl<T> Foo for (T,) {}
 pub trait Bar {}
 
 // @has foo/trait.Bar.html
-// @has - '//section[@id="impl-Bar-for-(U%2C)"]/h3' 'impl<U: Foo> Bar for (U₁, U₂, …, Uₙ)'
+// @has - '//section[@id="impl-Bar-for-(U%2C)"]/h3' 'impl<U> Bar for (U₁, U₂, …, Uₙ)'
+// @has - '//section[@id="impl-Bar-for-(U%2C)"]/h3' 'where U: Foo'
 #[doc(tuple_variadic)]
 impl<U: Foo> Bar for (U,) {}
diff --git a/src/test/rustdoc/rfc-2632-const-trait-impl.rs b/src/test/rustdoc/rfc-2632-const-trait-impl.rs
index ec70a69ff1060..8e16c880a310d 100644
--- a/src/test/rustdoc/rfc-2632-const-trait-impl.rs
+++ b/src/test/rustdoc/rfc-2632-const-trait-impl.rs
@@ -13,13 +13,11 @@ use std::marker::Destruct;
 pub struct S<T>(T);
 
 // @!has foo/trait.Tr.html '//pre[@class="rust trait"]/code/a[@class="trait"]' '~const'
-// @has - '//pre[@class="rust trait"]/code/a[@class="trait"]' 'Clone'
 // @!has - '//pre[@class="rust trait"]/code/span[@class="where"]' '~const'
 // @has - '//pre[@class="rust trait"]/code/span[@class="where"]' ': Clone'
 #[const_trait]
 pub trait Tr<T> {
     // @!has - '//div[@id="method.a"]/h4[@class="code-header"]' '~const'
-    // @has - '//div[@id="method.a"]/h4[@class="code-header"]/a[@class="trait"]' 'Clone'
     // @!has - '//div[@id="method.a"]/h4[@class="code-header"]/span[@class="where"]' '~const'
     // @has - '//div[@id="method.a"]/h4[@class="code-header"]/span[@class="where fmt-newline"]' ': Clone'
     fn a<A: ~const Clone + ~const Destruct>()
@@ -30,9 +28,9 @@ pub trait Tr<T> {
 }
 
 // @!has - '//section[@id="impl-Tr%3CT%3E"]/h3[@class="code-header in-band"]' '~const'
-// @has - '//section[@id="impl-Tr%3CT%3E"]/h3[@class="code-header in-band"]/a[@class="trait"]' 'Clone'
 // @!has - '//section[@id="impl-Tr%3CT%3E"]/h3[@class="code-header in-band"]/span[@class="where"]' '~const'
-// @has - '//section[@id="impl-Tr%3CT%3E"]/h3[@class="code-header in-band"]/span[@class="where fmt-newline"]' ': Clone'
+// @has - '//section[@id="impl-Tr%3CT%3E"]/h3[@class="code-header in-band"]/span[@class="where fmt-newline"]/a[@class="trait"]' 'Clone'
+// @!has - '//section[@id="impl-Tr%3CT%3E"]/h3[@class="code-header in-band"]/span[@class="where fmt-newline"]/a[@class="trait"]' 'Destruct'
 impl<T: ~const Clone + ~const Destruct> const Tr<T> for T
 where
     Option<T>: ~const Clone + ~const Destruct,
@@ -45,8 +43,9 @@ where
 }
 
 // @!has foo/fn.foo.html '//pre[@class="rust fn"]/code/a[@class="trait"]' '~const'
-// @has - '//pre[@class="rust fn"]/code/a[@class="trait"]' 'Clone'
 // @!has - '//pre[@class="rust fn"]/code/span[@class="where fmt-newline"]' '~const'
+// @has - '//pre[@class="rust fn"]/code/span[@class="where fmt-newline"]/a[@class="trait"]' 'Clone'
+// @!has - '//pre[@class="rust fn"]/code/span[@class="where fmt-newline"]/a[@class="trait"]' 'Destruct'
 // @has - '//pre[@class="rust fn"]/code/span[@class="where fmt-newline"]' ': Clone'
 pub const fn foo<F: ~const Clone + ~const Destruct>()
 where
@@ -57,9 +56,9 @@ where
 
 impl<T> S<T> {
     // @!has foo/struct.S.html '//section[@id="method.foo"]/h4[@class="code-header"]' '~const'
-    // @has - '//section[@id="method.foo"]/h4[@class="code-header"]/a[@class="trait"]' 'Clone'
     // @!has - '//section[@id="method.foo"]/h4[@class="code-header"]/span[@class="where"]' '~const'
-    // @has - '//section[@id="method.foo"]/h4[@class="code-header"]/span[@class="where fmt-newline"]' ': Clone'
+    // @has - '//section[@id="method.foo"]/h4[@class="code-header"]/span[@class="where fmt-newline"]/a[@class="trait"]' 'Clone'
+    // @!has - '//section[@id="method.foo"]/h4[@class="code-header"]/span[@class="where fmt-newline"]/a[@class="trait"]' 'Destruct'
     pub const fn foo<B: ~const Clone + ~const Destruct>()
     where
         B: ~const Clone + ~const Destruct,
diff --git a/src/test/rustdoc/synthetic_auto/complex.rs b/src/test/rustdoc/synthetic_auto/complex.rs
index f9017b90caee7..c437cbb1c9f75 100644
--- a/src/test/rustdoc/synthetic_auto/complex.rs
+++ b/src/test/rustdoc/synthetic_auto/complex.rs
@@ -21,16 +21,12 @@ mod foo {
 
 // @has complex/struct.NotOuter.html
 // @has - '//*[@id="synthetic-implementations-list"]//*[@class="impl has-srclink"]//h3[@class="code-header in-band"]' \
-// "impl<'a, T, K: ?Sized> Send for Outer<'a, T, K> where K: for<'b> Fn((&'b bool, &'a u8)) \
+// "impl<'a, T, K> Send for Outer<'a, T, K> where K: ?Sized + for<'b> Fn((&'b bool, &'a u8)) \
 // -> &'b i8, T: MyTrait<'a>, <T as MyTrait<'a>>::MyItem: Copy, 'a: 'static"
 
 pub use foo::{Foo, Inner as NotInner, MyTrait as NotMyTrait, Outer as NotOuter};
 
-unsafe impl<T> Send for Foo<T>
-where
-    T: NotMyTrait<'static>,
-{
-}
+unsafe impl<T> Send for Foo<T> where T: NotMyTrait<'static> {}
 
 unsafe impl<'a, Q, R: ?Sized> Send for NotInner<'a, Q, R>
 where
diff --git a/src/test/rustdoc/where-sized.rs b/src/test/rustdoc/where-sized.rs
index fe7cad8c3ef84..3b36536ae3b81 100644
--- a/src/test/rustdoc/where-sized.rs
+++ b/src/test/rustdoc/where-sized.rs
@@ -1,6 +1,11 @@
 #![crate_name = "foo"]
 
 // @has foo/fn.foo.html
-// @has - '//*[@class="rust fn"]' 'pub fn foo<X, Y: ?Sized>(_: &X)'
-// @has - '//*[@class="rust fn"]' 'where X: ?Sized,'
-pub fn foo<X, Y: ?Sized>(_: &X) where X: ?Sized {}
+// @has - '//*[@class="rust fn"]' 'pub fn foo<X, Y>(_: &X)'
+// @has - '//*[@class="rust fn"]' 'where Y: ?Sized,'
+// @has - '//*[@class="rust fn"]' 'X: ?Sized,'
+pub fn foo<X, Y: ?Sized>(_: &X)
+where
+    X: ?Sized,
+{
+}