rust-lang/rust
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Consolidate obligation cause codes for where clauses

Browse Source
This commit is contained in:
Michael Goulet
2024-05-10 11:04:53 -04:00
parent ef15976387
commit e444017b49
25 changed files with 137 additions and 139 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -1205,8 +1205,13 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
let code = match obligation.cause.code() {
ObligationCauseCode::FunctionArg { parent_code, .. } => parent_code,
c @ ObligationCauseCode::WhereClause(_)
| c @ ObligationCauseCode::WhereClauseInExpr(..) => c,
// FIXME(compiler-errors): This is kind of a mess, but required for obligations
// that come from a path expr to affect the *call* expr.
c @ ObligationCauseCode::WhereClauseInExpr(_, _, hir_id, _)
if self.tcx.hir().span(*hir_id).lo() == span.lo() =>
{
c
}
c if matches!(
span.ctxt().outer_expn_data().kind,
ExpnKind::Desugaring(DesugaringKind::ForLoop)
@@ -1262,8 +1267,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
let mut_ref_self_ty_satisfies_pred = mk_result(trait_pred_and_mut_ref);
let (ref_inner_ty_satisfies_pred, ref_inner_ty_mut) =
if let ObligationCauseCode::WhereClause(_)
| ObligationCauseCode::WhereClauseInExpr(..) = obligation.cause.code()
if let ObligationCauseCode::WhereClauseInExpr(..) = obligation.cause.code()
&& let ty::Ref(_, ty, mutability) = old_pred.self_ty().skip_binder().kind()
{
(
@@ -1403,10 +1407,8 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
if let ObligationCauseCode::ImplDerived(cause) = &*code {
try_borrowing(cause.derived.parent_trait_pred, &[])
} else if let ObligationCauseCode::SpannedWhereClause(_, _)
| ObligationCauseCode::WhereClause(_)
| ObligationCauseCode::WhereClauseInExpr(..)
| ObligationCauseCode::SpannedWhereClauseInExpr(..) = code
} else if let ObligationCauseCode::WhereClause(..)
| ObligationCauseCode::WhereClauseInExpr(..) = code
{
try_borrowing(poly_trait_pred, &never_suggest_borrow)
} else {
@@ -2102,10 +2104,10 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
cause: &ObligationCauseCode<'tcx>,
err: &mut Diag<'tcx>,
) {
// First, look for an `SpannedWhereClauseInExpr`, which means we can get
// First, look for an `WhereClauseInExpr`, which means we can get
// the uninstantiated predicate list of the called function. And check
// that the predicate that we failed to satisfy is a `Fn`-like trait.
if let ObligationCauseCode::SpannedWhereClauseInExpr(def_id, _, _, idx) = cause
if let ObligationCauseCode::WhereClauseInExpr(def_id, _, _, idx) = cause
&& let predicates = self.tcx.predicates_of(def_id).instantiate_identity(self.tcx)
&& let Some(pred) = predicates.predicates.get(*idx)
&& let ty::ClauseKind::Trait(trait_pred) = pred.kind().skip_binder()
@@ -2746,12 +2748,10 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
ObligationCauseCode::TupleElem => {
err.note("only the last element of a tuple may have a dynamically sized type");
}
ObligationCauseCode::WhereClause(_) | ObligationCauseCode::WhereClauseInExpr(..) => {
// We hold the `DefId` of the item introducing the obligation, but displaying it
// doesn't add user usable information. It always point at an associated item.
}
ObligationCauseCode::SpannedWhereClause(item_def_id, span)
| ObligationCauseCode::SpannedWhereClauseInExpr(item_def_id, span, ..) => {
ObligationCauseCode::WhereClause(item_def_id, span)
| ObligationCauseCode::WhereClauseInExpr(item_def_id, span, ..)
if !span.is_dummy() =>
{
let item_name = tcx.def_path_str(item_def_id);
let short_item_name = with_forced_trimmed_paths!(tcx.def_path_str(item_def_id));
let mut multispan = MultiSpan::from(span);
@@ -2882,6 +2882,10 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
err.help(help);
}
}
ObligationCauseCode::WhereClause(..) | ObligationCauseCode::WhereClauseInExpr(..) => {
// We hold the `DefId` of the item introducing the obligation, but displaying it
// doesn't add user usable information. It always point at an associated item.
}
ObligationCauseCode::Coercion { source, target } => {
let source =
tcx.short_ty_string(self.resolve_vars_if_possible(source), &mut long_ty_file);
@@ -3802,7 +3806,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
// to an associated type (as seen from `trait_pred`) in the predicate. Like in
// trait_pred `S: Sum<<Self as Iterator>::Item>` and predicate `i32: Sum<&()>`
let mut type_diffs = vec![];
if let ObligationCauseCode::SpannedWhereClauseInExpr(def_id, _, _, idx) = parent_code
if let ObligationCauseCode::WhereClauseInExpr(def_id, _, _, idx) = parent_code
&& let Some(node_args) = typeck_results.node_args_opt(call_hir_id)
&& let where_clauses =
self.tcx.predicates_of(def_id).instantiate(self.tcx, node_args)

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

@@ -1535,9 +1535,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
*err,
);
let code = error.obligation.cause.code().peel_derives().peel_match_impls();
if let ObligationCauseCode::SpannedWhereClause(..)
| ObligationCauseCode::WhereClause(..)
| ObligationCauseCode::SpannedWhereClauseInExpr(..)
if let ObligationCauseCode::WhereClause(..)
| ObligationCauseCode::WhereClauseInExpr(..) = code
{
self.note_obligation_cause_code(
@@ -1612,11 +1610,9 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
let is_normalized_term_expected = !matches!(
obligation.cause.code().peel_derives(),
ObligationCauseCode::WhereClause(_)
| ObligationCauseCode::SpannedWhereClause(_, _)
| ObligationCauseCode::WhereClauseInExpr(..)
| ObligationCauseCode::SpannedWhereClauseInExpr(..)
| ObligationCauseCode::Coercion { .. }
|ObligationCauseCode::WhereClause(..)| ObligationCauseCode::WhereClauseInExpr(
..
) | ObligationCauseCode::Coercion { .. }
);
let (expected, actual) = if is_normalized_term_expected {
@@ -2447,7 +2443,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
}
}
if let ObligationCauseCode::WhereClause(def_id)
if let ObligationCauseCode::WhereClause(def_id, _)
| ObligationCauseCode::WhereClauseInExpr(def_id, ..) = *obligation.cause.code()
{
self.suggest_fully_qualified_path(&mut err, def_id, span, trait_ref.def_id());
@@ -2883,12 +2879,15 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
else {
return;
};
let (ObligationCauseCode::SpannedWhereClause(item_def_id, span)
| ObligationCauseCode::SpannedWhereClauseInExpr(item_def_id, span, ..)) =
let (ObligationCauseCode::WhereClause(item_def_id, span)
| ObligationCauseCode::WhereClauseInExpr(item_def_id, span, ..)) =
*obligation.cause.code().peel_derives()
else {
return;
};
if span.is_dummy() {
return;
}
debug!(?pred, ?item_def_id, ?span);
let (Some(node), true) = (
@@ -3181,10 +3180,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
ObligationCauseCode::RustCall => {
err.primary_message("functions with the \"rust-call\" ABI must take a single non-self tuple argument");
}
ObligationCauseCode::SpannedWhereClause(def_id, _)
| ObligationCauseCode::WhereClause(def_id)
if self.tcx.is_fn_trait(*def_id) =>
{
ObligationCauseCode::WhereClause(def_id, _) if self.tcx.is_fn_trait(*def_id) => {
err.code(E0059);
err.primary_message(format!(
"type parameter to bare `{}` trait must be a tuple",

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

@@ -573,11 +573,7 @@ pub fn normalize_inherent_projection<'a, 'b, 'tcx>(
// cause code, inherent projections will be printed with identity instantiation in
// diagnostics which is not ideal.
// Consider creating separate cause codes for this specific situation.
if span.is_dummy() {
ObligationCauseCode::WhereClause(alias_ty.def_id)
} else {
ObligationCauseCode::SpannedWhereClause(alias_ty.def_id, span)
},
ObligationCauseCode::WhereClause(alias_ty.def_id, span),
);
obligations.push(Obligation::with_depth(
@@ -2130,17 +2126,11 @@ fn assoc_ty_own_obligations<'cx, 'tcx>(
| ObligationCauseCode::AscribeUserTypeProvePredicate(..)
) {
obligation.cause.clone()
} else if span.is_dummy() {
ObligationCause::new(
obligation.cause.span,
obligation.cause.body_id,
ObligationCauseCode::WhereClause(obligation.predicate.def_id),
)
} else {
ObligationCause::new(
obligation.cause.span,
obligation.cause.body_id,
ObligationCauseCode::SpannedWhereClause(obligation.predicate.def_id, span),
ObligationCauseCode::WhereClause(obligation.predicate.def_id, span),
)
};
nested.push(Obligation::with_depth(

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

@@ -568,11 +568,7 @@ impl<'a, 'tcx> WfPredicates<'a, 'tcx> {
iter::zip(predicates, origins.into_iter().rev())
.map(|((pred, span), origin_def_id)| {
let code = if span.is_dummy() {
ObligationCauseCode::WhereClause(origin_def_id)
} else {
ObligationCauseCode::SpannedWhereClause(origin_def_id, span)
};
let code = ObligationCauseCode::WhereClause(origin_def_id, span);
let cause = self.cause(code);
traits::Obligation::with_depth(
self.tcx(),