Use PredicateObligations instead of Predicates

Keep more information about trait binding failures.

Author: estebank

src/librustc_infer/infer/outlives/verify.rs

@@ -296,7 +296,10 @@ impl<'cx, 'tcx> VerifyBoundCx<'cx, 'tcx> {
  let identity_proj = tcx.mk_projection(assoc_item_def_id, identity_substs);
  self.collect_outlives_from_predicate_list(
  move |ty| ty == identity_proj,
- traits::elaborate_predicates(tcx, trait_predicates),
+ traits::elaborate_predicates(tcx, trait_predicates)
+ .into_iter()
+ .map(|o| o.predicate)
+ .collect::<Vec<_>>(),
  )
  .map(|b| b.1)
  }

src/librustc_infer/traits/util.rs

@@ -1,8 +1,10 @@
 use smallvec::smallvec;
 
+use crate::traits::{Obligation, ObligationCause, PredicateObligation};
 use rustc_data_structures::fx::FxHashSet;
 use rustc_middle::ty::outlives::Component;
 use rustc_middle::ty::{self, ToPolyTraitRef, ToPredicate, TyCtxt, WithConstness};
+use rustc_span::Span;
 
 pub fn anonymize_predicate<'tcx>(
  tcx: TyCtxt<'tcx>,
@@ -87,7 +89,7 @@ impl<T: AsRef<ty::Predicate<'tcx>>> Extend<T> for PredicateSet<'tcx> {
 /// holds as well. Similarly, if we have `trait Foo: 'static`, and we know that
 /// `T: Foo`, then we know that `T: 'static`.
 pub struct Elaborator<'tcx> {
- stack: Vec<ty::Predicate<'tcx>>,
+ stack: Vec<PredicateObligation<'tcx>>,
  visited: PredicateSet<'tcx>,
 }
 
@@ -112,35 +114,60 @@ pub fn elaborate_predicates<'tcx>(
 ) -> Elaborator<'tcx> {
  let mut visited = PredicateSet::new(tcx);
  predicates.retain(|pred| visited.insert(pred));
- Elaborator { stack: predicates, visited }
+ let obligations: Vec<_> =
+ predicates.into_iter().map(|predicate| predicate_obligation(predicate, None)).collect();
+ elaborate_obligations(tcx, obligations)
+}
+
+pub fn elaborate_obligations<'tcx>(
+ tcx: TyCtxt<'tcx>,
+ mut obligations: Vec<PredicateObligation<'tcx>>,
+) -> Elaborator<'tcx> {
+ let mut visited = PredicateSet::new(tcx);
+ obligations.retain(|obligation| visited.insert(&obligation.predicate));
+ Elaborator { stack: obligations, visited }
+}
+
+fn predicate_obligation<'tcx>(
+ predicate: ty::Predicate<'tcx>,
+ span: Option<Span>,
+) -> PredicateObligation<'tcx> {
+ let mut cause = ObligationCause::dummy();
+ if let Some(span) = span {
+ cause.span = span;
+ }
+ Obligation { cause, param_env: ty::ParamEnv::empty(), recursion_depth: 0, predicate }
 }
 
 impl Elaborator<'tcx> {
  pub fn filter_to_traits(self) -> FilterToTraits<Self> {
  FilterToTraits::new(self)
  }
 
- fn elaborate(&mut self, predicate: &ty::Predicate<'tcx>) {
+ fn elaborate(&mut self, obligation: &PredicateObligation<'tcx>) {
  let tcx = self.visited.tcx;
- match *predicate {
+ match obligation.predicate {
  ty::Predicate::Trait(ref data, _) => {
  // Get predicates declared on the trait.
  let predicates = tcx.super_predicates_of(data.def_id());
 
- let predicates = predicates
- .predicates
- .iter()
- .map(|(pred, _)| pred.subst_supertrait(tcx, &data.to_poly_trait_ref()));
- debug!("super_predicates: data={:?} predicates={:?}", data, predicates.clone());
+ let obligations = predicates.predicates.iter().map(|(pred, span)| {
+ predicate_obligation(
+ pred.subst_supertrait(tcx, &data.to_poly_trait_ref()),
+ Some(*span),
+ )
+ });
+ debug!("super_predicates: data={:?} predicates={:?}", data, &obligations);
 
  // Only keep those bounds that we haven't already seen.
  // This is necessary to prevent infinite recursion in some
  // cases. One common case is when people define
  // `trait Sized: Sized { }` rather than `trait Sized { }`.
  let visited = &mut self.visited;
- let predicates = predicates.filter(|pred| visited.insert(pred));
+ let obligations =
+ obligations.filter(|obligation| visited.insert(&obligation.predicate));
 
- self.stack.extend(predicates);
+ self.stack.extend(obligations);
  }
  ty::Predicate::WellFormed(..) => {
  // Currently, we do not elaborate WF predicates,
@@ -221,25 +248,26 @@ impl Elaborator<'tcx> {
  None
  }
  })
- .filter(|p| visited.insert(p)),
+ .filter(|p| visited.insert(p))
+ .map(|p| predicate_obligation(p, None)),
  );
  }
  }
  }
 }
 
 impl Iterator for Elaborator<'tcx> {
- type Item = ty::Predicate<'tcx>;
+ type Item = PredicateObligation<'tcx>;
 
  fn size_hint(&self) -> (usize, Option<usize>) {
  (self.stack.len(), None)
  }
 
- fn next(&mut self) -> Option<ty::Predicate<'tcx>> {
+ fn next(&mut self) -> Option<Self::Item> {
  // Extract next item from top-most stack frame, if any.
- if let Some(pred) = self.stack.pop() {
- self.elaborate(&pred);
- Some(pred)
+ if let Some(obligation) = self.stack.pop() {
+ self.elaborate(&obligation);
+ Some(obligation)
  } else {
  None
  }
@@ -282,12 +310,12 @@ impl<I> FilterToTraits<I> {
  }
 }
 
-impl<'tcx, I: Iterator<Item = ty::Predicate<'tcx>>> Iterator for FilterToTraits<I> {
+impl<'tcx, I: Iterator<Item = PredicateObligation<'tcx>>> Iterator for FilterToTraits<I> {
  type Item = ty::PolyTraitRef<'tcx>;
 
  fn next(&mut self) -> Option<ty::PolyTraitRef<'tcx>> {
- while let Some(pred) = self.base_iterator.next() {
- if let ty::Predicate::Trait(data, _) = pred {
+ while let Some(obligation) = self.base_iterator.next() {
+ if let ty::Predicate::Trait(data, _) = obligation.predicate {
  return Some(data.to_poly_trait_ref());
  }
  }

src/librustc_mir/transform/const_prop.rs

@@ -126,7 +126,7 @@ impl<'tcx> MirPass<'tcx> for ConstProp {
  .collect();
  if !traits::normalize_and_test_predicates(
  tcx,
- traits::elaborate_predicates(tcx, predicates).collect(),
+ traits::elaborate_predicates(tcx, predicates).map(|o| o.predicate).collect(),
  ) {
  trace!("ConstProp skipped for {:?}: found unsatisfiable predicates", source.def_id());
  return;

src/librustc_trait_selection/opaque_types.rs

@@ -1255,8 +1255,8 @@ crate fn required_region_bounds(
  assert!(!erased_self_ty.has_escaping_bound_vars());
 
  traits::elaborate_predicates(tcx, predicates)
- .filter_map(|predicate| {
- match predicate {
+ .filter_map(|obligation| {
+ match obligation.predicate {
  ty::Predicate::Projection(..)
  | ty::Predicate::Trait(..)
  | ty::Predicate::Subtype(..)

src/librustc_trait_selection/traits/auto_trait.rs

@@ -366,7 +366,8 @@ impl AutoTraitFinder<'tcx> {
 
  computed_preds.extend(user_computed_preds.iter().cloned());
  let normalized_preds =
- elaborate_predicates(tcx, computed_preds.iter().cloned().collect());
+ elaborate_predicates(tcx, computed_preds.iter().cloned().collect())
+ .map(|o| o.predicate);
  new_env =
  ty::ParamEnv::new(tcx.mk_predicates(normalized_preds), param_env.reveal, None);
  }

src/librustc_trait_selection/traits/error_reporting/mod.rs

@@ -976,8 +976,8 @@ impl<'a, 'tcx> InferCtxtPrivExt<'tcx> for InferCtxt<'a, 'tcx> {
  }
  };
 
- for implication in super::elaborate_predicates(self.tcx, vec![*cond]) {
- if let ty::Predicate::Trait(implication, _) = implication {
+ for obligation in super::elaborate_predicates(self.tcx, vec![*cond]) {
+ if let ty::Predicate::Trait(implication, _) = obligation.predicate {
  let error = error.to_poly_trait_ref();
  let implication = implication.to_poly_trait_ref();
  // FIXME: I'm just not taking associated types at all here.
@@ -1387,7 +1387,7 @@ impl<'a, 'tcx> InferCtxtPrivExt<'tcx> for InferCtxt<'a, 'tcx> {
  (self.tcx.sess.source_map().span_to_snippet(span), &obligation.cause.code)
  {
  let generics = self.tcx.generics_of(*def_id);
- if !generics.params.is_empty() && !snippet.ends_with('>') {
+ if generics.params.iter().filter(|p| p.name.as_str() != "Self").next().is_some() && !snippet.ends_with('>') {
  // FIXME: To avoid spurious suggestions in functions where type arguments
  // where already supplied, we check the snippet to make sure it doesn't
  // end with a turbofish. Ideally we would have access to a `PathSegment`

src/librustc_trait_selection/traits/error_reporting/on_unimplemented.rs

@@ -142,7 +142,9 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
  }
  }
 
- if let ObligationCauseCode::ItemObligation(item) = obligation.cause.code {
+ if let ObligationCauseCode::ItemObligation(item)
+ | ObligationCauseCode::BindingObligation(item, _) = obligation.cause.code
+ {
  // FIXME: maybe also have some way of handling methods
  // from other traits? That would require name resolution,
  // which we might want to be some sort of hygienic.

src/librustc_trait_selection/traits/error_reporting/suggestions.rs

@@ -1345,7 +1345,6 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
  ObligationCauseCode::ItemObligation(item_def_id) => {
  let item_name = tcx.def_path_str(item_def_id);
  let msg = format!("required by `{}`", item_name);
-
  if let Some(sp) = tcx.hir().span_if_local(item_def_id) {
  let sp = tcx.sess.source_map().guess_head_span(sp);
  err.span_label(sp, &msg);
@@ -1357,7 +1356,9 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
  let item_name = tcx.def_path_str(item_def_id);
  let msg = format!("required by this bound in `{}`", item_name);
  if let Some(ident) = tcx.opt_item_name(item_def_id) {
- err.span_label(ident.span, "");
+ if !ident.span.overlaps(span) {
+ err.span_label(ident.span, "");
+ }
  }
  if span != DUMMY_SP {
  err.span_label(span, &msg);

src/librustc_trait_selection/traits/mod.rs

@@ -297,7 +297,9 @@ pub fn normalize_param_env_or_error<'tcx>(
  );
 
  let mut predicates: Vec<_> =
- util::elaborate_predicates(tcx, unnormalized_env.caller_bounds.to_vec()).collect();
+ util::elaborate_predicates(tcx, unnormalized_env.caller_bounds.to_vec())
+ .map(|obligation| obligation.predicate)
+ .collect();
 
  debug!("normalize_param_env_or_error: elaborated-predicates={:?}", predicates);
 

src/librustc_trait_selection/traits/object_safety.rs

@@ -298,7 +298,7 @@ fn generics_require_sized_self(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
  // Search for a predicate like `Self : Sized` amongst the trait bounds.
  let predicates = tcx.predicates_of(def_id);
  let predicates = predicates.instantiate_identity(tcx).predicates;
- elaborate_predicates(tcx, predicates).any(|predicate| match predicate {
+ elaborate_predicates(tcx, predicates).any(|obligation| match obligation.predicate {
  ty::Predicate::Trait(ref trait_pred, _) => {
  trait_pred.def_id() == sized_def_id && trait_pred.skip_binder().self_ty().is_param(0)
  }