More attempts to fix ICE

Author: fee1-dead

compiler/rustc_infer/src/infer/equate.rs

@@ -166,8 +166,10 @@ impl<'tcx> TypeRelation<'tcx> for Equate<'_, '_, 'tcx> {
         a: ty::ConstnessArg,
         b: ty::ConstnessArg,
     ) -> RelateResult<'tcx, ty::ConstnessArg> {
-        // TODO handle infer
-        relate::super_relate_constness(self, a, b)
+        match (a, b) {
+            (ty::ConstnessArg::Infer, x) | (x, ty::ConstnessArg::Infer) => Ok(x),
+            _ => relate::super_relate_constness(self, a, b),
+        }
     }
 }
 

compiler/rustc_middle/src/ty/context.rs

@@ -2964,6 +2964,15 @@ impl<'tcx> TyCtxt<'tcx> {
             })
         )
     }
+
+    pub fn should_have_constness(self, def_id: DefId) -> bool {
+        match self.def_kind(def_id) {
+            DefKind::Trait => true,
+            DefKind::Impl if self.constness(def_id) == hir::Constness::Const => true,
+            DefKind::AssocFn => self.should_have_constness(self.parent(def_id)),
+            _ => false,
+        }
+    }
 }
 
 impl<'tcx> TyCtxtAt<'tcx> {

compiler/rustc_middle/src/ty/generics.rs

@@ -123,6 +123,7 @@ pub struct Generics {
 
     pub has_self: bool,
     pub has_constness: bool,
+    pub parent_has_constness: bool,
     pub has_late_bound_regions: Option<Span>,
 }
 
@@ -240,6 +241,7 @@ impl<'tcx> Generics {
     }
 
     /// Returns the `ConstnessArg`
+    // TODO just use self.has_constness?
     pub fn has_constness_param(&'tcx self) -> bool {
         self.params.iter().any(|param| matches!(param.kind, ty::GenericParamDefKind::Constness))
     }
@@ -295,6 +297,15 @@ impl<'tcx> Generics {
         let own = &substs[self.parent_count..][..self.params.len()];
         if self.has_self && self.parent.is_none() { &own[1..] } else { &own }
     }
+
+    /*pub fn expected_arg_count(&self) -> std::ops::RangeInclusive<usize> {
+        self.count()
+        todo!()
+    }*/
+
+    pub fn expected_parent_count(&self) -> std::ops::RangeInclusive<usize> {
+        self.parent_count..=self.parent_count + self.parent_has_constness as usize
+    }
 }
 
 /// Bounds on generics.

compiler/rustc_middle/src/ty/print/pretty.rs

@@ -1824,11 +1824,15 @@ impl<'tcx> Printer<'tcx> for FmtPrinter<'_, 'tcx> {
                 GenericArgKind::Lifetime(r) => !r.is_erased(),
                 _ => false,
             });
-        let mut args = args.iter().cloned().filter(|arg| match arg.unpack() {
-            GenericArgKind::Lifetime(_) => print_regions,
-            GenericArgKind::Constness(_) => false,
-            _ => true,
-        }).peekable();
+        let mut args = args
+            .iter()
+            .cloned()
+            .filter(|arg| match arg.unpack() {
+                GenericArgKind::Lifetime(_) => print_regions,
+                GenericArgKind::Constness(_) => false,
+                _ => true,
+            })
+            .peekable();
 
         if args.peek().is_some() {
             if self.in_value {

compiler/rustc_middle/src/ty/subst.rs

@@ -580,8 +580,8 @@ impl<'a, 'tcx> TypeFolder<'tcx> for SubstFolder<'a, 'tcx> {
                     _ => {
                         let msg = format!(
                             "Region parameter out of range \
-                             when substituting in region {} (index={})",
-                            data.name, data.index
+                             when substituting in region {} (index={}, substs={:?})",
+                            data.name, data.index, self.substs
                         );
                         span_bug!(DUMMY_SP, "{}", msg);
                     }

compiler/rustc_typeck/src/astconv/mod.rs

@@ -376,7 +376,11 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
         // non-`Self` generic parameters.
         if generics.params.is_empty() {
             return (
-                tcx.intern_substs(&constness.map(Into::into).into_iter().collect::<Vec<_>>()),
+                tcx.intern_substs(&if let Some(ty::ConstnessArg::Const) = constness {
+                    vec![ty::ConstnessArg::Const.into()]
+                } else {
+                    vec![]
+                }),
                 arg_count,
             );
         }

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

@@ -345,7 +345,7 @@ impl<'a, 'tcx> ConfirmContext<'a, 'tcx> {
 
         // Create subst for early-bound lifetime parameters, combining
         // parameters from the type and those from the method.
-        assert_eq!(generics.parent_count, parent_substs.len());
+        assert!(generics.expected_parent_count().contains(&parent_substs.len()));
 
         struct MethodSubstsCtxt<'a, 'tcx> {
             cfcx: &'a ConfirmContext<'a, 'tcx>,

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

@@ -454,7 +454,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         };
         let def_id = method_item.def_id;
         let generics = tcx.generics_of(def_id);
-        assert_eq!(generics.params.len(), generics.has_constness as usize); // no generics except for constness
+        assert!(generics.params.len() <= generics.has_constness as usize); // no generics except for constness
 
         debug!("lookup_in_trait_adjusted: method_item={:?}", method_item);
         let mut obligations = vec![];

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

@@ -1783,9 +1783,8 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
         // method yet. So create fresh variables here for those too,
         // if there are any.
         let generics = self.tcx.generics_of(method);
-        assert_eq!(
-            substs.len(),
-            generics.parent_count as usize,
+        assert!(
+            generics.expected_parent_count().contains(&substs.len()),
             "substs: {:#?}\ngenerics: {:#?}",
             substs,
             generics

compiler/rustc_typeck/src/check/mod.rs

@@ -963,7 +963,10 @@ fn has_expected_num_generic_args<'tcx>(
 ) -> bool {
     trait_did.map_or(true, |trait_did| {
         let generics = tcx.generics_of(trait_did);
-        generics.count() == expected + if generics.has_self { 1 } else { 0 } + if generics.has_constness { 1 } else { 0 }
+        generics.count()
+            == expected
+                + if generics.has_self { 1 } else { 0 }
+                + if generics.has_constness { 1 } else { 0 }
     })
 }
 

compiler/rustc_typeck/src/collect.rs

@@ -1519,6 +1519,7 @@ fn generics_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::Generics {
                         param_def_id_to_index,
                         has_self: generics.has_self,
                         has_constness: generics.has_constness,
+                        parent_has_constness: generics.parent_has_constness,
                         has_late_bound_regions: generics.has_late_bound_regions,
                     };
                 }
@@ -1624,9 +1625,7 @@ fn generics_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::Generics {
     };
 
     let has_self = opt_self.is_some();
-    let has_constness = tcx.has_attr(def_id, sym::const_trait)
-        || (tcx.def_kind(def_id) == DefKind::Impl
-            && tcx.impl_constness(def_id) == hir::Constness::Const);
+    let has_constness = tcx.should_have_constness(def_id);
     let mut parent_has_self = false;
     let mut parent_has_constness = false;
     let mut own_start = has_self as u32;
@@ -1783,6 +1782,7 @@ fn generics_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::Generics {
         param_def_id_to_index,
         has_self: has_self || parent_has_self,
         has_constness: has_constness || parent_has_constness,
+        parent_has_constness: parent_has_constness,
         has_late_bound_regions: has_late_bound_regions(tcx, node),
     };
     trace!("{:#?}", generics);

library/core/src/ops/function.rs

@@ -237,6 +237,7 @@ pub trait FnMut<Args>: FnOnce<Args> {
 )]
 #[fundamental] // so that regex can rely that `&str: !FnMut`
 #[must_use = "closures are lazy and do nothing unless called"]
+#[cfg_attr(not(bootstrap), const_trait)]
 pub trait FnOnce<Args> {
     /// The returned type after the call operator is used.
     #[lang = "fn_once_output"]

library/core/src/slice/index.rs

@@ -152,6 +152,7 @@ mod private_slice_index {
     message = "the type `{T}` cannot be indexed by `{Self}`",
     label = "slice indices are of type `usize` or ranges of `usize`"
 )]
+#[cfg_attr(not(bootstrap), const_trait)]
 pub unsafe trait SliceIndex<T: ?Sized>: private_slice_index::Sealed {
     /// The output type returned by methods.
     #[stable(feature = "slice_get_slice", since = "1.28.0")]