bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Rename some ObligationCauseCode variants

Browse source
This commit is contained in:
Michael Goulet 2024-05-09 20:12:47 -04:00
parent 4bde8a8f4b
commit 534e267d48
33 changed files with 186 additions and 246 deletions
Download patch file Download diff file Expand all files Collapse all files

14
compiler/rustc_trait_selection/src/solve/fulfill.rs
View file

@ -425,14 +425,12 @@ fn derive_cause<'tcx>(
tcx.predicates_of(impl_def_id).instantiate_identity(tcx).iter().nth(idx)
{
cause = cause.derived_cause(parent_trait_pred, |derived| {
ObligationCauseCode::ImplDerivedObligation(Box::new(
traits::ImplDerivedObligationCause {
derived,
impl_or_alias_def_id: impl_def_id,
impl_def_predicate_index: Some(idx),
span,
},
))
ObligationCauseCode::ImplDerived(Box::new(traits::ImplDerivedObligationCause {
derived,
impl_or_alias_def_id: impl_def_id,
impl_def_predicate_index: Some(idx),
span,
}))
})
}
}

6
compiler/rustc_trait_selection/src/traits/error_reporting/on_unimplemented.rs
View file

@ -127,9 +127,9 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
flags.push((sym::ItemContext, enclosure));
match obligation.cause.code() {
ObligationCauseCode::BuiltinDerivedObligation(..)
| ObligationCauseCode::ImplDerivedObligation(..)
| ObligationCauseCode::WellFormedDerivedObligation(..) => {}
ObligationCauseCode::BuiltinDerived(..)
| ObligationCauseCode::ImplDerived(..)
| ObligationCauseCode::WellFormedDerived(..) => {}
_ => {
// this is a "direct", user-specified, rather than derived,
// obligation.

88
compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs
View file

@ -455,8 +455,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
trait_pred: ty::PolyTraitPredicate<'tcx>,
) -> bool {
let mut code = obligation.cause.code();
if let ObligationCauseCode::FunctionArgumentObligation { arg_hir_id, call_hir_id, .. } =
code
if let ObligationCauseCode::FunctionArg { arg_hir_id, call_hir_id, .. } = code
&& let Some(typeck_results) = &self.typeck_results
&& let hir::Node::Expr(expr) = self.tcx.hir_node(*arg_hir_id)
&& let Some(arg_ty) = typeck_results.expr_ty_adjusted_opt(expr)
@ -846,7 +845,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
.collect::<Vec<_>>()
.join(", ");
if matches!(obligation.cause.code(), ObligationCauseCode::FunctionArgumentObligation { .. })
if matches!(obligation.cause.code(), ObligationCauseCode::FunctionArg { .. })
&& obligation.cause.span.can_be_used_for_suggestions()
{
// When the obligation error has been ensured to have been caused by
@ -980,8 +979,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
};
let ty::Ref(_, inner_ty, hir::Mutability::Not) = ty.kind() else { return false };
let ty::Param(param) = inner_ty.kind() else { return false };
let ObligationCauseCode::FunctionArgumentObligation { arg_hir_id, .. } =
obligation.cause.code()
let ObligationCauseCode::FunctionArg { arg_hir_id, .. } = obligation.cause.code()
else {
return false;
};
@ -1204,9 +1202,8 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
let span = obligation.cause.span;
let code = match obligation.cause.code() {
ObligationCauseCode::FunctionArgumentObligation { parent_code, .. } => parent_code,
c @ ObligationCauseCode::ItemObligation(_)
| c @ ObligationCauseCode::ExprItemObligation(..) => c,
ObligationCauseCode::FunctionArg { parent_code, .. } => parent_code,
c @ ObligationCauseCode::MiscItem(_) | c @ ObligationCauseCode::MiscItemInExpr(..) => c,
c if matches!(
span.ctxt().outer_expn_data().kind,
ExpnKind::Desugaring(DesugaringKind::ForLoop)
@ -1262,8 +1259,8 @@ 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::ItemObligation(_)
| ObligationCauseCode::ExprItemObligation(..) = obligation.cause.code()
if let ObligationCauseCode::MiscItem(_) | ObligationCauseCode::MiscItemInExpr(..) =
obligation.cause.code()
&& let ty::Ref(_, ty, mutability) = old_pred.self_ty().skip_binder().kind()
{
(
@ -1401,12 +1398,12 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
return false;
};
if let ObligationCauseCode::ImplDerivedObligation(cause) = &*code {
if let ObligationCauseCode::ImplDerived(cause) = &*code {
try_borrowing(cause.derived.parent_trait_pred, &[])
} else if let ObligationCauseCode::BindingObligation(_, _)
| ObligationCauseCode::ItemObligation(_)
| ObligationCauseCode::ExprItemObligation(..)
| ObligationCauseCode::ExprBindingObligation(..) = code
} else if let ObligationCauseCode::Where(_, _)
| ObligationCauseCode::MiscItem(_)
| ObligationCauseCode::MiscItemInExpr(..)
| ObligationCauseCode::WhereInExpr(..) = code
{
try_borrowing(poly_trait_pred, &never_suggest_borrow)
} else {
@ -1644,10 +1641,8 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
err: &mut Diag<'_>,
trait_pred: ty::PolyTraitPredicate<'tcx>,
) {
let points_at_arg = matches!(
obligation.cause.code(),
ObligationCauseCode::FunctionArgumentObligation { .. },
);
let points_at_arg =
matches!(obligation.cause.code(), ObligationCauseCode::FunctionArg { .. },);
let span = obligation.cause.span;
if let Ok(snippet) = self.tcx.sess.source_map().span_to_snippet(span) {
@ -1953,7 +1948,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
found: Ty<'tcx>,
param_env: ty::ParamEnv<'tcx>,
) {
let ObligationCauseCode::FunctionArgumentObligation { arg_hir_id, .. } = cause else {
let ObligationCauseCode::FunctionArg { arg_hir_id, .. } = cause else {
return;
};
let ty::FnPtr(expected) = expected.kind() else {
@ -2107,7 +2102,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
// First, look for an `ExprBindingObligation`, 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::ExprBindingObligation(def_id, _, _, idx) = cause
if let ObligationCauseCode::WhereInExpr(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()
@ -2261,10 +2256,10 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
while let Some(code) = next_code {
debug!(?code);
match code {
ObligationCauseCode::FunctionArgumentObligation { parent_code, .. } => {
ObligationCauseCode::FunctionArg { parent_code, .. } => {
next_code = Some(parent_code);
}
ObligationCauseCode::ImplDerivedObligation(cause) => {
ObligationCauseCode::ImplDerived(cause) => {
let ty = cause.derived.parent_trait_pred.skip_binder().self_ty();
debug!(
parent_trait_ref = ?cause.derived.parent_trait_pred,
@ -2293,8 +2288,8 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
next_code = Some(&cause.derived.parent_code);
}
ObligationCauseCode::WellFormedDerivedObligation(derived_obligation)
| ObligationCauseCode::BuiltinDerivedObligation(derived_obligation) => {
ObligationCauseCode::WellFormedDerived(derived_obligation)
| ObligationCauseCode::BuiltinDerived(derived_obligation) => {
let ty = derived_obligation.parent_trait_pred.skip_binder().self_ty();
debug!(
parent_trait_ref = ?derived_obligation.parent_trait_pred,
@ -2719,7 +2714,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
| ObligationCauseCode::MethodReceiver
| ObligationCauseCode::ReturnNoExpression
| ObligationCauseCode::UnifyReceiver(..)
| ObligationCauseCode::MiscObligation
| ObligationCauseCode::Misc
| ObligationCauseCode::WellFormed(..)
| ObligationCauseCode::MatchImpl(..)
| ObligationCauseCode::ReturnValue(_)
@ -2748,13 +2743,12 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
ObligationCauseCode::TupleElem => {
err.note("only the last element of a tuple may have a dynamically sized type");
}
ObligationCauseCode::ItemObligation(_)
| ObligationCauseCode::ExprItemObligation(..) => {
ObligationCauseCode::MiscItem(_) | ObligationCauseCode::MiscItemInExpr(..) => {
// 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::BindingObligation(item_def_id, span)
| ObligationCauseCode::ExprBindingObligation(item_def_id, span, ..) => {
ObligationCauseCode::Where(item_def_id, span)
| ObligationCauseCode::WhereInExpr(item_def_id, span, ..) => {
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);
@ -3175,7 +3169,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
ObligationCauseCode::SharedStatic => {
err.note("shared static variables must have a type that implements `Sync`");
}
ObligationCauseCode::BuiltinDerivedObligation(ref data) => {
ObligationCauseCode::BuiltinDerived(ref data) => {
let parent_trait_ref = self.resolve_vars_if_possible(data.parent_trait_pred);
let ty = parent_trait_ref.skip_binder().self_ty();
if parent_trait_ref.references_error() {
@ -3190,8 +3184,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
let is_upvar_tys_infer_tuple = if !matches!(ty.kind(), ty::Tuple(..)) {
false
} else {
if let ObligationCauseCode::BuiltinDerivedObligation(data) = &*data.parent_code
{
if let ObligationCauseCode::BuiltinDerived(data) = &*data.parent_code {
let parent_trait_ref =
self.resolve_vars_if_possible(data.parent_trait_pred);
let nested_ty = parent_trait_ref.skip_binder().self_ty();
@ -3297,7 +3290,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
});
}
}
ObligationCauseCode::ImplDerivedObligation(ref data) => {
ObligationCauseCode::ImplDerived(ref data) => {
let mut parent_trait_pred =
self.resolve_vars_if_possible(data.derived.parent_trait_pred);
let parent_def_id = parent_trait_pred.def_id();
@ -3367,9 +3360,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
if is_auto_trait {
// We don't want to point at the ADT saying "required because it appears within
// the type `X`", like we would otherwise do in test `supertrait-auto-trait.rs`.
while let ObligationCauseCode::BuiltinDerivedObligation(derived) =
&*data.parent_code
{
while let ObligationCauseCode::BuiltinDerived(derived) = &*data.parent_code {
let child_trait_ref =
self.resolve_vars_if_possible(derived.parent_trait_pred);
let child_def_id = child_trait_ref.def_id();
@ -3381,7 +3372,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
parent_trait_pred = child_trait_ref;
}
}
while let ObligationCauseCode::ImplDerivedObligation(child) = &*data.parent_code {
while let ObligationCauseCode::ImplDerived(child) = &*data.parent_code {
// Skip redundant recursive obligation notes. See `ui/issue-20413.rs`.
let child_trait_pred =
self.resolve_vars_if_possible(child.derived.parent_trait_pred);
@ -3422,7 +3413,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
)
});
}
ObligationCauseCode::WellFormedDerivedObligation(ref data) => {
ObligationCauseCode::WellFormedDerived(ref data) => {
let parent_trait_ref = self.resolve_vars_if_possible(data.parent_trait_pred);
let parent_predicate = parent_trait_ref;
// #74711: avoid a stack overflow
@ -3458,11 +3449,8 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
format!("required by a bound on the type alias `{}`", tcx.item_name(def_id)),
);
}
ObligationCauseCode::FunctionArgumentObligation {
arg_hir_id,
call_hir_id,
ref parent_code,
..
ObligationCauseCode::FunctionArg {
arg_hir_id, call_hir_id, ref parent_code, ..
} => {
self.note_function_argument_obligation(
body_id,
@ -3485,7 +3473,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
)
});
}
ObligationCauseCode::CompareImplItemObligation { trait_item_def_id, kind, .. } => {
ObligationCauseCode::CompareImplItem { trait_item_def_id, kind, .. } => {
let item_name = tcx.item_name(trait_item_def_id);
let msg = format!(
"the requirement `{predicate}` appears on the `impl`'s {kind} \
@ -3694,7 +3682,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
err: &mut Diag<'_>,
trait_pred: ty::PolyTraitPredicate<'tcx>,
) {
if let ObligationCauseCode::ImplDerivedObligation(_) = obligation.cause.code()
if let ObligationCauseCode::ImplDerived(_) = obligation.cause.code()
&& self
.tcx
.is_diagnostic_item(sym::SliceIndex, trait_pred.skip_binder().trait_ref.def_id)
@ -3811,7 +3799,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::ExprBindingObligation(def_id, _, _, idx) = parent_code
if let ObligationCauseCode::WhereInExpr(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)
@ -4320,8 +4308,8 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
) {
// We can only suggest the slice coersion for function and binary operation arguments,
// since the suggestion would make no sense in turbofish or call
let (ObligationCauseCode::BinOp { .. }
| ObligationCauseCode::FunctionArgumentObligation { .. }) = obligation.cause.code()
let (ObligationCauseCode::BinOp { .. } | ObligationCauseCode::FunctionArg { .. }) =
obligation.cause.code()
else {
return;
};
@ -4407,7 +4395,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
return;
}
if let ObligationCauseCode::FunctionArgumentObligation {
if let ObligationCauseCode::FunctionArg {
call_hir_id,
arg_hir_id,
parent_code: _,

42
compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs
View file

@ -391,7 +391,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
}
}
if let ObligationCauseCode::CompareImplItemObligation {
if let ObligationCauseCode::CompareImplItem {
impl_item_def_id,
trait_item_def_id,
kind: _,
@ -1017,7 +1017,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
if let Some((_, Some(parent))) = obligation.cause.code().parent() {
// If we have a derived obligation, then the parent will be a `AsyncFn*` goal.
trait_ref = parent.to_poly_trait_ref();
} else if let &ObligationCauseCode::FunctionArgumentObligation { arg_hir_id, .. } =
} else if let &ObligationCauseCode::FunctionArg { arg_hir_id, .. } =
obligation.cause.code()
&& let Some(typeck_results) = &self.typeck_results
&& let ty::Closure(closure_def_id, _) | ty::CoroutineClosure(closure_def_id, _) =
@ -1104,8 +1104,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
&self,
obligation: &PredicateObligation<'tcx>,
) -> Result<(), ErrorGuaranteed> {
if let ObligationCauseCode::FunctionArgumentObligation { arg_hir_id, .. } =
obligation.cause.code()
if let ObligationCauseCode::FunctionArg { arg_hir_id, .. } = obligation.cause.code()
&& let Node::Expr(arg) = self.tcx.hir_node(*arg_hir_id)
&& let arg = arg.peel_borrows()
&& let hir::ExprKind::Path(hir::QPath::Resolved(
@ -1534,10 +1533,10 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
*err,
);
let code = error.obligation.cause.code().peel_derives().peel_match_impls();
if let ObligationCauseCode::BindingObligation(..)
| ObligationCauseCode::ItemObligation(..)
| ObligationCauseCode::ExprBindingObligation(..)
| ObligationCauseCode::ExprItemObligation(..) = code
if let ObligationCauseCode::Where(..)
| ObligationCauseCode::MiscItem(..)
| ObligationCauseCode::WhereInExpr(..)
| ObligationCauseCode::MiscItemInExpr(..) = code
{
self.note_obligation_cause_code(
error.obligation.cause.body_id,
@ -1611,10 +1610,10 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
let is_normalized_term_expected = !matches!(
obligation.cause.code().peel_derives(),
ObligationCauseCode::ItemObligation(_)
| ObligationCauseCode::BindingObligation(_, _)
| ObligationCauseCode::ExprItemObligation(..)
| ObligationCauseCode::ExprBindingObligation(..)
ObligationCauseCode::MiscItem(_)
| ObligationCauseCode::Where(_, _)
| ObligationCauseCode::MiscItemInExpr(..)
| ObligationCauseCode::WhereInExpr(..)
| ObligationCauseCode::Coercion { .. }
);
@ -2211,7 +2210,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
code: &ObligationCauseCode<'tcx>,
) -> Option<(Ty<'tcx>, Option<Span>)> {
match code {
ObligationCauseCode::BuiltinDerivedObligation(data) => {
ObligationCauseCode::BuiltinDerived(data) => {
let parent_trait_ref = self.resolve_vars_if_possible(data.parent_trait_pred);
match self.get_parent_trait_ref(&data.parent_code) {
Some(t) => Some(t),
@ -2223,7 +2222,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
}
}
}
ObligationCauseCode::FunctionArgumentObligation { parent_code, .. } => {
ObligationCauseCode::FunctionArg { parent_code, .. } => {
self.get_parent_trait_ref(parent_code)
}
_ => None,
@ -2446,8 +2445,8 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
}
}
if let ObligationCauseCode::ItemObligation(def_id)
| ObligationCauseCode::ExprItemObligation(def_id, ..) = *obligation.cause.code()
if let ObligationCauseCode::MiscItem(def_id)
| ObligationCauseCode::MiscItemInExpr(def_id, ..) = *obligation.cause.code()
{
self.suggest_fully_qualified_path(&mut err, def_id, span, trait_ref.def_id());
}
@ -2882,8 +2881,8 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
else {
return;
};
let (ObligationCauseCode::BindingObligation(item_def_id, span)
| ObligationCauseCode::ExprBindingObligation(item_def_id, span, ..)) =
let (ObligationCauseCode::Where(item_def_id, span)
| ObligationCauseCode::WhereInExpr(item_def_id, span, ..)) =
*obligation.cause.code().peel_derives()
else {
return;
@ -3003,7 +3002,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
obligated_types: &mut Vec<Ty<'tcx>>,
cause_code: &ObligationCauseCode<'tcx>,
) -> bool {
if let ObligationCauseCode::BuiltinDerivedObligation(ref data) = cause_code {
if let ObligationCauseCode::BuiltinDerived(ref data) = cause_code {
let parent_trait_ref = self.resolve_vars_if_possible(data.parent_trait_pred);
let self_ty = parent_trait_ref.skip_binder().self_ty();
if obligated_types.iter().any(|ot| ot == &self_ty) {
@ -3180,8 +3179,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::BindingObligation(def_id, _)
| ObligationCauseCode::ItemObligation(def_id)
ObligationCauseCode::Where(def_id, _) | ObligationCauseCode::MiscItem(def_id)
if self.tcx.is_fn_trait(*def_id) =>
{
err.code(E0059);
@ -3570,7 +3568,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
match self.tcx.sess.source_map().span_to_snippet(const_span) {
Ok(snippet) => {
let code = format!("[(); {snippet}{cast}]:");
let def_id = if let ObligationCauseCode::CompareImplItemObligation {
let def_id = if let ObligationCauseCode::CompareImplItem {
trait_item_def_id,
..
} = obligation.cause.code()

10
compiler/rustc_trait_selection/src/traits/project.rs
View file

@ -574,9 +574,9 @@ pub fn normalize_inherent_projection<'a, 'b, 'tcx>(
// diagnostics which is not ideal.
// Consider creating separate cause codes for this specific situation.
if span.is_dummy() {
ObligationCauseCode::ItemObligation(alias_ty.def_id)
ObligationCauseCode::MiscItem(alias_ty.def_id)
} else {
ObligationCauseCode::BindingObligation(alias_ty.def_id, span)
ObligationCauseCode::Where(alias_ty.def_id, span)
},
);
@ -2114,7 +2114,7 @@ fn assoc_ty_own_obligations<'cx, 'tcx>(
let nested_cause = if matches!(
obligation.cause.code(),
ObligationCauseCode::CompareImplItemObligation { .. }
ObligationCauseCode::CompareImplItem { .. }
| ObligationCauseCode::CheckAssociatedTypeBounds { .. }
| ObligationCauseCode::AscribeUserTypeProvePredicate(..)
) {
@ -2123,13 +2123,13 @@ fn assoc_ty_own_obligations<'cx, 'tcx>(
ObligationCause::new(
obligation.cause.span,
obligation.cause.body_id,
ObligationCauseCode::ItemObligation(obligation.predicate.def_id),
ObligationCauseCode::MiscItem(obligation.predicate.def_id),
)
} else {
ObligationCause::new(
obligation.cause.span,
obligation.cause.body_id,
ObligationCauseCode::BindingObligation(obligation.predicate.def_id, span),
ObligationCauseCode::Where(obligation.predicate.def_id, span),
)
};
nested.push(Obligation::with_depth(

2
compiler/rustc_trait_selection/src/traits/select/confirmation.rs
View file

@ -1396,7 +1396,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
debug!(?args, "impl args");
let cause = obligation.derived_cause(|derived| {
ObligationCauseCode::ImplDerivedObligation(Box::new(ImplDerivedObligationCause {
ObligationCauseCode::ImplDerived(Box::new(ImplDerivedObligationCause {
derived,
impl_or_alias_def_id: impl_def_id,
impl_def_predicate_index: None,

14
compiler/rustc_trait_selection/src/traits/select/mod.rs
View file

@ -2771,14 +2771,12 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
cause.clone()
} else {
cause.clone().derived_cause(parent_trait_pred, |derived| {
ObligationCauseCode::ImplDerivedObligation(Box::new(
ImplDerivedObligationCause {
derived,
impl_or_alias_def_id: def_id,
impl_def_predicate_index: Some(index),
span,
},
))
ObligationCauseCode::ImplDerived(Box::new(ImplDerivedObligationCause {
derived,
impl_or_alias_def_id: def_id,
impl_def_predicate_index: Some(index),
span,
}))
})
};
let clause = normalize_with_depth_to(

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

@ -566,9 +566,9 @@ 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::ItemObligation(origin_def_id)
ObligationCauseCode::MiscItem(origin_def_id)
} else {
ObligationCauseCode::BindingObligation(origin_def_id, span)
ObligationCauseCode::Where(origin_def_id, span)
};
let cause = self.cause(code);
traits::Obligation::with_depth(
@ -683,7 +683,7 @@ impl<'a, 'tcx> TypeVisitor<TyCtxt<'tcx>> for WfPredicates<'a, 'tcx> {
}
ty::Pat(subty, _) => {
self.require_sized(subty, ObligationCauseCode::MiscObligation);
self.require_sized(subty, ObligationCauseCode::Misc);
}
ty::Tuple(tys) => {