rustdoc

Author: oli-obk

src/librustdoc/clean/auto_trait.rs

@@ -40,7 +40,10 @@ impl<'a, 'tcx> AutoTraitFinder<'a, 'tcx> {
         discard_positive_impl: bool,
     ) -> Option<Item> {
         let tcx = self.cx.tcx;
-        let trait_ref = ty::TraitRef { def_id: trait_def_id, substs: tcx.mk_substs_trait(ty, &[]) };
+        let trait_ref = ty::TraitRef {
+            def_id: trait_def_id,
+            substs: tcx.mk_substs_trait(ty, &[], ty::ConstnessArg::Not),
+        };
         if !self.cx.generated_synthetics.insert((ty, trait_def_id)) {
             debug!("get_auto_trait_impl_for({:?}): already generated, aborting", trait_ref);
             return None;
@@ -625,6 +628,7 @@ impl<'a, 'tcx> AutoTraitFinder<'a, 'tcx> {
                     }
                 }
                 GenericParamDefKind::Lifetime { .. } => {}
+                GenericParamDefKind::Constness => {}
                 GenericParamDefKind::Const { ref mut default, .. } => {
                     // We never want something like `impl<const N: usize = 10>`
                     default.take();

src/librustdoc/clean/mod.rs

@@ -308,7 +308,7 @@ impl<'tcx> Clean<'tcx, Option<WherePredicate>> for ty::Predicate<'tcx> {
 impl<'tcx> Clean<'tcx, Option<WherePredicate>> for ty::PolyTraitPredicate<'tcx> {
     fn clean(&self, cx: &mut DocContext<'tcx>) -> Option<WherePredicate> {
         // `T: ~const Destruct` is hidden because `T: Destruct` is a no-op.
-        if self.skip_binder().constness == ty::BoundConstness::ConstIfConst
+        if self.skip_binder().constness() != ty::ConstnessArg::Not
             && Some(self.skip_binder().def_id()) == cx.tcx.lang_items().destruct_trait()
         {
             return None;
@@ -439,6 +439,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::Constness => (self.name, GenericParamDefKind::Constness),
             ty::GenericParamDefKind::Lifetime => {
                 (self.name, GenericParamDefKind::Lifetime { outlives: vec![] })
             }
@@ -561,6 +562,7 @@ impl<'tcx> Clean<'tcx, Generics> for hir::Generics<'tcx> {
             .map(|param| {
                 let param = clean_generic_param(cx, Some(self), param);
                 match param.kind {
+                    GenericParamDefKind::Constness => unreachable!(),
                     GenericParamDefKind::Lifetime { .. } => unreachable!(),
                     GenericParamDefKind::Type { did, ref bounds, .. } => {
                         cx.impl_trait_bounds.insert(did.into(), bounds.clone());
@@ -594,6 +596,7 @@ impl<'tcx> Clean<'tcx, Generics> for hir::Generics<'tcx> {
                     if bounds.is_empty() {
                         for param in &mut generics.params {
                             match param.kind {
+                                GenericParamDefKind::Constness => {}
                                 GenericParamDefKind::Lifetime { .. } => {}
                                 GenericParamDefKind::Type { bounds: ref mut ty_bounds, .. } => {
                                     if &param.name == name {
@@ -642,6 +645,7 @@ fn clean_ty_generics<'tcx>(
                 }
                 Some(param.clean(cx))
             }
+            ty::GenericParamDefKind::Constness => None,
             ty::GenericParamDefKind::Const { .. } => Some(param.clean(cx)),
         })
         .collect::<Vec<GenericParamDef>>();

src/librustdoc/clean/types.rs

@@ -1362,6 +1362,7 @@ impl WherePredicate {
 
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub(crate) enum GenericParamDefKind {
+    Constness,
     Lifetime { outlives: Vec<Lifetime> },
     Type { did: DefId, bounds: Vec<GenericBound>, default: Option<Box<Type>>, synthetic: bool },
     Const { did: DefId, ty: Box<Type>, default: Option<Box<String>> },
@@ -1386,7 +1387,9 @@ rustc_data_structures::static_assert_size!(GenericParamDef, 56);
 impl GenericParamDef {
     pub(crate) fn is_synthetic_type_param(&self) -> bool {
         match self.kind {
-            GenericParamDefKind::Lifetime { .. } | GenericParamDefKind::Const { .. } => false,
+            GenericParamDefKind::Constness
+            | GenericParamDefKind::Lifetime { .. }
+            | GenericParamDefKind::Const { .. } => false,
             GenericParamDefKind::Type { synthetic, .. } => synthetic,
         }
     }

src/librustdoc/clean/utils.rs

@@ -84,6 +84,7 @@ pub(crate) fn substs_to_args<'tcx>(
     let mut ret_val =
         Vec::with_capacity(substs.len().saturating_sub(if skip_first { 1 } else { 0 }));
     ret_val.extend(substs.iter().filter_map(|kind| match kind.unpack() {
+        GenericArgKind::Constness(_) => None,
         GenericArgKind::Lifetime(lt) => {
             Some(GenericArg::Lifetime(lt.clean(cx).unwrap_or(Lifetime::elided())))
         }

src/librustdoc/html/format.rs

@@ -190,6 +190,7 @@ impl clean::GenericParamDef {
         cx: &'a Context<'tcx>,
     ) -> impl fmt::Display + 'a + Captures<'tcx> {
         display_fn(move |f| match &self.kind {
+            clean::GenericParamDefKind::Constness => Ok(()),
             clean::GenericParamDefKind::Lifetime { outlives } => {
                 write!(f, "{}", self.name)?;
 

src/librustdoc/json/conversions.rs

@@ -363,6 +363,7 @@ impl FromWithTcx<clean::GenericParamDefKind> for GenericParamDefKind {
                 type_: (*ty).into_tcx(tcx),
                 default: default.map(|x| *x),
             },
+            Constness => GenericParamDefKind::Constness,
         }
     }
 }

src/rustdoc-json-types/lib.rs

@@ -382,6 +382,7 @@ pub enum GenericParamDefKind {
         type_: Type,
         default: Option<String>,
     },
+    Constness,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]