attempt to refactor the *** thing

Author: Ariel Ben-Yehuda

src/librustc/middle/traits/select.rs

@@ -645,6 +645,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
         }
 
         let mut candidates = candidate_set.vec;
+        let candidate;
 
         debug!("assembled {} candidates for {}: {}",
                candidates.len(),
@@ -678,39 +679,6 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             candidates.retain(|c| self.winnow_candidate(stack, c).may_apply())
         }
 
-        // If the predicate is fully known, there should be only one
-        // matching candidate by coherence. However, there may also be
-        // other candidates from impls (see the doc-comment for
-        // Candidate). Pick one candidate to use. This is somewhat
-        // wrong around regions.
-        if candidates.len() > 1 && !stack.obligation.predicate.has_ty_infer() {
-            let mut i = 0;
-            while i < candidates.len() {
-                let is_dup =
-                    (0..candidates.len())
-                    .filter(|&j| i != j)
-                    .any(|j| self.candidate_should_be_dropped_in_favor_of(&candidates[i],
-                                                                          &candidates[j]));
-                if is_dup {
-                    debug!("Dropping candidate #{}/{}: {}",
-                           i, candidates.len(), candidates[i].repr(self.tcx()));
-                    candidates.swap_remove(i);
-                } else {
-                    debug!("Retaining candidate #{}/{}: {}",
-                           i, candidates.len(), candidates[i].repr(self.tcx()));
-                    i += 1;
-                }
-            }
-        }
-
-        // If there are *STILL* multiple candidates, give up and
-        // report ambiguity.
-        if candidates.len() > 1 {
-            debug!("multiple matches, ambig");
-            return Ok(None);
-        }
-
-
         // If there are *NO* candidates, that there are no impls --
         // that we know of, anyway. Note that in the case where there
         // are unbound type variables within the obligation, it might
@@ -724,22 +692,65 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             return Err(Unimplemented);
         }
 
-        // Just one candidate left.
-        let candidate = candidates.pop().unwrap();
-
-        match candidate {
-            ImplCandidate(def_id) => {
-                match ty::trait_impl_polarity(self.tcx(), def_id) {
-                    Some(ast::ImplPolarity::Negative) => return Err(Unimplemented),
-                    _ => {}
+        let candidate;
+        if let Some(c) = self.find_sure_clause(&stack.obligation, &candidates) {
+            // If we have a projection/where-clause candidate that
+            // surely matches, go ahead and pick it. There can be other
+            // candidates that match, but the clause will transform into
+            // the right one at monomorphization-time.
+            candidate = candidates.swap_remove(c)
+        } else {
+            candidate = candidates.pop().unwrap();
+
+            // If there are *still* multiple distinct candidates,
+            // report ambiguity.
+            for c in candidates {
+                if c != candidate {
+                    debug!("multiple matches, ambig");
+                    return Ok(None);
                 }
             }
-            _ => {}
+        }
+
+        if let ImplCandidate(def_id) = candidate {
+            let polarity = ty::trait_impl_polarity(self.tcx(), def_id);
+            if polarity == Some(ast::ImplPolarity::Negative) {
+                return Err(Unimplemented);
+            }
         }
 
         Ok(Some(candidate))
     }
 
+    /// Return the index of a where clause/projection that surely matches out
+    /// of cs, if any exists.
+    ///
+    /// This is somewhat wrong as it does not take regions into account.
+    fn find_sure_candidate(&self,
+                           obligation: &TraitObligation<'tcx>,
+                           cs: &[SelectionCandidate<'tcx>])
+                           -> Option<usize>
+    {
+        let sure_projection = None;
+        let sure_impl = None;
+        for (i,candidate) in cs.iter().enumerate() {
+            match candidate {
+                &ErrorCandidate => return None,
+                &ProjectionCandidate => {
+//                    if let Ok(_) = self.match_where_
+                },
+                &ImplCandidate(iid) => {
+                    if let Ok(..) = self.infcx.can_equate(
+                        &obligation.predicate.trait_ref.0,
+                        &
+                },
+                _ => {}
+            }
+        }
+
+        sure_projection.or(sure_impl)
+    }
+
     fn pick_candidate_cache(&self) -> &SelectionCache<'tcx> {
         // If there are any where-clauses in scope, then we always use
         // a cache local to this particular scope. Otherwise, we