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

Auto merge of #125153 - compiler-errors:opt-poly, r=lcnr

Browse Source 
`to_opt_poly_X_pred` -> `as_X_clause`

r? lcnr
This commit is contained in:
bors 2024-05-17 18:23:47 +00:00
commit 1a73979886
9 changed files with 23 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
compiler/rustc_hir_analysis/src/check/compare_impl_item.rs
View File

@ -2250,7 +2250,7 @@ fn try_report_async_mismatch<'tcx>(
for error in errors {
if let ObligationCauseCode::WhereClause(def_id, _) = *error.root_obligation.cause.code()
&& def_id == async_future_def_id
&& let Some(proj) = error.root_obligation.predicate.to_opt_poly_projection_pred()
&& let Some(proj) = error.root_obligation.predicate.as_projection_clause()
&& let Some(proj) = proj.no_bound_vars()
&& infcx.can_eq(
error.root_obligation.param_env,

4
compiler/rustc_hir_analysis/src/check/wfcheck.rs
View File

@ -1350,12 +1350,12 @@ fn check_impl<'tcx>(
// We already have a better span.
continue;
}
if let Some(pred) = obligation.predicate.to_opt_poly_trait_pred()
if let Some(pred) = obligation.predicate.as_trait_clause()
&& pred.skip_binder().self_ty() == trait_ref.self_ty()
{
obligation.cause.span = hir_self_ty.span;
}
if let Some(pred) = obligation.predicate.to_opt_poly_projection_pred()
if let Some(pred) = obligation.predicate.as_projection_clause()
&& pred.skip_binder().self_ty() == trait_ref.self_ty()
{
obligation.cause.span = hir_self_ty.span;

8
compiler/rustc_hir_typeck/src/op.rs
View File

@ -583,7 +583,7 @@ fn check_overloaded_binop(
if !errors.is_empty() {
for error in errors {
if let Some(trait_pred) =
error.obligation.predicate.to_opt_poly_trait_pred()
error.obligation.predicate.as_trait_clause()
{
let output_associated_item = match error.obligation.cause.code()
{
@ -797,9 +797,9 @@ pub fn check_user_unop(
);
if operand_ty.has_non_region_param() {
let predicates = errors.iter().filter_map(|error| {
error.obligation.predicate.to_opt_poly_trait_pred()
});
let predicates = errors
.iter()
.filter_map(|error| error.obligation.predicate.as_trait_clause());
for pred in predicates {
self.err_ctxt().suggest_restricting_param_bound(
&mut err,

2
compiler/rustc_infer/src/traits/util.rs
View File

@ -455,7 +455,7 @@ impl<'tcx, I: Iterator<Item = ty::Predicate<'tcx>>> Iterator for FilterToTraits<
fn next(&mut self) -> Option<ty::PolyTraitRef<'tcx>> {
while let Some(pred) = self.base_iterator.next() {
if let Some(data) = pred.to_opt_poly_trait_pred() {
if let Some(data) = pred.as_trait_clause() {
return Some(data.map_bound(|t| t.trait_ref));
}
}

4
compiler/rustc_middle/src/ty/predicate.rs
View File

@ -702,7 +702,7 @@ fn upcast_from(from: NormalizesTo<'tcx>, tcx: TyCtxt<'tcx>) -> Self {
}
impl<'tcx> Predicate<'tcx> {
pub fn to_opt_poly_trait_pred(self) -> Option<PolyTraitPredicate<'tcx>> {
pub fn as_trait_clause(self) -> Option<PolyTraitPredicate<'tcx>> {
let predicate = self.kind();
match predicate.skip_binder() {
PredicateKind::Clause(ClauseKind::Trait(t)) => Some(predicate.rebind(t)),
@ -722,7 +722,7 @@ pub fn to_opt_poly_trait_pred(self) -> Option<PolyTraitPredicate<'tcx>> {
}
}
pub fn to_opt_poly_projection_pred(self) -> Option<PolyProjectionPredicate<'tcx>> {
pub fn as_projection_clause(self) -> Option<PolyProjectionPredicate<'tcx>> {
let predicate = self.kind();
match predicate.skip_binder() {
PredicateKind::Clause(ClauseKind::Projection(t)) => Some(predicate.rebind(t)),

8
compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs
View File

@ -2739,7 +2739,7 @@ fn note_obligation_cause_code<G: EmissionGuarantee, T>(
| ObligationCauseCode::ReferenceOutlivesReferent(..)
| ObligationCauseCode::ObjectTypeBound(..) => {}
ObligationCauseCode::RustCall => {
if let Some(pred) = predicate.to_opt_poly_trait_pred()
if let Some(pred) = predicate.as_trait_clause()
&& Some(pred.def_id()) == tcx.lang_items().sized_trait()
{
err.note("argument required to be sized due to `extern \"rust-call\"` ABI");
@ -3725,7 +3725,7 @@ fn note_function_argument_obligation<G: EmissionGuarantee>(
{
if let hir::Expr { kind: hir::ExprKind::MethodCall(_, rcvr, _, _), .. } = expr
&& let Some(ty) = typeck_results.node_type_opt(rcvr.hir_id)
&& let Some(failed_pred) = failed_pred.to_opt_poly_trait_pred()
&& let Some(failed_pred) = failed_pred.as_trait_clause()
&& let pred = failed_pred.map_bound(|pred| pred.with_self_ty(tcx, ty))
&& self.predicate_must_hold_modulo_regions(&Obligation::misc(
tcx, expr.span, body_id, param_env, pred,
@ -3816,7 +3816,7 @@ fn note_function_argument_obligation<G: EmissionGuarantee>(
&& let Some(where_pred) = where_clauses.predicates.get(*idx)
{
if let Some(where_pred) = where_pred.as_trait_clause()
&& let Some(failed_pred) = failed_pred.to_opt_poly_trait_pred()
&& let Some(failed_pred) = failed_pred.as_trait_clause()
{
self.enter_forall(where_pred, |where_pred| {
let failed_pred = self.instantiate_binder_with_fresh_vars(
@ -3842,7 +3842,7 @@ fn note_function_argument_obligation<G: EmissionGuarantee>(
}
})
} else if let Some(where_pred) = where_pred.as_projection_clause()
&& let Some(failed_pred) = failed_pred.to_opt_poly_projection_pred()
&& let Some(failed_pred) = failed_pred.as_projection_clause()
&& let Some(found) = failed_pred.skip_binder().term.ty()
{
type_diffs = vec![Sorts(ty::error::ExpectedFound {

14
compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs
View File

@ -1417,7 +1417,7 @@ fn report_const_param_not_wf(
};
let mut code = obligation.cause.code();
let mut pred = obligation.predicate.to_opt_poly_trait_pred();
let mut pred = obligation.predicate.as_trait_clause();
while let Some((next_code, next_pred)) = code.parent() {
if let Some(pred) = pred {
self.enter_forall(pred, |pred| {
@ -1481,16 +1481,16 @@ fn error_implies(&self, cond: ty::Predicate<'tcx>, error: ty::Predicate<'tcx>) -
return true;
}
if let Some(error) = error.to_opt_poly_trait_pred() {
if let Some(error) = error.as_trait_clause() {
self.enter_forall(error, |error| {
elaborate(self.tcx, std::iter::once(cond))
.filter_map(|implied| implied.to_opt_poly_trait_pred())
.filter_map(|implied| implied.as_trait_clause())
.any(|implied| self.can_match_trait(error, implied))
})
} else if let Some(error) = error.to_opt_poly_projection_pred() {
} else if let Some(error) = error.as_projection_clause() {
self.enter_forall(error, |error| {
elaborate(self.tcx, std::iter::once(cond))
.filter_map(|implied| implied.to_opt_poly_projection_pred())
.filter_map(|implied| implied.as_projection_clause())
.any(|implied| self.can_match_projection(error, implied))
})
} else {
@ -2415,8 +2415,8 @@ fn maybe_report_ambiguity(&self, obligation: &PredicateObligation<'tcx>) -> Erro
return e;
}
err.note(format!("cannot satisfy `{predicate}`"));
let impl_candidates = self
.find_similar_impl_candidates(predicate.to_opt_poly_trait_pred().unwrap());
let impl_candidates =
self.find_similar_impl_candidates(predicate.as_trait_clause().unwrap());
if impl_candidates.len() < 40 {
self.report_similar_impl_candidates(
impl_candidates.as_slice(),

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

@ -653,7 +653,7 @@ fn object_ty_for_trait<'tcx>(
let mut elaborated_predicates: Vec<_> = elaborate(tcx, [pred])
.filter_map(|pred| {
debug!(?pred);
let pred = pred.to_opt_poly_projection_pred()?;
let pred = pred.as_projection_clause()?;
Some(pred.map_bound(|p| {
ty::ExistentialPredicate::Projection(ty::ExistentialProjection::erase_self_ty(
tcx, p,

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

@ -377,7 +377,7 @@ fn compute_trait_pred(&mut self, trait_pred: ty::TraitPredicate<'tcx>, elaborate
let item = self.item;
let extend = |traits::PredicateObligation { predicate, mut cause, .. }| {
if let Some(parent_trait_pred) = predicate.to_opt_poly_trait_pred() {
if let Some(parent_trait_pred) = predicate.as_trait_clause() {
cause = cause.derived_cause(
parent_trait_pred,
traits::ObligationCauseCode::WellFormedDerived,