Mock Version: 3.5
ENTER ['do_with_status'](['bash', '--login', '-c', '/usr/bin/rpmbuild -bs  --target s390x --nodeps /builddir/build/SPECS/rust-destructure_traitobject.spec'], chrootPath='/var/lib/mock/fedora-rawhide-s390x-1679431920.499448/root'env={'TERM': 'vt100', 'SHELL': '/bin/bash', 'HOME': '/builddir', 'HOSTNAME': 'mock', 'PATH': '/usr/bin:/bin:/usr/sbin:/sbin', 'PROMPT_COMMAND': 'printf "\\033]0;<mock-chroot>\\007"', 'PS1': '<mock-chroot> \\s-\\v\\$ ', 'LANG': 'C.UTF-8'}shell=Falselogger=<mockbuild.trace_decorator.getLog object at 0x3ffa2b079d0>timeout=0uid=1001gid=135user='mockbuild'nspawn_args=['--capability=cap_ipc_lock', '--rlimit=RLIMIT_NOFILE=10240', '--capability=cap_ipc_lock', '--bind=/tmp/mock-resolv.3ps3iqgo:/etc/resolv.conf', '--bind=/dev/btrfs-control', '--bind=/dev/mapper/control', '--bind=/dev/loop-control', '--bind=/dev/loop0', '--bind=/dev/loop1', '--bind=/dev/loop2', '--bind=/dev/loop3', '--bind=/dev/loop4', '--bind=/dev/loop5', '--bind=/dev/loop6', '--bind=/dev/loop7', '--bind=/dev/loop8', '--bind=/dev/loop9', '--bind=/dev/loop10', '--bind=/dev/loop11']unshare_net=TrueprintOutput=True)
Using nspawn with args ['--capability=cap_ipc_lock', '--rlimit=RLIMIT_NOFILE=10240', '--capability=cap_ipc_lock', '--bind=/tmp/mock-resolv.3ps3iqgo:/etc/resolv.conf', '--bind=/dev/btrfs-control', '--bind=/dev/mapper/control', '--bind=/dev/loop-control', '--bind=/dev/loop0', '--bind=/dev/loop1', '--bind=/dev/loop2', '--bind=/dev/loop3', '--bind=/dev/loop4', '--bind=/dev/loop5', '--bind=/dev/loop6', '--bind=/dev/loop7', '--bind=/dev/loop8', '--bind=/dev/loop9', '--bind=/dev/loop10', '--bind=/dev/loop11']
Executing command: ['/usr/bin/systemd-nspawn', '-q', '-M', '75afdfef418944e9a7224934416b06c6', '-D', '/var/lib/mock/fedora-rawhide-s390x-1679431920.499448/root', '-a', '-u', 'mockbuild', '--capability=cap_ipc_lock', '--rlimit=RLIMIT_NOFILE=10240', '--capability=cap_ipc_lock', '--bind=/tmp/mock-resolv.3ps3iqgo:/etc/resolv.conf', '--bind=/dev/btrfs-control', '--bind=/dev/mapper/control', '--bind=/dev/loop-control', '--bind=/dev/loop0', '--bind=/dev/loop1', '--bind=/dev/loop2', '--bind=/dev/loop3', '--bind=/dev/loop4', '--bind=/dev/loop5', '--bind=/dev/loop6', '--bind=/dev/loop7', '--bind=/dev/loop8', '--bind=/dev/loop9', '--bind=/dev/loop10', '--bind=/dev/loop11', '--console=pipe', '--setenv=TERM=vt100', '--setenv=SHELL=/bin/bash', '--setenv=HOME=/builddir', '--setenv=HOSTNAME=mock', '--setenv=PATH=/usr/bin:/bin:/usr/sbin:/sbin', '--setenv=PROMPT_COMMAND=printf "\\033]0;<mock-chroot>\\007"', '--setenv=PS1=<mock-chroot> \\s-\\v\\$ ', '--setenv=LANG=C.UTF-8', '--resolv-conf=off', 'bash', '--login', '-c', '/usr/bin/rpmbuild -bs  --target s390x --nodeps /builddir/build/SPECS/rust-destructure_traitobject.spec'] with env {'TERM': 'vt100', 'SHELL': '/bin/bash', 'HOME': '/builddir', 'HOSTNAME': 'mock', 'PATH': '/usr/bin:/bin:/usr/sbin:/sbin', 'PROMPT_COMMAND': 'printf "\\033]0;<mock-chroot>\\007"', 'PS1': '<mock-chroot> \\s-\\v\\$ ', 'LANG': 'C.UTF-8', 'SYSTEMD_NSPAWN_TMPFS_TMP': '0', 'SYSTEMD_SECCOMP': '0'} and shell False
Building target platforms: s390x
Building for target s390x
setting SOURCE_DATE_EPOCH=1679356800
Wrote: /builddir/build/SRPMS/rust-destructure_traitobject-0.2.0-1.fc39.src.rpm
Child return code was: 0
ENTER ['do_with_status'](['bash', '--login', '-c', '/usr/bin/rpmbuild -br  --target s390x --nodeps /builddir/build/SPECS/rust-destructure_traitobject.spec'], chrootPath='/var/lib/mock/fedora-rawhide-s390x-1679431920.499448/root'env={'TERM': 'vt100', 'SHELL': '/bin/bash', 'HOME': '/builddir', 'HOSTNAME': 'mock', 'PATH': '/usr/bin:/bin:/usr/sbin:/sbin', 'PROMPT_COMMAND': 'printf "\\033]0;<mock-chroot>\\007"', 'PS1': '<mock-chroot> \\s-\\v\\$ ', 'LANG': 'C.UTF-8'}shell=Falselogger=<mockbuild.trace_decorator.getLog object at 0x3ffa2b079d0>timeout=0uid=1001gid=135user='mockbuild'nspawn_args=['--capability=cap_ipc_lock', '--rlimit=RLIMIT_NOFILE=10240', '--capability=cap_ipc_lock', '--bind=/tmp/mock-resolv.3ps3iqgo:/etc/resolv.conf', '--bind=/dev/btrfs-control', '--bind=/dev/mapper/control', '--bind=/dev/loop-control', '--bind=/dev/loop0', '--bind=/dev/loop1', '--bind=/dev/loop2', '--bind=/dev/loop3', '--bind=/dev/loop4', '--bind=/dev/loop5', '--bind=/dev/loop6', '--bind=/dev/loop7', '--bind=/dev/loop8', '--bind=/dev/loop9', '--bind=/dev/loop10', '--bind=/dev/loop11']unshare_net=TrueraiseExc=FalseprintOutput=True)
Using nspawn with args ['--capability=cap_ipc_lock', '--rlimit=RLIMIT_NOFILE=10240', '--capability=cap_ipc_lock', '--bind=/tmp/mock-resolv.3ps3iqgo:/etc/resolv.conf', '--bind=/dev/btrfs-control', '--bind=/dev/mapper/control', '--bind=/dev/loop-control', '--bind=/dev/loop0', '--bind=/dev/loop1', '--bind=/dev/loop2', '--bind=/dev/loop3', '--bind=/dev/loop4', '--bind=/dev/loop5', '--bind=/dev/loop6', '--bind=/dev/loop7', '--bind=/dev/loop8', '--bind=/dev/loop9', '--bind=/dev/loop10', '--bind=/dev/loop11']
Executing command: ['/usr/bin/systemd-nspawn', '-q', '-M', '9f00ddf06bf54a28a4035e646772b75f', '-D', '/var/lib/mock/fedora-rawhide-s390x-1679431920.499448/root', '-a', '-u', 'mockbuild', '--capability=cap_ipc_lock', '--rlimit=RLIMIT_NOFILE=10240', '--capability=cap_ipc_lock', '--bind=/tmp/mock-resolv.3ps3iqgo:/etc/resolv.conf', '--bind=/dev/btrfs-control', '--bind=/dev/mapper/control', '--bind=/dev/loop-control', '--bind=/dev/loop0', '--bind=/dev/loop1', '--bind=/dev/loop2', '--bind=/dev/loop3', '--bind=/dev/loop4', '--bind=/dev/loop5', '--bind=/dev/loop6', '--bind=/dev/loop7', '--bind=/dev/loop8', '--bind=/dev/loop9', '--bind=/dev/loop10', '--bind=/dev/loop11', '--console=pipe', '--setenv=TERM=vt100', '--setenv=SHELL=/bin/bash', '--setenv=HOME=/builddir', '--setenv=HOSTNAME=mock', '--setenv=PATH=/usr/bin:/bin:/usr/sbin:/sbin', '--setenv=PROMPT_COMMAND=printf "\\033]0;<mock-chroot>\\007"', '--setenv=PS1=<mock-chroot> \\s-\\v\\$ ', '--setenv=LANG=C.UTF-8', '--resolv-conf=off', 'bash', '--login', '-c', '/usr/bin/rpmbuild -br  --target s390x --nodeps /builddir/build/SPECS/rust-destructure_traitobject.spec'] with env {'TERM': 'vt100', 'SHELL': '/bin/bash', 'HOME': '/builddir', 'HOSTNAME': 'mock', 'PATH': '/usr/bin:/bin:/usr/sbin:/sbin', 'PROMPT_COMMAND': 'printf "\\033]0;<mock-chroot>\\007"', 'PS1': '<mock-chroot> \\s-\\v\\$ ', 'LANG': 'C.UTF-8', 'SYSTEMD_NSPAWN_TMPFS_TMP': '0', 'SYSTEMD_SECCOMP': '0'} and shell False
Building target platforms: s390x
Building for target s390x
setting SOURCE_DATE_EPOCH=1679356800
Executing(%prep): /bin/sh -e /var/tmp/rpm-tmp.WR0043
+ umask 022
+ cd /builddir/build/BUILD
+ cd /builddir/build/BUILD
+ rm -rf destructure_traitobject-0.2.0
+ /usr/lib/rpm/rpmuncompress -x /builddir/build/SOURCES/destructure_traitobject-0.2.0.crate
+ STATUS=0
+ '[' 0 -ne 0 ']'
+ cd destructure_traitobject-0.2.0
+ /usr/bin/chmod -Rf a+rX,u+w,g-w,o-w .
+ set -eu
+ /usr/bin/mkdir -p .cargo
+ 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 /var/tmp/rpm-tmp.quLpWJ
+ umask 022
+ cd /builddir/build/BUILD
+ cd destructure_traitobject-0.2.0
+ /usr/bin/cargo2rpm --path Cargo.toml buildrequires --with-check
+ RPM_EC=0
++ jobs -p
+ exit 0
Wrote: /builddir/build/SRPMS/rust-destructure_traitobject-0.2.0-1.fc39.buildreqs.nosrc.rpm
Child return code was: 11
Dynamic buildrequires detected
Going to install missing buildrequires. See root.log for details.
ENTER ['do_with_status'](['bash', '--login', '-c', '/usr/bin/rpmbuild -ba --noprep  --target s390x --nodeps /builddir/build/SPECS/rust-destructure_traitobject.spec'], chrootPath='/var/lib/mock/fedora-rawhide-s390x-1679431920.499448/root'env={'TERM': 'vt100', 'SHELL': '/bin/bash', 'HOME': '/builddir', 'HOSTNAME': 'mock', 'PATH': '/usr/bin:/bin:/usr/sbin:/sbin', 'PROMPT_COMMAND': 'printf "\\033]0;<mock-chroot>\\007"', 'PS1': '<mock-chroot> \\s-\\v\\$ ', 'LANG': 'C.UTF-8'}shell=Falselogger=<mockbuild.trace_decorator.getLog object at 0x3ffa2b079d0>timeout=0uid=1001gid=135user='mockbuild'nspawn_args=['--capability=cap_ipc_lock', '--rlimit=RLIMIT_NOFILE=10240', '--capability=cap_ipc_lock', '--bind=/tmp/mock-resolv.3ps3iqgo:/etc/resolv.conf', '--bind=/dev/btrfs-control', '--bind=/dev/mapper/control', '--bind=/dev/loop-control', '--bind=/dev/loop0', '--bind=/dev/loop1', '--bind=/dev/loop2', '--bind=/dev/loop3', '--bind=/dev/loop4', '--bind=/dev/loop5', '--bind=/dev/loop6', '--bind=/dev/loop7', '--bind=/dev/loop8', '--bind=/dev/loop9', '--bind=/dev/loop10', '--bind=/dev/loop11']unshare_net=TrueprintOutput=True)
Using nspawn with args ['--capability=cap_ipc_lock', '--rlimit=RLIMIT_NOFILE=10240', '--capability=cap_ipc_lock', '--bind=/tmp/mock-resolv.3ps3iqgo:/etc/resolv.conf', '--bind=/dev/btrfs-control', '--bind=/dev/mapper/control', '--bind=/dev/loop-control', '--bind=/dev/loop0', '--bind=/dev/loop1', '--bind=/dev/loop2', '--bind=/dev/loop3', '--bind=/dev/loop4', '--bind=/dev/loop5', '--bind=/dev/loop6', '--bind=/dev/loop7', '--bind=/dev/loop8', '--bind=/dev/loop9', '--bind=/dev/loop10', '--bind=/dev/loop11']
Executing command: ['/usr/bin/systemd-nspawn', '-q', '-M', '7e61f2c76b9c4db7b6254a64a3bca5d7', '-D', '/var/lib/mock/fedora-rawhide-s390x-1679431920.499448/root', '-a', '-u', 'mockbuild', '--capability=cap_ipc_lock', '--rlimit=RLIMIT_NOFILE=10240', '--capability=cap_ipc_lock', '--bind=/tmp/mock-resolv.3ps3iqgo:/etc/resolv.conf', '--bind=/dev/btrfs-control', '--bind=/dev/mapper/control', '--bind=/dev/loop-control', '--bind=/dev/loop0', '--bind=/dev/loop1', '--bind=/dev/loop2', '--bind=/dev/loop3', '--bind=/dev/loop4', '--bind=/dev/loop5', '--bind=/dev/loop6', '--bind=/dev/loop7', '--bind=/dev/loop8', '--bind=/dev/loop9', '--bind=/dev/loop10', '--bind=/dev/loop11', '--console=pipe', '--setenv=TERM=vt100', '--setenv=SHELL=/bin/bash', '--setenv=HOME=/builddir', '--setenv=HOSTNAME=mock', '--setenv=PATH=/usr/bin:/bin:/usr/sbin:/sbin', '--setenv=PROMPT_COMMAND=printf "\\033]0;<mock-chroot>\\007"', '--setenv=PS1=<mock-chroot> \\s-\\v\\$ ', '--setenv=LANG=C.UTF-8', '--resolv-conf=off', 'bash', '--login', '-c', '/usr/bin/rpmbuild -ba --noprep  --target s390x --nodeps /builddir/build/SPECS/rust-destructure_traitobject.spec'] with env {'TERM': 'vt100', 'SHELL': '/bin/bash', 'HOME': '/builddir', 'HOSTNAME': 'mock', 'PATH': '/usr/bin:/bin:/usr/sbin:/sbin', 'PROMPT_COMMAND': 'printf "\\033]0;<mock-chroot>\\007"', 'PS1': '<mock-chroot> \\s-\\v\\$ ', 'LANG': 'C.UTF-8', 'SYSTEMD_NSPAWN_TMPFS_TMP': '0', 'SYSTEMD_SECCOMP': '0'} and shell False
Building target platforms: s390x
Building for target s390x
setting SOURCE_DATE_EPOCH=1679356800
Executing(%generate_buildrequires): /bin/sh -e /var/tmp/rpm-tmp.5irnLO
+ umask 022
+ cd /builddir/build/BUILD
+ cd destructure_traitobject-0.2.0
+ /usr/bin/cargo2rpm --path Cargo.toml buildrequires --with-check
+ RPM_EC=0
++ jobs -p
+ exit 0
Executing(%build): /bin/sh -e /var/tmp/rpm-tmp.xrLQos
+ umask 022
+ cd /builddir/build/BUILD
+ CFLAGS='-O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -m64 -march=z13 -mtune=z14 -fasynchronous-unwind-tables -fstack-clash-protection '
+ export CFLAGS
+ CXXFLAGS='-O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -m64 -march=z13 -mtune=z14 -fasynchronous-unwind-tables -fstack-clash-protection '
+ export CXXFLAGS
+ FFLAGS='-O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -m64 -march=z13 -mtune=z14 -fasynchronous-unwind-tables -fstack-clash-protection -I/usr/lib64/gfortran/modules '
+ export FFLAGS
+ FCFLAGS='-O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -m64 -march=z13 -mtune=z14 -fasynchronous-unwind-tables -fstack-clash-protection -I/usr/lib64/gfortran/modules '
+ export FCFLAGS
+ VALAFLAGS=-g
+ export VALAFLAGS
+ RUSTFLAGS='-Copt-level=3 -Cdebuginfo=2 -Ccodegen-units=1 -Clink-arg=-Wl,-z,relro -Clink-arg=-Wl,-z,now -Clink-arg=-specs=/usr/lib/rpm/redhat/redhat-package-notes --cap-lints=warn'
+ export RUSTFLAGS
+ LDFLAGS='-Wl,-z,relro -Wl,--as-needed  -Wl,-z,now -specs=/usr/lib/rpm/redhat/redhat-hardened-ld -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -Wl,--build-id=sha1 -specs=/usr/lib/rpm/redhat/redhat-package-notes '
+ export LDFLAGS
+ LT_SYS_LIBRARY_PATH=/usr/lib64:
+ export LT_SYS_LIBRARY_PATH
+ CC=gcc
+ export CC
+ CXX=g++
+ export CXX
+ cd destructure_traitobject-0.2.0
+ /usr/bin/env CARGO_HOME=.cargo RUSTC_BOOTSTRAP=1 'RUSTFLAGS=-Copt-level=3 -Cdebuginfo=2 -Ccodegen-units=1 -Clink-arg=-Wl,-z,relro -Clink-arg=-Wl,-z,now -Clink-arg=-specs=/usr/lib/rpm/redhat/redhat-package-notes --cap-lints=warn' /usr/bin/cargo build -j2 -Z avoid-dev-deps --release
   Compiling destructure_traitobject v0.2.0 (/builddir/build/BUILD/destructure_traitobject-0.2.0)
     Running `/usr/bin/rustc --crate-name destructure_traitobject 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 metadata=e805baf83691f643 -C extra-filename=-e805baf83691f643 --out-dir /builddir/build/BUILD/destructure_traitobject-0.2.0/target/release/deps -L dependency=/builddir/build/BUILD/destructure_traitobject-0.2.0/target/release/deps -Copt-level=3 -Cdebuginfo=2 -Ccodegen-units=1 -Clink-arg=-Wl,-z,relro -Clink-arg=-Wl,-z,now -Clink-arg=-specs=/usr/lib/rpm/redhat/redhat-package-notes --cap-lints=warn`
warning: trait objects without an explicit `dyn` are deprecated
 --> src/impls.rs:3:23
  |
3 | unsafe impl Trait for Send { }
  |                       ^^^^
  |
  = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
  = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
  = note: `#[warn(bare_trait_objects)]` on by default
help: use `dyn`
  |
3 | unsafe impl Trait for dyn Send { }
  |                       +++
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `Send`
  |
3 | unsafe impl<T: Send> Trait for T { }
  |            +++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
 --> src/impls.rs:4:23
  |
4 | unsafe impl Trait for Sync { }
  |                       ^^^^
  |
  = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
  = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
  |
4 | unsafe impl Trait for dyn Sync { }
  |                       +++
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `Sync`
  |
4 | unsafe impl<T: Sync> Trait for T { }
  |            +++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
 --> src/impls.rs:5:23
  |
5 | unsafe impl Trait for Send + Sync { }
  |                       ^^^^^^^^^^^
  |
  = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
  = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
  |
5 | unsafe impl Trait for dyn Send + Sync { }
  |                       +++
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `Send + Sync`
  |
5 | unsafe impl<T: Send + Sync> Trait for T { }
  |            ++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
 --> src/impls.rs:6:23
  |
6 | unsafe impl Trait for ::std::any::Any + Send { }
  |                       ^^^^^^^^^^^^^^^^^^^^^^
  |
  = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
  = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
  |
6 | unsafe impl Trait for dyn (::std::any::Any + Send) { }
  |                       +++++                      +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::any::Any + Send`
  |
6 | unsafe impl<T: ::std::any::Any + Send> Trait for T { }
  |            +++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
 --> src/impls.rs:7:23
  |
7 | unsafe impl Trait for ::std::any::Any + Sync { }
  |                       ^^^^^^^^^^^^^^^^^^^^^^
  |
  = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
  = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
  |
7 | unsafe impl Trait for dyn (::std::any::Any + Sync) { }
  |                       +++++                      +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::any::Any + Sync`
  |
7 | unsafe impl<T: ::std::any::Any + Sync> Trait for T { }
  |            +++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
 --> src/impls.rs:8:23
  |
8 | unsafe impl Trait for ::std::any::Any + Send + Sync { }
  |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  |
  = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
  = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
  |
8 | unsafe impl Trait for dyn (::std::any::Any + Send + Sync) { }
  |                       +++++                             +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::any::Any + Send + Sync`
  |
8 | unsafe impl<T: ::std::any::Any + Send + Sync> Trait for T { }
  |            ++++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
 --> src/impls.rs:9:34
  |
9 | unsafe impl<T: ?Sized> Trait for ::std::borrow::Borrow<T> + Send { }
  |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  |
  = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
  = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
  |
9 | unsafe impl<T: ?Sized> Trait for dyn (::std::borrow::Borrow<T> + Send) { }
  |                                  +++++                               +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::borrow::Borrow<T> + Send`
  |
9 | unsafe impl<T: ?Sized, U: ::std::borrow::Borrow<T> + Send> Trait for U { }
  |                      ++++++++++++++++++++++++++++++++++++            ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:10:34
   |
10 | unsafe impl<T: ?Sized> Trait for ::std::borrow::Borrow<T> + Sync { }
   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
10 | unsafe impl<T: ?Sized> Trait for dyn (::std::borrow::Borrow<T> + Sync) { }
   |                                  +++++                               +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::borrow::Borrow<T> + Sync`
   |
10 | unsafe impl<T: ?Sized, U: ::std::borrow::Borrow<T> + Sync> Trait for U { }
   |                      ++++++++++++++++++++++++++++++++++++            ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:11:34
   |
11 | unsafe impl<T: ?Sized> Trait for ::std::borrow::Borrow<T> + Send + Sync { }
   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
11 | unsafe impl<T: ?Sized> Trait for dyn (::std::borrow::Borrow<T> + Send + Sync) { }
   |                                  +++++                                      +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::borrow::Borrow<T> + Send + Sync`
   |
11 | unsafe impl<T: ?Sized, U: ::std::borrow::Borrow<T> + Send + Sync> Trait for U { }
   |                      +++++++++++++++++++++++++++++++++++++++++++            ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:12:34
   |
12 | unsafe impl<T: ?Sized> Trait for ::std::borrow::BorrowMut<T> + Send { }
   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
12 | unsafe impl<T: ?Sized> Trait for dyn (::std::borrow::BorrowMut<T> + Send) { }
   |                                  +++++                                  +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::borrow::BorrowMut<T> + Send`
   |
12 | unsafe impl<T: ?Sized, U: ::std::borrow::BorrowMut<T> + Send> Trait for U { }
   |                      +++++++++++++++++++++++++++++++++++++++            ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:13:34
   |
13 | unsafe impl<T: ?Sized> Trait for ::std::borrow::BorrowMut<T> + Sync { }
   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
13 | unsafe impl<T: ?Sized> Trait for dyn (::std::borrow::BorrowMut<T> + Sync) { }
   |                                  +++++                                  +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::borrow::BorrowMut<T> + Sync`
   |
13 | unsafe impl<T: ?Sized, U: ::std::borrow::BorrowMut<T> + Sync> Trait for U { }
   |                      +++++++++++++++++++++++++++++++++++++++            ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:14:34
   |
14 | unsafe impl<T: ?Sized> Trait for ::std::borrow::BorrowMut<T> + Send + Sync { }
   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
14 | unsafe impl<T: ?Sized> Trait for dyn (::std::borrow::BorrowMut<T> + Send + Sync) { }
   |                                  +++++                                         +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::borrow::BorrowMut<T> + Send + Sync`
   |
14 | unsafe impl<T: ?Sized, U: ::std::borrow::BorrowMut<T> + Send + Sync> Trait for U { }
   |                      ++++++++++++++++++++++++++++++++++++++++++++++            ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:15:34
   |
15 | unsafe impl<T: ?Sized> Trait for ::std::convert::AsMut<T> + Send { }
   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
15 | unsafe impl<T: ?Sized> Trait for dyn (::std::convert::AsMut<T> + Send) { }
   |                                  +++++                               +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::convert::AsMut<T> + Send`
   |
15 | unsafe impl<T: ?Sized, U: ::std::convert::AsMut<T> + Send> Trait for U { }
   |                      ++++++++++++++++++++++++++++++++++++            ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:16:34
   |
16 | unsafe impl<T: ?Sized> Trait for ::std::convert::AsMut<T> + Sync { }
   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
16 | unsafe impl<T: ?Sized> Trait for dyn (::std::convert::AsMut<T> + Sync) { }
   |                                  +++++                               +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::convert::AsMut<T> + Sync`
   |
16 | unsafe impl<T: ?Sized, U: ::std::convert::AsMut<T> + Sync> Trait for U { }
   |                      ++++++++++++++++++++++++++++++++++++            ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:17:34
   |
17 | unsafe impl<T: ?Sized> Trait for ::std::convert::AsMut<T> + Send + Sync { }
   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
17 | unsafe impl<T: ?Sized> Trait for dyn (::std::convert::AsMut<T> + Send + Sync) { }
   |                                  +++++                                      +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::convert::AsMut<T> + Send + Sync`
   |
17 | unsafe impl<T: ?Sized, U: ::std::convert::AsMut<T> + Send + Sync> Trait for U { }
   |                      +++++++++++++++++++++++++++++++++++++++++++            ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:18:34
   |
18 | unsafe impl<T: ?Sized> Trait for ::std::convert::AsRef<T> + Send { }
   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
18 | unsafe impl<T: ?Sized> Trait for dyn (::std::convert::AsRef<T> + Send) { }
   |                                  +++++                               +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::convert::AsRef<T> + Send`
   |
18 | unsafe impl<T: ?Sized, U: ::std::convert::AsRef<T> + Send> Trait for U { }
   |                      ++++++++++++++++++++++++++++++++++++            ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:19:34
   |
19 | unsafe impl<T: ?Sized> Trait for ::std::convert::AsRef<T> + Sync { }
   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
19 | unsafe impl<T: ?Sized> Trait for dyn (::std::convert::AsRef<T> + Sync) { }
   |                                  +++++                               +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::convert::AsRef<T> + Sync`
   |
19 | unsafe impl<T: ?Sized, U: ::std::convert::AsRef<T> + Sync> Trait for U { }
   |                      ++++++++++++++++++++++++++++++++++++            ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:20:34
   |
20 | unsafe impl<T: ?Sized> Trait for ::std::convert::AsRef<T> + Send + Sync { }
   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
20 | unsafe impl<T: ?Sized> Trait for dyn (::std::convert::AsRef<T> + Send + Sync) { }
   |                                  +++++                                      +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::convert::AsRef<T> + Send + Sync`
   |
20 | unsafe impl<T: ?Sized, U: ::std::convert::AsRef<T> + Send + Sync> Trait for U { }
   |                      +++++++++++++++++++++++++++++++++++++++++++            ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:21:23
   |
21 | unsafe impl Trait for ::std::error::Error + Send { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
21 | unsafe impl Trait for dyn (::std::error::Error + Send) { }
   |                       +++++                          +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::error::Error + Send`
   |
21 | unsafe impl<T: ::std::error::Error + Send> Trait for T { }
   |            +++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:22:23
   |
22 | unsafe impl Trait for ::std::error::Error + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
22 | unsafe impl Trait for dyn (::std::error::Error + Sync) { }
   |                       +++++                          +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::error::Error + Sync`
   |
22 | unsafe impl<T: ::std::error::Error + Sync> Trait for T { }
   |            +++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:23:23
   |
23 | unsafe impl Trait for ::std::error::Error + Send + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
23 | unsafe impl Trait for dyn (::std::error::Error + Send + Sync) { }
   |                       +++++                                 +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::error::Error + Send + Sync`
   |
23 | unsafe impl<T: ::std::error::Error + Send + Sync> Trait for T { }
   |            ++++++++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:24:23
   |
24 | unsafe impl Trait for ::std::fmt::Binary + Send { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
24 | unsafe impl Trait for dyn (::std::fmt::Binary + Send) { }
   |                       +++++                         +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::Binary + Send`
   |
24 | unsafe impl<T: ::std::fmt::Binary + Send> Trait for T { }
   |            ++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:25:23
   |
25 | unsafe impl Trait for ::std::fmt::Binary + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
25 | unsafe impl Trait for dyn (::std::fmt::Binary + Sync) { }
   |                       +++++                         +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::Binary + Sync`
   |
25 | unsafe impl<T: ::std::fmt::Binary + Sync> Trait for T { }
   |            ++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:26:23
   |
26 | unsafe impl Trait for ::std::fmt::Binary + Send + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
26 | unsafe impl Trait for dyn (::std::fmt::Binary + Send + Sync) { }
   |                       +++++                                +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::Binary + Send + Sync`
   |
26 | unsafe impl<T: ::std::fmt::Binary + Send + Sync> Trait for T { }
   |            +++++++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:27:23
   |
27 | unsafe impl Trait for ::std::fmt::Debug + Send { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
27 | unsafe impl Trait for dyn (::std::fmt::Debug + Send) { }
   |                       +++++                        +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::Debug + Send`
   |
27 | unsafe impl<T: ::std::fmt::Debug + Send> Trait for T { }
   |            +++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:28:23
   |
28 | unsafe impl Trait for ::std::fmt::Debug + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
28 | unsafe impl Trait for dyn (::std::fmt::Debug + Sync) { }
   |                       +++++                        +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::Debug + Sync`
   |
28 | unsafe impl<T: ::std::fmt::Debug + Sync> Trait for T { }
   |            +++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:29:23
   |
29 | unsafe impl Trait for ::std::fmt::Debug + Send + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
29 | unsafe impl Trait for dyn (::std::fmt::Debug + Send + Sync) { }
   |                       +++++                               +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::Debug + Send + Sync`
   |
29 | unsafe impl<T: ::std::fmt::Debug + Send + Sync> Trait for T { }
   |            ++++++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:30:23
   |
30 | unsafe impl Trait for ::std::fmt::Display + Send { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
30 | unsafe impl Trait for dyn (::std::fmt::Display + Send) { }
   |                       +++++                          +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::Display + Send`
   |
30 | unsafe impl<T: ::std::fmt::Display + Send> Trait for T { }
   |            +++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:31:23
   |
31 | unsafe impl Trait for ::std::fmt::Display + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
31 | unsafe impl Trait for dyn (::std::fmt::Display + Sync) { }
   |                       +++++                          +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::Display + Sync`
   |
31 | unsafe impl<T: ::std::fmt::Display + Sync> Trait for T { }
   |            +++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:32:23
   |
32 | unsafe impl Trait for ::std::fmt::Display + Send + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
32 | unsafe impl Trait for dyn (::std::fmt::Display + Send + Sync) { }
   |                       +++++                                 +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::Display + Send + Sync`
   |
32 | unsafe impl<T: ::std::fmt::Display + Send + Sync> Trait for T { }
   |            ++++++++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:33:23
   |
33 | unsafe impl Trait for ::std::fmt::LowerExp + Send { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
33 | unsafe impl Trait for dyn (::std::fmt::LowerExp + Send) { }
   |                       +++++                           +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::LowerExp + Send`
   |
33 | unsafe impl<T: ::std::fmt::LowerExp + Send> Trait for T { }
   |            ++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:34:23
   |
34 | unsafe impl Trait for ::std::fmt::LowerExp + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
34 | unsafe impl Trait for dyn (::std::fmt::LowerExp + Sync) { }
   |                       +++++                           +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::LowerExp + Sync`
   |
34 | unsafe impl<T: ::std::fmt::LowerExp + Sync> Trait for T { }
   |            ++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:35:23
   |
35 | unsafe impl Trait for ::std::fmt::LowerExp + Send + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
35 | unsafe impl Trait for dyn (::std::fmt::LowerExp + Send + Sync) { }
   |                       +++++                                  +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::LowerExp + Send + Sync`
   |
35 | unsafe impl<T: ::std::fmt::LowerExp + Send + Sync> Trait for T { }
   |            +++++++++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:36:23
   |
36 | unsafe impl Trait for ::std::fmt::LowerHex + Send { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
36 | unsafe impl Trait for dyn (::std::fmt::LowerHex + Send) { }
   |                       +++++                           +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::LowerHex + Send`
   |
36 | unsafe impl<T: ::std::fmt::LowerHex + Send> Trait for T { }
   |            ++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:37:23
   |
37 | unsafe impl Trait for ::std::fmt::LowerHex + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
37 | unsafe impl Trait for dyn (::std::fmt::LowerHex + Sync) { }
   |                       +++++                           +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::LowerHex + Sync`
   |
37 | unsafe impl<T: ::std::fmt::LowerHex + Sync> Trait for T { }
   |            ++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:38:23
   |
38 | unsafe impl Trait for ::std::fmt::LowerHex + Send + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
38 | unsafe impl Trait for dyn (::std::fmt::LowerHex + Send + Sync) { }
   |                       +++++                                  +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::LowerHex + Send + Sync`
   |
38 | unsafe impl<T: ::std::fmt::LowerHex + Send + Sync> Trait for T { }
   |            +++++++++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:39:23
   |
39 | unsafe impl Trait for ::std::fmt::Octal + Send { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
39 | unsafe impl Trait for dyn (::std::fmt::Octal + Send) { }
   |                       +++++                        +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::Octal + Send`
   |
39 | unsafe impl<T: ::std::fmt::Octal + Send> Trait for T { }
   |            +++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:40:23
   |
40 | unsafe impl Trait for ::std::fmt::Octal + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
40 | unsafe impl Trait for dyn (::std::fmt::Octal + Sync) { }
   |                       +++++                        +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::Octal + Sync`
   |
40 | unsafe impl<T: ::std::fmt::Octal + Sync> Trait for T { }
   |            +++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:41:23
   |
41 | unsafe impl Trait for ::std::fmt::Octal + Send + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
41 | unsafe impl Trait for dyn (::std::fmt::Octal + Send + Sync) { }
   |                       +++++                               +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::Octal + Send + Sync`
   |
41 | unsafe impl<T: ::std::fmt::Octal + Send + Sync> Trait for T { }
   |            ++++++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:42:23
   |
42 | unsafe impl Trait for ::std::fmt::Pointer + Send { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
42 | unsafe impl Trait for dyn (::std::fmt::Pointer + Send) { }
   |                       +++++                          +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::Pointer + Send`
   |
42 | unsafe impl<T: ::std::fmt::Pointer + Send> Trait for T { }
   |            +++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:43:23
   |
43 | unsafe impl Trait for ::std::fmt::Pointer + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
43 | unsafe impl Trait for dyn (::std::fmt::Pointer + Sync) { }
   |                       +++++                          +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::Pointer + Sync`
   |
43 | unsafe impl<T: ::std::fmt::Pointer + Sync> Trait for T { }
   |            +++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:44:23
   |
44 | unsafe impl Trait for ::std::fmt::Pointer + Send + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
44 | unsafe impl Trait for dyn (::std::fmt::Pointer + Send + Sync) { }
   |                       +++++                                 +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::Pointer + Send + Sync`
   |
44 | unsafe impl<T: ::std::fmt::Pointer + Send + Sync> Trait for T { }
   |            ++++++++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:45:23
   |
45 | unsafe impl Trait for ::std::fmt::UpperExp + Send { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
45 | unsafe impl Trait for dyn (::std::fmt::UpperExp + Send) { }
   |                       +++++                           +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::UpperExp + Send`
   |
45 | unsafe impl<T: ::std::fmt::UpperExp + Send> Trait for T { }
   |            ++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:46:23
   |
46 | unsafe impl Trait for ::std::fmt::UpperExp + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
46 | unsafe impl Trait for dyn (::std::fmt::UpperExp + Sync) { }
   |                       +++++                           +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::UpperExp + Sync`
   |
46 | unsafe impl<T: ::std::fmt::UpperExp + Sync> Trait for T { }
   |            ++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:47:23
   |
47 | unsafe impl Trait for ::std::fmt::UpperExp + Send + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
47 | unsafe impl Trait for dyn (::std::fmt::UpperExp + Send + Sync) { }
   |                       +++++                                  +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::UpperExp + Send + Sync`
   |
47 | unsafe impl<T: ::std::fmt::UpperExp + Send + Sync> Trait for T { }
   |            +++++++++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:48:23
   |
48 | unsafe impl Trait for ::std::fmt::UpperHex + Send { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
48 | unsafe impl Trait for dyn (::std::fmt::UpperHex + Send) { }
   |                       +++++                           +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::UpperHex + Send`
   |
48 | unsafe impl<T: ::std::fmt::UpperHex + Send> Trait for T { }
   |            ++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:49:23
   |
49 | unsafe impl Trait for ::std::fmt::UpperHex + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
49 | unsafe impl Trait for dyn (::std::fmt::UpperHex + Sync) { }
   |                       +++++                           +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::UpperHex + Sync`
   |
49 | unsafe impl<T: ::std::fmt::UpperHex + Sync> Trait for T { }
   |            ++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:50:23
   |
50 | unsafe impl Trait for ::std::fmt::UpperHex + Send + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
50 | unsafe impl Trait for dyn (::std::fmt::UpperHex + Send + Sync) { }
   |                       +++++                                  +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::UpperHex + Send + Sync`
   |
50 | unsafe impl<T: ::std::fmt::UpperHex + Send + Sync> Trait for T { }
   |            +++++++++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:51:23
   |
51 | unsafe impl Trait for ::std::fmt::Write + Send { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
51 | unsafe impl Trait for dyn (::std::fmt::Write + Send) { }
   |                       +++++                        +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::Write + Send`
   |
51 | unsafe impl<T: ::std::fmt::Write + Send> Trait for T { }
   |            +++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:52:23
   |
52 | unsafe impl Trait for ::std::fmt::Write + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
52 | unsafe impl Trait for dyn (::std::fmt::Write + Sync) { }
   |                       +++++                        +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::Write + Sync`
   |
52 | unsafe impl<T: ::std::fmt::Write + Sync> Trait for T { }
   |            +++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:53:23
   |
53 | unsafe impl Trait for ::std::fmt::Write + Send + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
53 | unsafe impl Trait for dyn (::std::fmt::Write + Send + Sync) { }
   |                       +++++                               +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::Write + Send + Sync`
   |
53 | unsafe impl<T: ::std::fmt::Write + Send + Sync> Trait for T { }
   |            ++++++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:54:23
   |
54 | unsafe impl Trait for ::std::hash::Hasher + Send { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
54 | unsafe impl Trait for dyn (::std::hash::Hasher + Send) { }
   |                       +++++                          +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::hash::Hasher + Send`
   |
54 | unsafe impl<T: ::std::hash::Hasher + Send> Trait for T { }
   |            +++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:55:23
   |
55 | unsafe impl Trait for ::std::hash::Hasher + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
55 | unsafe impl Trait for dyn (::std::hash::Hasher + Sync) { }
   |                       +++++                          +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::hash::Hasher + Sync`
   |
55 | unsafe impl<T: ::std::hash::Hasher + Sync> Trait for T { }
   |            +++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:56:23
   |
56 | unsafe impl Trait for ::std::hash::Hasher + Send + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
56 | unsafe impl Trait for dyn (::std::hash::Hasher + Send + Sync) { }
   |                       +++++                                 +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::hash::Hasher + Send + Sync`
   |
56 | unsafe impl<T: ::std::hash::Hasher + Send + Sync> Trait for T { }
   |            ++++++++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:57:23
   |
57 | unsafe impl Trait for ::std::io::BufRead + Send { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
57 | unsafe impl Trait for dyn (::std::io::BufRead + Send) { }
   |                       +++++                         +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::io::BufRead + Send`
   |
57 | unsafe impl<T: ::std::io::BufRead + Send> Trait for T { }
   |            ++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:58:23
   |
58 | unsafe impl Trait for ::std::io::BufRead + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
58 | unsafe impl Trait for dyn (::std::io::BufRead + Sync) { }
   |                       +++++                         +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::io::BufRead + Sync`
   |
58 | unsafe impl<T: ::std::io::BufRead + Sync> Trait for T { }
   |            ++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:59:23
   |
59 | unsafe impl Trait for ::std::io::BufRead + Send + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
59 | unsafe impl Trait for dyn (::std::io::BufRead + Send + Sync) { }
   |                       +++++                                +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::io::BufRead + Send + Sync`
   |
59 | unsafe impl<T: ::std::io::BufRead + Send + Sync> Trait for T { }
   |            +++++++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:60:23
   |
60 | unsafe impl Trait for ::std::io::Read + Send { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
60 | unsafe impl Trait for dyn (::std::io::Read + Send) { }
   |                       +++++                      +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::io::Read + Send`
   |
60 | unsafe impl<T: ::std::io::Read + Send> Trait for T { }
   |            +++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:61:23
   |
61 | unsafe impl Trait for ::std::io::Read + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
61 | unsafe impl Trait for dyn (::std::io::Read + Sync) { }
   |                       +++++                      +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::io::Read + Sync`
   |
61 | unsafe impl<T: ::std::io::Read + Sync> Trait for T { }
   |            +++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:62:23
   |
62 | unsafe impl Trait for ::std::io::Read + Send + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
62 | unsafe impl Trait for dyn (::std::io::Read + Send + Sync) { }
   |                       +++++                             +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::io::Read + Send + Sync`
   |
62 | unsafe impl<T: ::std::io::Read + Send + Sync> Trait for T { }
   |            ++++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:63:23
   |
63 | unsafe impl Trait for ::std::io::Seek + Send { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
63 | unsafe impl Trait for dyn (::std::io::Seek + Send) { }
   |                       +++++                      +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::io::Seek + Send`
   |
63 | unsafe impl<T: ::std::io::Seek + Send> Trait for T { }
   |            +++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:64:23
   |
64 | unsafe impl Trait for ::std::io::Seek + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
64 | unsafe impl Trait for dyn (::std::io::Seek + Sync) { }
   |                       +++++                      +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::io::Seek + Sync`
   |
64 | unsafe impl<T: ::std::io::Seek + Sync> Trait for T { }
   |            +++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:65:23
   |
65 | unsafe impl Trait for ::std::io::Seek + Send + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
65 | unsafe impl Trait for dyn (::std::io::Seek + Send + Sync) { }
   |                       +++++                             +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::io::Seek + Send + Sync`
   |
65 | unsafe impl<T: ::std::io::Seek + Send + Sync> Trait for T { }
   |            ++++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:66:23
   |
66 | unsafe impl Trait for ::std::io::Write + Send { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
66 | unsafe impl Trait for dyn (::std::io::Write + Send) { }
   |                       +++++                       +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::io::Write + Send`
   |
66 | unsafe impl<T: ::std::io::Write + Send> Trait for T { }
   |            ++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:67:23
   |
67 | unsafe impl Trait for ::std::io::Write + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
67 | unsafe impl Trait for dyn (::std::io::Write + Sync) { }
   |                       +++++                       +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::io::Write + Sync`
   |
67 | unsafe impl<T: ::std::io::Write + Sync> Trait for T { }
   |            ++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:68:23
   |
68 | unsafe impl Trait for ::std::io::Write + Send + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
68 | unsafe impl Trait for dyn (::std::io::Write + Send + Sync) { }
   |                       +++++                              +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::io::Write + Send + Sync`
   |
68 | unsafe impl<T: ::std::io::Write + Send + Sync> Trait for T { }
   |            +++++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:69:29
   |
69 | unsafe impl<T, I> Trait for ::std::iter::IntoIterator<IntoIter = I, Item = T> { }
   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
69 | unsafe impl<T, I> Trait for dyn (::std::iter::IntoIterator<IntoIter = I, Item = T>) { }
   |                             +++++                                                 +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::iter::IntoIterator<IntoIter = I, Item = T>`
   |
69 | unsafe impl<T, I, U: ::std::iter::IntoIterator<IntoIter = I, Item = T>> Trait for U { }
   |                 ++++++++++++++++++++++++++++++++++++++++++++++++++++++            ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:70:26
   |
70 | unsafe impl<T> Trait for ::std::iter::Iterator<Item = T> + Send { }
   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
70 | unsafe impl<T> Trait for dyn (::std::iter::Iterator<Item = T> + Send) { }
   |                          +++++                                      +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::iter::Iterator<Item = T> + Send`
   |
70 | unsafe impl<T, U: ::std::iter::Iterator<Item = T> + Send> Trait for U { }
   |              +++++++++++++++++++++++++++++++++++++++++++            ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:71:26
   |
71 | unsafe impl<T> Trait for ::std::iter::Iterator<Item = T> + Sync { }
   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
71 | unsafe impl<T> Trait for dyn (::std::iter::Iterator<Item = T> + Sync) { }
   |                          +++++                                      +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::iter::Iterator<Item = T> + Sync`
   |
71 | unsafe impl<T, U: ::std::iter::Iterator<Item = T> + Sync> Trait for U { }
   |              +++++++++++++++++++++++++++++++++++++++++++            ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:72:26
   |
72 | unsafe impl<T> Trait for ::std::iter::Iterator<Item = T> + Send + Sync { }
   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
72 | unsafe impl<T> Trait for dyn (::std::iter::Iterator<Item = T> + Send + Sync) { }
   |                          +++++                                             +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::iter::Iterator<Item = T> + Send + Sync`
   |
72 | unsafe impl<T, U: ::std::iter::Iterator<Item = T> + Send + Sync> Trait for U { }
   |              ++++++++++++++++++++++++++++++++++++++++++++++++++            ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:73:23
   |
73 | unsafe impl Trait for ::std::ops::Drop + Send { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
73 | unsafe impl Trait for dyn (::std::ops::Drop + Send) { }
   |                       +++++                       +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::ops::Drop + Send`
   |
73 | unsafe impl<T: ::std::ops::Drop + Send> Trait for T { }
   |            ++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:74:23
   |
74 | unsafe impl Trait for ::std::ops::Drop + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
74 | unsafe impl Trait for dyn (::std::ops::Drop + Sync) { }
   |                       +++++                       +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::ops::Drop + Sync`
   |
74 | unsafe impl<T: ::std::ops::Drop + Sync> Trait for T { }
   |            ++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:75:23
   |
75 | unsafe impl Trait for ::std::ops::Drop + Send + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
75 | unsafe impl Trait for dyn (::std::ops::Drop + Send + Sync) { }
   |                       +++++                              +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::ops::Drop + Send + Sync`
   |
75 | unsafe impl<T: ::std::ops::Drop + Send + Sync> Trait for T { }
   |            +++++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:76:23
   |
76 | unsafe impl Trait for ::std::string::ToString + Send { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
76 | unsafe impl Trait for dyn (::std::string::ToString + Send) { }
   |                       +++++                              +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::string::ToString + Send`
   |
76 | unsafe impl<T: ::std::string::ToString + Send> Trait for T { }
   |            +++++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:77:23
   |
77 | unsafe impl Trait for ::std::string::ToString + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
77 | unsafe impl Trait for dyn (::std::string::ToString + Sync) { }
   |                       +++++                              +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::string::ToString + Sync`
   |
77 | unsafe impl<T: ::std::string::ToString + Sync> Trait for T { }
   |            +++++++++++++++++++++++++++++++++++           ~
Executing(%install): /bin/sh -e /var/tmp/rpm-tmp.wtDA1k
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:78:23
   |
78 | unsafe impl Trait for ::std::string::ToString + Send + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
78 | unsafe impl Trait for dyn (::std::string::ToString + Send + Sync) { }
   |                       +++++                                     +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::string::ToString + Send + Sync`
   |
78 | unsafe impl<T: ::std::string::ToString + Send + Sync> Trait for T { }
   |            ++++++++++++++++++++++++++++++++++++++++++           ~
warning: types that do not implement `Drop` can still have drop glue, consider instead using `std::mem::needs_drop` to detect whether a type is trivially dropped
  --> src/impls.rs:73:23
   |
73 | unsafe impl Trait for ::std::ops::Drop + Send { }
   |                       ^^^^^^^^^^^^^^^^
   |
   = note: `#[warn(dyn_drop)]` on by default
warning: types that do not implement `Drop` can still have drop glue, consider instead using `std::mem::needs_drop` to detect whether a type is trivially dropped
  --> src/impls.rs:74:23
   |
74 | unsafe impl Trait for ::std::ops::Drop + Sync { }
   |                       ^^^^^^^^^^^^^^^^
warning: types that do not implement `Drop` can still have drop glue, consider instead using `std::mem::needs_drop` to detect whether a type is trivially dropped
  --> src/impls.rs:75:23
   |
75 | unsafe impl Trait for ::std::ops::Drop + Send + Sync { }
   |                       ^^^^^^^^^^^^^^^^
warning: `destructure_traitobject` (lib) generated 79 warnings (run `cargo fix --lib -p destructure_traitobject` to apply 76 suggestions)
    Finished release [optimized] target(s) in 0.14s
+ RPM_EC=0
++ jobs -p
+ exit 0
+ umask 022
+ cd /builddir/build/BUILD
+ '[' /builddir/build/BUILDROOT/rust-destructure_traitobject-0.2.0-1.fc39.s390x '!=' / ']'
+ rm -rf /builddir/build/BUILDROOT/rust-destructure_traitobject-0.2.0-1.fc39.s390x
++ dirname /builddir/build/BUILDROOT/rust-destructure_traitobject-0.2.0-1.fc39.s390x
+ mkdir -p /builddir/build/BUILDROOT
+ mkdir /builddir/build/BUILDROOT/rust-destructure_traitobject-0.2.0-1.fc39.s390x
+ CFLAGS='-O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -m64 -march=z13 -mtune=z14 -fasynchronous-unwind-tables -fstack-clash-protection '
+ export CFLAGS
+ CXXFLAGS='-O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -m64 -march=z13 -mtune=z14 -fasynchronous-unwind-tables -fstack-clash-protection '
+ export CXXFLAGS
+ FFLAGS='-O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -m64 -march=z13 -mtune=z14 -fasynchronous-unwind-tables -fstack-clash-protection -I/usr/lib64/gfortran/modules '
+ export FFLAGS
+ FCFLAGS='-O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -m64 -march=z13 -mtune=z14 -fasynchronous-unwind-tables -fstack-clash-protection -I/usr/lib64/gfortran/modules '
+ export FCFLAGS
+ VALAFLAGS=-g
+ export VALAFLAGS
+ RUSTFLAGS='-Copt-level=3 -Cdebuginfo=2 -Ccodegen-units=1 -Clink-arg=-Wl,-z,relro -Clink-arg=-Wl,-z,now -Clink-arg=-specs=/usr/lib/rpm/redhat/redhat-package-notes --cap-lints=warn'
+ export RUSTFLAGS
+ LDFLAGS='-Wl,-z,relro -Wl,--as-needed  -Wl,-z,now -specs=/usr/lib/rpm/redhat/redhat-hardened-ld -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -Wl,--build-id=sha1 -specs=/usr/lib/rpm/redhat/redhat-package-notes '
+ export LDFLAGS
+ LT_SYS_LIBRARY_PATH=/usr/lib64:
+ export LT_SYS_LIBRARY_PATH
+ CC=gcc
+ export CC
+ CXX=g++
+ export CXX
+ cd destructure_traitobject-0.2.0
+ set -eu
++ /usr/bin/cargo2rpm --path Cargo.toml is-lib
+ '[' 1 -eq 1 ']'
++ /usr/bin/cargo2rpm --path Cargo.toml name
+ CRATE_NAME=destructure_traitobject
++ /usr/bin/cargo2rpm --path Cargo.toml version
+ CRATE_VERSION=0.2.0
+ REG_DIR=/builddir/build/BUILDROOT/rust-destructure_traitobject-0.2.0-1.fc39.s390x/usr/share/cargo/registry/destructure_traitobject-0.2.0
+ /usr/bin/mkdir -p /builddir/build/BUILDROOT/rust-destructure_traitobject-0.2.0-1.fc39.s390x/usr/share/cargo/registry/destructure_traitobject-0.2.0
+ gawk -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 -Clink-arg=-Wl,-z,relro -Clink-arg=-Wl,-z,now -Clink-arg=-specs=/usr/lib/rpm/redhat/redhat-package-notes --cap-lints=warn' /usr/bin/cargo package -l
+ xargs -d '\n' /usr/bin/cp --parents -a -t /builddir/build/BUILDROOT/rust-destructure_traitobject-0.2.0-1.fc39.s390x/usr/share/cargo/registry/destructure_traitobject-0.2.0
+ grep -w -E -v 'Cargo.(lock|toml.orig)'
warning: No (git) VCS found for `/builddir/build/BUILD/destructure_traitobject-0.2.0`
+ /usr/bin/mv Cargo.toml.deps Cargo.toml
+ /usr/bin/cp -a Cargo.toml /builddir/build/BUILDROOT/rust-destructure_traitobject-0.2.0-1.fc39.s390x/usr/share/cargo/registry/destructure_traitobject-0.2.0/Cargo.toml
+ /usr/bin/rm -f /builddir/build/BUILDROOT/rust-destructure_traitobject-0.2.0-1.fc39.s390x/usr/share/cargo/registry/destructure_traitobject-0.2.0/Cargo.toml.deps
+ echo '{"files":{},"package":""}'
++ /usr/bin/cargo2rpm --path Cargo.toml is-bin
+ '[' 0 -eq 1 ']'
+ /usr/lib/rpm/check-buildroot
+ /usr/lib/rpm/redhat/brp-ldconfig
+ /usr/lib/rpm/brp-compress
+ /usr/lib/rpm/brp-strip /usr/bin/strip
+ /usr/lib/rpm/brp-strip-comment-note /usr/bin/strip /usr/bin/objdump
+ /usr/lib/rpm/redhat/brp-strip-lto /usr/bin/strip
+ /usr/lib/rpm/brp-strip-static-archive /usr/bin/strip
+ /usr/lib/rpm/check-rpaths
+ /usr/lib/rpm/redhat/brp-mangle-shebangs
+ /usr/lib/rpm/brp-remove-la-files
+ env /usr/lib/rpm/redhat/brp-python-bytecompile '' 1 0 -j2
+ /usr/lib/rpm/redhat/brp-python-hardlink
Executing(%check): /bin/sh -e /var/tmp/rpm-tmp.ratwWF
+ umask 022
+ cd /builddir/build/BUILD
+ CFLAGS='-O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -m64 -march=z13 -mtune=z14 -fasynchronous-unwind-tables -fstack-clash-protection '
+ export CFLAGS
+ CXXFLAGS='-O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -m64 -march=z13 -mtune=z14 -fasynchronous-unwind-tables -fstack-clash-protection '
+ export CXXFLAGS
+ FFLAGS='-O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -m64 -march=z13 -mtune=z14 -fasynchronous-unwind-tables -fstack-clash-protection -I/usr/lib64/gfortran/modules '
+ export FFLAGS
+ FCFLAGS='-O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -m64 -march=z13 -mtune=z14 -fasynchronous-unwind-tables -fstack-clash-protection -I/usr/lib64/gfortran/modules '
+ export FCFLAGS
+ VALAFLAGS=-g
+ export VALAFLAGS
+ RUSTFLAGS='-Copt-level=3 -Cdebuginfo=2 -Ccodegen-units=1 -Clink-arg=-Wl,-z,relro -Clink-arg=-Wl,-z,now -Clink-arg=-specs=/usr/lib/rpm/redhat/redhat-package-notes --cap-lints=warn'
+ export RUSTFLAGS
+ LDFLAGS='-Wl,-z,relro -Wl,--as-needed  -Wl,-z,now -specs=/usr/lib/rpm/redhat/redhat-hardened-ld -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1  -Wl,--build-id=sha1 -specs=/usr/lib/rpm/redhat/redhat-package-notes '
+ export LDFLAGS
+ LT_SYS_LIBRARY_PATH=/usr/lib64:
+ export LT_SYS_LIBRARY_PATH
+ CC=gcc
+ export CC
+ CXX=g++
+ export CXX
+ cd destructure_traitobject-0.2.0
+ /usr/bin/env CARGO_HOME=.cargo RUSTC_BOOTSTRAP=1 'RUSTFLAGS=-Copt-level=3 -Cdebuginfo=2 -Ccodegen-units=1 -Clink-arg=-Wl,-z,relro -Clink-arg=-Wl,-z,now -Clink-arg=-specs=/usr/lib/rpm/redhat/redhat-package-notes --cap-lints=warn' /usr/bin/cargo test -j2 -Z avoid-dev-deps --release --no-fail-fast
warning: trait objects without an explicit `dyn` are deprecated
 --> src/impls.rs:3:23
  |
3 | unsafe impl Trait for Send { }
  |                       ^^^^
  |
  = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
  = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
  = note: `#[warn(bare_trait_objects)]` on by default
help: use `dyn`
  |
3 | unsafe impl Trait for dyn Send { }
  |                       +++
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `Send`
  |
3 | unsafe impl<T: Send> Trait for T { }
  |            +++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
 --> src/impls.rs:4:23
  |
4 | unsafe impl Trait for Sync { }
  |                       ^^^^
  |
  = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
  = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
  |
4 | unsafe impl Trait for dyn Sync { }
  |                       +++
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `Sync`
  |
4 | unsafe impl<T: Sync> Trait for T { }
  |            +++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
 --> src/impls.rs:5:23
  |
5 | unsafe impl Trait for Send + Sync { }
  |                       ^^^^^^^^^^^
  |
  = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
  = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
  |
5 | unsafe impl Trait for dyn Send + Sync { }
  |                       +++
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `Send + Sync`
  |
5 | unsafe impl<T: Send + Sync> Trait for T { }
  |            ++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
 --> src/impls.rs:6:23
  |
6 | unsafe impl Trait for ::std::any::Any + Send { }
  |                       ^^^^^^^^^^^^^^^^^^^^^^
  |
  = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
  = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
  |
6 | unsafe impl Trait for dyn (::std::any::Any + Send) { }
  |                       +++++                      +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::any::Any + Send`
  |
6 | unsafe impl<T: ::std::any::Any + Send> Trait for T { }
  |            +++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
 --> src/impls.rs:7:23
  |
7 | unsafe impl Trait for ::std::any::Any + Sync { }
  |                       ^^^^^^^^^^^^^^^^^^^^^^
  |
  = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
  = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
  |
7 | unsafe impl Trait for dyn (::std::any::Any + Sync) { }
  |                       +++++                      +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::any::Any + Sync`
  |
7 | unsafe impl<T: ::std::any::Any + Sync> Trait for T { }
  |            +++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
 --> src/impls.rs:8:23
  |
8 | unsafe impl Trait for ::std::any::Any + Send + Sync { }
  |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  |
  = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
  = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
  |
8 | unsafe impl Trait for dyn (::std::any::Any + Send + Sync) { }
  |                       +++++                             +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::any::Any + Send + Sync`
  |
8 | unsafe impl<T: ::std::any::Any + Send + Sync> Trait for T { }
  |            ++++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
 --> src/impls.rs:9:34
  |
9 | unsafe impl<T: ?Sized> Trait for ::std::borrow::Borrow<T> + Send { }
  |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  |
  = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
  = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
  |
9 | unsafe impl<T: ?Sized> Trait for dyn (::std::borrow::Borrow<T> + Send) { }
  |                                  +++++                               +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::borrow::Borrow<T> + Send`
  |
9 | unsafe impl<T: ?Sized, U: ::std::borrow::Borrow<T> + Send> Trait for U { }
  |                      ++++++++++++++++++++++++++++++++++++            ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:10:34
   |
10 | unsafe impl<T: ?Sized> Trait for ::std::borrow::Borrow<T> + Sync { }
   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
10 | unsafe impl<T: ?Sized> Trait for dyn (::std::borrow::Borrow<T> + Sync) { }
   |                                  +++++                               +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::borrow::Borrow<T> + Sync`
   |
10 | unsafe impl<T: ?Sized, U: ::std::borrow::Borrow<T> + Sync> Trait for U { }
   |                      ++++++++++++++++++++++++++++++++++++            ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:11:34
   |
11 | unsafe impl<T: ?Sized> Trait for ::std::borrow::Borrow<T> + Send + Sync { }
   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
11 | unsafe impl<T: ?Sized> Trait for dyn (::std::borrow::Borrow<T> + Send + Sync) { }
   |                                  +++++                                      +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::borrow::Borrow<T> + Send + Sync`
   |
11 | unsafe impl<T: ?Sized, U: ::std::borrow::Borrow<T> + Send + Sync> Trait for U { }
   |                      +++++++++++++++++++++++++++++++++++++++++++            ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:12:34
   |
12 | unsafe impl<T: ?Sized> Trait for ::std::borrow::BorrowMut<T> + Send { }
   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
12 | unsafe impl<T: ?Sized> Trait for dyn (::std::borrow::BorrowMut<T> + Send) { }
   |                                  +++++                                  +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::borrow::BorrowMut<T> + Send`
   |
12 | unsafe impl<T: ?Sized, U: ::std::borrow::BorrowMut<T> + Send> Trait for U { }
   |                      +++++++++++++++++++++++++++++++++++++++            ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:13:34
   |
13 | unsafe impl<T: ?Sized> Trait for ::std::borrow::BorrowMut<T> + Sync { }
   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
13 | unsafe impl<T: ?Sized> Trait for dyn (::std::borrow::BorrowMut<T> + Sync) { }
   |                                  +++++                                  +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::borrow::BorrowMut<T> + Sync`
   |
13 | unsafe impl<T: ?Sized, U: ::std::borrow::BorrowMut<T> + Sync> Trait for U { }
   |                      +++++++++++++++++++++++++++++++++++++++            ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:14:34
   |
14 | unsafe impl<T: ?Sized> Trait for ::std::borrow::BorrowMut<T> + Send + Sync { }
   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
14 | unsafe impl<T: ?Sized> Trait for dyn (::std::borrow::BorrowMut<T> + Send + Sync) { }
   |                                  +++++                                         +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::borrow::BorrowMut<T> + Send + Sync`
   |
14 | unsafe impl<T: ?Sized, U: ::std::borrow::BorrowMut<T> + Send + Sync> Trait for U { }
   |                      ++++++++++++++++++++++++++++++++++++++++++++++            ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:15:34
   |
15 | unsafe impl<T: ?Sized> Trait for ::std::convert::AsMut<T> + Send { }
   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
15 | unsafe impl<T: ?Sized> Trait for dyn (::std::convert::AsMut<T> + Send) { }
   |                                  +++++                               +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::convert::AsMut<T> + Send`
   |
15 | unsafe impl<T: ?Sized, U: ::std::convert::AsMut<T> + Send> Trait for U { }
   |                      ++++++++++++++++++++++++++++++++++++            ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:16:34
   |
16 | unsafe impl<T: ?Sized> Trait for ::std::convert::AsMut<T> + Sync { }
   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
16 | unsafe impl<T: ?Sized> Trait for dyn (::std::convert::AsMut<T> + Sync) { }
   |                                  +++++                               +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::convert::AsMut<T> + Sync`
   |
16 | unsafe impl<T: ?Sized, U: ::std::convert::AsMut<T> + Sync> Trait for U { }
   |                      ++++++++++++++++++++++++++++++++++++            ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:17:34
   |
17 | unsafe impl<T: ?Sized> Trait for ::std::convert::AsMut<T> + Send + Sync { }
   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
17 | unsafe impl<T: ?Sized> Trait for dyn (::std::convert::AsMut<T> + Send + Sync) { }
   |                                  +++++                                      +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::convert::AsMut<T> + Send + Sync`
   |
17 | unsafe impl<T: ?Sized, U: ::std::convert::AsMut<T> + Send + Sync> Trait for U { }
   |                      +++++++++++++++++++++++++++++++++++++++++++            ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:18:34
   |
18 | unsafe impl<T: ?Sized> Trait for ::std::convert::AsRef<T> + Send { }
   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
18 | unsafe impl<T: ?Sized> Trait for dyn (::std::convert::AsRef<T> + Send) { }
   |                                  +++++                               +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::convert::AsRef<T> + Send`
   |
18 | unsafe impl<T: ?Sized, U: ::std::convert::AsRef<T> + Send> Trait for U { }
   |                      ++++++++++++++++++++++++++++++++++++            ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:19:34
   |
19 | unsafe impl<T: ?Sized> Trait for ::std::convert::AsRef<T> + Sync { }
   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
19 | unsafe impl<T: ?Sized> Trait for dyn (::std::convert::AsRef<T> + Sync) { }
   |                                  +++++                               +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::convert::AsRef<T> + Sync`
   |
19 | unsafe impl<T: ?Sized, U: ::std::convert::AsRef<T> + Sync> Trait for U { }
   |                      ++++++++++++++++++++++++++++++++++++            ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:20:34
   |
20 | unsafe impl<T: ?Sized> Trait for ::std::convert::AsRef<T> + Send + Sync { }
   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
20 | unsafe impl<T: ?Sized> Trait for dyn (::std::convert::AsRef<T> + Send + Sync) { }
   |                                  +++++                                      +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::convert::AsRef<T> + Send + Sync`
   |
20 | unsafe impl<T: ?Sized, U: ::std::convert::AsRef<T> + Send + Sync> Trait for U { }
   |                      +++++++++++++++++++++++++++++++++++++++++++            ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:21:23
   |
21 | unsafe impl Trait for ::std::error::Error + Send { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
21 | unsafe impl Trait for dyn (::std::error::Error + Send) { }
   |                       +++++                          +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::error::Error + Send`
   |
21 | unsafe impl<T: ::std::error::Error + Send> Trait for T { }
   |            +++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:22:23
   |
22 | unsafe impl Trait for ::std::error::Error + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
22 | unsafe impl Trait for dyn (::std::error::Error + Sync) { }
   |                       +++++                          +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::error::Error + Sync`
   |
22 | unsafe impl<T: ::std::error::Error + Sync> Trait for T { }
   |            +++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:23:23
   |
23 | unsafe impl Trait for ::std::error::Error + Send + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
23 | unsafe impl Trait for dyn (::std::error::Error + Send + Sync) { }
   |                       +++++                                 +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::error::Error + Send + Sync`
   |
23 | unsafe impl<T: ::std::error::Error + Send + Sync> Trait for T { }
   |            ++++++++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:24:23
   |
24 | unsafe impl Trait for ::std::fmt::Binary + Send { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
24 | unsafe impl Trait for dyn (::std::fmt::Binary + Send) { }
   |                       +++++                         +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::Binary + Send`
   |
24 | unsafe impl<T: ::std::fmt::Binary + Send> Trait for T { }
   |            ++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:25:23
   |
25 | unsafe impl Trait for ::std::fmt::Binary + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
25 | unsafe impl Trait for dyn (::std::fmt::Binary + Sync) { }
   |                       +++++                         +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::Binary + Sync`
   |
25 | unsafe impl<T: ::std::fmt::Binary + Sync> Trait for T { }
   |            ++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:26:23
   |
26 | unsafe impl Trait for ::std::fmt::Binary + Send + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
26 | unsafe impl Trait for dyn (::std::fmt::Binary + Send + Sync) { }
   |                       +++++                                +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::Binary + Send + Sync`
   |
26 | unsafe impl<T: ::std::fmt::Binary + Send + Sync> Trait for T { }
   |            +++++++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:27:23
   |
27 | unsafe impl Trait for ::std::fmt::Debug + Send { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
27 | unsafe impl Trait for dyn (::std::fmt::Debug + Send) { }
   |                       +++++                        +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::Debug + Send`
   |
27 | unsafe impl<T: ::std::fmt::Debug + Send> Trait for T { }
   |            +++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:28:23
   |
28 | unsafe impl Trait for ::std::fmt::Debug + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
28 | unsafe impl Trait for dyn (::std::fmt::Debug + Sync) { }
   |                       +++++                        +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::Debug + Sync`
   |
28 | unsafe impl<T: ::std::fmt::Debug + Sync> Trait for T { }
   |            +++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:29:23
   |
29 | unsafe impl Trait for ::std::fmt::Debug + Send + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
29 | unsafe impl Trait for dyn (::std::fmt::Debug + Send + Sync) { }
   |                       +++++                               +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::Debug + Send + Sync`
   |
29 | unsafe impl<T: ::std::fmt::Debug + Send + Sync> Trait for T { }
   |            ++++++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:30:23
   |
30 | unsafe impl Trait for ::std::fmt::Display + Send { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
30 | unsafe impl Trait for dyn (::std::fmt::Display + Send) { }
   |                       +++++                          +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::Display + Send`
   |
30 | unsafe impl<T: ::std::fmt::Display + Send> Trait for T { }
   |            +++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:31:23
   |
31 | unsafe impl Trait for ::std::fmt::Display + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
31 | unsafe impl Trait for dyn (::std::fmt::Display + Sync) { }
   |                       +++++                          +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::Display + Sync`
   |
31 | unsafe impl<T: ::std::fmt::Display + Sync> Trait for T { }
   |            +++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:32:23
   |
32 | unsafe impl Trait for ::std::fmt::Display + Send + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
32 | unsafe impl Trait for dyn (::std::fmt::Display + Send + Sync) { }
   |                       +++++                                 +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::Display + Send + Sync`
   |
32 | unsafe impl<T: ::std::fmt::Display + Send + Sync> Trait for T { }
   |            ++++++++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:33:23
   |
33 | unsafe impl Trait for ::std::fmt::LowerExp + Send { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
33 | unsafe impl Trait for dyn (::std::fmt::LowerExp + Send) { }
   |                       +++++                           +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::LowerExp + Send`
   |
33 | unsafe impl<T: ::std::fmt::LowerExp + Send> Trait for T { }
   |            ++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:34:23
   |
34 | unsafe impl Trait for ::std::fmt::LowerExp + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
34 | unsafe impl Trait for dyn (::std::fmt::LowerExp + Sync) { }
   |                       +++++                           +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::LowerExp + Sync`
   |
34 | unsafe impl<T: ::std::fmt::LowerExp + Sync> Trait for T { }
   |            ++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:35:23
   |
35 | unsafe impl Trait for ::std::fmt::LowerExp + Send + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
35 | unsafe impl Trait for dyn (::std::fmt::LowerExp + Send + Sync) { }
   |                       +++++                                  +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::LowerExp + Send + Sync`
   |
35 | unsafe impl<T: ::std::fmt::LowerExp + Send + Sync> Trait for T { }
   |            +++++++++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:36:23
   |
36 | unsafe impl Trait for ::std::fmt::LowerHex + Send { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
36 | unsafe impl Trait for dyn (::std::fmt::LowerHex + Send) { }
   |                       +++++                           +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::LowerHex + Send`
   |
36 | unsafe impl<T: ::std::fmt::LowerHex + Send> Trait for T { }
   |            ++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:37:23
   |
37 | unsafe impl Trait for ::std::fmt::LowerHex + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
37 | unsafe impl Trait for dyn (::std::fmt::LowerHex + Sync) { }
   |                       +++++                           +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::LowerHex + Sync`
   |
37 | unsafe impl<T: ::std::fmt::LowerHex + Sync> Trait for T { }
   |            ++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:38:23
   |
38 | unsafe impl Trait for ::std::fmt::LowerHex + Send + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
38 | unsafe impl Trait for dyn (::std::fmt::LowerHex + Send + Sync) { }
   |                       +++++                                  +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::LowerHex + Send + Sync`
   |
38 | unsafe impl<T: ::std::fmt::LowerHex + Send + Sync> Trait for T { }
   |            +++++++++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:39:23
   |
39 | unsafe impl Trait for ::std::fmt::Octal + Send { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
39 | unsafe impl Trait for dyn (::std::fmt::Octal + Send) { }
   |                       +++++                        +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::Octal + Send`
   |
39 | unsafe impl<T: ::std::fmt::Octal + Send> Trait for T { }
   |            +++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:40:23
   |
40 | unsafe impl Trait for ::std::fmt::Octal + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
40 | unsafe impl Trait for dyn (::std::fmt::Octal + Sync) { }
   |                       +++++                        +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::Octal + Sync`
   |
40 | unsafe impl<T: ::std::fmt::Octal + Sync> Trait for T { }
   |            +++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:41:23
   |
41 | unsafe impl Trait for ::std::fmt::Octal + Send + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
41 | unsafe impl Trait for dyn (::std::fmt::Octal + Send + Sync) { }
   |                       +++++                               +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::Octal + Send + Sync`
   |
41 | unsafe impl<T: ::std::fmt::Octal + Send + Sync> Trait for T { }
   |            ++++++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:42:23
   |
42 | unsafe impl Trait for ::std::fmt::Pointer + Send { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
42 | unsafe impl Trait for dyn (::std::fmt::Pointer + Send) { }
   |                       +++++                          +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::Pointer + Send`
   |
42 | unsafe impl<T: ::std::fmt::Pointer + Send> Trait for T { }
   |            +++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:43:23
   |
43 | unsafe impl Trait for ::std::fmt::Pointer + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
43 | unsafe impl Trait for dyn (::std::fmt::Pointer + Sync) { }
   |                       +++++                          +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::Pointer + Sync`
   |
43 | unsafe impl<T: ::std::fmt::Pointer + Sync> Trait for T { }
   |            +++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:44:23
   |
44 | unsafe impl Trait for ::std::fmt::Pointer + Send + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
44 | unsafe impl Trait for dyn (::std::fmt::Pointer + Send + Sync) { }
   |                       +++++                                 +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::Pointer + Send + Sync`
   |
44 | unsafe impl<T: ::std::fmt::Pointer + Send + Sync> Trait for T { }
   |            ++++++++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:45:23
   |
45 | unsafe impl Trait for ::std::fmt::UpperExp + Send { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
45 | unsafe impl Trait for dyn (::std::fmt::UpperExp + Send) { }
   |                       +++++                           +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::UpperExp + Send`
   |
45 | unsafe impl<T: ::std::fmt::UpperExp + Send> Trait for T { }
   |            ++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:46:23
   |
46 | unsafe impl Trait for ::std::fmt::UpperExp + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
46 | unsafe impl Trait for dyn (::std::fmt::UpperExp + Sync) { }
   |                       +++++                           +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::UpperExp + Sync`
   |
46 | unsafe impl<T: ::std::fmt::UpperExp + Sync> Trait for T { }
   |            ++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:47:23
   |
47 | unsafe impl Trait for ::std::fmt::UpperExp + Send + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
47 | unsafe impl Trait for dyn (::std::fmt::UpperExp + Send + Sync) { }
   |                       +++++                                  +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::UpperExp + Send + Sync`
   |
47 | unsafe impl<T: ::std::fmt::UpperExp + Send + Sync> Trait for T { }
   |            +++++++++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:48:23
   |
48 | unsafe impl Trait for ::std::fmt::UpperHex + Send { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
48 | unsafe impl Trait for dyn (::std::fmt::UpperHex + Send) { }
   |                       +++++                           +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::UpperHex + Send`
   |
48 | unsafe impl<T: ::std::fmt::UpperHex + Send> Trait for T { }
   |            ++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:49:23
   |
49 | unsafe impl Trait for ::std::fmt::UpperHex + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
49 | unsafe impl Trait for dyn (::std::fmt::UpperHex + Sync) { }
   |                       +++++                           +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::UpperHex + Sync`
   |
49 | unsafe impl<T: ::std::fmt::UpperHex + Sync> Trait for T { }
   |            ++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:50:23
   |
50 | unsafe impl Trait for ::std::fmt::UpperHex + Send + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
50 | unsafe impl Trait for dyn (::std::fmt::UpperHex + Send + Sync) { }
   |                       +++++                                  +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::UpperHex + Send + Sync`
   |
50 | unsafe impl<T: ::std::fmt::UpperHex + Send + Sync> Trait for T { }
   |            +++++++++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:51:23
   |
51 | unsafe impl Trait for ::std::fmt::Write + Send { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
51 | unsafe impl Trait for dyn (::std::fmt::Write + Send) { }
   |                       +++++                        +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::Write + Send`
   |
51 | unsafe impl<T: ::std::fmt::Write + Send> Trait for T { }
   |            +++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:52:23
   |
52 | unsafe impl Trait for ::std::fmt::Write + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
52 | unsafe impl Trait for dyn (::std::fmt::Write + Sync) { }
   |                       +++++                        +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::Write + Sync`
   |
52 | unsafe impl<T: ::std::fmt::Write + Sync> Trait for T { }
   |            +++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:53:23
   |
53 | unsafe impl Trait for ::std::fmt::Write + Send + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
53 | unsafe impl Trait for dyn (::std::fmt::Write + Send + Sync) { }
   |                       +++++                               +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::fmt::Write + Send + Sync`
   |
53 | unsafe impl<T: ::std::fmt::Write + Send + Sync> Trait for T { }
   |            ++++++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:54:23
   |
54 | unsafe impl Trait for ::std::hash::Hasher + Send { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
54 | unsafe impl Trait for dyn (::std::hash::Hasher + Send) { }
   |                       +++++                          +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::hash::Hasher + Send`
   |
54 | unsafe impl<T: ::std::hash::Hasher + Send> Trait for T { }
   |            +++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:55:23
   |
55 | unsafe impl Trait for ::std::hash::Hasher + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
55 | unsafe impl Trait for dyn (::std::hash::Hasher + Sync) { }
   |                       +++++                          +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::hash::Hasher + Sync`
   |
55 | unsafe impl<T: ::std::hash::Hasher + Sync> Trait for T { }
   |            +++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:56:23
   |
56 | unsafe impl Trait for ::std::hash::Hasher + Send + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
56 | unsafe impl Trait for dyn (::std::hash::Hasher + Send + Sync) { }
   |                       +++++                                 +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::hash::Hasher + Send + Sync`
   |
56 | unsafe impl<T: ::std::hash::Hasher + Send + Sync> Trait for T { }
   |            ++++++++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:57:23
   |
57 | unsafe impl Trait for ::std::io::BufRead + Send { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
57 | unsafe impl Trait for dyn (::std::io::BufRead + Send) { }
   |                       +++++                         +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::io::BufRead + Send`
   |
57 | unsafe impl<T: ::std::io::BufRead + Send> Trait for T { }
   |            ++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:58:23
   |
58 | unsafe impl Trait for ::std::io::BufRead + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
58 | unsafe impl Trait for dyn (::std::io::BufRead + Sync) { }
   |                       +++++                         +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::io::BufRead + Sync`
   |
58 | unsafe impl<T: ::std::io::BufRead + Sync> Trait for T { }
   |            ++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:59:23
   |
59 | unsafe impl Trait for ::std::io::BufRead + Send + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
59 | unsafe impl Trait for dyn (::std::io::BufRead + Send + Sync) { }
   |                       +++++                                +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::io::BufRead + Send + Sync`
   |
59 | unsafe impl<T: ::std::io::BufRead + Send + Sync> Trait for T { }
   |            +++++++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:60:23
   |
60 | unsafe impl Trait for ::std::io::Read + Send { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
60 | unsafe impl Trait for dyn (::std::io::Read + Send) { }
   |                       +++++                      +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::io::Read + Send`
   |
60 | unsafe impl<T: ::std::io::Read + Send> Trait for T { }
   |            +++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:61:23
   |
61 | unsafe impl Trait for ::std::io::Read + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
61 | unsafe impl Trait for dyn (::std::io::Read + Sync) { }
   |                       +++++                      +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::io::Read + Sync`
   |
61 | unsafe impl<T: ::std::io::Read + Sync> Trait for T { }
   |            +++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:62:23
   |
62 | unsafe impl Trait for ::std::io::Read + Send + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
62 | unsafe impl Trait for dyn (::std::io::Read + Send + Sync) { }
   |                       +++++                             +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::io::Read + Send + Sync`
   |
62 | unsafe impl<T: ::std::io::Read + Send + Sync> Trait for T { }
   |            ++++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:63:23
   |
63 | unsafe impl Trait for ::std::io::Seek + Send { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
63 | unsafe impl Trait for dyn (::std::io::Seek + Send) { }
   |                       +++++                      +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::io::Seek + Send`
   |
63 | unsafe impl<T: ::std::io::Seek + Send> Trait for T { }
   |            +++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:64:23
   |
64 | unsafe impl Trait for ::std::io::Seek + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
64 | unsafe impl Trait for dyn (::std::io::Seek + Sync) { }
   |                       +++++                      +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::io::Seek + Sync`
   |
64 | unsafe impl<T: ::std::io::Seek + Sync> Trait for T { }
   |            +++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:65:23
   |
65 | unsafe impl Trait for ::std::io::Seek + Send + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
65 | unsafe impl Trait for dyn (::std::io::Seek + Send + Sync) { }
   |                       +++++                             +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::io::Seek + Send + Sync`
   |
65 | unsafe impl<T: ::std::io::Seek + Send + Sync> Trait for T { }
   |            ++++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:66:23
   |
66 | unsafe impl Trait for ::std::io::Write + Send { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
66 | unsafe impl Trait for dyn (::std::io::Write + Send) { }
   |                       +++++                       +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::io::Write + Send`
   |
66 | unsafe impl<T: ::std::io::Write + Send> Trait for T { }
   |            ++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:67:23
   |
67 | unsafe impl Trait for ::std::io::Write + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
67 | unsafe impl Trait for dyn (::std::io::Write + Sync) { }
   |                       +++++                       +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::io::Write + Sync`
   |
67 | unsafe impl<T: ::std::io::Write + Sync> Trait for T { }
   |            ++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:68:23
   |
68 | unsafe impl Trait for ::std::io::Write + Send + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
68 | unsafe impl Trait for dyn (::std::io::Write + Send + Sync) { }
   |                       +++++                              +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::io::Write + Send + Sync`
   |
68 | unsafe impl<T: ::std::io::Write + Send + Sync> Trait for T { }
   |            +++++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:69:29
   |
69 | unsafe impl<T, I> Trait for ::std::iter::IntoIterator<IntoIter = I, Item = T> { }
   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
69 | unsafe impl<T, I> Trait for dyn (::std::iter::IntoIterator<IntoIter = I, Item = T>) { }
   |                             +++++                                                 +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::iter::IntoIterator<IntoIter = I, Item = T>`
   |
69 | unsafe impl<T, I, U: ::std::iter::IntoIterator<IntoIter = I, Item = T>> Trait for U { }
   |                 ++++++++++++++++++++++++++++++++++++++++++++++++++++++            ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:70:26
   |
70 | unsafe impl<T> Trait for ::std::iter::Iterator<Item = T> + Send { }
   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
70 | unsafe impl<T> Trait for dyn (::std::iter::Iterator<Item = T> + Send) { }
   |                          +++++                                      +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::iter::Iterator<Item = T> + Send`
   |
70 | unsafe impl<T, U: ::std::iter::Iterator<Item = T> + Send> Trait for U { }
   |              +++++++++++++++++++++++++++++++++++++++++++            ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:71:26
   |
71 | unsafe impl<T> Trait for ::std::iter::Iterator<Item = T> + Sync { }
   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
71 | unsafe impl<T> Trait for dyn (::std::iter::Iterator<Item = T> + Sync) { }
   |                          +++++                                      +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::iter::Iterator<Item = T> + Sync`
   |
71 | unsafe impl<T, U: ::std::iter::Iterator<Item = T> + Sync> Trait for U { }
   |              +++++++++++++++++++++++++++++++++++++++++++            ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:72:26
   |
72 | unsafe impl<T> Trait for ::std::iter::Iterator<Item = T> + Send + Sync { }
   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
72 | unsafe impl<T> Trait for dyn (::std::iter::Iterator<Item = T> + Send + Sync) { }
   |                          +++++                                             +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::iter::Iterator<Item = T> + Send + Sync`
   |
72 | unsafe impl<T, U: ::std::iter::Iterator<Item = T> + Send + Sync> Trait for U { }
   |              ++++++++++++++++++++++++++++++++++++++++++++++++++            ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:73:23
   |
73 | unsafe impl Trait for ::std::ops::Drop + Send { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
73 | unsafe impl Trait for dyn (::std::ops::Drop + Send) { }
   |                       +++++                       +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::ops::Drop + Send`
   |
73 | unsafe impl<T: ::std::ops::Drop + Send> Trait for T { }
   |            ++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:74:23
   |
74 | unsafe impl Trait for ::std::ops::Drop + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
74 | unsafe impl Trait for dyn (::std::ops::Drop + Sync) { }
   |                       +++++                       +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::ops::Drop + Sync`
   |
74 | unsafe impl<T: ::std::ops::Drop + Sync> Trait for T { }
   |            ++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:75:23
   |
75 | unsafe impl Trait for ::std::ops::Drop + Send + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
75 | unsafe impl Trait for dyn (::std::ops::Drop + Send + Sync) { }
   |                       +++++                              +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::ops::Drop + Send + Sync`
   |
75 | unsafe impl<T: ::std::ops::Drop + Send + Sync> Trait for T { }
   |            +++++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:76:23
   |
76 | unsafe impl Trait for ::std::string::ToString + Send { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
76 | unsafe impl Trait for dyn (::std::string::ToString + Send) { }
   |                       +++++                              +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::string::ToString + Send`
   |
76 | unsafe impl<T: ::std::string::ToString + Send> Trait for T { }
   |            +++++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:77:23
   |
77 | unsafe impl Trait for ::std::string::ToString + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
77 | unsafe impl Trait for dyn (::std::string::ToString + Sync) { }
   |                       +++++                              +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::string::ToString + Sync`
   |
77 | unsafe impl<T: ::std::string::ToString + Sync> Trait for T { }
   |            +++++++++++++++++++++++++++++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/impls.rs:78:23
   |
78 | unsafe impl Trait for ::std::string::ToString + Send + Sync { }
   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
78 | unsafe impl Trait for dyn (::std::string::ToString + Send + Sync) { }
   |                       +++++                                     +
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `::std::string::ToString + Send + Sync`
   |
78 | unsafe impl<T: ::std::string::ToString + Send + Sync> Trait for T { }
   |            ++++++++++++++++++++++++++++++++++++++++++           ~
warning: types that do not implement `Drop` can still have drop glue, consider instead using `std::mem::needs_drop` to detect whether a type is trivially dropped
  --> src/impls.rs:73:23
   |
73 | unsafe impl Trait for ::std::ops::Drop + Send { }
   |                       ^^^^^^^^^^^^^^^^
   |
   = note: `#[warn(dyn_drop)]` on by default
warning: types that do not implement `Drop` can still have drop glue, consider instead using `std::mem::needs_drop` to detect whether a type is trivially dropped
  --> src/impls.rs:74:23
   |
74 | unsafe impl Trait for ::std::ops::Drop + Sync { }
   |                       ^^^^^^^^^^^^^^^^
warning: types that do not implement `Drop` can still have drop glue, consider instead using `std::mem::needs_drop` to detect whether a type is trivially dropped
  --> src/impls.rs:75:23
   |
75 | unsafe impl Trait for ::std::ops::Drop + Send + Sync { }
   |                       ^^^^^^^^^^^^^^^^
warning: `destructure_traitobject` (lib) generated 79 warnings (run `cargo fix --lib -p destructure_traitobject` to apply 76 suggestions)
   Compiling destructure_traitobject v0.2.0 (/builddir/build/BUILD/destructure_traitobject-0.2.0)
     Running `/usr/bin/rustc --crate-name destructure_traitobject src/lib.rs --error-format=json --json=diagnostic-rendered-ansi,artifacts,future-incompat --emit=dep-info,link -C opt-level=3 -C embed-bitcode=no --test -C metadata=76df6fcbc05d6e18 -C extra-filename=-76df6fcbc05d6e18 --out-dir /builddir/build/BUILD/destructure_traitobject-0.2.0/target/release/deps -L dependency=/builddir/build/BUILD/destructure_traitobject-0.2.0/target/release/deps -Copt-level=3 -Cdebuginfo=2 -Ccodegen-units=1 -Clink-arg=-Wl,-z,relro -Clink-arg=-Wl,-z,now -Clink-arg=-specs=/usr/lib/rpm/redhat/redhat-package-notes --cap-lints=warn`
warning: trait objects without an explicit `dyn` are deprecated
 --> src/impls.rs:3:23
  |
3 | unsafe impl Trait for Send { }
  |                       ^^^^
  |
  = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
  = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
note: the lint level is defined here
 --> src/lib.rs:1:24
  |
1 | #![cfg_attr(test, deny(warnings))]
  |                        ^^^^^^^^
  = note: `#[warn(bare_trait_objects)]` implied by `#[warn(warnings)]`
help: use `dyn`
  |
3 | unsafe impl Trait for dyn Send { }
  |                       +++
help: alternatively use a blanket implementation to implement `Trait` for all types that also implement `Send`
  |
3 | unsafe impl<T: Send> Trait for T { }
  |            +++++++++           ~
warning: trait objects without an explicit `dyn` are deprecated
  --> src/lib.rs:24:20
   |
24 |     let x = &7 as &Send;
   |                    ^^^^
   |
   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
help: use `dyn`
   |
24 |     let x = &7 as &dyn Send;
   |                    +++
warning: types that do not implement `Drop` can still have drop glue, consider instead using `std::mem::needs_drop` to detect whether a type is trivially dropped
  --> src/impls.rs:73:23
   |
73 | unsafe impl Trait for ::std::ops::Drop + Send { }
   |                       ^^^^^^^^^^^^^^^^
   |
   = note: `#[warn(dyn_drop)]` implied by `#[warn(warnings)]`
warning: `destructure_traitobject` (lib test) generated 80 warnings (77 duplicates) (run `cargo fix --lib -p destructure_traitobject --tests` to apply 2 suggestions)
    Finished release [optimized] target(s) in 0.21s
     Running `/builddir/build/BUILD/destructure_traitobject-0.2.0/target/release/deps/destructure_traitobject-76df6fcbc05d6e18`
running 1 test
test test_simple ... ok
test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
   Doc-tests destructure_traitobject
     Running `/usr/bin/rustdoc --crate-type lib --crate-name destructure_traitobject --test /builddir/build/BUILD/destructure_traitobject-0.2.0/src/lib.rs -L dependency=/builddir/build/BUILD/destructure_traitobject-0.2.0/target/release/deps -L dependency=/builddir/build/BUILD/destructure_traitobject-0.2.0/target/release/deps --extern destructure_traitobject=/builddir/build/BUILD/destructure_traitobject-0.2.0/target/release/deps/libdestructure_traitobject-e805baf83691f643.rlib -C embed-bitcode=no --error-format human`
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
+ RPM_EC=0
++ jobs -p
+ exit 0
Processing files: rust-destructure_traitobject-devel-0.2.0-1.fc39.noarch
warning: File listed twice: /usr/share/cargo/registry/destructure_traitobject-0.2.0/AUTHORS.txt
warning: File listed twice: /usr/share/cargo/registry/destructure_traitobject-0.2.0/LICENSE_APACHE.txt
warning: File listed twice: /usr/share/cargo/registry/destructure_traitobject-0.2.0/LICENSE_APACHE.txt
warning: File listed twice: /usr/share/cargo/registry/destructure_traitobject-0.2.0/LICENSE_MIT.txt
warning: File listed twice: /usr/share/cargo/registry/destructure_traitobject-0.2.0/LICENSE_MIT.txt
warning: File listed twice: /usr/share/cargo/registry/destructure_traitobject-0.2.0/README.md
Provides: crate(destructure_traitobject) = 0.2.0 rust-destructure_traitobject-devel = 0.2.0-1.fc39
Requires(rpmlib): rpmlib(CompressedFileNames) <= 3.0.4-1 rpmlib(FileDigests) <= 4.6.0-1 rpmlib(PayloadFilesHavePrefix) <= 4.0-1
Requires: cargo
Processing files: rust-destructure_traitobject+default-devel-0.2.0-1.fc39.noarch
Provides: crate(destructure_traitobject/default) = 0.2.0 rust-destructure_traitobject+default-devel = 0.2.0-1.fc39
Requires(rpmlib): rpmlib(CompressedFileNames) <= 3.0.4-1 rpmlib(FileDigests) <= 4.6.0-1 rpmlib(PayloadFilesHavePrefix) <= 4.0-1
Requires: cargo crate(destructure_traitobject) = 0.2.0
Checking for unpackaged file(s): /usr/lib/rpm/check-files /builddir/build/BUILDROOT/rust-destructure_traitobject-0.2.0-1.fc39.s390x
Wrote: /builddir/build/SRPMS/rust-destructure_traitobject-0.2.0-1.fc39.src.rpm
Wrote: /builddir/build/RPMS/rust-destructure_traitobject+default-devel-0.2.0-1.fc39.noarch.rpm
Wrote: /builddir/build/RPMS/rust-destructure_traitobject-devel-0.2.0-1.fc39.noarch.rpm
Executing(%clean): /bin/sh -e /var/tmp/rpm-tmp.pQjWZC
+ umask 022
+ cd /builddir/build/BUILD
+ cd destructure_traitobject-0.2.0
+ /usr/bin/rm -rf /builddir/build/BUILDROOT/rust-destructure_traitobject-0.2.0-1.fc39.s390x
+ RPM_EC=0
++ jobs -p
+ exit 0
Executing(rmbuild): /bin/sh -e /var/tmp/rpm-tmp.BjOXjT
+ umask 022
+ cd /builddir/build/BUILD
+ rm -rf destructure_traitobject-0.2.0 destructure_traitobject-0.2.0.gemspec
+ RPM_EC=0
++ jobs -p
+ exit 0
RPM build warnings:
    File listed twice: /usr/share/cargo/registry/destructure_traitobject-0.2.0/AUTHORS.txt
    File listed twice: /usr/share/cargo/registry/destructure_traitobject-0.2.0/LICENSE_APACHE.txt
    File listed twice: /usr/share/cargo/registry/destructure_traitobject-0.2.0/LICENSE_APACHE.txt
    File listed twice: /usr/share/cargo/registry/destructure_traitobject-0.2.0/LICENSE_MIT.txt
    File listed twice: /usr/share/cargo/registry/destructure_traitobject-0.2.0/LICENSE_MIT.txt
    File listed twice: /usr/share/cargo/registry/destructure_traitobject-0.2.0/README.md
Child return code was: 0