nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2025-02-16 17:03:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

non_local_defs: use labels to indicate what may need to be moved

Browse Source
This commit is contained in:
Urgau 2024-05-14 12:41:27 +02:00
parent 26b873d030
commit 22095fbd8d
12 changed files with 587 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
compiler/rustc_lint/messages.ftl
View File

@ -544,7 +544,7 @@ lint_non_local_definitions_deprecation = this lint may become deny-by-default in
lint_non_local_definitions_impl = non-local `impl` definition, `impl` blocks should be written at the same level as their item
.help =
move this `impl` block outside the of the current {$body_kind_descr} {$depth ->
move this `impl` block outside of the current {$body_kind_descr} {$depth ->
[one] `{$body_name}`
*[other] `{$body_name}` and up {$depth} bodies
}
@ -565,6 +565,8 @@ lint_non_local_definitions_macro_rules = non-local `macro_rules!` definition, `#
.non_local = a `macro_rules!` definition is non-local if it is nested inside an item and has a `#[macro_export]` attribute
.exception = one exception to the rule are anon-const (`const _: () = {"{"} ... {"}"}`) at top-level module
lint_non_local_definitions_may_move = may need to be moved as well
lint_non_snake_case = {$sort} `{$name}` should have a snake case name
.rename_or_convert_suggestion = rename the identifier or convert it to a snake case raw identifier
.cannot_convert_note = `{$sc}` cannot be used as a raw identifier

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

@ -6,7 +6,7 @@ use crate::errors::RequestedLevel;
use crate::fluent_generated as fluent;
use rustc_errors::{
codes::*, Applicability, Diag, DiagArgValue, DiagMessage, DiagStyledString,
ElidedLifetimeInPathSubdiag, EmissionGuarantee, LintDiagnostic, SubdiagMessageOp,
ElidedLifetimeInPathSubdiag, EmissionGuarantee, LintDiagnostic, MultiSpan, SubdiagMessageOp,
Subdiagnostic, SuggestionStyle,
};
use rustc_hir::{def::Namespace, def_id::DefId};
@ -1336,6 +1336,9 @@ pub enum NonLocalDefinitionsDiag {
body_name: String,
cargo_update: Option<NonLocalDefinitionsCargoUpdateNote>,
const_anon: Option<Option<Span>>,
move_help: Span,
self_ty: Span,
of_trait: Option<Span>,
has_trait: bool,
},
MacroRules {
@ -1357,6 +1360,9 @@ impl<'a> LintDiagnostic<'a, ()> for NonLocalDefinitionsDiag {
body_name,
cargo_update,
const_anon,
move_help,
self_ty,
of_trait,
has_trait,
} => {
diag.primary_message(fluent::lint_non_local_definitions_impl);
@ -1364,13 +1370,18 @@ impl<'a> LintDiagnostic<'a, ()> for NonLocalDefinitionsDiag {
diag.arg("body_kind_descr", body_kind_descr);
diag.arg("body_name", body_name);
diag.help(fluent::lint_help);
if has_trait {
diag.note(fluent::lint_bounds);
diag.note(fluent::lint_with_trait);
} else {
diag.note(fluent::lint_without_trait);
}
let mut ms = MultiSpan::from_span(move_help);
ms.push_span_label(self_ty, fluent::lint_non_local_definitions_may_move);
if let Some(of_trait) = of_trait {
ms.push_span_label(of_trait, fluent::lint_non_local_definitions_may_move);
}
diag.span_help(ms, fluent::lint_help);
if let Some(cargo_update) = cargo_update {
diag.subdiagnostic(&diag.dcx, cargo_update);

3
compiler/rustc_lint/src/non_local_def.rs
View File

@ -222,6 +222,9 @@ impl<'tcx> LateLintPass<'tcx> for NonLocalDefinitions {
item.span.shrink_to_lo().to(impl_.self_ty.span),
NonLocalDefinitionsDiag::Impl {
depth: self.body_depth,
move_help: item.span,
self_ty: impl_.self_ty.span,
of_trait: impl_.of_trait.map(|t| t.path.span),
body_kind_descr: cx.tcx.def_kind_descr(parent_def_kind, parent),
body_name: parent_opt_item_name
.map(|s| s.to_ident_string())

9
tests/ui/lint/non-local-defs/cargo-update.stderr
View File

@ -4,9 +4,16 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | non_local_macro::non_local_impl!(LocalStruct);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: move this `impl` block outside the of the current constant `_IMPL_DEBUG`
= note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
= note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
help: move this `impl` block outside of the current constant `_IMPL_DEBUG`
--> $DIR/cargo-update.rs:17:1
|
LL | non_local_macro::non_local_impl!(LocalStruct);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| |
| may need to be moved as well
| may need to be moved as well
= note: the macro `non_local_macro::non_local_impl` may come from an old version of the `non_local_macro` crate, try updating your dependency with `cargo update -p non_local_macro`
= note: anon-const (`const _: () = { ... }`) at top-level module and anon-const at the same nesting as the trait or type are consider to be transparent regarding the nesting level
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>

81
tests/ui/lint/non-local-defs/consts.stderr
View File

@ -7,9 +7,16 @@ LL | const Z: () = {
LL | impl Uto for &Test {}
| ^^^^^^^^^^^^^^^^^^
|
= help: move this `impl` block outside the of the current constant `Z`
= note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
= note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
help: move this `impl` block outside of the current constant `Z`
--> $DIR/consts.rs:13:5
|
LL | impl Uto for &Test {}
| ^^^^^---^^^^^-----^^^
| | |
| | may need to be moved as well
| may need to be moved as well
= note: anon-const (`const _: () = { ... }`) at top-level module and anon-const at the same nesting as the trait or type are consider to be transparent regarding the nesting level
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
= note: `#[warn(non_local_definitions)]` on by default
@ -20,9 +27,16 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl Uto2 for Test {}
| ^^^^^^^^^^^^^^^^^^
|
= help: move this `impl` block outside the of the current static `A`
= note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
= note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
help: move this `impl` block outside of the current static `A`
--> $DIR/consts.rs:24:5
|
LL | impl Uto2 for Test {}
| ^^^^^----^^^^^----^^^
| | |
| | may need to be moved as well
| may need to be moved as well
= note: anon-const (`const _: () = { ... }`) at top-level module and anon-const at the same nesting as the trait or type are consider to be transparent regarding the nesting level
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
@ -32,9 +46,16 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl Uto3 for Test {}
| ^^^^^^^^^^^^^^^^^^
|
= help: move this `impl` block outside the of the current constant `B`
= note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
= note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
help: move this `impl` block outside of the current constant `B`
--> $DIR/consts.rs:32:5
|
LL | impl Uto3 for Test {}
| ^^^^^----^^^^^----^^^
| | |
| | may need to be moved as well
| may need to be moved as well
= note: anon-const (`const _: () = { ... }`) at top-level module and anon-const at the same nesting as the trait or type are consider to be transparent regarding the nesting level
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
@ -44,8 +65,18 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl Test {
| ^^^^^^^^^
|
= help: move this `impl` block outside the of the current function `main`
= note: methods and assoc const are still usable outside the current expression, only `impl Local` and `impl dyn Local` are local and only if the `Local` type is at the same nesting as the `impl` block
help: move this `impl` block outside of the current function `main`
--> $DIR/consts.rs:43:5
|
LL | impl Test {
| ^ ---- may need to be moved as well
| _____|
| |
LL | |
LL | | fn foo() {}
LL | | }
| |_____^
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
@ -54,8 +85,18 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl Test {
| ^^^^^^^^^
|
= help: move this `impl` block outside the of the current inline constant `<unnameable>` and up 2 bodies
= note: methods and assoc const are still usable outside the current expression, only `impl Local` and `impl dyn Local` are local and only if the `Local` type is at the same nesting as the `impl` block
help: move this `impl` block outside of the current inline constant `<unnameable>` and up 2 bodies
--> $DIR/consts.rs:50:9
|
LL | impl Test {
| ^ ---- may need to be moved as well
| _________|
| |
LL | |
LL | | fn hoo() {}
LL | | }
| |_________^
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
@ -64,8 +105,18 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl Test {
| ^^^^^^^^^
|
= help: move this `impl` block outside the of the current constant `_` and up 2 bodies
= note: methods and assoc const are still usable outside the current expression, only `impl Local` and `impl dyn Local` are local and only if the `Local` type is at the same nesting as the `impl` block
help: move this `impl` block outside of the current constant `_` and up 2 bodies
--> $DIR/consts.rs:59:9
|
LL | impl Test {
| ^ ---- may need to be moved as well
| _________|
| |
LL | |
LL | | fn foo2() {}
LL | | }
| |_________^
= note: anon-const (`const _: () = { ... }`) at top-level module and anon-const at the same nesting as the trait or type are consider to be transparent regarding the nesting level
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
@ -75,9 +126,16 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl Uto9 for Test {}
| ^^^^^^^^^^^^^^^^^^
|
= help: move this `impl` block outside the of the current closure `<unnameable>` and up 2 bodies
= note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
= note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
help: move this `impl` block outside of the current closure `<unnameable>` and up 2 bodies
--> $DIR/consts.rs:72:9
|
LL | impl Uto9 for Test {}
| ^^^^^----^^^^^----^^^
| | |
| | may need to be moved as well
| may need to be moved as well
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
@ -86,9 +144,16 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl Uto10 for Test {}
| ^^^^^^^^^^^^^^^^^^^
|
= help: move this `impl` block outside the of the current constant expression `<unnameable>` and up 2 bodies
= note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
= note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
help: move this `impl` block outside of the current constant expression `<unnameable>` and up 2 bodies
--> $DIR/consts.rs:79:9
|
LL | impl Uto10 for Test {}
| ^^^^^-----^^^^^----^^^
| | |
| | may need to be moved as well
| may need to be moved as well
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: 8 warnings emitted

90
tests/ui/lint/non-local-defs/exhaustive-trait.stderr
View File

@ -4,9 +4,22 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl PartialEq<()> for Dog {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: move this `impl` block outside the of the current function `main`
= note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
= note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
help: move this `impl` block outside of the current function `main`
--> $DIR/exhaustive-trait.rs:7:5
|
LL | impl PartialEq<()> for Dog {
| ^ ------------- --- may need to be moved as well
| | |
| _____| may need to be moved as well
| |
LL | |
LL | | fn eq(&self, _: &()) -> bool {
LL | | todo!()
LL | | }
LL | | }
| |_____^
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
= note: `#[warn(non_local_definitions)]` on by default
@ -16,9 +29,22 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl PartialEq<()> for &Dog {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: move this `impl` block outside the of the current function `main`
= note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
= note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
help: move this `impl` block outside of the current function `main`
--> $DIR/exhaustive-trait.rs:14:5
|
LL | impl PartialEq<()> for &Dog {
| ^ ------------- ---- may need to be moved as well
| | |
| _____| may need to be moved as well
| |
LL | |
LL | | fn eq(&self, _: &()) -> bool {
LL | | todo!()
LL | | }
LL | | }
| |_____^
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
@ -27,9 +53,22 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl PartialEq<Dog> for () {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: move this `impl` block outside the of the current function `main`
= note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
= note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
help: move this `impl` block outside of the current function `main`
--> $DIR/exhaustive-trait.rs:21:5
|
LL | impl PartialEq<Dog> for () {
| ^ -------------- -- may need to be moved as well
| | |
| _____| may need to be moved as well
| |
LL | |
LL | | fn eq(&self, _: &Dog) -> bool {
LL | | todo!()
LL | | }
LL | | }
| |_____^
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
@ -38,9 +77,22 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl PartialEq<&Dog> for () {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: move this `impl` block outside the of the current function `main`
= note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
= note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
help: move this `impl` block outside of the current function `main`
--> $DIR/exhaustive-trait.rs:28:5
|
LL | impl PartialEq<&Dog> for () {
| ^ --------------- -- may need to be moved as well
| | |
| _____| may need to be moved as well
| |
LL | |
LL | | fn eq(&self, _: &&Dog) -> bool {
LL | | todo!()
LL | | }
LL | | }
| |_____^
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
@ -49,9 +101,22 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl PartialEq<Dog> for &Dog {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: move this `impl` block outside the of the current function `main`
= note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
= note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
help: move this `impl` block outside of the current function `main`
--> $DIR/exhaustive-trait.rs:35:5
|
LL | impl PartialEq<Dog> for &Dog {
| ^ -------------- ---- may need to be moved as well
| | |
| _____| may need to be moved as well
| |
LL | |
LL | | fn eq(&self, _: &Dog) -> bool {
LL | | todo!()
LL | | }
LL | | }
| |_____^
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
@ -60,9 +125,22 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl PartialEq<&Dog> for &Dog {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: move this `impl` block outside the of the current function `main`
= note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
= note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
help: move this `impl` block outside of the current function `main`
--> $DIR/exhaustive-trait.rs:42:5
|
LL | impl PartialEq<&Dog> for &Dog {
| ^ --------------- ---- may need to be moved as well
| | |
| _____| may need to be moved as well
| |
LL | |
LL | | fn eq(&self, _: &&Dog) -> bool {
LL | | todo!()
LL | | }
LL | | }
| |_____^
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: 6 warnings emitted

197
tests/ui/lint/non-local-defs/exhaustive.stderr
View File

@ -4,8 +4,18 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl Test {
| ^^^^^^^^^
|
= help: move this `impl` block outside the of the current function `main`
= note: methods and assoc const are still usable outside the current expression, only `impl Local` and `impl dyn Local` are local and only if the `Local` type is at the same nesting as the `impl` block
help: move this `impl` block outside of the current function `main`
--> $DIR/exhaustive.rs:10:5
|
LL | impl Test {
| ^ ---- may need to be moved as well
| _____|
| |
LL | |
LL | | fn foo() {}
LL | | }
| |_____^
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
= note: `#[warn(non_local_definitions)]` on by default
@ -15,9 +25,22 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl Display for Test {
| ^^^^^^^^^^^^^^^^^^^^^
|
= help: move this `impl` block outside the of the current function `main`
= note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
= note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
help: move this `impl` block outside of the current function `main`
--> $DIR/exhaustive.rs:15:5
|
LL | impl Display for Test {
| ^ ------- ---- may need to be moved as well
| | |
| _____| may need to be moved as well
| |
LL | |
LL | | fn fmt(&self, _f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
LL | | todo!()
LL | | }
LL | | }
| |_____^
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
@ -26,8 +49,14 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl dyn Trait {}
| ^^^^^^^^^^^^^^
|
= help: move this `impl` block outside the of the current function `main`
= note: methods and assoc const are still usable outside the current expression, only `impl Local` and `impl dyn Local` are local and only if the `Local` type is at the same nesting as the `impl` block
help: move this `impl` block outside of the current function `main`
--> $DIR/exhaustive.rs:22:5
|
LL | impl dyn Trait {}
| ^^^^^---------^^^
| |
| may need to be moved as well
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
@ -36,9 +65,16 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl<T: Trait> Trait for Vec<T> { }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: move this `impl` block outside the of the current function `main`
= note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
= note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
help: move this `impl` block outside of the current function `main`
--> $DIR/exhaustive.rs:25:5
|
LL | impl<T: Trait> Trait for Vec<T> { }
| ^^^^^^^^^^^^^^^-----^^^^^------^^^^
| | |
| | may need to be moved as well
| may need to be moved as well
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
@ -47,9 +83,16 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl Trait for &dyn Trait {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: move this `impl` block outside the of the current function `main`
= note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
= note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
help: move this `impl` block outside of the current function `main`
--> $DIR/exhaustive.rs:28:5
|
LL | impl Trait for &dyn Trait {}
| ^^^^^-----^^^^^----------^^^
| | |
| | may need to be moved as well
| may need to be moved as well
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
@ -58,9 +101,16 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl Trait for *mut Test {}
| ^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: move this `impl` block outside the of the current function `main`
= note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
= note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
help: move this `impl` block outside of the current function `main`
--> $DIR/exhaustive.rs:31:5
|
LL | impl Trait for *mut Test {}
| ^^^^^-----^^^^^---------^^^
| | |
| | may need to be moved as well
| may need to be moved as well
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
@ -69,9 +119,16 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl Trait for *mut [Test] {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: move this `impl` block outside the of the current function `main`
= note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
= note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
help: move this `impl` block outside of the current function `main`
--> $DIR/exhaustive.rs:34:5
|
LL | impl Trait for *mut [Test] {}
| ^^^^^-----^^^^^-----------^^^
| | |
| | may need to be moved as well
| may need to be moved as well
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
@ -80,9 +137,16 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl Trait for [Test; 8] {}
| ^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: move this `impl` block outside the of the current function `main`
= note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
= note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
help: move this `impl` block outside of the current function `main`
--> $DIR/exhaustive.rs:37:5
|
LL | impl Trait for [Test; 8] {}
| ^^^^^-----^^^^^---------^^^
| | |
| | may need to be moved as well
| may need to be moved as well
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
@ -91,9 +155,16 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl Trait for (Test,) {}
| ^^^^^^^^^^^^^^^^^^^^^^
|
= help: move this `impl` block outside the of the current function `main`
= note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
= note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
help: move this `impl` block outside of the current function `main`
--> $DIR/exhaustive.rs:40:5
|
LL | impl Trait for (Test,) {}
| ^^^^^-----^^^^^-------^^^
| | |
| | may need to be moved as well
| may need to be moved as well
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
@ -102,9 +173,16 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl Trait for fn(Test) -> () {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: move this `impl` block outside the of the current function `main`
= note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
= note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
help: move this `impl` block outside of the current function `main`
--> $DIR/exhaustive.rs:43:5
|
LL | impl Trait for fn(Test) -> () {}
| ^^^^^-----^^^^^--------------^^^
| | |
| | may need to be moved as well
| may need to be moved as well
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
@ -113,9 +191,16 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl Trait for fn() -> Test {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: move this `impl` block outside the of the current function `main`
= note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
= note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
help: move this `impl` block outside of the current function `main`
--> $DIR/exhaustive.rs:46:5
|
LL | impl Trait for fn() -> Test {}
| ^^^^^-----^^^^^------------^^^
| | |
| | may need to be moved as well
| may need to be moved as well
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
@ -124,9 +209,16 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl Trait for Test {}
| ^^^^^^^^^^^^^^^^^^^
|
= help: move this `impl` block outside the of the current closure `<unnameable>` and up 2 bodies
= note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
= note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
help: move this `impl` block outside of the current closure `<unnameable>` and up 2 bodies
--> $DIR/exhaustive.rs:50:9
|
LL | impl Trait for Test {}
| ^^^^^-----^^^^^----^^^
| | |
| | may need to be moved as well
| may need to be moved as well
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
@ -135,9 +227,16 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl Trait for *mut InsideMain {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: move this `impl` block outside the of the current function `main`
= note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
= note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
help: move this `impl` block outside of the current function `main`
--> $DIR/exhaustive.rs:58:5
|
LL | impl Trait for *mut InsideMain {}
| ^^^^^-----^^^^^---------------^^^
| | |
| | may need to be moved as well
| may need to be moved as well
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
@ -146,9 +245,16 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl Trait for *mut [InsideMain] {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: move this `impl` block outside the of the current function `main`
= note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
= note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
help: move this `impl` block outside of the current function `main`
--> $DIR/exhaustive.rs:60:5
|
LL | impl Trait for *mut [InsideMain] {}
| ^^^^^-----^^^^^-----------------^^^
| | |
| | may need to be moved as well
| may need to be moved as well
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
@ -157,9 +263,16 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl Trait for [InsideMain; 8] {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: move this `impl` block outside the of the current function `main`
= note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
= note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
help: move this `impl` block outside of the current function `main`
--> $DIR/exhaustive.rs:62:5
|
LL | impl Trait for [InsideMain; 8] {}
| ^^^^^-----^^^^^---------------^^^
| | |
| | may need to be moved as well
| may need to be moved as well
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
@ -168,9 +281,16 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl Trait for (InsideMain,) {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: move this `impl` block outside the of the current function `main`
= note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
= note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
help: move this `impl` block outside of the current function `main`
--> $DIR/exhaustive.rs:64:5
|
LL | impl Trait for (InsideMain,) {}
| ^^^^^-----^^^^^-------------^^^
| | |
| | may need to be moved as well
| may need to be moved as well
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
@ -179,9 +299,16 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl Trait for fn(InsideMain) -> () {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: move this `impl` block outside the of the current function `main`
= note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
= note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
help: move this `impl` block outside of the current function `main`
--> $DIR/exhaustive.rs:66:5
|
LL | impl Trait for fn(InsideMain) -> () {}
| ^^^^^-----^^^^^--------------------^^^
| | |
| | may need to be moved as well
| may need to be moved as well
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
@ -190,9 +317,16 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl Trait for fn() -> InsideMain {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: move this `impl` block outside the of the current function `main`
= note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
= note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
help: move this `impl` block outside of the current function `main`
--> $DIR/exhaustive.rs:68:5
|
LL | impl Trait for fn() -> InsideMain {}
| ^^^^^-----^^^^^------------------^^^
| | |
| | may need to be moved as well
| may need to be moved as well
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
@ -201,9 +335,22 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl Display for InsideMain {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: move this `impl` block outside the of the current function `inside_inside` and up 2 bodies
= note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
= note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
help: move this `impl` block outside of the current function `inside_inside` and up 2 bodies
--> $DIR/exhaustive.rs:72:9
|
LL | impl Display for InsideMain {
| ^ ------- ---------- may need to be moved as well
| | |
| _________| may need to be moved as well
| |
LL | |
LL | | fn fmt(&self, _f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
LL | | todo!()
LL | | }
LL | | }
| |_________^
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
@ -212,8 +359,18 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl InsideMain {
| ^^^^^^^^^^^^^^^
|
= help: move this `impl` block outside the of the current function `inside_inside` and up 2 bodies
= note: methods and assoc const are still usable outside the current expression, only `impl Local` and `impl dyn Local` are local and only if the `Local` type is at the same nesting as the `impl` block
help: move this `impl` block outside of the current function `inside_inside` and up 2 bodies
--> $DIR/exhaustive.rs:79:9
|
LL | impl InsideMain {
| ^ ---------- may need to be moved as well
| _________|
| |
LL | |
LL | | fn bar() {}
LL | | }
| |_________^
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: 20 warnings emitted

69
tests/ui/lint/non-local-defs/from-local-for-global.stderr
View File

@ -4,9 +4,22 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl From<Cat> for () {
| ^^^^^^^^^^^^^^^^^^^^^
|
= help: move this `impl` block outside the of the current function `main`
= note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
= note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
help: move this `impl` block outside of the current function `main`
--> $DIR/from-local-for-global.rs:8:5
|
LL | impl From<Cat> for () {
| ^ --------- -- may need to be moved as well
| | |
| _____| may need to be moved as well
| |
LL | |
LL | | fn from(_: Cat) -> () {
LL | | todo!()
LL | | }
LL | | }
| |_____^
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
= note: `#[warn(non_local_definitions)]` on by default
@ -16,9 +29,22 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl From<Wrap<Wrap<Elephant>>> for () {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: move this `impl` block outside the of the current function `main`
= note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
= note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
help: move this `impl` block outside of the current function `main`
--> $DIR/from-local-for-global.rs:18:5
|
LL | impl From<Wrap<Wrap<Elephant>>> for () {
| ^ -------------------------- -- may need to be moved as well
| | |
| _____| may need to be moved as well
| |
LL | |
LL | | fn from(_: Wrap<Wrap<Elephant>>) -> Self {
LL | | todo!()
LL | | }
LL | | }
| |_____^
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
@ -27,9 +53,16 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl StillNonLocal for &Foo {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: move this `impl` block outside the of the current function `only_global`
= note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
= note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
help: move this `impl` block outside of the current function `only_global`
--> $DIR/from-local-for-global.rs:32:5
|
LL | impl StillNonLocal for &Foo {}
| ^^^^^-------------^^^^^----^^^
| | |
| | may need to be moved as well
| may need to be moved as well
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
@ -38,9 +71,22 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl From<Local1> for GlobalSameFunction {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: move this `impl` block outside the of the current function `same_function`
= note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
= note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
help: move this `impl` block outside of the current function `same_function`
--> $DIR/from-local-for-global.rs:40:5
|
LL | impl From<Local1> for GlobalSameFunction {
| ^ ------------ ------------------ may need to be moved as well
| | |
| _____| may need to be moved as well
| |
LL | |
LL | | fn from(x: Local1) -> GlobalSameFunction {
LL | | x.0
LL | | }
LL | | }
| |_____^
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
@ -49,9 +95,22 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl From<Local2> for GlobalSameFunction {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: move this `impl` block outside the of the current function `same_function`
= note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
= note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
help: move this `impl` block outside of the current function `same_function`
--> $DIR/from-local-for-global.rs:48:5
|
LL | impl From<Local2> for GlobalSameFunction {
| ^ ------------ ------------------ may need to be moved as well
| | |
| _____| may need to be moved as well
| |
LL | |
LL | | fn from(x: Local2) -> GlobalSameFunction {
LL | | x.0
LL | | }
LL | | }
| |_____^
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: 5 warnings emitted

100
tests/ui/lint/non-local-defs/generics.stderr
View File

@ -4,9 +4,16 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl<T: Local> Global for Vec<T> { }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: move this `impl` block outside the of the current function `main`
= note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
= note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
help: move this `impl` block outside of the current function `main`
--> $DIR/generics.rs:9:5
|
LL | impl<T: Local> Global for Vec<T> { }
| ^^^^^^^^^^^^^^^------^^^^^------^^^^
| | |
| | may need to be moved as well
| may need to be moved as well
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
= note: `#[warn(non_local_definitions)]` on by default
@ -16,9 +23,16 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl Uto7 for Test where Local: std::any::Any {}
| ^^^^^^^^^^^^^^^^^^
|
= help: move this `impl` block outside the of the current function `bad`
= note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
= note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
help: move this `impl` block outside of the current function `bad`
--> $DIR/generics.rs:20:5
|
LL | impl Uto7 for Test where Local: std::any::Any {}
| ^^^^^----^^^^^----^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| | |
| | may need to be moved as well
| may need to be moved as well
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
@ -27,9 +41,16 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl<T> Uto8 for T {}
| ^^^^^^^^^^^^^^^^^^
|
= help: move this `impl` block outside the of the current function `bad`
= note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
= note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
help: move this `impl` block outside of the current function `bad`
--> $DIR/generics.rs:23:5
|
LL | impl<T> Uto8 for T {}
| ^^^^^^^^----^^^^^-^^^
| | |
| | may need to be moved as well
| may need to be moved as well
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
@ -38,9 +59,22 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl Default for UwU<OwO> {
| ^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: move this `impl` block outside the of the current function `fun`
= note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
= note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
help: move this `impl` block outside of the current function `fun`
--> $DIR/generics.rs:32:5
|
LL | impl Default for UwU<OwO> {
| ^ ------- -------- may need to be moved as well
| | |
| _____| may need to be moved as well
| |
LL | |
LL | | fn default() -> Self {
LL | | UwU(OwO)
LL | | }
LL | | }
| |_____^
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
@ -49,9 +83,20 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl AsRef<Cat> for () {
| ^^^^^^^^^^^^^^^^^^^^^^
|
= help: move this `impl` block outside the of the current function `meow`
= note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
= note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
help: move this `impl` block outside of the current function `meow`
--> $DIR/generics.rs:43:5
|
LL | impl AsRef<Cat> for () {
| ^ ---------- -- may need to be moved as well
| | |
| _____| may need to be moved as well
| |
LL | |
LL | | fn as_ref(&self) -> &Cat { &Cat }
LL | | }
| |_____^
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
@ -60,9 +105,22 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl PartialEq<B> for G {
| ^^^^^^^^^^^^^^^^^^^^^^^
|
= help: move this `impl` block outside the of the current function `fun2`
= note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
= note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
help: move this `impl` block outside of the current function `fun2`
--> $DIR/generics.rs:54:5
|
LL | impl PartialEq<B> for G {
| ^ ------------ - may need to be moved as well
| | |
| _____| may need to be moved as well
| |
LL | |
LL | | fn eq(&self, _: &B) -> bool {
LL | | true
LL | | }
LL | | }
| |_____^
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
@ -71,9 +129,22 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl From<Wrap<Wrap<Lion>>> for () {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: move this `impl` block outside the of the current function `rawr`
= note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
= note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
help: move this `impl` block outside of the current function `rawr`
--> $DIR/generics.rs:69:5
|
LL | impl From<Wrap<Wrap<Lion>>> for () {
| ^ ---------------------- -- may need to be moved as well
| | |
| _____| may need to be moved as well
| |
LL | |
LL | | fn from(_: Wrap<Wrap<Lion>>) -> Self {
LL | | todo!()
LL | | }
LL | | }
| |_____^
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
@ -82,9 +153,22 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl From<()> for Wrap<Lion> {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: move this `impl` block outside the of the current function `rawr`
= note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
= note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
help: move this `impl` block outside of the current function `rawr`
--> $DIR/generics.rs:76:5
|
LL | impl From<()> for Wrap<Lion> {
| ^ -------- ---------- may need to be moved as well
| | |
| _____| may need to be moved as well
| |
LL | |
LL | | fn from(_: ()) -> Self {
LL | | todo!()
LL | | }
LL | | }
| |_____^
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: 8 warnings emitted

12
tests/ui/lint/non-local-defs/inside-macro_rules.stderr
View File

@ -7,9 +7,19 @@ LL | impl MacroTrait for OutsideStruct {}
LL | m!();
| ---- in this macro invocation
|
= help: move this `impl` block outside the of the current function `my_func`
= note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
= note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
help: move this `impl` block outside of the current function `my_func`
--> $DIR/inside-macro_rules.rs:9:13
|
LL | impl MacroTrait for OutsideStruct {}
| ^^^^^----------^^^^^-------------^^^
| | |
| | may need to be moved as well
| may need to be moved as well
...
LL | m!();
| ---- in this macro invocation
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
= note: `#[warn(non_local_definitions)]` on by default
= note: this warning originates in the macro `m` (in Nightly builds, run with -Z macro-backtrace for more info)

9
tests/ui/lint/non-local-defs/trait-solver-overflow-123573.stderr
View File

@ -4,9 +4,16 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl Test for &Local {}
| ^^^^^^^^^^^^^^^^^^^^
|
= help: move this `impl` block outside the of the current function `main`
= note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
= note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
help: move this `impl` block outside of the current function `main`
--> $DIR/trait-solver-overflow-123573.rs:12:5
|
LL | impl Test for &Local {}
| ^^^^^----^^^^^------^^^
| | |
| | may need to be moved as well
| may need to be moved as well
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
= note: `#[warn(non_local_definitions)]` on by default

57
tests/ui/lint/non-local-defs/weird-exprs.stderr
View File

@ -4,9 +4,16 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl Uto for *mut Test {}
| ^^^^^^^^^^^^^^^^^^^^^^
|
= help: move this `impl` block outside the of the current constant expression `<unnameable>`
= note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
= note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
help: move this `impl` block outside of the current constant expression `<unnameable>`
--> $DIR/weird-exprs.rs:8:5
|
LL | impl Uto for *mut Test {}
| ^^^^^---^^^^^---------^^^
| | |
| | may need to be moved as well
| may need to be moved as well
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
= note: `#[warn(non_local_definitions)]` on by default
@ -16,9 +23,16 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl Uto for Test {}
| ^^^^^^^^^^^^^^^^^
|
= help: move this `impl` block outside the of the current constant expression `<unnameable>`
= note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
= note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
help: move this `impl` block outside of the current constant expression `<unnameable>`
--> $DIR/weird-exprs.rs:16:9
|
LL | impl Uto for Test {}
| ^^^^^---^^^^^----^^^
| | |
| | may need to be moved as well
| may need to be moved as well
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
@ -27,8 +41,18 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl Test {
| ^^^^^^^^^
|
= help: move this `impl` block outside the of the current constant expression `<unnameable>` and up 2 bodies
= note: methods and assoc const are still usable outside the current expression, only `impl Local` and `impl dyn Local` are local and only if the `Local` type is at the same nesting as the `impl` block
help: move this `impl` block outside of the current constant expression `<unnameable>` and up 2 bodies
--> $DIR/weird-exprs.rs:25:9
|
LL | impl Test {
| ^ ---- may need to be moved as well
| _________|
| |
LL | |
LL | | fn bar() {}
LL | | }
| |_________^
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
@ -37,9 +61,16 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl Uto for &Test {}
| ^^^^^^^^^^^^^^^^^^
|
= help: move this `impl` block outside the of the current constant expression `<unnameable>` and up 2 bodies
= note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
= note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
help: move this `impl` block outside of the current constant expression `<unnameable>` and up 2 bodies
--> $DIR/weird-exprs.rs:34:9
|
LL | impl Uto for &Test {}
| ^^^^^---^^^^^-----^^^
| | |
| | may need to be moved as well
| may need to be moved as well
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
@ -48,9 +79,16 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl Uto for &(Test,) {}
| ^^^^^^^^^^^^^^^^^^^^^
|
= help: move this `impl` block outside the of the current constant expression `<unnameable>` and up 2 bodies
= note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
= note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
help: move this `impl` block outside of the current constant expression `<unnameable>` and up 2 bodies
--> $DIR/weird-exprs.rs:41:9
|
LL | impl Uto for &(Test,) {}
| ^^^^^---^^^^^--------^^^
| | |
| | may need to be moved as well
| may need to be moved as well
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
@ -59,9 +97,16 @@ warning: non-local `impl` definition, `impl` blocks should be written at the sam
LL | impl Uto for &(Test,Test) {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: move this `impl` block outside the of the current constant expression `<unnameable>` and up 2 bodies
= note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
= note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
help: move this `impl` block outside of the current constant expression `<unnameable>` and up 2 bodies
--> $DIR/weird-exprs.rs:48:9
|
LL | impl Uto for &(Test,Test) {}
| ^^^^^---^^^^^------------^^^
| | |
| | may need to be moved as well
| may need to be moved as well
= note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
warning: 6 warnings emitted