use rustc_middle::mir::interpret::ErrorHandled;
use rustc_middle::ty::fold::{TypeFolder, TypeSuperFoldable};
use rustc_middle::ty::visit::TypeVisitable;
-use rustc_middle::ty::{PolyTraitRef, Region, RegionVid};
+use rustc_middle::ty::{ImplPolarity, Region, RegionVid};
use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexSet};
let trait_ref = tcx.mk_trait_ref(trait_did, [ty]);
- let trait_pred = ty::Binder::dummy(trait_ref);
-
let infcx = tcx.infer_ctxt().build();
let mut selcx = SelectionContext::new(&infcx);
- for f in [
- PolyTraitRef::to_poly_trait_predicate,
- PolyTraitRef::to_poly_trait_predicate_negative_polarity,
- ] {
+ for polarity in [true, false] {
let result = selcx.select(&Obligation::new(
tcx,
ObligationCause::dummy(),
orig_env,
- f(&trait_pred),
+ ty::Binder::dummy(ty::TraitPredicate {
+ trait_ref,
+ constness: ty::BoundConstness::NotConst,
+ polarity: if polarity {
+ ImplPolarity::Positive
+ } else {
+ ImplPolarity::Negative
+ },
+ }),
));
if let Ok(Some(ImplSource::UserDefined(_))) = result {
debug!(
) {
let mut should_add_new = true;
user_computed_preds.retain(|&old_pred| {
- if let (ty::PredicateKind::Trait(new_trait), ty::PredicateKind::Trait(old_trait)) =
- (new_pred.kind().skip_binder(), old_pred.kind().skip_binder())
+ if let (
+ ty::PredicateKind::Clause(ty::Clause::Trait(new_trait)),
+ ty::PredicateKind::Clause(ty::Clause::Trait(old_trait)),
+ ) = (new_pred.kind().skip_binder(), old_pred.kind().skip_binder())
{
if new_trait.def_id() == old_trait.def_id() {
let new_substs = new_trait.trait_ref.substs;
computed_preds: &mut FxIndexSet<ty::Predicate<'tcx>>,
fresh_preds: &mut FxHashSet<ty::Predicate<'tcx>>,
predicates: &mut VecDeque<ty::PolyTraitPredicate<'tcx>>,
- select: &mut SelectionContext<'_, 'tcx>,
+ selcx: &mut SelectionContext<'_, 'tcx>,
only_projections: bool,
) -> bool {
let dummy_cause = ObligationCause::dummy();
for obligation in nested {
let is_new_pred =
- fresh_preds.insert(self.clean_pred(select.infcx(), obligation.predicate));
+ fresh_preds.insert(self.clean_pred(selcx.infcx, obligation.predicate));
// Resolve any inference variables that we can, to help selection succeed
- let predicate = select.infcx().resolve_vars_if_possible(obligation.predicate);
+ let predicate = selcx.infcx.resolve_vars_if_possible(obligation.predicate);
// We only add a predicate as a user-displayable bound if
// it involves a generic parameter, and doesn't contain
let bound_predicate = predicate.kind();
match bound_predicate.skip_binder() {
- ty::PredicateKind::Trait(p) => {
+ ty::PredicateKind::Clause(ty::Clause::Trait(p)) => {
// Add this to `predicates` so that we end up calling `select`
// with it. If this predicate ends up being unimplemented,
// then `evaluate_predicates` will handle adding it the `ParamEnv`
// if possible.
predicates.push_back(bound_predicate.rebind(p));
}
- ty::PredicateKind::Projection(p) => {
+ ty::PredicateKind::Clause(ty::Clause::Projection(p)) => {
let p = bound_predicate.rebind(p);
debug!(
"evaluate_nested_obligations: examining projection predicate {:?}",
// and turn them into an explicit negative impl for our type.
debug!("Projecting and unifying projection predicate {:?}", predicate);
- match project::poly_project_and_unify_type(
- select,
- &obligation.with(self.tcx, p),
- ) {
+ match project::poly_project_and_unify_type(selcx, &obligation.with(self.tcx, p))
+ {
ProjectAndUnifyResult::MismatchedProjectionTypes(e) => {
debug!(
"evaluate_nested_obligations: Unable to unify predicate \
computed_preds,
fresh_preds,
predicates,
- select,
+ selcx,
only_projections,
) {
return false;
}
}
}
- ty::PredicateKind::RegionOutlives(binder) => {
+ ty::PredicateKind::Clause(ty::Clause::RegionOutlives(binder)) => {
let binder = bound_predicate.rebind(binder);
- select.infcx().region_outlives_predicate(&dummy_cause, binder)
+ selcx.infcx.region_outlives_predicate(&dummy_cause, binder)
}
- ty::PredicateKind::TypeOutlives(binder) => {
+ ty::PredicateKind::Clause(ty::Clause::TypeOutlives(binder)) => {
let binder = bound_predicate.rebind(binder);
match (
binder.no_bound_vars(),
binder.map_bound_ref(|pred| pred.0).no_bound_vars(),
) {
(None, Some(t_a)) => {
- select.infcx().register_region_obligation_with_cause(
+ selcx.infcx.register_region_obligation_with_cause(
t_a,
- select.infcx().tcx.lifetimes.re_static,
+ selcx.infcx.tcx.lifetimes.re_static,
&dummy_cause,
);
}
(Some(ty::OutlivesPredicate(t_a, r_b)), _) => {
- select.infcx().register_region_obligation_with_cause(
+ selcx.infcx.register_region_obligation_with_cause(
t_a,
r_b,
&dummy_cause,
ty::PredicateKind::ConstEquate(c1, c2) => {
let evaluate = |c: ty::Const<'tcx>| {
if let ty::ConstKind::Unevaluated(unevaluated) = c.kind() {
- match select.infcx().const_eval_resolve(
+ match selcx.infcx.const_eval_resolve(
obligation.param_env,
unevaluated,
Some(obligation.cause.span),
) {
Ok(Some(valtree)) => {
- Ok(ty::Const::from_value(select.tcx(), valtree, c.ty()))
+ Ok(ty::Const::from_value(selcx.tcx(), valtree, c.ty()))
}
Ok(None) => {
let tcx = self.tcx;
match (evaluate(c1), evaluate(c2)) {
(Ok(c1), Ok(c2)) => {
- match select
- .infcx()
- .at(&obligation.cause, obligation.param_env)
- .eq(c1, c2)
+ match selcx.infcx.at(&obligation.cause, obligation.param_env).eq(c1, c2)
{
Ok(_) => (),
Err(_) => return false,
}
}
-// Replaces all ReVars in a type with ty::Region's, using the provided map
+/// Replaces all ReVars in a type with ty::Region's, using the provided map
pub struct RegionReplacer<'a, 'tcx> {
vid_to_region: &'a FxHashMap<ty::RegionVid, ty::Region<'tcx>>,
tcx: TyCtxt<'tcx>,