Filter out trait predicate in compare_predicate_entailment

Author: tmandry

src/librustc/traits/select.rs

@@ -1164,11 +1164,28 @@ impl<'cx, 'gcx, 'tcx> SelectionContext<'cx, 'gcx, 'tcx> {
             }
         }).collect();
 
+        debug!("winnowed to {} candidates for {:?}: {:?}",
+               candidates.len(),
+               stack,
+               candidates);
+
         // If there are STILL multiple candidate, we can further
         // reduce the list by dropping duplicates -- including
         // resolving specializations.
         if candidates.len() > 1 {
             let mut i = 0;
+            //candidates.retain(|c| {
+            //    match c.candidate {
+            //        ParamCandidate(poly_trait_ref) => {
+            //            if poly_trait_ref == stack.obligation.predicate.map_bound(|x| x.trait_ref) {
+            //                debug!("Dropping candidate (== obligation): {:?}", c);
+            //                return false;
+            //            }
+            //        }
+            //        _ => {}
+            //    }
+            //    true
+            //});
             while i < candidates.len() {
                 let is_dup =
                     (0..candidates.len())

src/librustc_typeck/check/compare_method.rs

@@ -181,7 +181,22 @@ fn compare_predicate_entailment<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
     let impl_m_generics = tcx.generics_of(impl_m.def_id);
     let trait_m_generics = tcx.generics_of(trait_m.def_id);
     let impl_m_predicates = tcx.predicates_of(impl_m.def_id);
-    let trait_m_predicates = tcx.predicates_of(trait_m.def_id);
+    let mut trait_m_predicates = tcx.predicates_of(trait_m.def_id);
+
+    if let Some(trait_def_id) = trait_m_predicates.parent {
+        trait_m_predicates.predicates.retain(|pred| {
+            match pred {
+                ty::Predicate::Trait(trait_ref) => {
+                    if trait_ref.def_id() == trait_def_id {
+                        false
+                    } else {
+                        true
+                    }
+                }
+                _ => true
+            }
+        });
+    }
 
     // Check region bounds.
     check_region_bounds_on_impl_method(tcx,
@@ -212,6 +227,8 @@ fn compare_predicate_entailment<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
     hybrid_preds.predicates
                 .extend(trait_m_predicates.instantiate_own(tcx, trait_to_skol_substs).predicates);
 
+    debug!("compare_impl_method: impl_bounds+trait_bounds={:?}", hybrid_preds);
+
     // Construct trait parameter environment and then shift it into the skolemized viewpoint.
     // The key step here is to update the caller_bounds's predicates to be
     // the new hybrid bounds we computed.