dnrops
/
rust
mirror of https://github.com/rust-lang/rust.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Rollup merge of #125258 - compiler-errors:static-if-no-lt, r=nnethercote 

Resolve elided lifetimes in assoc const to static if no other lifetimes are in scope

Implements the change to elided lifetime resolution in *associated consts* subject to FCP here: https://github.com/rust-lang/rust/issues/125190#issue-2301532282

Specifically, walk the enclosing lifetime ribs in an associated const, and if we find no other lifetimes, then resolve to `'static`.

Also make it work for traits, but don't lint -- just give a hard error in that case.
This commit is contained in:
许杰友 Jieyou Xu (Joe) 2024-06-17 04:53:54 +01:00 committed by GitHub
parent 6b65c30f8e 5f3357c3c6
commit 23b936f981
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
21 changed files with 385 additions and 209 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
compiler/rustc_lint/messages.ftl
View File

@ -14,6 +14,7 @@ lint_associated_const_elided_lifetime = {$elided ->
*[false] `'_` cannot be used here
}
.suggestion = use the `'static` lifetime
.note = cannot automatically infer `'static` because of other lifetimes in scope
lint_async_fn_in_trait = use of `async fn` in public traits is discouraged as auto trait bounds cannot be specified
.note = you can suppress this lint if you plan to use the trait only in your own code, or do not care about auto traits like `Send` on the `Future`

15
compiler/rustc_lint/src/context/diagnostics.rs
View File

@ -319,11 +319,20 @@ pub(super) fn decorate_lint(sess: &Session, diagnostic: BuiltinLintDiag, diag: &
BuiltinLintDiag::UnusedQualifications { removal_span } => {
lints::UnusedQualifications { removal_span }.decorate_lint(diag);
}
BuiltinLintDiag::AssociatedConstElidedLifetime { elided, span: lt_span } => {
BuiltinLintDiag::AssociatedConstElidedLifetime {
elided,
span: lt_span,
lifetimes_in_scope,
} => {
let lt_span = if elided { lt_span.shrink_to_hi() } else { lt_span };
let code = if elided { "'static " } else { "'static" };
lints::AssociatedConstElidedLifetime { span: lt_span, code, elided }
.decorate_lint(diag);
lints::AssociatedConstElidedLifetime {
span: lt_span,
code,
elided,
lifetimes_in_scope,
}
.decorate_lint(diag);
}
BuiltinLintDiag::RedundantImportVisibility { max_vis, span: vis_span, import_vis } => {
lints::RedundantImportVisibility { span: vis_span, help: (), max_vis, import_vis }

2
compiler/rustc_lint/src/lints.rs
View File

@ -2873,6 +2873,8 @@ pub struct AssociatedConstElidedLifetime {
pub code: &'static str,
pub elided: bool,
#[note]
pub lifetimes_in_scope: MultiSpan,
}
#[derive(LintDiagnostic)]

8
compiler/rustc_lint_defs/src/builtin.rs
View File

@ -4593,16 +4593,18 @@ declare_lint! {
declare_lint! {
/// The `elided_lifetimes_in_associated_constant` lint detects elided lifetimes
/// that were erroneously allowed in associated constants.
/// in associated constants when there are other lifetimes in scope. This was
/// accidentally supported, and this lint was later relaxed to allow eliding
/// lifetimes to `'static` when there are no lifetimes in scope.
///
/// ### Example
///
/// ```rust,compile_fail
/// #![deny(elided_lifetimes_in_associated_constant)]
///
/// struct Foo;
/// struct Foo<'a>(&'a ());
///
/// impl Foo {
/// impl<'a> Foo<'a> {
/// const STR: &str = "hello, world";
/// }
/// ```

1
compiler/rustc_lint_defs/src/lib.rs
View File

@ -696,6 +696,7 @@ pub enum BuiltinLintDiag {
AssociatedConstElidedLifetime {
elided: bool,
span: Span,
lifetimes_in_scope: MultiSpan,
},
RedundantImportVisibility {
span: Span,

140
compiler/rustc_resolve/src/late.rs
View File

@ -310,9 +310,10 @@ enum LifetimeRibKind {
/// error on default object bounds (e.g., `Box<dyn Foo>`).
AnonymousReportError,
/// Resolves elided lifetimes to `'static`, but gives a warning that this behavior
/// is a bug and will be reverted soon.
AnonymousWarn(NodeId),
/// Resolves elided lifetimes to `'static` if there are no other lifetimes in scope,
/// otherwise give a warning that the previous behavior of introducing a new early-bound
/// lifetime is a bug and will be removed (if `emit_lint` is enabled).
StaticIfNoLifetimeInScope { lint_id: NodeId, emit_lint: bool },
/// Signal we cannot find which should be the anonymous lifetime.
ElisionFailure,
@ -1212,7 +1213,7 @@ impl<'a: 'ast, 'ast, 'tcx> Visitor<'ast> for LateResolutionVisitor<'a, '_, 'ast,
}
LifetimeRibKind::AnonymousCreateParameter { .. }
| LifetimeRibKind::AnonymousReportError
| LifetimeRibKind::AnonymousWarn(_)
| LifetimeRibKind::StaticIfNoLifetimeInScope { .. }
| LifetimeRibKind::Elided(_)
| LifetimeRibKind::ElisionFailure
| LifetimeRibKind::ConcreteAnonConst(_)
@ -1580,7 +1581,7 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
// lifetime would be illegal.
LifetimeRibKind::Item
| LifetimeRibKind::AnonymousReportError
| LifetimeRibKind::AnonymousWarn(_)
| LifetimeRibKind::StaticIfNoLifetimeInScope { .. }
| LifetimeRibKind::ElisionFailure => Some(LifetimeUseSet::Many),
// An anonymous lifetime is legal here, and bound to the right
// place, go ahead.
@ -1643,7 +1644,7 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
| LifetimeRibKind::Generics { .. }
| LifetimeRibKind::ElisionFailure
| LifetimeRibKind::AnonymousReportError
| LifetimeRibKind::AnonymousWarn(_) => {}
| LifetimeRibKind::StaticIfNoLifetimeInScope { .. } => {}
}
}
@ -1677,16 +1678,36 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
self.record_lifetime_res(lifetime.id, res, elision_candidate);
return;
}
LifetimeRibKind::AnonymousWarn(node_id) => {
self.r.lint_buffer.buffer_lint(
lint::builtin::ELIDED_LIFETIMES_IN_ASSOCIATED_CONSTANT,
node_id,
lifetime.ident.span,
lint::BuiltinLintDiag::AssociatedConstElidedLifetime {
elided,
span: lifetime.ident.span,
},
);
LifetimeRibKind::StaticIfNoLifetimeInScope { lint_id: node_id, emit_lint } => {
let mut lifetimes_in_scope = vec![];
for rib in &self.lifetime_ribs[..i] {
lifetimes_in_scope.extend(rib.bindings.iter().map(|(ident, _)| ident.span));
// Consider any anonymous lifetimes, too
if let LifetimeRibKind::AnonymousCreateParameter { binder, .. } = rib.kind
&& let Some(extra) = self.r.extra_lifetime_params_map.get(&binder)
{
lifetimes_in_scope.extend(extra.iter().map(|(ident, _, _)| ident.span));
}
}
if lifetimes_in_scope.is_empty() {
self.record_lifetime_res(
lifetime.id,
LifetimeRes::Static,
elision_candidate,
);
return;
} else if emit_lint {
self.r.lint_buffer.buffer_lint(
lint::builtin::ELIDED_LIFETIMES_IN_ASSOCIATED_CONSTANT,
node_id,
lifetime.ident.span,
lint::BuiltinLintDiag::AssociatedConstElidedLifetime {
elided,
span: lifetime.ident.span,
lifetimes_in_scope: lifetimes_in_scope.into(),
},
);
}
}
LifetimeRibKind::AnonymousReportError => {
if elided {
@ -1904,7 +1925,7 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
// impl Foo for std::cell::Ref<u32> // note lack of '_
// async fn foo(_: std::cell::Ref<u32>) { ... }
LifetimeRibKind::AnonymousCreateParameter { report_in_path: true, .. }
| LifetimeRibKind::AnonymousWarn(_) => {
| LifetimeRibKind::StaticIfNoLifetimeInScope { .. } => {
let sess = self.r.tcx.sess;
let subdiag = rustc_errors::elided_lifetime_in_path_suggestion(
sess.source_map(),
@ -2838,19 +2859,27 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
kind: LifetimeBinderKind::ConstItem,
},
|this| {
this.visit_generics(generics);
this.visit_ty(ty);
this.with_lifetime_rib(
LifetimeRibKind::StaticIfNoLifetimeInScope {
lint_id: item.id,
emit_lint: false,
},
|this| {
this.visit_generics(generics);
this.visit_ty(ty);
// Only impose the restrictions of `ConstRibKind` for an
// actual constant expression in a provided default.
if let Some(expr) = expr {
// We allow arbitrary const expressions inside of associated consts,
// even if they are potentially not const evaluatable.
//
// Type parameters can already be used and as associated consts are
// not used as part of the type system, this is far less surprising.
this.resolve_const_body(expr, None);
}
// Only impose the restrictions of `ConstRibKind` for an
// actual constant expression in a provided default.
if let Some(expr) = expr {
// We allow arbitrary const expressions inside of associated consts,
// even if they are potentially not const evaluatable.
//
// Type parameters can already be used and as associated consts are
// not used as part of the type system, this is far less surprising.
this.resolve_const_body(expr, None);
}
},
)
},
);
}
@ -3030,30 +3059,37 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
kind: LifetimeBinderKind::ConstItem,
},
|this| {
this.with_lifetime_rib(LifetimeRibKind::AnonymousWarn(item.id), |this| {
// If this is a trait impl, ensure the const
// exists in trait
this.check_trait_item(
item.id,
item.ident,
&item.kind,
ValueNS,
item.span,
seen_trait_items,
|i, s, c| ConstNotMemberOfTrait(i, s, c),
);
this.with_lifetime_rib(
LifetimeRibKind::StaticIfNoLifetimeInScope {
lint_id: item.id,
// In impls, it's not a hard error yet due to backcompat.
emit_lint: true,
},
|this| {
// If this is a trait impl, ensure the const
// exists in trait
this.check_trait_item(
item.id,
item.ident,
&item.kind,
ValueNS,
item.span,
seen_trait_items,
|i, s, c| ConstNotMemberOfTrait(i, s, c),
);
this.visit_generics(generics);
this.visit_ty(ty);
if let Some(expr) = expr {
// We allow arbitrary const expressions inside of associated consts,
// even if they are potentially not const evaluatable.
//
// Type parameters can already be used and as associated consts are
// not used as part of the type system, this is far less surprising.
this.resolve_const_body(expr, None);
}
});
this.visit_generics(generics);
this.visit_ty(ty);
if let Some(expr) = expr {
// We allow arbitrary const expressions inside of associated consts,
// even if they are potentially not const evaluatable.
//
// Type parameters can already be used and as associated consts are
// not used as part of the type system, this is far less surprising.
this.resolve_const_body(expr, None);
}
},
);
},
);
}

8
tests/ui/associated-consts/double-elided.rs
View File

@ -1,12 +1,10 @@
//@ check-pass
struct S;
impl S {
const C: &&str = &"";
//~^ WARN `&` without an explicit lifetime name cannot be used here
//~| WARN this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
//~| WARN `&` without an explicit lifetime name cannot be used here
//~| WARN this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
//~| ERROR in type `&&str`, reference has a longer lifetime than the data it references
// Now resolves to `&'static &'static str`.
}
fn main() {}

47
tests/ui/associated-consts/double-elided.stderr
View File

@ -1,47 +0,0 @@
warning: `&` without an explicit lifetime name cannot be used here
--> $DIR/double-elided.rs:4:14
|
LL | const C: &&str = &"";
| ^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= note: for more information, see issue #115010 <https://github.com/rust-lang/rust/issues/115010>
= note: `#[warn(elided_lifetimes_in_associated_constant)]` on by default
help: use the `'static` lifetime
|
LL | const C: &'static &str = &"";
| +++++++
warning: `&` without an explicit lifetime name cannot be used here
--> $DIR/double-elided.rs:4:15
|
LL | const C: &&str = &"";
| ^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= note: for more information, see issue #115010 <https://github.com/rust-lang/rust/issues/115010>
help: use the `'static` lifetime
|
LL | const C: &&'static str = &"";
| +++++++
error[E0491]: in type `&&str`, reference has a longer lifetime than the data it references
--> $DIR/double-elided.rs:4:5
|
LL | const C: &&str = &"";
| ^^^^^^^^^^^^^^^^^^^^^
|
note: the pointer is valid for the anonymous lifetime as defined here
--> $DIR/double-elided.rs:4:14
|
LL | const C: &&str = &"";
| ^
note: but the referenced data is only valid for the anonymous lifetime as defined here
--> $DIR/double-elided.rs:4:14
|
LL | const C: &&str = &"";
| ^
error: aborting due to 1 previous error; 2 warnings emitted
For more information about this error, try `rustc --explain E0491`.

2
tests/ui/associated-consts/infer-placeholder-in-non-suggestable-pos.rs
View File

@ -5,8 +5,6 @@ trait Trait {
impl Trait for () {
const ASSOC: &dyn Fn(_) = 1i32;
//~^ ERROR the placeholder `_` is not allowed within types on item signatures for associated constants
//~| WARN `&` without an explicit lifetime name cannot be used here
//~| WARN this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
}
fn main() {}

16
tests/ui/associated-consts/infer-placeholder-in-non-suggestable-pos.stderr
View File

@ -1,23 +1,9 @@
warning: `&` without an explicit lifetime name cannot be used here
--> $DIR/infer-placeholder-in-non-suggestable-pos.rs:6:18
|
LL | const ASSOC: &dyn Fn(_) = 1i32;
| ^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= note: for more information, see issue #115010 <https://github.com/rust-lang/rust/issues/115010>
= note: `#[warn(elided_lifetimes_in_associated_constant)]` on by default
help: use the `'static` lifetime
|
LL | const ASSOC: &'static dyn Fn(_) = 1i32;
| +++++++
error[E0121]: the placeholder `_` is not allowed within types on item signatures for associated constants
--> $DIR/infer-placeholder-in-non-suggestable-pos.rs:6:26
|
LL | const ASSOC: &dyn Fn(_) = 1i32;
| ^ not allowed in type signatures
error: aborting due to 1 previous error; 1 warning emitted
error: aborting due to 1 previous error
For more information about this error, try `rustc --explain E0121`.

12
tests/ui/consts/assoc-const-elided-lifetime.stderr
View File

@ -6,6 +6,11 @@ LL | const FOO: Foo<'_> = Foo { x: PhantomData::<&()> };
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= note: for more information, see issue #115010 <https://github.com/rust-lang/rust/issues/115010>
note: cannot automatically infer `'static` because of other lifetimes in scope
--> $DIR/assoc-const-elided-lifetime.rs:9:6
|
LL | impl<'a> Foo<'a> {
| ^^
note: the lint level is defined here
--> $DIR/assoc-const-elided-lifetime.rs:1:9
|
@ -24,6 +29,13 @@ LL | const BAR: &() = &();
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= note: for more information, see issue #115010 <https://github.com/rust-lang/rust/issues/115010>
note: cannot automatically infer `'static` because of other lifetimes in scope
--> $DIR/assoc-const-elided-lifetime.rs:9:6
|
LL | impl<'a> Foo<'a> {
| ^^
LL | const FOO: Foo<'_> = Foo { x: PhantomData::<&()> };
| ^^
help: use the `'static` lifetime
|
LL | const BAR: &'static () = &();

22
tests/ui/consts/static-default-lifetime/elided-lifetime.rs Normal file
View File

@ -0,0 +1,22 @@
#![deny(elided_lifetimes_in_associated_constant)]
struct Foo<'a>(&'a ());
impl Foo<'_> {
const STATIC: &str = "";
//~^ ERROR `&` without an explicit lifetime name cannot be used here
//~| WARN this was previously accepted by the compiler but is being phased out
}
trait Bar {
const STATIC: &str;
}
impl Bar for Foo<'_> {
const STATIC: &str = "";
//~^ ERROR `&` without an explicit lifetime name cannot be used here
//~| WARN this was previously accepted by the compiler but is being phased out
//~| ERROR const not compatible with trait
}
fn main() {}

59
tests/ui/consts/static-default-lifetime/elided-lifetime.stderr Normal file
View File

@ -0,0 +1,59 @@
error: `&` without an explicit lifetime name cannot be used here
--> $DIR/elided-lifetime.rs:6:19
|
LL | const STATIC: &str = "";
| ^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= note: for more information, see issue #115010 <https://github.com/rust-lang/rust/issues/115010>
note: cannot automatically infer `'static` because of other lifetimes in scope
--> $DIR/elided-lifetime.rs:5:10
|
LL | impl Foo<'_> {
| ^^
note: the lint level is defined here
--> $DIR/elided-lifetime.rs:1:9
|
LL | #![deny(elided_lifetimes_in_associated_constant)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
help: use the `'static` lifetime
|
LL | const STATIC: &'static str = "";
| +++++++
error: `&` without an explicit lifetime name cannot be used here
--> $DIR/elided-lifetime.rs:16:19
|
LL | const STATIC: &str = "";
| ^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= note: for more information, see issue #115010 <https://github.com/rust-lang/rust/issues/115010>
note: cannot automatically infer `'static` because of other lifetimes in scope
--> $DIR/elided-lifetime.rs:15:18
|
LL | impl Bar for Foo<'_> {
| ^^
help: use the `'static` lifetime
|
LL | const STATIC: &'static str = "";
| +++++++
error[E0308]: const not compatible with trait
--> $DIR/elided-lifetime.rs:16:5
|
LL | const STATIC: &str = "";
| ^^^^^^^^^^^^^^^^^^ lifetime mismatch
|
= note: expected reference `&'static _`
found reference `&_`
note: the anonymous lifetime as defined here...
--> $DIR/elided-lifetime.rs:15:18
|
LL | impl Bar for Foo<'_> {
| ^^
= note: ...does not necessarily outlive the static lifetime
error: aborting due to 3 previous errors
For more information about this error, try `rustc --explain E0308`.

19
tests/ui/consts/static-default-lifetime/generic-associated-const.rs Normal file
View File

@ -0,0 +1,19 @@
#![deny(elided_lifetimes_in_associated_constant)]
#![feature(generic_const_items)]
//~^ WARN the feature `generic_const_items` is incomplete
struct A;
impl A {
const GAC_TYPE<T>: &str = "";
const GAC_LIFETIME<'a>: &str = "";
//~^ ERROR `&` without an explicit lifetime name cannot be used here
//~| WARN this was previously accepted by the compiler but is being phased out
}
trait Trait {
const GAC_TYPE<T>: &str = "";
const GAC_LIFETIME<'a>: &str = "";
//~^ ERROR missing lifetime specifier
}
fn main() {}

46
tests/ui/consts/static-default-lifetime/generic-associated-const.stderr Normal file
View File

@ -0,0 +1,46 @@
error[E0106]: missing lifetime specifier
--> $DIR/generic-associated-const.rs:15:29
|
LL | const GAC_LIFETIME<'a>: &str = "";
| ^ expected named lifetime parameter
|
help: consider using the `'a` lifetime
|
LL | const GAC_LIFETIME<'a>: &'a str = "";
| ++
warning: the feature `generic_const_items` is incomplete and may not be safe to use and/or cause compiler crashes
--> $DIR/generic-associated-const.rs:2:12
|
LL | #![feature(generic_const_items)]
| ^^^^^^^^^^^^^^^^^^^
|
= note: see issue #113521 <https://github.com/rust-lang/rust/issues/113521> for more information
= note: `#[warn(incomplete_features)]` on by default
error: `&` without an explicit lifetime name cannot be used here
--> $DIR/generic-associated-const.rs:8:29
|
LL | const GAC_LIFETIME<'a>: &str = "";
| ^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= note: for more information, see issue #115010 <https://github.com/rust-lang/rust/issues/115010>
note: cannot automatically infer `'static` because of other lifetimes in scope
--> $DIR/generic-associated-const.rs:8:24
|
LL | const GAC_LIFETIME<'a>: &str = "";
| ^^
note: the lint level is defined here
--> $DIR/generic-associated-const.rs:1:9
|
LL | #![deny(elided_lifetimes_in_associated_constant)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
help: use the `'static` lifetime
|
LL | const GAC_LIFETIME<'a>: &'static str = "";
| +++++++
error: aborting due to 2 previous errors; 1 warning emitted
For more information about this error, try `rustc --explain E0106`.

21
tests/ui/consts/static-default-lifetime/inner-item.rs Normal file
View File

@ -0,0 +1,21 @@
//@ check-pass
struct Foo<'a>(&'a ());
impl<'a> Foo<'a> {
fn hello(self) {
const INNER: &str = "";
}
}
impl Foo<'_> {
fn implicit(self) {
const INNER: &str = "";
}
fn fn_lifetime(&self) {
const INNER: &str = "";
}
}
fn main() {}

20
tests/ui/consts/static-default-lifetime/static-trait-impl.rs Normal file
View File

@ -0,0 +1,20 @@
#![deny(elided_lifetimes_in_associated_constant)]
trait Bar<'a> {
const STATIC: &'a str;
}
struct A;
impl Bar<'_> for A {
const STATIC: &str = "";
//~^ ERROR `&` without an explicit lifetime name cannot be used here
//~| WARN this was previously accepted by the compiler but is being phased out
//~| ERROR const not compatible with trait
}
struct B;
impl Bar<'static> for B {
const STATIC: &str = "";
}
fn main() {}

45
tests/ui/consts/static-default-lifetime/static-trait-impl.stderr Normal file
View File

@ -0,0 +1,45 @@
error: `&` without an explicit lifetime name cannot be used here
--> $DIR/static-trait-impl.rs:9:19
|
LL | const STATIC: &str = "";
| ^
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= note: for more information, see issue #115010 <https://github.com/rust-lang/rust/issues/115010>
note: cannot automatically infer `'static` because of other lifetimes in scope
--> $DIR/static-trait-impl.rs:8:10
|
LL | impl Bar<'_> for A {
| ^^
note: the lint level is defined here
--> $DIR/static-trait-impl.rs:1:9
|
LL | #![deny(elided_lifetimes_in_associated_constant)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
help: use the `'static` lifetime
|
LL | const STATIC: &'static str = "";
| +++++++
error[E0308]: const not compatible with trait
--> $DIR/static-trait-impl.rs:9:5
|
LL | const STATIC: &str = "";
| ^^^^^^^^^^^^^^^^^^ lifetime mismatch
|
= note: expected reference `&_`
found reference `&_`
note: the anonymous lifetime as defined here...
--> $DIR/static-trait-impl.rs:8:10
|
LL | impl Bar<'_> for A {
| ^^
note: ...does not necessarily outlive the anonymous lifetime as defined here
--> $DIR/static-trait-impl.rs:8:10
|
LL | impl Bar<'_> for A {
| ^^
error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0308`.

56
tests/ui/suggestions/missing-lifetime-in-assoc-const-type.default.stderr
View File

@ -1,57 +1,25 @@
error[E0106]: missing lifetime specifier
--> $DIR/missing-lifetime-in-assoc-const-type.rs:6:14
|
LL | const A: &str = "";
| ^ expected named lifetime parameter
|
help: consider introducing a named lifetime parameter
|
LL ~ trait ZstAssert<'a>: Sized {
LL ~ const A: &'a str = "";
|
error[E0106]: missing lifetime specifier
error[E0726]: implicit elided lifetime not allowed here
--> $DIR/missing-lifetime-in-assoc-const-type.rs:7:14
|
LL | const B: S = S { s: &() };
| ^ expected named lifetime parameter
| ^ expected lifetime parameter
|
help: consider introducing a named lifetime parameter
|
LL ~ trait ZstAssert<'a>: Sized {
LL | const A: &str = "";
LL ~ const B: S<'a> = S { s: &() };
help: indicate the anonymous lifetime
|
LL | const B: S<'_> = S { s: &() };
| ++++
error[E0106]: missing lifetime specifier
--> $DIR/missing-lifetime-in-assoc-const-type.rs:8:15
|
LL | const C: &'_ str = "";
| ^^ expected named lifetime parameter
|
help: consider introducing a named lifetime parameter
|
LL ~ trait ZstAssert<'a>: Sized {
LL | const A: &str = "";
LL | const B: S = S { s: &() };
LL ~ const C: &'a str = "";
|
error[E0106]: missing lifetime specifiers
error[E0726]: implicit elided lifetime not allowed here
--> $DIR/missing-lifetime-in-assoc-const-type.rs:9:14
|
LL | const D: T = T { a: &(), b: &() };
| ^ expected 2 lifetime parameters
| ^ expected lifetime parameters
|
help: consider introducing a named lifetime parameter
|
LL ~ trait ZstAssert<'a>: Sized {
LL | const A: &str = "";
LL | const B: S = S { s: &() };
LL | const C: &'_ str = "";
LL ~ const D: T<'a, 'a> = T { a: &(), b: &() };
help: indicate the anonymous lifetimes
|
LL | const D: T<'_, '_> = T { a: &(), b: &() };
| ++++++++
error: aborting due to 4 previous errors
error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0106`.
For more information about this error, try `rustc --explain E0726`.

46
tests/ui/suggestions/missing-lifetime-in-assoc-const-type.generic_const_items.stderr
View File

@ -1,47 +1,25 @@
error[E0106]: missing lifetime specifier
--> $DIR/missing-lifetime-in-assoc-const-type.rs:6:14
|
LL | const A: &str = "";
| ^ expected named lifetime parameter
|
help: consider introducing a named lifetime parameter
|
LL | const A<'a>: &'a str = "";
| ++++ ++
error[E0106]: missing lifetime specifier
error[E0726]: implicit elided lifetime not allowed here
--> $DIR/missing-lifetime-in-assoc-const-type.rs:7:14
|
LL | const B: S = S { s: &() };
| ^ expected named lifetime parameter
| ^ expected lifetime parameter
|
help: consider introducing a named lifetime parameter
help: indicate the anonymous lifetime
|
LL | const B<'a>: S<'a> = S { s: &() };
| ++++ ++++
LL | const B: S<'_> = S { s: &() };
| ++++
error[E0106]: missing lifetime specifier
--> $DIR/missing-lifetime-in-assoc-const-type.rs:8:15
|
LL | const C: &'_ str = "";
| ^^ expected named lifetime parameter
|
help: consider introducing a named lifetime parameter
|
LL | const C<'a>: &'a str = "";
| ++++ ~~
error[E0106]: missing lifetime specifiers
error[E0726]: implicit elided lifetime not allowed here
--> $DIR/missing-lifetime-in-assoc-const-type.rs:9:14
|
LL | const D: T = T { a: &(), b: &() };
| ^ expected 2 lifetime parameters
| ^ expected lifetime parameters
|
help: consider introducing a named lifetime parameter
help: indicate the anonymous lifetimes
|
LL | const D<'a>: T<'a, 'a> = T { a: &(), b: &() };
| ++++ ++++++++
LL | const D: T<'_, '_> = T { a: &(), b: &() };
| ++++++++
error: aborting due to 4 previous errors
error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0106`.
For more information about this error, try `rustc --explain E0726`.

8
tests/ui/suggestions/missing-lifetime-in-assoc-const-type.rs
View File

@ -3,10 +3,10 @@
#![cfg_attr(generic_const_items, feature(generic_const_items), allow(incomplete_features))]
trait ZstAssert: Sized {
const A: &str = ""; //~ ERROR missing lifetime specifier
const B: S = S { s: &() }; //~ ERROR missing lifetime specifier
const C: &'_ str = ""; //~ ERROR missing lifetime specifier
const D: T = T { a: &(), b: &() }; //~ ERROR missing lifetime specifier
const A: &str = "";
const B: S = S { s: &() }; //~ ERROR implicit elided lifetime not allowed here
const C: &'_ str = "";
const D: T = T { a: &(), b: &() }; //~ ERROR implicit elided lifetime not allowed here
}
struct S<'a> {