[INFO] fetching crate blackboxmc_java 0.5.1...
[INFO] checking blackboxmc_java-0.5.1 against a5689b034ad287112f709693384a37f1377eb9cc for pr-129249-3
[INFO] extracting crate blackboxmc_java 0.5.1 into /workspace/builds/worker-7-tc2/source
[INFO] started tweaking crates.io crate blackboxmc_java 0.5.1
[INFO] finished tweaking crates.io crate blackboxmc_java 0.5.1
[INFO] tweaked toml for crates.io crate blackboxmc_java 0.5.1 written to /workspace/builds/worker-7-tc2/source/Cargo.toml
[INFO] validating manifest of crates.io crate blackboxmc_java 0.5.1 on toolchain a5689b034ad287112f709693384a37f1377eb9cc
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "generate-lockfile" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] [stderr]     Updating crates.io index
[INFO] [stderr]      Locking 73 packages to highest compatible versions
[INFO] [stderr]       Adding jni v0.21.1 (available: v0.22.4)
[INFO] [stderr]       Adding libffi v3.2.0 (available: v5.2.0)
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-7-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-7-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-m" "1610612736" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:77db811e55d90add9212f6832c23229e3de5f1c1f9905e8cb07319ea15df73ac" "sleep" "infinity", kill_on_drop: false }`
[INFO] [stdout] c75a8b3e9ed6350b36e978ca937147addcc83a15bd6a1d34be72ff033d12c19c
[INFO] running `Command { std: "docker" "start" "c75a8b3e9ed6350b36e978ca937147addcc83a15bd6a1d34be72ff033d12c19c", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "c75a8b3e9ed6350b36e978ca937147addcc83a15bd6a1d34be72ff033d12c19c", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "exec" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-w" "/opt/rustwide/workdir" "--user" "0:0" "c75a8b3e9ed6350b36e978ca937147addcc83a15bd6a1d34be72ff033d12c19c" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "c75a8b3e9ed6350b36e978ca937147addcc83a15bd6a1d34be72ff033d12c19c", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "exec" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=--cap-lints=forbid" "-e" "RUSTDOCFLAGS=--cap-lints=forbid" "-w" "/opt/rustwide/workdir" "--user" "0:0" "c75a8b3e9ed6350b36e978ca937147addcc83a15bd6a1d34be72ff033d12c19c" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stderr]    Compiling syn v2.0.119
[INFO] [stderr]     Checking lazy_static v1.5.1
[INFO] [stderr]     Checking thread_local v1.1.10
[INFO] [stderr]     Checking tracing-core v0.1.36
[INFO] [stderr]    Compiling object v0.37.3
[INFO] [stderr]    Compiling eyre v0.6.14
[INFO] [stderr]    Compiling proc-macro2-diagnostics v0.10.1
[INFO] [stderr]    Compiling color-spantrace v0.3.0
[INFO] [stderr]     Checking sharded-slab v0.1.7
[INFO] [stderr]    Compiling jni-sys v0.3.1
[INFO] [stderr]     Checking gimli v0.32.3
[INFO] [stderr]     Checking miniz_oxide v0.8.9
[INFO] [stderr]    Compiling libffi-sys v2.3.0
[INFO] [stderr]     Checking rustc-demangle v0.1.28
[INFO] [stderr]    Compiling semver v1.0.28
[INFO] [stderr]     Checking tracing v0.1.44
[INFO] [stderr]     Checking indenter v0.3.4
[INFO] [stderr]     Checking owo-colors v4.4.0
[INFO] [stderr]     Checking smallvec v1.16.3
[INFO] [stderr]     Checking tracing-subscriber v0.3.23
[INFO] [stderr]    Compiling rustc_version v0.4.1
[INFO] [stderr]     Checking parking_lot_core v0.9.12
[INFO] [stderr]     Checking combine v4.6.9
[INFO] [stderr]     Checking cesu8 v1.1.0
[INFO] [stderr]     Checking parking_lot v0.12.5
[INFO] [stderr]     Checking tracing-error v0.2.1
[INFO] [stderr]     Checking addr2line v0.25.1
[INFO] [stderr]    Compiling jni-sys-macros v0.4.1
[INFO] [stderr]    Compiling thiserror-impl v1.0.69
[INFO] [stderr]    Compiling blackboxmc_proc v0.5.1
[INFO] [stderr]     Checking backtrace v0.3.76
[INFO] [stderr]     Checking jni-sys v0.4.1
[INFO] [stderr]     Checking color-eyre v0.6.5
[INFO] [stderr]     Checking thiserror v1.0.69
[INFO] [stderr]     Checking jni v0.21.1
[INFO] [stderr]     Checking blackboxmc_general v0.5.1
[INFO] [stderr]     Checking libffi v3.2.0
[INFO] [stderr]     Checking blackboxmc_java v0.5.1 (/opt/rustwide/workdir)
[INFO] [stdout] warning: unnecessary braces around method argument
[INFO] [stdout]    --> src/util/mod.rs:288:22
[INFO] [stdout]     |
[INFO] [stdout] 288 |             vec.push({ res });
[INFO] [stdout]     |                      ^^   ^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: `#[warn(unused_braces)]` (part of `#[warn(unused)]`) on by default
[INFO] [stdout] help: remove these braces
[INFO] [stdout]     |
[INFO] [stdout] 288 -             vec.push({ res });
[INFO] [stdout] 288 +             vec.push(res);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary braces around method argument
[INFO] [stdout]     --> src/util/mod.rs:1573:22
[INFO] [stdout]      |
[INFO] [stdout] 1573 |             vec.push({ res });
[INFO] [stdout]      |                      ^^   ^^
[INFO] [stdout]      |
[INFO] [stdout] help: remove these braces
[INFO] [stdout]      |
[INFO] [stdout] 1573 -             vec.push({ res });
[INFO] [stdout] 1573 +             vec.push(res);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary braces around method argument
[INFO] [stdout]     --> src/util/mod.rs:2235:22
[INFO] [stdout]      |
[INFO] [stdout] 2235 |             vec.push({ res });
[INFO] [stdout]      |                      ^^   ^^
[INFO] [stdout]      |
[INFO] [stdout] help: remove these braces
[INFO] [stdout]      |
[INFO] [stdout] 2235 -             vec.push({ res });
[INFO] [stdout] 2235 +             vec.push(res);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary braces around method argument
[INFO] [stdout]     --> src/util/mod.rs:4658:22
[INFO] [stdout]      |
[INFO] [stdout] 4658 |             vec.push({ res });
[INFO] [stdout]      |                      ^^   ^^
[INFO] [stdout]      |
[INFO] [stdout] help: remove these braces
[INFO] [stdout]      |
[INFO] [stdout] 4658 -             vec.push({ res });
[INFO] [stdout] 4658 +             vec.push(res);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary braces around method argument
[INFO] [stdout]     --> src/util/mod.rs:5091:22
[INFO] [stdout]      |
[INFO] [stdout] 5091 |             vec.push({ res });
[INFO] [stdout]      |                      ^^   ^^
[INFO] [stdout]      |
[INFO] [stdout] help: remove these braces
[INFO] [stdout]      |
[INFO] [stdout] 5091 -             vec.push({ res });
[INFO] [stdout] 5091 +             vec.push(res);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary braces around method argument
[INFO] [stdout]     --> src/util/mod.rs:5417:22
[INFO] [stdout]      |
[INFO] [stdout] 5417 |             vec.push({ res });
[INFO] [stdout]      |                      ^^   ^^
[INFO] [stdout]      |
[INFO] [stdout] help: remove these braces
[INFO] [stdout]      |
[INFO] [stdout] 5417 -             vec.push({ res });
[INFO] [stdout] 5417 +             vec.push(res);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary braces around method argument
[INFO] [stdout]     --> src/util/mod.rs:5788:22
[INFO] [stdout]      |
[INFO] [stdout] 5788 |             vec.push({ res });
[INFO] [stdout]      |                      ^^   ^^
[INFO] [stdout]      |
[INFO] [stdout] help: remove these braces
[INFO] [stdout]      |
[INFO] [stdout] 5788 -             vec.push({ res });
[INFO] [stdout] 5788 +             vec.push(res);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary braces around method argument
[INFO] [stdout]     --> src/util/mod.rs:6374:22
[INFO] [stdout]      |
[INFO] [stdout] 6374 |             vec.push({ res });
[INFO] [stdout]      |                      ^^   ^^
[INFO] [stdout]      |
[INFO] [stdout] help: remove these braces
[INFO] [stdout]      |
[INFO] [stdout] 6374 -             vec.push({ res });
[INFO] [stdout] 6374 +             vec.push(res);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary braces around method argument
[INFO] [stdout]     --> src/util/mod.rs:7451:22
[INFO] [stdout]      |
[INFO] [stdout] 7451 |             vec.push({ res });
[INFO] [stdout]      |                      ^^   ^^
[INFO] [stdout]      |
[INFO] [stdout] help: remove these braces
[INFO] [stdout]      |
[INFO] [stdout] 7451 -             vec.push({ res });
[INFO] [stdout] 7451 +             vec.push(res);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary braces around method argument
[INFO] [stdout]     --> src/util/mod.rs:9293:22
[INFO] [stdout]      |
[INFO] [stdout] 9293 |             vec.push({ res });
[INFO] [stdout]      |                      ^^   ^^
[INFO] [stdout]      |
[INFO] [stdout] help: remove these braces
[INFO] [stdout]      |
[INFO] [stdout] 9293 -             vec.push({ res });
[INFO] [stdout] 9293 +             vec.push(res);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary braces around method argument
[INFO] [stdout]      --> src/util/mod.rs:10018:22
[INFO] [stdout]       |
[INFO] [stdout] 10018 |             vec.push({ res });
[INFO] [stdout]       |                      ^^   ^^
[INFO] [stdout]       |
[INFO] [stdout] help: remove these braces
[INFO] [stdout]       |
[INFO] [stdout] 10018 -             vec.push({ res });
[INFO] [stdout] 10018 +             vec.push(res);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary braces around method argument
[INFO] [stdout]      --> src/util/mod.rs:10489:22
[INFO] [stdout]       |
[INFO] [stdout] 10489 |             vec.push({ crate::util::JavaLocale::from_raw(&jni, res)? });
[INFO] [stdout]       |                      ^^                                             ^^
[INFO] [stdout]       |
[INFO] [stdout] help: remove these braces
[INFO] [stdout]       |
[INFO] [stdout] 10489 -             vec.push({ crate::util::JavaLocale::from_raw(&jni, res)? });
[INFO] [stdout] 10489 +             vec.push(crate::util::JavaLocale::from_raw(&jni, res)?);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary braces around method argument
[INFO] [stdout]      --> src/util/mod.rs:13130:22
[INFO] [stdout]       |
[INFO] [stdout] 13130 |             vec.push({ res });
[INFO] [stdout]       |                      ^^   ^^
[INFO] [stdout]       |
[INFO] [stdout] help: remove these braces
[INFO] [stdout]       |
[INFO] [stdout] 13130 -             vec.push({ res });
[INFO] [stdout] 13130 +             vec.push(res);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary braces around method argument
[INFO] [stdout]      --> src/util/mod.rs:14153:22
[INFO] [stdout]       |
[INFO] [stdout] 14153 |             vec.push({ res });
[INFO] [stdout]       |                      ^^   ^^
[INFO] [stdout]       |
[INFO] [stdout] help: remove these braces
[INFO] [stdout]       |
[INFO] [stdout] 14153 -             vec.push({ res });
[INFO] [stdout] 14153 +             vec.push(res);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary braces around method argument
[INFO] [stdout]      --> src/util/mod.rs:14914:22
[INFO] [stdout]       |
[INFO] [stdout] 14914 |             vec.push({ res });
[INFO] [stdout]       |                      ^^   ^^
[INFO] [stdout]       |
[INFO] [stdout] help: remove these braces
[INFO] [stdout]       |
[INFO] [stdout] 14914 -             vec.push({ res });
[INFO] [stdout] 14914 +             vec.push(res);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary braces around method argument
[INFO] [stdout]      --> src/util/mod.rs:15475:22
[INFO] [stdout]       |
[INFO] [stdout] 15475 |             vec.push({ res });
[INFO] [stdout]       |                      ^^   ^^
[INFO] [stdout]       |
[INFO] [stdout] help: remove these braces
[INFO] [stdout]       |
[INFO] [stdout] 15475 -             vec.push({ res });
[INFO] [stdout] 15475 +             vec.push(res);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary braces around method argument
[INFO] [stdout]      --> src/util/mod.rs:16589:22
[INFO] [stdout]       |
[INFO] [stdout] 16589 |             vec.push({ res });
[INFO] [stdout]       |                      ^^   ^^
[INFO] [stdout]       |
[INFO] [stdout] help: remove these braces
[INFO] [stdout]       |
[INFO] [stdout] 16589 -             vec.push({ res });
[INFO] [stdout] 16589 +             vec.push(res);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary braces around method argument
[INFO] [stdout]      --> src/util/mod.rs:17313:22
[INFO] [stdout]       |
[INFO] [stdout] 17313 |             vec.push({ res });
[INFO] [stdout]       |                      ^^   ^^
[INFO] [stdout]       |
[INFO] [stdout] help: remove these braces
[INFO] [stdout]       |
[INFO] [stdout] 17313 -             vec.push({ res });
[INFO] [stdout] 17313 +             vec.push(res);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary braces around method argument
[INFO] [stdout]      --> src/util/mod.rs:18151:22
[INFO] [stdout]       |
[INFO] [stdout] 18151 |             vec.push({ res });
[INFO] [stdout]       |                      ^^   ^^
[INFO] [stdout]       |
[INFO] [stdout] help: remove these braces
[INFO] [stdout]       |
[INFO] [stdout] 18151 -             vec.push({ res });
[INFO] [stdout] 18151 +             vec.push(res);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary braces around method argument
[INFO] [stdout]      --> src/util/mod.rs:19172:22
[INFO] [stdout]       |
[INFO] [stdout] 19172 |             vec.push({ res });
[INFO] [stdout]       |                      ^^   ^^
[INFO] [stdout]       |
[INFO] [stdout] help: remove these braces
[INFO] [stdout]       |
[INFO] [stdout] 19172 -             vec.push({ res });
[INFO] [stdout] 19172 +             vec.push(res);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary braces around method argument
[INFO] [stdout]    --> src/util/mod.rs:288:22
[INFO] [stdout]     |
[INFO] [stdout] 288 |             vec.push({ res });
[INFO] [stdout]     |                      ^^   ^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: `#[warn(unused_braces)]` (part of `#[warn(unused)]`) on by default
[INFO] [stdout] help: remove these braces
[INFO] [stdout]     |
[INFO] [stdout] 288 -             vec.push({ res });
[INFO] [stdout] 288 +             vec.push(res);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary braces around method argument
[INFO] [stdout]     --> src/util/logging/mod.rs:1395:22
[INFO] [stdout]      |
[INFO] [stdout] 1395 |             vec.push({ crate::util::logging::JavaHandler::from_raw(&self.jni_ref(), res)? });
[INFO] [stdout]      |                      ^^                                                                  ^^
[INFO] [stdout]      |
[INFO] [stdout] help: remove these braces
[INFO] [stdout]      |
[INFO] [stdout] 1395 -             vec.push({ crate::util::logging::JavaHandler::from_raw(&self.jni_ref(), res)? });
[INFO] [stdout] 1395 +             vec.push(crate::util::logging::JavaHandler::from_raw(&self.jni_ref(), res)?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary braces around method argument
[INFO] [stdout]     --> src/util/logging/mod.rs:2651:22
[INFO] [stdout]      |
[INFO] [stdout] 2651 |             vec.push({ res });
[INFO] [stdout]      |                      ^^   ^^
[INFO] [stdout]      |
[INFO] [stdout] help: remove these braces
[INFO] [stdout]      |
[INFO] [stdout] 2651 -             vec.push({ res });
[INFO] [stdout] 2651 +             vec.push(res);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary braces around method argument
[INFO] [stdout]     --> src/util/mod.rs:1573:22
[INFO] [stdout]      |
[INFO] [stdout] 1573 |             vec.push({ res });
[INFO] [stdout]      |                      ^^   ^^
[INFO] [stdout]      |
[INFO] [stdout] help: remove these braces
[INFO] [stdout]      |
[INFO] [stdout] 1573 -             vec.push({ res });
[INFO] [stdout] 1573 +             vec.push(res);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary braces around method argument
[INFO] [stdout]     --> src/util/mod.rs:2235:22
[INFO] [stdout]      |
[INFO] [stdout] 2235 |             vec.push({ res });
[INFO] [stdout]      |                      ^^   ^^
[INFO] [stdout]      |
[INFO] [stdout] help: remove these braces
[INFO] [stdout]      |
[INFO] [stdout] 2235 -             vec.push({ res });
[INFO] [stdout] 2235 +             vec.push(res);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary braces around method argument
[INFO] [stdout]     --> src/util/mod.rs:4658:22
[INFO] [stdout]      |
[INFO] [stdout] 4658 |             vec.push({ res });
[INFO] [stdout]      |                      ^^   ^^
[INFO] [stdout]      |
[INFO] [stdout] help: remove these braces
[INFO] [stdout]      |
[INFO] [stdout] 4658 -             vec.push({ res });
[INFO] [stdout] 4658 +             vec.push(res);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary braces around method argument
[INFO] [stdout]     --> src/util/mod.rs:5091:22
[INFO] [stdout]      |
[INFO] [stdout] 5091 |             vec.push({ res });
[INFO] [stdout]      |                      ^^   ^^
[INFO] [stdout]      |
[INFO] [stdout] help: remove these braces
[INFO] [stdout]      |
[INFO] [stdout] 5091 -             vec.push({ res });
[INFO] [stdout] 5091 +             vec.push(res);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary braces around method argument
[INFO] [stdout]     --> src/util/mod.rs:5417:22
[INFO] [stdout]      |
[INFO] [stdout] 5417 |             vec.push({ res });
[INFO] [stdout]      |                      ^^   ^^
[INFO] [stdout]      |
[INFO] [stdout] help: remove these braces
[INFO] [stdout]      |
[INFO] [stdout] 5417 -             vec.push({ res });
[INFO] [stdout] 5417 +             vec.push(res);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary braces around method argument
[INFO] [stdout]     --> src/util/mod.rs:5788:22
[INFO] [stdout]      |
[INFO] [stdout] 5788 |             vec.push({ res });
[INFO] [stdout]      |                      ^^   ^^
[INFO] [stdout]      |
[INFO] [stdout] help: remove these braces
[INFO] [stdout]      |
[INFO] [stdout] 5788 -             vec.push({ res });
[INFO] [stdout] 5788 +             vec.push(res);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary braces around method argument
[INFO] [stdout]     --> src/util/mod.rs:6374:22
[INFO] [stdout]      |
[INFO] [stdout] 6374 |             vec.push({ res });
[INFO] [stdout]      |                      ^^   ^^
[INFO] [stdout]      |
[INFO] [stdout] help: remove these braces
[INFO] [stdout]      |
[INFO] [stdout] 6374 -             vec.push({ res });
[INFO] [stdout] 6374 +             vec.push(res);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary braces around method argument
[INFO] [stdout]     --> src/util/mod.rs:7451:22
[INFO] [stdout]      |
[INFO] [stdout] 7451 |             vec.push({ res });
[INFO] [stdout]      |                      ^^   ^^
[INFO] [stdout]      |
[INFO] [stdout] help: remove these braces
[INFO] [stdout]      |
[INFO] [stdout] 7451 -             vec.push({ res });
[INFO] [stdout] 7451 +             vec.push(res);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary braces around method argument
[INFO] [stdout]     --> src/util/mod.rs:9293:22
[INFO] [stdout]      |
[INFO] [stdout] 9293 |             vec.push({ res });
[INFO] [stdout]      |                      ^^   ^^
[INFO] [stdout]      |
[INFO] [stdout] help: remove these braces
[INFO] [stdout]      |
[INFO] [stdout] 9293 -             vec.push({ res });
[INFO] [stdout] 9293 +             vec.push(res);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary braces around method argument
[INFO] [stdout]      --> src/util/mod.rs:10018:22
[INFO] [stdout]       |
[INFO] [stdout] 10018 |             vec.push({ res });
[INFO] [stdout]       |                      ^^   ^^
[INFO] [stdout]       |
[INFO] [stdout] help: remove these braces
[INFO] [stdout]       |
[INFO] [stdout] 10018 -             vec.push({ res });
[INFO] [stdout] 10018 +             vec.push(res);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary braces around method argument
[INFO] [stdout]      --> src/util/mod.rs:10489:22
[INFO] [stdout]       |
[INFO] [stdout] 10489 |             vec.push({ crate::util::JavaLocale::from_raw(&jni, res)? });
[INFO] [stdout]       |                      ^^                                             ^^
[INFO] [stdout]       |
[INFO] [stdout] help: remove these braces
[INFO] [stdout]       |
[INFO] [stdout] 10489 -             vec.push({ crate::util::JavaLocale::from_raw(&jni, res)? });
[INFO] [stdout] 10489 +             vec.push(crate::util::JavaLocale::from_raw(&jni, res)?);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary braces around method argument
[INFO] [stdout]      --> src/util/mod.rs:13130:22
[INFO] [stdout]       |
[INFO] [stdout] 13130 |             vec.push({ res });
[INFO] [stdout]       |                      ^^   ^^
[INFO] [stdout]       |
[INFO] [stdout] help: remove these braces
[INFO] [stdout]       |
[INFO] [stdout] 13130 -             vec.push({ res });
[INFO] [stdout] 13130 +             vec.push(res);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary braces around method argument
[INFO] [stdout]      --> src/util/mod.rs:14153:22
[INFO] [stdout]       |
[INFO] [stdout] 14153 |             vec.push({ res });
[INFO] [stdout]       |                      ^^   ^^
[INFO] [stdout]       |
[INFO] [stdout] help: remove these braces
[INFO] [stdout]       |
[INFO] [stdout] 14153 -             vec.push({ res });
[INFO] [stdout] 14153 +             vec.push(res);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary braces around method argument
[INFO] [stdout]      --> src/util/mod.rs:14914:22
[INFO] [stdout]       |
[INFO] [stdout] 14914 |             vec.push({ res });
[INFO] [stdout]       |                      ^^   ^^
[INFO] [stdout]       |
[INFO] [stdout] help: remove these braces
[INFO] [stdout]       |
[INFO] [stdout] 14914 -             vec.push({ res });
[INFO] [stdout] 14914 +             vec.push(res);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary braces around method argument
[INFO] [stdout]      --> src/util/mod.rs:15475:22
[INFO] [stdout]       |
[INFO] [stdout] 15475 |             vec.push({ res });
[INFO] [stdout]       |                      ^^   ^^
[INFO] [stdout]       |
[INFO] [stdout] help: remove these braces
[INFO] [stdout]       |
[INFO] [stdout] 15475 -             vec.push({ res });
[INFO] [stdout] 15475 +             vec.push(res);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary braces around method argument
[INFO] [stdout]      --> src/util/mod.rs:16589:22
[INFO] [stdout]       |
[INFO] [stdout] 16589 |             vec.push({ res });
[INFO] [stdout]       |                      ^^   ^^
[INFO] [stdout]       |
[INFO] [stdout] help: remove these braces
[INFO] [stdout]       |
[INFO] [stdout] 16589 -             vec.push({ res });
[INFO] [stdout] 16589 +             vec.push(res);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary braces around method argument
[INFO] [stdout]      --> src/util/mod.rs:17313:22
[INFO] [stdout]       |
[INFO] [stdout] 17313 |             vec.push({ res });
[INFO] [stdout]       |                      ^^   ^^
[INFO] [stdout]       |
[INFO] [stdout] help: remove these braces
[INFO] [stdout]       |
[INFO] [stdout] 17313 -             vec.push({ res });
[INFO] [stdout] 17313 +             vec.push(res);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary braces around method argument
[INFO] [stdout]      --> src/util/mod.rs:18151:22
[INFO] [stdout]       |
[INFO] [stdout] 18151 |             vec.push({ res });
[INFO] [stdout]       |                      ^^   ^^
[INFO] [stdout]       |
[INFO] [stdout] help: remove these braces
[INFO] [stdout]       |
[INFO] [stdout] 18151 -             vec.push({ res });
[INFO] [stdout] 18151 +             vec.push(res);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary braces around method argument
[INFO] [stdout]      --> src/util/mod.rs:19172:22
[INFO] [stdout]       |
[INFO] [stdout] 19172 |             vec.push({ res });
[INFO] [stdout]       |                      ^^   ^^
[INFO] [stdout]       |
[INFO] [stdout] help: remove these braces
[INFO] [stdout]       |
[INFO] [stdout] 19172 -             vec.push({ res });
[INFO] [stdout] 19172 +             vec.push(res);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary braces around method argument
[INFO] [stdout]     --> src/util/logging/mod.rs:1395:22
[INFO] [stdout]      |
[INFO] [stdout] 1395 |             vec.push({ crate::util::logging::JavaHandler::from_raw(&self.jni_ref(), res)? });
[INFO] [stdout]      |                      ^^                                                                  ^^
[INFO] [stdout]      |
[INFO] [stdout] help: remove these braces
[INFO] [stdout]      |
[INFO] [stdout] 1395 -             vec.push({ crate::util::logging::JavaHandler::from_raw(&self.jni_ref(), res)? });
[INFO] [stdout] 1395 +             vec.push(crate::util::logging::JavaHandler::from_raw(&self.jni_ref(), res)?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary braces around method argument
[INFO] [stdout]     --> src/util/logging/mod.rs:2651:22
[INFO] [stdout]      |
[INFO] [stdout] 2651 |             vec.push({ res });
[INFO] [stdout]      |                      ^^   ^^
[INFO] [stdout]      |
[INFO] [stdout] help: remove these braces
[INFO] [stdout]      |
[INFO] [stdout] 2651 -             vec.push({ res });
[INFO] [stdout] 2651 +             vec.push(res);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaAbstractCollection<'_>`
[INFO] [stdout]    --> src/util/mod.rs:626:57
[INFO] [stdout]     |
[INFO] [stdout] 626 |         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout]     |                                                         ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: `#[deny(self_type_conversion)]` on by default
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 626 -         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout] 626 +         let real: crate::util::JavaAbstractCollection = temp_clone;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 626 -         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout] 626 +         let real: crate::util::JavaAbstractCollection = <JavaAbstractCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaCollection<'_>`
[INFO] [stdout]     --> src/util/mod.rs:1717:49
[INFO] [stdout]      |
[INFO] [stdout] 1717 |         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1717 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 1717 +         let real: crate::util::JavaCollection = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1717 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 1717 +         let real: crate::util::JavaCollection = <JavaCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaAbstractCollection<'_>`
[INFO] [stdout]     --> src/util/mod.rs:1729:57
[INFO] [stdout]      |
[INFO] [stdout] 1729 |         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout]      |                                                         ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1729 -         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout] 1729 +         let real: crate::util::JavaAbstractCollection = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1729 -         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout] 1729 +         let real: crate::util::JavaAbstractCollection = <JavaAbstractCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaAbstractMap<'_>`
[INFO] [stdout]     --> src/util/mod.rs:4455:50
[INFO] [stdout]      |
[INFO] [stdout] 4455 |         let real: crate::util::JavaAbstractMap = temp_clone.into();
[INFO] [stdout]      |                                                  ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4455 -         let real: crate::util::JavaAbstractMap = temp_clone.into();
[INFO] [stdout] 4455 +         let real: crate::util::JavaAbstractMap = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4455 -         let real: crate::util::JavaAbstractMap = temp_clone.into();
[INFO] [stdout] 4455 +         let real: crate::util::JavaAbstractMap = <JavaAbstractMap<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaCollection<'_>`
[INFO] [stdout]     --> src/util/mod.rs:5593:49
[INFO] [stdout]      |
[INFO] [stdout] 5593 |         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5593 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 5593 +         let real: crate::util::JavaCollection = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5593 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 5593 +         let real: crate::util::JavaCollection = <JavaCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaCollection<'_>`
[INFO] [stdout]     --> src/util/mod.rs:5741:49
[INFO] [stdout]      |
[INFO] [stdout] 5741 |         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5741 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 5741 +         let real: crate::util::JavaCollection = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5741 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 5741 +         let real: crate::util::JavaCollection = <JavaCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaCollection<'_>`
[INFO] [stdout]     --> src/util/mod.rs:5748:49
[INFO] [stdout]      |
[INFO] [stdout] 5748 |         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5748 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 5748 +         let real: crate::util::JavaCollection = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5748 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 5748 +         let real: crate::util::JavaCollection = <JavaCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaCollection<'_>`
[INFO] [stdout]     --> src/util/mod.rs:5755:49
[INFO] [stdout]      |
[INFO] [stdout] 5755 |         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5755 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 5755 +         let real: crate::util::JavaCollection = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5755 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 5755 +         let real: crate::util::JavaCollection = <JavaCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaCollection<'_>`
[INFO] [stdout]     --> src/util/mod.rs:5762:49
[INFO] [stdout]      |
[INFO] [stdout] 5762 |         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5762 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 5762 +         let real: crate::util::JavaCollection = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5762 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 5762 +         let real: crate::util::JavaCollection = <JavaCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaCollection<'_>`
[INFO] [stdout]     --> src/util/mod.rs:5814:49
[INFO] [stdout]      |
[INFO] [stdout] 5814 |         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5814 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 5814 +         let real: crate::util::JavaCollection = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5814 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 5814 +         let real: crate::util::JavaCollection = <JavaCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaCollection<'_>`
[INFO] [stdout]     --> src/util/mod.rs:5824:49
[INFO] [stdout]      |
[INFO] [stdout] 5824 |         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5824 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 5824 +         let real: crate::util::JavaCollection = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5824 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 5824 +         let real: crate::util::JavaCollection = <JavaCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaCollection<'_>`
[INFO] [stdout]     --> src/util/mod.rs:5834:49
[INFO] [stdout]      |
[INFO] [stdout] 5834 |         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5834 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 5834 +         let real: crate::util::JavaCollection = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5834 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 5834 +         let real: crate::util::JavaCollection = <JavaCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaCollection<'_>`
[INFO] [stdout]     --> src/util/mod.rs:5844:49
[INFO] [stdout]      |
[INFO] [stdout] 5844 |         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5844 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 5844 +         let real: crate::util::JavaCollection = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5844 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 5844 +         let real: crate::util::JavaCollection = <JavaCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaAbstractCollection<'_>`
[INFO] [stdout]     --> src/util/mod.rs:5854:57
[INFO] [stdout]      |
[INFO] [stdout] 5854 |         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout]      |                                                         ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5854 -         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout] 5854 +         let real: crate::util::JavaAbstractCollection = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5854 -         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout] 5854 +         let real: crate::util::JavaAbstractCollection = <JavaAbstractCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaCollection<'_>`
[INFO] [stdout]     --> src/util/mod.rs:7617:49
[INFO] [stdout]      |
[INFO] [stdout] 7617 |         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7617 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 7617 +         let real: crate::util::JavaCollection = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7617 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 7617 +         let real: crate::util::JavaCollection = <JavaCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaAbstractCollection<'_>`
[INFO] [stdout]     --> src/util/mod.rs:7627:57
[INFO] [stdout]      |
[INFO] [stdout] 7627 |         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout]      |                                                         ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7627 -         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout] 7627 +         let real: crate::util::JavaAbstractCollection = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7627 -         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout] 7627 +         let real: crate::util::JavaAbstractCollection = <JavaAbstractCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaAbstractMap<'_>`
[INFO] [stdout]     --> src/util/mod.rs:8738:50
[INFO] [stdout]      |
[INFO] [stdout] 8738 |         let real: crate::util::JavaAbstractMap = temp_clone.into();
[INFO] [stdout]      |                                                  ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8738 -         let real: crate::util::JavaAbstractMap = temp_clone.into();
[INFO] [stdout] 8738 +         let real: crate::util::JavaAbstractMap = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8738 -         let real: crate::util::JavaAbstractMap = temp_clone.into();
[INFO] [stdout] 8738 +         let real: crate::util::JavaAbstractMap = <JavaAbstractMap<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaCollection<'_>`
[INFO] [stdout]     --> src/util/mod.rs:9246:49
[INFO] [stdout]      |
[INFO] [stdout] 9246 |         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9246 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 9246 +         let real: crate::util::JavaCollection = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9246 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 9246 +         let real: crate::util::JavaCollection = <JavaCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaCollection<'_>`
[INFO] [stdout]     --> src/util/mod.rs:9253:49
[INFO] [stdout]      |
[INFO] [stdout] 9253 |         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9253 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 9253 +         let real: crate::util::JavaCollection = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9253 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 9253 +         let real: crate::util::JavaCollection = <JavaCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaCollection<'_>`
[INFO] [stdout]     --> src/util/mod.rs:9260:49
[INFO] [stdout]      |
[INFO] [stdout] 9260 |         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9260 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 9260 +         let real: crate::util::JavaCollection = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9260 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 9260 +         let real: crate::util::JavaCollection = <JavaCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaCollection<'_>`
[INFO] [stdout]     --> src/util/mod.rs:9267:49
[INFO] [stdout]      |
[INFO] [stdout] 9267 |         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9267 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 9267 +         let real: crate::util::JavaCollection = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9267 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 9267 +         let real: crate::util::JavaCollection = <JavaCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaCollection<'_>`
[INFO] [stdout]     --> src/util/mod.rs:9304:49
[INFO] [stdout]      |
[INFO] [stdout] 9304 |         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9304 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 9304 +         let real: crate::util::JavaCollection = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9304 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 9304 +         let real: crate::util::JavaCollection = <JavaCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaCollection<'_>`
[INFO] [stdout]     --> src/util/mod.rs:9314:49
[INFO] [stdout]      |
[INFO] [stdout] 9314 |         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9314 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 9314 +         let real: crate::util::JavaCollection = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9314 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 9314 +         let real: crate::util::JavaCollection = <JavaCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaCollection<'_>`
[INFO] [stdout]     --> src/util/mod.rs:9324:49
[INFO] [stdout]      |
[INFO] [stdout] 9324 |         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9324 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 9324 +         let real: crate::util::JavaCollection = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9324 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 9324 +         let real: crate::util::JavaCollection = <JavaCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaCollection<'_>`
[INFO] [stdout]     --> src/util/mod.rs:9334:49
[INFO] [stdout]      |
[INFO] [stdout] 9334 |         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9334 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 9334 +         let real: crate::util::JavaCollection = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9334 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 9334 +         let real: crate::util::JavaCollection = <JavaCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaCollection<'_>`
[INFO] [stdout]      --> src/util/mod.rs:10194:49
[INFO] [stdout]       |
[INFO] [stdout] 10194 |         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout]       |                                                 ^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10194 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 10194 +         let real: crate::util::JavaCollection = temp_clone;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10194 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 10194 +         let real: crate::util::JavaCollection = <JavaCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHashSet<'_>`
[INFO] [stdout]      --> src/util/mod.rs:10203:46
[INFO] [stdout]       |
[INFO] [stdout] 10203 |         let real: crate::util::JavaHashSet = temp_clone.into();
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10203 -         let real: crate::util::JavaHashSet = temp_clone.into();
[INFO] [stdout] 10203 +         let real: crate::util::JavaHashSet = temp_clone;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10203 -         let real: crate::util::JavaHashSet = temp_clone.into();
[INFO] [stdout] 10203 +         let real: crate::util::JavaHashSet = <JavaHashSet<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaAbstractCollection<'_>`
[INFO] [stdout]      --> src/util/mod.rs:10215:57
[INFO] [stdout]       |
[INFO] [stdout] 10215 |         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout]       |                                                         ^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10215 -         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout] 10215 +         let real: crate::util::JavaAbstractCollection = temp_clone;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10215 -         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout] 10215 +         let real: crate::util::JavaAbstractCollection = <JavaAbstractCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaAbstractMap<'_>`
[INFO] [stdout]      --> src/util/mod.rs:11608:50
[INFO] [stdout]       |
[INFO] [stdout] 11608 |         let real: crate::util::JavaAbstractMap = temp_clone.into();
[INFO] [stdout]       |                                                  ^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11608 -         let real: crate::util::JavaAbstractMap = temp_clone.into();
[INFO] [stdout] 11608 +         let real: crate::util::JavaAbstractMap = temp_clone;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11608 -         let real: crate::util::JavaAbstractMap = temp_clone.into();
[INFO] [stdout] 11608 +         let real: crate::util::JavaAbstractMap = <JavaAbstractMap<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaAbstractMap<'_>`
[INFO] [stdout]      --> src/util/mod.rs:12209:50
[INFO] [stdout]       |
[INFO] [stdout] 12209 |         let real: crate::util::JavaAbstractMap = temp_clone.into();
[INFO] [stdout]       |                                                  ^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 12209 -         let real: crate::util::JavaAbstractMap = temp_clone.into();
[INFO] [stdout] 12209 +         let real: crate::util::JavaAbstractMap = temp_clone;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 12209 -         let real: crate::util::JavaAbstractMap = temp_clone.into();
[INFO] [stdout] 12209 +         let real: crate::util::JavaAbstractMap = <JavaAbstractMap<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHashMap<'_>`
[INFO] [stdout]      --> src/util/mod.rs:12814:46
[INFO] [stdout]       |
[INFO] [stdout] 12814 |         let real: crate::util::JavaHashMap = temp_clone.into();
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 12814 -         let real: crate::util::JavaHashMap = temp_clone.into();
[INFO] [stdout] 12814 +         let real: crate::util::JavaHashMap = temp_clone;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 12814 -         let real: crate::util::JavaHashMap = temp_clone.into();
[INFO] [stdout] 12814 +         let real: crate::util::JavaHashMap = <JavaHashMap<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaAbstractMap<'_>`
[INFO] [stdout]      --> src/util/mod.rs:12823:50
[INFO] [stdout]       |
[INFO] [stdout] 12823 |         let real: crate::util::JavaAbstractMap = temp_clone.into();
[INFO] [stdout]       |                                                  ^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 12823 -         let real: crate::util::JavaAbstractMap = temp_clone.into();
[INFO] [stdout] 12823 +         let real: crate::util::JavaAbstractMap = temp_clone;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 12823 -         let real: crate::util::JavaAbstractMap = temp_clone.into();
[INFO] [stdout] 12823 +         let real: crate::util::JavaAbstractMap = <JavaAbstractMap<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaCollection<'_>`
[INFO] [stdout]      --> src/util/mod.rs:13299:49
[INFO] [stdout]       |
[INFO] [stdout] 13299 |         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout]       |                                                 ^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 13299 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 13299 +         let real: crate::util::JavaCollection = temp_clone;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 13299 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 13299 +         let real: crate::util::JavaCollection = <JavaCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaAbstractCollection<'_>`
[INFO] [stdout]      --> src/util/mod.rs:13309:57
[INFO] [stdout]       |
[INFO] [stdout] 13309 |         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout]       |                                                         ^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 13309 -         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout] 13309 +         let real: crate::util::JavaAbstractCollection = temp_clone;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 13309 -         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout] 13309 +         let real: crate::util::JavaAbstractCollection = <JavaAbstractCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaCollection<'_>`
[INFO] [stdout]      --> src/util/mod.rs:15118:49
[INFO] [stdout]       |
[INFO] [stdout] 15118 |         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout]       |                                                 ^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 15118 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 15118 +         let real: crate::util::JavaCollection = temp_clone;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 15118 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 15118 +         let real: crate::util::JavaCollection = <JavaCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaAbstractCollection<'_>`
[INFO] [stdout]      --> src/util/mod.rs:15130:57
[INFO] [stdout]       |
[INFO] [stdout] 15130 |         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout]       |                                                         ^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 15130 -         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout] 15130 +         let real: crate::util::JavaAbstractCollection = temp_clone;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 15130 -         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout] 15130 +         let real: crate::util::JavaAbstractCollection = <JavaAbstractCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaCollection<'_>`
[INFO] [stdout]      --> src/util/mod.rs:15644:49
[INFO] [stdout]       |
[INFO] [stdout] 15644 |         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout]       |                                                 ^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 15644 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 15644 +         let real: crate::util::JavaCollection = temp_clone;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 15644 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 15644 +         let real: crate::util::JavaCollection = <JavaCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaAbstractCollection<'_>`
[INFO] [stdout]      --> src/util/mod.rs:15654:57
[INFO] [stdout]       |
[INFO] [stdout] 15654 |         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout]       |                                                         ^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 15654 -         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout] 15654 +         let real: crate::util::JavaAbstractCollection = temp_clone;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 15654 -         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout] 15654 +         let real: crate::util::JavaAbstractCollection = <JavaAbstractCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaCollection<'_>`
[INFO] [stdout]      --> src/util/mod.rs:16908:49
[INFO] [stdout]       |
[INFO] [stdout] 16908 |         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout]       |                                                 ^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 16908 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 16908 +         let real: crate::util::JavaCollection = temp_clone;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 16908 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 16908 +         let real: crate::util::JavaCollection = <JavaCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaAbstractCollection<'_>`
[INFO] [stdout]      --> src/util/mod.rs:16923:57
[INFO] [stdout]       |
[INFO] [stdout] 16923 |         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout]       |                                                         ^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 16923 -         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout] 16923 +         let real: crate::util::JavaAbstractCollection = temp_clone;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 16923 -         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout] 16923 +         let real: crate::util::JavaAbstractCollection = <JavaAbstractCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaCollection<'_>`
[INFO] [stdout]      --> src/util/mod.rs:18225:49
[INFO] [stdout]       |
[INFO] [stdout] 18225 |         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout]       |                                                 ^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 18225 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 18225 +         let real: crate::util::JavaCollection = temp_clone;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 18225 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 18225 +         let real: crate::util::JavaCollection = <JavaCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaAbstractCollection<'_>`
[INFO] [stdout]      --> src/util/mod.rs:18235:57
[INFO] [stdout]       |
[INFO] [stdout] 18235 |         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout]       |                                                         ^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 18235 -         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout] 18235 +         let real: crate::util::JavaAbstractCollection = temp_clone;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 18235 -         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout] 18235 +         let real: crate::util::JavaAbstractCollection = <JavaAbstractCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaAbstractCollection<'_>`
[INFO] [stdout]      --> src/util/mod.rs:19356:57
[INFO] [stdout]       |
[INFO] [stdout] 19356 |         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout]       |                                                         ^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 19356 -         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout] 19356 +         let real: crate::util::JavaAbstractCollection = temp_clone;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 19356 -         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout] 19356 +         let real: crate::util::JavaAbstractCollection = <JavaAbstractCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaFormatter<'_>`
[INFO] [stdout]    --> src/util/logging/mod.rs:187:57
[INFO] [stdout]     |
[INFO] [stdout] 187 |         let real: crate::util::logging::JavaFormatter = temp_clone.into();
[INFO] [stdout]     |                                                         ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 187 -         let real: crate::util::logging::JavaFormatter = temp_clone.into();
[INFO] [stdout] 187 +         let real: crate::util::logging::JavaFormatter = temp_clone;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 187 -         let real: crate::util::logging::JavaFormatter = temp_clone.into();
[INFO] [stdout] 187 +         let real: crate::util::logging::JavaFormatter = <JavaFormatter<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaStreamHandler<'_>`
[INFO] [stdout]    --> src/util/logging/mod.rs:457:61
[INFO] [stdout]     |
[INFO] [stdout] 457 |         let real: crate::util::logging::JavaStreamHandler = temp_clone.into();
[INFO] [stdout]     |                                                             ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 457 -         let real: crate::util::logging::JavaStreamHandler = temp_clone.into();
[INFO] [stdout] 457 +         let real: crate::util::logging::JavaStreamHandler = temp_clone;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 457 -         let real: crate::util::logging::JavaStreamHandler = temp_clone.into();
[INFO] [stdout] 457 +         let real: crate::util::logging::JavaStreamHandler = <JavaStreamHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaStreamHandler<'_>`
[INFO] [stdout]    --> src/util/logging/mod.rs:464:61
[INFO] [stdout]     |
[INFO] [stdout] 464 |         let real: crate::util::logging::JavaStreamHandler = temp_clone.into();
[INFO] [stdout]     |                                                             ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 464 -         let real: crate::util::logging::JavaStreamHandler = temp_clone.into();
[INFO] [stdout] 464 +         let real: crate::util::logging::JavaStreamHandler = temp_clone;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 464 -         let real: crate::util::logging::JavaStreamHandler = temp_clone.into();
[INFO] [stdout] 464 +         let real: crate::util::logging::JavaStreamHandler = <JavaStreamHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaStreamHandler<'_>`
[INFO] [stdout]    --> src/util/logging/mod.rs:471:61
[INFO] [stdout]     |
[INFO] [stdout] 471 |         let real: crate::util::logging::JavaStreamHandler = temp_clone.into();
[INFO] [stdout]     |                                                             ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 471 -         let real: crate::util::logging::JavaStreamHandler = temp_clone.into();
[INFO] [stdout] 471 +         let real: crate::util::logging::JavaStreamHandler = temp_clone;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 471 -         let real: crate::util::logging::JavaStreamHandler = temp_clone.into();
[INFO] [stdout] 471 +         let real: crate::util::logging::JavaStreamHandler = <JavaStreamHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]    --> src/util/logging/mod.rs:482:55
[INFO] [stdout]     |
[INFO] [stdout] 482 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]     |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 482 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 482 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 482 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 482 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]    --> src/util/logging/mod.rs:492:55
[INFO] [stdout]     |
[INFO] [stdout] 492 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]     |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 492 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 492 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 492 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 492 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]    --> src/util/logging/mod.rs:501:55
[INFO] [stdout]     |
[INFO] [stdout] 501 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]     |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 501 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 501 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 501 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 501 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]    --> src/util/logging/mod.rs:511:55
[INFO] [stdout]     |
[INFO] [stdout] 511 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]     |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 511 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 511 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 511 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 511 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]    --> src/util/logging/mod.rs:520:55
[INFO] [stdout]     |
[INFO] [stdout] 520 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]     |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 520 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 520 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 520 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 520 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]    --> src/util/logging/mod.rs:530:55
[INFO] [stdout]     |
[INFO] [stdout] 530 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]     |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 530 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 530 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 530 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 530 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]    --> src/util/logging/mod.rs:539:55
[INFO] [stdout]     |
[INFO] [stdout] 539 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]     |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 539 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 539 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 539 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 539 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]    --> src/util/logging/mod.rs:546:55
[INFO] [stdout]     |
[INFO] [stdout] 546 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]     |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 546 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 546 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 546 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 546 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]    --> src/util/logging/mod.rs:555:55
[INFO] [stdout]     |
[INFO] [stdout] 555 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]     |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 555 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 555 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 555 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 555 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaFormatter<'_>`
[INFO] [stdout]    --> src/util/logging/mod.rs:652:57
[INFO] [stdout]     |
[INFO] [stdout] 652 |         let real: crate::util::logging::JavaFormatter = temp_clone.into();
[INFO] [stdout]     |                                                         ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 652 -         let real: crate::util::logging::JavaFormatter = temp_clone.into();
[INFO] [stdout] 652 +         let real: crate::util::logging::JavaFormatter = temp_clone;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 652 -         let real: crate::util::logging::JavaFormatter = temp_clone.into();
[INFO] [stdout] 652 +         let real: crate::util::logging::JavaFormatter = <JavaFormatter<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaFormatter<'_>`
[INFO] [stdout]    --> src/util/logging/mod.rs:662:57
[INFO] [stdout]     |
[INFO] [stdout] 662 |         let real: crate::util::logging::JavaFormatter = temp_clone.into();
[INFO] [stdout]     |                                                         ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 662 -         let real: crate::util::logging::JavaFormatter = temp_clone.into();
[INFO] [stdout] 662 +         let real: crate::util::logging::JavaFormatter = temp_clone;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 662 -         let real: crate::util::logging::JavaFormatter = temp_clone.into();
[INFO] [stdout] 662 +         let real: crate::util::logging::JavaFormatter = <JavaFormatter<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaFormatter<'_>`
[INFO] [stdout]    --> src/util/logging/mod.rs:672:57
[INFO] [stdout]     |
[INFO] [stdout] 672 |         let real: crate::util::logging::JavaFormatter = temp_clone.into();
[INFO] [stdout]     |                                                         ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 672 -         let real: crate::util::logging::JavaFormatter = temp_clone.into();
[INFO] [stdout] 672 +         let real: crate::util::logging::JavaFormatter = temp_clone;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 672 -         let real: crate::util::logging::JavaFormatter = temp_clone.into();
[INFO] [stdout] 672 +         let real: crate::util::logging::JavaFormatter = <JavaFormatter<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:1140:55
[INFO] [stdout]      |
[INFO] [stdout] 1140 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1140 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 1140 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1140 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 1140 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:1150:55
[INFO] [stdout]      |
[INFO] [stdout] 1150 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1150 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 1150 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1150 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 1150 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:1159:55
[INFO] [stdout]      |
[INFO] [stdout] 1159 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1159 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 1159 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1159 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 1159 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:1169:55
[INFO] [stdout]      |
[INFO] [stdout] 1169 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1169 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 1169 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1169 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 1169 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:1178:55
[INFO] [stdout]      |
[INFO] [stdout] 1178 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1178 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 1178 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1178 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 1178 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:1185:55
[INFO] [stdout]      |
[INFO] [stdout] 1185 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1185 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 1185 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1185 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 1185 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:1195:55
[INFO] [stdout]      |
[INFO] [stdout] 1195 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1195 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 1195 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1195 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 1195 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:1204:55
[INFO] [stdout]      |
[INFO] [stdout] 1204 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1204 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 1204 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1204 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 1204 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:1211:55
[INFO] [stdout]      |
[INFO] [stdout] 1211 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1211 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 1211 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1211 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 1211 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:1220:55
[INFO] [stdout]      |
[INFO] [stdout] 1220 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1220 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 1220 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1220 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 1220 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaStreamHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:1976:61
[INFO] [stdout]      |
[INFO] [stdout] 1976 |         let real: crate::util::logging::JavaStreamHandler = temp_clone.into();
[INFO] [stdout]      |                                                             ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1976 -         let real: crate::util::logging::JavaStreamHandler = temp_clone.into();
[INFO] [stdout] 1976 +         let real: crate::util::logging::JavaStreamHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1976 -         let real: crate::util::logging::JavaStreamHandler = temp_clone.into();
[INFO] [stdout] 1976 +         let real: crate::util::logging::JavaStreamHandler = <JavaStreamHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaStreamHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:1983:61
[INFO] [stdout]      |
[INFO] [stdout] 1983 |         let real: crate::util::logging::JavaStreamHandler = temp_clone.into();
[INFO] [stdout]      |                                                             ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1983 -         let real: crate::util::logging::JavaStreamHandler = temp_clone.into();
[INFO] [stdout] 1983 +         let real: crate::util::logging::JavaStreamHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1983 -         let real: crate::util::logging::JavaStreamHandler = temp_clone.into();
[INFO] [stdout] 1983 +         let real: crate::util::logging::JavaStreamHandler = <JavaStreamHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaStreamHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:1990:61
[INFO] [stdout]      |
[INFO] [stdout] 1990 |         let real: crate::util::logging::JavaStreamHandler = temp_clone.into();
[INFO] [stdout]      |                                                             ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1990 -         let real: crate::util::logging::JavaStreamHandler = temp_clone.into();
[INFO] [stdout] 1990 +         let real: crate::util::logging::JavaStreamHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1990 -         let real: crate::util::logging::JavaStreamHandler = temp_clone.into();
[INFO] [stdout] 1990 +         let real: crate::util::logging::JavaStreamHandler = <JavaStreamHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:2001:55
[INFO] [stdout]      |
[INFO] [stdout] 2001 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2001 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2001 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2001 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2001 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:2011:55
[INFO] [stdout]      |
[INFO] [stdout] 2011 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2011 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2011 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2011 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2011 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:2020:55
[INFO] [stdout]      |
[INFO] [stdout] 2020 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2020 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2020 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2020 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2020 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:2030:55
[INFO] [stdout]      |
[INFO] [stdout] 2030 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2030 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2030 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2030 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2030 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:2039:55
[INFO] [stdout]      |
[INFO] [stdout] 2039 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2039 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2039 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2039 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2039 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:2049:55
[INFO] [stdout]      |
[INFO] [stdout] 2049 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2049 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2049 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2049 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2049 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:2058:55
[INFO] [stdout]      |
[INFO] [stdout] 2058 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2058 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2058 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2058 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2058 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:2065:55
[INFO] [stdout]      |
[INFO] [stdout] 2065 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2065 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2065 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2065 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2065 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:2074:55
[INFO] [stdout]      |
[INFO] [stdout] 2074 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2074 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2074 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2074 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2074 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:2824:55
[INFO] [stdout]      |
[INFO] [stdout] 2824 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2824 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2824 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2824 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2824 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:2834:55
[INFO] [stdout]      |
[INFO] [stdout] 2834 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2834 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2834 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2834 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2834 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:2843:55
[INFO] [stdout]      |
[INFO] [stdout] 2843 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2843 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2843 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2843 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2843 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:2853:55
[INFO] [stdout]      |
[INFO] [stdout] 2853 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2853 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2853 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2853 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2853 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:2862:55
[INFO] [stdout]      |
[INFO] [stdout] 2862 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2862 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2862 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2862 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2862 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:2872:55
[INFO] [stdout]      |
[INFO] [stdout] 2872 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2872 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2872 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2872 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2872 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:2881:55
[INFO] [stdout]      |
[INFO] [stdout] 2881 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2881 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2881 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2881 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2881 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:2888:55
[INFO] [stdout]      |
[INFO] [stdout] 2888 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2888 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2888 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2888 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2888 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:2897:55
[INFO] [stdout]      |
[INFO] [stdout] 2897 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2897 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2897 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2897 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2897 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaRandomGeneratorJumpableGenerator<'_>`
[INFO] [stdout]     --> src/util/random/mod.rs:1028:79
[INFO] [stdout]      |
[INFO] [stdout] 1028 |         let real: crate::util::random::JavaRandomGeneratorJumpableGenerator = temp_clone.into();
[INFO] [stdout]      |                                                                               ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1028 -         let real: crate::util::random::JavaRandomGeneratorJumpableGenerator = temp_clone.into();
[INFO] [stdout] 1028 +         let real: crate::util::random::JavaRandomGeneratorJumpableGenerator = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1028 -         let real: crate::util::random::JavaRandomGeneratorJumpableGenerator = temp_clone.into();
[INFO] [stdout] 1028 +         let real: crate::util::random::JavaRandomGeneratorJumpableGenerator = <JavaRandomGeneratorJumpableGenerator<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `blackboxmc_java` (lib test) due to 91 previous errors; 22 warnings emitted
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] [stdout] error: useless conversion to the same type: `JavaAbstractCollection<'_>`
[INFO] [stdout]    --> src/util/mod.rs:626:57
[INFO] [stdout]     |
[INFO] [stdout] 626 |         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout]     |                                                         ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: `#[deny(self_type_conversion)]` on by default
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 626 -         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout] 626 +         let real: crate::util::JavaAbstractCollection = temp_clone;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 626 -         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout] 626 +         let real: crate::util::JavaAbstractCollection = <JavaAbstractCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaCollection<'_>`
[INFO] [stdout]     --> src/util/mod.rs:1717:49
[INFO] [stdout]      |
[INFO] [stdout] 1717 |         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1717 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 1717 +         let real: crate::util::JavaCollection = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1717 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 1717 +         let real: crate::util::JavaCollection = <JavaCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaAbstractCollection<'_>`
[INFO] [stdout]     --> src/util/mod.rs:1729:57
[INFO] [stdout]      |
[INFO] [stdout] 1729 |         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout]      |                                                         ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1729 -         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout] 1729 +         let real: crate::util::JavaAbstractCollection = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1729 -         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout] 1729 +         let real: crate::util::JavaAbstractCollection = <JavaAbstractCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaAbstractMap<'_>`
[INFO] [stdout]     --> src/util/mod.rs:4455:50
[INFO] [stdout]      |
[INFO] [stdout] 4455 |         let real: crate::util::JavaAbstractMap = temp_clone.into();
[INFO] [stdout]      |                                                  ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 4455 -         let real: crate::util::JavaAbstractMap = temp_clone.into();
[INFO] [stdout] 4455 +         let real: crate::util::JavaAbstractMap = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 4455 -         let real: crate::util::JavaAbstractMap = temp_clone.into();
[INFO] [stdout] 4455 +         let real: crate::util::JavaAbstractMap = <JavaAbstractMap<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaCollection<'_>`
[INFO] [stdout]     --> src/util/mod.rs:5593:49
[INFO] [stdout]      |
[INFO] [stdout] 5593 |         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5593 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 5593 +         let real: crate::util::JavaCollection = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5593 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 5593 +         let real: crate::util::JavaCollection = <JavaCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaCollection<'_>`
[INFO] [stdout]     --> src/util/mod.rs:5741:49
[INFO] [stdout]      |
[INFO] [stdout] 5741 |         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5741 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 5741 +         let real: crate::util::JavaCollection = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5741 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 5741 +         let real: crate::util::JavaCollection = <JavaCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaCollection<'_>`
[INFO] [stdout]     --> src/util/mod.rs:5748:49
[INFO] [stdout]      |
[INFO] [stdout] 5748 |         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5748 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 5748 +         let real: crate::util::JavaCollection = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5748 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 5748 +         let real: crate::util::JavaCollection = <JavaCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaCollection<'_>`
[INFO] [stdout]     --> src/util/mod.rs:5755:49
[INFO] [stdout]      |
[INFO] [stdout] 5755 |         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5755 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 5755 +         let real: crate::util::JavaCollection = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5755 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 5755 +         let real: crate::util::JavaCollection = <JavaCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaCollection<'_>`
[INFO] [stdout]     --> src/util/mod.rs:5762:49
[INFO] [stdout]      |
[INFO] [stdout] 5762 |         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5762 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 5762 +         let real: crate::util::JavaCollection = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5762 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 5762 +         let real: crate::util::JavaCollection = <JavaCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaCollection<'_>`
[INFO] [stdout]     --> src/util/mod.rs:5814:49
[INFO] [stdout]      |
[INFO] [stdout] 5814 |         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5814 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 5814 +         let real: crate::util::JavaCollection = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5814 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 5814 +         let real: crate::util::JavaCollection = <JavaCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaCollection<'_>`
[INFO] [stdout]     --> src/util/mod.rs:5824:49
[INFO] [stdout]      |
[INFO] [stdout] 5824 |         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5824 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 5824 +         let real: crate::util::JavaCollection = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5824 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 5824 +         let real: crate::util::JavaCollection = <JavaCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaCollection<'_>`
[INFO] [stdout]     --> src/util/mod.rs:5834:49
[INFO] [stdout]      |
[INFO] [stdout] 5834 |         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5834 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 5834 +         let real: crate::util::JavaCollection = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5834 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 5834 +         let real: crate::util::JavaCollection = <JavaCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaCollection<'_>`
[INFO] [stdout]     --> src/util/mod.rs:5844:49
[INFO] [stdout]      |
[INFO] [stdout] 5844 |         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5844 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 5844 +         let real: crate::util::JavaCollection = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5844 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 5844 +         let real: crate::util::JavaCollection = <JavaCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaAbstractCollection<'_>`
[INFO] [stdout]     --> src/util/mod.rs:5854:57
[INFO] [stdout]      |
[INFO] [stdout] 5854 |         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout]      |                                                         ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 5854 -         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout] 5854 +         let real: crate::util::JavaAbstractCollection = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 5854 -         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout] 5854 +         let real: crate::util::JavaAbstractCollection = <JavaAbstractCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaCollection<'_>`
[INFO] [stdout]     --> src/util/mod.rs:7617:49
[INFO] [stdout]      |
[INFO] [stdout] 7617 |         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7617 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 7617 +         let real: crate::util::JavaCollection = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7617 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 7617 +         let real: crate::util::JavaCollection = <JavaCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaAbstractCollection<'_>`
[INFO] [stdout]     --> src/util/mod.rs:7627:57
[INFO] [stdout]      |
[INFO] [stdout] 7627 |         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout]      |                                                         ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 7627 -         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout] 7627 +         let real: crate::util::JavaAbstractCollection = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 7627 -         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout] 7627 +         let real: crate::util::JavaAbstractCollection = <JavaAbstractCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaAbstractMap<'_>`
[INFO] [stdout]     --> src/util/mod.rs:8738:50
[INFO] [stdout]      |
[INFO] [stdout] 8738 |         let real: crate::util::JavaAbstractMap = temp_clone.into();
[INFO] [stdout]      |                                                  ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 8738 -         let real: crate::util::JavaAbstractMap = temp_clone.into();
[INFO] [stdout] 8738 +         let real: crate::util::JavaAbstractMap = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 8738 -         let real: crate::util::JavaAbstractMap = temp_clone.into();
[INFO] [stdout] 8738 +         let real: crate::util::JavaAbstractMap = <JavaAbstractMap<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaCollection<'_>`
[INFO] [stdout]     --> src/util/mod.rs:9246:49
[INFO] [stdout]      |
[INFO] [stdout] 9246 |         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9246 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 9246 +         let real: crate::util::JavaCollection = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9246 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 9246 +         let real: crate::util::JavaCollection = <JavaCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaCollection<'_>`
[INFO] [stdout]     --> src/util/mod.rs:9253:49
[INFO] [stdout]      |
[INFO] [stdout] 9253 |         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9253 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 9253 +         let real: crate::util::JavaCollection = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9253 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 9253 +         let real: crate::util::JavaCollection = <JavaCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaCollection<'_>`
[INFO] [stdout]     --> src/util/mod.rs:9260:49
[INFO] [stdout]      |
[INFO] [stdout] 9260 |         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9260 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 9260 +         let real: crate::util::JavaCollection = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9260 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 9260 +         let real: crate::util::JavaCollection = <JavaCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaCollection<'_>`
[INFO] [stdout]     --> src/util/mod.rs:9267:49
[INFO] [stdout]      |
[INFO] [stdout] 9267 |         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9267 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 9267 +         let real: crate::util::JavaCollection = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9267 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 9267 +         let real: crate::util::JavaCollection = <JavaCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaCollection<'_>`
[INFO] [stdout]     --> src/util/mod.rs:9304:49
[INFO] [stdout]      |
[INFO] [stdout] 9304 |         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9304 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 9304 +         let real: crate::util::JavaCollection = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9304 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 9304 +         let real: crate::util::JavaCollection = <JavaCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaCollection<'_>`
[INFO] [stdout]     --> src/util/mod.rs:9314:49
[INFO] [stdout]      |
[INFO] [stdout] 9314 |         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9314 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 9314 +         let real: crate::util::JavaCollection = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9314 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 9314 +         let real: crate::util::JavaCollection = <JavaCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaCollection<'_>`
[INFO] [stdout]     --> src/util/mod.rs:9324:49
[INFO] [stdout]      |
[INFO] [stdout] 9324 |         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9324 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 9324 +         let real: crate::util::JavaCollection = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9324 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 9324 +         let real: crate::util::JavaCollection = <JavaCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaCollection<'_>`
[INFO] [stdout]     --> src/util/mod.rs:9334:49
[INFO] [stdout]      |
[INFO] [stdout] 9334 |         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 9334 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 9334 +         let real: crate::util::JavaCollection = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 9334 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 9334 +         let real: crate::util::JavaCollection = <JavaCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaCollection<'_>`
[INFO] [stdout]      --> src/util/mod.rs:10194:49
[INFO] [stdout]       |
[INFO] [stdout] 10194 |         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout]       |                                                 ^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10194 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 10194 +         let real: crate::util::JavaCollection = temp_clone;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10194 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 10194 +         let real: crate::util::JavaCollection = <JavaCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHashSet<'_>`
[INFO] [stdout]      --> src/util/mod.rs:10203:46
[INFO] [stdout]       |
[INFO] [stdout] 10203 |         let real: crate::util::JavaHashSet = temp_clone.into();
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10203 -         let real: crate::util::JavaHashSet = temp_clone.into();
[INFO] [stdout] 10203 +         let real: crate::util::JavaHashSet = temp_clone;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10203 -         let real: crate::util::JavaHashSet = temp_clone.into();
[INFO] [stdout] 10203 +         let real: crate::util::JavaHashSet = <JavaHashSet<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaAbstractCollection<'_>`
[INFO] [stdout]      --> src/util/mod.rs:10215:57
[INFO] [stdout]       |
[INFO] [stdout] 10215 |         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout]       |                                                         ^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 10215 -         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout] 10215 +         let real: crate::util::JavaAbstractCollection = temp_clone;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 10215 -         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout] 10215 +         let real: crate::util::JavaAbstractCollection = <JavaAbstractCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaAbstractMap<'_>`
[INFO] [stdout]      --> src/util/mod.rs:11608:50
[INFO] [stdout]       |
[INFO] [stdout] 11608 |         let real: crate::util::JavaAbstractMap = temp_clone.into();
[INFO] [stdout]       |                                                  ^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 11608 -         let real: crate::util::JavaAbstractMap = temp_clone.into();
[INFO] [stdout] 11608 +         let real: crate::util::JavaAbstractMap = temp_clone;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 11608 -         let real: crate::util::JavaAbstractMap = temp_clone.into();
[INFO] [stdout] 11608 +         let real: crate::util::JavaAbstractMap = <JavaAbstractMap<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaAbstractMap<'_>`
[INFO] [stdout]      --> src/util/mod.rs:12209:50
[INFO] [stdout]       |
[INFO] [stdout] 12209 |         let real: crate::util::JavaAbstractMap = temp_clone.into();
[INFO] [stdout]       |                                                  ^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 12209 -         let real: crate::util::JavaAbstractMap = temp_clone.into();
[INFO] [stdout] 12209 +         let real: crate::util::JavaAbstractMap = temp_clone;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 12209 -         let real: crate::util::JavaAbstractMap = temp_clone.into();
[INFO] [stdout] 12209 +         let real: crate::util::JavaAbstractMap = <JavaAbstractMap<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHashMap<'_>`
[INFO] [stdout]      --> src/util/mod.rs:12814:46
[INFO] [stdout]       |
[INFO] [stdout] 12814 |         let real: crate::util::JavaHashMap = temp_clone.into();
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 12814 -         let real: crate::util::JavaHashMap = temp_clone.into();
[INFO] [stdout] 12814 +         let real: crate::util::JavaHashMap = temp_clone;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 12814 -         let real: crate::util::JavaHashMap = temp_clone.into();
[INFO] [stdout] 12814 +         let real: crate::util::JavaHashMap = <JavaHashMap<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaAbstractMap<'_>`
[INFO] [stdout]      --> src/util/mod.rs:12823:50
[INFO] [stdout]       |
[INFO] [stdout] 12823 |         let real: crate::util::JavaAbstractMap = temp_clone.into();
[INFO] [stdout]       |                                                  ^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 12823 -         let real: crate::util::JavaAbstractMap = temp_clone.into();
[INFO] [stdout] 12823 +         let real: crate::util::JavaAbstractMap = temp_clone;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 12823 -         let real: crate::util::JavaAbstractMap = temp_clone.into();
[INFO] [stdout] 12823 +         let real: crate::util::JavaAbstractMap = <JavaAbstractMap<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaCollection<'_>`
[INFO] [stdout]      --> src/util/mod.rs:13299:49
[INFO] [stdout]       |
[INFO] [stdout] 13299 |         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout]       |                                                 ^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 13299 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 13299 +         let real: crate::util::JavaCollection = temp_clone;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 13299 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 13299 +         let real: crate::util::JavaCollection = <JavaCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaAbstractCollection<'_>`
[INFO] [stdout]      --> src/util/mod.rs:13309:57
[INFO] [stdout]       |
[INFO] [stdout] 13309 |         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout]       |                                                         ^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 13309 -         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout] 13309 +         let real: crate::util::JavaAbstractCollection = temp_clone;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 13309 -         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout] 13309 +         let real: crate::util::JavaAbstractCollection = <JavaAbstractCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaCollection<'_>`
[INFO] [stdout]      --> src/util/mod.rs:15118:49
[INFO] [stdout]       |
[INFO] [stdout] 15118 |         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout]       |                                                 ^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 15118 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 15118 +         let real: crate::util::JavaCollection = temp_clone;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 15118 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 15118 +         let real: crate::util::JavaCollection = <JavaCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaAbstractCollection<'_>`
[INFO] [stdout]      --> src/util/mod.rs:15130:57
[INFO] [stdout]       |
[INFO] [stdout] 15130 |         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout]       |                                                         ^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 15130 -         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout] 15130 +         let real: crate::util::JavaAbstractCollection = temp_clone;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 15130 -         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout] 15130 +         let real: crate::util::JavaAbstractCollection = <JavaAbstractCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaCollection<'_>`
[INFO] [stdout]      --> src/util/mod.rs:15644:49
[INFO] [stdout]       |
[INFO] [stdout] 15644 |         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout]       |                                                 ^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 15644 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 15644 +         let real: crate::util::JavaCollection = temp_clone;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 15644 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 15644 +         let real: crate::util::JavaCollection = <JavaCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaAbstractCollection<'_>`
[INFO] [stdout]      --> src/util/mod.rs:15654:57
[INFO] [stdout]       |
[INFO] [stdout] 15654 |         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout]       |                                                         ^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 15654 -         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout] 15654 +         let real: crate::util::JavaAbstractCollection = temp_clone;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 15654 -         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout] 15654 +         let real: crate::util::JavaAbstractCollection = <JavaAbstractCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaCollection<'_>`
[INFO] [stdout]      --> src/util/mod.rs:16908:49
[INFO] [stdout]       |
[INFO] [stdout] 16908 |         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout]       |                                                 ^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 16908 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 16908 +         let real: crate::util::JavaCollection = temp_clone;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 16908 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 16908 +         let real: crate::util::JavaCollection = <JavaCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaAbstractCollection<'_>`
[INFO] [stdout]      --> src/util/mod.rs:16923:57
[INFO] [stdout]       |
[INFO] [stdout] 16923 |         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout]       |                                                         ^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 16923 -         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout] 16923 +         let real: crate::util::JavaAbstractCollection = temp_clone;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 16923 -         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout] 16923 +         let real: crate::util::JavaAbstractCollection = <JavaAbstractCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaCollection<'_>`
[INFO] [stdout]      --> src/util/mod.rs:18225:49
[INFO] [stdout]       |
[INFO] [stdout] 18225 |         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout]       |                                                 ^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 18225 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 18225 +         let real: crate::util::JavaCollection = temp_clone;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 18225 -         let real: crate::util::JavaCollection = temp_clone.into();
[INFO] [stdout] 18225 +         let real: crate::util::JavaCollection = <JavaCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaAbstractCollection<'_>`
[INFO] [stdout]      --> src/util/mod.rs:18235:57
[INFO] [stdout]       |
[INFO] [stdout] 18235 |         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout]       |                                                         ^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 18235 -         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout] 18235 +         let real: crate::util::JavaAbstractCollection = temp_clone;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 18235 -         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout] 18235 +         let real: crate::util::JavaAbstractCollection = <JavaAbstractCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaAbstractCollection<'_>`
[INFO] [stdout]      --> src/util/mod.rs:19356:57
[INFO] [stdout]       |
[INFO] [stdout] 19356 |         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout]       |                                                         ^^^^^^^^^^^^^^^^^
[INFO] [stdout]       |
[INFO] [stdout]       = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]       |
[INFO] [stdout] 19356 -         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout] 19356 +         let real: crate::util::JavaAbstractCollection = temp_clone;
[INFO] [stdout]       |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]       |
[INFO] [stdout] 19356 -         let real: crate::util::JavaAbstractCollection = temp_clone.into();
[INFO] [stdout] 19356 +         let real: crate::util::JavaAbstractCollection = <JavaAbstractCollection<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]       |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaFormatter<'_>`
[INFO] [stdout]    --> src/util/logging/mod.rs:187:57
[INFO] [stdout]     |
[INFO] [stdout] 187 |         let real: crate::util::logging::JavaFormatter = temp_clone.into();
[INFO] [stdout]     |                                                         ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 187 -         let real: crate::util::logging::JavaFormatter = temp_clone.into();
[INFO] [stdout] 187 +         let real: crate::util::logging::JavaFormatter = temp_clone;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 187 -         let real: crate::util::logging::JavaFormatter = temp_clone.into();
[INFO] [stdout] 187 +         let real: crate::util::logging::JavaFormatter = <JavaFormatter<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaStreamHandler<'_>`
[INFO] [stdout]    --> src/util/logging/mod.rs:457:61
[INFO] [stdout]     |
[INFO] [stdout] 457 |         let real: crate::util::logging::JavaStreamHandler = temp_clone.into();
[INFO] [stdout]     |                                                             ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 457 -         let real: crate::util::logging::JavaStreamHandler = temp_clone.into();
[INFO] [stdout] 457 +         let real: crate::util::logging::JavaStreamHandler = temp_clone;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 457 -         let real: crate::util::logging::JavaStreamHandler = temp_clone.into();
[INFO] [stdout] 457 +         let real: crate::util::logging::JavaStreamHandler = <JavaStreamHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaStreamHandler<'_>`
[INFO] [stdout]    --> src/util/logging/mod.rs:464:61
[INFO] [stdout]     |
[INFO] [stdout] 464 |         let real: crate::util::logging::JavaStreamHandler = temp_clone.into();
[INFO] [stdout]     |                                                             ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 464 -         let real: crate::util::logging::JavaStreamHandler = temp_clone.into();
[INFO] [stdout] 464 +         let real: crate::util::logging::JavaStreamHandler = temp_clone;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 464 -         let real: crate::util::logging::JavaStreamHandler = temp_clone.into();
[INFO] [stdout] 464 +         let real: crate::util::logging::JavaStreamHandler = <JavaStreamHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaStreamHandler<'_>`
[INFO] [stdout]    --> src/util/logging/mod.rs:471:61
[INFO] [stdout]     |
[INFO] [stdout] 471 |         let real: crate::util::logging::JavaStreamHandler = temp_clone.into();
[INFO] [stdout]     |                                                             ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 471 -         let real: crate::util::logging::JavaStreamHandler = temp_clone.into();
[INFO] [stdout] 471 +         let real: crate::util::logging::JavaStreamHandler = temp_clone;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 471 -         let real: crate::util::logging::JavaStreamHandler = temp_clone.into();
[INFO] [stdout] 471 +         let real: crate::util::logging::JavaStreamHandler = <JavaStreamHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]    --> src/util/logging/mod.rs:482:55
[INFO] [stdout]     |
[INFO] [stdout] 482 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]     |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 482 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 482 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 482 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 482 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]    --> src/util/logging/mod.rs:492:55
[INFO] [stdout]     |
[INFO] [stdout] 492 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]     |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 492 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 492 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 492 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 492 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]    --> src/util/logging/mod.rs:501:55
[INFO] [stdout]     |
[INFO] [stdout] 501 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]     |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 501 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 501 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 501 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 501 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]    --> src/util/logging/mod.rs:511:55
[INFO] [stdout]     |
[INFO] [stdout] 511 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]     |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 511 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 511 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 511 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 511 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]    --> src/util/logging/mod.rs:520:55
[INFO] [stdout]     |
[INFO] [stdout] 520 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]     |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 520 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 520 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 520 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 520 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]    --> src/util/logging/mod.rs:530:55
[INFO] [stdout]     |
[INFO] [stdout] 530 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]     |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 530 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 530 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 530 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 530 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]    --> src/util/logging/mod.rs:539:55
[INFO] [stdout]     |
[INFO] [stdout] 539 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]     |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 539 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 539 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 539 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 539 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]    --> src/util/logging/mod.rs:546:55
[INFO] [stdout]     |
[INFO] [stdout] 546 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]     |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 546 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 546 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 546 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 546 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]    --> src/util/logging/mod.rs:555:55
[INFO] [stdout]     |
[INFO] [stdout] 555 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]     |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 555 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 555 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 555 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 555 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaFormatter<'_>`
[INFO] [stdout]    --> src/util/logging/mod.rs:652:57
[INFO] [stdout]     |
[INFO] [stdout] 652 |         let real: crate::util::logging::JavaFormatter = temp_clone.into();
[INFO] [stdout]     |                                                         ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 652 -         let real: crate::util::logging::JavaFormatter = temp_clone.into();
[INFO] [stdout] 652 +         let real: crate::util::logging::JavaFormatter = temp_clone;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 652 -         let real: crate::util::logging::JavaFormatter = temp_clone.into();
[INFO] [stdout] 652 +         let real: crate::util::logging::JavaFormatter = <JavaFormatter<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaFormatter<'_>`
[INFO] [stdout]    --> src/util/logging/mod.rs:662:57
[INFO] [stdout]     |
[INFO] [stdout] 662 |         let real: crate::util::logging::JavaFormatter = temp_clone.into();
[INFO] [stdout]     |                                                         ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 662 -         let real: crate::util::logging::JavaFormatter = temp_clone.into();
[INFO] [stdout] 662 +         let real: crate::util::logging::JavaFormatter = temp_clone;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 662 -         let real: crate::util::logging::JavaFormatter = temp_clone.into();
[INFO] [stdout] 662 +         let real: crate::util::logging::JavaFormatter = <JavaFormatter<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaFormatter<'_>`
[INFO] [stdout]    --> src/util/logging/mod.rs:672:57
[INFO] [stdout]     |
[INFO] [stdout] 672 |         let real: crate::util::logging::JavaFormatter = temp_clone.into();
[INFO] [stdout]     |                                                         ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 672 -         let real: crate::util::logging::JavaFormatter = temp_clone.into();
[INFO] [stdout] 672 +         let real: crate::util::logging::JavaFormatter = temp_clone;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 672 -         let real: crate::util::logging::JavaFormatter = temp_clone.into();
[INFO] [stdout] 672 +         let real: crate::util::logging::JavaFormatter = <JavaFormatter<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:1140:55
[INFO] [stdout]      |
[INFO] [stdout] 1140 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1140 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 1140 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1140 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 1140 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:1150:55
[INFO] [stdout]      |
[INFO] [stdout] 1150 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1150 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 1150 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1150 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 1150 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:1159:55
[INFO] [stdout]      |
[INFO] [stdout] 1159 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1159 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 1159 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1159 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 1159 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:1169:55
[INFO] [stdout]      |
[INFO] [stdout] 1169 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1169 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 1169 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1169 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 1169 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:1178:55
[INFO] [stdout]      |
[INFO] [stdout] 1178 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1178 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 1178 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1178 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 1178 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:1185:55
[INFO] [stdout]      |
[INFO] [stdout] 1185 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1185 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 1185 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1185 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 1185 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:1195:55
[INFO] [stdout]      |
[INFO] [stdout] 1195 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1195 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 1195 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1195 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 1195 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:1204:55
[INFO] [stdout]      |
[INFO] [stdout] 1204 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1204 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 1204 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1204 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 1204 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:1211:55
[INFO] [stdout]      |
[INFO] [stdout] 1211 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1211 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 1211 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1211 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 1211 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:1220:55
[INFO] [stdout]      |
[INFO] [stdout] 1220 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1220 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 1220 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1220 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 1220 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaStreamHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:1976:61
[INFO] [stdout]      |
[INFO] [stdout] 1976 |         let real: crate::util::logging::JavaStreamHandler = temp_clone.into();
[INFO] [stdout]      |                                                             ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1976 -         let real: crate::util::logging::JavaStreamHandler = temp_clone.into();
[INFO] [stdout] 1976 +         let real: crate::util::logging::JavaStreamHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1976 -         let real: crate::util::logging::JavaStreamHandler = temp_clone.into();
[INFO] [stdout] 1976 +         let real: crate::util::logging::JavaStreamHandler = <JavaStreamHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaStreamHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:1983:61
[INFO] [stdout]      |
[INFO] [stdout] 1983 |         let real: crate::util::logging::JavaStreamHandler = temp_clone.into();
[INFO] [stdout]      |                                                             ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1983 -         let real: crate::util::logging::JavaStreamHandler = temp_clone.into();
[INFO] [stdout] 1983 +         let real: crate::util::logging::JavaStreamHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1983 -         let real: crate::util::logging::JavaStreamHandler = temp_clone.into();
[INFO] [stdout] 1983 +         let real: crate::util::logging::JavaStreamHandler = <JavaStreamHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaStreamHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:1990:61
[INFO] [stdout]      |
[INFO] [stdout] 1990 |         let real: crate::util::logging::JavaStreamHandler = temp_clone.into();
[INFO] [stdout]      |                                                             ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1990 -         let real: crate::util::logging::JavaStreamHandler = temp_clone.into();
[INFO] [stdout] 1990 +         let real: crate::util::logging::JavaStreamHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1990 -         let real: crate::util::logging::JavaStreamHandler = temp_clone.into();
[INFO] [stdout] 1990 +         let real: crate::util::logging::JavaStreamHandler = <JavaStreamHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:2001:55
[INFO] [stdout]      |
[INFO] [stdout] 2001 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2001 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2001 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2001 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2001 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:2011:55
[INFO] [stdout]      |
[INFO] [stdout] 2011 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2011 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2011 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2011 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2011 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:2020:55
[INFO] [stdout]      |
[INFO] [stdout] 2020 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2020 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2020 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2020 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2020 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:2030:55
[INFO] [stdout]      |
[INFO] [stdout] 2030 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2030 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2030 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2030 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2030 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:2039:55
[INFO] [stdout]      |
[INFO] [stdout] 2039 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2039 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2039 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2039 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2039 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:2049:55
[INFO] [stdout]      |
[INFO] [stdout] 2049 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2049 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2049 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2049 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2049 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:2058:55
[INFO] [stdout]      |
[INFO] [stdout] 2058 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2058 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2058 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2058 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2058 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:2065:55
[INFO] [stdout]      |
[INFO] [stdout] 2065 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2065 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2065 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2065 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2065 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:2074:55
[INFO] [stdout]      |
[INFO] [stdout] 2074 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2074 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2074 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2074 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2074 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:2824:55
[INFO] [stdout]      |
[INFO] [stdout] 2824 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2824 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2824 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2824 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2824 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:2834:55
[INFO] [stdout]      |
[INFO] [stdout] 2834 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2834 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2834 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2834 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2834 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:2843:55
[INFO] [stdout]      |
[INFO] [stdout] 2843 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2843 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2843 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2843 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2843 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:2853:55
[INFO] [stdout]      |
[INFO] [stdout] 2853 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2853 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2853 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2853 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2853 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:2862:55
[INFO] [stdout]      |
[INFO] [stdout] 2862 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2862 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2862 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2862 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2862 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:2872:55
[INFO] [stdout]      |
[INFO] [stdout] 2872 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2872 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2872 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2872 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2872 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:2881:55
[INFO] [stdout]      |
[INFO] [stdout] 2881 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2881 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2881 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2881 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2881 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:2888:55
[INFO] [stdout]      |
[INFO] [stdout] 2888 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2888 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2888 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2888 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2888 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaHandler<'_>`
[INFO] [stdout]     --> src/util/logging/mod.rs:2897:55
[INFO] [stdout]      |
[INFO] [stdout] 2897 |         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2897 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2897 +         let real: crate::util::logging::JavaHandler = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2897 -         let real: crate::util::logging::JavaHandler = temp_clone.into();
[INFO] [stdout] 2897 +         let real: crate::util::logging::JavaHandler = <JavaHandler<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `JavaRandomGeneratorJumpableGenerator<'_>`
[INFO] [stdout]     --> src/util/random/mod.rs:1028:79
[INFO] [stdout]      |
[INFO] [stdout] 1028 |         let real: crate::util::random::JavaRandomGeneratorJumpableGenerator = temp_clone.into();
[INFO] [stdout]      |                                                                               ^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1028 -         let real: crate::util::random::JavaRandomGeneratorJumpableGenerator = temp_clone.into();
[INFO] [stdout] 1028 +         let real: crate::util::random::JavaRandomGeneratorJumpableGenerator = temp_clone;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1028 -         let real: crate::util::random::JavaRandomGeneratorJumpableGenerator = temp_clone.into();
[INFO] [stdout] 1028 +         let real: crate::util::random::JavaRandomGeneratorJumpableGenerator = <JavaRandomGeneratorJumpableGenerator<'_> as Into<_>>::into(temp_clone);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `blackboxmc_java` (lib) due to 91 previous errors; 22 warnings emitted
[INFO] running `Command { std: "docker" "inspect" "c75a8b3e9ed6350b36e978ca937147addcc83a15bd6a1d34be72ff033d12c19c", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "c75a8b3e9ed6350b36e978ca937147addcc83a15bd6a1d34be72ff033d12c19c", kill_on_drop: false }`
[INFO] [stdout] c75a8b3e9ed6350b36e978ca937147addcc83a15bd6a1d34be72ff033d12c19c
