exhaustive.stderr

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
  --> $DIR/exhaustive.rs:10:5
   |
LL |     impl Test {
   |     ^^^^^^^^^
   |
   = note: methods and associated constants are still usable outside the current expression, only `impl Local` and `impl dyn Local` can ever be private, and only if the type is nested in the same item as the `impl`
help: move this `impl` block outside of the current function `main`
  --> $DIR/exhaustive.rs:10:5
   |
LL | /     impl Test {
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

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
  --> $DIR/exhaustive.rs:15:5
   |
LL |     impl Display for Test {
   |     ^^^^^^^^^^^^^^^^^^^^^
   |
   = 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 {
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
  --> $DIR/exhaustive.rs:22:5
   |
LL |     impl dyn Trait {}
   |     ^^^^^^^^^^^^^^
   |
   = note: methods and associated constants are still usable outside the current expression, only `impl Local` and `impl dyn Local` can ever be private, and only if the type is nested in the same item as the `impl`
help: move this `impl` block outside of the current function `main`
  --> $DIR/exhaustive.rs:22:5
   |
LL |     impl dyn Trait {}
   |     ^^^^^^^^^^^^^^^^^
   = 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
  --> $DIR/exhaustive.rs:25:5
   |
LL |     impl<T: Trait> Trait for Vec<T> { }
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = 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> { }
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   = 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
  --> $DIR/exhaustive.rs:28:5
   |
LL |     impl Trait for &dyn Trait {}
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = 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 {}
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   = 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
  --> $DIR/exhaustive.rs:31:5
   |
LL |     impl Trait for *mut Test {}
   |     ^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = 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 {}
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
   = 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
  --> $DIR/exhaustive.rs:34:5
   |
LL |     impl Trait for *mut [Test] {}
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = 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] {}
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   = 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
  --> $DIR/exhaustive.rs:37:5
   |
LL |     impl Trait for [Test; 8] {}
   |     ^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = 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] {}
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
   = 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
  --> $DIR/exhaustive.rs:40:5
   |
LL |     impl Trait for (Test,) {}
   |     ^^^^^^^^^^^^^^^^^^^^^^
   |
   = 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,) {}
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
   = 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
  --> $DIR/exhaustive.rs:43:5
   |
LL |     impl Trait for fn(Test) -> () {}
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = 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) -> () {}
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   = 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
  --> $DIR/exhaustive.rs:46:5
   |
LL |     impl Trait for fn() -> Test {}
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = 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 {}
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   = 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
  --> $DIR/exhaustive.rs:50:9
   |
LL |         impl Trait for Test {}
   |         ^^^^^^^^^^^^^^^^^^^
   |
   = 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 {}
   |         ^^^^^^^^^^^^^^^^^^^^^^
   = 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
  --> $DIR/exhaustive.rs:58:5
   |
LL |     impl Trait for *mut InsideMain {}
   |     ^^^^^^^^^^^^^^^-----^^^^^^^^^^
   |                    |
   |                    help: remove `*mut ` to make the `impl` local
   |
   = 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
   = 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
  --> $DIR/exhaustive.rs:60:5
   |
LL |     impl Trait for *mut [InsideMain] {}
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = 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
   = 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
  --> $DIR/exhaustive.rs:62:5
   |
LL |     impl Trait for [InsideMain; 8] {}
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = 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
   = 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
  --> $DIR/exhaustive.rs:64:5
   |
LL |     impl Trait for (InsideMain,) {}
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = 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
   = 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
  --> $DIR/exhaustive.rs:66:5
   |
LL |     impl Trait for fn(InsideMain) -> () {}
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = 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
   = 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
  --> $DIR/exhaustive.rs:68:5
   |
LL |     impl Trait for fn() -> InsideMain {}
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = 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
   = 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
  --> $DIR/exhaustive.rs:72:9
   |
LL |         impl Display for InsideMain {
   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = 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 {
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
  --> $DIR/exhaustive.rs:79:9
   |
LL |         impl InsideMain {
   |         ^^^^^^^^^^^^^^^
   |
   = note: methods and associated constants are still usable outside the current expression, only `impl Local` and `impl dyn Local` can ever be private, and only if the type is nested in the same item as the `impl`
help: move this `impl` block outside of the current function `inside_inside` and up 2 bodies
  --> $DIR/exhaustive.rs:79:9
   |
LL | /         impl InsideMain {
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