typeck and borrowck compile

compiler/rustc_borrowck/src/diagnostics/region_name.rs

@@ -642,6 +642,7 @@ impl<'tcx> MirBorrowckCtxt<'_, 'tcx> {
                 (
                     GenericArgKind::Lifetime(_)
                     | GenericArgKind::Type(_)
+                    | GenericArgKind::Constness(_)
                     | GenericArgKind::Const(_),
                     _,
                 ) => {

compiler/rustc_borrowck/src/type_check/constraint_conversion.rs

@@ -126,7 +126,7 @@ impl<'a, 'tcx> ConstraintConversion<'a, 'tcx> {
                 .type_must_outlive(origin, t1, r2);
             }
 
-            GenericArgKind::Const(_) => {
+            GenericArgKind::Constness(_) | GenericArgKind::Const(_) => {
                 // Consts cannot outlive one another, so we
                 // don't need to handle any relations here.
             }

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -2608,7 +2608,9 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
                                 (outlives_requirements.category, outlives_requirements.blame_span),
                             ))
                         }
-                        GenericArgKind::Type(_) | GenericArgKind::Const(_) => None,
+                        GenericArgKind::Type(_)
+                        | GenericArgKind::Const(_)
+                        | GenericArgKind::Constness(_) => None,
                     }
                 })
                 .collect();

compiler/rustc_mir_transform/src/shim.rs

@@ -342,7 +342,7 @@ impl<'tcx> CloneShimBuilder<'tcx> {
         // we must subst the self_ty because it's
         // otherwise going to be TySelf and we can't index
         // or access fields of a Place of type TySelf.
-        let substs = tcx.mk_substs_trait(self_ty, &[]);
+        let substs = tcx.mk_substs_trait(self_ty, &[], ty::ConstnessArg::Not);
         let sig = tcx.bound_fn_sig(def_id).subst(tcx, substs);
         let sig = tcx.erase_late_bound_regions(sig);
         let span = tcx.def_span(def_id);
@@ -423,7 +423,7 @@ impl<'tcx> CloneShimBuilder<'tcx> {
     ) {
         let tcx = self.tcx;
 
-        let substs = tcx.mk_substs_trait(ty, &[]);
+        let substs = tcx.mk_substs_trait(ty, &[], ty::ConstnessArg::Not);
 
         // `func == Clone::clone(&ty) -> ty`
         let func_ty = tcx.mk_fn_def(self.def_id, substs);
@@ -529,7 +529,8 @@ fn build_call_shim<'tcx>(
 
         // Create substitutions for the `Self` and `Args` generic parameters of the shim body.
         let arg_tup = tcx.mk_tup(untuple_args.iter());
-        let sig_substs = tcx.mk_substs_trait(ty, &[ty::subst::GenericArg::from(arg_tup)]);
+        let sig_substs =
+            tcx.mk_substs_trait(ty, &[ty::subst::GenericArg::from(arg_tup)], ty::ConstnessArg::Not);
 
         (Some(sig_substs), Some(untuple_args))
     } else {

compiler/rustc_privacy/src/lib.rs

@@ -132,11 +132,9 @@ where
 
     fn visit_predicate(&mut self, predicate: ty::Predicate<'tcx>) -> ControlFlow<V::BreakTy> {
         match predicate.kind().skip_binder() {
-            ty::PredicateKind::Trait(ty::TraitPredicate {
-                trait_ref,
-                constness: _,
-                polarity: _,
-            }) => self.visit_trait(trait_ref),
+            ty::PredicateKind::Trait(ty::TraitPredicate { trait_ref, polarity: _ }) => {
+                self.visit_trait(trait_ref)
+            }
             ty::PredicateKind::Projection(ty::ProjectionPredicate { projection_ty, term }) => {
                 term.visit_with(self)?;
                 self.visit_projection_ty(projection_ty)
@@ -1167,7 +1165,7 @@ impl<'tcx> Visitor<'tcx> for TypePrivacyVisitor<'tcx> {
                 self.tcx.types.never,
             );
 
-            for (trait_predicate, _, _) in bounds.trait_bounds {
+            for (trait_predicate, _) in bounds.trait_bounds {
                 if self.visit_trait(trait_predicate.skip_binder()).is_break() {
                     return;
                 }

compiler/rustc_typeck/src/check/compare_method.rs

@@ -1013,7 +1013,9 @@ fn compare_generic_param_kinds<'tcx>(
             // this is exhaustive so that anyone adding new generic param kinds knows
             // to make sure this error is reported for them.
             (Const { .. }, Const { .. }) | (Type { .. }, Type { .. }) => false,
-            (Lifetime { .. }, _) | (_, Lifetime { .. }) => unreachable!(),
+            (Constness, _) | (_, Constness) | (Lifetime { .. }, _) | (_, Lifetime { .. }) => {
+                unreachable!()
+            }
         } {
             let param_impl_span = tcx.def_span(param_impl.def_id);
             let param_trait_span = tcx.def_span(param_trait.def_id);
@@ -1033,7 +1035,7 @@ fn compare_generic_param_kinds<'tcx>(
                     format!("{} const parameter of type `{}`", prefix, tcx.type_of(param.def_id))
                 }
                 Type { .. } => format!("{} type parameter", prefix),
-                Lifetime { .. } => unreachable!(),
+                Constness | Lifetime { .. } => unreachable!(),
             };
 
             let trait_header_span = tcx.def_ident_span(tcx.parent(trait_item.def_id)).unwrap();
@@ -1376,6 +1378,7 @@ pub fn check_type_bounds<'tcx>(
             })
             .into()
         }
+        GenericParamDefKind::Constness => ty::ConstnessArg::Param.into(),
     });
     let bound_vars = tcx.mk_bound_variable_kinds(bound_vars.into_iter());
     let impl_ty_substs = tcx.intern_substs(&substs);

compiler/rustc_typeck/src/impl_wf_check/min_specialization.rs

@@ -413,8 +413,7 @@ fn trait_predicate_kind<'tcx>(
             trait_ref, // TODO review specialization check
             polarity: _,
         }) => Some(tcx.trait_def(trait_ref.def_id).specialization_kind),
-        ty::PredicateKind::Trait(_)
-        | ty::PredicateKind::RegionOutlives(_)
+        ty::PredicateKind::RegionOutlives(_)
         | ty::PredicateKind::TypeOutlives(_)
         | ty::PredicateKind::Projection(_)
         | ty::PredicateKind::WellFormed(_)