Tweak wording in associated type with anon lifetime error

estebank · estebank · commit e4c1caaef965 · 2025-08-12T17:27:21.000Z
Move the previous long message to a note and use a shorter primary message:

```
error: missing lifetime in associated type
  --&gt; $DIR/missing-lifetime-in-assoc-type-1.rs:9:17
   |
LL | impl&lt;'a&gt; IntoIterator for &amp;S {
   |     ---- there is a named lifetime specified on the impl block you could use
...
LL |     type Item = &amp;T;
   |                 ^ this lifetime must come from the implemented type
   |
note: in the trait the associated type is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type
  --&gt; $SRC_DIR/core/src/iter/traits/collect.rs:LL:COL
help: consider using the lifetime from the impl block
   |
LL |     type Item = &amp;'a T;
   |                  ++
```
diff --git a/compiler/rustc_resolve/messages.ftl b/compiler/rustc_resolve/messages.ftl
@@ -11,9 +11,9 @@ resolve_added_macro_use =
 resolve_ancestor_only =
     visibilities can only be restricted to ancestor modules
 
-resolve_anonymous_lifetime_non_gat_report_error =
-    in the trait associated type is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type
+resolve_anonymous_lifetime_non_gat_report_error = missing lifetime in associated type
     .label = this lifetime must come from the implemented type
+    .note = in the trait the associated type is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type
 
 resolve_arguments_macro_use_not_allowed = arguments to `macro_use` are not allowed here
 
diff --git a/compiler/rustc_resolve/src/errors.rs b/compiler/rustc_resolve/src/errors.rs
@@ -897,6 +897,8 @@ pub(crate) struct AnonymousLifetimeNonGatReportError {
     #[primary_span]
     #[label]
     pub(crate) lifetime: Span,
+    #[note]
+    pub(crate) decl: MultiSpan,
 }
 
 #[derive(Subdiagnostic)]
diff --git a/compiler/rustc_resolve/src/late.rs b/compiler/rustc_resolve/src/late.rs
@@ -21,21 +21,21 @@ use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap};
 use rustc_data_structures::unord::{UnordMap, UnordSet};
 use rustc_errors::codes::*;
 use rustc_errors::{
-    Applicability, Diag, DiagArgValue, ErrorGuaranteed, IntoDiagArg, StashKey, Suggestions,
-    pluralize,
+    Applicability, Diag, DiagArgValue, ErrorGuaranteed, IntoDiagArg, MultiSpan, StashKey,
+    Suggestions, pluralize,
 };
 use rustc_hir::def::Namespace::{self, *};
 use rustc_hir::def::{self, CtorKind, DefKind, LifetimeRes, NonMacroAttrKind, PartialRes, PerNS};
 use rustc_hir::def_id::{CRATE_DEF_ID, DefId, LOCAL_CRATE, LocalDefId};
 use rustc_hir::{MissingLifetimeKind, PrimTy, TraitCandidate};
 use rustc_middle::middle::resolve_bound_vars::Set1;
-use rustc_middle::ty::{DelegationFnSig, Visibility};
+use rustc_middle::ty::{AssocTag, DelegationFnSig, Visibility};
 use rustc_middle::{bug, span_bug};
 use rustc_session::config::{CrateType, ResolveDocLinks};
 use rustc_session::lint::{self, BuiltinLintDiag};
 use rustc_session::parse::feature_err;
 use rustc_span::source_map::{Spanned, respan};
-use rustc_span::{BytePos, Ident, Span, Symbol, SyntaxContext, kw, sym};
+use rustc_span::{BytePos, DUMMY_SP, Ident, Span, Symbol, SyntaxContext, kw, sym};
 use smallvec::{SmallVec, smallvec};
 use thin_vec::ThinVec;
 use tracing::{debug, instrument, trace};
@@ -725,6 +725,9 @@ struct DiagMetadata<'ast> {
     /// The current impl items (used to suggest).
     current_impl_items: Option<&'ast [Box<AssocItem>]>,
 
+    /// The current impl items (used to suggest).
+    current_impl_item: Option<&'ast AssocItem>,
+
     /// When processing impl trait
     currently_processing_impl_trait: Option<(TraitRef, Ty)>,
 
@@ -1891,9 +1894,31 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                                     ty: ty.span,
                                 });
                             } else {
+                                let decl = if !trait_id.is_local()
+                                    && let Some(assoc) = self.diag_metadata.current_impl_item
+                                    && let AssocItemKind::Type(_) = assoc.kind
+                                    && let assocs = self.r.tcx.associated_items(trait_id)
+                                    && let Some(ident) = assoc.kind.ident()
+                                    && let Some(assoc) = assocs.find_by_ident_and_kind(
+                                        self.r.tcx,
+                                        ident,
+                                        AssocTag::Type,
+                                        trait_id,
+                                    ) {
+                                    let mut decl: MultiSpan =
+                                        self.r.tcx.def_span(assoc.def_id).into();
+                                    decl.push_span_label(
+                                        self.r.tcx.def_span(trait_id),
+                                        String::new(),
+                                    );
+                                    decl
+                                } else {
+                                    DUMMY_SP.into()
+                                };
                                 let mut err = self.r.dcx().create_err(
                                     errors::AnonymousLifetimeNonGatReportError {
                                         lifetime: lifetime.ident.span,
+                                        decl,
                                     },
                                 );
                                 self.point_at_impl_lifetimes(&mut err, i, lifetime.ident.span);
@@ -2006,7 +2031,7 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
             } else if let Some(item) = &self.diag_metadata.current_item
                 && let ItemKind::Impl(impl_) = &item.kind
                 && let Some(of_trait) = &impl_.of_trait
-                && let ControlFlow::Break(sp) = AnonRefFinder.visit_trait_ref(of_trait)
+                && let ControlFlow::Break(sp) = AnonRefFinder.visit_trait_ref(&of_trait.trait_ref)
             {
                 err.multipart_suggestion_verbose(
                     "add a lifetime to the impl block and use it in the trait and associated type",
@@ -3362,6 +3387,8 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
     ) {
         use crate::ResolutionError::*;
         self.resolve_doc_links(&item.attrs, MaybeExported::ImplItem(trait_id.ok_or(&item.vis)));
+        let prev = self.diag_metadata.current_impl_item.take();
+        self.diag_metadata.current_impl_item = Some(&item);
         match &item.kind {
             AssocItemKind::Const(box ast::ConstItem {
                 ident,
@@ -3510,6 +3537,7 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                 panic!("unexpanded macro in resolve!")
             }
         }
+        self.diag_metadata.current_impl_item = prev;
     }
 
     fn check_trait_item<F>(
diff --git a/tests/ui/impl-header-lifetime-elision/assoc-type.rs b/tests/ui/impl-header-lifetime-elision/assoc-type.rs
@@ -9,7 +9,7 @@ trait MyTrait {
 
 impl MyTrait for &i32 {
     type Output = &i32;
-    //~^ ERROR in the trait associated type is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type
+    //~^ ERROR missing lifetime in associated type
 }
 
 impl MyTrait for &u32 {
@@ -19,15 +19,15 @@ impl MyTrait for &u32 {
 
 impl<'a> MyTrait for &f64 {
     type Output = &f64;
-    //~^ ERROR in the trait associated type is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type
+    //~^ ERROR missing lifetime in associated type
 }
 
 trait OtherTrait<'a> {
     type Output;
 }
 impl OtherTrait<'_> for f64 {
     type Output = &f64;
-    //~^ ERROR in the trait associated type is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type
+    //~^ ERROR missing lifetime in associated type
 }
 
 // This is what you have to do:
diff --git a/tests/ui/impl-header-lifetime-elision/assoc-type.stderr b/tests/ui/impl-header-lifetime-elision/assoc-type.stderr
@@ -1,9 +1,10 @@
-error: in the trait associated type is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type
+error: missing lifetime in associated type
   --> $DIR/assoc-type.rs:11:19
    |
 LL |     type Output = &i32;
    |                   ^ this lifetime must come from the implemented type
    |
+   = note: in the trait the associated type is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type
 help: add a lifetime to the impl block and use it in the self type and associated type
    |
 LL ~ impl<'a> MyTrait for &'a i32 {
@@ -16,25 +17,27 @@ error[E0637]: `'_` cannot be used here
 LL |     type Output = &'_ i32;
    |                    ^^ `'_` is a reserved lifetime name
 
-error: in the trait associated type is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type
+error: missing lifetime in associated type
   --> $DIR/assoc-type.rs:21:19
    |
 LL | impl<'a> MyTrait for &f64 {
    |     ---- there is a named lifetime specified on the impl block you could use
 LL |     type Output = &f64;
    |                   ^ this lifetime must come from the implemented type
    |
+   = note: in the trait the associated type is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type
 help: consider using the lifetime from the impl block
    |
 LL |     type Output = &'a f64;
    |                    ++
 
-error: in the trait associated type is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type
+error: missing lifetime in associated type
   --> $DIR/assoc-type.rs:29:19
    |
 LL |     type Output = &f64;
    |                   ^ this lifetime must come from the implemented type
    |
+   = note: in the trait the associated type is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type
 help: add a lifetime to the impl block and use it in the trait and associated type
    |
 LL ~ impl<'a> OtherTrait<'a> for f64 {
diff --git a/tests/ui/lifetimes/missing-lifetime-in-assoc-type-1.rs b/tests/ui/lifetimes/missing-lifetime-in-assoc-type-1.rs
@@ -7,9 +7,10 @@ impl<'a> IntoIterator for &S {
     //~| NOTE unconstrained lifetime parameter
     //~| HELP consider using the named lifetime here instead of an implict lifetime
     type Item = &T;
-    //~^ ERROR in the trait associated type
+    //~^ ERROR missing lifetime in associated type
     //~| HELP consider using the lifetime from the impl block
     //~| NOTE this lifetime must come from the implemented type
+    //~| NOTE in the trait the associated type is declared without lifetime parameters
     type IntoIter = std::collections::btree_map::Values<'a, i32, T>;
 
     fn into_iter(self) -> Self::IntoIter {
diff --git a/tests/ui/lifetimes/missing-lifetime-in-assoc-type-1.stderr b/tests/ui/lifetimes/missing-lifetime-in-assoc-type-1.stderr
@@ -1,4 +1,4 @@
-error: in the trait associated type is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type
+error: missing lifetime in associated type
   --> $DIR/missing-lifetime-in-assoc-type-1.rs:9:17
    |
 LL | impl<'a> IntoIterator for &S {
@@ -7,6 +7,8 @@ LL | impl<'a> IntoIterator for &S {
 LL |     type Item = &T;
    |                 ^ this lifetime must come from the implemented type
    |
+note: in the trait the associated type is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type
+  --> $SRC_DIR/core/src/iter/traits/collect.rs:LL:COL
 help: consider using the lifetime from the impl block
    |
 LL |     type Item = &'a T;
diff --git a/tests/ui/lifetimes/missing-lifetime-in-assoc-type-2.rs b/tests/ui/lifetimes/missing-lifetime-in-assoc-type-2.rs
@@ -3,7 +3,7 @@ struct T;
 
 impl IntoIterator for &S {
     type Item = &T;
-    //~^ ERROR in the trait associated type
+    //~^ ERROR missing lifetime in associated type
     type IntoIter = std::collections::btree_map::Values<'a, i32, T>;
     //~^ ERROR use of undeclared lifetime name `'a`
 
diff --git a/tests/ui/lifetimes/missing-lifetime-in-assoc-type-2.stderr b/tests/ui/lifetimes/missing-lifetime-in-assoc-type-2.stderr
@@ -1,9 +1,11 @@
-error: in the trait associated type is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type
+error: missing lifetime in associated type
   --> $DIR/missing-lifetime-in-assoc-type-2.rs:5:17
    |
 LL |     type Item = &T;
    |                 ^ this lifetime must come from the implemented type
    |
+note: in the trait the associated type is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type
+  --> $SRC_DIR/core/src/iter/traits/collect.rs:LL:COL
 help: add a lifetime to the impl block and use it in the self type and associated type
    |
 LL ~ impl<'a> IntoIterator for &'a S {
diff --git a/tests/ui/lifetimes/missing-lifetime-in-assoc-type-3.rs b/tests/ui/lifetimes/missing-lifetime-in-assoc-type-3.rs
@@ -3,7 +3,7 @@ struct T;
 
 impl IntoIterator for &S {
     type Item = &T;
-    //~^ ERROR in the trait associated type
+    //~^ ERROR missing lifetime in associated type
     type IntoIter = std::collections::btree_map::Values<i32, T>;
     //~^ ERROR missing lifetime specifier
 
diff --git a/tests/ui/lifetimes/missing-lifetime-in-assoc-type-3.stderr b/tests/ui/lifetimes/missing-lifetime-in-assoc-type-3.stderr
@@ -1,9 +1,11 @@
-error: in the trait associated type is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type
+error: missing lifetime in associated type
   --> $DIR/missing-lifetime-in-assoc-type-3.rs:5:17
    |
 LL |     type Item = &T;
    |                 ^ this lifetime must come from the implemented type
    |
+note: in the trait the associated type is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type
+  --> $SRC_DIR/core/src/iter/traits/collect.rs:LL:COL
 help: add a lifetime to the impl block and use it in the self type and associated type
    |
 LL ~ impl<'a> IntoIterator for &'a S {
diff --git a/tests/ui/lifetimes/missing-lifetime-in-assoc-type-4.rs b/tests/ui/lifetimes/missing-lifetime-in-assoc-type-4.rs
@@ -3,7 +3,7 @@ struct T;
 
 impl IntoIterator for &S {
     type Item = &T;
-    //~^ ERROR in the trait associated type
+    //~^ ERROR missing lifetime in associated type
     type IntoIter<'a> = std::collections::btree_map::Values<'a, i32, T>;
     //~^ ERROR lifetime parameters or bounds on associated type `IntoIter` do not match the trait declaration
 
diff --git a/tests/ui/lifetimes/missing-lifetime-in-assoc-type-4.stderr b/tests/ui/lifetimes/missing-lifetime-in-assoc-type-4.stderr
@@ -1,9 +1,11 @@
-error: in the trait associated type is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type
+error: missing lifetime in associated type
   --> $DIR/missing-lifetime-in-assoc-type-4.rs:5:17
    |
 LL |     type Item = &T;
    |                 ^ this lifetime must come from the implemented type
    |
+note: in the trait the associated type is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type
+  --> $SRC_DIR/core/src/iter/traits/collect.rs:LL:COL
 help: add a lifetime to the impl block and use it in the self type and associated type
    |
 LL ~ impl<'a> IntoIterator for &'a S {
diff --git a/tests/ui/lifetimes/missing-lifetime-in-assoc-type-5.rs b/tests/ui/lifetimes/missing-lifetime-in-assoc-type-5.rs
@@ -7,9 +7,10 @@ impl<'a> IntoIterator for &'_ S {
     //~| NOTE unconstrained lifetime parameter
     //~| HELP consider using the named lifetime here instead of an implict lifetime
     type Item = &T;
-    //~^ ERROR in the trait associated type
+    //~^ ERROR missing lifetime in associated type
     //~| HELP consider using the lifetime from the impl block
     //~| NOTE this lifetime must come from the implemented type
+    //~| NOTE in the trait the associated type is declared without lifetime parameters
     type IntoIter = std::collections::btree_map::Values<'a, i32, T>;
 
     fn into_iter(self) -> Self::IntoIter {
diff --git a/tests/ui/lifetimes/missing-lifetime-in-assoc-type-5.stderr b/tests/ui/lifetimes/missing-lifetime-in-assoc-type-5.stderr
@@ -1,4 +1,4 @@
-error: in the trait associated type is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type
+error: missing lifetime in associated type
   --> $DIR/missing-lifetime-in-assoc-type-5.rs:9:17
    |
 LL | impl<'a> IntoIterator for &'_ S {
@@ -7,6 +7,8 @@ LL | impl<'a> IntoIterator for &'_ S {
 LL |     type Item = &T;
    |                 ^ this lifetime must come from the implemented type
    |
+note: in the trait the associated type is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type
+  --> $SRC_DIR/core/src/iter/traits/collect.rs:LL:COL
 help: consider using the lifetime from the impl block
    |
 LL |     type Item = &'a T;
diff --git a/tests/ui/lifetimes/missing-lifetime-in-assoc-type-6.rs b/tests/ui/lifetimes/missing-lifetime-in-assoc-type-6.rs
@@ -0,0 +1,26 @@
+//~ NOTE in the trait the associated type is declared without lifetime parameters
+struct S;
+struct T;
+
+trait Trait {
+    type Item;
+    type IntoIter;
+    fn into_iter(self) -> Self::IntoIter;
+}
+
+impl<'a> Trait for &'_ S {
+    //~^ ERROR E0207
+    //~| NOTE there is a named lifetime specified on the impl block you could use
+    //~| NOTE unconstrained lifetime parameter
+    //~| HELP consider using the named lifetime here instead of an implict lifetime
+    type Item = &T;
+    //~^ ERROR missing lifetime in associated type
+    //~| HELP consider using the lifetime from the impl block
+    //~| NOTE this lifetime must come from the implemented type
+    type IntoIter = std::collections::btree_map::Values<'a, i32, T>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        todo!()
+    }
+}
+fn main() {}
diff --git a/tests/ui/lifetimes/missing-lifetime-in-assoc-type-6.stderr b/tests/ui/lifetimes/missing-lifetime-in-assoc-type-6.stderr
@@ -0,0 +1,30 @@
+error: missing lifetime in associated type
+  --> $DIR/missing-lifetime-in-assoc-type-6.rs:16:17
+   |
+LL | impl<'a> Trait for &'_ S {
+   |     ---- there is a named lifetime specified on the impl block you could use
+...
+LL |     type Item = &T;
+   |                 ^ this lifetime must come from the implemented type
+   |
+   = note: in the trait the associated type is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type
+help: consider using the lifetime from the impl block
+   |
+LL |     type Item = &'a T;
+   |                  ++
+
+error[E0207]: the lifetime parameter `'a` is not constrained by the impl trait, self type, or predicates
+  --> $DIR/missing-lifetime-in-assoc-type-6.rs:11:6
+   |
+LL | impl<'a> Trait for &'_ S {
+   |      ^^ unconstrained lifetime parameter
+   |
+help: consider using the named lifetime here instead of an implict lifetime
+   |
+LL - impl<'a> Trait for &'_ S {
+LL + impl<'a> Trait for &'a S {
+   |
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0207`.
diff --git a/tests/ui/lifetimes/no_lending_iterators.rs b/tests/ui/lifetimes/no_lending_iterators.rs
@@ -16,7 +16,7 @@ trait Bar {
 
 impl Bar for usize {
     type Item = &usize;
-    //~^ ERROR in the trait associated type is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type
+    //~^ ERROR missing lifetime in associated type
 
     fn poke(&mut self, item: Self::Item) {
         self += *item;
diff --git a/tests/ui/lifetimes/no_lending_iterators.stderr b/tests/ui/lifetimes/no_lending_iterators.stderr
@@ -10,13 +10,15 @@ note: you can't create an `Iterator` that borrows each `Item` from itself, but y
 LL | impl Iterator for Data {
    |                   ^^^^
 
-error: in the trait associated type is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type
+error: missing lifetime in associated type
   --> $DIR/no_lending_iterators.rs:18:17
    |
 LL | impl Bar for usize {
    |     - you could add a lifetime on the impl block, if the trait or the self type could have one
 LL |     type Item = &usize;
    |                 ^ this lifetime must come from the implemented type
+   |
+   = note: in the trait the associated type is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type
 
 error[E0195]: lifetime parameters or bounds on associated type `Item` do not match the trait declaration
   --> $DIR/no_lending_iterators.rs:27:14

Original file line number	Diff line number	Diff line change
`@@ -897,6 +897,8 @@ pub(crate) struct AnonymousLifetimeNonGatReportError {`
`897`	`897`	`#[primary_span]`
`898`	`898`	`#[label]`
`899`	`899`	`pub(crate) lifetime: Span,`
	`900`	`+ #[note]`
	`901`	`+ pub(crate) decl: MultiSpan,`
`900`	`902`	`}`
`901`	`903`
`902`	`904`	`#[derive(Subdiagnostic)]`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ trait MyTrait {`
`9`	`9`
`10`	`10`	`impl MyTrait for &i32 {`
`11`	`11`	`type Output = &i32;`
`12`		`- //~^ ERROR in the trait associated type is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type`
	`12`	`+ //~^ ERROR missing lifetime in associated type`
`13`	`13`	`}`
`14`	`14`
`15`	`15`	`impl MyTrait for &u32 {`
`@@ -19,15 +19,15 @@ impl MyTrait for &u32 {`
`19`	`19`
`20`	`20`	`impl<'a> MyTrait for &f64 {`
`21`	`21`	`type Output = &f64;`
`22`		`- //~^ ERROR in the trait associated type is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type`
	`22`	`+ //~^ ERROR missing lifetime in associated type`
`23`	`23`	`}`
`24`	`24`
`25`	`25`	`trait OtherTrait<'a> {`
`26`	`26`	`type Output;`
`27`	`27`	`}`
`28`	`28`	`impl OtherTrait<'_> for f64 {`
`29`	`29`	`type Output = &f64;`
`30`		`- //~^ ERROR in the trait associated type is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type`
	`30`	`+ //~^ ERROR missing lifetime in associated type`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`// This is what you have to do:`
Original file line number	Diff line number	Diff line change
`@@ -1,9 +1,10 @@`
`1`		`-error: in the trait associated type is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type`
	`1`	`+error: missing lifetime in associated type`
`2`	`2`	`--> $DIR/assoc-type.rs:11:19`
`3`	`3`	`\|`
`4`	`4`	`LL \| type Output = &i32;`
`5`	`5`	`\| ^ this lifetime must come from the implemented type`
`6`	`6`	`\|`
	`7`	`+ = note: in the trait the associated type is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type`
`7`	`8`	`help: add a lifetime to the impl block and use it in the self type and associated type`
`8`	`9`	`\|`
`9`	`10`	`LL ~ impl<'a> MyTrait for &'a i32 {`
@@ -16,25 +17,27 @@ error[E0637]: `'_` cannot be used here
`16`	`17`	`LL \| type Output = &'_ i32;`
`17`	`18`	\| ^^ `'_` is a reserved lifetime name
`18`	`19`
`19`		`-error: in the trait associated type is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type`
	`20`	`+error: missing lifetime in associated type`
`20`	`21`	`--> $DIR/assoc-type.rs:21:19`
`21`	`22`	`\|`
`22`	`23`	`LL \| impl<'a> MyTrait for &f64 {`
`23`	`24`	`\| ---- there is a named lifetime specified on the impl block you could use`
`24`	`25`	`LL \| type Output = &f64;`
`25`	`26`	`\| ^ this lifetime must come from the implemented type`
`26`	`27`	`\|`
	`28`	`+ = note: in the trait the associated type is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type`
`27`	`29`	`help: consider using the lifetime from the impl block`
`28`	`30`	`\|`
`29`	`31`	`LL \| type Output = &'a f64;`
`30`	`32`	`\| ++`
`31`	`33`
`32`		`-error: in the trait associated type is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type`
	`34`	`+error: missing lifetime in associated type`
`33`	`35`	`--> $DIR/assoc-type.rs:29:19`
`34`	`36`	`\|`
`35`	`37`	`LL \| type Output = &f64;`
`36`	`38`	`\| ^ this lifetime must come from the implemented type`
`37`	`39`	`\|`
	`40`	`+ = note: in the trait the associated type is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type`
`38`	`41`	`help: add a lifetime to the impl block and use it in the trait and associated type`
`39`	`42`	`\|`
`40`	`43`	`LL ~ impl<'a> OtherTrait<'a> for f64 {`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-error: in the trait associated type is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type`
	`1`	`+error: missing lifetime in associated type`
`2`	`2`	`--> $DIR/missing-lifetime-in-assoc-type-1.rs:9:17`
`3`	`3`	`\|`
`4`	`4`	`LL \| impl<'a> IntoIterator for &S {`
`@@ -7,6 +7,8 @@ LL \| impl<'a> IntoIterator for &S {`
`7`	`7`	`LL \| type Item = &T;`
`8`	`8`	`\| ^ this lifetime must come from the implemented type`
`9`	`9`	`\|`
	`10`	`+note: in the trait the associated type is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type`
	`11`	`+ --> $SRC_DIR/core/src/iter/traits/collect.rs:LL:COL`
`10`	`12`	`help: consider using the lifetime from the impl block`
`11`	`13`	`\|`
`12`	`14`	`LL \| type Item = &'a T;`
Original file line number	Diff line number	Diff line change
`@@ -1,9 +1,11 @@`
`1`		`-error: in the trait associated type is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type`
	`1`	`+error: missing lifetime in associated type`
`2`	`2`	`--> $DIR/missing-lifetime-in-assoc-type-2.rs:5:17`
`3`	`3`	`\|`
`4`	`4`	`LL \| type Item = &T;`
`5`	`5`	`\| ^ this lifetime must come from the implemented type`
`6`	`6`	`\|`
	`7`	`+note: in the trait the associated type is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type`
	`8`	`+ --> $SRC_DIR/core/src/iter/traits/collect.rs:LL:COL`
`7`	`9`	`help: add a lifetime to the impl block and use it in the self type and associated type`
`8`	`10`	`\|`
`9`	`11`	`LL ~ impl<'a> IntoIterator for &'a S {`