1 //! Error Reporting for static impl Traits.
2
3 use crate::errors::{
4 ButCallingIntroduces, ButNeedsToSatisfy, DynTraitConstraintSuggestion, MoreTargeted,
5 ReqIntroducedLocations,
6 };
7 use crate::infer::error_reporting::nice_region_error::NiceRegionError;
8 use crate::infer::lexical_region_resolve::RegionResolutionError;
9 use crate::infer::{SubregionOrigin, TypeTrace};
10 use crate::traits::{ObligationCauseCode, UnifyReceiverContext};
11 use rustc_data_structures::fx::FxIndexSet;
12 use rustc_errors::{AddToDiagnostic, Applicability, Diagnostic, ErrorGuaranteed, MultiSpan};
13 use rustc_hir::def_id::DefId;
14 use rustc_hir::intravisit::{walk_ty, Visitor};
15 use rustc_hir::{
16 self as hir, GenericBound, GenericParamKind, Item, ItemKind, Lifetime, LifetimeName, Node,
17 TyKind,
18 };
19 use rustc_middle::ty::{
20 self, AssocItemContainer, StaticLifetimeVisitor, Ty, TyCtxt, TypeSuperVisitable, TypeVisitor,
21 };
22 use rustc_span::symbol::Ident;
23 use rustc_span::Span;
24
25 use rustc_span::def_id::LocalDefId;
26 use std::ops::ControlFlow;
27
28 impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
29 /// Print the error message for lifetime errors when the return type is a static `impl Trait`,
30 /// `dyn Trait` or if a method call on a trait object introduces a static requirement.
try_report_static_impl_trait(&self) -> Option<ErrorGuaranteed>31 pub(super) fn try_report_static_impl_trait(&self) -> Option<ErrorGuaranteed> {
32 debug!("try_report_static_impl_trait(error={:?})", self.error);
33 let tcx = self.tcx();
34 let (var_origin, sub_origin, sub_r, sup_origin, sup_r, spans) = match self.error.as_ref()? {
35 RegionResolutionError::SubSupConflict(
36 _,
37 var_origin,
38 sub_origin,
39 sub_r,
40 sup_origin,
41 sup_r,
42 spans,
43 ) if sub_r.is_static() => (var_origin, sub_origin, sub_r, sup_origin, sup_r, spans),
44 RegionResolutionError::ConcreteFailure(
45 SubregionOrigin::Subtype(box TypeTrace { cause, .. }),
46 sub_r,
47 sup_r,
48 ) if sub_r.is_static() => {
49 // This is for an implicit `'static` requirement coming from `impl dyn Trait {}`.
50 if let ObligationCauseCode::UnifyReceiver(ctxt) = cause.code() {
51 // This may have a closure and it would cause ICE
52 // through `find_param_with_region` (#78262).
53 let anon_reg_sup = tcx.is_suitable_region(*sup_r)?;
54 let fn_returns = tcx.return_type_impl_or_dyn_traits(anon_reg_sup.def_id);
55 if fn_returns.is_empty() {
56 return None;
57 }
58
59 let param = self.find_param_with_region(*sup_r, *sub_r)?;
60 let simple_ident = param.param.pat.simple_ident();
61
62 let (has_impl_path, impl_path) = match ctxt.assoc_item.container {
63 AssocItemContainer::TraitContainer => {
64 let id = ctxt.assoc_item.container_id(tcx);
65 (true, tcx.def_path_str(id))
66 }
67 AssocItemContainer::ImplContainer => (false, String::new()),
68 };
69
70 let mut err = self.tcx().sess.create_err(ButCallingIntroduces {
71 param_ty_span: param.param_ty_span,
72 cause_span: cause.span,
73 has_param_name: simple_ident.is_some(),
74 param_name: simple_ident.map(|x| x.to_string()).unwrap_or_default(),
75 has_lifetime: sup_r.has_name(),
76 lifetime: sup_r.to_string(),
77 assoc_item: ctxt.assoc_item.name,
78 has_impl_path,
79 impl_path,
80 });
81 if self.find_impl_on_dyn_trait(&mut err, param.param_ty, &ctxt) {
82 let reported = err.emit();
83 return Some(reported);
84 } else {
85 err.cancel()
86 }
87 }
88 return None;
89 }
90 _ => return None,
91 };
92 debug!(
93 "try_report_static_impl_trait(var={:?}, sub={:?} {:?} sup={:?} {:?})",
94 var_origin, sub_origin, sub_r, sup_origin, sup_r
95 );
96 let anon_reg_sup = tcx.is_suitable_region(*sup_r)?;
97 debug!("try_report_static_impl_trait: anon_reg_sup={:?}", anon_reg_sup);
98 let sp = var_origin.span();
99 let return_sp = sub_origin.span();
100 let param = self.find_param_with_region(*sup_r, *sub_r)?;
101 let simple_ident = param.param.pat.simple_ident();
102 let lifetime_name = if sup_r.has_name() { sup_r.to_string() } else { "'_".to_owned() };
103
104 let (mention_influencer, influencer_point) =
105 if sup_origin.span().overlaps(param.param_ty_span) {
106 // Account for `async fn` like in `async-await/issues/issue-62097.rs`.
107 // The desugaring of `async fn`s causes `sup_origin` and `param` to point at the same
108 // place (but with different `ctxt`, hence `overlaps` instead of `==` above).
109 //
110 // This avoids the following:
111 //
112 // LL | pub async fn run_dummy_fn(&self) {
113 // | ^^^^^
114 // | |
115 // | this data with an anonymous lifetime `'_`...
116 // | ...is captured here...
117 (false, sup_origin.span())
118 } else {
119 (!sup_origin.span().overlaps(return_sp), param.param_ty_span)
120 };
121
122 debug!("try_report_static_impl_trait: param_info={:?}", param);
123
124 let mut spans = spans.clone();
125
126 if mention_influencer {
127 spans.push(sup_origin.span());
128 }
129 // We dedup the spans *ignoring* expansion context.
130 spans.sort();
131 spans.dedup_by_key(|span| (span.lo(), span.hi()));
132
133 // We try to make the output have fewer overlapping spans if possible.
134 let require_span =
135 if sup_origin.span().overlaps(return_sp) { sup_origin.span() } else { return_sp };
136
137 let spans_empty = spans.is_empty();
138 let require_as_note = spans.iter().any(|sp| sp.overlaps(return_sp) || *sp > return_sp);
139 let bound = if let SubregionOrigin::RelateParamBound(_, _, Some(bound)) = sub_origin {
140 Some(*bound)
141 } else {
142 None
143 };
144
145 let mut subdiag = None;
146
147 if let SubregionOrigin::Subtype(box TypeTrace { cause, .. }) = sub_origin {
148 if let ObligationCauseCode::ReturnValue(hir_id)
149 | ObligationCauseCode::BlockTailExpression(hir_id) = cause.code()
150 {
151 let parent_id = tcx.hir().get_parent_item(*hir_id);
152 if let Some(fn_decl) = tcx.hir().fn_decl_by_hir_id(parent_id.into()) {
153 let mut span: MultiSpan = fn_decl.output.span().into();
154 let mut spans = Vec::new();
155 let mut add_label = true;
156 if let hir::FnRetTy::Return(ty) = fn_decl.output {
157 let mut v = StaticLifetimeVisitor(vec![], tcx.hir());
158 v.visit_ty(ty);
159 if !v.0.is_empty() {
160 span = v.0.clone().into();
161 spans = v.0;
162 add_label = false;
163 }
164 }
165 let fn_decl_span = fn_decl.output.span();
166
167 subdiag = Some(ReqIntroducedLocations {
168 span,
169 spans,
170 fn_decl_span,
171 cause_span: cause.span,
172 add_label,
173 });
174 }
175 }
176 }
177
178 let diag = ButNeedsToSatisfy {
179 sp,
180 influencer_point,
181 spans: spans.clone(),
182 // If any of the "captured here" labels appears on the same line or after
183 // `require_span`, we put it on a note to ensure the text flows by appearing
184 // always at the end.
185 require_span_as_note: require_as_note.then_some(require_span),
186 // We don't need a note, it's already at the end, it can be shown as a `span_label`.
187 require_span_as_label: (!require_as_note).then_some(require_span),
188 req_introduces_loc: subdiag,
189
190 has_lifetime: sup_r.has_name(),
191 lifetime: lifetime_name.clone(),
192 has_param_name: simple_ident.is_some(),
193 param_name: simple_ident.map(|x| x.to_string()).unwrap_or_default(),
194 spans_empty,
195 bound,
196 };
197
198 let mut err = self.tcx().sess.create_err(diag);
199
200 let fn_returns = tcx.return_type_impl_or_dyn_traits(anon_reg_sup.def_id);
201
202 let mut override_error_code = None;
203 if let SubregionOrigin::Subtype(box TypeTrace { cause, .. }) = &sup_origin
204 && let ObligationCauseCode::UnifyReceiver(ctxt) = cause.code()
205 // Handle case of `impl Foo for dyn Bar { fn qux(&self) {} }` introducing a
206 // `'static` lifetime when called as a method on a binding: `bar.qux()`.
207 && self.find_impl_on_dyn_trait(&mut err, param.param_ty, &ctxt)
208 {
209 override_error_code = Some(ctxt.assoc_item.name);
210 }
211
212 if let SubregionOrigin::Subtype(box TypeTrace { cause, .. }) = &sub_origin
213 && let code = match cause.code() {
214 ObligationCauseCode::MatchImpl(parent, ..) => parent.code(),
215 _ => cause.code(),
216 }
217 && let (&ObligationCauseCode::ItemObligation(item_def_id) | &ObligationCauseCode::ExprItemObligation(item_def_id, ..), None) = (code, override_error_code)
218 {
219 // Same case of `impl Foo for dyn Bar { fn qux(&self) {} }` introducing a `'static`
220 // lifetime as above, but called using a fully-qualified path to the method:
221 // `Foo::qux(bar)`.
222 let mut v = TraitObjectVisitor(FxIndexSet::default());
223 v.visit_ty(param.param_ty);
224 if let Some((ident, self_ty)) =
225 NiceRegionError::get_impl_ident_and_self_ty_from_trait(tcx, item_def_id, &v.0)
226 && self.suggest_constrain_dyn_trait_in_impl(&mut err, &v.0, ident, self_ty)
227 {
228 override_error_code = Some(ident.name);
229 }
230 }
231 if let (Some(ident), true) = (override_error_code, fn_returns.is_empty()) {
232 // Provide a more targeted error code and description.
233 let retarget_subdiag = MoreTargeted { ident };
234 retarget_subdiag.add_to_diagnostic(&mut err);
235 }
236
237 let arg = match param.param.pat.simple_ident() {
238 Some(simple_ident) => format!("argument `{}`", simple_ident),
239 None => "the argument".to_string(),
240 };
241 let captures = format!("captures data from {}", arg);
242 suggest_new_region_bound(
243 tcx,
244 &mut err,
245 fn_returns,
246 lifetime_name,
247 Some(arg),
248 captures,
249 Some((param.param_ty_span, param.param_ty.to_string())),
250 Some(anon_reg_sup.def_id),
251 );
252
253 let reported = err.emit();
254 Some(reported)
255 }
256 }
257
suggest_new_region_bound( tcx: TyCtxt<'_>, err: &mut Diagnostic, fn_returns: Vec<&rustc_hir::Ty<'_>>, lifetime_name: String, arg: Option<String>, captures: String, param: Option<(Span, String)>, scope_def_id: Option<LocalDefId>, )258 pub fn suggest_new_region_bound(
259 tcx: TyCtxt<'_>,
260 err: &mut Diagnostic,
261 fn_returns: Vec<&rustc_hir::Ty<'_>>,
262 lifetime_name: String,
263 arg: Option<String>,
264 captures: String,
265 param: Option<(Span, String)>,
266 scope_def_id: Option<LocalDefId>,
267 ) {
268 debug!("try_report_static_impl_trait: fn_return={:?}", fn_returns);
269 // FIXME: account for the need of parens in `&(dyn Trait + '_)`
270 let consider = "consider changing";
271 let declare = "to declare that";
272 let explicit = format!("you can add an explicit `{}` lifetime bound", lifetime_name);
273 let explicit_static =
274 arg.map(|arg| format!("explicit `'static` bound to the lifetime of {}", arg));
275 let add_static_bound = "alternatively, add an explicit `'static` bound to this reference";
276 let plus_lt = format!(" + {}", lifetime_name);
277 for fn_return in fn_returns {
278 if fn_return.span.desugaring_kind().is_some() {
279 // Skip `async` desugaring `impl Future`.
280 continue;
281 }
282 match fn_return.kind {
283 TyKind::OpaqueDef(item_id, _, _) => {
284 let item = tcx.hir().item(item_id);
285 let ItemKind::OpaqueTy(opaque) = &item.kind else {
286 return;
287 };
288
289 // Get the identity type for this RPIT
290 let did = item_id.owner_id.to_def_id();
291 let ty = Ty::new_opaque(tcx, did, ty::InternalSubsts::identity_for_item(tcx, did));
292
293 if let Some(span) = opaque.bounds.iter().find_map(|arg| match arg {
294 GenericBound::Outlives(Lifetime {
295 res: LifetimeName::Static, ident, ..
296 }) => Some(ident.span),
297 _ => None,
298 }) {
299 if let Some(explicit_static) = &explicit_static {
300 err.span_suggestion_verbose(
301 span,
302 format!("{consider} `{ty}`'s {explicit_static}"),
303 &lifetime_name,
304 Applicability::MaybeIncorrect,
305 );
306 }
307 if let Some((param_span, ref param_ty)) = param {
308 err.span_suggestion_verbose(
309 param_span,
310 add_static_bound,
311 param_ty,
312 Applicability::MaybeIncorrect,
313 );
314 }
315 } else if opaque.bounds.iter().any(|arg| {
316 matches!(arg,
317 GenericBound::Outlives(Lifetime { ident, .. })
318 if ident.name.to_string() == lifetime_name )
319 }) {
320 } else {
321 // get a lifetime name of existing named lifetimes if any
322 let existing_lt_name = if let Some(id) = scope_def_id
323 && let Some(generics) = tcx.hir().get_generics(id)
324 && let named_lifetimes = generics
325 .params
326 .iter()
327 .filter(|p| matches!(p.kind, GenericParamKind::Lifetime { kind: hir::LifetimeParamKind::Explicit }))
328 .map(|p| { if let hir::ParamName::Plain(name) = p.name {Some(name.to_string())} else {None}})
329 .filter(|n| ! matches!(n, None))
330 .collect::<Vec<_>>()
331 && named_lifetimes.len() > 0 {
332 named_lifetimes[0].clone()
333 } else {
334 None
335 };
336 let name = if let Some(name) = &existing_lt_name {
337 format!("{}", name)
338 } else {
339 format!("'a")
340 };
341 // if there are more than one elided lifetimes in inputs, the explicit `'_` lifetime cannot be used.
342 // introducing a new lifetime `'a` or making use of one from existing named lifetimes if any
343 if let Some(id) = scope_def_id
344 && let Some(generics) = tcx.hir().get_generics(id)
345 && let mut spans_suggs = generics
346 .params
347 .iter()
348 .filter(|p| p.is_elided_lifetime())
349 .map(|p|
350 if p.span.hi() - p.span.lo() == rustc_span::BytePos(1) { // Ampersand (elided without '_)
351 (p.span.shrink_to_hi(),format!("{name} "))
352 } else { // Underscore (elided with '_)
353 (p.span, format!("{name}"))
354 }
355 )
356 .collect::<Vec<_>>()
357 && spans_suggs.len() > 1
358 {
359 let use_lt =
360 if existing_lt_name == None {
361 spans_suggs.push((generics.span.shrink_to_hi(), format!("<{name}>")));
362 format!("you can introduce a named lifetime parameter `{name}`")
363 } else {
364 // make use the existing named lifetime
365 format!("you can use the named lifetime parameter `{name}`")
366 };
367 spans_suggs
368 .push((fn_return.span.shrink_to_hi(), format!(" + {name} ")));
369 err.multipart_suggestion_verbose(
370 format!(
371 "{declare} `{ty}` {captures}, {use_lt}",
372 ),
373 spans_suggs,
374 Applicability::MaybeIncorrect,
375 );
376 } else {
377 err.span_suggestion_verbose(
378 fn_return.span.shrink_to_hi(),
379 format!("{declare} `{ty}` {captures}, {explicit}",),
380 &plus_lt,
381 Applicability::MaybeIncorrect,
382 );
383 }
384 }
385 }
386 TyKind::TraitObject(_, lt, _) => {
387 if let LifetimeName::ImplicitObjectLifetimeDefault = lt.res {
388 err.span_suggestion_verbose(
389 fn_return.span.shrink_to_hi(),
390 format!(
391 "{declare} the trait object {captures}, {explicit}",
392 declare = declare,
393 captures = captures,
394 explicit = explicit,
395 ),
396 &plus_lt,
397 Applicability::MaybeIncorrect,
398 );
399 } else if lt.ident.name.to_string() != lifetime_name {
400 // With this check we avoid suggesting redundant bounds. This
401 // would happen if there are nested impl/dyn traits and only
402 // one of them has the bound we'd suggest already there, like
403 // in `impl Foo<X = dyn Bar> + '_`.
404 if let Some(explicit_static) = &explicit_static {
405 err.span_suggestion_verbose(
406 lt.ident.span,
407 format!("{} the trait object's {}", consider, explicit_static),
408 &lifetime_name,
409 Applicability::MaybeIncorrect,
410 );
411 }
412 if let Some((param_span, param_ty)) = param.clone() {
413 err.span_suggestion_verbose(
414 param_span,
415 add_static_bound,
416 param_ty,
417 Applicability::MaybeIncorrect,
418 );
419 }
420 }
421 }
422 _ => {}
423 }
424 }
425 }
426
427 impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
get_impl_ident_and_self_ty_from_trait( tcx: TyCtxt<'tcx>, def_id: DefId, trait_objects: &FxIndexSet<DefId>, ) -> Option<(Ident, &'tcx hir::Ty<'tcx>)>428 pub fn get_impl_ident_and_self_ty_from_trait(
429 tcx: TyCtxt<'tcx>,
430 def_id: DefId,
431 trait_objects: &FxIndexSet<DefId>,
432 ) -> Option<(Ident, &'tcx hir::Ty<'tcx>)> {
433 match tcx.hir().get_if_local(def_id)? {
434 Node::ImplItem(impl_item) => {
435 let impl_did = tcx.hir().get_parent_item(impl_item.hir_id());
436 if let hir::OwnerNode::Item(Item {
437 kind: ItemKind::Impl(hir::Impl { self_ty, .. }),
438 ..
439 }) = tcx.hir().owner(impl_did)
440 {
441 Some((impl_item.ident, self_ty))
442 } else {
443 None
444 }
445 }
446 Node::TraitItem(trait_item) => {
447 let trait_id = tcx.hir().get_parent_item(trait_item.hir_id());
448 debug_assert_eq!(tcx.def_kind(trait_id.def_id), hir::def::DefKind::Trait);
449 // The method being called is defined in the `trait`, but the `'static`
450 // obligation comes from the `impl`. Find that `impl` so that we can point
451 // at it in the suggestion.
452 let trait_did = trait_id.to_def_id();
453 tcx.hir().trait_impls(trait_did).iter().find_map(|&impl_did| {
454 if let Node::Item(Item {
455 kind: ItemKind::Impl(hir::Impl { self_ty, .. }),
456 ..
457 }) = tcx.hir().find_by_def_id(impl_did)?
458 && trait_objects.iter().all(|did| {
459 // FIXME: we should check `self_ty` against the receiver
460 // type in the `UnifyReceiver` context, but for now, use
461 // this imperfect proxy. This will fail if there are
462 // multiple `impl`s for the same trait like
463 // `impl Foo for Box<dyn Bar>` and `impl Foo for dyn Bar`.
464 // In that case, only the first one will get suggestions.
465 let mut traits = vec![];
466 let mut hir_v = HirTraitObjectVisitor(&mut traits, *did);
467 hir_v.visit_ty(self_ty);
468 !traits.is_empty()
469 })
470 {
471 Some((trait_item.ident, *self_ty))
472 } else {
473 None
474 }
475 })
476 }
477 _ => None,
478 }
479 }
480
481 /// When we call a method coming from an `impl Foo for dyn Bar`, `dyn Bar` introduces a default
482 /// `'static` obligation. Suggest relaxing that implicit bound.
find_impl_on_dyn_trait( &self, err: &mut Diagnostic, ty: Ty<'_>, ctxt: &UnifyReceiverContext<'tcx>, ) -> bool483 fn find_impl_on_dyn_trait(
484 &self,
485 err: &mut Diagnostic,
486 ty: Ty<'_>,
487 ctxt: &UnifyReceiverContext<'tcx>,
488 ) -> bool {
489 let tcx = self.tcx();
490
491 // Find the method being called.
492 let Ok(Some(instance)) = ty::Instance::resolve(
493 tcx,
494 ctxt.param_env,
495 ctxt.assoc_item.def_id,
496 self.cx.resolve_vars_if_possible(ctxt.substs),
497 ) else {
498 return false;
499 };
500
501 let mut v = TraitObjectVisitor(FxIndexSet::default());
502 v.visit_ty(ty);
503
504 // Get the `Ident` of the method being called and the corresponding `impl` (to point at
505 // `Bar` in `impl Foo for dyn Bar {}` and the definition of the method being called).
506 let Some((ident, self_ty)) = NiceRegionError::get_impl_ident_and_self_ty_from_trait(tcx, instance.def_id(), &v.0) else {
507 return false;
508 };
509
510 // Find the trait object types in the argument, so we point at *only* the trait object.
511 self.suggest_constrain_dyn_trait_in_impl(err, &v.0, ident, self_ty)
512 }
513
suggest_constrain_dyn_trait_in_impl( &self, err: &mut Diagnostic, found_dids: &FxIndexSet<DefId>, ident: Ident, self_ty: &hir::Ty<'_>, ) -> bool514 fn suggest_constrain_dyn_trait_in_impl(
515 &self,
516 err: &mut Diagnostic,
517 found_dids: &FxIndexSet<DefId>,
518 ident: Ident,
519 self_ty: &hir::Ty<'_>,
520 ) -> bool {
521 let mut suggested = false;
522 for found_did in found_dids {
523 let mut traits = vec![];
524 let mut hir_v = HirTraitObjectVisitor(&mut traits, *found_did);
525 hir_v.visit_ty(&self_ty);
526 for &span in &traits {
527 let subdiag = DynTraitConstraintSuggestion { span, ident };
528 subdiag.add_to_diagnostic(err);
529 suggested = true;
530 }
531 }
532 suggested
533 }
534 }
535
536 /// Collect all the trait objects in a type that could have received an implicit `'static` lifetime.
537 pub struct TraitObjectVisitor(pub FxIndexSet<DefId>);
538
539 impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for TraitObjectVisitor {
visit_ty(&mut self, t: Ty<'tcx>) -> ControlFlow<Self::BreakTy>540 fn visit_ty(&mut self, t: Ty<'tcx>) -> ControlFlow<Self::BreakTy> {
541 match t.kind() {
542 ty::Dynamic(preds, re, _) if re.is_static() => {
543 if let Some(def_id) = preds.principal_def_id() {
544 self.0.insert(def_id);
545 }
546 ControlFlow::Continue(())
547 }
548 _ => t.super_visit_with(self),
549 }
550 }
551 }
552
553 /// Collect all `hir::Ty<'_>` `Span`s for trait objects with an implicit lifetime.
554 pub struct HirTraitObjectVisitor<'a>(pub &'a mut Vec<Span>, pub DefId);
555
556 impl<'a, 'tcx> Visitor<'tcx> for HirTraitObjectVisitor<'a> {
visit_ty(&mut self, t: &'tcx hir::Ty<'tcx>)557 fn visit_ty(&mut self, t: &'tcx hir::Ty<'tcx>) {
558 if let TyKind::TraitObject(
559 poly_trait_refs,
560 Lifetime { res: LifetimeName::ImplicitObjectLifetimeDefault, .. },
561 _,
562 ) = t.kind
563 {
564 for ptr in poly_trait_refs {
565 if Some(self.1) == ptr.trait_ref.trait_def_id() {
566 self.0.push(ptr.span);
567 }
568 }
569 }
570 walk_ty(self, t);
571 }
572 }
573