diff --git a/compiler/rustc_infer/src/infer/error_reporting/mod.rs b/compiler/rustc_infer/src/infer/error_reporting/mod.rs
index 72cfc1337e2f0..12dcb7118203a 100644
--- a/compiler/rustc_infer/src/infer/error_reporting/mod.rs
+++ b/compiler/rustc_infer/src/infer/error_reporting/mod.rs
@@ -59,20 +59,19 @@ use crate::traits::{
};
use rustc_data_structures::fx::{FxIndexMap, FxIndexSet};
+use rustc_errors::{error_code, Applicability, DiagnosticBuilder, DiagnosticStyledString};
use rustc_errors::{pluralize, struct_span_err, Diagnostic, ErrorGuaranteed, IntoDiagnosticArg};
-use rustc_errors::{Applicability, DiagnosticBuilder, DiagnosticStyledString};
use rustc_hir as hir;
use rustc_hir::def::DefKind;
use rustc_hir::def_id::{DefId, LocalDefId};
use rustc_hir::intravisit::Visitor;
use rustc_hir::lang_items::LangItem;
-use rustc_hir::Node;
use rustc_middle::dep_graph::DepContext;
use rustc_middle::ty::print::with_forced_trimmed_paths;
use rustc_middle::ty::relate::{self, RelateResult, TypeRelation};
use rustc_middle::ty::{
- self, error::TypeError, List, Region, Ty, TyCtxt, TypeFoldable, TypeSuperVisitable,
- TypeVisitable, TypeVisitableExt,
+ self, error::TypeError, IsSuggestable, List, Region, Ty, TyCtxt, TypeFoldable,
+ TypeSuperVisitable, TypeVisitable, TypeVisitableExt,
};
use rustc_span::{sym, symbol::kw, BytePos, DesugaringKind, Pos, Span};
use rustc_target::spec::abi;
@@ -2317,113 +2316,18 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
bound_kind: GenericKind<'tcx>,
sub: Region<'tcx>,
) -> DiagnosticBuilder<'tcx, ErrorGuaranteed> {
- // Attempt to obtain the span of the parameter so we can
- // suggest adding an explicit lifetime bound to it.
- let generics = self.tcx.generics_of(generic_param_scope);
- // type_param_span is (span, has_bounds)
- let mut is_synthetic = false;
- let mut ast_generics = None;
- let type_param_span = match bound_kind {
- GenericKind::Param(ref param) => {
- // Account for the case where `param` corresponds to `Self`,
- // which doesn't have the expected type argument.
- if !(generics.has_self && param.index == 0) {
- let type_param = generics.type_param(param, self.tcx);
- is_synthetic = type_param.kind.is_synthetic();
- type_param.def_id.as_local().map(|def_id| {
- // Get the `hir::Param` to verify whether it already has any bounds.
- // We do this to avoid suggesting code that ends up as `T: 'a'b`,
- // instead we suggest `T: 'a + 'b` in that case.
- let hir_id = self.tcx.hir().local_def_id_to_hir_id(def_id);
- ast_generics = self.tcx.hir().get_generics(hir_id.owner.def_id);
- let bounds =
- ast_generics.and_then(|g| g.bounds_span_for_suggestions(def_id));
- // `sp` only covers `T`, change it so that it covers
- // `T:` when appropriate
- if let Some(span) = bounds {
- (span, true)
- } else {
- let sp = self.tcx.def_span(def_id);
- (sp.shrink_to_hi(), false)
- }
- })
- } else {
- None
- }
- }
- _ => None,
- };
-
- let new_lt = {
- let mut possible = (b'a'..=b'z').map(|c| format!("'{}", c as char));
- let lts_names =
- iter::successors(Some(generics), |g| g.parent.map(|p| self.tcx.generics_of(p)))
- .flat_map(|g| &g.params)
- .filter(|p| matches!(p.kind, ty::GenericParamDefKind::Lifetime))
- .map(|p| p.name.as_str())
- .collect::<Vec<_>>();
- possible
- .find(|candidate| !lts_names.contains(&&candidate[..]))
- .unwrap_or("'lt".to_string())
- };
-
- let mut add_lt_suggs: Vec<Option<_>> = vec![];
- if is_synthetic {
- if let Some(ast_generics) = ast_generics {
- let named_lifetime_param_exist = ast_generics.params.iter().any(|p| {
- matches!(
- p.kind,
- hir::GenericParamKind::Lifetime { kind: hir::LifetimeParamKind::Explicit }
- )
- });
- if named_lifetime_param_exist && let [param, ..] = ast_generics.params
- {
- add_lt_suggs.push(Some((
- self.tcx.def_span(param.def_id).shrink_to_lo(),
- format!("{new_lt}, "),
- )));
- } else {
- add_lt_suggs
- .push(Some((ast_generics.span.shrink_to_hi(), format!("<{new_lt}>"))));
- }
- }
- } else {
- if let [param, ..] = &generics.params[..] && let Some(def_id) = param.def_id.as_local()
- {
- add_lt_suggs
- .push(Some((self.tcx.def_span(def_id).shrink_to_lo(), format!("{new_lt}, "))));
- }
- }
-
- if let Some(ast_generics) = ast_generics {
- for p in ast_generics.params {
- if p.is_elided_lifetime() {
- if self
- .tcx
- .sess
- .source_map()
- .span_to_prev_source(p.span.shrink_to_hi())
- .ok()
- .is_some_and(|s| *s.as_bytes().last().unwrap() == b'&')
- {
- add_lt_suggs
- .push(Some(
- (
- p.span.shrink_to_hi(),
- if let Ok(snip) = self.tcx.sess.source_map().span_to_next_source(p.span)
- && snip.starts_with(' ')
- {
- new_lt.to_string()
- } else {
- format!("{new_lt} ")
- }
- )
- ));
- } else {
- add_lt_suggs.push(Some((p.span.shrink_to_hi(), format!("<{new_lt}>"))));
- }
- }
- }
+ if let Some(SubregionOrigin::CompareImplItemObligation {
+ span,
+ impl_item_def_id,
+ trait_item_def_id,
+ }) = origin
+ {
+ return self.report_extra_impl_obligation(
+ span,
+ impl_item_def_id,
+ trait_item_def_id,
+ &format!("`{bound_kind}: {sub}`"),
+ );
}
let labeled_user_string = match bound_kind {
@@ -2437,223 +2341,207 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
},
};
- if let Some(SubregionOrigin::CompareImplItemObligation {
+ let mut err = self.tcx.sess.struct_span_err_with_code(
span,
- impl_item_def_id,
- trait_item_def_id,
- }) = origin
- {
- return self.report_extra_impl_obligation(
- span,
- impl_item_def_id,
- trait_item_def_id,
- &format!("`{bound_kind}: {sub}`"),
- );
+ format!("{labeled_user_string} may not live long enough"),
+ match sub.kind() {
+ ty::ReEarlyBound(_) | ty::ReFree(_) if sub.has_name() => error_code!(E0309),
+ ty::ReStatic => error_code!(E0310),
+ _ => error_code!(E0311),
+ },
+ );
+
+ '_explain: {
+ let (description, span) = match sub.kind() {
+ ty::ReEarlyBound(_) | ty::ReFree(_) | ty::ReStatic => {
+ msg_span_from_named_region(self.tcx, sub, Some(span))
+ }
+ _ => (format!("lifetime `{sub}`"), Some(span)),
+ };
+ let prefix = format!("{labeled_user_string} must be valid for ");
+ label_msg_span(&mut err, &prefix, description, span, "...");
+ if let Some(origin) = origin {
+ self.note_region_origin(&mut err, &origin);
+ }
}
- fn binding_suggestion<'tcx, S: fmt::Display>(
- err: &mut Diagnostic,
- type_param_span: Option<(Span, bool)>,
- bound_kind: GenericKind<'tcx>,
- sub: S,
- add_lt_suggs: Vec<Option<(Span, String)>>,
- ) {
+ 'suggestion: {
let msg = "consider adding an explicit lifetime bound";
- if let Some((sp, has_lifetimes)) = type_param_span {
- let suggestion =
- if has_lifetimes { format!(" + {sub}") } else { format!(": {sub}") };
- let mut suggestions = vec![(sp, suggestion)];
- for add_lt_sugg in add_lt_suggs.into_iter().flatten() {
- suggestions.push(add_lt_sugg);
+
+ if (bound_kind, sub).has_infer_regions()
+ || (bound_kind, sub).has_placeholders()
+ || !bound_kind.is_suggestable(self.tcx, false)
+ {
+ let lt_name = sub.get_name_or_anon().to_string();
+ err.help(format!("{msg} `{bound_kind}: {lt_name}`..."));
+ break 'suggestion;
+ }
+
+ let mut generic_param_scope = generic_param_scope;
+ while self.tcx.def_kind(generic_param_scope) == DefKind::OpaqueTy {
+ generic_param_scope = self.tcx.local_parent(generic_param_scope);
+ }
+
+ // type_param_sugg_span is (span, has_bounds)
+ let (type_scope, type_param_sugg_span) = match bound_kind {
+ GenericKind::Param(ref param) => {
+ let generics = self.tcx.generics_of(generic_param_scope);
+ let def_id = generics.type_param(param, self.tcx).def_id.expect_local();
+ let scope = self.tcx.local_def_id_to_hir_id(def_id).owner.def_id;
+ // Get the `hir::Param` to verify whether it already has any bounds.
+ // We do this to avoid suggesting code that ends up as `T: 'a'b`,
+ // instead we suggest `T: 'a + 'b` in that case.
+ let hir_generics = self.tcx.hir().get_generics(scope).unwrap();
+ let sugg_span = match hir_generics.bounds_span_for_suggestions(def_id) {
+ Some(span) => Some((span, true)),
+ // If `param` corresponds to `Self`, no usable suggestion span.
+ None if generics.has_self && param.index == 0 => None,
+ None => Some((self.tcx.def_span(def_id).shrink_to_hi(), false)),
+ };
+ (scope, sugg_span)
}
- err.multipart_suggestion_verbose(
- format!("{msg}..."),
- suggestions,
- Applicability::MaybeIncorrect, // Issue #41966
- );
- } else {
- let consider = format!("{msg} `{bound_kind}: {sub}`...");
- err.help(consider);
- }
- }
-
- let new_binding_suggestion =
- |err: &mut Diagnostic, type_param_span: Option<(Span, bool)>| {
- let msg = "consider introducing an explicit lifetime bound";
- if let Some((sp, has_lifetimes)) = type_param_span {
- let suggestion =
- if has_lifetimes { format!(" + {new_lt}") } else { format!(": {new_lt}") };
- let mut sugg =
- vec![(sp, suggestion), (span.shrink_to_hi(), format!(" + {new_lt}"))];
- for lt in add_lt_suggs.clone().into_iter().flatten() {
- sugg.push(lt);
- sugg.rotate_right(1);
- }
- // `MaybeIncorrect` due to issue #41966.
- err.multipart_suggestion(msg, sugg, Applicability::MaybeIncorrect);
+ _ => (generic_param_scope, None),
+ };
+ let suggestion_scope = {
+ let lifetime_scope = match sub.kind() {
+ ty::ReStatic => hir::def_id::CRATE_DEF_ID,
+ _ => match self.tcx.is_suitable_region(sub) {
+ Some(info) => info.def_id,
+ None => generic_param_scope,
+ },
+ };
+ match self.tcx.is_descendant_of(type_scope.into(), lifetime_scope.into()) {
+ true => type_scope,
+ false => lifetime_scope,
}
};
- #[derive(Debug)]
- enum SubOrigin<'hir> {
- GAT(&'hir hir::Generics<'hir>),
- Impl,
- Trait,
- Fn,
- Unknown,
- }
- let sub_origin = 'origin: {
- match *sub {
- ty::ReEarlyBound(ty::EarlyBoundRegion { def_id, .. }) => {
- let node = self.tcx.hir().get_if_local(def_id).unwrap();
- match node {
- Node::GenericParam(param) => {
- for h in self.tcx.hir().parent_iter(param.hir_id) {
- break 'origin match h.1 {
- Node::ImplItem(hir::ImplItem {
- kind: hir::ImplItemKind::Type(..),
- generics,
- ..
- })
- | Node::TraitItem(hir::TraitItem {
- kind: hir::TraitItemKind::Type(..),
- generics,
- ..
- }) => SubOrigin::GAT(generics),
- Node::ImplItem(hir::ImplItem {
- kind: hir::ImplItemKind::Fn(..),
- ..
- })
- | Node::TraitItem(hir::TraitItem {
- kind: hir::TraitItemKind::Fn(..),
- ..
- })
- | Node::Item(hir::Item {
- kind: hir::ItemKind::Fn(..), ..
- }) => SubOrigin::Fn,
- Node::Item(hir::Item {
- kind: hir::ItemKind::Trait(..),
- ..
- }) => SubOrigin::Trait,
- Node::Item(hir::Item {
- kind: hir::ItemKind::Impl(..), ..
- }) => SubOrigin::Impl,
- _ => continue,
- };
- }
+ let mut suggs = vec![];
+ let lt_name = self.suggest_name_region(sub, &mut suggs);
+
+ if let Some((sp, has_lifetimes)) = type_param_sugg_span
+ && suggestion_scope == type_scope
+ {
+ let suggestion =
+ if has_lifetimes { format!(" + {lt_name}") } else { format!(": {lt_name}") };
+ suggs.push((sp, suggestion))
+ } else {
+ let generics = self.tcx.hir().get_generics(suggestion_scope).unwrap();
+ let pred = format!("{bound_kind}: {lt_name}");
+ let suggestion = format!("{} {}", generics.add_where_or_trailing_comma(), pred,);
+ suggs.push((generics.tail_span_for_predicate_suggestion(), suggestion))
+ }
+
+ err.multipart_suggestion_verbose(
+ format!("{msg}"),
+ suggs,
+ Applicability::MaybeIncorrect, // Issue #41966
+ );
+ }
+
+ err
+ }
+
+ pub fn suggest_name_region(
+ &self,
+ lifetime: Region<'tcx>,
+ add_lt_suggs: &mut Vec<(Span, String)>,
+ ) -> String {
+ struct LifetimeReplaceVisitor<'tcx, 'a> {
+ tcx: TyCtxt<'tcx>,
+ needle: hir::LifetimeName,
+ new_lt: &'a str,
+ add_lt_suggs: &'a mut Vec<(Span, String)>,
+ }
+
+ impl<'hir, 'tcx> hir::intravisit::Visitor<'hir> for LifetimeReplaceVisitor<'tcx, '_> {
+ fn visit_lifetime(&mut self, lt: &'hir hir::Lifetime) {
+ if lt.res == self.needle {
+ let (pos, span) = lt.suggestion_position();
+ let new_lt = &self.new_lt;
+ let sugg = match pos {
+ hir::LifetimeSuggestionPosition::Normal => format!("{new_lt}"),
+ hir::LifetimeSuggestionPosition::Ampersand => format!("{new_lt} "),
+ hir::LifetimeSuggestionPosition::ElidedPath => format!("<{new_lt}>"),
+ hir::LifetimeSuggestionPosition::ElidedPathArgument => {
+ format!("{new_lt}, ")
}
- _ => {}
+ hir::LifetimeSuggestionPosition::ObjectDefault => format!("+ {new_lt}"),
+ };
+ self.add_lt_suggs.push((span, sugg));
+ }
+ }
+
+ fn visit_ty(&mut self, ty: &'hir hir::Ty<'hir>) {
+ let hir::TyKind::OpaqueDef(item_id, _, _) = ty.kind else {
+ return hir::intravisit::walk_ty(self, ty);
+ };
+ let opaque_ty = self.tcx.hir().item(item_id).expect_opaque_ty();
+ if let Some(&(_, b)) =
+ opaque_ty.lifetime_mapping.iter().find(|&(a, _)| a.res == self.needle)
+ {
+ let prev_needle =
+ std::mem::replace(&mut self.needle, hir::LifetimeName::Param(b));
+ for bound in opaque_ty.bounds {
+ self.visit_param_bound(bound);
}
+ self.needle = prev_needle;
}
- _ => {}
}
- SubOrigin::Unknown
- };
- debug!(?sub_origin);
-
- let mut err = match (*sub, sub_origin) {
- // In the case of GATs, we have to be careful. If we a type parameter `T` on an impl,
- // but a lifetime `'a` on an associated type, then we might need to suggest adding
- // `where T: 'a`. Importantly, this is on the GAT span, not on the `T` declaration.
- (ty::ReEarlyBound(ty::EarlyBoundRegion { name: _, .. }), SubOrigin::GAT(generics)) => {
- // Does the required lifetime have a nice name we can print?
- let mut err = struct_span_err!(
- self.tcx.sess,
- span,
- E0309,
- "{} may not live long enough",
- labeled_user_string
- );
- let pred = format!("{bound_kind}: {sub}");
- let suggestion = format!("{} {}", generics.add_where_or_trailing_comma(), pred,);
- err.span_suggestion(
- generics.tail_span_for_predicate_suggestion(),
- "consider adding a where clause",
- suggestion,
- Applicability::MaybeIncorrect,
- );
- err
- }
- (
- ty::ReEarlyBound(ty::EarlyBoundRegion { name, .. })
- | ty::ReFree(ty::FreeRegion { bound_region: ty::BrNamed(_, name), .. }),
- _,
- ) if name != kw::UnderscoreLifetime => {
- // Does the required lifetime have a nice name we can print?
- let mut err = struct_span_err!(
- self.tcx.sess,
- span,
- E0309,
- "{} may not live long enough",
- labeled_user_string
- );
- // Explicitly use the name instead of `sub`'s `Display` impl. The `Display` impl
- // for the bound is not suitable for suggestions when `-Zverbose` is set because it
- // uses `Debug` output, so we handle it specially here so that suggestions are
- // always correct.
- binding_suggestion(&mut err, type_param_span, bound_kind, name, vec![]);
- err
- }
-
- (ty::ReStatic, _) => {
- // Does the required lifetime have a nice name we can print?
- let mut err = struct_span_err!(
- self.tcx.sess,
- span,
- E0310,
- "{} may not live long enough",
- labeled_user_string
- );
- binding_suggestion(&mut err, type_param_span, bound_kind, "'static", vec![]);
- err
+ }
+
+ let (lifetime_def_id, lifetime_scope) = match self.tcx.is_suitable_region(lifetime) {
+ Some(info) if !lifetime.has_name() => {
+ (info.boundregion.get_id().unwrap().expect_local(), info.def_id)
}
+ _ => return lifetime.get_name_or_anon().to_string(),
+ };
- _ => {
- // If not, be less specific.
- let mut err = struct_span_err!(
- self.tcx.sess,
- span,
- E0311,
- "{} may not live long enough",
- labeled_user_string
- );
- note_and_explain_region(
- self.tcx,
- &mut err,
- &format!("{labeled_user_string} must be valid for "),
- sub,
- "...",
- None,
- );
- if let Some(infer::RelateParamBound(_, t, _)) = origin {
- let t = self.resolve_vars_if_possible(t);
- match t.kind() {
- // We've got:
- // fn get_later<G, T>(g: G, dest: &mut T) -> impl FnOnce() + '_
- // suggest:
- // fn get_later<'a, G: 'a, T>(g: G, dest: &mut T) -> impl FnOnce() + '_ + 'a
- ty::Closure(..) | ty::Alias(ty::Opaque, ..) => {
- new_binding_suggestion(&mut err, type_param_span);
- }
- _ => {
- binding_suggestion(
- &mut err,
- type_param_span,
- bound_kind,
- new_lt,
- add_lt_suggs,
- );
- }
+ let new_lt = {
+ let generics = self.tcx.generics_of(lifetime_scope);
+ let mut used_names =
+ iter::successors(Some(generics), |g| g.parent.map(|p| self.tcx.generics_of(p)))
+ .flat_map(|g| &g.params)
+ .filter(|p| matches!(p.kind, ty::GenericParamDefKind::Lifetime))
+ .map(|p| p.name)
+ .collect::<Vec<_>>();
+ if let Some(hir_id) = self.tcx.opt_local_def_id_to_hir_id(lifetime_scope) {
+ // consider late-bound lifetimes ...
+ used_names.extend(self.tcx.late_bound_vars(hir_id).into_iter().filter_map(|p| {
+ match p {
+ ty::BoundVariableKind::Region(lt) => lt.get_name(),
+ _ => None,
}
- }
- err
+ }))
}
+ (b'a'..=b'z')
+ .map(|c| format!("'{}", c as char))
+ .find(|candidate| !used_names.iter().any(|e| e.as_str() == candidate))
+ .unwrap_or("'lt".to_string())
};
- if let Some(origin) = origin {
- self.note_region_origin(&mut err, &origin);
- }
- err
+ let mut visitor = LifetimeReplaceVisitor {
+ tcx: self.tcx,
+ needle: hir::LifetimeName::Param(lifetime_def_id),
+ add_lt_suggs,
+ new_lt: &new_lt,
+ };
+ match self.tcx.hir().expect_owner(lifetime_scope) {
+ hir::OwnerNode::Item(i) => visitor.visit_item(i),
+ hir::OwnerNode::ForeignItem(i) => visitor.visit_foreign_item(i),
+ hir::OwnerNode::ImplItem(i) => visitor.visit_impl_item(i),
+ hir::OwnerNode::TraitItem(i) => visitor.visit_trait_item(i),
+ hir::OwnerNode::Crate(_) => bug!("OwnerNode::Crate doesn't not have generics"),
+ }
+
+ let ast_generics = self.tcx.hir().get_generics(lifetime_scope).unwrap();
+ let sugg = ast_generics
+ .span_for_lifetime_suggestion()
+ .map(|span| (span, format!("{new_lt}, ")))
+ .unwrap_or_else(|| (ast_generics.span, format!("<{new_lt}>")));
+ add_lt_suggs.push(sugg);
+
+ new_lt
}
fn report_sub_sup_conflict(
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index 83adbc3c79041..1ccb81dcb9b6b 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -1057,16 +1057,21 @@ impl<'tcx> TyCtxt<'tcx> {
}
/// Returns the `DefId` and the `BoundRegionKind` corresponding to the given region.
- pub fn is_suitable_region(self, region: Region<'tcx>) -> Option<FreeRegionInfo> {
- let (suitable_region_binding_scope, bound_region) = match *region {
- ty::ReFree(ref free_region) => {
- (free_region.scope.expect_local(), free_region.bound_region)
+ pub fn is_suitable_region(self, mut region: Region<'tcx>) -> Option<FreeRegionInfo> {
+ let (suitable_region_binding_scope, bound_region) = loop {
+ let def_id = match region.kind() {
+ ty::ReFree(fr) => fr.bound_region.get_id()?.as_local()?,
+ ty::ReEarlyBound(ebr) => ebr.def_id.expect_local(),
+ _ => return None, // not a free region
+ };
+ let scope = self.local_parent(def_id);
+ if self.def_kind(scope) == DefKind::OpaqueTy {
+ // Lifetime params of opaque types are synthetic and thus irrelevant to
+ // diagnostics. Map them back to their origin!
+ region = self.map_rpit_lifetime_to_fn_lifetime(def_id);
+ continue;
}
- ty::ReEarlyBound(ref ebr) => (
- self.local_parent(ebr.def_id.expect_local()),
- ty::BoundRegionKind::BrNamed(ebr.def_id, ebr.name),
- ),
- _ => return None, // not a free region
+ break (scope, ty::BrNamed(def_id.into(), self.item_name(def_id.into())));
};
let is_impl_item = match self.hir().find_by_def_id(suitable_region_binding_scope) {
@@ -1074,7 +1079,7 @@ impl<'tcx> TyCtxt<'tcx> {
Some(Node::ImplItem(..)) => {
self.is_bound_region_in_impl_item(suitable_region_binding_scope)
}
- _ => return None,
+ _ => false,
};
Some(FreeRegionInfo {
diff --git a/tests/ui/associated-inherent-types/regionck-1.stderr b/tests/ui/associated-inherent-types/regionck-1.stderr
index b17d89ca306f4..62a00868248a5 100644
--- a/tests/ui/associated-inherent-types/regionck-1.stderr
+++ b/tests/ui/associated-inherent-types/regionck-1.stderr
@@ -2,9 +2,14 @@ error[E0309]: the parameter type `T` may not live long enough
--> $DIR/regionck-1.rs:9:30
|
LL | type NoTyOutliv<'a, T> = &'a T;
- | ^^^^^- help: consider adding a where clause: `where T: 'a`
- | |
- | ...so that the reference type `&'a T` does not outlive the data it points at
+ | -- ^^^^^ ...so that the reference type `&'a T` does not outlive the data it points at
+ | |
+ | the parameter type `T` must be valid for the lifetime `'a` as defined here...
+ |
+help: consider adding an explicit lifetime bound
+ |
+LL | type NoTyOutliv<'a, T: 'a> = &'a T;
+ | ++++
error[E0491]: in type `&'a &'b ()`, reference has a longer lifetime than the data it references
--> $DIR/regionck-1.rs:10:31
diff --git a/tests/ui/async-await/in-trait/async-generics-and-bounds.stderr b/tests/ui/async-await/in-trait/async-generics-and-bounds.stderr
index 90b40e221e45d..965c385e9bc7f 100644
--- a/tests/ui/async-await/in-trait/async-generics-and-bounds.stderr
+++ b/tests/ui/async-await/in-trait/async-generics-and-bounds.stderr
@@ -2,35 +2,29 @@ error[E0311]: the parameter type `U` may not live long enough
--> $DIR/async-generics-and-bounds.rs:12:5
|
LL | async fn foo(&self) -> &(T, U) where T: Debug + Sized, U: Hash;
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ | ^^^^^^^^^^^^^-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ | | |
+ | | the parameter type `U` must be valid for the anonymous lifetime as defined here...
+ | ...so that the reference type `&(T, U)` does not outlive the data it points at
|
-note: the parameter type `U` must be valid for the anonymous lifetime as defined here...
- --> $DIR/async-generics-and-bounds.rs:12:18
+help: consider adding an explicit lifetime bound
|
-LL | async fn foo(&self) -> &(T, U) where T: Debug + Sized, U: Hash;
- | ^
-note: ...so that the reference type `&(T, U)` does not outlive the data it points at
- --> $DIR/async-generics-and-bounds.rs:12:5
- |
-LL | async fn foo(&self) -> &(T, U) where T: Debug + Sized, U: Hash;
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | async fn foo<'a>(&'a self) -> &'a (T, U) where T: Debug + Sized, U: Hash, U: 'a;
+ | ++++ ++ ++ +++++++
error[E0311]: the parameter type `T` may not live long enough
--> $DIR/async-generics-and-bounds.rs:12:5
|
LL | async fn foo(&self) -> &(T, U) where T: Debug + Sized, U: Hash;
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ | ^^^^^^^^^^^^^-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ | | |
+ | | the parameter type `T` must be valid for the anonymous lifetime as defined here...
+ | ...so that the reference type `&(T, U)` does not outlive the data it points at
|
-note: the parameter type `T` must be valid for the anonymous lifetime as defined here...
- --> $DIR/async-generics-and-bounds.rs:12:18
+help: consider adding an explicit lifetime bound
|
-LL | async fn foo(&self) -> &(T, U) where T: Debug + Sized, U: Hash;
- | ^
-note: ...so that the reference type `&(T, U)` does not outlive the data it points at
- --> $DIR/async-generics-and-bounds.rs:12:5
- |
-LL | async fn foo(&self) -> &(T, U) where T: Debug + Sized, U: Hash;
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | async fn foo<'a>(&'a self) -> &'a (T, U) where T: Debug + Sized, U: Hash, T: 'a;
+ | ++++ ++ ++ +++++++
error: aborting due to 2 previous errors
diff --git a/tests/ui/async-await/in-trait/async-generics.stderr b/tests/ui/async-await/in-trait/async-generics.stderr
index 07f986e94e02e..20c2491e9d0c7 100644
--- a/tests/ui/async-await/in-trait/async-generics.stderr
+++ b/tests/ui/async-await/in-trait/async-generics.stderr
@@ -2,35 +2,29 @@ error[E0311]: the parameter type `U` may not live long enough
--> $DIR/async-generics.rs:9:5
|
LL | async fn foo(&self) -> &(T, U);
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ | ^^^^^^^^^^^^^-^^^^^^^^^^^^^^^^^
+ | | |
+ | | the parameter type `U` must be valid for the anonymous lifetime as defined here...
+ | ...so that the reference type `&(T, U)` does not outlive the data it points at
|
-note: the parameter type `U` must be valid for the anonymous lifetime as defined here...
- --> $DIR/async-generics.rs:9:18
+help: consider adding an explicit lifetime bound
|
-LL | async fn foo(&self) -> &(T, U);
- | ^
-note: ...so that the reference type `&(T, U)` does not outlive the data it points at
- --> $DIR/async-generics.rs:9:5
- |
-LL | async fn foo(&self) -> &(T, U);
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | async fn foo<'a>(&'a self) -> &'a (T, U) where U: 'a;
+ | ++++ ++ ++ +++++++++++
error[E0311]: the parameter type `T` may not live long enough
--> $DIR/async-generics.rs:9:5
|
LL | async fn foo(&self) -> &(T, U);
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ | ^^^^^^^^^^^^^-^^^^^^^^^^^^^^^^^
+ | | |
+ | | the parameter type `T` must be valid for the anonymous lifetime as defined here...
+ | ...so that the reference type `&(T, U)` does not outlive the data it points at
|
-note: the parameter type `T` must be valid for the anonymous lifetime as defined here...
- --> $DIR/async-generics.rs:9:18
+help: consider adding an explicit lifetime bound
|
-LL | async fn foo(&self) -> &(T, U);
- | ^
-note: ...so that the reference type `&(T, U)` does not outlive the data it points at
- --> $DIR/async-generics.rs:9:5
- |
-LL | async fn foo(&self) -> &(T, U);
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | async fn foo<'a>(&'a self) -> &'a (T, U) where T: 'a;
+ | ++++ ++ ++ +++++++++++
error: aborting due to 2 previous errors
diff --git a/tests/ui/builtin-superkinds/builtin-superkinds-self-type.stderr b/tests/ui/builtin-superkinds/builtin-superkinds-self-type.stderr
index e2b177b951cc9..0e2c6c60b6e3a 100644
--- a/tests/ui/builtin-superkinds/builtin-superkinds-self-type.stderr
+++ b/tests/ui/builtin-superkinds/builtin-superkinds-self-type.stderr
@@ -2,14 +2,17 @@ error[E0310]: the parameter type `T` may not live long enough
--> $DIR/builtin-superkinds-self-type.rs:10:16
|
LL | impl <T: Sync> Foo for T { }
- | ^^^ ...so that the type `T` will meet its required lifetime bounds...
+ | ^^^
+ | |
+ | the parameter type `T` must be valid for the static lifetime...
+ | ...so that the type `T` will meet its required lifetime bounds...
|
note: ...that is required by this bound
--> $DIR/builtin-superkinds-self-type.rs:6:24
|
LL | trait Foo : Sized+Sync+'static {
| ^^^^^^^
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | impl <T: Sync + 'static> Foo for T { }
| +++++++++
diff --git a/tests/ui/coercion/issue-53475.stderr b/tests/ui/coercion/issue-53475.stderr
index 522c50dca9508..4778611bf1b53 100644
--- a/tests/ui/coercion/issue-53475.stderr
+++ b/tests/ui/coercion/issue-53475.stderr
@@ -2,9 +2,12 @@ error[E0310]: the parameter type `T` may not live long enough
--> $DIR/issue-53475.rs:10:1
|
LL | impl<T> CoerceUnsized<Foo<dyn Any>> for Foo<T> {}
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ | |
+ | the parameter type `T` must be valid for the static lifetime...
+ | ...so that the type `T` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | impl<T: 'static> CoerceUnsized<Foo<dyn Any>> for Foo<T> {}
| +++++++++
diff --git a/tests/ui/consts/issue-102117.stderr b/tests/ui/consts/issue-102117.stderr
index a297916b30f93..da92db87f1821 100644
--- a/tests/ui/consts/issue-102117.stderr
+++ b/tests/ui/consts/issue-102117.stderr
@@ -2,9 +2,12 @@ error[E0310]: the parameter type `T` may not live long enough
--> $DIR/issue-102117.rs:19:26
|
LL | type_id: TypeId::of::<T>(),
- | ^^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
+ | ^^^^^^^^^^^^^^^^^
+ | |
+ | the parameter type `T` must be valid for the static lifetime...
+ | ...so that the type `T` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | pub fn new<T: 'static>() -> &'static Self {
| +++++++++
@@ -13,10 +16,13 @@ error[E0310]: the parameter type `T` may not live long enough
--> $DIR/issue-102117.rs:19:26
|
LL | type_id: TypeId::of::<T>(),
- | ^^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
+ | ^^^^^^^^^^^^^^^^^
+ | |
+ | the parameter type `T` must be valid for the static lifetime...
+ | ...so that the type `T` will meet its required lifetime bounds
|
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | pub fn new<T: 'static>() -> &'static Self {
| +++++++++
diff --git a/tests/ui/error-codes/E0311.fixed b/tests/ui/error-codes/E0311.fixed
index 4410a4d707af4..09ceecd0666cd 100644
--- a/tests/ui/error-codes/E0311.fixed
+++ b/tests/ui/error-codes/E0311.fixed
@@ -2,7 +2,7 @@
#![allow(warnings)]
-fn no_restriction<'a, T: 'a>(x: &'a ()) -> &() {
+fn no_restriction<'a, T: 'a>(x: &'a ()) -> &'a () {
with_restriction::<T>(x) //~ ERROR E0311
}
diff --git a/tests/ui/error-codes/E0311.stderr b/tests/ui/error-codes/E0311.stderr
index b0e6dd1e2727c..96546b83f2f93 100644
--- a/tests/ui/error-codes/E0311.stderr
+++ b/tests/ui/error-codes/E0311.stderr
@@ -1,23 +1,15 @@
error[E0311]: the parameter type `T` may not live long enough
--> $DIR/E0311.rs:6:5
|
-LL | with_restriction::<T>(x)
- | ^^^^^^^^^^^^^^^^^^^^^
- |
-note: the parameter type `T` must be valid for the anonymous lifetime defined here...
- --> $DIR/E0311.rs:5:25
- |
LL | fn no_restriction<T>(x: &()) -> &() {
- | ^^^
-note: ...so that the type `T` will meet its required lifetime bounds
- --> $DIR/E0311.rs:6:5
- |
+ | --- the parameter type `T` must be valid for the anonymous lifetime defined here...
LL | with_restriction::<T>(x)
- | ^^^^^^^^^^^^^^^^^^^^^
-help: consider adding an explicit lifetime bound...
+ | ^^^^^^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
+ |
+help: consider adding an explicit lifetime bound
|
-LL | fn no_restriction<'a, T: 'a>(x: &'a ()) -> &() {
- | +++ ++++ ++
+LL | fn no_restriction<'a, T: 'a>(x: &'a ()) -> &'a () {
+ | +++ ++++ ++ ++
error: aborting due to previous error
diff --git a/tests/ui/fn/implied-bounds-unnorm-associated-type-5.stderr b/tests/ui/fn/implied-bounds-unnorm-associated-type-5.stderr
index 458756a3dcd96..3f6401b9f7a4d 100644
--- a/tests/ui/fn/implied-bounds-unnorm-associated-type-5.stderr
+++ b/tests/ui/fn/implied-bounds-unnorm-associated-type-5.stderr
@@ -2,14 +2,16 @@ error[E0309]: the parameter type `T` may not live long enough
--> $DIR/implied-bounds-unnorm-associated-type-5.rs:6:13
|
LL | impl<'a, T> Trait<'a> for T {
- | ^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds...
+ | -- ^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds...
+ | |
+ | the parameter type `T` must be valid for the lifetime `'a` as defined here...
|
note: ...that is required by this bound
--> $DIR/implied-bounds-unnorm-associated-type-5.rs:1:18
|
LL | trait Trait<'a>: 'a {
| ^^
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | impl<'a, T: 'a> Trait<'a> for T {
| ++++
diff --git a/tests/ui/generic-associated-types/issue-84931.stderr b/tests/ui/generic-associated-types/issue-84931.stderr
index fffea98a449e2..fe9932c205a17 100644
--- a/tests/ui/generic-associated-types/issue-84931.stderr
+++ b/tests/ui/generic-associated-types/issue-84931.stderr
@@ -2,9 +2,14 @@ error[E0309]: the parameter type `T` may not live long enough
--> $DIR/issue-84931.rs:14:21
|
LL | type Item<'a> = &'a mut T;
- | ^^^^^^^^^- help: consider adding a where clause: `where T: 'a`
- | |
- | ...so that the reference type `&'a mut T` does not outlive the data it points at
+ | -- ^^^^^^^^^ ...so that the reference type `&'a mut T` does not outlive the data it points at
+ | |
+ | the parameter type `T` must be valid for the lifetime `'a` as defined here...
+ |
+help: consider adding an explicit lifetime bound
+ |
+LL | type Item<'a> = &'a mut T where T: 'a;
+ | +++++++++++
error: aborting due to previous error
diff --git a/tests/ui/impl-trait/must_outlive_least_region_or_bound.stderr b/tests/ui/impl-trait/must_outlive_least_region_or_bound.stderr
index 33b48b1e9eae9..c60fe08c5d7c5 100644
--- a/tests/ui/impl-trait/must_outlive_least_region_or_bound.stderr
+++ b/tests/ui/impl-trait/must_outlive_least_region_or_bound.stderr
@@ -117,9 +117,12 @@ error[E0310]: the parameter type `T` may not live long enough
--> $DIR/must_outlive_least_region_or_bound.rs:43:5
|
LL | x
- | ^ ...so that the type `T` will meet its required lifetime bounds
+ | ^
+ | |
+ | the parameter type `T` must be valid for the static lifetime...
+ | ...so that the type `T` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | fn ty_param_wont_outlive_static<T:Debug + 'static>(x: T) -> impl Debug + 'static {
| +++++++++
diff --git a/tests/ui/impl-trait/type_parameters_captured.stderr b/tests/ui/impl-trait/type_parameters_captured.stderr
index fb502cfdd2b35..46859296fb8b4 100644
--- a/tests/ui/impl-trait/type_parameters_captured.stderr
+++ b/tests/ui/impl-trait/type_parameters_captured.stderr
@@ -2,9 +2,12 @@ error[E0310]: the parameter type `T` may not live long enough
--> $DIR/type_parameters_captured.rs:8:5
|
LL | x
- | ^ ...so that the type `T` will meet its required lifetime bounds
+ | ^
+ | |
+ | the parameter type `T` must be valid for the static lifetime...
+ | ...so that the type `T` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | fn foo<T: 'static>(x: T) -> impl Any + 'static {
| +++++++++
diff --git a/tests/ui/impl-trait/unactionable_diagnostic.fixed b/tests/ui/impl-trait/unactionable_diagnostic.fixed
index 6c2505177fef8..d446512ffc281 100644
--- a/tests/ui/impl-trait/unactionable_diagnostic.fixed
+++ b/tests/ui/impl-trait/unactionable_diagnostic.fixed
@@ -14,7 +14,7 @@ fn foo<'x, P>(
}
pub fn bar<'t, T: 't>(
- //~^ HELP: consider adding an explicit lifetime bound...
+ //~^ HELP: consider adding an explicit lifetime bound
post: T,
x: &'t Foo,
) -> &'t impl Trait {
diff --git a/tests/ui/impl-trait/unactionable_diagnostic.rs b/tests/ui/impl-trait/unactionable_diagnostic.rs
index bce35cbdd0d38..76b9a62ca1338 100644
--- a/tests/ui/impl-trait/unactionable_diagnostic.rs
+++ b/tests/ui/impl-trait/unactionable_diagnostic.rs
@@ -14,7 +14,7 @@ fn foo<'x, P>(
}
pub fn bar<'t, T>(
- //~^ HELP: consider adding an explicit lifetime bound...
+ //~^ HELP: consider adding an explicit lifetime bound
post: T,
x: &'t Foo,
) -> &'t impl Trait {
diff --git a/tests/ui/impl-trait/unactionable_diagnostic.stderr b/tests/ui/impl-trait/unactionable_diagnostic.stderr
index a32004cda1a6f..4df7f45c3b37e 100644
--- a/tests/ui/impl-trait/unactionable_diagnostic.stderr
+++ b/tests/ui/impl-trait/unactionable_diagnostic.stderr
@@ -1,10 +1,13 @@
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/unactionable_diagnostic.rs:21:5
|
+LL | pub fn bar<'t, T>(
+ | -- the parameter type `T` must be valid for the lifetime `'t` as defined here...
+...
LL | foo(post, x)
| ^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | pub fn bar<'t, T: 't>(
| ++++
diff --git a/tests/ui/lifetimes/lifetime-doesnt-live-long-enough.stderr b/tests/ui/lifetimes/lifetime-doesnt-live-long-enough.stderr
index affb4e8d04434..235092e24634b 100644
--- a/tests/ui/lifetimes/lifetime-doesnt-live-long-enough.stderr
+++ b/tests/ui/lifetimes/lifetime-doesnt-live-long-enough.stderr
@@ -2,9 +2,12 @@ error[E0310]: the parameter type `T` may not live long enough
--> $DIR/lifetime-doesnt-live-long-enough.rs:19:10
|
LL | foo: &'static T
- | ^^^^^^^^^^ ...so that the reference type `&'static T` does not outlive the data it points at
+ | ^^^^^^^^^^
+ | |
+ | the parameter type `T` must be valid for the static lifetime...
+ | ...so that the reference type `&'static T` does not outlive the data it points at
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | struct Foo<T: 'static> {
| +++++++++
@@ -13,20 +16,24 @@ error[E0309]: the parameter type `K` may not live long enough
--> $DIR/lifetime-doesnt-live-long-enough.rs:41:33
|
LL | fn generic_in_parent<'a, L: X<&'a Nested<K>>>() {
- | ^^^^^^^^^^^^^^^^ ...so that the reference type `&'a Nested<K>` does not outlive the data it points at
+ | -- ^^^^^^^^^^^^^^^^ ...so that the reference type `&'a Nested<K>` does not outlive the data it points at
+ | |
+ | the parameter type `K` must be valid for the lifetime `'a` as defined here...
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
-LL | impl<K: 'a> Nested<K> {
- | ++++
+LL | fn generic_in_parent<'a, L: X<&'a Nested<K>>>() where K: 'a {
+ | +++++++++++
error[E0309]: the parameter type `M` may not live long enough
--> $DIR/lifetime-doesnt-live-long-enough.rs:44:36
|
LL | fn generic_in_child<'a, 'b, L: X<&'a Nested<M>>, M: 'b>() {
- | ^^^^^^^^^^^^^^^^ ...so that the reference type `&'a Nested<M>` does not outlive the data it points at
+ | -- ^^^^^^^^^^^^^^^^ ...so that the reference type `&'a Nested<M>` does not outlive the data it points at
+ | |
+ | the parameter type `M` must be valid for the lifetime `'a` as defined here...
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | fn generic_in_child<'a, 'b, L: X<&'a Nested<M>>, M: 'b + 'a>() {
| ++++
@@ -35,29 +42,37 @@ error[E0309]: the parameter type `K` may not live long enough
--> $DIR/lifetime-doesnt-live-long-enough.rs:24:19
|
LL | fn foo<'a, L: X<&'a Nested<K>>>();
- | ^^^^^^^^^^^^^^^^ ...so that the reference type `&'a Nested<K>` does not outlive the data it points at
+ | -- ^^^^^^^^^^^^^^^^ ...so that the reference type `&'a Nested<K>` does not outlive the data it points at
+ | |
+ | the parameter type `K` must be valid for the lifetime `'a` as defined here...
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
-LL | trait X<K: 'a>: Sized {
- | ++++
+LL | fn foo<'a, L: X<&'a Nested<K>>>() where K: 'a;
+ | +++++++++++
error[E0309]: the parameter type `Self` may not live long enough
--> $DIR/lifetime-doesnt-live-long-enough.rs:28:19
|
LL | fn bar<'a, L: X<&'a Nested<Self>>>();
- | ^^^^^^^^^^^^^^^^^^^
+ | -- ^^^^^^^^^^^^^^^^^^^ ...so that the reference type `&'a Nested<Self>` does not outlive the data it points at
+ | |
+ | the parameter type `Self` must be valid for the lifetime `'a` as defined here...
|
- = help: consider adding an explicit lifetime bound `Self: 'a`...
- = note: ...so that the reference type `&'a Nested<Self>` does not outlive the data it points at
+help: consider adding an explicit lifetime bound
+ |
+LL | fn bar<'a, L: X<&'a Nested<Self>>>() where Self: 'a;
+ | ++++++++++++++
error[E0309]: the parameter type `L` may not live long enough
--> $DIR/lifetime-doesnt-live-long-enough.rs:32:22
|
LL | fn baz<'a, L, M: X<&'a Nested<L>>>() {
- | ^^^^^^^^^^^^^^^^ ...so that the reference type `&'a Nested<L>` does not outlive the data it points at
+ | -- ^^^^^^^^^^^^^^^^ ...so that the reference type `&'a Nested<L>` does not outlive the data it points at
+ | |
+ | the parameter type `L` must be valid for the lifetime `'a` as defined here...
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | fn baz<'a, L: 'a, M: X<&'a Nested<L>>>() {
| ++++
diff --git a/tests/ui/lifetimes/lifetime-errors/issue_74400.stderr b/tests/ui/lifetimes/lifetime-errors/issue_74400.stderr
index 7049f28e2f6eb..dbc587dd004a4 100644
--- a/tests/ui/lifetimes/lifetime-errors/issue_74400.stderr
+++ b/tests/ui/lifetimes/lifetime-errors/issue_74400.stderr
@@ -2,9 +2,12 @@ error[E0310]: the parameter type `T` may not live long enough
--> $DIR/issue_74400.rs:12:5
|
LL | f(data, identity)
- | ^^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
+ | ^^^^^^^^^^^^^^^^^
+ | |
+ | the parameter type `T` must be valid for the static lifetime...
+ | ...so that the type `T` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | fn g<T: 'static>(data: &[T]) {
| +++++++++
diff --git a/tests/ui/lifetimes/suggest-introducing-and-adding-missing-lifetime.fixed b/tests/ui/lifetimes/suggest-introducing-and-adding-missing-lifetime.fixed
index f977f0bd3a8c2..7c41549043915 100644
--- a/tests/ui/lifetimes/suggest-introducing-and-adding-missing-lifetime.fixed
+++ b/tests/ui/lifetimes/suggest-introducing-and-adding-missing-lifetime.fixed
@@ -2,7 +2,7 @@
#![allow(warnings)]
-fn no_restriction<'a, T: 'a>(x: &'a ()) -> &() {
+fn no_restriction<'a, T: 'a>(x: &'a ()) -> &'a () {
with_restriction::<T>(x) //~ ERROR the parameter type `T` may not live long enough
}
diff --git a/tests/ui/lifetimes/suggest-introducing-and-adding-missing-lifetime.stderr b/tests/ui/lifetimes/suggest-introducing-and-adding-missing-lifetime.stderr
index 2d58d3a02f35e..79df2c8dfbcc8 100644
--- a/tests/ui/lifetimes/suggest-introducing-and-adding-missing-lifetime.stderr
+++ b/tests/ui/lifetimes/suggest-introducing-and-adding-missing-lifetime.stderr
@@ -1,23 +1,15 @@
error[E0311]: the parameter type `T` may not live long enough
--> $DIR/suggest-introducing-and-adding-missing-lifetime.rs:6:5
|
-LL | with_restriction::<T>(x)
- | ^^^^^^^^^^^^^^^^^^^^^
- |
-note: the parameter type `T` must be valid for the anonymous lifetime defined here...
- --> $DIR/suggest-introducing-and-adding-missing-lifetime.rs:5:25
- |
LL | fn no_restriction<T>(x: &()) -> &() {
- | ^^^
-note: ...so that the type `T` will meet its required lifetime bounds
- --> $DIR/suggest-introducing-and-adding-missing-lifetime.rs:6:5
- |
+ | --- the parameter type `T` must be valid for the anonymous lifetime defined here...
LL | with_restriction::<T>(x)
- | ^^^^^^^^^^^^^^^^^^^^^
-help: consider adding an explicit lifetime bound...
+ | ^^^^^^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
+ |
+help: consider adding an explicit lifetime bound
|
-LL | fn no_restriction<'a, T: 'a>(x: &'a ()) -> &() {
- | +++ ++++ ++
+LL | fn no_restriction<'a, T: 'a>(x: &'a ()) -> &'a () {
+ | +++ ++++ ++ ++
error: aborting due to previous error
diff --git a/tests/ui/marker_trait_attr/overlapping-impl-1-modulo-regions.stderr b/tests/ui/marker_trait_attr/overlapping-impl-1-modulo-regions.stderr
index e713d1451cfd2..64bccda56c65e 100644
--- a/tests/ui/marker_trait_attr/overlapping-impl-1-modulo-regions.stderr
+++ b/tests/ui/marker_trait_attr/overlapping-impl-1-modulo-regions.stderr
@@ -2,9 +2,12 @@ error[E0310]: the parameter type `T` may not live long enough
--> $DIR/overlapping-impl-1-modulo-regions.rs:14:21
|
LL | impl<T: Copy> F for T {}
- | ^ ...so that the type `T` will meet its required lifetime bounds
+ | ^
+ | |
+ | the parameter type `T` must be valid for the static lifetime...
+ | ...so that the type `T` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | impl<T: Copy + 'static> F for T {}
| +++++++++
diff --git a/tests/ui/nll/closure-requirements/propagate-from-trait-match.stderr b/tests/ui/nll/closure-requirements/propagate-from-trait-match.stderr
index 1aa7de1e13703..a20f885fe81f4 100644
--- a/tests/ui/nll/closure-requirements/propagate-from-trait-match.stderr
+++ b/tests/ui/nll/closure-requirements/propagate-from-trait-match.stderr
@@ -25,10 +25,13 @@ LL | | T: Trait<'a>,
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/propagate-from-trait-match.rs:43:9
|
+LL | fn supply<'a, T>(value: T)
+ | -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
+...
LL | require(value);
| ^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | T: Trait<'a> + 'a,
| ++++
diff --git a/tests/ui/nll/issue-98589-closures-relate-named-regions.stderr b/tests/ui/nll/issue-98589-closures-relate-named-regions.stderr
index d8b26f0b0171e..4e741abc2dcf2 100644
--- a/tests/ui/nll/issue-98589-closures-relate-named-regions.stderr
+++ b/tests/ui/nll/issue-98589-closures-relate-named-regions.stderr
@@ -37,10 +37,12 @@ LL | || { None::<&'a &'b ()>; };
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/issue-98589-closures-relate-named-regions.rs:26:10
|
+LL | fn test_early_type<'a: 'a, T>() {
+ | -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
LL | || { None::<&'a T>; };
| ^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | fn test_early_type<'a: 'a, T: 'a>() {
| ++++
@@ -48,10 +50,12 @@ LL | fn test_early_type<'a: 'a, T: 'a>() {
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/issue-98589-closures-relate-named-regions.rs:32:10
|
+LL | fn test_late_type<'a, T>() {
+ | -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
LL | || { None::<&'a T>; };
| ^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | fn test_late_type<'a, T: 'a>() {
| ++++
diff --git a/tests/ui/nll/issue-98693.stderr b/tests/ui/nll/issue-98693.stderr
index 15ca38aa25dce..a3d87d74a8e94 100644
--- a/tests/ui/nll/issue-98693.stderr
+++ b/tests/ui/nll/issue-98693.stderr
@@ -2,9 +2,12 @@ error[E0310]: the parameter type `T` may not live long enough
--> $DIR/issue-98693.rs:16:9
|
LL | assert_static::<T>();
- | ^^^^^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
+ | ^^^^^^^^^^^^^^^^^^^^
+ | |
+ | the parameter type `T` must be valid for the static lifetime...
+ | ...so that the type `T` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | fn test<T: 'static>() {
| +++++++++
diff --git a/tests/ui/nll/member-constraints/min-choice-reject-ambiguous.stderr b/tests/ui/nll/member-constraints/min-choice-reject-ambiguous.stderr
index e0d476a33b23b..cab75e630a7c8 100644
--- a/tests/ui/nll/member-constraints/min-choice-reject-ambiguous.stderr
+++ b/tests/ui/nll/member-constraints/min-choice-reject-ambiguous.stderr
@@ -1,10 +1,13 @@
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/min-choice-reject-ambiguous.rs:17:5
|
+LL | fn test_b<'a, 'b, 'c, T>() -> impl Cap<'a> + Cap<'b> + Cap<'c>
+ | -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
+...
LL | type_test::<'_, T>() // This should pass if we pick 'b.
| ^^^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | T: 'b + 'a,
| ++++
@@ -12,10 +15,13 @@ LL | T: 'b + 'a,
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/min-choice-reject-ambiguous.rs:28:5
|
+LL | fn test_c<'a, 'b, 'c, T>() -> impl Cap<'a> + Cap<'b> + Cap<'c>
+ | -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
+...
LL | type_test::<'_, T>() // This should pass if we pick 'c.
| ^^^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | T: 'c + 'a,
| ++++
diff --git a/tests/ui/nll/ty-outlives/impl-trait-outlives.stderr b/tests/ui/nll/ty-outlives/impl-trait-outlives.stderr
index 64b08a9b32fb3..ff9d750570e59 100644
--- a/tests/ui/nll/ty-outlives/impl-trait-outlives.stderr
+++ b/tests/ui/nll/ty-outlives/impl-trait-outlives.stderr
@@ -1,10 +1,13 @@
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/impl-trait-outlives.rs:11:5
|
+LL | fn no_region<'a, T>(x: Box<T>) -> impl Debug + 'a
+ | -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
+...
LL | x
| ^ ...so that the type `T` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | T: Debug + 'a,
| ++++
@@ -12,10 +15,13 @@ LL | T: Debug + 'a,
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/impl-trait-outlives.rs:26:5
|
+LL | fn wrong_region<'a, 'b, T>(x: Box<T>) -> impl Debug + 'a
+ | -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
+...
LL | x
| ^ ...so that the type `T` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | T: 'b + Debug + 'a,
| ++++
diff --git a/tests/ui/nll/ty-outlives/projection-implied-bounds.stderr b/tests/ui/nll/ty-outlives/projection-implied-bounds.stderr
index d949e29b2b812..6de023ffdd416 100644
--- a/tests/ui/nll/ty-outlives/projection-implied-bounds.stderr
+++ b/tests/ui/nll/ty-outlives/projection-implied-bounds.stderr
@@ -2,9 +2,12 @@ error[E0310]: the parameter type `T` may not live long enough
--> $DIR/projection-implied-bounds.rs:30:36
|
LL | twice(value, |value_ref, item| invoke2(value_ref, item));
- | ^^^^^^^^^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
+ | ^^^^^^^^^^^^^^^^^^^^^^^^
+ | |
+ | the parameter type `T` must be valid for the static lifetime...
+ | ...so that the type `T` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | fn generic2<T: Iterator + 'static>(value: T) {
| +++++++++
diff --git a/tests/ui/nll/ty-outlives/projection-no-regions-closure.stderr b/tests/ui/nll/ty-outlives/projection-no-regions-closure.stderr
index 433024c30bbcf..4f93fb4eaea34 100644
--- a/tests/ui/nll/ty-outlives/projection-no-regions-closure.stderr
+++ b/tests/ui/nll/ty-outlives/projection-no-regions-closure.stderr
@@ -25,11 +25,16 @@ LL | | T: Iterator,
error[E0309]: the associated type `<T as Iterator>::Item` may not live long enough
--> $DIR/projection-no-regions-closure.rs:25:31
|
+LL | fn no_region<'a, T>(x: Box<T>) -> Box<dyn Anything + 'a>
+ | -- the associated type `<T as Iterator>::Item` must be valid for the lifetime `'a` as defined here...
+...
LL | with_signature(x, |mut y| Box::new(y.next()))
- | ^^^^^^^^^^^^^^^^^^
+ | ^^^^^^^^^^^^^^^^^^ ...so that the type `<T as Iterator>::Item` will meet its required lifetime bounds
|
- = help: consider adding an explicit lifetime bound `<T as Iterator>::Item: 'a`...
- = note: ...so that the type `<T as Iterator>::Item` will meet its required lifetime bounds
+help: consider adding an explicit lifetime bound
+ |
+LL | T: Iterator, <T as Iterator>::Item: 'a
+ | ~~~~~~~~~~~~~~~~~~~~~~~~~~~
note: external requirements
--> $DIR/projection-no-regions-closure.rs:34:23
@@ -82,11 +87,16 @@ LL | | T: 'b + Iterator,
error[E0309]: the associated type `<T as Iterator>::Item` may not live long enough
--> $DIR/projection-no-regions-closure.rs:42:31
|
+LL | fn wrong_region<'a, 'b, T>(x: Box<T>) -> Box<dyn Anything + 'a>
+ | -- the associated type `<T as Iterator>::Item` must be valid for the lifetime `'a` as defined here...
+...
LL | with_signature(x, |mut y| Box::new(y.next()))
- | ^^^^^^^^^^^^^^^^^^
+ | ^^^^^^^^^^^^^^^^^^ ...so that the type `<T as Iterator>::Item` will meet its required lifetime bounds
+ |
+help: consider adding an explicit lifetime bound
|
- = help: consider adding an explicit lifetime bound `<T as Iterator>::Item: 'a`...
- = note: ...so that the type `<T as Iterator>::Item` will meet its required lifetime bounds
+LL | T: 'b + Iterator, <T as Iterator>::Item: 'a
+ | ~~~~~~~~~~~~~~~~~~~~~~~~~~~
note: external requirements
--> $DIR/projection-no-regions-closure.rs:52:23
diff --git a/tests/ui/nll/ty-outlives/projection-no-regions-fn.stderr b/tests/ui/nll/ty-outlives/projection-no-regions-fn.stderr
index e0ff544fe4713..da76ac1c474a3 100644
--- a/tests/ui/nll/ty-outlives/projection-no-regions-fn.stderr
+++ b/tests/ui/nll/ty-outlives/projection-no-regions-fn.stderr
@@ -1,20 +1,30 @@
error[E0309]: the associated type `<T as Iterator>::Item` may not live long enough
--> $DIR/projection-no-regions-fn.rs:13:5
|
+LL | fn no_region<'a, T>(mut x: T) -> Box<dyn Anything + 'a>
+ | -- the associated type `<T as Iterator>::Item` must be valid for the lifetime `'a` as defined here...
+...
LL | Box::new(x.next())
- | ^^^^^^^^^^^^^^^^^^
+ | ^^^^^^^^^^^^^^^^^^ ...so that the type `<T as Iterator>::Item` will meet its required lifetime bounds
|
- = help: consider adding an explicit lifetime bound `<T as Iterator>::Item: 'a`...
- = note: ...so that the type `<T as Iterator>::Item` will meet its required lifetime bounds
+help: consider adding an explicit lifetime bound
+ |
+LL | T: Iterator, <T as Iterator>::Item: 'a
+ | ~~~~~~~~~~~~~~~~~~~~~~~~~~~
error[E0309]: the associated type `<T as Iterator>::Item` may not live long enough
--> $DIR/projection-no-regions-fn.rs:28:5
|
+LL | fn wrong_region<'a, 'b, T>(mut x: T) -> Box<dyn Anything + 'a>
+ | -- the associated type `<T as Iterator>::Item` must be valid for the lifetime `'a` as defined here...
+...
LL | Box::new(x.next())
- | ^^^^^^^^^^^^^^^^^^
+ | ^^^^^^^^^^^^^^^^^^ ...so that the type `<T as Iterator>::Item` will meet its required lifetime bounds
+ |
+help: consider adding an explicit lifetime bound
|
- = help: consider adding an explicit lifetime bound `<T as Iterator>::Item: 'a`...
- = note: ...so that the type `<T as Iterator>::Item` will meet its required lifetime bounds
+LL | T: 'b + Iterator, <T as Iterator>::Item: 'a
+ | ~~~~~~~~~~~~~~~~~~~~~~~~~~~
error: aborting due to 2 previous errors
diff --git a/tests/ui/nll/ty-outlives/projection-one-region-closure.stderr b/tests/ui/nll/ty-outlives/projection-one-region-closure.stderr
index ebdce7bc10832..dda60398198e7 100644
--- a/tests/ui/nll/ty-outlives/projection-one-region-closure.stderr
+++ b/tests/ui/nll/ty-outlives/projection-one-region-closure.stderr
@@ -27,10 +27,13 @@ LL | | T: Anything<'b>,
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/projection-one-region-closure.rs:45:39
|
+LL | fn no_relationships_late<'a, 'b, T>(cell: Cell<&'a ()>, t: T)
+ | -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
+...
LL | with_signature(cell, t, |cell, t| require(cell, t));
| ^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | T: Anything<'b> + 'a,
| ++++
@@ -77,10 +80,13 @@ LL | | 'a: 'a,
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/projection-one-region-closure.rs:56:39
|
+LL | fn no_relationships_early<'a, 'b, T>(cell: Cell<&'a ()>, t: T)
+ | -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
+...
LL | with_signature(cell, t, |cell, t| require(cell, t));
| ^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | T: Anything<'b> + 'a,
| ++++
diff --git a/tests/ui/nll/ty-outlives/projection-two-region-trait-bound-closure.stderr b/tests/ui/nll/ty-outlives/projection-two-region-trait-bound-closure.stderr
index dbad8e478463c..c157e89ff8f31 100644
--- a/tests/ui/nll/ty-outlives/projection-two-region-trait-bound-closure.stderr
+++ b/tests/ui/nll/ty-outlives/projection-two-region-trait-bound-closure.stderr
@@ -26,11 +26,13 @@ LL | | T: Anything<'b, 'c>,
error[E0309]: the associated type `<T as Anything<'?5, '?6>>::AssocType` may not live long enough
--> $DIR/projection-two-region-trait-bound-closure.rs:38:39
|
+LL | fn no_relationships_late<'a, 'b, 'c, T>(cell: Cell<&'a ()>, t: T)
+ | -- the associated type `<T as Anything<'?5, '?6>>::AssocType` must be valid for the lifetime `'a` as defined here...
+...
LL | with_signature(cell, t, |cell, t| require(cell, t));
- | ^^^^^^^^^^^^^^^^
+ | ^^^^^^^^^^^^^^^^ ...so that the type `<T as Anything<'?5, '?6>>::AssocType` will meet its required lifetime bounds
|
= help: consider adding an explicit lifetime bound `<T as Anything<'?5, '?6>>::AssocType: 'a`...
- = note: ...so that the type `<T as Anything<'?5, '?6>>::AssocType` will meet its required lifetime bounds
note: external requirements
--> $DIR/projection-two-region-trait-bound-closure.rs:48:29
@@ -60,11 +62,13 @@ LL | | 'a: 'a,
error[E0309]: the associated type `<T as Anything<'?6, '?7>>::AssocType` may not live long enough
--> $DIR/projection-two-region-trait-bound-closure.rs:48:39
|
+LL | fn no_relationships_early<'a, 'b, 'c, T>(cell: Cell<&'a ()>, t: T)
+ | -- the associated type `<T as Anything<'?6, '?7>>::AssocType` must be valid for the lifetime `'a` as defined here...
+...
LL | with_signature(cell, t, |cell, t| require(cell, t));
- | ^^^^^^^^^^^^^^^^
+ | ^^^^^^^^^^^^^^^^ ...so that the type `<T as Anything<'?6, '?7>>::AssocType` will meet its required lifetime bounds
|
= help: consider adding an explicit lifetime bound `<T as Anything<'?6, '?7>>::AssocType: 'a`...
- = note: ...so that the type `<T as Anything<'?6, '?7>>::AssocType` will meet its required lifetime bounds
note: external requirements
--> $DIR/projection-two-region-trait-bound-closure.rs:61:29
diff --git a/tests/ui/nll/ty-outlives/projection-where-clause-env-wrong-bound.stderr b/tests/ui/nll/ty-outlives/projection-where-clause-env-wrong-bound.stderr
index b4435fe06bccc..1fa74f67ccd71 100644
--- a/tests/ui/nll/ty-outlives/projection-where-clause-env-wrong-bound.stderr
+++ b/tests/ui/nll/ty-outlives/projection-where-clause-env-wrong-bound.stderr
@@ -1,11 +1,13 @@
error[E0309]: the associated type `<T as MyTrait<'_>>::Output` may not live long enough
--> $DIR/projection-where-clause-env-wrong-bound.rs:15:5
|
+LL | fn foo1<'a, 'b, T>() -> &'a ()
+ | -- the associated type `<T as MyTrait<'_>>::Output` must be valid for the lifetime `'a` as defined here...
+...
LL | bar::<T::Output>()
- | ^^^^^^^^^^^^^^^^
+ | ^^^^^^^^^^^^^^^^ ...so that the type `<T as MyTrait<'_>>::Output` will meet its required lifetime bounds
|
= help: consider adding an explicit lifetime bound `<T as MyTrait<'_>>::Output: 'a`...
- = note: ...so that the type `<T as MyTrait<'_>>::Output` will meet its required lifetime bounds
error: aborting due to previous error
diff --git a/tests/ui/nll/ty-outlives/projection-where-clause-env-wrong-lifetime.stderr b/tests/ui/nll/ty-outlives/projection-where-clause-env-wrong-lifetime.stderr
index ddeaf3c1f9e8c..c8dbe4ebc6d94 100644
--- a/tests/ui/nll/ty-outlives/projection-where-clause-env-wrong-lifetime.stderr
+++ b/tests/ui/nll/ty-outlives/projection-where-clause-env-wrong-lifetime.stderr
@@ -1,11 +1,13 @@
error[E0309]: the associated type `<T as MyTrait<'_>>::Output` may not live long enough
--> $DIR/projection-where-clause-env-wrong-lifetime.rs:14:5
|
+LL | fn foo1<'a, 'b, T>() -> &'a ()
+ | -- the associated type `<T as MyTrait<'_>>::Output` must be valid for the lifetime `'a` as defined here...
+...
LL | bar::<<T as MyTrait<'a>>::Output>()
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ...so that the type `<T as MyTrait<'_>>::Output` will meet its required lifetime bounds
|
= help: consider adding an explicit lifetime bound `<T as MyTrait<'_>>::Output: 'a`...
- = note: ...so that the type `<T as MyTrait<'_>>::Output` will meet its required lifetime bounds
error: aborting due to previous error
diff --git a/tests/ui/nll/ty-outlives/projection-where-clause-none.stderr b/tests/ui/nll/ty-outlives/projection-where-clause-none.stderr
index 0df44644d6a9c..f78708dc48d94 100644
--- a/tests/ui/nll/ty-outlives/projection-where-clause-none.stderr
+++ b/tests/ui/nll/ty-outlives/projection-where-clause-none.stderr
@@ -1,10 +1,13 @@
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/projection-where-clause-none.rs:14:5
|
+LL | fn foo<'a, T>() -> &'a ()
+ | -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
+...
LL | bar::<T::Output>()
| ^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | T: MyTrait<'a> + 'a,
| ++++
diff --git a/tests/ui/nll/ty-outlives/ty-param-closure-approximate-lower-bound.stderr b/tests/ui/nll/ty-outlives/ty-param-closure-approximate-lower-bound.stderr
index f58d49d8461b0..59e29e9a420fe 100644
--- a/tests/ui/nll/ty-outlives/ty-param-closure-approximate-lower-bound.stderr
+++ b/tests/ui/nll/ty-outlives/ty-param-closure-approximate-lower-bound.stderr
@@ -46,10 +46,12 @@ LL | fn generic_fail<'a, T>(cell: Cell<&'a ()>, value: T) {
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/ty-param-closure-approximate-lower-bound.rs:29:31
|
+LL | fn generic_fail<'a, T>(cell: Cell<&'a ()>, value: T) {
+ | -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
LL | twice(cell, value, |a, b| invoke(a, b));
| ^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | fn generic_fail<'a, T: 'a>(cell: Cell<&'a ()>, value: T) {
| ++++
diff --git a/tests/ui/nll/ty-outlives/ty-param-closure-outlives-from-return-type.stderr b/tests/ui/nll/ty-outlives/ty-param-closure-outlives-from-return-type.stderr
index ddad1d205e761..3468c5ad37298 100644
--- a/tests/ui/nll/ty-outlives/ty-param-closure-outlives-from-return-type.stderr
+++ b/tests/ui/nll/ty-outlives/ty-param-closure-outlives-from-return-type.stderr
@@ -25,10 +25,13 @@ LL | | T: Debug,
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/ty-param-closure-outlives-from-return-type.rs:26:27
|
+LL | fn no_region<'a, T>(x: Box<T>) -> Box<dyn Debug + 'a>
+ | -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
+...
LL | with_signature(x, |y| y)
| ^ ...so that the type `T` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | T: Debug + 'a,
| ++++
@@ -36,10 +39,13 @@ LL | T: Debug + 'a,
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/ty-param-closure-outlives-from-return-type.rs:41:5
|
+LL | fn wrong_region<'a, 'b, T>(x: Box<T>) -> Box<Debug + 'a>
+ | -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
+...
LL | x
| ^ ...so that the type `T` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | T: 'b + Debug + 'a,
| ++++
diff --git a/tests/ui/nll/ty-outlives/ty-param-closure-outlives-from-where-clause.stderr b/tests/ui/nll/ty-outlives/ty-param-closure-outlives-from-where-clause.stderr
index bb455e9aed090..cef4a0f1e9377 100644
--- a/tests/ui/nll/ty-outlives/ty-param-closure-outlives-from-where-clause.stderr
+++ b/tests/ui/nll/ty-outlives/ty-param-closure-outlives-from-where-clause.stderr
@@ -24,10 +24,13 @@ LL | fn no_region<'a, T>(a: Cell<&'a ()>, b: T) {
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/ty-param-closure-outlives-from-where-clause.rs:32:9
|
+LL | fn no_region<'a, T>(a: Cell<&'a ()>, b: T) {
+ | -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
+...
LL | require(&x, &y)
| ^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | fn no_region<'a, T: 'a>(a: Cell<&'a ()>, b: T) {
| ++++
@@ -84,10 +87,13 @@ LL | | T: 'b,
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/ty-param-closure-outlives-from-where-clause.rs:65:9
|
+LL | fn wrong_region<'a, 'b, T>(a: Cell<&'a ()>, b: T)
+ | -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
+...
LL | require(&x, &y)
| ^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | T: 'b + 'a,
| ++++
diff --git a/tests/ui/nll/ty-outlives/ty-param-fn-body.stderr b/tests/ui/nll/ty-outlives/ty-param-fn-body.stderr
index 5fb69255dbade..73f01ff1519a4 100644
--- a/tests/ui/nll/ty-outlives/ty-param-fn-body.stderr
+++ b/tests/ui/nll/ty-outlives/ty-param-fn-body.stderr
@@ -1,10 +1,12 @@
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/ty-param-fn-body.rs:17:5
|
+LL | fn region_static<'a, T>(cell: Cell<&'a usize>, t: T) {
+ | -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
LL | outlives(cell, t)
| ^^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | fn region_static<'a, T: 'a>(cell: Cell<&'a usize>, t: T) {
| ++++
diff --git a/tests/ui/nll/ty-outlives/ty-param-fn.stderr b/tests/ui/nll/ty-outlives/ty-param-fn.stderr
index 825b26d2f777b..56bd41051e276 100644
--- a/tests/ui/nll/ty-outlives/ty-param-fn.stderr
+++ b/tests/ui/nll/ty-outlives/ty-param-fn.stderr
@@ -1,10 +1,13 @@
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/ty-param-fn.rs:9:5
|
+LL | fn no_region<'a, T>(x: Box<T>) -> Box<Debug + 'a>
+ | -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
+...
LL | x
| ^ ...so that the type `T` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | T: Debug + 'a,
| ++++
@@ -12,10 +15,13 @@ LL | T: Debug + 'a,
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/ty-param-fn.rs:24:5
|
+LL | fn wrong_region<'a, 'b, T>(x: Box<T>) -> Box<Debug + 'a>
+ | -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
+...
LL | x
| ^ ...so that the type `T` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | T: 'b + Debug + 'a,
| ++++
diff --git a/tests/ui/nll/user-annotations/normalization-infer.stderr b/tests/ui/nll/user-annotations/normalization-infer.stderr
index 12854ab6816b7..41d563a55231a 100644
--- a/tests/ui/nll/user-annotations/normalization-infer.stderr
+++ b/tests/ui/nll/user-annotations/normalization-infer.stderr
@@ -2,9 +2,12 @@ error[E0310]: the parameter type `A` may not live long enough
--> $DIR/normalization-infer.rs:11:12
|
LL | let _: <(_,) as Tr>::Ty = a;
- | ^^^^^^^^^^^^^^^^ ...so that the type `A` will meet its required lifetime bounds
+ | ^^^^^^^^^^^^^^^^
+ | |
+ | the parameter type `A` must be valid for the static lifetime...
+ | ...so that the type `A` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | fn test1<A: 'static, B, C, D>(a: A, b: B, c: C) {
| +++++++++
@@ -13,9 +16,12 @@ error[E0310]: the parameter type `B` may not live long enough
--> $DIR/normalization-infer.rs:12:5
|
LL | Some::<<(_,) as Tr>::Ty>(b);
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ...so that the type `B` will meet its required lifetime bounds
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ | |
+ | the parameter type `B` must be valid for the static lifetime...
+ | ...so that the type `B` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | fn test1<A, B: 'static, C, D>(a: A, b: B, c: C) {
| +++++++++
@@ -24,9 +30,12 @@ error[E0310]: the parameter type `C` may not live long enough
--> $DIR/normalization-infer.rs:13:11
|
LL | || -> <(_,) as Tr>::Ty { c };
- | ^^^^^^^^^^^^^^^^ ...so that the type `C` will meet its required lifetime bounds
+ | ^^^^^^^^^^^^^^^^
+ | |
+ | the parameter type `C` must be valid for the static lifetime...
+ | ...so that the type `C` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | fn test1<A, B, C: 'static, D>(a: A, b: B, c: C) {
| +++++++++
@@ -35,9 +44,12 @@ error[E0310]: the parameter type `D` may not live long enough
--> $DIR/normalization-infer.rs:14:6
|
LL | |d: <(_,) as Tr>::Ty| -> D { d };
- | ^ ...so that the type `D` will meet its required lifetime bounds
+ | ^
+ | |
+ | the parameter type `D` must be valid for the static lifetime...
+ | ...so that the type `D` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | fn test1<A, B, C, D: 'static>(a: A, b: B, c: C) {
| +++++++++
@@ -46,9 +58,12 @@ error[E0310]: the parameter type `A` may not live long enough
--> $DIR/normalization-infer.rs:28:12
|
LL | let _: Alias<_, _> = (a, 0u8);
- | ^^^^^^^^^^^ ...so that the type `A` will meet its required lifetime bounds
+ | ^^^^^^^^^^^
+ | |
+ | the parameter type `A` must be valid for the static lifetime...
+ | ...so that the type `A` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | fn test2<A: 'static, B, C>(a: A, b: B, c: C) {
| +++++++++
@@ -57,9 +72,12 @@ error[E0310]: the parameter type `B` may not live long enough
--> $DIR/normalization-infer.rs:29:5
|
LL | Some::<Alias<_, _>>((b, 0u8));
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ...so that the type `B` will meet its required lifetime bounds
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ | |
+ | the parameter type `B` must be valid for the static lifetime...
+ | ...so that the type `B` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | fn test2<A, B: 'static, C>(a: A, b: B, c: C) {
| +++++++++
@@ -68,9 +86,12 @@ error[E0310]: the parameter type `C` may not live long enough
--> $DIR/normalization-infer.rs:30:11
|
LL | || -> Alias<_, _> { (c, 0u8) };
- | ^^^^^^^^^^^ ...so that the type `C` will meet its required lifetime bounds
+ | ^^^^^^^^^^^
+ | |
+ | the parameter type `C` must be valid for the static lifetime...
+ | ...so that the type `C` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | fn test2<A, B, C: 'static>(a: A, b: B, c: C) {
| +++++++++
diff --git a/tests/ui/object-safety/object-safety-supertrait-mentions-GAT.stderr b/tests/ui/object-safety/object-safety-supertrait-mentions-GAT.stderr
index 40429fe756f46..2d2bb27b8f39a 100644
--- a/tests/ui/object-safety/object-safety-supertrait-mentions-GAT.stderr
+++ b/tests/ui/object-safety/object-safety-supertrait-mentions-GAT.stderr
@@ -1,17 +1,11 @@
error[E0311]: the parameter type `Self` may not live long enough
|
-note: the parameter type `Self` must be valid for the lifetime `'a` as defined here...
- --> $DIR/object-safety-supertrait-mentions-GAT.rs:9:26
- |
-LL | trait SuperTrait<T>: for<'a> GatTrait<Gat<'a> = T> {
- | ^^
- = help: consider adding an explicit lifetime bound `Self: 'a`...
- = note: ...so that the type `Self` will meet its required lifetime bounds...
note: ...that is required by this bound
--> $DIR/object-safety-supertrait-mentions-GAT.rs:6:15
|
LL | Self: 'a;
| ^^
+ = help: consider adding an explicit lifetime bound `Self: 'a`...
error: associated item referring to unboxed trait object for its own trait
--> $DIR/object-safety-supertrait-mentions-GAT.rs:10:20
diff --git a/tests/ui/regions/closure-in-projection-issue-97405.stderr b/tests/ui/regions/closure-in-projection-issue-97405.stderr
index c08f1059ebf58..7070dfef138ac 100644
--- a/tests/ui/regions/closure-in-projection-issue-97405.stderr
+++ b/tests/ui/regions/closure-in-projection-issue-97405.stderr
@@ -3,27 +3,33 @@ error[E0310]: the associated type `<impl Iterator as Iterator>::Item` may not li
|
LL | assert_static(opaque(async move { t; }).next());
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ | |
+ | the associated type `<impl Iterator as Iterator>::Item` must be valid for the static lifetime...
+ | ...so that the type `<impl Iterator as Iterator>::Item` will meet its required lifetime bounds
|
= help: consider adding an explicit lifetime bound `<impl Iterator as Iterator>::Item: 'static`...
- = note: ...so that the type `<impl Iterator as Iterator>::Item` will meet its required lifetime bounds
error[E0310]: the associated type `<impl Iterator as Iterator>::Item` may not live long enough
--> $DIR/closure-in-projection-issue-97405.rs:26:5
|
LL | assert_static(opaque(move || { t; }).next());
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ | |
+ | the associated type `<impl Iterator as Iterator>::Item` must be valid for the static lifetime...
+ | ...so that the type `<impl Iterator as Iterator>::Item` will meet its required lifetime bounds
|
= help: consider adding an explicit lifetime bound `<impl Iterator as Iterator>::Item: 'static`...
- = note: ...so that the type `<impl Iterator as Iterator>::Item` will meet its required lifetime bounds
error[E0310]: the associated type `<impl Iterator as Iterator>::Item` may not live long enough
--> $DIR/closure-in-projection-issue-97405.rs:28:5
|
LL | assert_static(opaque(opaque(async move { t; }).next()).next());
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ | |
+ | the associated type `<impl Iterator as Iterator>::Item` must be valid for the static lifetime...
+ | ...so that the type `<impl Iterator as Iterator>::Item` will meet its required lifetime bounds
|
= help: consider adding an explicit lifetime bound `<impl Iterator as Iterator>::Item: 'static`...
- = note: ...so that the type `<impl Iterator as Iterator>::Item` will meet its required lifetime bounds
error: aborting due to 3 previous errors
diff --git a/tests/ui/regions/regions-close-associated-type-into-object.stderr b/tests/ui/regions/regions-close-associated-type-into-object.stderr
index f7dcaa9d97e7c..6fb514377a6c2 100644
--- a/tests/ui/regions/regions-close-associated-type-into-object.stderr
+++ b/tests/ui/regions/regions-close-associated-type-into-object.stderr
@@ -3,36 +3,56 @@ error[E0310]: the associated type `<T as Iter>::Item` may not live long enough
|
LL | Box::new(item)
| ^^^^^^^^^^^^^^
+ | |
+ | the associated type `<T as Iter>::Item` must be valid for the static lifetime...
+ | ...so that the type `<T as Iter>::Item` will meet its required lifetime bounds
|
- = help: consider adding an explicit lifetime bound `<T as Iter>::Item: 'static`...
- = note: ...so that the type `<T as Iter>::Item` will meet its required lifetime bounds
+help: consider adding an explicit lifetime bound
+ |
+LL | fn bad1<T: Iter>(v: T) -> Box<dyn X + 'static> where <T as Iter>::Item: 'static
+ | ++++++++++++++++++++++++++++++++
error[E0310]: the associated type `<T as Iter>::Item` may not live long enough
--> $DIR/regions-close-associated-type-into-object.rs:22:5
|
LL | Box::new(item)
| ^^^^^^^^^^^^^^
+ | |
+ | the associated type `<T as Iter>::Item` must be valid for the static lifetime...
+ | ...so that the type `<T as Iter>::Item` will meet its required lifetime bounds
+ |
+help: consider adding an explicit lifetime bound
|
- = help: consider adding an explicit lifetime bound `<T as Iter>::Item: 'static`...
- = note: ...so that the type `<T as Iter>::Item` will meet its required lifetime bounds
+LL | where Box<T::Item> : X, <T as Iter>::Item: 'static
+ | ++++++++++++++++++++++++++++
error[E0309]: the associated type `<T as Iter>::Item` may not live long enough
--> $DIR/regions-close-associated-type-into-object.rs:28:5
|
+LL | fn bad3<'a, T: Iter>(v: T) -> Box<dyn X + 'a>
+ | -- the associated type `<T as Iter>::Item` must be valid for the lifetime `'a` as defined here...
+...
LL | Box::new(item)
- | ^^^^^^^^^^^^^^
+ | ^^^^^^^^^^^^^^ ...so that the type `<T as Iter>::Item` will meet its required lifetime bounds
|
- = help: consider adding an explicit lifetime bound `<T as Iter>::Item: 'a`...
- = note: ...so that the type `<T as Iter>::Item` will meet its required lifetime bounds
+help: consider adding an explicit lifetime bound
+ |
+LL | fn bad3<'a, T: Iter>(v: T) -> Box<dyn X + 'a> where <T as Iter>::Item: 'a
+ | +++++++++++++++++++++++++++
error[E0309]: the associated type `<T as Iter>::Item` may not live long enough
--> $DIR/regions-close-associated-type-into-object.rs:35:5
|
+LL | fn bad4<'a, T: Iter>(v: T) -> Box<dyn X + 'a>
+ | -- the associated type `<T as Iter>::Item` must be valid for the lifetime `'a` as defined here...
+...
LL | Box::new(item)
- | ^^^^^^^^^^^^^^
+ | ^^^^^^^^^^^^^^ ...so that the type `<T as Iter>::Item` will meet its required lifetime bounds
+ |
+help: consider adding an explicit lifetime bound
|
- = help: consider adding an explicit lifetime bound `<T as Iter>::Item: 'a`...
- = note: ...so that the type `<T as Iter>::Item` will meet its required lifetime bounds
+LL | where Box<T::Item> : X, <T as Iter>::Item: 'a
+ | +++++++++++++++++++++++
error: aborting due to 4 previous errors
diff --git a/tests/ui/regions/regions-close-object-into-object-4.stderr b/tests/ui/regions/regions-close-object-into-object-4.stderr
index 3ff7f891c6610..b8b414b7e125e 100644
--- a/tests/ui/regions/regions-close-object-into-object-4.stderr
+++ b/tests/ui/regions/regions-close-object-into-object-4.stderr
@@ -2,9 +2,12 @@ error[E0310]: the parameter type `U` may not live long enough
--> $DIR/regions-close-object-into-object-4.rs:9:5
|
LL | Box::new(B(&*v)) as Box<dyn X>
- | ^^^^^^^^ ...so that the type `U` will meet its required lifetime bounds
+ | ^^^^^^^^
+ | |
+ | the parameter type `U` must be valid for the static lifetime...
+ | ...so that the type `U` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | fn i<'a, T, U: 'static>(v: Box<dyn A<U>+'a>) -> Box<dyn X + 'static> {
| +++++++++
@@ -13,9 +16,12 @@ error[E0310]: the parameter type `U` may not live long enough
--> $DIR/regions-close-object-into-object-4.rs:9:5
|
LL | Box::new(B(&*v)) as Box<dyn X>
- | ^^^^^^^^^^^^^^^^ ...so that the type `U` will meet its required lifetime bounds
+ | ^^^^^^^^^^^^^^^^
+ | |
+ | the parameter type `U` must be valid for the static lifetime...
+ | ...so that the type `U` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | fn i<'a, T, U: 'static>(v: Box<dyn A<U>+'a>) -> Box<dyn X + 'static> {
| +++++++++
@@ -24,10 +30,13 @@ error[E0310]: the parameter type `U` may not live long enough
--> $DIR/regions-close-object-into-object-4.rs:9:5
|
LL | Box::new(B(&*v)) as Box<dyn X>
- | ^^^^^^^^^^^^^^^^ ...so that the type `U` will meet its required lifetime bounds
+ | ^^^^^^^^^^^^^^^^
+ | |
+ | the parameter type `U` must be valid for the static lifetime...
+ | ...so that the type `U` will meet its required lifetime bounds
|
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | fn i<'a, T, U: 'static>(v: Box<dyn A<U>+'a>) -> Box<dyn X + 'static> {
| +++++++++
@@ -62,9 +71,12 @@ error[E0310]: the parameter type `U` may not live long enough
--> $DIR/regions-close-object-into-object-4.rs:9:14
|
LL | Box::new(B(&*v)) as Box<dyn X>
- | ^^^^^^ ...so that the type `U` will meet its required lifetime bounds
+ | ^^^^^^
+ | |
+ | the parameter type `U` must be valid for the static lifetime...
+ | ...so that the type `U` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | fn i<'a, T, U: 'static>(v: Box<dyn A<U>+'a>) -> Box<dyn X + 'static> {
| +++++++++
diff --git a/tests/ui/regions/regions-close-object-into-object-5.stderr b/tests/ui/regions/regions-close-object-into-object-5.stderr
index 88c1348326370..4a2f4f847a308 100644
--- a/tests/ui/regions/regions-close-object-into-object-5.stderr
+++ b/tests/ui/regions/regions-close-object-into-object-5.stderr
@@ -2,9 +2,12 @@ error[E0310]: the parameter type `T` may not live long enough
--> $DIR/regions-close-object-into-object-5.rs:17:5
|
LL | Box::new(B(&*v)) as Box<dyn X>
- | ^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
+ | ^^^^^^^^
+ | |
+ | the parameter type `T` must be valid for the static lifetime...
+ | ...so that the type `T` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | fn f<'a, T: 'static, U>(v: Box<A<T> + 'static>) -> Box<X + 'static> {
| +++++++++
@@ -13,9 +16,12 @@ error[E0310]: the parameter type `T` may not live long enough
--> $DIR/regions-close-object-into-object-5.rs:17:5
|
LL | Box::new(B(&*v)) as Box<dyn X>
- | ^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
+ | ^^^^^^^^^^^^^^^^
+ | |
+ | the parameter type `T` must be valid for the static lifetime...
+ | ...so that the type `T` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | fn f<'a, T: 'static, U>(v: Box<A<T> + 'static>) -> Box<X + 'static> {
| +++++++++
@@ -24,10 +30,13 @@ error[E0310]: the parameter type `T` may not live long enough
--> $DIR/regions-close-object-into-object-5.rs:17:5
|
LL | Box::new(B(&*v)) as Box<dyn X>
- | ^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
+ | ^^^^^^^^^^^^^^^^
+ | |
+ | the parameter type `T` must be valid for the static lifetime...
+ | ...so that the type `T` will meet its required lifetime bounds
|
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | fn f<'a, T: 'static, U>(v: Box<A<T> + 'static>) -> Box<X + 'static> {
| +++++++++
@@ -45,9 +54,12 @@ error[E0310]: the parameter type `T` may not live long enough
--> $DIR/regions-close-object-into-object-5.rs:17:14
|
LL | Box::new(B(&*v)) as Box<dyn X>
- | ^^^^^^ ...so that the type `T` will meet its required lifetime bounds
+ | ^^^^^^
+ | |
+ | the parameter type `T` must be valid for the static lifetime...
+ | ...so that the type `T` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | fn f<'a, T: 'static, U>(v: Box<A<T> + 'static>) -> Box<X + 'static> {
| +++++++++
diff --git a/tests/ui/regions/regions-close-over-type-parameter-1.stderr b/tests/ui/regions/regions-close-over-type-parameter-1.stderr
index b7b557d7a60a4..1cd5b7f225079 100644
--- a/tests/ui/regions/regions-close-over-type-parameter-1.stderr
+++ b/tests/ui/regions/regions-close-over-type-parameter-1.stderr
@@ -2,9 +2,12 @@ error[E0310]: the parameter type `A` may not live long enough
--> $DIR/regions-close-over-type-parameter-1.rs:11:5
|
LL | Box::new(v) as Box<dyn SomeTrait + 'static>
- | ^^^^^^^^^^^ ...so that the type `A` will meet its required lifetime bounds
+ | ^^^^^^^^^^^
+ | |
+ | the parameter type `A` must be valid for the static lifetime...
+ | ...so that the type `A` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | fn make_object1<A: SomeTrait + 'static>(v: A) -> Box<dyn SomeTrait + 'static> {
| +++++++++
@@ -12,10 +15,12 @@ LL | fn make_object1<A: SomeTrait + 'static>(v: A) -> Box<dyn SomeTrait + 'stati
error[E0309]: the parameter type `A` may not live long enough
--> $DIR/regions-close-over-type-parameter-1.rs:20:5
|
+LL | fn make_object3<'a, 'b, A: SomeTrait + 'a>(v: A) -> Box<dyn SomeTrait + 'b> {
+ | -- the parameter type `A` must be valid for the lifetime `'b` as defined here...
LL | Box::new(v) as Box<dyn SomeTrait + 'b>
| ^^^^^^^^^^^ ...so that the type `A` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | fn make_object3<'a, 'b, A: SomeTrait + 'a + 'b>(v: A) -> Box<dyn SomeTrait + 'b> {
| ++++
diff --git a/tests/ui/regions/regions-close-param-into-object.stderr b/tests/ui/regions/regions-close-param-into-object.stderr
index 9162be5b93cca..385441d328277 100644
--- a/tests/ui/regions/regions-close-param-into-object.stderr
+++ b/tests/ui/regions/regions-close-param-into-object.stderr
@@ -2,9 +2,12 @@ error[E0310]: the parameter type `T` may not live long enough
--> $DIR/regions-close-param-into-object.rs:6:5
|
LL | Box::new(v)
- | ^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
+ | ^^^^^^^^^^^
+ | |
+ | the parameter type `T` must be valid for the static lifetime...
+ | ...so that the type `T` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | where T : X + 'static
| +++++++++
@@ -13,9 +16,12 @@ error[E0310]: the parameter type `T` may not live long enough
--> $DIR/regions-close-param-into-object.rs:12:5
|
LL | Box::new(v)
- | ^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
+ | ^^^^^^^^^^^
+ | |
+ | the parameter type `T` must be valid for the static lifetime...
+ | ...so that the type `T` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | fn p2<T: 'static>(v: Box<T>) -> Box<dyn X + 'static>
| +++++++++
@@ -23,10 +29,13 @@ LL | fn p2<T: 'static>(v: Box<T>) -> Box<dyn X + 'static>
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/regions-close-param-into-object.rs:18:5
|
+LL | fn p3<'a,T>(v: T) -> Box<dyn X + 'a>
+ | -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
+...
LL | Box::new(v)
| ^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | where T : X + 'a
| ++++
@@ -34,10 +43,13 @@ LL | where T : X + 'a
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/regions-close-param-into-object.rs:24:5
|
+LL | fn p4<'a,T>(v: Box<T>) -> Box<dyn X + 'a>
+ | -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
+...
LL | Box::new(v)
| ^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | fn p4<'a,T: 'a>(v: Box<T>) -> Box<dyn X + 'a>
| ++++
diff --git a/tests/ui/regions/regions-implied-bounds-projection-gap-1.stderr b/tests/ui/regions/regions-implied-bounds-projection-gap-1.stderr
index 7c9f405563caa..8c1791fc11d76 100644
--- a/tests/ui/regions/regions-implied-bounds-projection-gap-1.stderr
+++ b/tests/ui/regions/regions-implied-bounds-projection-gap-1.stderr
@@ -1,10 +1,13 @@
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/regions-implied-bounds-projection-gap-1.rs:16:5
|
+LL | fn func<'x, T:Trait1<'x>>(t: &'x T::Foo)
+ | -- the parameter type `T` must be valid for the lifetime `'x` as defined here...
+LL | {
LL | wf::<&'x T>();
| ^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | fn func<'x, T:Trait1<'x> + 'x>(t: &'x T::Foo)
| ++++
diff --git a/tests/ui/regions/regions-infer-bound-from-trait-self.stderr b/tests/ui/regions/regions-infer-bound-from-trait-self.stderr
index e88f79a3a8c54..d0c4b9a57e096 100644
--- a/tests/ui/regions/regions-infer-bound-from-trait-self.stderr
+++ b/tests/ui/regions/regions-infer-bound-from-trait-self.stderr
@@ -1,11 +1,16 @@
error[E0309]: the parameter type `Self` may not live long enough
--> $DIR/regions-infer-bound-from-trait-self.rs:46:9
|
+LL | trait InheritsFromNothing<'a> : Sized {
+ | -- the parameter type `Self` must be valid for the lifetime `'a` as defined here...
+LL | fn foo(self, x: Inv<'a>) {
LL | check_bound(x, self)
- | ^^^^^^^^^^^^^^^^^^^^
+ | ^^^^^^^^^^^^^^^^^^^^ ...so that the type `Self` will meet its required lifetime bounds
|
- = help: consider adding an explicit lifetime bound `Self: 'a`...
- = note: ...so that the type `Self` will meet its required lifetime bounds
+help: consider adding an explicit lifetime bound
+ |
+LL | trait InheritsFromNothing<'a> : Sized where Self: 'a {
+ | ++++++++++++++
error: aborting due to previous error
diff --git a/tests/ui/regions/regions-infer-bound-from-trait.stderr b/tests/ui/regions/regions-infer-bound-from-trait.stderr
index 3ee71543d1570..b9be11a4639fe 100644
--- a/tests/ui/regions/regions-infer-bound-from-trait.stderr
+++ b/tests/ui/regions/regions-infer-bound-from-trait.stderr
@@ -1,10 +1,12 @@
error[E0309]: the parameter type `A` may not live long enough
--> $DIR/regions-infer-bound-from-trait.rs:33:5
|
+LL | fn bar1<'a,A>(x: Inv<'a>, a: A) {
+ | -- the parameter type `A` must be valid for the lifetime `'a` as defined here...
LL | check_bound(x, a)
| ^^^^^^^^^^^^^^^^^ ...so that the type `A` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | fn bar1<'a,A: 'a>(x: Inv<'a>, a: A) {
| ++++
@@ -12,10 +14,12 @@ LL | fn bar1<'a,A: 'a>(x: Inv<'a>, a: A) {
error[E0309]: the parameter type `A` may not live long enough
--> $DIR/regions-infer-bound-from-trait.rs:37:5
|
+LL | fn bar2<'a,'b,A:Is<'b>>(x: Inv<'a>, y: Inv<'b>, a: A) {
+ | -- the parameter type `A` must be valid for the lifetime `'a` as defined here...
LL | check_bound(x, a)
| ^^^^^^^^^^^^^^^^^ ...so that the type `A` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | fn bar2<'a,'b,A:Is<'b> + 'a>(x: Inv<'a>, y: Inv<'b>, a: A) {
| ++++
diff --git a/tests/ui/rfcs/rfc-2093-infer-outlives/dont-infer-static.stderr b/tests/ui/rfcs/rfc-2093-infer-outlives/dont-infer-static.stderr
index 0c388f5fe411b..041f7ebc0aa1d 100644
--- a/tests/ui/rfcs/rfc-2093-infer-outlives/dont-infer-static.stderr
+++ b/tests/ui/rfcs/rfc-2093-infer-outlives/dont-infer-static.stderr
@@ -2,14 +2,17 @@ error[E0310]: the parameter type `U` may not live long enough
--> $DIR/dont-infer-static.rs:6:10
|
LL | bar: Bar<U>
- | ^^^^^^ ...so that the type `U` will meet its required lifetime bounds...
+ | ^^^^^^
+ | |
+ | the parameter type `U` must be valid for the static lifetime...
+ | ...so that the type `U` will meet its required lifetime bounds...
|
note: ...that is required by this bound
--> $DIR/dont-infer-static.rs:8:15
|
LL | struct Bar<T: 'static> {
| ^^^^^^^
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | struct Foo<U: 'static> {
| +++++++++
diff --git a/tests/ui/rfcs/rfc-2093-infer-outlives/regions-enum-not-wf.stderr b/tests/ui/rfcs/rfc-2093-infer-outlives/regions-enum-not-wf.stderr
index 2c660b2850097..5b605f3eef569 100644
--- a/tests/ui/rfcs/rfc-2093-infer-outlives/regions-enum-not-wf.stderr
+++ b/tests/ui/rfcs/rfc-2093-infer-outlives/regions-enum-not-wf.stderr
@@ -1,10 +1,12 @@
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/regions-enum-not-wf.rs:17:18
|
+LL | enum Ref1<'a, T> {
+ | -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
LL | Ref1Variant1(RequireOutlives<'a, T>),
| ^^^^^^^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | enum Ref1<'a, T: 'a> {
| ++++
@@ -12,10 +14,13 @@ LL | enum Ref1<'a, T: 'a> {
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/regions-enum-not-wf.rs:22:25
|
+LL | enum Ref2<'a, T> {
+ | -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
+LL | Ref2Variant1,
LL | Ref2Variant2(isize, RequireOutlives<'a, T>),
| ^^^^^^^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | enum Ref2<'a, T: 'a> {
| ++++
@@ -23,10 +28,12 @@ LL | enum Ref2<'a, T: 'a> {
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/regions-enum-not-wf.rs:35:23
|
+LL | enum RefDouble<'a, 'b, T> {
+ | -- the parameter type `T` must be valid for the lifetime `'b` as defined here...
LL | RefDoubleVariant1(&'a RequireOutlives<'b, T>),
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | enum RefDouble<'a, 'b, T: 'b> {
| ++++
diff --git a/tests/ui/rfcs/rfc-2093-infer-outlives/regions-struct-not-wf.stderr b/tests/ui/rfcs/rfc-2093-infer-outlives/regions-struct-not-wf.stderr
index 34ff1362cf323..eb17ce736f766 100644
--- a/tests/ui/rfcs/rfc-2093-infer-outlives/regions-struct-not-wf.stderr
+++ b/tests/ui/rfcs/rfc-2093-infer-outlives/regions-struct-not-wf.stderr
@@ -1,10 +1,12 @@
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/regions-struct-not-wf.rs:13:16
|
+LL | impl<'a, T> Trait<'a, T> for usize {
+ | -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
LL | type Out = &'a T;
| ^^^^^ ...so that the reference type `&'a T` does not outlive the data it points at
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | impl<'a, T: 'a> Trait<'a, T> for usize {
| ++++
@@ -12,6 +14,8 @@ LL | impl<'a, T: 'a> Trait<'a, T> for usize {
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/regions-struct-not-wf.rs:21:16
|
+LL | impl<'a, T> Trait<'a, T> for u32 {
+ | -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
LL | type Out = RefOk<'a, T>;
| ^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds...
|
@@ -20,7 +24,7 @@ note: ...that is required by this bound
|
LL | struct RefOk<'a, T:'a> {
| ^^
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | impl<'a, T: 'a> Trait<'a, T> for u32 {
| ++++
diff --git a/tests/ui/suggestions/lifetimes/issue-105544.fixed b/tests/ui/suggestions/lifetimes/issue-105544.fixed
index 47087eb474972..c92114e181254 100644
--- a/tests/ui/suggestions/lifetimes/issue-105544.fixed
+++ b/tests/ui/suggestions/lifetimes/issue-105544.fixed
@@ -2,7 +2,7 @@
#![allow(warnings)]
-fn foo<'a>(d: impl Sized + 'a, p: &'a mut ()) -> impl Sized + '_ { //~ NOTE the parameter type `impl Sized` must be valid for the anonymous lifetime defined here...
+fn foo<'a>(d: impl Sized + 'a, p: &'a mut ()) -> impl Sized + 'a { //~ NOTE the parameter type `impl Sized` must be valid for the anonymous lifetime defined here...
//~^ HELP consider adding an explicit lifetime bound
(d, p)
//~^ ERROR the parameter type `impl Sized` may not live long enough
@@ -10,19 +10,20 @@ fn foo<'a>(d: impl Sized + 'a, p: &'a mut ()) -> impl Sized + '_ { //~ NOTE the
}
fn foo1<'b>(d: impl Sized + 'b, p: &'b mut ()) -> impl Sized + '_ {
-//~^ HELP consider adding an explicit lifetime bound...
+//~^ NOTE the parameter type `impl Sized` must be valid for the lifetime `'b` as defined here...
+//~| HELP consider adding an explicit lifetime bound
(d, p) //~ NOTE ...so that the type `impl Sized` will meet its required lifetime bounds
//~^ ERROR the parameter type `impl Sized` may not live long enough
}
-fn foo2<'b, 'a>(d: impl Sized + 'a + 'b, p: &'b mut ()) -> impl Sized + '_ { //~ NOTE the parameter type `impl Sized + 'a` must be valid for the anonymous lifetime defined here...
+fn foo2<'b, 'a>(d: impl Sized + 'a + 'b, p: &'b mut ()) -> impl Sized + 'b { //~ NOTE the parameter type `impl Sized + 'a` must be valid for the anonymous lifetime defined here...
//~^ HELP consider adding an explicit lifetime bound
(d, p)
//~^ ERROR the parameter type `impl Sized + 'a` may not live long enough
//~| NOTE ...so that the type `impl Sized + 'a` will meet its required lifetime bounds
}
-fn bar<'a, T : Sized + 'a>(d: T, p: &'a mut ()) -> impl Sized + '_ { //~ NOTE the parameter type `T` must be valid for the anonymous lifetime defined here...
+fn bar<'a, T : Sized + 'a>(d: T, p: &'a mut ()) -> impl Sized + 'a { //~ NOTE the parameter type `T` must be valid for the anonymous lifetime defined here...
//~^ HELP consider adding an explicit lifetime bound
(d, p)
//~^ ERROR the parameter type `T` may not live long enough
@@ -30,12 +31,13 @@ fn bar<'a, T : Sized + 'a>(d: T, p: &'a mut ()) -> impl Sized + '_ { //~ NOTE th
}
fn bar1<'b, T : Sized + 'b>(d: T, p: &'b mut ()) -> impl Sized + '_ {
-//~^ HELP consider adding an explicit lifetime bound...
+//~^ NOTE the parameter type `T` must be valid for the lifetime `'b` as defined here...
+//~| HELP consider adding an explicit lifetime bound
(d, p) //~ NOTE ...so that the type `T` will meet its required lifetime bounds
//~^ ERROR the parameter type `T` may not live long enough
}
-fn bar2<'b, 'a, T : Sized + 'a + 'b>(d: T, p: &'b mut ()) -> impl Sized + '_ { //~ NOTE the parameter type `T` must be valid for the anonymous lifetime defined here...
+fn bar2<'b, 'a, T : Sized + 'a + 'b>(d: T, p: &'b mut ()) -> impl Sized + 'b { //~ NOTE the parameter type `T` must be valid for the anonymous lifetime defined here...
//~^ HELP consider adding an explicit lifetime bound
(d, p)
//~^ ERROR the parameter type `T` may not live long enough
diff --git a/tests/ui/suggestions/lifetimes/issue-105544.rs b/tests/ui/suggestions/lifetimes/issue-105544.rs
index bd3bc1ef9bd2d..bbd0f097f8408 100644
--- a/tests/ui/suggestions/lifetimes/issue-105544.rs
+++ b/tests/ui/suggestions/lifetimes/issue-105544.rs
@@ -10,7 +10,8 @@ fn foo(d: impl Sized, p: &mut ()) -> impl Sized + '_ { //~ NOTE the parameter ty
}
fn foo1<'b>(d: impl Sized, p: &'b mut ()) -> impl Sized + '_ {
-//~^ HELP consider adding an explicit lifetime bound...
+//~^ NOTE the parameter type `impl Sized` must be valid for the lifetime `'b` as defined here...
+//~| HELP consider adding an explicit lifetime bound
(d, p) //~ NOTE ...so that the type `impl Sized` will meet its required lifetime bounds
//~^ ERROR the parameter type `impl Sized` may not live long enough
}
@@ -30,7 +31,8 @@ fn bar<T : Sized>(d: T, p: & mut ()) -> impl Sized + '_ { //~ NOTE the parameter
}
fn bar1<'b, T : Sized>(d: T, p: &'b mut ()) -> impl Sized + '_ {
-//~^ HELP consider adding an explicit lifetime bound...
+//~^ NOTE the parameter type `T` must be valid for the lifetime `'b` as defined here...
+//~| HELP consider adding an explicit lifetime bound
(d, p) //~ NOTE ...so that the type `T` will meet its required lifetime bounds
//~^ ERROR the parameter type `T` may not live long enough
}
diff --git a/tests/ui/suggestions/lifetimes/issue-105544.stderr b/tests/ui/suggestions/lifetimes/issue-105544.stderr
index 08fe21b11b501..553643c0c3f70 100644
--- a/tests/ui/suggestions/lifetimes/issue-105544.stderr
+++ b/tests/ui/suggestions/lifetimes/issue-105544.stderr
@@ -1,108 +1,86 @@
error[E0311]: the parameter type `impl Sized` may not live long enough
--> $DIR/issue-105544.rs:7:5
|
-LL | (d, p)
- | ^^^^^^
- |
-note: the parameter type `impl Sized` must be valid for the anonymous lifetime defined here...
- --> $DIR/issue-105544.rs:5:26
- |
LL | fn foo(d: impl Sized, p: &mut ()) -> impl Sized + '_ {
- | ^^^^^^^
-note: ...so that the type `impl Sized` will meet its required lifetime bounds
- --> $DIR/issue-105544.rs:7:5
- |
+ | ------- the parameter type `impl Sized` must be valid for the anonymous lifetime defined here...
+LL |
LL | (d, p)
- | ^^^^^^
-help: consider adding an explicit lifetime bound...
+ | ^^^^^^ ...so that the type `impl Sized` will meet its required lifetime bounds
|
-LL | fn foo<'a>(d: impl Sized + 'a, p: &'a mut ()) -> impl Sized + '_ {
- | ++++ ++++ ++
+help: consider adding an explicit lifetime bound
+ |
+LL | fn foo<'a>(d: impl Sized + 'a, p: &'a mut ()) -> impl Sized + 'a {
+ | ++++ ++++ ++ ~~
error[E0309]: the parameter type `impl Sized` may not live long enough
- --> $DIR/issue-105544.rs:14:5
+ --> $DIR/issue-105544.rs:15:5
|
+LL | fn foo1<'b>(d: impl Sized, p: &'b mut ()) -> impl Sized + '_ {
+ | -- the parameter type `impl Sized` must be valid for the lifetime `'b` as defined here...
+...
LL | (d, p)
| ^^^^^^ ...so that the type `impl Sized` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | fn foo1<'b>(d: impl Sized + 'b, p: &'b mut ()) -> impl Sized + '_ {
| ++++
error[E0311]: the parameter type `impl Sized + 'a` may not live long enough
- --> $DIR/issue-105544.rs:20:5
- |
-LL | (d, p)
- | ^^^^^^
- |
-note: the parameter type `impl Sized + 'a` must be valid for the anonymous lifetime defined here...
- --> $DIR/issue-105544.rs:18:36
+ --> $DIR/issue-105544.rs:21:5
|
LL | fn foo2<'a>(d: impl Sized + 'a, p: &mut ()) -> impl Sized + '_ {
- | ^^^^^^^
-note: ...so that the type `impl Sized + 'a` will meet its required lifetime bounds
- --> $DIR/issue-105544.rs:20:5
- |
+ | ------- the parameter type `impl Sized + 'a` must be valid for the anonymous lifetime defined here...
+LL |
LL | (d, p)
- | ^^^^^^
-help: consider adding an explicit lifetime bound...
+ | ^^^^^^ ...so that the type `impl Sized + 'a` will meet its required lifetime bounds
+ |
+help: consider adding an explicit lifetime bound
|
-LL | fn foo2<'b, 'a>(d: impl Sized + 'a + 'b, p: &'b mut ()) -> impl Sized + '_ {
- | +++ ++++ ++
+LL | fn foo2<'b, 'a>(d: impl Sized + 'a + 'b, p: &'b mut ()) -> impl Sized + 'b {
+ | +++ ++++ ++ ~~
error[E0311]: the parameter type `T` may not live long enough
- --> $DIR/issue-105544.rs:27:5
- |
-LL | (d, p)
- | ^^^^^^
- |
-note: the parameter type `T` must be valid for the anonymous lifetime defined here...
- --> $DIR/issue-105544.rs:25:28
+ --> $DIR/issue-105544.rs:28:5
|
LL | fn bar<T : Sized>(d: T, p: & mut ()) -> impl Sized + '_ {
- | ^^^^^^^^
-note: ...so that the type `T` will meet its required lifetime bounds
- --> $DIR/issue-105544.rs:27:5
- |
+ | -------- the parameter type `T` must be valid for the anonymous lifetime defined here...
+LL |
LL | (d, p)
- | ^^^^^^
-help: consider adding an explicit lifetime bound...
+ | ^^^^^^ ...so that the type `T` will meet its required lifetime bounds
+ |
+help: consider adding an explicit lifetime bound
|
-LL | fn bar<'a, T : Sized + 'a>(d: T, p: &'a mut ()) -> impl Sized + '_ {
- | +++ ++++ ++
+LL | fn bar<'a, T : Sized + 'a>(d: T, p: &'a mut ()) -> impl Sized + 'a {
+ | +++ ++++ ++ ~~
error[E0309]: the parameter type `T` may not live long enough
- --> $DIR/issue-105544.rs:34:5
+ --> $DIR/issue-105544.rs:36:5
|
+LL | fn bar1<'b, T : Sized>(d: T, p: &'b mut ()) -> impl Sized + '_ {
+ | -- the parameter type `T` must be valid for the lifetime `'b` as defined here...
+...
LL | (d, p)
| ^^^^^^ ...so that the type `T` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | fn bar1<'b, T : Sized + 'b>(d: T, p: &'b mut ()) -> impl Sized + '_ {
| ++++
error[E0311]: the parameter type `T` may not live long enough
- --> $DIR/issue-105544.rs:40:5
- |
-LL | (d, p)
- | ^^^^^^
- |
-note: the parameter type `T` must be valid for the anonymous lifetime defined here...
- --> $DIR/issue-105544.rs:38:38
+ --> $DIR/issue-105544.rs:42:5
|
LL | fn bar2<'a, T : Sized + 'a>(d: T, p: &mut ()) -> impl Sized + '_ {
- | ^^^^^^^
-note: ...so that the type `T` will meet its required lifetime bounds
- --> $DIR/issue-105544.rs:40:5
- |
+ | ------- the parameter type `T` must be valid for the anonymous lifetime defined here...
+LL |
LL | (d, p)
- | ^^^^^^
-help: consider adding an explicit lifetime bound...
+ | ^^^^^^ ...so that the type `T` will meet its required lifetime bounds
+ |
+help: consider adding an explicit lifetime bound
|
-LL | fn bar2<'b, 'a, T : Sized + 'a + 'b>(d: T, p: &'b mut ()) -> impl Sized + '_ {
- | +++ ++++ ++
+LL | fn bar2<'b, 'a, T : Sized + 'a + 'b>(d: T, p: &'b mut ()) -> impl Sized + 'b {
+ | +++ ++++ ++ ~~
error: aborting due to 6 previous errors
diff --git a/tests/ui/suggestions/lifetimes/missing-lifetimes-in-signature-2.fixed b/tests/ui/suggestions/lifetimes/missing-lifetimes-in-signature-2.fixed
index 4013d98c3cfe7..474986283fc4f 100644
--- a/tests/ui/suggestions/lifetimes/missing-lifetimes-in-signature-2.fixed
+++ b/tests/ui/suggestions/lifetimes/missing-lifetimes-in-signature-2.fixed
@@ -19,11 +19,16 @@ trait Test {
fn test(&self);
}
-fn func<'a, T: Test + 'a>(foo: &'a Foo<'a>, t: T) {
+fn func<'a, T: Test + 'a>(_dummy: &Foo, foo: &Foo<'a>, t: T) {
foo.bar(move |_| {
//~^ ERROR the parameter type `T` may not live long enough
t.test();
});
}
+// Test that the suggested fix does not overconstrain `func`. See #115375.
+fn test_func<'a, T: Test + 'a>(dummy: &Foo, foo: &Foo<'a>, t: T) {
+ func(dummy, foo, t);
+}
+
fn main() {}
diff --git a/tests/ui/suggestions/lifetimes/missing-lifetimes-in-signature-2.rs b/tests/ui/suggestions/lifetimes/missing-lifetimes-in-signature-2.rs
index 4096d95e5fd7f..99c8e9626af7f 100644
--- a/tests/ui/suggestions/lifetimes/missing-lifetimes-in-signature-2.rs
+++ b/tests/ui/suggestions/lifetimes/missing-lifetimes-in-signature-2.rs
@@ -19,11 +19,16 @@ trait Test {
fn test(&self);
}
-fn func<T: Test>(foo: &Foo, t: T) {
+fn func<T: Test>(_dummy: &Foo, foo: &Foo, t: T) {
foo.bar(move |_| {
//~^ ERROR the parameter type `T` may not live long enough
t.test();
});
}
+// Test that the suggested fix does not overconstrain `func`. See #115375.
+fn test_func<'a, T: Test + 'a>(dummy: &Foo, foo: &Foo<'a>, t: T) {
+ func(dummy, foo, t);
+}
+
fn main() {}
diff --git a/tests/ui/suggestions/lifetimes/missing-lifetimes-in-signature-2.stderr b/tests/ui/suggestions/lifetimes/missing-lifetimes-in-signature-2.stderr
index 936d87f796824..6c63e1ada6138 100644
--- a/tests/ui/suggestions/lifetimes/missing-lifetimes-in-signature-2.stderr
+++ b/tests/ui/suggestions/lifetimes/missing-lifetimes-in-signature-2.stderr
@@ -1,29 +1,18 @@
error[E0311]: the parameter type `T` may not live long enough
--> $DIR/missing-lifetimes-in-signature-2.rs:23:5
|
+LL | fn func<T: Test>(_dummy: &Foo, foo: &Foo, t: T) {
+ | --- the parameter type `T` must be valid for the anonymous lifetime defined here...
LL | / foo.bar(move |_| {
LL | |
LL | | t.test();
LL | | });
- | |______^
+ | |______^ ...so that the type `T` will meet its required lifetime bounds
|
-note: the parameter type `T` must be valid for the anonymous lifetime defined here...
- --> $DIR/missing-lifetimes-in-signature-2.rs:22:24
+help: consider adding an explicit lifetime bound
|
-LL | fn func<T: Test>(foo: &Foo, t: T) {
- | ^^^
-note: ...so that the type `T` will meet its required lifetime bounds
- --> $DIR/missing-lifetimes-in-signature-2.rs:23:5
- |
-LL | / foo.bar(move |_| {
-LL | |
-LL | | t.test();
-LL | | });
- | |______^
-help: consider adding an explicit lifetime bound...
- |
-LL | fn func<'a, T: Test + 'a>(foo: &'a Foo<'a>, t: T) {
- | +++ ++++ ++ ++++
+LL | fn func<'a, T: Test + 'a>(_dummy: &Foo, foo: &Foo<'a>, t: T) {
+ | +++ ++++ ++++
error: aborting due to previous error
diff --git a/tests/ui/suggestions/lifetimes/missing-lifetimes-in-signature.stderr b/tests/ui/suggestions/lifetimes/missing-lifetimes-in-signature.stderr
index 318ea4083d1fe..64af17c830e2e 100644
--- a/tests/ui/suggestions/lifetimes/missing-lifetimes-in-signature.stderr
+++ b/tests/ui/suggestions/lifetimes/missing-lifetimes-in-signature.stderr
@@ -28,28 +28,18 @@ LL | fn foo<G, T>(g: G, dest: &mut T) -> impl FnOnce() + '_
error[E0311]: the parameter type `G` may not live long enough
--> $DIR/missing-lifetimes-in-signature.rs:30:5
|
+LL | fn bar<G, T>(g: G, dest: &mut T) -> impl FnOnce() + '_
+ | ------ the parameter type `G` must be valid for the anonymous lifetime defined here...
+...
LL | / move || {
LL | |
LL | | *dest = g.get();
LL | | }
- | |_____^
- |
-note: the parameter type `G` must be valid for the anonymous lifetime defined here...
- --> $DIR/missing-lifetimes-in-signature.rs:26:26
- |
-LL | fn bar<G, T>(g: G, dest: &mut T) -> impl FnOnce() + '_
- | ^^^^^^
-note: ...so that the type `G` will meet its required lifetime bounds
- --> $DIR/missing-lifetimes-in-signature.rs:30:5
+ | |_____^ ...so that the type `G` will meet its required lifetime bounds
|
-LL | / move || {
-LL | |
-LL | | *dest = g.get();
-LL | | }
- | |_____^
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
-LL ~ fn bar<'a, G, T>(g: G, dest: &'a mut T) -> impl FnOnce() + '_
+LL ~ fn bar<'a, G, T>(g: G, dest: &'a mut T) -> impl FnOnce() + 'a
LL | where
LL ~ G: Get<T> + 'a,
|
@@ -57,85 +47,53 @@ LL ~ G: Get<T> + 'a,
error[E0311]: the parameter type `G` may not live long enough
--> $DIR/missing-lifetimes-in-signature.rs:52:5
|
+LL | fn qux<'a, G: 'a, T>(g: G, dest: &mut T) -> impl FnOnce() + '_
+ | ------ the parameter type `G` must be valid for the anonymous lifetime defined here...
+...
LL | / move || {
LL | |
LL | | *dest = g.get();
LL | | }
- | |_____^
- |
-note: the parameter type `G` must be valid for the anonymous lifetime defined here...
- --> $DIR/missing-lifetimes-in-signature.rs:48:34
- |
-LL | fn qux<'a, G: 'a, T>(g: G, dest: &mut T) -> impl FnOnce() + '_
- | ^^^^^^
-note: ...so that the type `G` will meet its required lifetime bounds
- --> $DIR/missing-lifetimes-in-signature.rs:52:5
+ | |_____^ ...so that the type `G` will meet its required lifetime bounds
|
-LL | / move || {
-LL | |
-LL | | *dest = g.get();
-LL | | }
- | |_____^
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
-LL | fn qux<'b, 'a, G: 'a + 'b, T>(g: G, dest: &'b mut T) -> impl FnOnce() + '_
- | +++ ++++ ++
+LL | fn qux<'b, 'a, G: 'a + 'b, T>(g: G, dest: &'b mut T) -> impl FnOnce() + 'b
+ | +++ ++++ ++ ~~
error[E0311]: the parameter type `G` may not live long enough
--> $DIR/missing-lifetimes-in-signature.rs:61:9
|
+LL | fn qux<'b, G: Get<T> + 'b, T>(g: G, dest: &mut T) -> impl FnOnce() + '_ {
+ | ------ the parameter type `G` must be valid for the anonymous lifetime defined here...
LL | / move || {
LL | |
LL | | *dest = g.get();
LL | | }
- | |_________^
+ | |_________^ ...so that the type `G` will meet its required lifetime bounds
|
-note: the parameter type `G` must be valid for the anonymous lifetime defined here...
- --> $DIR/missing-lifetimes-in-signature.rs:60:47
+help: consider adding an explicit lifetime bound
|
-LL | fn qux<'b, G: Get<T> + 'b, T>(g: G, dest: &mut T) -> impl FnOnce() + '_ {
- | ^^^^^^
-note: ...so that the type `G` will meet its required lifetime bounds
- --> $DIR/missing-lifetimes-in-signature.rs:61:9
- |
-LL | / move || {
-LL | |
-LL | | *dest = g.get();
-LL | | }
- | |_________^
-help: consider adding an explicit lifetime bound...
- |
-LL | fn qux<'c, 'b, G: Get<T> + 'b + 'c, T>(g: G, dest: &'c mut T) -> impl FnOnce() + '_ {
- | +++ ++++ ++
+LL | fn qux<'c, 'b, G: Get<T> + 'b + 'c, T>(g: G, dest: &'c mut T) -> impl FnOnce() + 'c {
+ | +++ ++++ ++ ~~
error[E0311]: the parameter type `G` may not live long enough
--> $DIR/missing-lifetimes-in-signature.rs:73:5
|
+LL | fn bat<'a, G: 'a, T>(g: G, dest: &mut T) -> impl FnOnce() + '_ + 'a
+ | ------ the parameter type `G` must be valid for the anonymous lifetime defined here...
+...
LL | / move || {
LL | |
LL | |
LL | | *dest = g.get();
LL | | }
- | |_____^
- |
-note: the parameter type `G` must be valid for the anonymous lifetime defined here...
- --> $DIR/missing-lifetimes-in-signature.rs:69:34
- |
-LL | fn bat<'a, G: 'a, T>(g: G, dest: &mut T) -> impl FnOnce() + '_ + 'a
- | ^^^^^^
-note: ...so that the type `G` will meet its required lifetime bounds
- --> $DIR/missing-lifetimes-in-signature.rs:73:5
+ | |_____^ ...so that the type `G` will meet its required lifetime bounds
|
-LL | / move || {
-LL | |
-LL | |
-LL | | *dest = g.get();
-LL | | }
- | |_____^
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
-LL | fn bat<'b, 'a, G: 'a + 'b, T>(g: G, dest: &'b mut T) -> impl FnOnce() + '_ + 'a
- | +++ ++++ ++
+LL | fn bat<'b, 'a, G: 'a + 'b, T>(g: G, dest: &'b mut T) -> impl FnOnce() + 'b + 'a
+ | +++ ++++ ++ ~~
error[E0621]: explicit lifetime required in the type of `dest`
--> $DIR/missing-lifetimes-in-signature.rs:73:5
@@ -153,13 +111,16 @@ LL | | }
error[E0309]: the parameter type `G` may not live long enough
--> $DIR/missing-lifetimes-in-signature.rs:85:5
|
+LL | fn bak<'a, G, T>(g: G, dest: &'a mut T) -> impl FnOnce() + 'a
+ | -- the parameter type `G` must be valid for the lifetime `'a` as defined here...
+...
LL | / move || {
LL | |
LL | | *dest = g.get();
LL | | }
| |_____^ ...so that the type `G` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | G: Get<T> + 'a,
| ++++
diff --git a/tests/ui/suggestions/lifetimes/type-param-bound-scope.fixed b/tests/ui/suggestions/lifetimes/type-param-bound-scope.fixed
new file mode 100644
index 0000000000000..470cc67b9736b
--- /dev/null
+++ b/tests/ui/suggestions/lifetimes/type-param-bound-scope.fixed
@@ -0,0 +1,47 @@
+// Make sure we suggest the bound `T: 'a` in the correct scope:
+// trait, impl or associated fn.
+// run-rustfix
+
+struct Inv<'a>(Option<*mut &'a u8>);
+
+fn check_bound<'a, A: 'a>(_: A, _: Inv<'a>) {}
+
+trait Trait1<'a>: Sized where Self: 'a {
+ fn foo(self, lt: Inv<'a>) {
+ check_bound(self, lt)
+ //~^ ERROR parameter type `Self` may not live long enough
+ }
+}
+
+trait Trait2: Sized {
+ fn foo<'a>(self, lt: Inv<'a>) where Self: 'a {
+ check_bound(self, lt)
+ //~^ ERROR parameter type `Self` may not live long enough
+ }
+}
+
+trait Trait3<T> {
+ fn foo<'a>(arg: T, lt: Inv<'a>) where T: 'a {
+ check_bound(arg, lt)
+ //~^ ERROR parameter type `T` may not live long enough
+ }
+}
+
+trait Trait4<'a> {
+ fn foo<T: 'a>(arg: T, lt: Inv<'a>) {
+ check_bound(arg, lt)
+ //~^ ERROR parameter type `T` may not live long enough
+ }
+}
+
+trait Trait5<'a> {
+ fn foo(self, _: Inv<'a>);
+}
+impl<'a, T: 'a> Trait5<'a> for T {
+ fn foo(self, lt: Inv<'a>) {
+ check_bound(self, lt);
+ //~^ ERROR parameter type `T` may not live long enough
+ }
+}
+
+fn main() {}
diff --git a/tests/ui/suggestions/lifetimes/type-param-bound-scope.rs b/tests/ui/suggestions/lifetimes/type-param-bound-scope.rs
new file mode 100644
index 0000000000000..874788e13ef09
--- /dev/null
+++ b/tests/ui/suggestions/lifetimes/type-param-bound-scope.rs
@@ -0,0 +1,47 @@
+// Make sure we suggest the bound `T: 'a` in the correct scope:
+// trait, impl or associated fn.
+// run-rustfix
+
+struct Inv<'a>(Option<*mut &'a u8>);
+
+fn check_bound<'a, A: 'a>(_: A, _: Inv<'a>) {}
+
+trait Trait1<'a>: Sized {
+ fn foo(self, lt: Inv<'a>) {
+ check_bound(self, lt)
+ //~^ ERROR parameter type `Self` may not live long enough
+ }
+}
+
+trait Trait2: Sized {
+ fn foo<'a>(self, lt: Inv<'a>) {
+ check_bound(self, lt)
+ //~^ ERROR parameter type `Self` may not live long enough
+ }
+}
+
+trait Trait3<T> {
+ fn foo<'a>(arg: T, lt: Inv<'a>) {
+ check_bound(arg, lt)
+ //~^ ERROR parameter type `T` may not live long enough
+ }
+}
+
+trait Trait4<'a> {
+ fn foo<T>(arg: T, lt: Inv<'a>) {
+ check_bound(arg, lt)
+ //~^ ERROR parameter type `T` may not live long enough
+ }
+}
+
+trait Trait5<'a> {
+ fn foo(self, _: Inv<'a>);
+}
+impl<'a, T> Trait5<'a> for T {
+ fn foo(self, lt: Inv<'a>) {
+ check_bound(self, lt);
+ //~^ ERROR parameter type `T` may not live long enough
+ }
+}
+
+fn main() {}
diff --git a/tests/ui/suggestions/lifetimes/type-param-bound-scope.stderr b/tests/ui/suggestions/lifetimes/type-param-bound-scope.stderr
new file mode 100644
index 0000000000000..d3ca2cc116228
--- /dev/null
+++ b/tests/ui/suggestions/lifetimes/type-param-bound-scope.stderr
@@ -0,0 +1,71 @@
+error[E0309]: the parameter type `Self` may not live long enough
+ --> $DIR/type-param-bound-scope.rs:11:9
+ |
+LL | trait Trait1<'a>: Sized {
+ | -- the parameter type `Self` must be valid for the lifetime `'a` as defined here...
+LL | fn foo(self, lt: Inv<'a>) {
+LL | check_bound(self, lt)
+ | ^^^^^^^^^^^^^^^^^^^^^ ...so that the type `Self` will meet its required lifetime bounds
+ |
+help: consider adding an explicit lifetime bound
+ |
+LL | trait Trait1<'a>: Sized where Self: 'a {
+ | ++++++++++++++
+
+error[E0309]: the parameter type `Self` may not live long enough
+ --> $DIR/type-param-bound-scope.rs:18:9
+ |
+LL | fn foo<'a>(self, lt: Inv<'a>) {
+ | -- the parameter type `Self` must be valid for the lifetime `'a` as defined here...
+LL | check_bound(self, lt)
+ | ^^^^^^^^^^^^^^^^^^^^^ ...so that the type `Self` will meet its required lifetime bounds
+ |
+help: consider adding an explicit lifetime bound
+ |
+LL | fn foo<'a>(self, lt: Inv<'a>) where Self: 'a {
+ | ++++++++++++++
+
+error[E0309]: the parameter type `T` may not live long enough
+ --> $DIR/type-param-bound-scope.rs:25:9
+ |
+LL | fn foo<'a>(arg: T, lt: Inv<'a>) {
+ | -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
+LL | check_bound(arg, lt)
+ | ^^^^^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
+ |
+help: consider adding an explicit lifetime bound
+ |
+LL | fn foo<'a>(arg: T, lt: Inv<'a>) where T: 'a {
+ | +++++++++++
+
+error[E0309]: the parameter type `T` may not live long enough
+ --> $DIR/type-param-bound-scope.rs:32:9
+ |
+LL | trait Trait4<'a> {
+ | -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
+LL | fn foo<T>(arg: T, lt: Inv<'a>) {
+LL | check_bound(arg, lt)
+ | ^^^^^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
+ |
+help: consider adding an explicit lifetime bound
+ |
+LL | fn foo<T: 'a>(arg: T, lt: Inv<'a>) {
+ | ++++
+
+error[E0309]: the parameter type `T` may not live long enough
+ --> $DIR/type-param-bound-scope.rs:42:9
+ |
+LL | impl<'a, T> Trait5<'a> for T {
+ | -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
+LL | fn foo(self, lt: Inv<'a>) {
+LL | check_bound(self, lt);
+ | ^^^^^^^^^^^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
+ |
+help: consider adding an explicit lifetime bound
+ |
+LL | impl<'a, T: 'a> Trait5<'a> for T {
+ | ++++
+
+error: aborting due to 5 previous errors
+
+For more information about this error, try `rustc --explain E0309`.
diff --git a/tests/ui/suggestions/lifetimes/type-param-missing-lifetime.fixed b/tests/ui/suggestions/lifetimes/type-param-missing-lifetime.fixed
new file mode 100644
index 0000000000000..e30c556457e53
--- /dev/null
+++ b/tests/ui/suggestions/lifetimes/type-param-missing-lifetime.fixed
@@ -0,0 +1,52 @@
+// We want to suggest a bound `T: 'a` but `'a` is elided,
+// run-rustfix
+// edition: 2018
+#![allow(dead_code)]
+
+struct Inv<'a>(Option<*mut &'a u8>);
+
+fn check_bound<'a, A: 'a>(_: A, _: Inv<'a>) {}
+
+struct Elided<'a, T = ()>(Inv<'a>, T);
+
+struct MyTy<X>(X);
+
+impl<'a, X> MyTy<Elided<'a, X>> {
+ async fn foo<A: 'a>(self, arg: A, _: &str) -> &str {
+ check_bound(arg, self.0 .0);
+ //~^ ERROR parameter type `A` may not live long enough
+ ""
+ }
+}
+
+// Make sure the new lifetime name doesn't conflict with
+// other early- or late-bound lifetimes in-scope.
+impl<'a, A> MyTy<(A, &'a ())> {
+ async fn foo2<'b>(
+ arg: A,
+ lt: Inv<'b>,
+ ) -> (
+ impl Into<&'b str> + Into<&'b str> + 'b,
+ impl Into<Option<Elided<'b>>> + 'b,
+ impl Into<Option<Elided<'b, ()>>>,
+ ) where A: 'b {
+ check_bound(arg, lt);
+ //~^ ERROR parameter type `A` may not live long enough
+ ("", None, None)
+ }
+
+ // same as above but there is a late-bound lifetime named `'b`.
+ async fn bar2<'c, 'b>(_dummy: &'a u8, arg: A, lt: Inv<'c>) where A: 'c {
+ check_bound(arg, lt);
+ //~^ ERROR parameter type `A` may not live long enough
+ }
+}
+
+impl<'a, A: 'a> MyTy<Elided<'a, A>> {
+ async fn foo3(self) {
+ check_bound(self.0 .1, self.0 .0);
+ //~^ ERROR parameter type `A` may not live long enough
+ }
+}
+
+fn main() {}
diff --git a/tests/ui/suggestions/lifetimes/type-param-missing-lifetime.rs b/tests/ui/suggestions/lifetimes/type-param-missing-lifetime.rs
new file mode 100644
index 0000000000000..85f08808b731c
--- /dev/null
+++ b/tests/ui/suggestions/lifetimes/type-param-missing-lifetime.rs
@@ -0,0 +1,52 @@
+// We want to suggest a bound `T: 'a` but `'a` is elided,
+// run-rustfix
+// edition: 2018
+#![allow(dead_code)]
+
+struct Inv<'a>(Option<*mut &'a u8>);
+
+fn check_bound<'a, A: 'a>(_: A, _: Inv<'a>) {}
+
+struct Elided<'a, T = ()>(Inv<'a>, T);
+
+struct MyTy<X>(X);
+
+impl<X> MyTy<Elided<'_, X>> {
+ async fn foo<A>(self, arg: A, _: &str) -> &str {
+ check_bound(arg, self.0 .0);
+ //~^ ERROR parameter type `A` may not live long enough
+ ""
+ }
+}
+
+// Make sure the new lifetime name doesn't conflict with
+// other early- or late-bound lifetimes in-scope.
+impl<'a, A> MyTy<(A, &'a ())> {
+ async fn foo2(
+ arg: A,
+ lt: Inv<'_>,
+ ) -> (
+ impl Into<&str> + Into<&'_ str> + '_,
+ impl Into<Option<Elided>> + '_,
+ impl Into<Option<Elided<()>>>,
+ ) {
+ check_bound(arg, lt);
+ //~^ ERROR parameter type `A` may not live long enough
+ ("", None, None)
+ }
+
+ // same as above but there is a late-bound lifetime named `'b`.
+ async fn bar2<'b>(_dummy: &'a u8, arg: A, lt: Inv<'_>) {
+ check_bound(arg, lt);
+ //~^ ERROR parameter type `A` may not live long enough
+ }
+}
+
+impl<A> MyTy<Elided<'_, A>> {
+ async fn foo3(self) {
+ check_bound(self.0 .1, self.0 .0);
+ //~^ ERROR parameter type `A` may not live long enough
+ }
+}
+
+fn main() {}
diff --git a/tests/ui/suggestions/lifetimes/type-param-missing-lifetime.stderr b/tests/ui/suggestions/lifetimes/type-param-missing-lifetime.stderr
new file mode 100644
index 0000000000000..2f74a006b3b74
--- /dev/null
+++ b/tests/ui/suggestions/lifetimes/type-param-missing-lifetime.stderr
@@ -0,0 +1,66 @@
+error[E0311]: the parameter type `A` may not live long enough
+ --> $DIR/type-param-missing-lifetime.rs:16:9
+ |
+LL | impl<X> MyTy<Elided<'_, X>> {
+ | -- the parameter type `A` must be valid for the anonymous lifetime as defined here...
+LL | async fn foo<A>(self, arg: A, _: &str) -> &str {
+LL | check_bound(arg, self.0 .0);
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ...so that the type `A` will meet its required lifetime bounds
+ |
+help: consider adding an explicit lifetime bound
+ |
+LL ~ impl<'a, X> MyTy<Elided<'a, X>> {
+LL ~ async fn foo<A: 'a>(self, arg: A, _: &str) -> &str {
+ |
+
+error[E0311]: the parameter type `A` may not live long enough
+ --> $DIR/type-param-missing-lifetime.rs:33:9
+ |
+LL | lt: Inv<'_>,
+ | ------- the parameter type `A` must be valid for the anonymous lifetime defined here...
+...
+LL | check_bound(arg, lt);
+ | ^^^^^^^^^^^^^^^^^^^^ ...so that the type `A` will meet its required lifetime bounds
+ |
+help: consider adding an explicit lifetime bound
+ |
+LL ~ async fn foo2<'b>(
+LL | arg: A,
+LL ~ lt: Inv<'b>,
+LL | ) -> (
+LL ~ impl Into<&'b str> + Into<&'b str> + 'b,
+LL ~ impl Into<Option<Elided<'b>>> + 'b,
+LL ~ impl Into<Option<Elided<'b, ()>>>,
+LL ~ ) where A: 'b {
+ |
+
+error[E0311]: the parameter type `A` may not live long enough
+ --> $DIR/type-param-missing-lifetime.rs:40:9
+ |
+LL | async fn bar2<'b>(_dummy: &'a u8, arg: A, lt: Inv<'_>) {
+ | ------- the parameter type `A` must be valid for the anonymous lifetime defined here...
+LL | check_bound(arg, lt);
+ | ^^^^^^^^^^^^^^^^^^^^ ...so that the type `A` will meet its required lifetime bounds
+ |
+help: consider adding an explicit lifetime bound
+ |
+LL | async fn bar2<'c, 'b>(_dummy: &'a u8, arg: A, lt: Inv<'c>) where A: 'c {
+ | +++ ~~ +++++++++++
+
+error[E0311]: the parameter type `A` may not live long enough
+ --> $DIR/type-param-missing-lifetime.rs:47:9
+ |
+LL | impl<A> MyTy<Elided<'_, A>> {
+ | -- the parameter type `A` must be valid for the anonymous lifetime as defined here...
+LL | async fn foo3(self) {
+LL | check_bound(self.0 .1, self.0 .0);
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ...so that the type `A` will meet its required lifetime bounds
+ |
+help: consider adding an explicit lifetime bound
+ |
+LL | impl<'a, A: 'a> MyTy<Elided<'a, A>> {
+ | +++ ++++ ~~
+
+error: aborting due to 4 previous errors
+
+For more information about this error, try `rustc --explain E0311`.
diff --git a/tests/ui/suggestions/suggest-impl-trait-lifetime.fixed b/tests/ui/suggestions/suggest-impl-trait-lifetime.fixed
index 589ee1a474ad6..4f2fd5ba6001b 100644
--- a/tests/ui/suggestions/suggest-impl-trait-lifetime.fixed
+++ b/tests/ui/suggestions/suggest-impl-trait-lifetime.fixed
@@ -3,9 +3,10 @@
use std::fmt::Debug;
fn foo(d: impl Debug + 'static) {
-//~^ HELP consider adding an explicit lifetime bound...
+//~^ HELP consider adding an explicit lifetime bound
bar(d);
//~^ ERROR the parameter type `impl Debug` may not live long enough
+//~| NOTE the parameter type `impl Debug` must be valid for the static lifetime...
//~| NOTE ...so that the type `impl Debug` will meet its required lifetime bounds
}
diff --git a/tests/ui/suggestions/suggest-impl-trait-lifetime.rs b/tests/ui/suggestions/suggest-impl-trait-lifetime.rs
index 9a87129fbf28a..a266e360edbad 100644
--- a/tests/ui/suggestions/suggest-impl-trait-lifetime.rs
+++ b/tests/ui/suggestions/suggest-impl-trait-lifetime.rs
@@ -3,9 +3,10 @@
use std::fmt::Debug;
fn foo(d: impl Debug) {
-//~^ HELP consider adding an explicit lifetime bound...
+//~^ HELP consider adding an explicit lifetime bound
bar(d);
//~^ ERROR the parameter type `impl Debug` may not live long enough
+//~| NOTE the parameter type `impl Debug` must be valid for the static lifetime...
//~| NOTE ...so that the type `impl Debug` will meet its required lifetime bounds
}
diff --git a/tests/ui/suggestions/suggest-impl-trait-lifetime.stderr b/tests/ui/suggestions/suggest-impl-trait-lifetime.stderr
index cf912f4aac201..1660db1aa83c7 100644
--- a/tests/ui/suggestions/suggest-impl-trait-lifetime.stderr
+++ b/tests/ui/suggestions/suggest-impl-trait-lifetime.stderr
@@ -2,9 +2,12 @@ error[E0310]: the parameter type `impl Debug` may not live long enough
--> $DIR/suggest-impl-trait-lifetime.rs:7:5
|
LL | bar(d);
- | ^^^^^^ ...so that the type `impl Debug` will meet its required lifetime bounds
+ | ^^^^^^
+ | |
+ | the parameter type `impl Debug` must be valid for the static lifetime...
+ | ...so that the type `impl Debug` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | fn foo(d: impl Debug + 'static) {
| +++++++++
diff --git a/tests/ui/type-alias-impl-trait/closure_wf_outlives.stderr b/tests/ui/type-alias-impl-trait/closure_wf_outlives.stderr
index ae6462bb62ce5..3484485e3fd7f 100644
--- a/tests/ui/type-alias-impl-trait/closure_wf_outlives.stderr
+++ b/tests/ui/type-alias-impl-trait/closure_wf_outlives.stderr
@@ -46,14 +46,17 @@ error[E0310]: the parameter type `T` may not live long enough
--> $DIR/closure_wf_outlives.rs:54:22
|
LL | type Opaque<T> = impl Sized;
- | ^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds...
+ | ^^^^^^^^^^
+ | |
+ | the parameter type `T` must be valid for the static lifetime...
+ | ...so that the type `T` will meet its required lifetime bounds...
|
note: ...that is required by this bound
--> $DIR/closure_wf_outlives.rs:59:12
|
LL | T: 'static,
| ^^^^^^^
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | type Opaque<T: 'static> = impl Sized;
| +++++++++
diff --git a/tests/ui/type-alias-impl-trait/generic_type_does_not_live_long_enough.stderr b/tests/ui/type-alias-impl-trait/generic_type_does_not_live_long_enough.stderr
index 8c3a25dbfe7de..c352a33fbbcf0 100644
--- a/tests/ui/type-alias-impl-trait/generic_type_does_not_live_long_enough.stderr
+++ b/tests/ui/type-alias-impl-trait/generic_type_does_not_live_long_enough.stderr
@@ -17,9 +17,12 @@ error[E0310]: the parameter type `T` may not live long enough
--> $DIR/generic_type_does_not_live_long_enough.rs:13:9
|
LL | t
- | ^ ...so that the type `T` will meet its required lifetime bounds
+ | ^
+ | |
+ | the parameter type `T` must be valid for the static lifetime...
+ | ...so that the type `T` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | fn wrong_generic<T: 'static>(t: T) -> WrongGeneric<T> {
| +++++++++
diff --git a/tests/ui/type-alias-impl-trait/implied_lifetime_wf_check3.stderr b/tests/ui/type-alias-impl-trait/implied_lifetime_wf_check3.stderr
index 399775641f8a3..d6dd20739b7af 100644
--- a/tests/ui/type-alias-impl-trait/implied_lifetime_wf_check3.stderr
+++ b/tests/ui/type-alias-impl-trait/implied_lifetime_wf_check3.stderr
@@ -22,9 +22,12 @@ error[E0310]: the parameter type `A` may not live long enough
--> $DIR/implied_lifetime_wf_check3.rs:29:41
|
LL | fn test<A>() where Ty<A>: 'static { assert_static::<A>() }
- | ^^^^^^^^^^^^^^^^^^ ...so that the type `A` will meet its required lifetime bounds
+ | ^^^^^^^^^^^^^^^^^^
+ | |
+ | the parameter type `A` must be valid for the static lifetime...
+ | ...so that the type `A` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | fn test<A: 'static>() where Ty<A>: 'static { assert_static::<A>() }
| +++++++++
diff --git a/tests/ui/type-alias-impl-trait/implied_lifetime_wf_check4_static.stderr b/tests/ui/type-alias-impl-trait/implied_lifetime_wf_check4_static.stderr
index 47bc31e78c34f..81bc64bc32c63 100644
--- a/tests/ui/type-alias-impl-trait/implied_lifetime_wf_check4_static.stderr
+++ b/tests/ui/type-alias-impl-trait/implied_lifetime_wf_check4_static.stderr
@@ -2,9 +2,12 @@ error[E0310]: the parameter type `A` may not live long enough
--> $DIR/implied_lifetime_wf_check4_static.rs:4:18
|
LL | type Ty<A> = impl Sized + 'static;
- | ^^^^^^^^^^^^^^^^^^^^ ...so that the type `A` will meet its required lifetime bounds
+ | ^^^^^^^^^^^^^^^^^^^^
+ | |
+ | the parameter type `A` must be valid for the static lifetime...
+ | ...so that the type `A` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | type Ty<A: 'static> = impl Sized + 'static;
| +++++++++
diff --git a/tests/ui/type-alias-impl-trait/wf-in-associated-type.fail.stderr b/tests/ui/type-alias-impl-trait/wf-in-associated-type.fail.stderr
index 9e96323ab54bb..7d72c9f811af4 100644
--- a/tests/ui/type-alias-impl-trait/wf-in-associated-type.fail.stderr
+++ b/tests/ui/type-alias-impl-trait/wf-in-associated-type.fail.stderr
@@ -1,10 +1,12 @@
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/wf-in-associated-type.rs:36:23
|
+LL | impl<'a, T> Trait<'a, T> for () {
+ | -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
LL | type Opaque = impl Sized + 'a;
| ^^^^^^^^^^^^^^^ ...so that the type `&'a T` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | impl<'a, T: 'a> Trait<'a, T> for () {
| ++++
@@ -12,10 +14,12 @@ LL | impl<'a, T: 'a> Trait<'a, T> for () {
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/wf-in-associated-type.rs:36:23
|
+LL | impl<'a, T> Trait<'a, T> for () {
+ | -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
LL | type Opaque = impl Sized + 'a;
| ^^^^^^^^^^^^^^^ ...so that the reference type `&'a T` does not outlive the data it points at
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | impl<'a, T: 'a> Trait<'a, T> for () {
| ++++
diff --git a/tests/ui/type-alias-impl-trait/wf-nested.fail.stderr b/tests/ui/type-alias-impl-trait/wf-nested.fail.stderr
index 753a46e882eda..2858afcd46f04 100644
--- a/tests/ui/type-alias-impl-trait/wf-nested.fail.stderr
+++ b/tests/ui/type-alias-impl-trait/wf-nested.fail.stderr
@@ -2,14 +2,17 @@ error[E0310]: the parameter type `T` may not live long enough
--> $DIR/wf-nested.rs:55:27
|
LL | type InnerOpaque<T> = impl Sized;
- | ^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds...
+ | ^^^^^^^^^^
+ | |
+ | the parameter type `T` must be valid for the static lifetime...
+ | ...so that the type `T` will meet its required lifetime bounds...
|
note: ...that is required by this bound
--> $DIR/wf-nested.rs:12:20
|
LL | struct IsStatic<T: 'static>(T);
| ^^^^^^^
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | type InnerOpaque<T: 'static> = impl Sized;
| +++++++++
diff --git a/tests/ui/type-alias-impl-trait/wf-nested.pass_sound.stderr b/tests/ui/type-alias-impl-trait/wf-nested.pass_sound.stderr
index 9ab6685a7f73f..285e4f18ca30c 100644
--- a/tests/ui/type-alias-impl-trait/wf-nested.pass_sound.stderr
+++ b/tests/ui/type-alias-impl-trait/wf-nested.pass_sound.stderr
@@ -2,9 +2,12 @@ error[E0310]: the parameter type `T` may not live long enough
--> $DIR/wf-nested.rs:46:17
|
LL | let _ = outer.get();
- | ^^^^^^^^^^^ ...so that the type `T` will meet its required lifetime bounds
+ | ^^^^^^^^^^^
+ | |
+ | the parameter type `T` must be valid for the static lifetime...
+ | ...so that the type `T` will meet its required lifetime bounds
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | fn test<T: 'static>() {
| +++++++++
diff --git a/tests/ui/wf/wf-impl-associated-type-region.stderr b/tests/ui/wf/wf-impl-associated-type-region.stderr
index b9d4857a3efde..e6fb81247ad66 100644
--- a/tests/ui/wf/wf-impl-associated-type-region.stderr
+++ b/tests/ui/wf/wf-impl-associated-type-region.stderr
@@ -1,10 +1,12 @@
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/wf-impl-associated-type-region.rs:10:16
|
+LL | impl<'a, T> Foo<'a> for T {
+ | -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
LL | type Bar = &'a T;
| ^^^^^ ...so that the reference type `&'a T` does not outlive the data it points at
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | impl<'a, T: 'a> Foo<'a> for T {
| ++++
diff --git a/tests/ui/wf/wf-in-fn-type-static.stderr b/tests/ui/wf/wf-in-fn-type-static.stderr
index 73fbb9ca670b0..45ad9fba0ce73 100644
--- a/tests/ui/wf/wf-in-fn-type-static.stderr
+++ b/tests/ui/wf/wf-in-fn-type-static.stderr
@@ -2,9 +2,12 @@ error[E0310]: the parameter type `T` may not live long enough
--> $DIR/wf-in-fn-type-static.rs:13:8
|
LL | x: fn() -> &'static T
- | ^^^^^^^^^^^^^^^^^^ ...so that the reference type `&'static T` does not outlive the data it points at
+ | ^^^^^^^^^^^^^^^^^^
+ | |
+ | the parameter type `T` must be valid for the static lifetime...
+ | ...so that the reference type `&'static T` does not outlive the data it points at
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | struct Foo<T: 'static> {
| +++++++++
@@ -13,9 +16,12 @@ error[E0310]: the parameter type `T` may not live long enough
--> $DIR/wf-in-fn-type-static.rs:18:8
|
LL | x: fn(&'static T)
- | ^^^^^^^^^^^^^^ ...so that the reference type `&'static T` does not outlive the data it points at
+ | ^^^^^^^^^^^^^^
+ | |
+ | the parameter type `T` must be valid for the static lifetime...
+ | ...so that the reference type `&'static T` does not outlive the data it points at
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | struct Bar<T: 'static> {
| +++++++++
diff --git a/tests/ui/wf/wf-in-obj-type-static.stderr b/tests/ui/wf/wf-in-obj-type-static.stderr
index c3ad42dd5d5ac..4b9b189164c6d 100644
--- a/tests/ui/wf/wf-in-obj-type-static.stderr
+++ b/tests/ui/wf/wf-in-obj-type-static.stderr
@@ -2,9 +2,12 @@ error[E0310]: the parameter type `T` may not live long enough
--> $DIR/wf-in-obj-type-static.rs:14:8
|
LL | x: dyn Object<&'static T>
- | ^^^^^^^^^^^^^^^^^^^^^^ ...so that the reference type `&'static T` does not outlive the data it points at
+ | ^^^^^^^^^^^^^^^^^^^^^^
+ | |
+ | the parameter type `T` must be valid for the static lifetime...
+ | ...so that the reference type `&'static T` does not outlive the data it points at
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | struct Foo<T: 'static> {
| +++++++++
diff --git a/tests/ui/wf/wf-outlives-ty-in-fn-or-trait.stderr b/tests/ui/wf/wf-outlives-ty-in-fn-or-trait.stderr
index 4d4d8b2ab4d46..e0cf42fd10c89 100644
--- a/tests/ui/wf/wf-outlives-ty-in-fn-or-trait.stderr
+++ b/tests/ui/wf/wf-outlives-ty-in-fn-or-trait.stderr
@@ -1,10 +1,12 @@
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/wf-outlives-ty-in-fn-or-trait.rs:9:16
|
+LL | impl<'a, T> Trait<'a, T> for usize {
+ | -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
LL | type Out = &'a fn(T);
| ^^^^^^^^^ ...so that the reference type `&'a fn(T)` does not outlive the data it points at
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | impl<'a, T: 'a> Trait<'a, T> for usize {
| ++++
@@ -12,10 +14,12 @@ LL | impl<'a, T: 'a> Trait<'a, T> for usize {
error[E0309]: the parameter type `T` may not live long enough
--> $DIR/wf-outlives-ty-in-fn-or-trait.rs:19:16
|
+LL | impl<'a, T> Trait<'a, T> for u32 {
+ | -- the parameter type `T` must be valid for the lifetime `'a` as defined here...
LL | type Out = &'a dyn Baz<T>;
| ^^^^^^^^^^^^^^ ...so that the reference type `&'a (dyn Baz<T> + 'a)` does not outlive the data it points at
|
-help: consider adding an explicit lifetime bound...
+help: consider adding an explicit lifetime bound
|
LL | impl<'a, T: 'a> Trait<'a, T> for u32 {
| ++++
diff --git a/tests/ui/wf/wf-trait-associated-type-region.stderr b/tests/ui/wf/wf-trait-associated-type-region.stderr
index 6e2cc8aba4b72..ca7aeb55b250c 100644
--- a/tests/ui/wf/wf-trait-associated-type-region.stderr
+++ b/tests/ui/wf/wf-trait-associated-type-region.stderr
@@ -1,11 +1,16 @@
error[E0309]: the associated type `<Self as SomeTrait<'a>>::Type1` may not live long enough
--> $DIR/wf-trait-associated-type-region.rs:9:18
|
+LL | trait SomeTrait<'a> {
+ | -- the associated type `<Self as SomeTrait<'a>>::Type1` must be valid for the lifetime `'a` as defined here...
+LL | type Type1;
LL | type Type2 = &'a Self::Type1;
- | ^^^^^^^^^^^^^^^
+ | ^^^^^^^^^^^^^^^ ...so that the reference type `&'a <Self as SomeTrait<'a>>::Type1` does not outlive the data it points at
|
- = help: consider adding an explicit lifetime bound `<Self as SomeTrait<'a>>::Type1: 'a`...
- = note: ...so that the reference type `&'a <Self as SomeTrait<'a>>::Type1` does not outlive the data it points at
+help: consider adding an explicit lifetime bound
+ |
+LL | type Type2 = &'a Self::Type1 where <Self as SomeTrait<'a>>::Type1: 'a;
+ | ++++++++++++++++++++++++++++++++++++++++
error: aborting due to previous error