support duplicate where-bounds

Author: lcnr

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

@@ -1779,53 +1779,60 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
             return Some(BuiltinCandidate { has_nested: false });
         }
 
-        // The next highest priority is for non-global where-bounds. However, there are
-        // two additional rules here:
-        // - if there are also global where-bound which may apply, we bail with ambiguity
-        //   instead of prefering the non-global where-bound. Note that if there are
-        //   only global where-bounds, they get ignored
-        // - if there are two where-bounds which only differ in their bound vars, but are
-        //   otherwise equal, we arbitrarily prefer one of them
+        // Before we consider where-bounds, we have to deduplicate them here and also
+        // dropwhere-bounds in case the same where-bound exists without bound vars.
+        // This is necessary as elaborating super-trait bounds may result in duplicates.
+        'search_victim: loop {
+            for (i, this) in candidates.iter().enumerate() {
+                let ParamCandidate(this) = this.candidate else { continue };
+                for (j, other) in candidates.iter().enumerate() {
+                    if i == j {
+                        continue;
+                    }
+
+                    let ParamCandidate(other) = other.candidate else { continue };
+                    if this == other {
+                        candidates.remove(j);
+                        continue 'search_victim;
+                    }
+
+                    if this.skip_binder().trait_ref == other.skip_binder().trait_ref
+                        && this.skip_binder().polarity == other.skip_binder().polarity
+                        && !this.skip_binder().trait_ref.has_escaping_bound_vars()
+                    {
+                        candidates.remove(j);
+                        continue 'search_victim;
+                    }
+                }
+            }
+
+            break;
+        }
+
+        // The next highest priority is for non-global where-bounds. However, while we don't
+        // prefer global where-clauses here, we do bail with ambiguity when encountering both
+        // a global and a non-global where-clause.
         //
-        // This is fairly messy but necessary for backwards compatability, see #50825 for why
-        // we need to handle global where-bounds like this.
+        // Our handling of where-bounds is generally fairly messy but necessary for backwards
+        // compatability, see #50825 for why we need to handle global where-bounds like this.
+        let is_global = |c: ty::PolyTraitPredicate<'tcx>| c.is_global() && !c.has_bound_vars();
         let param_candidates = candidates
             .iter()
             .filter_map(|c| if let ParamCandidate(p) = c.candidate { Some(p) } else { None });
-        let is_global = |c: ty::PolyTraitPredicate<'tcx>| c.is_global() && !c.has_bound_vars();
-        let mut has_non_global = false;
+        let mut has_global_bounds = false;
         let mut param_candidate = None;
         for c in param_candidates {
-            has_non_global |= !is_global(c);
-            let has_fewer_bound_vars =
-                |this: ty::PolyTraitPredicate<'tcx>, other: ty::PolyTraitPredicate<'tcx>| {
-                    this.skip_binder().trait_ref == other.skip_binder().trait_ref
-                        && this.skip_binder().polarity == other.skip_binder().polarity
-                        && !this.skip_binder().trait_ref.has_escaping_bound_vars()
-                };
-            if let Some(prev) = param_candidate.replace(c) {
-                if has_fewer_bound_vars(c, prev) {
-                    // Ok, prefer `c` over the previous entry
-                } else if has_fewer_bound_vars(prev, c) {
-                    // Ok, keep `prev` instead of the new entry
-                    param_candidate = Some(prev);
-                } else {
-                    // Ambiguity, two potentially different where-clauses
-                    return None;
-                }
+            if is_global(c) {
+                has_global_bounds = true;
+            } else if param_candidate.replace(c).is_some() {
+                // Ambiguity, two potentially different where-clauses
+                return None;
             }
         }
         if let Some(predicate) = param_candidate {
-            if is_global(predicate) {
-                // If we only have global where-bounds, we prefer
-                // impls over them, otherwise we bail with ambiguity.
-                //
-                // This is only reachable if there's one higher-ranked
-                // and one non-higher ranked version of a global
-                // where-clause.
-                if has_non_global {
-                    return None;
-                }
+            // Ambiguity, a global and a non-global where-bound.
+            if has_global_bounds {
+                return None;
             } else {
                 return Some(ParamCandidate(predicate));
             }
@@ -1912,15 +1919,19 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
             }
         }
 
-        // Also try ignoring all global where-bounds and check whether we end
-        // with a unique candidate in this case.
-        let mut not_a_global_where_bound = candidates
-            .into_iter()
-            .filter(|c| !matches!(c.candidate, ParamCandidate(p) if is_global(p)));
-        not_a_global_where_bound
-            .next()
-            .map(|c| c.candidate)
-            .filter(|_| not_a_global_where_bound.next().is_none())
+        if candidates.len() == 1 {
+            Some(candidates.pop().unwrap().candidate)
+        } else {
+            // Also try ignoring all global where-bounds and check whether we end
+            // with a unique candidate in this case.
+            let mut not_a_global_where_bound = candidates
+                .into_iter()
+                .filter(|c| !matches!(c.candidate, ParamCandidate(p) if is_global(p)));
+            not_a_global_where_bound
+                .next()
+                .map(|c| c.candidate)
+                .filter(|_| not_a_global_where_bound.next().is_none())
+        }
     }
 
     fn prefer_lhs_over_victim(