Add some helpful logging.

This commit adds some helpful logging statements to help work out what
is going on.

Author: davidtwco

src/librustc_typeck/check/method/probe.rs

@@ -491,6 +491,7 @@ impl<'a, 'gcx, 'tcx> ProbeContext<'a, 'gcx, 'tcx> {
     }
 
     fn reset(&mut self) {
+        debug!("reset");
         self.inherent_candidates.clear();
         self.extension_candidates.clear();
         self.impl_dups.clear();
@@ -505,13 +506,16 @@ impl<'a, 'gcx, 'tcx> ProbeContext<'a, 'gcx, 'tcx> {
                       candidate: Candidate<'tcx>,
                       is_inherent: bool)
     {
+        debug!("push_candidate: candidate={:?} is_inherent={:?}", candidate, is_inherent);
         let is_accessible = if let Some(name) = self.method_name {
             let item = candidate.item;
             let def_scope = self.tcx.adjust_ident(name, item.container.id(), self.body_id).1;
             item.vis.is_accessible_from(def_scope, self.tcx)
         } else {
             true
         };
+
+        debug!("push_candidate: is_accessible={:?}", is_accessible);
         if is_accessible {
             if is_inherent {
                 self.inherent_candidates.push(candidate);
@@ -847,6 +851,7 @@ impl<'a, 'gcx, 'tcx> ProbeContext<'a, 'gcx, 'tcx> {
     }
 
     fn assemble_extension_candidates_for_all_traits(&mut self) -> Result<(), MethodError<'tcx>> {
+        debug!("assemble_extension_candidates_for_all_traits");
         let mut duplicates = FxHashSet::default();
         for trait_info in suggest::all_traits(self.tcx) {
             if duplicates.insert(trait_info.def_id) {
@@ -939,6 +944,7 @@ impl<'a, 'gcx, 'tcx> ProbeContext<'a, 'gcx, 'tcx> {
     // THE ACTUAL SEARCH
 
     fn pick(mut self) -> PickResult<'tcx> {
+        debug!("pick: method_name={:?}", self.method_name);
         assert!(self.method_name.is_some());
 
         if let Some(r) = self.pick_core() {
@@ -958,9 +964,13 @@ impl<'a, 'gcx, 'tcx> ProbeContext<'a, 'gcx, 'tcx> {
         self.assemble_extension_candidates_for_all_traits()?;
 
         let out_of_scope_traits = match self.pick_core() {
-            Some(Ok(p)) => vec![p.item.container.id()],
+            Some(Ok(p)) => {
+                debug!("pick: (ok) p={:?}", p);
+                vec![p.item.container.id()]
+            },
             //Some(Ok(p)) => p.iter().map(|p| p.item.container().id()).collect(),
             Some(Err(MethodError::Ambiguity(v))) => {
+                debug!("pick: (ambiguity) v={:?}", v);
                 v.into_iter()
                     .map(|source| {
                         match source {
@@ -979,6 +989,7 @@ impl<'a, 'gcx, 'tcx> ProbeContext<'a, 'gcx, 'tcx> {
                     .collect()
             }
             Some(Err(MethodError::NoMatch(NoMatchData { out_of_scope_traits: others, .. }))) => {
+                debug!("pick: (no match) others={:?}", others);
                 assert!(others.is_empty());
                 vec![]
             }
@@ -990,6 +1001,7 @@ impl<'a, 'gcx, 'tcx> ProbeContext<'a, 'gcx, 'tcx> {
         }
         let lev_candidate = self.probe_for_lev_candidate()?;
 
+        debug!("pick: out_of_scope_traits={:?}", out_of_scope_traits);
         Err(MethodError::NoMatch(NoMatchData::new(static_candidates,
                                                   unsatisfied_predicates,
                                                   out_of_scope_traits,
@@ -1302,13 +1314,20 @@ impl<'a, 'gcx, 'tcx> ProbeContext<'a, 'gcx, 'tcx> {
                     let predicate = trait_ref.to_predicate();
                     let obligation =
                         traits::Obligation::new(cause, self.param_env, predicate);
+                    debug!(
+                        "consider_probe: predicate={:?} obligation={:?} trait_ref={:?}",
+                        predicate, obligation, trait_ref
+                    );
                     if !self.predicate_may_hold(&obligation) {
+                        debug!("consider_probe: predicate did not hold");
                         if self.probe(|_| self.select_trait_candidate(trait_ref).is_err()) {
+                            debug!("consider_probe: select_trait_candidate.is_err=true");
                             // This candidate's primary obligation doesn't even
                             // select - don't bother registering anything in
                             // `potentially_unsatisfied_predicates`.
                             return ProbeResult::NoMatch;
                         } else {
+                            debug!("consider_probe: nested subobligation");
                             // Some nested subobligation of this predicate
                             // failed.
                             //

src/librustc_typeck/check/method/suggest.rs

@@ -430,15 +430,10 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
                                       bound_list));
                 }
 
-                if actual.is_numeric() && actual.is_fresh() {
-
-                } else {
-                    self.suggest_traits_to_import(&mut err,
-                                                  span,
-                                                  rcvr_ty,
-                                                  item_name,
-                                                  source,
-                                                  out_of_scope_traits);
+                if !actual.is_numeric() || !actual.is_fresh() {
+                    self.suggest_traits_to_import(
+                        &mut err, span, rcvr_ty, item_name, source, out_of_scope_traits
+                    );
                 }
 
                 if let Some(lev_candidate) = lev_candidate {
@@ -575,13 +570,20 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
         }
     }
 
-    fn suggest_traits_to_import<'b>(&self,
-                                    err: &mut DiagnosticBuilder,
-                                    span: Span,
-                                    rcvr_ty: Ty<'tcx>,
-                                    item_name: ast::Ident,
-                                    source: SelfSource<'b>,
-                                    valid_out_of_scope_traits: Vec<DefId>) {
+    fn suggest_traits_to_import(
+        &self,
+        err: &mut DiagnosticBuilder,
+        span: Span,
+        rcvr_ty: Ty<'tcx>,
+        item_name: ast::Ident,
+        source: SelfSource<'a>,
+        valid_out_of_scope_traits: Vec<DefId>
+    ) {
+        debug!(
+            "suggest_traits_to_import: rcvr_ty={:?} item_name={:?} source={:?} \
+             valid_out_of_scope_traits={:?}",
+             rcvr_ty, item_name, source, valid_out_of_scope_traits,
+        );
         if self.suggest_valid_traits(err, valid_out_of_scope_traits) {
             return;
         }
@@ -610,6 +612,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
             })
             .collect::<Vec<_>>();
 
+        debug!("suggest_traits_to_import: candidates={:?}", candidates);
         if !candidates.is_empty() {
             // Sort from most relevant to least relevant.
             candidates.sort_by(|a, b| a.cmp(b).reverse());
@@ -676,13 +679,13 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
     }
 }
 
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, Debug)]
 pub enum SelfSource<'a> {
     QPath(&'a hir::Ty),
     MethodCall(&'a hir::Expr /* rcvr */),
 }
 
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, Debug)]
 pub struct TraitInfo {
     pub def_id: DefId,
 }
@@ -692,12 +695,15 @@ impl PartialEq for TraitInfo {
         self.cmp(other) == Ordering::Equal
     }
 }
+
 impl Eq for TraitInfo {}
+
 impl PartialOrd for TraitInfo {
     fn partial_cmp(&self, other: &TraitInfo) -> Option<Ordering> {
         Some(self.cmp(other))
     }
 }
+
 impl Ord for TraitInfo {
     fn cmp(&self, other: &TraitInfo) -> Ordering {
         // Local crates are more important than remote ones (local: