Equate candidates modulo constness

Author: fee1-dead

compiler/rustc_infer/src/traits/project.rs

@@ -228,6 +228,7 @@ impl<'tcx> ProjectionCache<'_, 'tcx> {
     /// type information (in which case, the "fully resolved" key will
     /// be different).
     pub fn ambiguous(&mut self, key: ProjectionCacheKey<'tcx>) {
+        debug!(?key, "ambiguous");
         let fresh = self.map().insert(key, ProjectionCacheEntry::Ambiguous);
         assert!(!fresh, "never started projecting `{:?}`", key);
     }

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

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

compiler/rustc_middle/src/ty/sty.rs

@@ -32,6 +32,8 @@ use rustc_type_ir::sty::TyKind::*;
 use rustc_type_ir::RegionKind as IrRegionKind;
 use rustc_type_ir::TyKind as IrTyKind;
 
+use super::GenericArgKind;
+
 // Re-export the `TyKind` from `rustc_type_ir` here for convenience
 #[rustc_diagnostic_item = "TyKind"]
 pub type TyKind<'tcx> = IrTyKind<TyCtxt<'tcx>>;
@@ -849,13 +851,19 @@ impl<'tcx> TraitRef<'tcx> {
     pub fn with_const(mut self, tcx: TyCtxt<'tcx>) -> Self {
         if self.constness() != ty::ConstnessArg::Const {
             self.substs = tcx.mk_substs(self.substs.iter().map(|arg| match arg.unpack() {
-                ty::subst::GenericArgKind::Constness(_) => ty::ConstnessArg::Const.into(),
+                GenericArgKind::Constness(_) => ty::ConstnessArg::Const.into(),
                 _ => arg,
             }));
         }
 
         self
     }
+
+    pub fn eq_modulo_constness(&self, other: &TraitRef<'tcx>) -> bool {
+        let f = |s: &GenericArg<'_>| !matches!(s.unpack(), GenericArgKind::Constness(_));
+        self.def_id == other.def_id
+            && self.substs.iter().filter(f).eq(other.substs.iter().filter(f))
+    }
 }
 
 pub type PolyTraitRef<'tcx> = Binder<'tcx, TraitRef<'tcx>>;
@@ -887,6 +895,11 @@ impl<'tcx> PolyTraitRef<'tcx> {
     pub fn without_const(self, tcx: TyCtxt<'tcx>) -> Self {
         self.map_bound(|tr| tr.without_const(tcx))
     }
+
+    pub fn eq_modulo_constness(&self, other: &Self) -> bool {
+        self.bound_vars() == other.bound_vars()
+            && self.skip_binder().eq_modulo_constness(other.as_ref().skip_binder())
+    }
 }
 
 /// An existential reference to a trait, where `Self` is erased.

compiler/rustc_trait_selection/src/traits/project.rs

@@ -91,7 +91,8 @@ impl<'tcx> ProjectionCandidateSet<'tcx> {
     // Returns true if the push was successful, or false if the candidate
     // was discarded -- this could be because of ambiguity, or because
     // a higher-priority candidate is already there.
-    fn push_candidate(&mut self, candidate: ProjectionCandidate<'tcx>) -> bool {
+    #[tracing::instrument(level = "debug", skip(self, tcx))]
+    fn push_candidate(&mut self, tcx: TyCtxt<'tcx>, candidate: ProjectionCandidate<'tcx>) -> bool {
         use self::ProjectionCandidate::*;
         use self::ProjectionCandidateSet::*;
 
@@ -126,6 +127,15 @@ impl<'tcx> ProjectionCandidateSet<'tcx> {
                 // clauses are the safer choice. See the comment on
                 // `select::SelectionCandidate` and #21974 for more details.
                 match (current, candidate) {
+                    // HACK(fee1-dead)
+                    // If both candidates are the same, except for the constness argument, it is not an ambiguity
+                    (ParamEnv(a), ParamEnv(b))
+                        if a.required_poly_trait_ref(tcx)
+                            .eq_modulo_constness(&b.required_poly_trait_ref(tcx))
+                            && a.term() == b.term() =>
+                    {
+                        return false;
+                    }
                     (ParamEnv(..), ParamEnv(..)) => convert_to_ambiguous = (),
                     (ParamEnv(..), _) => return false,
                     (_, ParamEnv(..)) => unreachable!(),
@@ -1365,7 +1375,7 @@ fn assemble_candidates_from_predicates<'cx, 'tcx>(
 
             match is_match {
                 ProjectionMatchesProjection::Yes => {
-                    candidate_set.push_candidate(ctor(data));
+                    candidate_set.push_candidate(infcx.tcx, ctor(data));
 
                     if potentially_unnormalized_candidates
                         && !obligation.predicate.has_infer_types_or_consts()
@@ -1635,7 +1645,7 @@ fn assemble_candidates_from_impls<'cx, 'tcx>(
         };
 
         if eligible {
-            if candidate_set.push_candidate(ProjectionCandidate::Select(impl_source)) {
+            if candidate_set.push_candidate(selcx.tcx(), ProjectionCandidate::Select(impl_source)) {
                 Ok(())
             } else {
                 Err(())

compiler/rustc_trait_selection/src/traits/select/mod.rs

@@ -1645,7 +1645,6 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             (ParamCandidate(other), ParamCandidate(victim)) => {
                 let same_except_bound_vars = other.skip_binder().trait_ref
                     == victim.skip_binder().trait_ref
-                    && other.skip_binder().constness() == victim.skip_binder().constness()
                     && other.skip_binder().polarity == victim.skip_binder().polarity
                     && !other.skip_binder().trait_ref.has_escaping_bound_vars();
                 if same_except_bound_vars {
@@ -1655,7 +1654,10 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                     // probably best characterized as a "hack", since we might prefer to just do our
                     // best to *not* create essentially duplicate candidates in the first place.
                     other.bound_vars().len() <= victim.bound_vars().len()
-                } else if other.skip_binder().trait_ref == victim.skip_binder().trait_ref
+                } else if other
+                    .skip_binder()
+                    .trait_ref
+                    .eq_modulo_constness(&victim.skip_binder().trait_ref)
                     && victim.skip_binder().constness() == ty::ConstnessArg::Not
                     && other.skip_binder().polarity == victim.skip_binder().polarity
                 {