mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add new ToPredicate impls and TraitRef methods to remove some ty::Binber::dummy calls

Browse Source
This commit is contained in:
Maybe Waffle 2023-04-26 11:48:17 +00:00
parent 4f2532fb53
commit 1b8c7784e5
9 changed files with 46 additions and 32 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
compiler/rustc_const_eval/src/transform/check_consts/qualifs.rs
View File

@ -157,13 +157,8 @@ impl Qualif for NeedsNonConstDrop {
cx.tcx,
ObligationCause::dummy_with_span(cx.body.span),
cx.param_env,
ty::Binder::dummy(ty::TraitRef::from_lang_item(
cx.tcx,
LangItem::Destruct,
cx.body.span,
[ty],
))
.with_constness(ty::BoundConstness::ConstIfConst),
ty::TraitRef::from_lang_item(cx.tcx, LangItem::Destruct, cx.body.span, [ty])
.with_constness(ty::BoundConstness::ConstIfConst),
);
let infcx = cx.tcx.infer_ctxt().build();

2
compiler/rustc_hir_analysis/src/bounds.rs
View File

@ -57,7 +57,7 @@ impl<'tcx> Bounds<'tcx> {
pub fn push_sized(&mut self, tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, span: Span) {
let sized_def_id = tcx.require_lang_item(LangItem::Sized, Some(span));
let trait_ref = ty::Binder::dummy(ty::TraitRef::new(tcx, sized_def_id, [ty]));
let trait_ref = ty::TraitRef::new(tcx, sized_def_id, [ty]);
// Preferable to put this obligation first, since we report better errors for sized ambiguity.
self.predicates.insert(0, (trait_ref.without_const().to_predicate(tcx), span));
}

18
compiler/rustc_middle/src/ty/mod.rs
View File

@ -1207,6 +1207,18 @@ impl<'tcx> ToPredicate<'tcx, PolyTraitPredicate<'tcx>> for Binder<'tcx, TraitRef
}
}
impl<'tcx> ToPredicate<'tcx, PolyTraitPredicate<'tcx>> for TraitRef<'tcx> {
fn to_predicate(self, tcx: TyCtxt<'tcx>) -> PolyTraitPredicate<'tcx> {
ty::Binder::dummy(self).to_predicate(tcx)
}
}
impl<'tcx> ToPredicate<'tcx, PolyTraitPredicate<'tcx>> for TraitPredicate<'tcx> {
fn to_predicate(self, _tcx: TyCtxt<'tcx>) -> PolyTraitPredicate<'tcx> {
ty::Binder::dummy(self)
}
}
impl<'tcx> ToPredicate<'tcx> for PolyTraitPredicate<'tcx> {
fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {
self.map_bound(|p| PredicateKind::Clause(Clause::Trait(p))).to_predicate(tcx)
@ -1231,6 +1243,12 @@ impl<'tcx> ToPredicate<'tcx> for PolyProjectionPredicate<'tcx> {
}
}
impl<'tcx> ToPredicate<'tcx> for TraitPredicate<'tcx> {
fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> {
PredicateKind::Clause(Clause::Trait(self)).to_predicate(tcx)
}
}
impl<'tcx> Predicate<'tcx> {
pub fn to_opt_poly_trait_pred(self) -> Option<PolyTraitPredicate<'tcx>> {
let predicate = self.kind();

12
compiler/rustc_middle/src/ty/sty.rs
View File

@ -871,6 +871,18 @@ impl<'tcx> TraitRef<'tcx> {
)
}
/// Converts this trait ref to a trait predicate with a given `constness` and a positive polarity.
#[inline]
pub fn with_constness(self, constness: ty::BoundConstness) -> ty::TraitPredicate<'tcx> {
ty::TraitPredicate { trait_ref: self, constness, polarity: ty::ImplPolarity::Positive }
}
/// Converts this trait ref to a trait predicate without `const` and a positive polarity.
#[inline]
pub fn without_const(self) -> ty::TraitPredicate<'tcx> {
self.with_constness(ty::BoundConstness::NotConst)
}
#[inline]
pub fn self_ty(&self) -> Ty<'tcx> {
self.substs.type_at(0)

2
compiler/rustc_trait_selection/src/traits/mod.rs
View File

@ -127,7 +127,7 @@ pub fn type_known_to_meet_bound_modulo_regions<'tcx>(
ty: Ty<'tcx>,
def_id: DefId,
) -> bool {
let trait_ref = ty::Binder::dummy(ty::TraitRef::new(infcx.tcx, def_id, [ty]));
let trait_ref = ty::TraitRef::new(infcx.tcx, def_id, [ty]);
pred_known_to_hold_modulo_regions(infcx, param_env, trait_ref.without_const())
}

11
compiler/rustc_trait_selection/src/traits/object_safety.rs
View File

@ -769,13 +769,10 @@ fn receiver_is_dispatchable<'tcx>(
let param_env = tcx.param_env(method.def_id);
// Self: Unsize<U>
let unsize_predicate = ty::Binder::dummy(ty::TraitRef::new(
tcx,
unsize_did,
[tcx.types.self_param, unsized_self_ty],
))
.without_const()
.to_predicate(tcx);
let unsize_predicate =
ty::TraitRef::new(tcx, unsize_did, [tcx.types.self_param, unsized_self_ty])
.without_const()
.to_predicate(tcx);
// U: Trait<Arg1, ..., ArgN>
let trait_predicate = {

12
compiler/rustc_trait_selection/src/traits/project.rs
View File

@ -1319,7 +1319,7 @@ fn assemble_candidate_for_impl_trait_in_trait<'cx, 'tcx>(
let trait_substs =
obligation.predicate.substs.truncate_to(tcx, tcx.generics_of(trait_def_id));
// FIXME(named-returns): Binders
let trait_predicate = ty::Binder::dummy(ty::TraitRef::new(tcx, trait_def_id, trait_substs));
let trait_predicate = ty::TraitRef::new(tcx, trait_def_id, trait_substs);
let _ = selcx.infcx.commit_if_ok(|_| {
match selcx.select(&obligation.with(tcx, trait_predicate)) {
@ -1682,10 +1682,8 @@ fn assemble_candidates_from_impls<'cx, 'tcx>(
if selcx.infcx.predicate_must_hold_modulo_regions(
&obligation.with(
selcx.tcx(),
ty::Binder::dummy(
ty::TraitRef::from_lang_item(selcx.tcx(), LangItem::Sized, obligation.cause.span(),[self_ty]),
)
.without_const(),
ty::TraitRef::from_lang_item(selcx.tcx(), LangItem::Sized, obligation.cause.span(),[self_ty])
.without_const(),
),
) =>
{
@ -1948,12 +1946,12 @@ fn confirm_builtin_candidate<'cx, 'tcx>(
)
});
if check_is_sized {
let sized_predicate = ty::Binder::dummy(ty::TraitRef::from_lang_item(
let sized_predicate = ty::TraitRef::from_lang_item(
tcx,
LangItem::Sized,
obligation.cause.span(),
[self_ty],
))
)
.without_const();
obligations.push(obligation.with(tcx, sized_predicate));
}

7
compiler/rustc_trait_selection/src/traits/select/confirmation.rs
View File

@ -1049,12 +1049,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
);
// We can only make objects from sized types.
let tr = ty::Binder::dummy(ty::TraitRef::from_lang_item(
tcx,
LangItem::Sized,
cause.span,
[source],
));
let tr = ty::TraitRef::from_lang_item(tcx, LangItem::Sized, cause.span, [source]);
nested.push(predicate_to_obligation(tr.without_const().to_predicate(tcx)));
// If the type is `Foo + 'a`, ensure that the type

5
compiler/rustc_ty_utils/src/ty.rs
View File

@ -62,9 +62,8 @@ fn sized_constraint_for_ty<'tcx>(
// it on the impl.
let Some(sized_trait) = tcx.lang_items().sized_trait() else { return vec![ty] };
let sized_predicate = ty::Binder::dummy(ty::TraitRef::new(tcx, sized_trait, [ty]))
.without_const()
.to_predicate(tcx);
let sized_predicate =
ty::TraitRef::new(tcx, sized_trait, [ty]).without_const().to_predicate(tcx);
let predicates = tcx.predicates_of(adtdef.did()).predicates;
if predicates.iter().any(|(p, _)| *p == sized_predicate) { vec![] } else { vec![ty] }
}