The following actions uses Node.js version which is deprecated and will be forced to run on node20: actions/checkout@v3. For more info: https://github.blog/changelog/2024-03-07-github-actions-all-actions-will-run-on-node20-instead-of-node16-by-default/

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:7722:51 | 7722 | Debug, Default, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone, | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_EspiSioAccessWidth` ... 7727 | pub enum EspiSioAccessWidth { | ------------------ `EspiSioAccessWidth` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:7722:36 | 7722 | Debug, Default, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone, | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_EspiSioAccessWidth` ... 7727 | pub enum EspiSioAccessWidth { | ------------------ `EspiSioAccessWidth` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:7538:47 | 7538 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Clone, Copy)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_EspiInitAlertMode` ... 7542 | pub enum EspiInitAlertMode { | ----------------- `EspiInitAlertMode` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:7538:32 | 7538 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Clone, Copy)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_EspiInitAlertMode` ... 7542 | pub enum EspiInitAlertMode { | ----------------- `EspiInitAlertMode` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:7527:47 | 7527 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Clone, Copy)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_EspiInitIoMode` ... 7531 | pub enum EspiInitIoMode { | -------------- `EspiInitIoMode` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:7527:32 | 7527 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Clone, Copy)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_EspiInitIoMode` ... 7531 | pub enum EspiInitIoMode { | -------------- `EspiInitIoMode` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:7513:47 | 7513 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Clone, Copy)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_EspiInitClockFrequency` ... 7517 | pub enum EspiInitClockFrequency { | ---------------------- `EspiInitClockFrequency` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:7513:32 | 7513 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Clone, Copy)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_EspiInitClockFrequency` ... 7517 | pub enum EspiInitClockFrequency { | ---------------------- `EspiInitClockFrequency` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:7503:47 | 7503 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Clone, Copy)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_EspiInitCsPinSelect` ... 7507 | pub enum EspiInitCsPinSelect { | ------------------- `EspiInitCsPinSelect` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:7503:32 | 7503 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Clone, Copy)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_EspiInitCsPinSelect` ... 7507 | pub enum EspiInitCsPinSelect { | ------------------- `EspiInitCsPinSelect` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:7493:47 | 7493 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Clone, Copy)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_EspiInitClockPinSelect` ... 7497 | pub enum EspiInitClockPinSelect { | ---------------------- `EspiInitClockPinSelect` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:7493:32 | 7493 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Clone, Copy)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_EspiInitClockPinSelect` ... 7497 | pub enum EspiInitClockPinSelect { | ---------------------- `EspiInitClockPinSelect` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:7483:47 | 7483 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Clone, Copy)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_EspiInitDataBusSelect` ... 7487 | pub enum EspiInitDataBusSelect { | --------------------- `EspiInitDataBusSelect` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:7483:32 | 7483 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Clone, Copy)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_EspiInitDataBusSelect` ... 7487 | pub enum EspiInitDataBusSelect { | --------------------- `EspiInitDataBusSelect` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:6983:67 | 6983 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_MotherboardLayerCount` ... 6987 | pub enum MotherboardLayerCount { | --------------------- `MotherboardLayerCount` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:6983:52 | 6983 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_MotherboardLayerCount` ... 6987 | pub enum MotherboardLayerCount { | --------------------- `MotherboardLayerCount` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:6935:67 | 6935 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_MemPowerPolicyType` ... 6939 | pub enum MemPowerPolicyType { | ------------------ `MemPowerPolicyType` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:6935:52 | 6935 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_MemPowerPolicyType` ... 6939 | pub enum MemPowerPolicyType { | ------------------ `MemPowerPolicyType` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:6587:67 | 6587 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_MemTechnologyType` ... 6592 | pub enum MemTechnologyType { | ----------------- `MemTechnologyType` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:6587:52 | 6587 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_MemTechnologyType` ... 6592 | pub enum MemTechnologyType { | ----------------- `MemTechnologyType` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:6474:67 | 6474 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_MemBusSpeedType` ... 6478 | pub enum MemBusSpeedType { // in MHz | --------------- `MemBusSpeedType` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:6474:52 | 6474 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_MemBusSpeedType` ... 6478 | pub enum MemBusSpeedType { // in MHz | --------------- `MemBusSpeedType` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:6464:67 | 6464 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_TimingMode` ... 6468 | pub enum TimingMode { | ---------- `TimingMode` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:6464:52 | 6464 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_TimingMode` ... 6468 | pub enum TimingMode { | ---------- `TimingMode` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:5363:47 | 5363 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_Ddr5RawCardVref` ... 5368 | pub enum Ddr5RawCardVref { | --------------- `Ddr5RawCardVref` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:5363:32 | 5363 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_Ddr5RawCardVref` ... 5368 | pub enum Ddr5RawCardVref { | --------------- `Ddr5RawCardVref` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:5350:47 | 5350 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_Ddr5RawCardSlew` ... 5355 | pub enum Ddr5RawCardSlew { | --------------- `Ddr5RawCardSlew` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:5350:32 | 5350 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_Ddr5RawCardSlew` ... 5355 | pub enum Ddr5RawCardSlew { | --------------- `Ddr5RawCardSlew` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:5339:47 | 5339 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_Ddr5RawCardDriveStrength` ... 5344 | pub enum Ddr5RawCardDriveStrength { | ------------------------ `Ddr5RawCardDriveStrength` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:5339:32 | 5339 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_Ddr5RawCardDriveStrength` ... 5344 | pub enum Ddr5RawCardDriveStrength { | ------------------------ `Ddr5RawCardDriveStrength` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:5237:47 | 5237 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_Ddr5RawCardImpedance` ... 5242 | pub enum Ddr5RawCardImpedance { | -------------------- `Ddr5RawCardImpedance` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:5237:32 | 5237 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_Ddr5RawCardImpedance` ... 5242 | pub enum Ddr5RawCardImpedance { | -------------------- `Ddr5RawCardImpedance` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:4472:47 | 4472 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_ErrorOutControlBeepCodeErrorType` ... 4477 | pub enum ErrorOutControlBeepCodeErrorType { | -------------------------------- `ErrorOutControlBeepCodeErrorType` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:4472:32 | 4472 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_ErrorOutControlBeepCodeErrorType` ... 4477 | pub enum ErrorOutControlBeepCodeErrorType { | -------------------------------- `ErrorOutControlBeepCodeErrorType` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:4153:47 | 4153 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_DdrSpeed` ... 4157 | pub enum DdrSpeed { | -------- `DdrSpeed` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:4153:32 | 4153 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_DdrSpeed` ... 4157 | pub enum DdrSpeed { | -------- `DdrSpeed` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:3425:29 | 3425 | #[derive(FromPrimitive, ToPrimitive, Clone, Copy)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_VrefDqRange2` ... 3429 | pub enum VrefDqRange2 { | ------------ `VrefDqRange2` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:3425:14 | 3425 | #[derive(FromPrimitive, ToPrimitive, Clone, Copy)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_VrefDqRange2` ... 3429 | pub enum VrefDqRange2 { | ------------ `VrefDqRange2` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:3316:29 | 3316 | #[derive(FromPrimitive, ToPrimitive, Clone, Copy)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_VrefDqRange1` ... 3320 | pub enum VrefDqRange1 { | ------------ `VrefDqRange1` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:3316:14 | 3316 | #[derive(FromPrimitive, ToPrimitive, Clone, Copy)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_VrefDqRange1` ... 3320 | pub enum VrefDqRange1 { | ------------ `VrefDqRange1` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:3298:47 | 3298 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_RttWr` ... 3302 | pub enum RttWr { | ----- `RttWr` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:3298:32 | 3298 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_RttWr` ... 3302 | pub enum RttWr { | ----- `RttWr` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:3268:47 | 3268 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_RttNom` ... 3272 | pub enum RttNom { | ------ `RttNom` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:3268:32 | 3268 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_RttNom` ... 3272 | pub enum RttNom { | ------ `RttNom` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:2728:53 | 2728 | #[derive(Clone, Copy, PartialEq, FromPrimitive, ToPrimitive)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_CadBusClkDriveStrength` ... 2733 | pub enum CadBusClkDriveStrength { | ---------------------- `CadBusClkDriveStrength` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:2728:38 | 2728 | #[derive(Clone, Copy, PartialEq, FromPrimitive, ToPrimitive)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_CadBusClkDriveStrength` ... 2733 | pub enum CadBusClkDriveStrength { | ---------------------- `CadBusClkDriveStrength` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:2570:51 | 2570 | Debug, Default, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone, | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_PortSize` ... 2575 | pub enum PortSize { | -------- `PortSize` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:2570:36 | 2570 | Debug, Default, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone, | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_PortSize` ... 2575 | pub enum PortSize { | -------- `PortSize` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:2555:51 | 2555 | Debug, Default, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone, | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_PortType` ... 2560 | pub enum PortType { | -------- `PortType` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:2555:36 | 2555 | Debug, Default, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone, | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_PortType` ... 2560 | pub enum PortType { | -------- `PortType` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:2024:47 | 2024 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_SlinkRegionInterleavingSize` ... 2029 | pub enum SlinkRegionInterleavingSize { | --------------------------- `SlinkRegionInterleavingSize` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:2024:32 | 2024 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_SlinkRegionInterleavingSize` ... 2029 | pub enum SlinkRegionInterleavingSize { | --------------------------- `SlinkRegionInterleavingSize` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:1531:9 | 1531 | ToPrimitive, | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_EarlyPcieResetPin` ... 1539 | pub enum EarlyPcieResetPin { | ----------------- `EarlyPcieResetPin` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:1530:9 | 1530 | FromPrimitive, | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_EarlyPcieResetPin` ... 1539 | pub enum EarlyPcieResetPin { | ----------------- `EarlyPcieResetPin` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:1505:9 | 1505 | ToPrimitive, | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_EarlyPcieLinkSpeed` ... 1513 | pub enum EarlyPcieLinkSpeed { | ------------------ `EarlyPcieLinkSpeed` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:1504:9 | 1504 | FromPrimitive, | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_EarlyPcieLinkSpeed` ... 1513 | pub enum EarlyPcieLinkSpeed { | ------------------ `EarlyPcieLinkSpeed` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:10159:43 | 10159 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_FchMp1WarnRstAckMode` ... 10163 | pub enum FchMp1WarnRstAckMode { | -------------------- `FchMp1WarnRstAckMode` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:10159:28 | 10159 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_FchMp1WarnRstAckMode` ... 10163 | pub enum FchMp1WarnRstAckMode { | -------------------- `FchMp1WarnRstAckMode` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:10119:43 | 10119 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_DfPdrTuningMode` ... 10123 | pub enum DfPdrTuningMode { | --------------- `DfPdrTuningMode` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:10119:28 | 10119 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_DfPdrTuningMode` ... 10123 | pub enum DfPdrTuningMode { | --------------- `DfPdrTuningMode` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:10108:43 | 10108 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_MemSelfHealing` ... 10112 | pub enum MemSelfHealing { | -------------- `MemSelfHealing` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:10108:28 | 10108 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_MemSelfHealing` ... 10112 | pub enum MemSelfHealing { | -------------- `MemSelfHealing` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:10098:43 | 10098 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_MemMbistPerBitSlaveDieReportDdr` ... 10102 | pub enum MemMbistPerBitSlaveDieReportDdr { | ------------------------------- `MemMbistPerBitSlaveDieReportDdr` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:10098:28 | 10098 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_MemMbistPerBitSlaveDieReportDdr` ... 10102 | pub enum MemMbistPerBitSlaveDieReportDdr { | ------------------------------- `MemMbistPerBitSlaveDieReportDdr` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:10088:43 | 10088 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_MemMbistAggressorsChannelDdrMode` ... 10092 | pub enum MemMbistAggressorsChannelDdrMode { | -------------------------------- `MemMbistAggressorsChannelDdrMode` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:10088:28 | 10088 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_MemMbistAggressorsChannelDdrMode` ... 10092 | pub enum MemMbistAggressorsChannelDdrMode { | -------------------------------- `MemMbistAggressorsChannelDdrMode` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:10078:43 | 10078 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_MemMbistDdrMode` ... 10082 | pub enum MemMbistDdrMode { | --------------- `MemMbistDdrMode` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:10078:28 | 10078 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_MemMbistDdrMode` ... 10082 | pub enum MemMbistDdrMode { | --------------- `MemMbistDdrMode` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:10069:43 | 10069 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_FchSpdControlOwnershipMode` ... 10073 | pub enum FchSpdControlOwnershipMode { | -------------------------- `FchSpdControlOwnershipMode` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:10069:28 | 10069 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_FchSpdControlOwnershipMode` ... 10073 | pub enum FchSpdControlOwnershipMode { | -------------------------- `FchSpdControlOwnershipMode` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:10060:43 | 10060 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_FchI2cMode` ... 10064 | pub enum FchI2cMode { | ---------- `FchI2cMode` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:10060:28 | 10060 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_FchI2cMode` ... 10064 | pub enum FchI2cMode { | ---------- `FchI2cMode` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:10047:43 | 10047 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_FchI2cI3cSmbusSelect` ... 10051 | pub enum FchI2cI3cSmbusSelect { | -------------------- `FchI2cI3cSmbusSelect` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:10047:28 | 10047 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_FchI2cI3cSmbusSelect` ... 10051 | pub enum FchI2cI3cSmbusSelect { | -------------------- `FchI2cI3cSmbusSelect` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:10036:43 | 10036 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_FchI2cI3cControllerMode` ... 10040 | pub enum FchI2cI3cControllerMode { | ----------------------- `FchI2cI3cControllerMode` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:10036:28 | 10036 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_FchI2cI3cControllerMode` ... 10040 | pub enum FchI2cI3cControllerMode { | ----------------------- `FchI2cI3cControllerMode` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:10027:43 | 10027 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_FchI3cSdaHoldOverrideMode` ... 10031 | pub enum FchI3cSdaHoldOverrideMode { | ------------------------- `FchI3cSdaHoldOverrideMode` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:10027:28 | 10027 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_FchI3cSdaHoldOverrideMode` ... 10031 | pub enum FchI3cSdaHoldOverrideMode { | ------------------------- `FchI3cSdaHoldOverrideMode` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:10018:43 | 10018 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_FchI2cSdaHoldOverrideMode` ... 10022 | pub enum FchI2cSdaHoldOverrideMode { | ------------------------- `FchI2cSdaHoldOverrideMode` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:10018:28 | 10018 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_FchI2cSdaHoldOverrideMode` ... 10022 | pub enum FchI2cSdaHoldOverrideMode { | ------------------------- `FchI2cSdaHoldOverrideMode` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:10008:43 | 10008 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_MemRcdParityMode` ... 10012 | pub enum MemRcdParityMode { | ---------------- `MemRcdParityMode` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:10008:28 | 10008 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_MemRcdParityMode` ... 10012 | pub enum MemRcdParityMode { | ---------------- `MemRcdParityMode` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:9999:43 | 9999 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_MemOdtsCmdThrottleMode` ... 10003 | pub enum MemOdtsCmdThrottleMode { | ---------------------- `MemOdtsCmdThrottleMode` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:9999:28 | 9999 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_MemOdtsCmdThrottleMode` ... 10003 | pub enum MemOdtsCmdThrottleMode { | ---------------------- `MemOdtsCmdThrottleMode` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:9990:43 | 9990 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_MemPopulationMsgControlMode` ... 9994 | pub enum MemPopulationMsgControlMode { | --------------------------- `MemPopulationMsgControlMode` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:9990:28 | 9990 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_MemPopulationMsgControlMode` ... 9994 | pub enum MemPopulationMsgControlMode { | --------------------------- `MemPopulationMsgControlMode` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:9981:43 | 9981 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_MemPmuTrainingResultOutput` ... 9985 | pub enum MemPmuTrainingResultOutput { | -------------------------- `MemPmuTrainingResultOutput` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:9981:28 | 9981 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_MemPmuTrainingResultOutput` ... 9985 | pub enum MemPmuTrainingResultOutput { | -------------------------- `MemPmuTrainingResultOutput` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:9972:43 | 9972 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_DfXgmiPresetControlMode` ... 9976 | pub enum DfXgmiPresetControlMode { | ----------------------- `DfXgmiPresetControlMode` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:9972:28 | 9972 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_DfXgmiPresetControlMode` ... 9976 | pub enum DfXgmiPresetControlMode { | ----------------------- `DfXgmiPresetControlMode` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:9963:43 | 9963 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_ReservedDramModuleDrtmMode` ... 9967 | pub enum ReservedDramModuleDrtmMode { | -------------------------- `ReservedDramModuleDrtmMode` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:9963:28 | 9963 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_ReservedDramModuleDrtmMode` ... 9967 | pub enum ReservedDramModuleDrtmMode { | -------------------------- `ReservedDramModuleDrtmMode` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:9954:43 | 9954 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_MemTccd5ReadCommandSpacingMode` ... 9958 | pub enum MemTccd5ReadCommandSpacingMode { | ------------------------------ `MemTccd5ReadCommandSpacingMode` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:9954:28 | 9954 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_MemTccd5ReadCommandSpacingMode` ... 9958 | pub enum MemTccd5ReadCommandSpacingMode { | ------------------------------ `MemTccd5ReadCommandSpacingMode` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:9943:43 | 9943 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_PspApmlSbtsiSlaveMode` ... 9947 | pub enum PspApmlSbtsiSlaveMode { | --------------------- `PspApmlSbtsiSlaveMode` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:9943:28 | 9943 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_PspApmlSbtsiSlaveMode` ... 9947 | pub enum PspApmlSbtsiSlaveMode { | --------------------- `PspApmlSbtsiSlaveMode` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:9934:43 | 9934 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_PspSevMode` ... 9938 | pub enum PspSevMode { | ---------- `PspSevMode` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:9934:28 | 9934 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_PspSevMode` ... 9938 | pub enum PspSevMode { | ---------- `PspSevMode` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:9924:43 | 9924 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_GnbAdditionalFeatureDsmDetector` ... 9928 | pub enum GnbAdditionalFeatureDsmDetector { | ------------------------------- `GnbAdditionalFeatureDsmDetector` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:9924:28 | 9924 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_GnbAdditionalFeatureDsmDetector` ... 9928 | pub enum GnbAdditionalFeatureDsmDetector { | ------------------------------- `GnbAdditionalFeatureDsmDetector` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:9914:43 | 9914 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_GnbAdditionalFeatureDsm` ... 9918 | pub enum GnbAdditionalFeatureDsm { | ----------------------- `GnbAdditionalFeatureDsm` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:9914:28 | 9914 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_GnbAdditionalFeatureDsm` ... 9918 | pub enum GnbAdditionalFeatureDsm { | ----------------------- `GnbAdditionalFeatureDsm` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:9844:47 | 9844 | Debug, Default, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone, | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_EspiController` ... 9849 | pub enum EspiController { | -------------- `EspiController` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:9844:32 | 9844 | Debug, Default, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone, | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_EspiController` ... 9849 | pub enum EspiController { | -------------- `EspiController` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:9744:43 | 9744 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_PspEnableDebugMode` ... 9748 | pub enum PspEnableDebugMode { | ------------------ `PspEnableDebugMode` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:9744:28 | 9744 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_PspEnableDebugMode` ... 9748 | pub enum PspEnableDebugMode { | ------------------ `PspEnableDebugMode` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:9724:43 | 9724 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_MemTrainingHdtControl` ... 9728 | pub enum MemTrainingHdtControl { | --------------------- `MemTrainingHdtControl` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:9724:28 | 9724 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_MemTrainingHdtControl` ... 9728 | pub enum MemTrainingHdtControl { | --------------------- `MemTrainingHdtControl` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:9545:43 | 9545 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_CbsMemSpeedDdr4` ... 9549 | pub enum CbsMemSpeedDdr4 { | --------------- `CbsMemSpeedDdr4` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:9545:28 | 9545 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_CbsMemSpeedDdr4` ... 9549 | pub enum CbsMemSpeedDdr4 { | --------------- `CbsMemSpeedDdr4` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:9534:43 | 9534 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_MemHealBistEnable` ... 9538 | pub enum MemHealBistEnable { | ----------------- `MemHealBistEnable` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:9534:28 | 9534 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_MemHealBistEnable` ... 9538 | pub enum MemHealBistEnable { | ----------------- `MemHealBistEnable` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:9399:43 | 9399 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_MemClockValue` ... 9404 | pub enum MemClockValue { | ------------- `MemClockValue` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:9399:28 | 9399 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_MemClockValue` ... 9404 | pub enum MemClockValue { | ------------- `MemClockValue` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:9378:43 | 9378 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_MemTargetSpeed` ... 9382 | pub enum MemTargetSpeed { | -------------- `MemTargetSpeed` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:9378:28 | 9378 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_MemTargetSpeed` ... 9382 | pub enum MemTargetSpeed { | -------------- `MemTargetSpeed` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:9171:43 | 9171 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_EccSymbolSize` ... 9175 | pub enum EccSymbolSize { | ------------- `EccSymbolSize` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:9171:28 | 9171 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_EccSymbolSize` ... 9175 | pub enum EccSymbolSize { | ------------- `EccSymbolSize` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:9160:43 | 9160 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_BmcRcbCheckingMode` ... 9164 | pub enum BmcRcbCheckingMode { | ------------------ `BmcRcbCheckingMode` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:9160:28 | 9160 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_BmcRcbCheckingMode` ... 9164 | pub enum BmcRcbCheckingMode { | ------------------ `BmcRcbCheckingMode` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:9148:43 | 9148 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_BmcGen2TxDeemphasis` ... 9152 | pub enum BmcGen2TxDeemphasis { | ------------------- `BmcGen2TxDeemphasis` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:9148:28 | 9148 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_BmcGen2TxDeemphasis` ... 9152 | pub enum BmcGen2TxDeemphasis { | ------------------- `BmcGen2TxDeemphasis` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:9132:43 | 9132 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_DfSysStorageAtTopOfMem` ... 9136 | pub enum DfSysStorageAtTopOfMem { | ---------------------- `DfSysStorageAtTopOfMem` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:9132:28 | 9132 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_DfSysStorageAtTopOfMem` ... 9136 | pub enum DfSysStorageAtTopOfMem { | ---------------------- `DfSysStorageAtTopOfMem` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:9065:43 | 9065 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_DfXgmiLinkMaxSpeed` ... 9069 | pub enum DfXgmiLinkMaxSpeed { | ------------------ `DfXgmiLinkMaxSpeed` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:9065:28 | 9065 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_DfXgmiLinkMaxSpeed` ... 9069 | pub enum DfXgmiLinkMaxSpeed { | ------------------ `DfXgmiLinkMaxSpeed` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:9052:43 | 9052 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_DfXgmiTxEqMode` ... 9056 | pub enum DfXgmiTxEqMode { | -------------- `DfXgmiTxEqMode` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:9052:28 | 9052 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_DfXgmiTxEqMode` ... 9056 | pub enum DfXgmiTxEqMode { | -------------- `DfXgmiTxEqMode` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:9024:43 | 9024 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_MemMbistDataEyeType` ... 9028 | pub enum MemMbistDataEyeType { | ------------------- `MemMbistDataEyeType` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:9024:28 | 9024 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_MemMbistDataEyeType` ... 9028 | pub enum MemMbistDataEyeType { | ------------------- `MemMbistDataEyeType` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:9013:43 | 9013 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_MemHealingBistRepairTypeDdr` ... 9017 | pub enum MemHealingBistRepairTypeDdr { | --------------------------- `MemHealingBistRepairTypeDdr` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:9013:28 | 9013 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_MemHealingBistRepairTypeDdr` ... 9017 | pub enum MemHealingBistRepairTypeDdr { | --------------------------- `MemHealingBistRepairTypeDdr` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:9002:43 | 9002 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_MemMbistTestMode` ... 9006 | pub enum MemMbistTestMode { | ---------------- `MemMbistTestMode` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:9002:28 | 9002 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_MemMbistTestMode` ... 9006 | pub enum MemMbistTestMode { | ---------------- `MemMbistTestMode` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8976:43 | 8976 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_MemMbistAggressorsChannels` ... 8980 | pub enum MemMbistAggressorsChannels { | -------------------------- `MemMbistAggressorsChannels` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8976:28 | 8976 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_MemMbistAggressorsChannels` ... 8980 | pub enum MemMbistAggressorsChannels { | -------------------------- `MemMbistAggressorsChannels` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8964:43 | 8964 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_MemMbistPatternSelect` ... 8968 | pub enum MemMbistPatternSelect { | --------------------- `MemMbistPatternSelect` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8964:28 | 8964 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_MemMbistPatternSelect` ... 8968 | pub enum MemMbistPatternSelect { | --------------------- `MemMbistPatternSelect` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8955:43 | 8955 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_MemMbistTest` ... 8959 | pub enum MemMbistTest { | ------------ `MemMbistTest` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8955:28 | 8955 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_MemMbistTest` ... 8959 | pub enum MemMbistTest { | ------------ `MemMbistTest` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8945:43 | 8945 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_UmaMode` ... 8949 | pub enum UmaMode { | ------- `UmaMode` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8945:28 | 8945 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_UmaMode` ... 8949 | pub enum UmaMode { | ------- `UmaMode` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8929:43 | 8929 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_MemControllerPmuTrainingMode` ... 8933 | pub enum MemControllerPmuTrainingMode { | ---------------------------- `MemControllerPmuTrainingMode` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8929:28 | 8929 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_MemControllerPmuTrainingMode` ... 8933 | pub enum MemControllerPmuTrainingMode { | ---------------------------- `MemControllerPmuTrainingMode` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8918:43 | 8918 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_MemControllerPmuTrainDfeDdr4` ... 8922 | pub enum MemControllerPmuTrainDfeDdr4 { | ---------------------------- `MemControllerPmuTrainDfeDdr4` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8918:28 | 8918 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_MemControllerPmuTrainDfeDdr4` ... 8922 | pub enum MemControllerPmuTrainDfeDdr4 { | ---------------------------- `MemControllerPmuTrainDfeDdr4` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8908:43 | 8908 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_MemControllerPmuTrainFfeDdr4` ... 8912 | pub enum MemControllerPmuTrainFfeDdr4 { | ---------------------------- `MemControllerPmuTrainFfeDdr4` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8908:28 | 8908 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_MemControllerPmuTrainFfeDdr4` ... 8912 | pub enum MemControllerPmuTrainFfeDdr4 { | ---------------------------- `MemControllerPmuTrainFfeDdr4` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8882:43 | 8882 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_WorkloadProfile` ... 8886 | pub enum WorkloadProfile { | --------------- `WorkloadProfile` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8882:28 | 8882 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_WorkloadProfile` ... 8886 | pub enum WorkloadProfile { | --------------- `WorkloadProfile` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8862:43 | 8862 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_SecondPcieLinkMaxPayload` ... 8866 | pub enum SecondPcieLinkMaxPayload { | ------------------------ `SecondPcieLinkMaxPayload` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8862:28 | 8862 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_SecondPcieLinkMaxPayload` ... 8866 | pub enum SecondPcieLinkMaxPayload { | ------------------------ `SecondPcieLinkMaxPayload` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8851:43 | 8851 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_BmcLinkSpeed` ... 8855 | pub enum BmcLinkSpeed { | ------------ `BmcLinkSpeed` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8851:28 | 8851 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_BmcLinkSpeed` ... 8855 | pub enum BmcLinkSpeed { | ------------ `BmcLinkSpeed` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8836:43 | 8836 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_AdditionalPcieLinkSpeed` ... 8840 | pub enum AdditionalPcieLinkSpeed { | ----------------------- `AdditionalPcieLinkSpeed` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8836:28 | 8836 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_AdditionalPcieLinkSpeed` ... 8840 | pub enum AdditionalPcieLinkSpeed { | ----------------------- `AdditionalPcieLinkSpeed` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8790:43 | 8790 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_GnbSmuDfPstateFclkLimit` ... 8794 | pub enum GnbSmuDfPstateFclkLimit { | ----------------------- `GnbSmuDfPstateFclkLimit` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8790:28 | 8790 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_GnbSmuDfPstateFclkLimit` ... 8794 | pub enum GnbSmuDfPstateFclkLimit { | ----------------------- `GnbSmuDfPstateFclkLimit` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8779:43 | 8779 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_DfPfOrganization` ... 8783 | pub enum DfPfOrganization { | ---------------- `DfPfOrganization` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8779:28 | 8779 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_DfPfOrganization` ... 8783 | pub enum DfPfOrganization { | ---------------- `DfPfOrganization` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8768:43 | 8768 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_DfPstateModeSelect` ... 8772 | pub enum DfPstateModeSelect { | ------------------ `DfPstateModeSelect` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8768:28 | 8768 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_DfPstateModeSelect` ... 8772 | pub enum DfPstateModeSelect { | ------------------ `DfPstateModeSelect` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8742:43 | 8742 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_DfXgmiLinkConfig` ... 8746 | pub enum DfXgmiLinkConfig { | ---------------- `DfXgmiLinkConfig` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8742:28 | 8742 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_DfXgmiLinkConfig` ... 8746 | pub enum DfXgmiLinkConfig { | ---------------- `DfXgmiLinkConfig` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8731:43 | 8731 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_DfRemapAt1TiB` ... 8735 | pub enum DfRemapAt1TiB { | ------------- `DfRemapAt1TiB` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8731:28 | 8731 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_DfRemapAt1TiB` ... 8735 | pub enum DfRemapAt1TiB { | ------------- `DfRemapAt1TiB` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8719:43 | 8719 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_DfDramNumaPerSocket` ... 8723 | pub enum DfDramNumaPerSocket { | ------------------- `DfDramNumaPerSocket` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8719:28 | 8719 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_DfDramNumaPerSocket` ... 8723 | pub enum DfDramNumaPerSocket { | ------------------- `DfDramNumaPerSocket` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8701:43 | 8701 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_DfCcdBwThrottleLevel` ... 8705 | pub enum DfCcdBwThrottleLevel { | -------------------- `DfCcdBwThrottleLevel` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8701:28 | 8701 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_DfCcdBwThrottleLevel` ... 8705 | pub enum DfCcdBwThrottleLevel { | -------------------- `DfCcdBwThrottleLevel` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8691:43 | 8691 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_DfCxlToggle` ... 8695 | pub enum DfCxlToggle { | ----------- `DfCxlToggle` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8691:28 | 8691 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_DfCxlToggle` ... 8695 | pub enum DfCxlToggle { | ----------- `DfCxlToggle` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8673:43 | 8673 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_DfMemInterleavingSize` ... 8677 | pub enum DfMemInterleavingSize { | --------------------- `DfMemInterleavingSize` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8673:28 | 8673 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_DfMemInterleavingSize` ... 8677 | pub enum DfMemInterleavingSize { | --------------------- `DfMemInterleavingSize` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8660:43 | 8660 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_DfMemInterleaving` ... 8664 | pub enum DfMemInterleaving { | ----------------- `DfMemInterleaving` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8660:28 | 8660 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_DfMemInterleaving` ... 8664 | pub enum DfMemInterleaving { | ----------------- `DfMemInterleaving` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8650:43 | 8650 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_DfSyncFloodPropagation` ... 8654 | pub enum DfSyncFloodPropagation { | ---------------------- `DfSyncFloodPropagation` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8650:28 | 8650 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_DfSyncFloodPropagation` ... 8654 | pub enum DfSyncFloodPropagation { | ---------------------- `DfSyncFloodPropagation` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8640:43 | 8640 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_DfExtIpSyncFloodPropagation` ... 8644 | pub enum DfExtIpSyncFloodPropagation { | --------------------------- `DfExtIpSyncFloodPropagation` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8640:28 | 8640 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_DfExtIpSyncFloodPropagation` ... 8644 | pub enum DfExtIpSyncFloodPropagation { | --------------------------- `DfExtIpSyncFloodPropagation` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8631:43 | 8631 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_MemPmuBistAlgorithmSelectDdr` ... 8635 | pub enum MemPmuBistAlgorithmSelectDdr { | ---------------------------- `MemPmuBistAlgorithmSelectDdr` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8631:28 | 8631 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_MemPmuBistAlgorithmSelectDdr` ... 8635 | pub enum MemPmuBistAlgorithmSelectDdr { | ---------------------------- `MemPmuBistAlgorithmSelectDdr` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8621:43 | 8621 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_MemHealTestSelect` ... 8625 | pub enum MemHealTestSelect { | ----------------- `MemHealTestSelect` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8621:28 | 8621 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_MemHealTestSelect` ... 8625 | pub enum MemHealTestSelect { | ----------------- `MemHealTestSelect` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8611:43 | 8611 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_MemHealPprType` ... 8615 | pub enum MemHealPprType { | -------------- `MemHealPprType` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8611:28 | 8611 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_MemHealPprType` ... 8615 | pub enum MemHealPprType { | -------------- `MemHealPprType` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8602:43 | 8602 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_MemControllerWritingCrcMode` ... 8606 | pub enum MemControllerWritingCrcMode { | --------------------------- `MemControllerWritingCrcMode` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8602:28 | 8602 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_MemControllerWritingCrcMode` ... 8606 | pub enum MemControllerWritingCrcMode { | --------------------------- `MemControllerWritingCrcMode` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8536:43 | 8536 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_MemAutoRefreshsCountForThrottling` ... 8540 | pub enum MemAutoRefreshsCountForThrottling { | --------------------------------- `MemAutoRefreshsCountForThrottling` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8536:28 | 8536 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_MemAutoRefreshsCountForThrottling` ... 8540 | pub enum MemAutoRefreshsCountForThrottling { | --------------------------------- `MemAutoRefreshsCountForThrottling` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8523:43 | 8523 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_MemAutoRefreshFineGranMode` ... 8527 | pub enum MemAutoRefreshFineGranMode { | -------------------------- `MemAutoRefreshFineGranMode` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8523:28 | 8523 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_MemAutoRefreshFineGranMode` ... 8527 | pub enum MemAutoRefreshFineGranMode { | -------------------------- `MemAutoRefreshFineGranMode` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8477:43 | 8477 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_MemRdimmTimingCmdParLatency` ... 8481 | pub enum MemRdimmTimingCmdParLatency { | --------------------------- `MemRdimmTimingCmdParLatency` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8477:28 | 8477 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_MemRdimmTimingCmdParLatency` ... 8481 | pub enum MemRdimmTimingCmdParLatency { | --------------------------- `MemRdimmTimingCmdParLatency` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8466:43 | 8466 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_MemNvdimmPowerSource` ... 8470 | pub enum MemNvdimmPowerSource { | -------------------- `MemNvdimmPowerSource` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8466:28 | 8466 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_MemNvdimmPowerSource` ... 8470 | pub enum MemNvdimmPowerSource { | -------------------- `MemNvdimmPowerSource` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8456:43 | 8456 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_MemTsmeMode` ... 8460 | pub enum MemTsmeMode { | ----------- `MemTsmeMode` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8456:28 | 8456 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_MemTsmeMode` ... 8460 | pub enum MemTsmeMode { | ----------- `MemTsmeMode` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8446:43 | 8446 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_DfToggle` ... 8450 | pub enum DfToggle { | -------- `DfToggle` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8446:28 | 8446 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_DfToggle` ... 8450 | pub enum DfToggle { | -------- `DfToggle` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8435:43 | 8435 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_FchIc3TransferSpeed` ... 8439 | pub enum FchIc3TransferSpeed { | ------------------- `FchIc3TransferSpeed` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8435:28 | 8435 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_FchIc3TransferSpeed` ... 8439 | pub enum FchIc3TransferSpeed { | ------------------- `FchIc3TransferSpeed` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8420:43 | 8420 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_FchConsoleOutSerialPortIoBase` ... 8424 | pub enum FchConsoleOutSerialPortIoBase { | ----------------------------- `FchConsoleOutSerialPortIoBase` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8420:28 | 8420 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_FchConsoleOutSerialPortIoBase` ... 8424 | pub enum FchConsoleOutSerialPortIoBase { | ----------------------------- `FchConsoleOutSerialPortIoBase` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8410:43 | 8410 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_FchConsoleSerialPort` ... 8414 | pub enum FchConsoleSerialPort { | -------------------- `FchConsoleSerialPort` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8410:28 | 8410 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_FchConsoleSerialPort` ... 8414 | pub enum FchConsoleSerialPort { | -------------------- `FchConsoleSerialPort` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8400:43 | 8400 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_FchConsoleOutSuperIoType` ... 8404 | pub enum FchConsoleOutSuperIoType { | ------------------------ `FchConsoleOutSuperIoType` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8400:28 | 8400 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_FchConsoleOutSuperIoType` ... 8404 | pub enum FchConsoleOutSuperIoType { | ------------------------ `FchConsoleOutSuperIoType` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8336:43 | 8336 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_FchConsoleOutMode` ... 8340 | pub enum FchConsoleOutMode { | ----------------- `FchConsoleOutMode` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8336:28 | 8336 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_FchConsoleOutMode` ... 8340 | pub enum FchConsoleOutMode { | ----------------- `FchConsoleOutMode` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8326:43 | 8326 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_CcxSmtControl` ... 8330 | pub enum CcxSmtControl { | ------------- `CcxSmtControl` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8326:28 | 8326 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_CcxSmtControl` ... 8330 | pub enum CcxSmtControl { | ------------- `CcxSmtControl` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8313:43 | 8313 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_CcxApicMode` ... 8317 | pub enum CcxApicMode { | ----------- `CcxApicMode` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8313:28 | 8313 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_CcxApicMode` ... 8317 | pub enum CcxApicMode { | ----------- `CcxApicMode` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8301:43 | 8301 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_CcxSevAsidCount` ... 8305 | pub enum CcxSevAsidCount { | --------------- `CcxSevAsidCount` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8301:28 | 8301 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_CcxSevAsidCount` ... 8305 | pub enum CcxSevAsidCount { | --------------- `CcxSevAsidCount` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8291:43 | 8291 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_CbsMemAddrCmdParityRetryDdr4` ... 8295 | pub enum CbsMemAddrCmdParityRetryDdr4 { | ---------------------------- `CbsMemAddrCmdParityRetryDdr4` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8291:28 | 8291 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_CbsMemAddrCmdParityRetryDdr4` ... 8295 | pub enum CbsMemAddrCmdParityRetryDdr4 { | ---------------------------- `CbsMemAddrCmdParityRetryDdr4` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8281:43 | 8281 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_MemSelfRefreshExitStaggering` ... 8285 | pub enum MemSelfRefreshExitStaggering { | ---------------------------- `MemSelfRefreshExitStaggering` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8281:28 | 8281 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_MemSelfRefreshExitStaggering` ... 8285 | pub enum MemSelfRefreshExitStaggering { | ---------------------------- `MemSelfRefreshExitStaggering` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8272:43 | 8272 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_MemRcwWeakDriveDisable` ... 8276 | pub enum MemRcwWeakDriveDisable { | ---------------------- `MemRcwWeakDriveDisable` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8272:28 | 8272 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_MemRcwWeakDriveDisable` ... 8276 | pub enum MemRcwWeakDriveDisable { | ---------------------- `MemRcwWeakDriveDisable` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8229:43 | 8229 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_MemMaxActivityCount` ... 8233 | pub enum MemMaxActivityCount { | ------------------- `MemMaxActivityCount` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8229:28 | 8229 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_MemMaxActivityCount` ... 8233 | pub enum MemMaxActivityCount { | ------------------- `MemMaxActivityCount` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8220:43 | 8220 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_MemBootTimePostPackageRepair` ... 8224 | pub enum MemBootTimePostPackageRepair { | ---------------------------- `MemBootTimePostPackageRepair` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8220:28 | 8220 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_MemBootTimePostPackageRepair` ... 8224 | pub enum MemBootTimePostPackageRepair { | ---------------------------- `MemBootTimePostPackageRepair` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8210:43 | 8210 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_MemEcsModeDdr` ... 8214 | pub enum MemEcsModeDdr { | ------------- `MemEcsModeDdr` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8210:28 | 8210 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_MemEcsModeDdr` ... 8214 | pub enum MemEcsModeDdr { | ------------- `MemEcsModeDdr` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8201:43 | 8201 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_MemOdtsMode` ... 8205 | pub enum MemOdtsMode { | ----------- `MemOdtsMode` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8201:28 | 8201 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_MemOdtsMode` ... 8205 | pub enum MemOdtsMode { | ----------- `MemOdtsMode` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8192:43 | 8192 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_MemSpdVerifyCrc` ... 8196 | pub enum MemSpdVerifyCrc { | --------------- `MemSpdVerifyCrc` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8192:28 | 8192 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_MemSpdVerifyCrc` ... 8196 | pub enum MemSpdVerifyCrc { | --------------- `MemSpdVerifyCrc` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8182:43 | 8182 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_MemDataPoison` ... 8186 | pub enum MemDataPoison { | ------------- `MemDataPoison` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8182:28 | 8182 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_MemDataPoison` ... 8186 | pub enum MemDataPoison { | ------------- `MemDataPoison` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8173:43 | 8173 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_MemActionOnBistFailure` ... 8177 | pub enum MemActionOnBistFailure { | ---------------------- `MemActionOnBistFailure` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8173:28 | 8173 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_MemActionOnBistFailure` ... 8177 | pub enum MemActionOnBistFailure { | ---------------------- `MemActionOnBistFailure` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8145:43 | 8145 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_BaudRate` ... 8149 | pub enum BaudRate { | -------- `BaudRate` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:8145:28 | 8145 | #[derive(Debug, PartialEq, FromPrimitive, ToPrimitive, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_BaudRate` ... 8149 | pub enum BaudRate { | -------- `BaudRate` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:1216:25 | 1216 | #[derive(FromPrimitive, ToPrimitive, Debug, PartialEq, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_ContextType` ... 1221 | pub enum ContextType { | ----------- `ContextType` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:1216:10 | 1216 | #[derive(FromPrimitive, ToPrimitive, Debug, PartialEq, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_ContextType` ... 1221 | pub enum ContextType { | ----------- `ContextType` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:1206:25 | 1206 | #[derive(FromPrimitive, ToPrimitive, Debug, PartialEq, Copy, Clone)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_ContextFormat` ... 1211 | pub enum ContextFormat { | ------------- `ContextFormat` is not local | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:1206:10 | 1206 | #[derive(FromPrimitive, ToPrimitive, Debug, PartialEq, Copy, Clone)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_ContextFormat` ... 1211 | pub enum ContextFormat { | ------------- `ContextFormat` is not local | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:183:55 | 183 | #[derive(Default, Copy, Clone, FromPrimitive, ToPrimitive)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_SerdeHex64` ... 262 | make_serde_hex!(SerdeHex64, u64, "{:#018x}", LU64); | -------------------------------------------------- | | | | | `SerdeHex64` is not local | in this macro invocation | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` which comes from the expansion of the macro `make_serde_hex` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:183:40 | 183 | #[derive(Default, Copy, Clone, FromPrimitive, ToPrimitive)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_SerdeHex64` ... 262 | make_serde_hex!(SerdeHex64, u64, "{:#018x}", LU64); | -------------------------------------------------- | | | | | `SerdeHex64` is not local | in this macro invocation | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` which comes from the expansion of the macro `make_serde_hex` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:183:55 | 183 | #[derive(Default, Copy, Clone, FromPrimitive, ToPrimitive)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_SerdeHex32` ... 260 | make_serde_hex!(SerdeHex32, u32, "{:#010x}", LU32); | -------------------------------------------------- | | | | | `SerdeHex32` is not local | in this macro invocation | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` which comes from the expansion of the macro `make_serde_hex` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:183:40 | 183 | #[derive(Default, Copy, Clone, FromPrimitive, ToPrimitive)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_SerdeHex32` ... 260 | make_serde_hex!(SerdeHex32, u32, "{:#010x}", LU32); | -------------------------------------------------- | | | | | `SerdeHex32` is not local | in this macro invocation | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` which comes from the expansion of the macro `make_serde_hex` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:183:55 | 183 | #[derive(Default, Copy, Clone, FromPrimitive, ToPrimitive)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_SerdeHex16` ... 258 | make_serde_hex!(SerdeHex16, u16, "{:#06x}", LU16); | ------------------------------------------------- | | | | | `SerdeHex16` is not local | in this macro invocation | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` which comes from the expansion of the macro `make_serde_hex` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:183:40 | 183 | #[derive(Default, Copy, Clone, FromPrimitive, ToPrimitive)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_SerdeHex16` ... 258 | make_serde_hex!(SerdeHex16, u16, "{:#06x}", LU16); | ------------------------------------------------- | | | | | `SerdeHex16` is not local | in this macro invocation | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` which comes from the expansion of the macro `make_serde_hex` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:183:55 | 183 | #[derive(Default, Copy, Clone, FromPrimitive, ToPrimitive)] | ^---------- | | | `ToPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_ToPrimitive_FOR_SerdeHex8` ... 256 | make_serde_hex!(SerdeHex8, u8, "{:#04x}"); | ----------------------------------------- | | | | | `SerdeHex8` is not local | in this macro invocation | = note: the derive macro `ToPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `ToPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `ToPrimitive` which comes from the expansion of the macro `make_serde_hex` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/ondisk.rs:183:40 | 183 | #[derive(Default, Copy, Clone, FromPrimitive, ToPrimitive)] | ^------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_SerdeHex8` ... 256 | make_serde_hex!(SerdeHex8, u8, "{:#04x}"); | ----------------------------------------- | | | | | `SerdeHex8` is not local | in this macro invocation | = note: the derive macro `FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `FromPrimitive` which comes from the expansion of the macro `make_serde_hex` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/naples.rs:43:23 | 43 | Debug, PartialEq, num_derive::FromPrimitive, Clone, Copy, BitfieldSpecifier, | ^------------------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_ParameterTokenConfig` ... 50 | pub enum ParameterTokenConfig { | -------------------- `ParameterTokenConfig` is not local | = note: the derive macro `num_derive::FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `num_derive::FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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: this warning originates in the derive macro `num_derive::FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item --> src/naples.rs:12:23 | 12 | Debug, PartialEq, num_derive::FromPrimitive, Clone, Copy, BitfieldSpecifier, | ^------------------------ | | | `FromPrimitive` is not local | move the `impl` block outside of this constant `_IMPL_NUM_FromPrimitive_FOR_ParameterTimePoint` ... 19 | pub enum ParameterTimePoint { | ------------------ `ParameterTimePoint` is not local | = note: the derive macro `num_derive::FromPrimitive` defines the non-local `impl`, and may need to be changed = note: the derive macro `num_derive::FromPrimitive` may come from an old version of the `num_derive` crate, try updating your dependency with `cargo update -p num_derive` = 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` = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration = 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 derive macro `num_derive::FromPrimitive` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: you should consider adding a `Default` implementation for `DfXgmiAcDcCoupledLink` --> src/ondisk.rs:1255:7 | 1255 | $(#[$struct_meta])* | _______^ 1256 | | $struct_vis 1257 | | struct $StructName { 1258 | | $( ... | 1263 | | )* 1264 | | } | |_____^ ... 10142 | / make_bitfield_serde! { 10143 | | #[bitfield(bits = 8)] 10144 | | #[repr(u8)] 10145 | | #[derive(Debug, Copy, Clone, PartialEq)] ... | 10155 | | } 10156 | | } | |_- in this macro invocation | = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#new_without_default = note: this warning originates in the macro `make_bitfield_serde` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: you should consider adding a `Default` implementation for `MemPmuBistAlgorithmSelect` --> src/ondisk.rs:1255:7 | 1255 | $(#[$struct_meta])* | _______^ 1256 | | $struct_vis 1257 | | struct $StructName { 1258 | | $( ... | 1263 | | )* 1264 | | } | |_____^ ... 9891 | / make_bitfield_serde! { 9892 | | #[bitfield(bits = 16)] 9893 | | #[repr(u16)] 9894 | | #[derive(Debug, Copy, Clone, PartialEq)] ... | 9906 | | } 9907 | | } | |_- in this macro invocation | = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#new_without_default = note: this warning originates in the macro `make_bitfield_serde` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: you should consider adding a `Default` implementation for `FchConsoleOutSerialPortEspiControllerSelect` --> src/ondisk.rs:1255:7 | 1255 | $(#[$struct_meta])* | _______^ 1256 | | $struct_vis 1257 | | struct $StructName { 1258 | | $( ... | 1263 | | )* 1264 | | } | |_____^ ... 9873 | / make_bitfield_serde! { 9874 | | #[bitfield(bits = 8)] 9875 | | #[repr(u8)] 9876 | | #[derive(Debug, Copy, Clone, PartialEq)] ... | 9883 | | } 9884 | | } | |_- in this macro invocation | = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#new_without_default = note: this warning originates in the macro `make_bitfield_serde` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: you should consider adding a `Default` implementation for `MemPmuBistTestSelect` --> src/ondisk.rs:1255:7 | 1255 | $(#[$struct_meta])* | _______^ 1256 | | $struct_vis 1257 | | struct $StructName { 1258 | | $( ... | 1263 | | )* 1264 | | } | |_____^ ... 9828 | / make_bitfield_serde! { 9829 | | #[bitfield(bits = 8)] 9830 | | #[repr(u8)] 9831 | | #[derive(Debug, Copy, Clone, PartialEq)] ... | 9839 | | } 9840 | | } | |_- in this macro invocation | = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#new_without_default = note: this warning originates in the macro `make_bitfield_serde` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: you should consider adding a `Default` implementation for `DfXgmiChannelTypeSelect` --> src/ondisk.rs:1255:7 | 1255 | $(#[$struct_meta])* | _______^ 1256 | | $struct_vis 1257 | | struct $StructName { 1258 | | $( ... | 1263 | | )* 1264 | | } | |_____^ ... 9703 | / make_bitfield_serde! { 9704 | | #[bitfield(bits = 32)] 9705 | | #[derive(PartialEq, Debug, Copy, Clone)] 9706 | | #[repr(u32)] ... | 9716 | | } 9717 | | } | |_- in this macro invocation | = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#new_without_default = note: this warning originates in the macro `make_bitfield_serde` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: you should consider adding a `Default` implementation for `LrdimmDdr4OdtPatDimmRankBitmaps` --> src/ondisk.rs:1255:7 | 1255 | $(#[$struct_meta])* | _______^ 1256 | | $struct_vis 1257 | | struct $StructName { 1258 | | $( ... | 1263 | | )* 1264 | | } | |_____^ ... 4854 | / make_bitfield_serde! { 4855 | | #[bitfield(bits = 32)] 4856 | | #[repr(u32)] 4857 | | #[derive(Clone, Copy, BitfieldSpecifier)] ... | 4863 | | } 4864 | | } | |_____- in this macro invocation | = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#new_without_default = note: this warning originates in the macro `make_bitfield_serde` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: you should consider adding a `Default` implementation for `OdtPatPatterns` --> src/ondisk.rs:1255:7 | 1255 | $(#[$struct_meta])* | _______^ 1256 | | $struct_vis 1257 | | struct $StructName { 1258 | | $( ... | 1263 | | )* 1264 | | } | |_____^ ... 4786 | / make_bitfield_serde! { 4787 | | #[bitfield(bits = 32)] 4788 | | #[repr(u32)] 4789 | | #[derive(Clone, Copy)] ... | 4795 | | } 4796 | | } | |_____- in this macro invocation | = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#new_without_default = note: this warning originates in the macro `make_bitfield_serde` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: you should consider adding a `Default` implementation for `ErrorOutControlBeepCodePeakAttr` --> src/ondisk.rs:1255:7 | 1255 | $(#[$struct_meta])* | _______^ 1256 | | $struct_vis 1257 | | struct $StructName { 1258 | | $( ... | 1263 | | )* 1264 | | } | |_____^ ... 4454 | / make_bitfield_serde! { 4455 | | #[bitfield(bits = 32)] 4456 | | #[derive(PartialEq, Debug, Copy, Clone)] 4457 | | #[repr(u32)] ... | 4464 | | } 4465 | | } | |_____- in this macro invocation | = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#new_without_default = note: this warning originates in the macro `make_bitfield_serde` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: you should consider adding a `Default` implementation for `UdimmDdr4Voltages` --> src/ondisk.rs:1255:7 | 1255 | $(#[$struct_meta])* | _______^ 1256 | | $struct_vis 1257 | | struct $StructName { 1258 | | $( ... | 1263 | | )* 1264 | | } | |_____^ ... 3049 | / make_bitfield_serde! { 3050 | | #[bitfield(bits = 32)] 3051 | | #[repr(u32)] 3052 | | #[derive(Clone, Copy)] ... | 3059 | | } 3060 | | } | |_____- in this macro invocation | = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#new_without_default = note: this warning originates in the macro `make_bitfield_serde` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: you should consider adding a `Default` implementation for `DimmsPerChannelSelector` --> src/ondisk.rs:1255:7 | 1255 | $(#[$struct_meta])* | _______^ 1256 | | $struct_vis 1257 | | struct $StructName { 1258 | | $( ... | 1263 | | )* 1264 | | } | |_____^ ... 2815 | / make_bitfield_serde! { 2816 | | #[bitfield(bits = 32)] 2817 | | #[repr(u32)] 2818 | | #[derive(Clone, Copy)] ... | 2825 | | } 2826 | | } | |_____- in this macro invocation | = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#new_without_default = note: this warning originates in the macro `make_bitfield_serde` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: you should consider adding a `Default` implementation for `DdrRates` --> src/ondisk.rs:1255:7 | 1255 | $(#[$struct_meta])* | _______^ 1256 | | $struct_vis 1257 | | struct $StructName { 1258 | | $( ... | 1263 | | )* 1264 | | } | |_____^ ... 2759 | / make_bitfield_serde!( 2760 | | #[bitfield(bits = 32)] 2761 | | #[repr(u32)] 2762 | | #[derive(Clone, Copy, PartialEq)] ... | 2807 | | } 2808 | | ); | |_____- in this macro invocation | = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#new_without_default = note: this warning originates in the macro `make_bitfield_serde` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: you should consider adding a `Default` implementation for `ParameterAttributes` --> src/ondisk.rs:1255:7 | 1255 | $(#[$struct_meta])* | _______^ 1256 | | $struct_vis 1257 | | struct $StructName { 1258 | | $( ... | 1263 | | )* 1264 | | } | |_____^ ... 1769 | / make_bitfield_serde! { 1770 | | /// For Naples. 1771 | | #[bitfield(bits = 32)] 1772 | | #[repr(u32)] ... | 1783 | | } 1784 | | } | |_- in this macro invocation | = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#new_without_default = note: `#[warn(clippy::new_without_default)]` on by default = note: this warning originates in the macro `make_bitfield_serde` (in Nightly builds, run with -Z macro-backtrace for more info)

The following actions uses node12 which is deprecated and will be forced to run on node16: actions-rs/clippy-check@v1. For more info: https://github.blog/changelog/2023-06-13-github-actions-all-actions-will-run-on-node16-instead-of-node12-by-default/

The following actions uses Node.js version which is deprecated and will be forced to run on node20: actions/checkout@v3, actions-rs/clippy-check@v1. For more info: https://github.blog/changelog/2024-03-07-github-actions-all-actions-will-run-on-node20-instead-of-node16-by-default/