mirror of
https://github.com/rust-lang/rust.git
synced 2024-11-27 01:04:03 +00:00
Add proper tracing spans to rustc_trait_selection::traits::error_reporting
This commit is contained in:
Noa
parent
9d20fd1098
commit
976336dab0
@ -259,7 +259,7 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
|
||||
let cycle = self.resolve_vars_if_possible(cycle.to_owned());
|
||||
assert!(!cycle.is_empty());
|
||||
|
||||
debug!("report_overflow_error_cycle: cycle={:?}", cycle);
|
||||
debug!(?cycle, "report_overflow_error_cycle");
|
||||
|
||||
// The 'deepest' obligation is most likely to have a useful
|
||||
// cause 'backtrace'
|
||||
@ -1513,6 +1513,7 @@ impl<'a, 'tcx> InferCtxtPrivExt<'a, 'tcx> for InferCtxt<'a, 'tcx> {
|
||||
}
|
||||
}
|
||||
|
||||
#[instrument(level = "debug", skip_all)]
|
||||
fn report_projection_error(
|
||||
&self,
|
||||
obligation: &PredicateObligation<'tcx>,
|
||||
@ -1551,15 +1552,9 @@ impl<'a, 'tcx> InferCtxtPrivExt<'a, 'tcx> for InferCtxt<'a, 'tcx> {
|
||||
&mut obligations,
|
||||
);
|
||||
|
||||
debug!(
|
||||
"report_projection_error obligation.cause={:?} obligation.param_env={:?}",
|
||||
obligation.cause, obligation.param_env
|
||||
);
|
||||
debug!(?obligation.cause, ?obligation.param_env);
|
||||
|
||||
debug!(
|
||||
"report_projection_error normalized_ty={:?} data.ty={:?}",
|
||||
normalized_ty, data.term,
|
||||
);
|
||||
debug!(?normalized_ty, data.ty = ?data.term);
|
||||
|
||||
let is_normalized_ty_expected = !matches!(
|
||||
obligation.cause.code().peel_derives(),
|
||||
@ -2346,6 +2341,7 @@ impl<'a, 'tcx> InferCtxtPrivExt<'a, 'tcx> for InferCtxt<'a, 'tcx> {
|
||||
}
|
||||
}
|
||||
|
||||
#[instrument(level = "debug", skip_all)]
|
||||
fn suggest_unsized_bound_if_applicable(
|
||||
&self,
|
||||
err: &mut Diagnostic,
|
||||
@ -2360,10 +2356,7 @@ impl<'a, 'tcx> InferCtxtPrivExt<'a, 'tcx> for InferCtxt<'a, 'tcx> {
|
||||
) else {
|
||||
return;
|
||||
};
|
||||
debug!(
|
||||
"suggest_unsized_bound_if_applicable: pred={:?} item_def_id={:?} span={:?}",
|
||||
pred, item_def_id, span
|
||||
);
|
||||
debug!(?pred, ?item_def_id, ?span);
|
||||
|
||||
let (Some(node), true) = (
|
||||
self.tcx.hir().get_if_local(item_def_id),
|
||||
@ -2374,6 +2367,7 @@ impl<'a, 'tcx> InferCtxtPrivExt<'a, 'tcx> for InferCtxt<'a, 'tcx> {
|
||||
self.maybe_suggest_unsized_generics(err, span, node);
|
||||
}
|
||||
|
||||
#[instrument(level = "debug", skip_all)]
|
||||
fn maybe_suggest_unsized_generics<'hir>(
|
||||
&self,
|
||||
err: &mut Diagnostic,
|
||||
@ -2384,8 +2378,8 @@ impl<'a, 'tcx> InferCtxtPrivExt<'a, 'tcx> for InferCtxt<'a, 'tcx> {
|
||||
return;
|
||||
};
|
||||
let sized_trait = self.tcx.lang_items().sized_trait();
|
||||
debug!("maybe_suggest_unsized_generics: generics.params={:?}", generics.params);
|
||||
debug!("maybe_suggest_unsized_generics: generics.predicates={:?}", generics.predicates);
|
||||
debug!(?generics.params);
|
||||
debug!(?generics.predicates);
|
||||
let Some(param) = generics.params.iter().find(|param| param.span == span) else {
|
||||
return;
|
||||
};
|
||||
@ -2399,7 +2393,7 @@ impl<'a, 'tcx> InferCtxtPrivExt<'a, 'tcx> for InferCtxt<'a, 'tcx> {
|
||||
if explicitly_sized {
|
||||
return;
|
||||
}
|
||||
debug!("maybe_suggest_unsized_generics: param={:?}", param);
|
||||
debug!(?param);
|
||||
match node {
|
||||
hir::Node::Item(
|
||||
item @ hir::Item {
|
||||
@ -2517,7 +2511,7 @@ impl<'v> Visitor<'v> for FindTypeParam {
|
||||
if path.segments.len() == 1 && path.segments[0].ident.name == self.param =>
|
||||
{
|
||||
if !self.nested {
|
||||
debug!("FindTypeParam::visit_ty: ty={:?}", ty);
|
||||
debug!(?ty, "FindTypeParam::visit_ty");
|
||||
self.invalid_spans.push(ty.span);
|
||||
}
|
||||
}
|
||||
|
||||
@ -1623,16 +1623,12 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
|
||||
/// ```
|
||||
///
|
||||
/// Returns `true` if an async-await specific note was added to the diagnostic.
|
||||
#[instrument(level = "debug", skip_all, fields(?obligation.predicate, ?obligation.cause.span))]
|
||||
fn maybe_note_obligation_cause_for_async_await(
|
||||
&self,
|
||||
err: &mut Diagnostic,
|
||||
obligation: &PredicateObligation<'tcx>,
|
||||
) -> bool {
|
||||
debug!(
|
||||
"maybe_note_obligation_cause_for_async_await: obligation.predicate={:?} \
|
||||
obligation.cause.span={:?}",
|
||||
obligation.predicate, obligation.cause.span
|
||||
);
|
||||
let hir = self.tcx.hir();
|
||||
|
||||
// Attempt to detect an async-await error by looking at the obligation causes, looking
|
||||
@ -1672,7 +1668,7 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
|
||||
let mut seen_upvar_tys_infer_tuple = false;
|
||||
|
||||
while let Some(code) = next_code {
|
||||
debug!("maybe_note_obligation_cause_for_async_await: code={:?}", code);
|
||||
debug!(?code);
|
||||
match code {
|
||||
ObligationCauseCode::FunctionArgumentObligation { parent_code, .. } => {
|
||||
next_code = Some(parent_code);
|
||||
@ -1680,10 +1676,9 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
|
||||
ObligationCauseCode::ImplDerivedObligation(cause) => {
|
||||
let ty = cause.derived.parent_trait_pred.skip_binder().self_ty();
|
||||
debug!(
|
||||
"maybe_note_obligation_cause_for_async_await: ImplDerived \
|
||||
parent_trait_ref={:?} self_ty.kind={:?}",
|
||||
cause.derived.parent_trait_pred,
|
||||
ty.kind()
|
||||
parent_trait_ref = ?cause.derived.parent_trait_pred,
|
||||
self_ty.kind = ?ty.kind(),
|
||||
"ImplDerived",
|
||||
);
|
||||
|
||||
match *ty.kind() {
|
||||
@ -1712,10 +1707,8 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
|
||||
| ObligationCauseCode::BuiltinDerivedObligation(derived_obligation) => {
|
||||
let ty = derived_obligation.parent_trait_pred.skip_binder().self_ty();
|
||||
debug!(
|
||||
"maybe_note_obligation_cause_for_async_await: \
|
||||
parent_trait_ref={:?} self_ty.kind={:?}",
|
||||
derived_obligation.parent_trait_pred,
|
||||
ty.kind()
|
||||
parent_trait_ref = ?derived_obligation.parent_trait_pred,
|
||||
self_ty.kind = ?ty.kind(),
|
||||
);
|
||||
|
||||
match *ty.kind() {
|
||||
@ -1745,7 +1738,7 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
|
||||
}
|
||||
|
||||
// Only continue if a generator was found.
|
||||
debug!(?generator, ?trait_ref, ?target_ty, "maybe_note_obligation_cause_for_async_await");
|
||||
debug!(?generator, ?trait_ref, ?target_ty);
|
||||
let (Some(generator_did), Some(trait_ref), Some(target_ty)) = (generator, trait_ref, target_ty) else {
|
||||
return false;
|
||||
};
|
||||
@ -1755,12 +1748,10 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
|
||||
let in_progress_typeck_results = self.in_progress_typeck_results.map(|t| t.borrow());
|
||||
let generator_did_root = self.tcx.typeck_root_def_id(generator_did);
|
||||
debug!(
|
||||
"maybe_note_obligation_cause_for_async_await: generator_did={:?} \
|
||||
generator_did_root={:?} in_progress_typeck_results.hir_owner={:?} span={:?}",
|
||||
generator_did,
|
||||
generator_did_root,
|
||||
in_progress_typeck_results.as_ref().map(|t| t.hir_owner),
|
||||
span
|
||||
?generator_did,
|
||||
?generator_did_root,
|
||||
in_progress_typeck_results.hir_owner = ?in_progress_typeck_results.as_ref().map(|t| t.hir_owner),
|
||||
?span,
|
||||
);
|
||||
|
||||
let generator_body = generator_did
|
||||
@ -1783,7 +1774,7 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
|
||||
if let Some(body) = generator_body {
|
||||
visitor.visit_body(body);
|
||||
}
|
||||
debug!("maybe_note_obligation_cause_for_async_await: awaits = {:?}", visitor.awaits);
|
||||
debug!(awaits = ?visitor.awaits);
|
||||
|
||||
// Look for a type inside the generator interior that matches the target type to get
|
||||
// a span.
|
||||
@ -1804,11 +1795,7 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
|
||||
let ty_erased = self.tcx.erase_late_bound_regions(ty);
|
||||
let ty_erased = self.tcx.erase_regions(ty_erased);
|
||||
let eq = ty_erased == target_ty_erased;
|
||||
debug!(
|
||||
"maybe_note_obligation_cause_for_async_await: ty_erased={:?} \
|
||||
target_ty_erased={:?} eq={:?}",
|
||||
ty_erased, target_ty_erased, eq
|
||||
);
|
||||
debug!(?ty_erased, ?target_ty_erased, ?eq);
|
||||
eq
|
||||
};
|
||||
|
||||
@ -1883,6 +1870,7 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
|
||||
|
||||
/// Unconditionally adds the diagnostic note described in
|
||||
/// `maybe_note_obligation_cause_for_async_await`'s documentation comment.
|
||||
#[instrument(level = "debug", skip_all)]
|
||||
fn note_obligation_cause_for_async_await(
|
||||
&self,
|
||||
err: &mut Diagnostic,
|
||||
@ -2032,8 +2020,9 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
|
||||
} else {
|
||||
// Look at the last interior type to get a span for the `.await`.
|
||||
debug!(
|
||||
"note_obligation_cause_for_async_await generator_interior_types: {:#?}",
|
||||
typeck_results.as_ref().map(|t| &t.generator_interior_types)
|
||||
generator_interior_types = ?format_args!(
|
||||
"{:#?}", typeck_results.as_ref().map(|t| &t.generator_interior_types)
|
||||
),
|
||||
);
|
||||
explain_yield(interior_span, yield_span, scope_span);
|
||||
}
|
||||
@ -2068,7 +2057,7 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
|
||||
// bar(Foo(std::ptr::null())).await;
|
||||
// ^^^^^^^^^^^^^^^^^^^^^ raw-ptr `*T` created inside this struct ctor.
|
||||
// ```
|
||||
debug!("parent_def_kind: {:?}", self.tcx.def_kind(parent_did));
|
||||
debug!(parent_def_kind = ?self.tcx.def_kind(parent_did));
|
||||
let is_raw_borrow_inside_fn_like_call =
|
||||
match self.tcx.def_kind(parent_did) {
|
||||
DefKind::Fn | DefKind::Ctor(..) => target_ty.is_unsafe_ptr(),
|
||||
@ -2126,7 +2115,7 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
|
||||
|
||||
// Add a note for the item obligation that remains - normally a note pointing to the
|
||||
// bound that introduced the obligation (e.g. `T: Send`).
|
||||
debug!("note_obligation_cause_for_async_await: next_code={:?}", next_code);
|
||||
debug!(?next_code);
|
||||
self.note_obligation_cause_code(
|
||||
err,
|
||||
&obligation.predicate,
|
||||
@ -2683,6 +2672,9 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
|
||||
));
|
||||
}
|
||||
|
||||
#[instrument(
|
||||
level = "debug", skip(self, err), fields(trait_pred.self_ty = ?trait_pred.self_ty())
|
||||
)]
|
||||
fn suggest_await_before_try(
|
||||
&self,
|
||||
err: &mut Diagnostic,
|
||||
@ -2690,13 +2682,6 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
|
||||
trait_pred: ty::PolyTraitPredicate<'tcx>,
|
||||
span: Span,
|
||||
) {
|
||||
debug!(
|
||||
"suggest_await_before_try: obligation={:?}, span={:?}, trait_pred={:?}, trait_pred_self_ty={:?}",
|
||||
obligation,
|
||||
span,
|
||||
trait_pred,
|
||||
trait_pred.self_ty()
|
||||
);
|
||||
let body_hir_id = obligation.cause.body_id;
|
||||
let item_id = self.tcx.hir().get_parent_node(body_hir_id);
|
||||
|
||||
@ -2734,14 +2719,13 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
|
||||
);
|
||||
|
||||
debug!(
|
||||
"suggest_await_before_try: normalized_projection_type {:?}",
|
||||
self.resolve_vars_if_possible(projection_ty)
|
||||
normalized_projection_type = ?self.resolve_vars_if_possible(projection_ty)
|
||||
);
|
||||
let try_obligation = self.mk_trait_obligation_with_new_self_ty(
|
||||
obligation.param_env,
|
||||
trait_pred.map_bound(|trait_pred| (trait_pred, projection_ty.skip_binder())),
|
||||
);
|
||||
debug!("suggest_await_before_try: try_trait_obligation {:?}", try_obligation);
|
||||
debug!(try_trait_obligation = ?try_obligation);
|
||||
if self.predicate_may_hold(&try_obligation)
|
||||
&& let Ok(snippet) = self.tcx.sess.source_map().span_to_snippet(span)
|
||||
&& snippet.ends_with('?')
|
||||
|
||||
Loading…
Reference in New Issue
Block a user