Allow the constness argument anywhere in the generics list

Author: oli-obk

compiler/rustc_middle/src/ty/generics.rs

@@ -241,9 +241,7 @@ impl<'tcx> Generics {
 
     /// Returns the `ConstnessArg`
     pub fn has_constness_param(&'tcx self) -> bool {
-        self.params
-            .last()
-            .map_or(false, |param| matches!(param.kind, ty::GenericParamDefKind::Constness))
+        self.params.iter().any(|param| matches!(param.kind, ty::GenericParamDefKind::Constness))
     }
 
     /// Returns `true` if `params` has `impl Trait`.

compiler/rustc_middle/src/ty/sty.rs

@@ -816,33 +816,32 @@ impl<'tcx> TraitRef<'tcx> {
     }
 
     pub fn constness(self) -> ty::ConstnessArg {
-        match self.substs.last().expect("constness").unpack() {
-            ty::subst::GenericArgKind::Constness(constness) => constness,
-            _ => ty::ConstnessArg::Not,
+        for arg in self.substs.iter() {
+            match arg.unpack() {
+                ty::subst::GenericArgKind::Constness(constness) => return constness,
+                _ => {}
+            }
         }
+        ty::ConstnessArg::Not
     }
 
     pub fn without_const(mut self, tcx: TyCtxt<'tcx>) -> Self {
         if self.constness().is_const() {
-            self.substs = tcx.mk_substs(
-                self.substs
-                    .iter()
-                    .take(self.substs.len() - 1)
-                    .chain(Some(ty::ConstnessArg::Not.into())),
-            );
+            self.substs = tcx.mk_substs(self.substs.iter().map(|arg| match arg.unpack() {
+                ty::subst::GenericArgKind::Constness(_) => ty::ConstnessArg::Not.into(),
+                _ => arg,
+            }));
         }
 
         self
     }
 
     pub fn with_const(mut self, tcx: TyCtxt<'tcx>) -> Self {
         if !self.constness().is_const() {
-            self.substs = tcx.mk_substs(
-                self.substs
-                    .iter()
-                    .take(self.substs.len() - 1)
-                    .chain(Some(ty::ConstnessArg::Required.into())),
-            );
+            self.substs = tcx.mk_substs(self.substs.iter().map(|arg| match arg.unpack() {
+                ty::subst::GenericArgKind::Constness(_) => ty::ConstnessArg::Required.into(),
+                _ => arg,
+            }));
         }
 
         self

compiler/rustc_typeck/src/check/method/probe.rs

@@ -1784,9 +1784,9 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
         assert_eq!(
             substs.len(),
             generics.parent_count as usize,
-            "{:#?} vs {:#?}",
+            "substs: {:#?}\ngenerics: {:#?}",
             substs,
-            generics.params
+            generics
         );
 
         let xform_fn_sig = if generics.params.is_empty() {

compiler/rustc_typeck/src/collect.rs

@@ -1633,10 +1633,9 @@ fn generics_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::Generics {
         assert!(!has_self);
         parent_has_self = generics.has_self;
         own_start = generics.count() as u32;
-        // if parent has constness param, we do not inherit it from the parent, and we
-        // get it in the end instead of the middle.
+        // if the parent has a constness param, we inherit it from the parent
         parent_has_constness = generics.has_constness;
-        generics.parent_count + generics.params.len() - parent_has_constness as usize
+        generics.parent_count + generics.params.len()
     });
 
     let mut params: Vec<_> = Vec::with_capacity(ast_generics.params.len() + has_self as usize);
@@ -1762,7 +1761,7 @@ fn generics_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::Generics {
         }
     }
 
-    if has_constness || parent_has_constness {
+    if has_constness && !parent_has_constness {
         trace!("adding constness param");
         params.push(ty::GenericParamDef {
             name: Symbol::intern("<constness>"),