D: [iurt_root_command] chroot
Building target platforms: noarch
Building for target noarch
Installing /home/pterjan/rpmbuild/SRPMS/rust-sharded-slab-0.1.7-0.2.mga10.src.rpm
Executing(%mkbuilddir): /bin/sh -e /home/pterjan/rpmbuild/tmp/rpm-tmp.spdcCO
Executing(%prep): /bin/sh -e /home/pterjan/rpmbuild/tmp/rpm-tmp.1cy4QV
+ umask 022
+ cd /home/pterjan/rpmbuild/BUILD/rust-sharded-slab-0.1.7-build
+ '[' 1 -eq 1 ']'
+ '[' 1 -eq 1 ']'
+ '[' 1 -eq 1 ']'
+ cd /home/pterjan/rpmbuild/BUILD/rust-sharded-slab-0.1.7-build
+ rm -rf sharded-slab-0.1.7
+ /usr/lib/rpm/rpmuncompress -x /home/pterjan/rpmbuild/SOURCES/sharded-slab-0.1.7.crate
+ STATUS=0
+ '[' 0 -ne 0 ']'
+ cd sharded-slab-0.1.7
+ /usr/bin/chmod -Rf a+rX,u+w,g-w,o-w .
+ /usr/bin/patch -p1 -s --fuzz=0 --no-backup-if-mismatch -f
+ /usr/lib/rpm/rpmuncompress /home/pterjan/rpmbuild/SOURCES/sharded-slab-fix-metadata-auto.diff
+ set -euo pipefail
+ /usr/bin/mkdir -p target/rpm
+ /usr/bin/ln -s rpm target/release
+ /usr/bin/rm -rf .cargo/
+ /usr/bin/mkdir -p .cargo
+ cat
+ cat
+ /usr/bin/rm -f Cargo.lock
+ /usr/bin/rm -f Cargo.toml.orig
+ RPM_EC=0
++ jobs -p
+ exit 0
Executing(%generate_buildrequires): /bin/sh -e /home/pterjan/rpmbuild/tmp/rpm-tmp.1nej4j
+ umask 022
+ cd /home/pterjan/rpmbuild/BUILD/rust-sharded-slab-0.1.7-build
+ cd sharded-slab-0.1.7
+ /usr/bin/cargo2rpm --path Cargo.toml buildrequires
+ RPM_EC=0
++ jobs -p
+ exit 0
Executing(%build): /bin/sh -e /home/pterjan/rpmbuild/tmp/rpm-tmp.RZ9lIn
+ umask 022
+ cd /home/pterjan/rpmbuild/BUILD/rust-sharded-slab-0.1.7-build
+ CFLAGS='-O2 -g -pipe -Wformat -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -m64 -fasynchronous-unwind-tables -fstack-clash-protection -fcf-protection=full'
+ export CFLAGS
+ CXXFLAGS='-O2 -g -pipe -Wformat -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -m64 -fasynchronous-unwind-tables -fstack-clash-protection -fcf-protection=full'
+ export CXXFLAGS
+ FFLAGS='-O2 -g -pipe -Wformat -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -m64 -fasynchronous-unwind-tables -fstack-clash-protection -fcf-protection=full '
+ export FFLAGS
+ FCFLAGS='-O2 -g -pipe -Wformat -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -m64 -fasynchronous-unwind-tables -fstack-clash-protection -fcf-protection=full '
+ export FCFLAGS
+ VALAFLAGS=-g
+ export VALAFLAGS
+ RUSTFLAGS='-Copt-level=3 -Cdebuginfo=2 -Ccodegen-units=1 -Cstrip=none --cap-lints=warn'
+ export RUSTFLAGS
+ LDFLAGS='-Wl,--as-needed -Wl,--no-undefined -Wl,-z,relro -Wl,-z,now -Wl,-O1 -Wl,--build-id=sha1 -Wl,--enable-new-dtags -specs=/usr/lib/rpm/redhat/redhat-hardened-ld'
+ export LDFLAGS
+ LT_SYS_LIBRARY_PATH=/usr/lib:
+ export LT_SYS_LIBRARY_PATH
+ CC=gcc
+ export CC
+ CXX=g++
+ export CXX
+ cd sharded-slab-0.1.7
+ '[' 1 -eq 1 ']'
+ '[' 1 -eq 1 ']'
+ /usr/bin/env CARGO_HOME=.cargo RUSTC_BOOTSTRAP=1 'RUSTFLAGS=-Copt-level=3 -Cdebuginfo=2 -Ccodegen-units=1 -Cstrip=none --cap-lints=warn' /usr/bin/cargo build -j16 -Z avoid-dev-deps --profile rpm
   Compiling lazy_static v1.5.0
     Running `/usr/bin/rustc --crate-name lazy_static --edition=2015 /usr/share/cargo/registry/lazy_static-1.5.0/src/lib.rs --error-format=json --json=diagnostic-rendered-ansi,artifacts,future-incompat --crate-type lib --emit=dep-info,metadata,link -C opt-level=3 -C embed-bitcode=no -C codegen-units=1 -C debuginfo=2 --check-cfg 'cfg(docsrs,test)' --check-cfg 'cfg(feature, values("spin", "spin_no_std"))' -C metadata=aced2b190352d324 -C extra-filename=-8b6f8489d85a9cdf --out-dir /home/pterjan/rpmbuild/BUILD/rust-sharded-slab-0.1.7-build/sharded-slab-0.1.7/target/rpm/deps -L dependency=/home/pterjan/rpmbuild/BUILD/rust-sharded-slab-0.1.7-build/sharded-slab-0.1.7/target/rpm/deps --cap-lints allow -Copt-level=3 -Cdebuginfo=2 -Ccodegen-units=1 -Cstrip=none --cap-lints=warn`
   Compiling sharded-slab v0.1.7 (/home/pterjan/rpmbuild/BUILD/rust-sharded-slab-0.1.7-build/sharded-slab-0.1.7)
     Running `/usr/bin/rustc --crate-name sharded_slab --edition=2018 src/lib.rs --error-format=json --json=diagnostic-rendered-ansi,artifacts,future-incompat --crate-type lib --emit=dep-info,metadata,link -C opt-level=3 -C embed-bitcode=no -C codegen-units=1 -C debuginfo=2 --check-cfg 'cfg(docsrs,test)' --check-cfg 'cfg(feature, values())' -C metadata=987b354d1fea26d1 -C extra-filename=-ef66a75319ed7208 --out-dir /home/pterjan/rpmbuild/BUILD/rust-sharded-slab-0.1.7-build/sharded-slab-0.1.7/target/rpm/deps -L dependency=/home/pterjan/rpmbuild/BUILD/rust-sharded-slab-0.1.7-build/sharded-slab-0.1.7/target/rpm/deps --extern lazy_static=/home/pterjan/rpmbuild/BUILD/rust-sharded-slab-0.1.7-build/sharded-slab-0.1.7/target/rpm/deps/liblazy_static-8b6f8489d85a9cdf.rmeta -Copt-level=3 -Cdebuginfo=2 -Ccodegen-units=1 -Cstrip=none --cap-lints=warn`
warning: unexpected `cfg` condition name: `loom`
  --> src/macros.rs:15:17
   |
15 | #[cfg(all(test, loom))]
   |                 ^^^^
   |
   = help: expected names are: `docsrs`, `feature`, and `test` and 31 more
   = help: consider using a Cargo feature instead
   = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
            [lints.rust]
            unexpected_cfgs = { level = "warn", check-cfg = ['cfg(loom)'] }
   = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(loom)");` to the top of the `build.rs`
   = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
   = note: `#[warn(unexpected_cfgs)]` on by default

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/pool.rs:453:9
    |
453 |         test_println!("pool: create {:?}", tid);
    |         --------------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/pool.rs:621:9
    |
621 |         test_println!("pool: create_owned {:?}", tid);
    |         --------------------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/pool.rs:655:9
    |
655 |         test_println!("pool: create_with");
    |         ---------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/pool.rs:678:9
    |
678 |         test_println!("pool: get{:?}; current={:?}", tid, Tid::<C>::current());
    |         ---------------------------------------------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/pool.rs:769:9
    |
769 |         test_println!("pool: get{:?}; current={:?}", tid, Tid::<C>::current());
    |         ---------------------------------------------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/pool.rs:914:9
    |
914 |         test_println!("drop Ref: try clearing data");
    |         -------------------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
    --> src/macros.rs:3:31
     |
   3 |         if cfg!(test) && cfg!(slab_print) {
     |                               ^^^^^^^^^^
     |
    ::: src/pool.rs:1049:9
     |
1049 |         test_println!(" -> drop RefMut: try clearing data");
     |         --------------------------------------------------- in this macro invocation
     |
     = help: consider using a Cargo feature instead
     = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
              [lints.rust]
              unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
     = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
     = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
     = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
    --> src/macros.rs:3:31
     |
   3 |         if cfg!(test) && cfg!(slab_print) {
     |                               ^^^^^^^^^^
     |
    ::: src/pool.rs:1124:9
     |
1124 |         test_println!("drop OwnedRef: try clearing data");
     |         ------------------------------------------------- in this macro invocation
     |
     = help: consider using a Cargo feature instead
     = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
              [lints.rust]
              unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
     = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
     = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
     = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
    --> src/macros.rs:3:31
     |
   3 |         if cfg!(test) && cfg!(slab_print) {
     |                               ^^^^^^^^^^
     |
    ::: src/pool.rs:1135:13
     |
1135 |             test_println!("-> shard={:?}", shard_idx);
     |             ----------------------------------------- in this macro invocation
     |
     = help: consider using a Cargo feature instead
     = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
              [lints.rust]
              unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
     = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
     = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
     = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
    --> src/macros.rs:3:31
     |
   3 |         if cfg!(test) && cfg!(slab_print) {
     |                               ^^^^^^^^^^
     |
    ::: src/pool.rs:1139:17
     |
1139 |                 test_println!("-> shard={:?} does not exist! THIS IS A BUG", shard_idx);
     |                 ----------------------------------------------------------------------- in this macro invocation
     |
     = help: consider using a Cargo feature instead
     = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
              [lints.rust]
              unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
     = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
     = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
     = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
    --> src/macros.rs:3:31
     |
   3 |         if cfg!(test) && cfg!(slab_print) {
     |                               ^^^^^^^^^^
     |
    ::: src/pool.rs:1238:9
     |
1238 |         test_println!("-> shard={:?}", shard_idx);
     |         ----------------------------------------- in this macro invocation
     |
     = help: consider using a Cargo feature instead
     = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
              [lints.rust]
              unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
     = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
     = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
     = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
    --> src/macros.rs:3:31
     |
   3 |         if cfg!(test) && cfg!(slab_print) {
     |                               ^^^^^^^^^^
     |
    ::: src/pool.rs:1290:9
     |
1290 |         test_println!("drop OwnedRefMut: try clearing data");
     |         ---------------------------------------------------- in this macro invocation
     |
     = help: consider using a Cargo feature instead
     = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
              [lints.rust]
              unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
     = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
     = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
     = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
    --> src/macros.rs:3:31
     |
   3 |         if cfg!(test) && cfg!(slab_print) {
     |                               ^^^^^^^^^^
     |
    ::: src/pool.rs:1303:17
     |
1303 |                 test_println!("-> shard does not exist! THIS IS A BUG");
     |                 ------------------------------------------------------- in this macro invocation
     |
     = help: consider using a Cargo feature instead
     = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
              [lints.rust]
              unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
     = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
     = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
     = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `loom`
 --> src/sync.rs:3:11
  |
3 | #[cfg(all(loom, any(test, feature = "loom")))]
  |           ^^^^
  |
  = help: consider using a Cargo feature instead
  = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
           [lints.rust]
           unexpected_cfgs = { level = "warn", check-cfg = ['cfg(loom)'] }
  = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(loom)");` to the top of the `build.rs`
  = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration

warning: unexpected `cfg` condition value: `loom`
 --> src/sync.rs:3:27
  |
3 | #[cfg(all(loom, any(test, feature = "loom")))]
  |                           ^^^^^^^^^^^^^^^^ help: remove the condition
  |
  = note: no expected values for `feature`
  = help: consider adding `loom` as a feature in `Cargo.toml`
  = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration

warning: unexpected `cfg` condition name: `loom`
  --> src/sync.rs:63:15
   |
63 | #[cfg(not(all(loom, any(feature = "loom", test))))]
   |               ^^^^
   |
   = help: consider using a Cargo feature instead
   = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
            [lints.rust]
            unexpected_cfgs = { level = "warn", check-cfg = ['cfg(loom)'] }
   = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(loom)");` to the top of the `build.rs`
   = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration

warning: unexpected `cfg` condition value: `loom`
  --> src/sync.rs:63:25
   |
63 | #[cfg(not(all(loom, any(feature = "loom", test))))]
   |                         ^^^^^^^^^^^^^^^^ help: remove the condition
   |
   = note: no expected values for `feature`
   = help: consider adding `loom` as a feature in `Cargo.toml`
   = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration

warning: unexpected `cfg` condition name: `loom`
  --> src/clear.rs:95:11
   |
95 | #[cfg(all(loom, test))]
   |           ^^^^
   |
   = help: consider using a Cargo feature instead
   = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
            [lints.rust]
            unexpected_cfgs = { level = "warn", check-cfg = ['cfg(loom)'] }
   = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(loom)");` to the top of the `build.rs`
   = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration

warning: unexpected `cfg` condition name: `slab_print`
  --> src/macros.rs:3:31
   |
 3 |         if cfg!(test) && cfg!(slab_print) {
   |                               ^^^^^^^^^^
   |
  ::: src/iter.rs:18:9
   |
18 |         test_println!("UniqueIter::next");
   |         --------------------------------- in this macro invocation
   |
   = help: consider using a Cargo feature instead
   = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
            [lints.rust]
            unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
   = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
   = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
   = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
  --> src/macros.rs:3:31
   |
 3 |         if cfg!(test) && cfg!(slab_print) {
   |                               ^^^^^^^^^^
   |
  ::: src/iter.rs:20:13
   |
20 |             test_println!("-> try next slot");
   |             --------------------------------- in this macro invocation
   |
   = help: consider using a Cargo feature instead
   = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
            [lints.rust]
            unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
   = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
   = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
   = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
  --> src/macros.rs:3:31
   |
 3 |         if cfg!(test) && cfg!(slab_print) {
   |                               ^^^^^^^^^^
   |
  ::: src/iter.rs:22:17
   |
22 |                 test_println!("-> found an item!");
   |                 ---------------------------------- in this macro invocation
   |
   = help: consider using a Cargo feature instead
   = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
            [lints.rust]
            unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
   = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
   = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
   = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
  --> src/macros.rs:3:31
   |
 3 |         if cfg!(test) && cfg!(slab_print) {
   |                               ^^^^^^^^^^
   |
  ::: src/iter.rs:26:13
   |
26 |             test_println!("-> try next page");
   |             --------------------------------- in this macro invocation
   |
   = help: consider using a Cargo feature instead
   = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
            [lints.rust]
            unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
   = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
   = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
   = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
  --> src/macros.rs:3:31
   |
 3 |         if cfg!(test) && cfg!(slab_print) {
   |                               ^^^^^^^^^^
   |
  ::: src/iter.rs:28:17
   |
28 |                 test_println!("-> found another page");
   |                 -------------------------------------- in this macro invocation
   |
   = help: consider using a Cargo feature instead
   = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
            [lints.rust]
            unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
   = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
   = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
   = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
  --> src/macros.rs:3:31
   |
 3 |         if cfg!(test) && cfg!(slab_print) {
   |                               ^^^^^^^^^^
   |
  ::: src/iter.rs:33:13
   |
33 |             test_println!("-> try next shard");
   |             ---------------------------------- in this macro invocation
   |
   = help: consider using a Cargo feature instead
   = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
            [lints.rust]
            unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
   = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
   = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
   = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
  --> src/macros.rs:3:31
   |
 3 |         if cfg!(test) && cfg!(slab_print) {
   |                               ^^^^^^^^^^
   |
  ::: src/iter.rs:35:17
   |
35 |                 test_println!("-> found another shard");
   |                 --------------------------------------- in this macro invocation
   |
   = help: consider using a Cargo feature instead
   = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
            [lints.rust]
            unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
   = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
   = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
   = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
  --> src/macros.rs:3:31
   |
 3 |         if cfg!(test) && cfg!(slab_print) {
   |                               ^^^^^^^^^^
   |
  ::: src/iter.rs:38:17
   |
38 |                 test_println!("-> all done!");
   |                 ----------------------------- in this macro invocation
   |
   = help: consider using a Cargo feature instead
   = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
            [lints.rust]
            unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
   = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
   = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
   = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |           if cfg!(test) && cfg!(slab_print) {
    |                                 ^^^^^^^^^^
    |
   ::: src/page/slot.rs:115:13
    |
115 | /             test_println!(
116 | |                 "-> get {:?}; current_gen={:?}; lifecycle={:#x}; state={:?}; refs={:?};",
117 | |                 gen,
118 | |                 current_gen,
...   |
121 | |                 refs,
122 | |             );
    | |_____________- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/page/slot.rs:129:17
    |
129 |                 test_println!("-> get: no longer exists!");
    |                 ------------------------------------------ in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/page/slot.rs:142:21
    |
142 |                     test_println!("-> {:?}", new_refs);
    |                     ---------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/page/slot.rs:154:21
    |
154 |                     test_println!("-> get: retrying; lifecycle={:#x};", actual);
    |                     ----------------------------------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |           if cfg!(test) && cfg!(slab_print) {
    |                                 ^^^^^^^^^^
    |
   ::: src/page/slot.rs:175:13
    |
175 | /             test_println!(
176 | |                 "-> mark_release; gen={:?}; current_gen={:?};",
177 | |                 gen,
178 | |                 curr_gen
179 | |             );
    | |_____________- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/page/slot.rs:187:13
    |
187 |             test_println!("-> mark_release; state={:?};", state);
    |             ---------------------------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/page/slot.rs:190:21
    |
190 |                     test_println!("--> mark_release; cannot release (already removed!)");
    |                     -------------------------------------------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/page/slot.rs:194:21
    |
194 |                     test_println!("--> mark_release; already marked;");
    |                     -------------------------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |           if cfg!(test) && cfg!(slab_print) {
    |                                 ^^^^^^^^^^
    |
   ::: src/page/slot.rs:202:13
    |
202 | /             test_println!(
203 | |                 "-> mark_release; old_lifecycle={:#x}; new_lifecycle={:#x};",
204 | |                 lifecycle,
205 | |                 new_lifecycle
206 | |             );
    | |_____________- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/page/slot.rs:216:21
    |
216 |                     test_println!("-> mark_release; retrying");
    |                     ------------------------------------------ in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/page/slot.rs:224:9
    |
224 |         test_println!("-> mark_release: marked; refs={:?};", refs);
    |         ---------------------------------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |           if cfg!(test) && cfg!(slab_print) {
    |                                 ^^^^^^^^^^
    |
   ::: src/page/slot.rs:246:13
    |
246 | /             test_println!("-> release_with; lifecycle={:#x}; expected_gen={:?}; current_gen={:?}; next_gen={:?};",
247 | |                 lifecycle,
248 | |                 gen,
249 | |                 current_gen,
250 | |                 next_gen
251 | |             );
    | |_____________- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/page/slot.rs:258:17
    |
258 |                 test_println!("-> already removed!");
    |                 ------------------------------------ in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/page/slot.rs:275:21
    |
275 |                     test_println!("-> advanced gen; lifecycle={:#x}; refs={:?};", actual, refs);
    |                     --------------------------------------------------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/page/slot.rs:277:25
    |
277 |                         test_println!("-> ok to remove!");
    |                         --------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/page/slot.rs:290:21
    |
290 |                     test_println!("-> refs={:?}; spin...", refs);
    |                     -------------------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/page/slot.rs:296:21
    |
296 |                     test_println!("-> retrying; lifecycle={:#x};", actual);
    |                     ------------------------------------------------------ in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |           if cfg!(test) && cfg!(slab_print) {
    |                                 ^^^^^^^^^^
    |
   ::: src/page/slot.rs:316:9
    |
316 | /         test_println!(
317 | |             "-> initialize_state; state={:?}; gen={:?}; refs={:?};",
318 | |             Lifecycle::<C>::from_packed(lifecycle),
319 | |             gen,
320 | |             refs,
321 | |         );
    | |_________- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/page/slot.rs:324:13
    |
324 |             test_println!("-> initialize while referenced! cancelling");
    |             ----------------------------------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/page/slot.rs:363:9
    |
363 |         test_println!("-> inserted at {:?}", gen);
    |         ----------------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |           if cfg!(test) && cfg!(slab_print) {
    |                                 ^^^^^^^^^^
    |
   ::: src/page/slot.rs:389:17
    |
389 | /                 test_println!(
390 | |                     "-> try_remove_value; nothing exists at generation={:?}",
391 | |                     gen
392 | |                 );
    | |_________________- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/page/slot.rs:397:9
    |
397 |         test_println!("-> try_remove_value; marked!");
    |         --------------------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/page/slot.rs:401:13
    |
401 |             test_println!("-> try_remove_value; can remove now");
    |             ---------------------------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |           if cfg!(test) && cfg!(slab_print) {
    |                                 ^^^^^^^^^^
    |
   ::: src/page/slot.rs:453:17
    |
453 | /                 test_println!(
454 | |                     "-> try_clear_storage; nothing exists at generation={:?}",
455 | |                     gen
456 | |                 );
    | |_________________- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/page/slot.rs:461:9
    |
461 |         test_println!("-> try_clear_storage; marked!");
    |         ---------------------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/page/slot.rs:465:13
    |
465 |             test_println!("-> try_remove_value; can clear now");
    |             --------------------------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/page/slot.rs:485:13
    |
485 |             test_println!("-> cleared: {}", cleared);
    |             ---------------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |           if cfg!(test) && cfg!(slab_print) {
    |                                 ^^^^^^^^^^
    |
   ::: src/page/slot.rs:510:13
    |
510 | /             test_println!(
511 | |                 "-> drop guard: state={:?}; gen={:?}; refs={:?}; lifecycle={:#x}; new_lifecycle={:#x}; dropping={:?}",
512 | |                 state,
513 | |                 gen,
...   |
517 | |                 dropping
518 | |             );
    | |_____________- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/page/slot.rs:526:21
    |
526 |                     test_println!("-> drop guard: done;  dropping={:?}", dropping);
    |                     -------------------------------------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/page/slot.rs:530:21
    |
530 |                     test_println!("-> drop guard; retry, actual={:#x}", actual);
    |                     ----------------------------------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/page/slot.rs:710:13
    |
710 |             test_println!("-> get: {}; MAX={}", self.value, RefCount::<C>::MAX);
    |             ------------------------------------------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |           if cfg!(test) && cfg!(slab_print) {
    |                                 ^^^^^^^^^^
    |
   ::: src/page/slot.rs:830:9
    |
830 | /         test_println!(
831 | |             "InitGuard::release; curr_lifecycle={:?}; downgrading={}",
832 | |             Lifecycle::<C>::from_packed(self.curr_lifecycle),
833 | |             new_refs != 0,
834 | |         );
    | |_________- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/page/slot.rs:836:13
    |
836 |             test_println!("-> already released!");
    |             ------------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/page/slot.rs:852:17
    |
852 |                 test_println!("--> advanced to PRESENT; done");
    |                 ---------------------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |           if cfg!(test) && cfg!(slab_print) {
    |                                 ^^^^^^^^^^
    |
   ::: src/page/slot.rs:856:17
    |
856 | /                 test_println!(
857 | |                     "--> lifecycle changed; actual={:?}",
858 | |                     Lifecycle::<C>::from_packed(actual)
859 | |                 );
    | |_________________- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |           if cfg!(test) && cfg!(slab_print) {
    |                                 ^^^^^^^^^^
    |
   ::: src/page/slot.rs:870:13
    |
870 | /             test_println!(
871 | |                 "-> InitGuard::release; lifecycle={:#x}; state={:?}; refs={:?};",
872 | |                 curr_lifecycle,
873 | |                 state,
874 | |                 refs,
875 | |             );
    | |_____________- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/page/slot.rs:889:21
    |
889 |                     test_println!("-> InitGuard::RELEASE: done!");
    |                     --------------------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/page/slot.rs:894:21
    |
894 |                     test_println!("-> InitGuard::release; retry, actual={:#x}", actual);
    |                     ------------------------------------------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `loom`
  --> src/page/stack.rs:72:11
   |
72 | #[cfg(all(loom, test))]
   |           ^^^^
   |
   = help: consider using a Cargo feature instead
   = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
            [lints.rust]
            unexpected_cfgs = { level = "warn", check-cfg = ['cfg(loom)'] }
   = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(loom)");` to the top of the `build.rs`
   = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration

warning: unexpected `cfg` condition name: `slab_print`
  --> src/macros.rs:3:31
   |
 3 |         if cfg!(test) && cfg!(slab_print) {
   |                               ^^^^^^^^^^
   |
  ::: src/page/stack.rs:20:9
   |
20 |         test_println!("-> pop {:#x}", val);
   |         ---------------------------------- in this macro invocation
   |
   = help: consider using a Cargo feature instead
   = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
            [lints.rust]
            unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
   = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
   = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
   = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
  --> src/macros.rs:3:31
   |
 3 |         if cfg!(test) && cfg!(slab_print) {
   |                               ^^^^^^^^^^
   |
  ::: src/page/stack.rs:34:13
   |
34 |             test_println!("-> next {:#x}", next);
   |             ------------------------------------ in this macro invocation
   |
   = help: consider using a Cargo feature instead
   = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
            [lints.rust]
            unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
   = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
   = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
   = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
  --> src/macros.rs:3:31
   |
 3 |         if cfg!(test) && cfg!(slab_print) {
   |                               ^^^^^^^^^^
   |
  ::: src/page/stack.rs:43:21
   |
43 |                     test_println!("-> retry!");
   |                     -------------------------- in this macro invocation
   |
   = help: consider using a Cargo feature instead
   = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
            [lints.rust]
            unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
   = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
   = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
   = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
  --> src/macros.rs:3:31
   |
 3 |         if cfg!(test) && cfg!(slab_print) {
   |                               ^^^^^^^^^^
   |
  ::: src/page/stack.rs:47:21
   |
47 |                     test_println!("-> successful; next={:#x}", next);
   |                     ------------------------------------------------ in this macro invocation
   |
   = help: consider using a Cargo feature instead
   = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
            [lints.rust]
            unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
   = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
   = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
   = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/page/mod.rs:146:9
    |
146 |         test_println!("-> local head {:?}", head);
    |         ----------------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/page/mod.rs:156:13
    |
156 |             test_println!("-> remote head {:?}", head);
    |             ------------------------------------------ in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/page/mod.rs:163:13
    |
163 |             test_println!("-> NULL! {:?}", head);
    |             ------------------------------------ in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/page/mod.rs:185:9
    |
185 |         test_println!("-> offset {:?}", poff);
    |         ------------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/page/mod.rs:214:9
    |
214 |         test_println!("-> take: offset {:?}", offset);
    |         --------------------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/page/mod.rs:231:9
    |
231 |         test_println!("-> offset {:?}", offset);
    |         --------------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/page/mod.rs:287:9
    |
287 |         test_println!("-> init_with: insert at offset: {}", index);
    |         ---------------------------------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/page/mod.rs:294:9
    |
294 |         test_println!("-> alloc new page ({})", self.size);
    |         -------------------------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/page/mod.rs:318:9
    |
318 |         test_println!("-> offset {:?}", offset);
    |         --------------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/page/mod.rs:338:9
    |
338 |         test_println!("-> offset {:?}", offset);
    |         --------------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
  --> src/macros.rs:3:31
   |
 3 |         if cfg!(test) && cfg!(slab_print) {
   |                               ^^^^^^^^^^
   |
  ::: src/shard.rs:79:9
   |
79 |         test_println!("-> {:?}", addr);
   |         ------------------------------ in this macro invocation
   |
   = help: consider using a Cargo feature instead
   = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
            [lints.rust]
            unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
   = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
   = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
   = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/shard.rs:111:9
    |
111 |         test_println!("-> remove_local {:?}", addr);
    |         ------------------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/shard.rs:125:9
    |
125 |         test_println!("-> take_remote {:?}; page {:?}", addr, page_index);
    |         ----------------------------------------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/shard.rs:172:13
    |
172 |             test_println!("-> page {}; {:?}; {:?}", page_idx, local, page);
    |             -------------------------------------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |           if cfg!(test) && cfg!(slab_print) {
    |                                 ^^^^^^^^^^
    |
   ::: src/shard.rs:208:9
    |
208 | /         test_println!(
209 | |             "-> clear_after_release; self.tid={:?}; current.tid={:?};",
210 | |             tid,
211 | |             self.tid
212 | |         );
    | |_________- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/shard.rs:286:9
    |
286 |         test_println!("-> get shard={}", idx);
    |         ------------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/shard.rs:293:9
    |
293 |         test_println!("current: {:?}", tid);
    |         ----------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/shard.rs:306:13
    |
306 |             test_println!("-> allocated new shard for index {} at {:p}", idx, ptr);
    |             ---------------------------------------------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/shard.rs:315:13
    |
315 |             test_println!("-> highest index={}, prev={}", std::cmp::max(max, idx), max);
    |             --------------------------------------------------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/shard.rs:326:9
    |
326 |         test_println!("Array::iter_mut");
    |         -------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/shard.rs:328:9
    |
328 |         test_println!("-> highest index={}", max);
    |         ----------------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/shard.rs:381:9
    |
381 |         test_println!("---> loaded={:p} (order={:?})", ptr, order);
    |         ---------------------------------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/shard.rs:383:13
    |
383 |             test_println!("---> null");
    |             -------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/shard.rs:418:9
    |
418 |         test_println!("IterMut::next");
    |         ------------------------------ in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/shard.rs:425:13
    |
425 |             test_println!("-> next.is_some={}", next.is_some());
    |             --------------------------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/shard.rs:427:17
    |
427 |                 test_println!("-> done");
    |                 ------------------------ in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `loom`
   --> src/tid.rs:185:15
    |
185 | #[cfg(not(all(loom, any(feature = "loom", test))))]
    |               ^^^^
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(loom)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(loom)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration

warning: unexpected `cfg` condition value: `loom`
   --> src/tid.rs:185:25
    |
185 | #[cfg(not(all(loom, any(feature = "loom", test))))]
    |                         ^^^^^^^^^^^^^^^^ help: remove the condition
    |
    = note: no expected values for `feature`
    = help: consider adding `loom` as a feature in `Cargo.toml`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration

warning: unexpected `cfg` condition name: `loom`
   --> src/tid.rs:197:21
    |
197 | #[cfg(all(test, not(loom)))]
    |                     ^^^^
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(loom)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(loom)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/lib.rs:422:9
    |
422 |         test_println!("insert {:?}", tid);
    |         --------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/lib.rs:457:9
    |
457 |         test_println!("vacant_entry {:?}", tid);
    |         --------------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/lib.rs:518:9
    |
518 |         test_println!("rm_deferred {:?}", tid);
    |         -------------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/lib.rs:584:9
    |
584 |         test_println!("rm {:?}", tid);
    |         ----------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/lib.rs:611:9
    |
611 |         test_println!("get {:?}; current={:?}", tid, Tid::<C>::current());
    |         ----------------------------------------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/lib.rs:709:9
    |
709 |         test_println!("get_owned {:?}; current={:?}", tid, Tid::<C>::current());
    |         ----------------------------------------------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/lib.rs:960:9
    |
960 |         test_println!("drop OwnedEntry: try clearing data");
    |         --------------------------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/lib.rs:971:13
    |
971 |             test_println!("-> shard={:?}", shard_idx);
    |             ----------------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unexpected `cfg` condition name: `slab_print`
   --> src/macros.rs:3:31
    |
  3 |         if cfg!(test) && cfg!(slab_print) {
    |                               ^^^^^^^^^^
    |
   ::: src/lib.rs:975:17
    |
975 |                 test_println!("-> shard={:?} does not exist! THIS IS A BUG", shard_idx);
    |                 ----------------------------------------------------------------------- in this macro invocation
    |
    = help: consider using a Cargo feature instead
    = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
             [lints.rust]
             unexpected_cfgs = { level = "warn", check-cfg = ['cfg(slab_print)'] }
    = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(slab_print)");` to the top of the `build.rs`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
    = note: this warning originates in the macro `test_println` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: `sharded-slab` (lib) generated 108 warnings
    Finished `rpm` profile [optimized + debuginfo] target(s) in 1.10s
+ RPM_EC=0
++ jobs -p
+ exit 0
Executing(%install): /bin/sh -e /home/pterjan/rpmbuild/tmp/rpm-tmp.jRquvL
+ umask 022
+ cd /home/pterjan/rpmbuild/BUILD/rust-sharded-slab-0.1.7-build
+ '[' 1 -eq 1 ']'
+ '[' /home/pterjan/rpmbuild/BUILD/rust-sharded-slab-0.1.7-build/BUILDROOT '!=' / ']'
+ rm -rf /home/pterjan/rpmbuild/BUILD/rust-sharded-slab-0.1.7-build/BUILDROOT
++ dirname /home/pterjan/rpmbuild/BUILD/rust-sharded-slab-0.1.7-build/BUILDROOT
+ mkdir -p /home/pterjan/rpmbuild/BUILD/rust-sharded-slab-0.1.7-build
+ mkdir /home/pterjan/rpmbuild/BUILD/rust-sharded-slab-0.1.7-build/BUILDROOT
+ CFLAGS='-O2 -g -pipe -Wformat -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -m64 -fasynchronous-unwind-tables -fstack-clash-protection -fcf-protection=full'
+ export CFLAGS
+ CXXFLAGS='-O2 -g -pipe -Wformat -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -m64 -fasynchronous-unwind-tables -fstack-clash-protection -fcf-protection=full'
+ export CXXFLAGS
+ FFLAGS='-O2 -g -pipe -Wformat -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -m64 -fasynchronous-unwind-tables -fstack-clash-protection -fcf-protection=full '
+ export FFLAGS
+ FCFLAGS='-O2 -g -pipe -Wformat -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -m64 -fasynchronous-unwind-tables -fstack-clash-protection -fcf-protection=full '
+ export FCFLAGS
+ VALAFLAGS=-g
+ export VALAFLAGS
+ RUSTFLAGS='-Copt-level=3 -Cdebuginfo=2 -Ccodegen-units=1 -Cstrip=none --cap-lints=warn'
+ export RUSTFLAGS
+ LDFLAGS='-Wl,--as-needed -Wl,--no-undefined -Wl,-z,relro -Wl,-z,now -Wl,-O1 -Wl,--build-id=sha1 -Wl,--enable-new-dtags -specs=/usr/lib/rpm/redhat/redhat-hardened-ld'
+ export LDFLAGS
+ LT_SYS_LIBRARY_PATH=/usr/lib:
+ export LT_SYS_LIBRARY_PATH
+ CC=gcc
+ export CC
+ CXX=g++
+ export CXX
+ cd sharded-slab-0.1.7
+ '[' 1 -eq 1 ']'
+ set -euo pipefail
++ /usr/bin/cargo2rpm --path Cargo.toml is-lib
+ '[' 1 -eq 1 ']'
+ '[' 1 -eq 1 ']'
++ /usr/bin/cargo2rpm --path Cargo.toml name
+ CRATE_NAME=sharded-slab
++ /usr/bin/cargo2rpm --path Cargo.toml version
+ CRATE_VERSION=0.1.7
+ REG_DIR=/home/pterjan/rpmbuild/BUILD/rust-sharded-slab-0.1.7-build/BUILDROOT/usr/share/cargo/registry/sharded-slab-0.1.7
+ /usr/bin/mkdir -p /home/pterjan/rpmbuild/BUILD/rust-sharded-slab-0.1.7-build/BUILDROOT/usr/share/cargo/registry/sharded-slab-0.1.7
+ /usr/bin/awk -i inplace -v INPLACE_SUFFIX=.deps '/^\[((.+\.)?((dev|build)-)?dependencies|features)/{f=1;next} /^\[/{f=0}; !f' Cargo.toml
+ /usr/bin/env CARGO_HOME=.cargo RUSTC_BOOTSTRAP=1 'RUSTFLAGS=-Copt-level=3 -Cdebuginfo=2 -Ccodegen-units=1 -Cstrip=none --cap-lints=warn' /usr/bin/cargo package -l
+ grep -w -E -v 'Cargo.(lock|toml.orig)'
+ xargs -d '\n' /usr/bin/cp --parents -a -t /home/pterjan/rpmbuild/BUILD/rust-sharded-slab-0.1.7-build/BUILDROOT/usr/share/cargo/registry/sharded-slab-0.1.7
warning: no (git) VCS found for `/home/pterjan/rpmbuild/BUILD/rust-sharded-slab-0.1.7-build/sharded-slab-0.1.7`
+ /usr/bin/mv Cargo.toml.deps Cargo.toml
+ /usr/bin/cp -a Cargo.toml /home/pterjan/rpmbuild/BUILD/rust-sharded-slab-0.1.7-build/BUILDROOT/usr/share/cargo/registry/sharded-slab-0.1.7/Cargo.toml
+ /usr/bin/rm -f /home/pterjan/rpmbuild/BUILD/rust-sharded-slab-0.1.7-build/BUILDROOT/usr/share/cargo/registry/sharded-slab-0.1.7/Cargo.toml.deps
+ echo '{"files":{},"package":""}'
++ /usr/bin/cargo2rpm --path Cargo.toml is-bin
+ '[' 0 -eq 1 ']'
+ /usr/lib/rpm/check-buildroot
+ '[' -n '' ']'
+ /usr/share/spec-helper/clean_files
+ '[' -n '' ']'
+ /usr/share/spec-helper/compress_files .xz
+ '[' -n '' ']'
+ /usr/share/spec-helper/relink_symlinks
+ '[' -n '' ']'
+ /usr/share/spec-helper/clean_perl
+ '[' -n '' ']'
+ /usr/share/spec-helper/lib_symlinks
+ '[' -n '' ']'
+ /usr/share/spec-helper/gprintify
+ '[' -n '' ']'
+ /usr/share/spec-helper/fix_mo
+ '[' -n '' ']'
+ /usr/share/spec-helper/fix_pamd
+ '[' -n '' ']'
+ /usr/share/spec-helper/remove_info_dir
+ '[' -n '' ']'
+ /usr/share/spec-helper/fix_eol
+ '[' -n '' ']'
+ /usr/share/spec-helper/check_desktop_files
+ '[' -n '' ']'
+ /usr/share/spec-helper/check_elf_files
+ /usr/lib/rpm/brp-strip /usr/bin/strip
+ /usr/lib/rpm/brp-strip-comment-note /usr/bin/strip /usr/bin/objdump
+ /usr/lib/rpm/brp-strip-static-archive /usr/bin/strip
+ /usr/lib/rpm/check-rpaths
+ /usr/lib/rpm/brp-remove-la-files
+ /usr/lib/rpm/redhat/brp-mangle-shebangs
mangling shebang in /usr/share/cargo/registry/sharded-slab-0.1.7/bin/loom.sh from /usr/bin/env bash to #!/usr/bin/bash
+ env -u SOURCE_DATE_EPOCH /usr/lib/rpm/redhat/brp-python-bytecompile '' 1 0 -j16
+ /usr/lib/rpm/redhat/brp-python-hardlink
Processing files: rust-sharded-slab-devel-0.1.7-0.2.mga10.noarch
warning: File listed twice: /usr/share/cargo/registry/sharded-slab-0.1.7/CHANGELOG.md
warning: File listed twice: /usr/share/cargo/registry/sharded-slab-0.1.7/IMPLEMENTATION.md
warning: File listed twice: /usr/share/cargo/registry/sharded-slab-0.1.7/LICENSE
warning: File listed twice: /usr/share/cargo/registry/sharded-slab-0.1.7/README.md
Provides: crate(sharded-slab) = 0.1.7 rust-sharded-slab-devel = 0.1.7-0.2.mga10
Requires(rpmlib): rpmlib(CompressedFileNames) <= 3.0.4-1 rpmlib(FileDigests) <= 4.6.0-1 rpmlib(PayloadFilesHavePrefix) <= 4.0-1
Requires: cargo crate(lazy_static/default) >= 1.0.0 rust >= 1.42.0
Processing files: rust-sharded-slab+default-devel-0.1.7-0.2.mga10.noarch
Provides: crate(sharded-slab/default) = 0.1.7 rust-sharded-slab+default-devel = 0.1.7-0.2.mga10
Requires(rpmlib): rpmlib(CompressedFileNames) <= 3.0.4-1 rpmlib(FileDigests) <= 4.6.0-1 rpmlib(PayloadFilesHavePrefix) <= 4.0-1
Requires: cargo crate(sharded-slab) = 0.1.7
Checking for unpackaged file(s): /usr/lib/rpm/check-files /home/pterjan/rpmbuild/BUILD/rust-sharded-slab-0.1.7-build/BUILDROOT
Wrote: /home/pterjan/rpmbuild/RPMS/noarch/rust-sharded-slab+default-devel-0.1.7-0.2.mga10.noarch.rpm
Wrote: /home/pterjan/rpmbuild/RPMS/noarch/rust-sharded-slab-devel-0.1.7-0.2.mga10.noarch.rpm
Executing(rmbuild): /bin/sh -e /home/pterjan/rpmbuild/tmp/rpm-tmp.JnyH3B
+ umask 022
+ cd /home/pterjan/rpmbuild/BUILD/rust-sharded-slab-0.1.7-build
+ test -d /home/pterjan/rpmbuild/BUILD/rust-sharded-slab-0.1.7-build
+ /usr/bin/chmod -Rf a+rX,u+w,g-w,o-w /home/pterjan/rpmbuild/BUILD/rust-sharded-slab-0.1.7-build
+ rm -rf /home/pterjan/rpmbuild/BUILD/rust-sharded-slab-0.1.7-build
+ RPM_EC=0
++ jobs -p
+ exit 0

RPM build warnings:
    File listed twice: /usr/share/cargo/registry/sharded-slab-0.1.7/CHANGELOG.md
    File listed twice: /usr/share/cargo/registry/sharded-slab-0.1.7/IMPLEMENTATION.md
    File listed twice: /usr/share/cargo/registry/sharded-slab-0.1.7/LICENSE
    File listed twice: /usr/share/cargo/registry/sharded-slab-0.1.7/README.md
D: [iurt_root_command] Success!
